newrelic_rpm 7.0.0 → 8.8.0

data/lib/new_relic/environment_report.rb

@@ -13,7 +13,6 @@ module NewRelic
   # Additional logic can be registered by using the EnvironmentReport.report_on
   # hook.
   class EnvironmentReport
-
     # This is the main interface for registering logic that should be included
     # in the Environment Report. For example:
     #
@@ -57,23 +56,23 @@ module NewRelic
         end
       end
     end
-    report_on('Plugin List'       ) { ::Rails.configuration.plugins.to_a }
-    report_on('Ruby version'      ) { RUBY_VERSION                       }
-    report_on('Ruby description'  ) { RUBY_DESCRIPTION                   }
-    report_on('Ruby platform'     ) { RUBY_PLATFORM                      }
-    report_on('Ruby patchlevel'   ) { RUBY_PATCHLEVEL.to_s               }
-    report_on('JRuby version'     ) { JRUBY_VERSION                      }
-    report_on('Java VM version'   ) { ENV_JAVA['java.vm.version']        }
+    report_on('Plugin List') { ::Rails.configuration.plugins.to_a }
+    report_on('Ruby version') { RUBY_VERSION }
+    report_on('Ruby description') { RUBY_DESCRIPTION }
+    report_on('Ruby platform') { RUBY_PLATFORM }
+    report_on('Ruby patchlevel') { RUBY_PATCHLEVEL.to_s }
+    report_on('JRuby version') { JRUBY_VERSION }
+    report_on('Java VM version') { ENV_JAVA['java.vm.version'] }
     report_on('Logical Processors') { ::NewRelic::Agent::SystemInfo.num_logical_processors }
-    report_on('Physical Cores'    ) { ::NewRelic::Agent::SystemInfo.num_physical_cores     }
-    report_on('Arch'              ) { ::NewRelic::Agent::SystemInfo.processor_arch         }
-    report_on('OS version'        ) { ::NewRelic::Agent::SystemInfo.os_version             }
-    report_on('OS'                ) { ::NewRelic::Agent::SystemInfo.ruby_os_identifier     }
-    report_on('Database adapter'  ) { ::NewRelic::Agent::DatabaseAdapter.value }
-    report_on('Framework'       ) { Agent.config[:framework].to_s  }
-    report_on('Dispatcher'      ) { Agent.config[:dispatcher].to_s }
-    report_on('Environment'     ) { NewRelic::Control.instance.env }
-    report_on('Rails version'   ) { ::Rails::VERSION::STRING       }
+    report_on('Physical Cores') { ::NewRelic::Agent::SystemInfo.num_physical_cores }
+    report_on('Arch') { ::NewRelic::Agent::SystemInfo.processor_arch }
+    report_on('OS version') { ::NewRelic::Agent::SystemInfo.os_version }
+    report_on('OS') { ::NewRelic::Agent::SystemInfo.ruby_os_identifier }
+    report_on('Database adapter') { ::NewRelic::Agent::DatabaseAdapter.value }
+    report_on('Framework') { Agent.config[:framework].to_s }
+    report_on('Dispatcher') { Agent.config[:dispatcher].to_s }
+    report_on('Environment') { NewRelic::Control.instance.env }
+    report_on('Rails version') { ::Rails::VERSION::STRING }
     report_on('Rails threadsafe') do
       ::Rails.configuration.action_controller.allow_concurrency
     end
@@ -88,7 +87,6 @@ module NewRelic
     # end reporting logic
     ####################################
 
-
     attr_reader :data
     # Generate the report based on the class level logic.
     def initialize

data/lib/new_relic/helper.rb

@@ -3,8 +3,12 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/language_support'
+require 'open3'
 
 module NewRelic
+  class CommandExecutableNotFoundError < StandardError; end
+  class CommandRunFailedError < StandardError; end
+
   # A singleton for shared generic helper methods
   module Helper
     extend self
@@ -19,9 +23,9 @@ module NewRelic
     end
 
     def instance_method_visibility(klass, method_name)
-      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+      if klass.private_instance_methods.map { |s| s.to_sym }.include? method_name.to_sym
         :private
-      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+      elsif klass.protected_instance_methods.map { |s| s.to_sym }.include? method_name.to_sym
         :protected
       else
         :public
@@ -31,14 +35,50 @@ module NewRelic
     def instance_methods_include?(klass, method_name)
       method_name_sym = method_name.to_sym
       (
-        klass.instance_methods.map{ |s| s.to_sym }.include?(method_name_sym)          ||
-        klass.protected_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym) ||
-        klass.private_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym)
+        klass.instance_methods.map { |s| s.to_sym }.include?(method_name_sym) ||
+        klass.protected_instance_methods.map { |s| s.to_sym }.include?(method_name_sym) ||
+        klass.private_instance_methods.map { |s| s.to_sym }.include?(method_name_sym)
       )
     end
 
     def time_to_millis(time)
       (time.to_f * 1000).round
     end
+
+    def run_command(command)
+      executable = command.split(' ').first
+      unless executable_in_path?(executable)
+        raise NewRelic::CommandExecutableNotFoundError.new("Executable not found: '#{executable}'")
+      end
+
+      exception = nil
+      begin
+        output, status = Open3.capture2e(command)
+      rescue => exception
+      end
+
+      if exception || !status.success?
+        message = exception ? "#{exception.class} - #{exception.message}" : output
+        raise NewRelic::CommandRunFailedError.new("Failed to run command '#{command}': #{message}")
+      end
+
+      output.chomp
+    end
+
+    # TODO: Open3 defers the actual excecution of a binary to Process.spawn,
+    #       which will raise an Errno::ENOENT exception for a file that
+    #       cannot be found. We might want to take the time to evaluate
+    #       relying on that Process.spawn behavior instead of checking for
+    #       existence ourselves. We'd need to see what it does, how efficient
+    #       it is, if it differs in functionality between Ruby versions and
+    #       operating systems, etc.
+    def executable_in_path?(executable)
+      return false unless ENV['PATH']
+
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |bin_path|
+        executable_path = File.join(bin_path, executable)
+        File.exist?(executable_path) && File.file?(executable_path) && File.executable?(executable_path)
+      end
+    end
   end
 end

data/lib/new_relic/language_support.rb

@@ -22,7 +22,8 @@ module NewRelic
     end
 
     def object_space_usable?
-      if defined?(::JRuby) && JRuby.respond_to?(:runtime)
+      if jruby?
+        require 'jruby'
         JRuby.runtime.is_object_space_enabled
       else
         defined?(::ObjectSpace)
@@ -33,8 +34,25 @@ module NewRelic
       RUBY_ENGINE == 'jruby'
     end
 
+    # TODO: OLD RUBIES - RUBY_VERSION < 2.6
+    #
+    # Ruby 2.6 introduced an improved version of `Object.const_get` that
+    # respects the full namespace of the input and doesn't just grab the first
+    # constant matching the string to the right of the last '::'.
+    # Once we drop support for Ruby 2.5 and below, the only value this custom
+    # method will provide beyond `Object.const_get` itself is to automatically
+    # catch NameError.
+    #
+    # see: https://github.com/rails/rails/commit/7057ccf6565c1cb5354c1906880119276a9d15c0
+    #
+    # With Ruby 2.6+, this method can be defined like so:
+    # def constantize(constant_as_string_or_symbol)
+    #   Object.const_get(constant_as_string_or_symbol)
+    # rescue NameError
+    # end
+    #
     def constantize(const_name)
-      const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
+      const_name.to_s.sub(/\A::/, '').split('::').inject(Object) do |namespace, name|
         begin
           result = namespace.const_get(name)
 

data/lib/new_relic/latest_changes.rb

@@ -13,7 +13,7 @@ module NewRelic
     changes.
 EOS
 
-    def self.read(changelog=default_changelog)
+    def self.read(changelog = default_changelog)
       changes = extract_latest_changes(File.read(changelog))
       changes << FOOTER
 
@@ -24,7 +24,7 @@ EOS
     # precise version number included in the line in parens. For example:
     #
     # * This is a patch item (3.7.1.188)
-    def self.read_patch(patch_level, changelog=default_changelog)
+    def self.read_patch(patch_level, changelog = default_changelog)
       latest = extract_latest_changes(File.read(changelog))
       changes = ["## v#{patch_level}", ""]
 

data/lib/new_relic/local_environment.rb

@@ -36,7 +36,7 @@ module NewRelic
     def initialize
       # Extend self with any any submodules of LocalEnvironment.  These can override
       # the discover methods to discover new framworks and dispatchers.
-      NewRelic::LocalEnvironment.constants.each do | const |
+      NewRelic::LocalEnvironment.constants.each do |const|
         mod = NewRelic::LocalEnvironment.const_get const
         self.extend mod if mod.instance_of? Module
       end
@@ -76,14 +76,15 @@ module NewRelic
         rainbows
         unicorn
       ]
+      # TODO: MAJOR VERSION - remove rainbows
       while dispatchers.any? && @discovered_dispatcher.nil?
-        send 'check_for_'+(dispatchers.shift)
+        send 'check_for_' + (dispatchers.shift)
       end
     end
 
     def check_for_torquebox
       return unless defined?(::JRuby) &&
-         ( org.torquebox::TorqueBox rescue nil)
+        (org.torquebox::TorqueBox rescue nil)
       @discovered_dispatcher = :torquebox
     end
 
@@ -127,6 +128,7 @@ module NewRelic
       end
     end
 
+    # TODO: MAJOR VERSION - remove this method
     def check_for_rainbows
       if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
         v = find_class_in_object_space(::Rainbows::HttpServer)
@@ -147,9 +149,9 @@ module NewRelic
     end
 
     def check_for_resque
-      has_queue              = ENV['QUEUE'] || ENV['QUEUES']
-      resque_rake            = executable == 'rake' && ARGV.include?('resque:work')
-      resque_pool_rake       = executable == 'rake' && ARGV.include?('resque:pool')
+      has_queue = ENV['QUEUE'] || ENV['QUEUES']
+      resque_rake = executable == 'rake' && ARGV.include?('resque:work')
+      resque_pool_rake = executable == 'rake' && ARGV.include?('resque:pool')
       resque_pool_executable = executable == 'resque-pool' && defined?(::Resque::Pool)
 
       using_resque = defined?(::Resque) &&
@@ -192,6 +194,7 @@ module NewRelic
     end
 
     public
+
     # outputs a human-readable description
     def to_s
       s = "LocalEnvironment["
@@ -202,6 +205,5 @@ module NewRelic
     def executable
       File.basename($0)
     end
-
   end
 end

data/lib/new_relic/metric_data.rb

@@ -18,7 +18,7 @@ module NewRelic
     end
 
     def eql?(o)
-     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+      (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
     end
 
     def original_spec
@@ -37,7 +37,7 @@ module NewRelic
     end
 
     def to_json(*a)
-       %Q[{"metric_spec":#{metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}}}]
+      %Q({"metric_spec":#{metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}}})
     end
 
     def to_s
@@ -50,9 +50,9 @@ module NewRelic
 
     include NewRelic::Coerce
 
-    def to_collector_array(encoder=nil)
-      stat_key = { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
-      [ stat_key,
+    def to_collector_array(encoder = nil)
+      stat_key = {'name' => metric_spec.name, 'scope' => metric_spec.scope}
+      [stat_key,
         [
           int(stats.call_count, stat_key),
           float(stats.total_call_time, stat_key),
@@ -60,8 +60,7 @@ module NewRelic
           float(stats.min_call_time, stat_key),
           float(stats.max_call_time, stat_key),
           float(stats.sum_of_squares, stat_key)
-        ]
-      ]
+        ]]
     end
   end
 end

data/lib/new_relic/metric_spec.rb

@@ -5,14 +5,14 @@
 # this struct uniquely defines a metric, optionally inside
 # the call scope of another metric
 class NewRelic::MetricSpec
-  attr_reader   :name, :scope
+  attr_reader :name, :scope
 
   # the maximum length of a metric name or metric scope
   MAX_LENGTH = 255
   LENGTH_RANGE = (0...MAX_LENGTH)
   EMPTY_SCOPE = ''.freeze
 
-  def initialize(metric_name='', metric_scope=nil)
+  def initialize(metric_name = '', metric_scope = nil)
     if metric_name.to_s.length > MAX_LENGTH
       @name = metric_name.to_s[LENGTH_RANGE]
     else
@@ -53,7 +53,7 @@ class NewRelic::MetricSpec
 
   def to_json(*a)
     {'name' => name,
-    'scope' => scope}.to_json(*a)
+     'scope' => scope}.to_json(*a)
   end
 
   def <=>(o)

data/lib/new_relic/noticed_error.rb

@@ -12,11 +12,11 @@ class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
 
   attr_accessor :path, :timestamp, :message, :exception_class_name,
-                :request_uri, :request_port, :file_name, :line_number,
-                :stack_trace, :attributes_from_notice_error, :attributes,
-                :expected
+    :request_uri, :request_port, :file_name, :line_number,
+    :stack_trace, :attributes_from_notice_error, :attributes,
+    :expected
 
-  attr_reader   :exception_id, :is_internal
+  attr_reader :exception_id, :is_internal
 
   STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by New Relic 'strip_exception_messages' setting"
   UNKNOWN_ERROR_CLASS_NAME = 'Error'
@@ -28,12 +28,12 @@ class NewRelic::NoticedError
 
   DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
 
-  ERROR_PREFIX_KEY   = 'error'
-  ERROR_MESSAGE_KEY  = "#{ERROR_PREFIX_KEY}.message"
-  ERROR_CLASS_KEY    = "#{ERROR_PREFIX_KEY}.class"
+  ERROR_PREFIX_KEY = 'error'
+  ERROR_MESSAGE_KEY = "#{ERROR_PREFIX_KEY}.message"
+  ERROR_CLASS_KEY = "#{ERROR_PREFIX_KEY}.class"
   ERROR_EXPECTED_KEY = "#{ERROR_PREFIX_KEY}.expected"
 
-  def initialize(path, exception, timestamp = Time.now)
+  def initialize(path, exception, timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), expected = false)
     @exception_id = exception.object_id
     @path = path
 
@@ -51,14 +51,14 @@ class NewRelic::NoticedError
 
     # replace error message if enabled
     if NewRelic::Agent.config[:'strip_exception_messages.enabled'] &&
-       !self.class.passes_message_allowlist(exception.class)
+        !self.class.passes_message_allowlist(exception.class)
       @message = STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE
     end
 
     @attributes_from_notice_error = nil
     @attributes = nil
     @timestamp = timestamp
-    @expected = false
+    @expected = expected
   end
 
   def ==(other)
@@ -77,12 +77,12 @@ class NewRelic::NoticedError
 
   include NewRelic::Coerce
 
-  def to_collector_array(encoder=nil)
-    [ NewRelic::Helper.time_to_millis(timestamp),
+  def to_collector_array(encoder = nil)
+    [NewRelic::Helper.time_to_millis(timestamp),
       string(path),
       string(message),
       string(exception_class_name),
-      processed_attributes ]
+      processed_attributes]
   end
 
   # Note that we process attributes lazily and store the result. This is because
@@ -101,10 +101,10 @@ class NewRelic::NoticedError
 
   def base_parameters
     params = {}
-    params[:file_name]        = file_name   if file_name
-    params[:line_number]      = line_number if line_number
-    params[:stack_trace]      = stack_trace if stack_trace
-    params[:'error.expected'] = expected
+    params[:file_name] = file_name if file_name
+    params[:line_number] = line_number if line_number
+    params[:stack_trace] = stack_trace if stack_trace
+    params[ERROR_EXPECTED_KEY.to_sym] = expected
     params
   end
 
@@ -139,7 +139,7 @@ class NewRelic::NoticedError
       ERROR_MESSAGE_KEY => string(message),
       ERROR_CLASS_KEY => string(exception_class_name)
     })
-    
+
     @attributes_from_notice_error[ERROR_EXPECTED_KEY] = true if expected
   end
 
@@ -200,5 +200,4 @@ class NewRelic::NoticedError
       @message = exception.to_s
     end
   end
-
 end

data/lib/new_relic/rack/agent_middleware.rb

@@ -13,10 +13,10 @@ module NewRelic
 
       attr_reader :transaction_options, :category, :target
 
-      def initialize(app, options={})
+      def initialize(app, options = {})
         @app = app
         @category = :middleware
-        @target   = self
+        @target = self
         @transaction_options = {
           :transaction_name => build_transaction_name
         }

data/lib/new_relic/rack/browser_monitoring.rb

@@ -19,15 +19,15 @@ module NewRelic::Rack
     # examine in order to look for a RUM insertion point.
     SCAN_LIMIT = 50_000
 
-    CONTENT_TYPE        = 'Content-Type'.freeze
+    CONTENT_TYPE = 'Content-Type'.freeze
     CONTENT_DISPOSITION = 'Content-Disposition'.freeze
-    CONTENT_LENGTH      = 'Content-Length'.freeze
-    ATTACHMENT          = 'attachment'.freeze
-    TEXT_HTML           = 'text/html'.freeze
+    CONTENT_LENGTH = 'Content-Length'.freeze
+    ATTACHMENT = 'attachment'.freeze
+    TEXT_HTML = 'text/html'.freeze
 
-    BODY_START          = "<body".freeze
-    HEAD_START          = "<head".freeze
-    GT                  = ">".freeze
+    BODY_START = "<body".freeze
+    HEAD_START = "<head".freeze
+    GT = ">".freeze
 
     def traced_call(env)
       result = @app.call(env)
@@ -79,7 +79,7 @@ module NewRelic::Rack
         env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
     end
 
-    CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
+    CHARSET_RE = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
     X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
 
     def autoinstrument_source(response, headers, js_to_inject)
@@ -123,7 +123,7 @@ module NewRelic::Rack
 
     def gather_source(response)
       source = nil
-      response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
+      response.each { |fragment| source ? (source << fragment.to_s) : (source = fragment.to_s) }
       source
     end
 

data/lib/new_relic/recipes/capistrano3.rb

@@ -5,7 +5,6 @@
 require 'capistrano/framework'
 
 namespace :newrelic do
-
   # notifies New Relic of a deployment
   desc "Record a deployment in New Relic (newrelic.com)"
   task :notice_deployment do
@@ -23,15 +22,15 @@ namespace :newrelic do
   def send_deployment_notification_to_newrelic
     environment = fetch(:newrelic_rails_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage, "production"))))
 
-    require 'new_relic/cli/command.rb'
+    require 'new_relic/cli/command'
 
     begin
       # allow overrides to be defined for revision, description, changelog, appname, and user
-      rev         = fetch(:newrelic_revision)
+      rev = fetch(:newrelic_revision)
       description = fetch(:newrelic_desc)
-      changelog   = fetch(:newrelic_changelog)
-      appname     = fetch(:newrelic_appname)
-      user        = fetch(:newrelic_user)
+      changelog = fetch(:newrelic_changelog)
+      appname = fetch(:newrelic_appname)
+      user = fetch(:newrelic_user)
       license_key = fetch(:newrelic_license_key)
 
       has_scm_from_plugin = respond_to?(:scm_plugin_installed?) && scm_plugin_installed?
@@ -39,17 +38,17 @@ namespace :newrelic do
 
       if has_scm_from_plugin || has_scm_from_config
         changelog ||= lookup_changelog
-        rev       ||= fetch(:current_revision)
+        rev ||= fetch(:current_revision)
       end
 
       new_revision = rev
       deploy_options = {
         :environment => environment,
-        :revision    => new_revision,
-        :changelog   => changelog,
+        :revision => new_revision,
+        :changelog => changelog,
         :description => description,
-        :appname     => appname,
-        :user        => user,
+        :appname => appname,
+        :user => user,
         :license_key => license_key
       }
 
@@ -57,7 +56,6 @@ namespace :newrelic do
       deployment = NewRelic::Cli::Deployments.new deploy_options
       deployment.run
       info "Uploaded deployment information to New Relic"
-
     rescue NewRelic::Cli::Command::CommandFailure => e
       info e.message
     rescue => e
@@ -74,7 +72,7 @@ namespace :newrelic do
 
     if Rake::Task.task_defined?("git:check")
       log_command = "git --no-pager log --no-color --pretty=format:'  * %an: %s' " +
-                    "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
+        "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
       `#{log_command}`
     end
   end

data/lib/new_relic/recipes/capistrano_legacy.rb

@@ -3,38 +3,36 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 make_notify_task = Proc.new do
-
   namespace :newrelic do
-
     # on all deployments, notify New Relic
     desc "Record a deployment in New Relic (newrelic.com)"
-    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
+    task :notice_deployment, :roles => :app, :except => {:no_release => true} do
       rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
 
       require 'new_relic/cli/command'
 
       begin
         # allow overrides to be defined for revision, description, changelog, appname, and user
-        rev         = fetch(:newrelic_revision)    if exists?(:newrelic_revision)
-        description = fetch(:newrelic_desc)        if exists?(:newrelic_desc)
-        changelog   = fetch(:newrelic_changelog)   if exists?(:newrelic_changelog)
-        appname     = fetch(:newrelic_appname)     if exists?(:newrelic_appname)
-        user        = fetch(:newrelic_user)        if exists?(:newrelic_user)
+        rev = fetch(:newrelic_revision) if exists?(:newrelic_revision)
+        description = fetch(:newrelic_desc) if exists?(:newrelic_desc)
+        changelog = fetch(:newrelic_changelog) if exists?(:newrelic_changelog)
+        appname = fetch(:newrelic_appname) if exists?(:newrelic_appname)
+        user = fetch(:newrelic_user) if exists?(:newrelic_user)
         license_key = fetch(:newrelic_license_key) if exists?(:newrelic_license_key)
 
         unless scm == :none
           changelog = lookup_changelog(changelog)
-          rev       = lookup_rev(rev)
+          rev = lookup_rev(rev)
         end
 
         new_revision = rev
         deploy_options = {
           :environment => rails_env,
-          :revision    => new_revision,
-          :changelog   => changelog,
+          :revision => new_revision,
+          :changelog => changelog,
           :description => description,
-          :appname     => appname,
-          :user        => user,
+          :appname => appname,
+          :user => user,
           :license_key => license_key
         }
 
@@ -42,7 +40,6 @@ make_notify_task = Proc.new do
         deployment = NewRelic::Cli::Deployments.new deploy_options
         deployment.run
         logger.info "Uploaded deployment information to New Relic"
-
       rescue NewRelic::Cli::Command::CommandFailure => e
         logger.info e.message
       rescue Capistrano::CommandError

data/lib/new_relic/supportability_helper.rb

@@ -4,7 +4,6 @@
 
 module NewRelic
   module SupportabilityHelper
-
     API_SUPPORTABILITY_PREFIX = 'Supportability/API/'.freeze
 
     # pre-instantiate these strings as they may be used multiple times per
@@ -51,10 +50,11 @@ module NewRelic
       :shutdown,
       :start_segment,
       :trace,
+      :traced_thread,
       :trace_execution_scoped,
       :trace_execution_unscoped,
       :wrap
-    ].reduce({}) do |h,o|
+    ].reduce({}) do |h, o|
       h[o] = API_SUPPORTABILITY_PREFIX + o.to_s
       h
     end

data/lib/new_relic/traced_thread.rb

@@ -0,0 +1,35 @@
+# 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
+  #
+  # This class allows the current transaction to be passed to a Thread so that nested segments can be created from the operations performed within the Thread's block.
+  # To have the New Relic Ruby agent automatically trace all of your applications threads,
+  # enable the +instrumentation.thread.tracing+ configuration option in your newrelic.yml.
+  #
+  # Note: disabling the configuration option +instrumentation.thread+ while using this class can cause incorrectly nested spans.
+  #
+  # @api public
+  class TracedThread < Thread
+    #
+    # Creates a new Thread whose work will be traced by New Relic.
+    # Use this class as a replacement for the native Thread class.
+    # Example: Instead of using +Thread.new+, use:
+    #
+    #     NewRelic::TracedThread.new { execute_some_code }
+    #
+    # @api public
+    def initialize(*args, &block)
+      NewRelic::Agent.record_api_supportability_metric(:traced_thread)
+      traced_block = create_traced_block(*args, &block)
+      super(*args, &traced_block)
+    end
+
+    def create_traced_block(*args, &block)
+      return block if NewRelic::Agent.config[:'instrumentation.thread.tracing'] # if this is on, don't double trace
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(*args, &block)
+    end
+  end
+end