Support deployment mode

.github/workflows/test.yml

@@ -112,6 +112,7 @@ jobs:
       - name: Set up Docker with containerd
         uses: docker/setup-docker-action@b60f85385d03ac8acfca6d9996982511d8620a19 # v4.3.0
         with:
+          version: v28.5.1
           daemon-config: |
             {
               "features": {
@@ -122,6 +123,7 @@ jobs:
         run: ruby test/bin/test.rb --filter engine:${{ matrix.ruby.engine }} --filter version:${{ matrix.ruby.version }}
         env:
           DOCKER_BUILDKIT: 1
+          DD_INTERNAL_RUBY_INJECTOR_LOG_LEVEL: DEBUG
 
   complete:
     name: Test (complete)

.gitignore

@@ -3,9 +3,11 @@
 /Gemfile.lock
 
 # transient files
-/test/tmp/
-/test/packages/
 /tmp/
+/test/tmp/
+/test/packages/*/*/*/
+!/test/packages/*/*/*/Gemfile
+!/test/packages/*/*/*/Gemfile.lock
 
 # tooling
 /.ruby-lsp/

src/mod/bundler.rb

@@ -6,6 +6,7 @@ def status
 
     {
       :rubygems          => Gem::VERSION,
+      :gem_path          => Gem.path,
       :version           => Bundler::VERSION,
       :simulate_version  => Bundler.settings[:simulate_version],
       :gemfile           => (Bundler.default_gemfile rescue nil),
@@ -21,6 +22,8 @@ def status
       :install_path      => (Bundler.install_path rescue nil),
       :app_config_path   => (Bundler.app_config_path rescue nil),
       :settings => {
+        :gem_home        => ENV['GEM_HOME'],
+        :gem_path        => ENV['GEM_PATH'],
         :gemfile         => Bundler.settings[:gemfile],
         :deployment      => Bundler.settings[:deployment],
         :frozen          => Bundler.settings[:frozen],
@@ -30,6 +33,37 @@ def status
     }
   end
 
+  def patch!
+    require!
+
+    mod = Module.new do
+      def [](name)
+
+        if name == :deployment
+          return false
+        end
+
+        super
+      end
+    end
+
+    ::Bundler::Settings.prepend mod
+
+    require 'bundler/cli'
+    require 'bundler/cli/exec'
+
+    mod = Module.new do
+      def kernel_exec(*args)
+        ENV['RUBYOPT'] = ENV['RUBYOPT'].gsub(%r{^(.*)(?:\s+|^)(-r(\s*)\S+/injector\.rb)(.*)$}, '\2 \1 \3')
+        ENV.delete('BUNDLER_SETUP')
+
+        super
+      end
+    end
+
+    ::Bundler::CLI::Exec.prepend mod
+  end
+
   private
 
   def require!

src/mod/context.rb

@@ -43,7 +43,7 @@ def primitive(val)
   private :primitive
 
   def status
-    {
+    @status ||= {
       :ruby => {
         :version => RUBY.version,
         :api_version => RUBY.api_version,

src/mod/guard.rb

@@ -48,16 +48,12 @@ def call(status)
       result << { :name => 'bundler.locked', :reason => 'bundler.unlocked' }
     end
 
-    if !status[:fs][:writable]
-      result << { :name => 'fs.writable', :reason => 'fs.readonly' }
-    end
-
-    if status[:bundler][:deployment]
-      result << { :name => 'bundler.deployment', :reason => 'bundler.deployment' }
+    if status[:bundler][:settings][:path]
+      result << { :name => 'bundler.path', :reason => 'bundler.vendored' }
     end
 
-    if !status[:bundler][:use_system_gems]
-      result << { :name => 'bundler.use_system_gems', :reason => 'bundler.vendored' }
+    if !status[:fs][:writable]
+      result << { :name => 'fs.writable', :reason => 'fs.readonly' }
     end
 
     result unless result.empty?

src/mod/injector.rb

@@ -59,15 +59,15 @@ def inject(gemfile_path, lockfile_path)
 end
 
 class << self
-  def call
-    LOG.info { 'injector:call' }
+  def call(context)
+    LOG.info { "injector:call context:#{context}" }
 
     # TODO: check if nested injection (maybe very early too)
     # TODO: check if injection already performed
 
     # TODO: extract to a package module
     package_basepath = ENV['DD_INTERNAL_RUBY_INJECTOR_BASEPATH'] || File.expand_path(File.join(File.dirname(__FILE__), '..'))
-    package_gem_home = ENV['DD_INTERNAL_RUBY_INJECTOR_GEM_HOME'] || File.join(package_basepath, RUBY.api_version)
+    package_gem_home = ENV['DD_INTERNAL_RUBY_INJECTOR_GEM_HOME'] || File.join(package_basepath, 'ruby', RUBY.api_version)
     package_lockfile = ENV['DD_INTERNAL_RUBY_INJECTOR_LOCKFILE'] || File.join(package_gem_home, 'Gemfile.lock')
 
     # TODO: capture stdout+stderr
@@ -76,13 +76,12 @@ def call
 
       BUNDLER.send(:require!)
 
-      # TODO: these are in context
       # pinpoint app gemfile and lockfile
-      app_gemfile  = Bundler.default_gemfile
-      app_lockfile = Bundler.default_lockfile
+      app_gemfile  = context[:bundler][:gemfile]
+      app_lockfile = context[:bundler][:lockfile]
 
       # determine output paths
-      out = File.join(app_gemfile.dirname)
+      out = File.dirname(app_gemfile)
 
       # TODO: this should work, unless the app's Gemfile has relative references...
       # if File.writable?(File.join(out, 'tmp'))
@@ -118,12 +117,27 @@ def call
 
     ENV['DD_INTERNAL_RUBY_INJECTOR'] = 'false'
 
-    return [nil, err] if err
+    if err
+      LOG.debug { "error: #{err}"}
+      return [nil, err]
+    end
 
     return [false, nil] unless gemfile
 
-    Gem.paths = { 'GEM_PATH' => "#{package_gem_home}:#{ENV['GEM_PATH']}" }
-    ENV['GEM_PATH'] = Gem.path.join(File::PATH_SEPARATOR)
+    if context[:bundler][:deployment]
+      app_bundle_path = context[:bundler][:bundle_path]
+
+      ENV['DD_INTERNAL_RUBY_INJECTOR_PATCH'] = "mode=deployment,path=#{package_gem_home}:#{app_bundle_path}"
+      Gem.paths = { 'GEM_PATH' => "#{package_gem_home}:#{app_bundle_path}" }
+      ENV['GEM_PATH'] = Gem.path.join(File::PATH_SEPARATOR)
+      ENV['GEM_HOME'] = app_bundle_path
+
+      BUNDLER.patch!
+    else
+      Gem.paths = { 'GEM_PATH' => "#{package_gem_home}:#{ENV['GEM_PATH']}" }
+      ENV['GEM_PATH'] = Gem.path.join(File::PATH_SEPARATOR)
+    end
+
     ENV['BUNDLE_GEMFILE'] = gemfile
 
     [true, nil]

src/mod/log.rb

@@ -26,7 +26,14 @@ def progname
   end
 
   def level
-    UNKNOWN
+    @level ||= case ENV['DD_INTERNAL_RUBY_INJECTOR_LOG_LEVEL']
+               when 'DEBUG', 0 then DEBUG
+               when 'INFO',  1 then INFO
+               when 'WARN',  2 then WARN
+               when 'ERROR', 3 then ERROR
+               when 'FATAL', 4 then FATAL
+               else UNKNOWN
+               end
   end
 
   def add(severity, message = nil, progname = nil)

src/mod/main.rb

@@ -40,17 +40,27 @@
   injector = import 'injector'
 
   if ENV['DD_INTERNAL_RUBY_INJECTOR'] == 'false'
-    log.info { 'inject:skip' }
+    if ENV['DD_INTERNAL_RUBY_INJECTOR_PATCH']
+      log.info { 'inject:patch' }
+
+      bundler = import 'bundler'
+
+      bundler.patch!
+    else
+      log.info { 'inject:skip' }
+    end
 
     telemetry.emit([
       { :name => 'library_entrypoint.complete', :tags => ["reason:internal.skip"] },
     ], { :result => report.cached })
   else
     begin
       # TODO: pass args, e.g context, location, etc...
-      injected, err = injector.call
+      injected, err = injector.call(context.status)
 
       if err
+        log.info { "inject:error err:#{err.inspect}" }
+
         telemetry.emit([
           { :name => 'library_entrypoint.error', :tags => ["reason:#{err}"] },
         ], { :result => report.errored(err) })
@@ -62,7 +72,7 @@
         ], { :result => report.completed(injected) })
       end
     rescue StandardError => e
-      log.info { 'inject:error' }
+      log.info { "inject:fatal exc:#{e.class.name},#{e.message.inspect},#{e.backtrace.first.inspect}" }
 
       telemetry.emit([
         { :name => 'library_entrypoint.error', :tags => ["reason:exc.fatal"] },

src/mod/ruby.rb

@@ -21,9 +21,7 @@ def self.platform
 end
 
 def self.api_version
-  # TODO: handle '+0' suffix appearing in preview versions
+  require 'rbconfig' unless defined?(RbConfig)
 
-  major, minor, = RUBY_VERSION.split('.')
-
-  "#{major}.#{minor}.0"
+  RbConfig::CONFIG['ruby_version']
 end

src/mod/telemetry.rb

@@ -47,7 +47,9 @@ def emit(*args)
 
     rd, wr = IO.pipe
 
+    opt = ENV.delete('RUBYOPT')
     pid = PROCESS.spawn(forwarder, 'library_entrypoint', { :in => rd, [:out, :err] => '/dev/null' })
+    ENV['RUBYOPT'] = opt if opt
 
     wr.write(payload(pid, version, result, points))
     wr.flush