Test: container publish

.github/workflows/ruby.yml

@@ -56,7 +56,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: check-modified-files
     # run only if files were modified, the workflow was manually invoked, or doing a release
-    if: needs.check-modified-files.outputs.files-changed == 'true' || github.event_name == 'workflow_dispatch' || github.event_name == 'release' && endsWith(github.ref, '_ruby')
+    if: needs.check-modified-files.outputs.files-changed == 'true' || github.event_name == 'workflow_dispatch' || (github.event_name == 'release' && endsWith(github.ref, '_ruby'))
 
     steps:
       - name: Checkout code
@@ -144,7 +144,9 @@ jobs:
         uses: docker/login-action@e92390c5fb421da1463c202d546fed0ec5c39f20 # 3.1.0
         with:
           username: ${{ github.repository_owner }}
+          # username: ${{ secrets.RUBY_AGENT_TEST_USERNAME }}
           password: ${{ secrets.DOCKER_TOKEN }}
+          # password: ${{ secrets.RUBY_AGENT_TEST_DOCKER_TOKEN }}
 
       - name: Build and publish init container image
         uses: docker/build-push-action@2cdde995de11925a030ce8070c3d77a52ffcf1c0 # 5.3.0

src/ruby/Dockerfile

@@ -6,6 +6,8 @@
 FROM ruby:latest AS build
 WORKDIR /operator-build
 
+ARG AGENT_VERSION
+
 # Install gems from Gemfile into the `workspace` directory
 ADD Gemfile .
 RUN BUNDLE_PATH=workspace bundle install
@@ -21,7 +23,7 @@ WORKDIR /operator-build
 # Copy the result into a new directory called `/instrumentation`.
 RUN sh -c "find 'workspace/ruby/' -type d -name newrelic_rpm\\* -exec cp -r '{}' /instrumentation \\;"
 
-# Adjust permissions of `instrumentation` director to readable by everyone
+# Adjust permissions of `instrumentation` directory to readable by everyone
 RUN chmod -R go+r /instrumentation
 
 # Clean up build artifacts

src/ruby/Gemfile

@@ -2,4 +2,4 @@
 
 source 'https://rubygems.org'
 
-gem 'newrelic_rpm'
+gem *['newrelic_rpm', ENV.fetch('AGENT_VERSION', nil)].compact

tests/ruby/.dockerignore

@@ -0,0 +1,31 @@
+# See https://docs.docker.com/engine/reference/builder/#dockerignore-file for more about ignoring files.
+
+# Ignore git directory.
+/.git/
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files (except templates).
+/.env*
+!/.env*.erb
+
+# Ignore all default key files.
+/config/master.key
+/config/credentials/*.key
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/.keep
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/.keep

tests/ruby/Dockerfile

@@ -8,9 +8,73 @@ RUN bundle install
 
 COPY . .
 
-EXPOSE 4567
+EXPOSE 3000
 
-#Ensure executable permissions
+# Ensure executable permissions
 RUN chmod +x start.sh
 
 CMD ["./start.sh"]
+
+
+
+
+
+
+
+
+
+# # syntax = docker/dockerfile:1
+
+# # Make sure RUBY_VERSION matches the Ruby version in .ruby-version and Gemfile
+# ARG RUBY_VERSION=3.2.2
+# FROM registry.docker.com/library/ruby:$RUBY_VERSION-slim as base
+
+# # Rails app lives here
+# WORKDIR /rails
+
+# # Set production environment
+# ENV RAILS_ENV="production" \
+#     BUNDLE_DEPLOYMENT="1" \
+#     BUNDLE_PATH="/usr/local/bundle" \
+#     BUNDLE_WITHOUT="development"
+
+
+# # Throw-away build stage to reduce size of final image
+# FROM base as build
+
+# # Install packages needed to build gems
+# RUN apt-get update -qq && \
+#     apt-get install --no-install-recommends -y build-essential git pkg-config
+
+# # Install application gems
+# COPY Gemfile Gemfile.lock ./
+# RUN bundle install && \
+#     rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git
+
+# # Copy application code
+# COPY . .
+
+
+# # Final stage for app image
+# FROM base
+
+# # Install packages needed for deployment
+# RUN apt-get update -qq && \
+#     apt-get install --no-install-recommends -y curl && \
+#     rm -rf /var/lib/apt/lists /var/cache/apt/archives
+
+# # Copy built artifacts: gems, application
+# COPY --from=build /usr/local/bundle /usr/local/bundle
+# COPY --from=build /rails /rails
+
+# # Run and own only the runtime files as a non-root user for security
+# RUN useradd rails --create-home --shell /bin/bash && \
+#     chown -R rails:rails log tmp
+# USER rails:rails
+
+# # Entrypoint prepares the database.
+# ENTRYPOINT ["/rails/bin/docker-entrypoint"]
+
+# # Start the server by default, this can be overwritten at runtime
+# EXPOSE 3000
+# CMD ["./bin/rails", "server"]

tests/ruby/Gemfile

@@ -1,8 +1,10 @@
-# frozen_string_literal: true
+source "https://rubygems.org"
 
-source 'https://rubygems.org'
+# Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
+gem "rails", "~> 7.1.3", ">= 7.1.3.4"
 
-gem 'sinatra'
-gem 'newrelic_rpm'
+# Use the Puma web server [https://github.com/puma/puma]
+gem "puma", ">= 5.0"
 
-gem "rackup", "~> 2.1"
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem "tzinfo-data", platforms: %i[ windows jruby ]

tests/ruby/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::API
+  def hello
+    render plain: "Hello, World!"
+  end
+end

tests/ruby/bin/bundle

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+  module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a.match?(Gem::Version::ANCHORED_VERSION_PATTERN)
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../Gemfile", __dir__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, ".locked")
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_requirement
+    @bundler_requirement ||=
+      env_var_version ||
+      cli_arg_version ||
+      bundler_requirement_for(lockfile_version)
+  end
+
+  def bundler_requirement_for(version)
+    return "#{Gem::Requirement.default}.a" unless version
+
+    bundler_gem_version = Gem::Version.new(version)
+
+    bundler_gem_version.approximate_recommendation
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    activate_bundler
+  end
+
+  def activate_bundler
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_requirement
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

tests/ruby/bin/docker-entrypoint

@@ -0,0 +1,3 @@
+#!/bin/bash -e
+
+exec "${@}"

tests/ruby/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

tests/ruby/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

tests/ruby/bin/setup

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args, exception: true)
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end