newrelic_rpm 8.2.0 → 9.0.0

data/lib/new_relic/agent/instrumentation/resque/helper.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -16,4 +16,4 @@ module NewRelic
       end
     end
   end
-end
+end

data/lib/new_relic/agent/instrumentation/resque/instrumentation.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
@@ -12,12 +11,13 @@ module NewRelic::Agent::Instrumentation
         perform_action_with_newrelic_trace(
           :name => 'perform',
           :class_name => self.payload_class,
-          :category => 'OtherTransaction/ResqueJob') do
-
+          :category => 'OtherTransaction/ResqueJob'
+        ) do
           NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
             args,
             :'job.resque.args',
-            NewRelic::Agent::AttributeFilter::DST_NONE)
+            NewRelic::Agent::AttributeFilter::DST_NONE
+          )
 
           yield
         end
@@ -30,6 +30,5 @@ module NewRelic::Agent::Instrumentation
         end
       end
     end
-
   end
 end

data/lib/new_relic/agent/instrumentation/resque/prepend.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
-
+# frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
   module Resque
-    module Prepend 
+    module Prepend
       include NewRelic::Agent::Instrumentation::Resque
 
       def perform

data/lib/new_relic/agent/instrumentation/resque.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require_relative 'resque/instrumentation'
 require_relative 'resque/chain'
@@ -10,21 +10,21 @@ DependencyDetection.defer do
   @name = :resque
 
   depends_on do
-    defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]
+    defined?(Resque::Job)
   end
 
   # Airbrake uses method chaining on Resque::Job on versions < 11.0.3
   conflicts_with_prepend do
-    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('11.0.3')
+    defined?(Airbrake) && defined?(Airbrake::AIRBRAKE_VERSION) && Gem::Version.create(Airbrake::AIRBRAKE_VERSION) < Gem::Version.create('11.0.3')
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
+    NewRelic::Agent.logger.info('Installing Resque instrumentation')
   end
 
   executes do
     if NewRelic::Agent.config[:'resque.use_ruby_dns'] && NewRelic::Agent.config[:dispatcher] == :resque
-      ::NewRelic::Agent.logger.info 'Requiring resolv-replace'
+      NewRelic::Agent.logger.info('Requiring resolv-replace')
       require 'resolv'
       require 'resolv-replace'
     end
@@ -32,33 +32,33 @@ DependencyDetection.defer do
 
   executes do
     if use_prepend?
-      prepend_instrument ::Resque::Job, NewRelic::Agent::Instrumentation::Resque::Prepend
+      prepend_instrument Resque::Job, NewRelic::Agent::Instrumentation::Resque::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Resque::Chain
     end
 
     if NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job?
-      ::Resque.before_first_fork do
-        NewRelic::Agent.manual_start(:dispatcher   => :resque,
-                                     :sync_startup => true,
-                                     :start_channel_listener => true)
+      Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher => :resque,
+          :sync_startup => true,
+          :start_channel_listener => true)
       end
 
-      ::Resque.before_fork do |job|
+      Resque.before_fork do |job|
         NewRelic::Agent.register_report_channel(job.object_id)
       end
 
-      ::Resque.after_fork do |job|
+      Resque.after_fork do |job|
         # Only suppress reporting Instance/Busy for forked children
         # Traced errors UI relies on having the parent process report that metric
         NewRelic::Agent.after_fork(:report_to_channel => job.object_id,
-                                   :report_instance_busy => false)
+          :report_instance_busy => false)
       end
     else
-      ::Resque.before_first_fork do
-        NewRelic::Agent.manual_start(:dispatcher   => :resque,
-                                     :sync_startup => true,
-                                     :start_channel_listener => false)
+      Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher => :resque,
+          :sync_startup => true,
+          :start_channel_listener => false)
       end
     end
   end

data/lib/new_relic/agent/instrumentation/sequel.rb

@@ -1,50 +1,47 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 DependencyDetection.defer do
   @name = :sequel
 
   depends_on do
-    defined?(::Sequel)
+    defined?(Sequel)
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_sequel_instrumentation] &&
-    !NewRelic::Agent.config[:disable_database_instrumentation]
+    !NewRelic::Agent.config[:disable_sequel_instrumentation]
   end
 
   def supported_sequel_version?
-    Sequel.const_defined?( :MAJOR ) &&
-      ( Sequel::MAJOR > 3 ||
-        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
+    Sequel.const_defined?(:MAJOR) &&
+      (Sequel::MAJOR > 3 ||
+        Sequel::MAJOR == 3 && Sequel::MINOR >= 37)
   end
 
   executes do
     if supported_sequel_version?
 
-      ::NewRelic::Agent.logger.info 'Installing Sequel instrumentation'
+      NewRelic::Agent.logger.info('Installing Sequel instrumentation')
 
-      if Sequel::Database.respond_to?( :extension )
-        Sequel::Database.extension :newrelic_instrumentation
+      if Sequel::Database.respond_to?(:extension)
+        Sequel::Database.extension(:new_relic_instrumentation)
       else
-        NewRelic::Agent.logger.info "Detected Sequel version %s." % [ Sequel::VERSION ]
-        NewRelic::Agent.logger.info "Please see additional documentation: " +
-          "https://newrelic.com/docs/ruby/sequel-instrumentation"
+        NewRelic::Agent.logger.info("Detected Sequel version %s." % [Sequel::VERSION])
+        NewRelic::Agent.logger.info("Please see additional documentation: " +
+          "https://newrelic.com/docs/ruby/sequel-instrumentation")
       end
 
-      Sequel.synchronize{Sequel::DATABASES.dup}.each do |db|
-        db.extension :newrelic_instrumentation
+      Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|
+        db.extension(:new_relic_instrumentation)
       end
 
-      Sequel::Model.plugin(:newrelic_instrumentation) if defined?(Sequel::Model)
+      Sequel::Model.plugin(:new_relic_instrumentation) if defined?(Sequel::Model)
     else
 
-      NewRelic::Agent.logger.info "Sequel instrumentation requires at least version 3.37.0."
+      NewRelic::Agent.logger.info("Sequel instrumentation requires at least version 3.37.0.")
 
     end
-
   end
-
 end

data/lib/new_relic/agent/instrumentation/sequel_helper.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -33,4 +33,4 @@ module NewRelic
       end
     end
   end
-end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/client.rb

@@ -0,0 +1,20 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Sidekiq
+  class Client
+    include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+    def call(_worker_class, job, *_)
+      job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+      yield
+    end
+
+    def distributed_tracing_headers
+      headers = {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+      headers
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/extensions/delayed_class.rb

@@ -0,0 +1,30 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# TODO: remove this class once Sidekiq v6 is no longer supported.
+#       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
+#       were removed entirely in Sidekiq 7.
+#
+#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       of the removal, which includes mentions of alternatives
+if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
+  class Sidekiq::Extensions::DelayedClass
+    def newrelic_trace_args(msg, queue)
+      (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
+        YAML.unsafe_load(msg['args'][0])
+      else
+        YAML.load(msg['args'][0])
+      end
+
+      {
+        :name => method_name,
+        :class_name => target.name,
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    rescue => e
+      NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+      NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/server.rb

@@ -0,0 +1,37 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Sidekiq
+  class Server
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+    # Client middleware has additional parameters, and our tests use the
+    # middleware client-side to work inline.
+    def call(worker, msg, queue, *_)
+      trace_args = if worker.respond_to?(:newrelic_trace_args)
+        worker.newrelic_trace_args(msg, queue)
+      else
+        self.class.default_trace_args(msg)
+      end
+      trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
+
+      perform_action_with_newrelic_trace(trace_args) do
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
+          NewRelic::Agent::AttributeFilter::DST_NONE)
+
+        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+        yield
+      end
+    end
+
+    def self.default_trace_args(msg)
+      {
+        :name => 'perform',
+        :class_name => msg['class'],
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq.rb

@@ -1,101 +1,55 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+require_relative 'sidekiq/client'
+require_relative 'sidekiq/server'
+require_relative 'sidekiq/extensions/delayed_class'
 
 DependencyDetection.defer do
   @name = :sidekiq
 
   depends_on do
-    defined?(::Sidekiq) && !NewRelic::Agent.config[:disable_sidekiq]
+    defined?(Sidekiq) && !NewRelic::Agent.config[:disable_sidekiq]
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Sidekiq instrumentation'
+    NewRelic::Agent.logger.info('Installing Sidekiq instrumentation')
   end
 
   executes do
-    module NewRelic::SidekiqInstrumentation
-      class Server
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-        # Client middleware has additional parameters, and our tests use the
-        # middleware client-side to work inline.
-        def call(worker, msg, queue, *_)
-          trace_args = if worker.respond_to?(:newrelic_trace_args)
-            worker.newrelic_trace_args(msg, queue)
-          else
-            self.class.default_trace_args(msg)
-          end
-          trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
-
-          perform_action_with_newrelic_trace(trace_args) do
-            NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-              NewRelic::Agent::AttributeFilter::DST_NONE)
-
-            ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
-            yield
-          end
-        end
-
-        def self.default_trace_args(msg)
-          {
-            :name => 'perform',
-            :class_name => msg['class'],
-            :category => 'OtherTransaction/SidekiqJob'
-          }
-        end
-      end
-      class Client
-        def call(_worker_class, job, *_)
-          job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
-          yield
-        end
-
-        def distributed_tracing_headers
-          headers = {}
-          ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
-          headers
-        end
-      end
-    end
-
-    class Sidekiq::Extensions::DelayedClass
-      def newrelic_trace_args(msg, queue)
-        (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
-                                         YAML.unsafe_load(msg['args'][0])
-                                       else 
-                                         YAML.load(msg['args'][0])
-                                       end
-
-        {
-          :name => method_name,
-          :class_name => target.name,
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      rescue => e
-        NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
-        NewRelic::SidekiqInstrumentation::Server.default_trace_args(msg)
-      end
-    end
-
     Sidekiq.configure_client do |config|
       config.client_middleware do |chain|
-        chain.add NewRelic::SidekiqInstrumentation::Client
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
     end
 
     Sidekiq.configure_server do |config|
       config.client_middleware do |chain|
-        chain.add NewRelic::SidekiqInstrumentation::Client
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
       config.server_middleware do |chain|
-        chain.add NewRelic::SidekiqInstrumentation::Server
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
       end
 
       if config.respond_to?(:error_handlers)
-        config.error_handlers << Proc.new do |error, *_|
+        config.error_handlers << proc do |error, *_|
           NewRelic::Agent.notice_error(error)
         end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Sidekiq version to continue receiving full support. '
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sidekiq_version,
+      deprecation_msg
+    )
+  end
 end

data/lib/new_relic/agent/instrumentation/sinatra/chain.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
   module Sinatra

data/lib/new_relic/agent/instrumentation/sinatra/ignorer.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
   module Sinatra
     module Ignorer
-
       def self.should_ignore?(app, type)
         return false if !app.settings.respond_to?(:newrelic_ignores)
 
@@ -31,7 +30,7 @@ module NewRelic::Agent::Instrumentation
       def set_newrelic_ignore(type, *routes)
         # Important to default this in the context of the actual app
         # If it's done at register time, ignores end up shared between apps.
-        set :newrelic_ignores, Hash.new([]) if !respond_to?(:newrelic_ignores)
+        set(:newrelic_ignores, Hash.new([])) if !respond_to?(:newrelic_ignores)
 
         # If we call an ignore without a route, it applies to the whole app
         routes = ["*"] if routes.empty?

data/lib/new_relic/agent/instrumentation/sinatra/instrumentation.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # NewRelic instrumentation for Sinatra applications.  Sinatra actions will
 # appear in the UI similar to controller actions, and have breakdown charts
@@ -70,7 +70,8 @@ module NewRelic::Agent::Instrumentation
         begin
           if txn_name = TransactionNamer.transaction_name_for_route(env, request)
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
-              "#{self.class.name}/#{txn_name}", :sinatra)
+              "#{self.class.name}/#{txn_name}", :sinatra
+            )
           end
         rescue => e
           ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
@@ -93,8 +94,8 @@ module NewRelic::Agent::Instrumentation
 
         name = TransactionNamer.initial_transaction_name(request)
         perform_action_with_newrelic_trace(:category => :sinatra,
-                                          :name => name,
-                                          :params => filtered_params) do
+          :name => name,
+          :params => filtered_params) do
           begin
             yield
           ensure

data/lib/new_relic/agent/instrumentation/sinatra/prepend.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
   module Sinatra

data/lib/new_relic/agent/instrumentation/sinatra/transaction_namer.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -12,7 +12,7 @@ module NewRelic
           SINATRA_ROUTE = 'sinatra.route'
 
           def transaction_name_for_route(env, request)
-            if env.key? SINATRA_ROUTE
+            if env.key?(SINATRA_ROUTE)
               env[SINATRA_ROUTE]
             else
               name = route_for_sinatra(env)

data/lib/new_relic/agent/instrumentation/sinatra.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require_relative 'sinatra/transaction_namer'
 require_relative 'sinatra/ignorer'
@@ -11,39 +11,48 @@ require_relative 'sinatra/prepend'
 DependencyDetection.defer do
   named :sinatra
 
-  depends_on { defined?(::Sinatra) && defined?(::Sinatra::Base) }
+  depends_on { defined?(Sinatra) && defined?(Sinatra::Base) }
   depends_on { Sinatra::Base.private_method_defined?(:dispatch!) }
   depends_on { Sinatra::Base.private_method_defined?(:process_route) }
   depends_on { Sinatra::Base.private_method_defined?(:route_eval) }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Sinatra instrumentation'
+    NewRelic::Agent.logger.info('Installing Sinatra instrumentation')
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Sinatra::Base, NewRelic::Agent::Instrumentation::Sinatra::Prepend
+      prepend_instrument Sinatra::Base, NewRelic::Agent::Instrumentation::Sinatra::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Chain
     end
 
-    ::Sinatra::Base.class_eval { register ::NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
-    ::Sinatra.module_eval { register NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
+    Sinatra::Base.class_eval { register NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
+    Sinatra.module_eval { register NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
   end
 
   executes do
-    if Sinatra::Base.respond_to?(:build)
-      # These requires are inside an executes block because they require rack, and
-      # we can't be sure that rack is available when this file is first required.
-      require 'new_relic/rack/agent_hooks'
-      require 'new_relic/rack/browser_monitoring'
-      if use_prepend?
-        prepend_instrument ::Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
-      else
-        chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
-      end
+    # These requires are inside an executes block because they require rack, and
+    # we can't be sure that rack is available when this file is first required.
+    require 'new_relic/rack/agent_hooks'
+    require 'new_relic/rack/browser_monitoring'
+    if use_prepend?
+      prepend_instrument Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
     else
-      ::NewRelic::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
+
+    deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
+      'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sinatra_version,
+      deprecation_msg
+    )
+  end
 end

data/lib/new_relic/agent/instrumentation/thread/chain.rb

@@ -0,0 +1,24 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module MonitoredThread
+    module Chain
+      def self.instrument!
+        ::Thread.class_eval do
+          include NewRelic::Agent::Instrumentation::MonitoredThread
+
+          alias_method(:initialize_without_new_relic, :initialize)
+
+          def initialize(*args, &block)
+            traced_block = add_thread_tracing(*args, &block)
+            initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/thread/instrumentation.rb

@@ -0,0 +1,28 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module MonitoredThread
+        attr_reader :nr_parent_key
+
+        def initialize_with_newrelic_tracing
+          @nr_parent_key = NewRelic::Agent::Tracer.current_segment_key
+          yield
+        end
+
+        def add_thread_tracing(*args, &block)
+          return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
+
+          NewRelic::Agent::Tracer.thread_block_with_current_transaction(
+            *args,
+            segment_name: 'Ruby/Thread',
+            &block
+          )
+        end
+      end
+    end
+  end
+end