newrelic_rpm 8.13.1 → 8.15.0

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

@@ -11,19 +11,19 @@ DependencyDetection.defer do
   named :rake_instrumentation
   configure_with :rake
 
-  depends_on { defined?(::Rake) && defined?(::Rake::VERSION) }
-  depends_on { Gem::Version.new(::Rake::VERSION) >= Gem::Version.new("10.0.0") }
-  depends_on { ::NewRelic::Agent.config[:'rake.tasks'].any? }
-  depends_on { ::NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
+  depends_on { defined?(Rake) && defined?(Rake::VERSION) }
+  depends_on { Gem::Version.new(Rake::VERSION) >= Gem::Version.new("10.0.0") }
+  depends_on { NewRelic::Agent.config[:'rake.tasks'].any? }
+  depends_on { NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
 
   executes do
-    ::NewRelic::Agent.logger.info("Installing Rake instrumentation")
-    ::NewRelic::Agent.logger.debug("Instrumenting Rake tasks: #{::NewRelic::Agent.config[:'rake.tasks']}")
+    NewRelic::Agent.logger.info("Installing Rake instrumentation")
+    NewRelic::Agent.logger.debug("Instrumenting Rake tasks: #{NewRelic::Agent.config[:'rake.tasks']}")
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Rake::Task, NewRelic::Agent::Instrumentation::Rake::Prepend
+      prepend_instrument Rake::Task, NewRelic::Agent::Instrumentation::Rake::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Rake::Chain
     end

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

@@ -27,10 +27,17 @@ module NewRelic::Agent::Instrumentation
 
     # Used for Redis 5.x+
     def call_pipelined_with_tracing(pipeline)
+      db = begin
+        _nr_redis_client_config.db
+      rescue StandardError => e
+        NewRelic::Agent.logger.error("Failed to determine configured Redis db value: #{e.class} - #{e.message}")
+        nil
+      end
+
       operation = pipeline.flatten.include?('MULTI') ? Constants::MULTI_OPERATION : Constants::PIPELINE_OPERATION
       statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline)
 
-      with_tracing(operation, statement: statement, database: client.config.db) { yield }
+      with_tracing(operation, statement: statement, database: db) { yield }
     end
 
     private
@@ -47,26 +54,40 @@ module NewRelic::Agent::Instrumentation
         segment.notice_nosql_statement(statement) if statement
         NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
       ensure
-        segment.finish if segment
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
       end
     end
 
     def _nr_hostname
-      _nr_client.path ? Constants::LOCALHOST : _nr_client.host
+      _nr_redis_client_config.path ? Constants::LOCALHOST : _nr_redis_client_config.host
     rescue => e
-      NewRelic::Agent.logger.debug("Failed to retrieve Redis host: #{e}")
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis host: #{e.class} - #{e.message}")
       Constants::UNKNOWN
     end
 
     def _nr_port_path_or_id
-      _nr_client.path || _nr_client.port
+      _nr_redis_client_config.path || _nr_redis_client_config.port
     rescue => e
-      NewRelic::Agent.logger.debug("Failed to retrieve Redis port_path_or_id: #{e}")
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis port_path_or_id: #{e.class} - #{e.message}")
       Constants::UNKNOWN
     end
 
-    def _nr_client
-      @nr_client ||= self.is_a?(::Redis::Client) ? self : client.config
+    def _nr_redis_client_config
+      @nr_config ||= begin
+        # redis gem
+        config = if defined?(::Redis::Client) && self.is_a?(::Redis::Client)
+          self
+        # redis-client gem v0.11+ (self is a RedisClient::Middlewares)
+        elsif respond_to?(:client)
+          client && client.config
+        # redis-client gem <0.11 (self is a RedisClient::Middlewares)
+        elsif defined?(::RedisClient)
+          ::RedisClient.config if ::RedisClient.respond_to?(:config)
+        end
+        raise 'Unable to locate the underlying Redis client configuration.' unless config
+
+        config
+      end
     end
   end
 end

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

@@ -17,11 +17,11 @@ DependencyDetection.defer do
   configure_with :redis
 
   depends_on do
-    defined?(::Redis) && defined?(::Redis::VERSION)
+    defined?(Redis) && defined?(Redis::VERSION)
   end
 
   conflicts_with_prepend do
-    defined?(::PrometheusExporter)
+    defined?(PrometheusExporter)
   end
 
   depends_on do
@@ -32,11 +32,11 @@ DependencyDetection.defer do
   executes do
     NewRelic::Agent.logger.info('Installing Redis Instrumentation')
     if NewRelic::Agent::Instrumentation::Redis::Constants::HAS_REDIS_CLIENT
-      ::RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::Middleware)
+      RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::Middleware)
     end
 
     if use_prepend?
-      prepend_instrument ::Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
+      prepend_instrument Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Redis::Chain
     end

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

@@ -10,21 +10,21 @@ DependencyDetection.defer do
   @name = :resque
 
   depends_on do
-    defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]
+    defined?(Resque::Job) && !NewRelic::Agent.config[:disable_resque]
   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,30 +32,30 @@ 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
+      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)
       end
     else
-      ::Resque.before_first_fork do
+      Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher => :resque,
           :sync_startup => true,
           :start_channel_listener => false)

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

@@ -7,7 +7,7 @@ DependencyDetection.defer do
   @name = :sequel
 
   depends_on do
-    defined?(::Sequel)
+    defined?(Sequel)
   end
 
   depends_on do
@@ -24,7 +24,7 @@ DependencyDetection.defer do
   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)

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

@@ -9,11 +9,11 @@ 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
@@ -46,7 +46,7 @@ DependencyDetection.defer do
       '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(
+    NewRelic::Agent.logger.log_once(
       :warn,
       :deprecated_sidekiq_version,
       deprecation_msg

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

@@ -11,24 +11,24 @@ 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
@@ -37,7 +37,7 @@ DependencyDetection.defer do
     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
+      prepend_instrument Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
     end
@@ -49,7 +49,7 @@ DependencyDetection.defer do
     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(
+    NewRelic::Agent.logger.log_once(
       :warn,
       :deprecated_sinatra_version,
       deprecation_msg

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

@@ -6,15 +6,15 @@ DependencyDetection.defer do
   @name = :sunspot
 
   depends_on do
-    defined?(::Sunspot)
+    defined?(Sunspot)
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing Rails Sunspot instrumentation')
+    NewRelic::Agent.logger.info('Installing Rails Sunspot instrumentation')
     deprecation_msg = 'The instrumentation for Sunspot is deprecated. ' \
       'It will be removed in version 9.0.0.'
 
-    ::NewRelic::Agent.logger.log_once(
+    NewRelic::Agent.logger.log_once(
       :warn,
       :deprecated_sunspot,
       deprecation_msg
@@ -22,7 +22,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::Sunspot.module_eval do
+    Sunspot.module_eval do
       class << self
         %w[index index!].each do |method|
           add_method_tracer method, 'SolrClient/Sunspot/index'

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

@@ -16,7 +16,11 @@ module NewRelic
         def add_thread_tracing(*args, &block)
           return block if skip_tracing?
 
-          NewRelic::Agent::Tracer.thread_block_with_current_transaction(*args, &block)
+          NewRelic::Agent::Tracer.thread_block_with_current_transaction(
+            *args,
+            segment_name: 'Ruby/Thread',
+            &block
+          )
         end
 
         def skip_tracing?

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

@@ -9,12 +9,12 @@ DependencyDetection.defer do
   named :thread
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing Thread Instrumentation')
+    NewRelic::Agent.logger.info('Installing Thread Instrumentation')
 
     if use_prepend?
-      prepend_instrument ::Thread, ::NewRelic::Agent::Instrumentation::MonitoredThread::Prepend
+      prepend_instrument Thread, NewRelic::Agent::Instrumentation::MonitoredThread::Prepend
     else
-      chain_instrument ::NewRelic::Agent::Instrumentation::MonitoredThread::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::MonitoredThread::Chain
     end
   end
 end

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

@@ -9,15 +9,15 @@ require_relative 'tilt/prepend'
 DependencyDetection.defer do
   named :tilt
 
-  depends_on { defined?(::Tilt) }
+  depends_on { defined?(Tilt) }
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing Tilt instrumentation')
+    NewRelic::Agent.logger.info('Installing Tilt instrumentation')
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend
+      prepend_instrument Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Tilt::Chain
     end

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

@@ -36,7 +36,7 @@ module NewRelic
           begin
             yield
           ensure
-            segment.finish if segment
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
           end
         end
 
@@ -68,7 +68,7 @@ module NewRelic
               segment.notice_error(NoticeableError.new(NOTICEABLE_ERROR_CLASS, response_message(request.response)))
             end
 
-            segment.finish if segment
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
           end
           request.on_complete.unshift(callback)
         rescue => e

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

@@ -18,7 +18,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing Typhoeus instrumentation')
+    NewRelic::Agent.logger.info('Installing Typhoeus instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/typhoeus_wrappers'
   end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -141,8 +141,8 @@ module NewRelic
         start_time_in_seconds = [transaction.start_time, 0.0].max
         app_time_in_seconds = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
 
-        queue_time_in_millis = (1000.0 * queue_time_in_seconds).round
-        app_time_in_millis = (1000.0 * app_time_in_seconds).round
+        queue_time_in_millis = (queue_time_in_seconds * 1000.0).round
+        app_time_in_millis = (app_time_in_seconds * 1000.0).round
 
         transaction_name = transaction.best_name || ::NewRelic::Agent::UNKNOWN_METRIC
 

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -17,8 +17,7 @@ module NewRelic
       extend self
 
       def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::Tracer.state
-        return yield unless state.is_execution_traced?
+        return yield unless NewRelic::Agent::Tracer.state.is_execution_traced?
 
         metric_names = Array(metric_names)
         first_name = metric_names.shift
@@ -29,19 +28,15 @@ module NewRelic
           unscoped_metrics: metric_names
         )
 
-        if options[:metric] == false
-          segment.record_metrics = false
-        end
+        segment.record_metrics = false if options[:metric] == false
 
         unless !options.key?(:code_information) || options[:code_information].nil? || options[:code_information].empty?
           segment.code_information = options[:code_information]
         end
 
-        begin
-          Tracer.capture_segment_error(segment) { yield }
-        ensure
-          segment.finish if segment
-        end
+        Tracer.capture_segment_error(segment) { yield }
+      ensure
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
       end
 
       def code_information(object, method_name)
@@ -77,7 +72,7 @@ module NewRelic
         name = Regexp.last_match(1) if object.to_s =~ /^#<Class:(.*)>$/
         return name if name
 
-        raise "Unable to glean a class name from string '#{object}'" unless name
+        raise "Unable to glean a class name from string '#{object}'"
       end
 
       # get at the underlying class from the singleton class

data/lib/new_relic/agent/range_extensions.rb

@@ -18,8 +18,8 @@ module NewRelic
         ranges.inject(0) do |memo, other|
           next memo unless intersects?(range, other)
 
-          memo += (range.end < other.end ? range.end : other.end) -
-            (range.begin > other.begin ? range.begin : other.begin)
+          memo += ([range.end, other.end].min) -
+            ([range.begin, other.begin].max)
         end
       end
     end

data/lib/new_relic/agent/tracer.rb

@@ -2,6 +2,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
+require 'fiber'
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/transaction/datastore_segment'
@@ -409,17 +410,20 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
-        def thread_block_with_current_transaction(*args, &block)
+        def thread_block_with_current_transaction(*args, segment_name:, parent: nil, &block)
           current_txn = ::Thread.current[:newrelic_tracer_state].current_transaction if ::Thread.current[:newrelic_tracer_state] && ::Thread.current[:newrelic_tracer_state].is_execution_traced?
           proc do
             begin
               if current_txn
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn
-                segment = NewRelic::Agent::Tracer.start_segment(name: "Ruby/Thread/#{::Thread.current.object_id}")
+                segment_name += "/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
+                segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent)
+              end
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield(*args)
               end
-              yield(*args) if block.respond_to?(:call)
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -111,8 +111,8 @@ module NewRelic
         end
 
         def merge_timings(timing1, timing2)
-          [(timing1.first < timing2.first ? timing1.first : timing2.first),
-            (timing1.last > timing2.last ? timing1.last : timing2.last)]
+          [([timing1.first, timing2.first].min),
+            ([timing1.last, timing2.last].max)]
         end
 
         # @children_timings is an array of array, with each inner array

data/lib/new_relic/agent/transaction/segment.rb

@@ -46,6 +46,12 @@ module NewRelic
           attributes.merge_custom_attributes(p)
         end
 
+        def self.finish(segment)
+          return unless segment
+
+          segment.finish
+        end
+
         private
 
         def record_metrics

data/lib/new_relic/agent/transaction/transaction_sample_buffer.rb

@@ -72,7 +72,7 @@ module NewRelic
         # A typical buffer should NOT override this method (although we do for
         # odd things like dev-mode)
         def max_capacity
-          capacity > SINGLE_BUFFER_MAX ? SINGLE_BUFFER_MAX : capacity
+          [capacity, SINGLE_BUFFER_MAX].min
         end
 
         # Our default truncation strategy is to keep max_capacity

data/lib/new_relic/agent/transaction.rb

@@ -168,7 +168,7 @@ module NewRelic
           :apdex_f
         when duration <= apdex_t
           :apdex_s
-        when duration <= 4 * apdex_t
+        when duration <= apdex_t * 4
           :apdex_t
         else
           :apdex_f
@@ -302,7 +302,7 @@ module NewRelic
       end
 
       def priority
-        @priority ||= (sampled? ? 1.0 + rand : rand).round(NewRelic::PRIORITY_PRECISION)
+        @priority ||= (sampled? ? rand + 1.0 : rand).round(NewRelic::PRIORITY_PRECISION)
       end
 
       def referer
@@ -635,7 +635,7 @@ module NewRelic
         return unless distributed_trace_payload
 
         duration = start_time - (distributed_trace_payload.timestamp / 1000.0)
-        duration < 0 ? 0 : duration
+        [duration, 0].max
       end
 
       # The summary metrics recorded by this method all end up with a duration

data/lib/new_relic/agent.rb

@@ -109,6 +109,7 @@ module NewRelic
     @logger = nil
     @tracer_lock = Mutex.new
     @tracer_queue = []
+    @metrics_already_recorded = Set.new
 
     # The singleton Agent instance.  Used internally.
     def agent # :nodoc:
@@ -203,6 +204,12 @@ module NewRelic
       agent.stats_engine.tl_record_unscoped_metrics(metric_name, value)
     end
 
+    def record_metric_once(metric_name, value = 0.0)
+      return unless @metrics_already_recorded.add?(metric_name)
+
+      record_metric(metric_name, value)
+    end
+
     # Increment a simple counter metric.
     #
     # +metric_name+ should follow a slash separated path convention. Application

data/lib/new_relic/control/instance_methods.rb

@@ -64,8 +64,12 @@ module NewRelic
 
         # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
         # methods in the module methods.
-        Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
-        Module.send(:include, NewRelic::Agent::MethodTracer)
+        # Rails applications load the next two lines before any other initializers are run
+        unless defined?(Rails::VERSION) && NewRelic::Agent.config[:defer_rails_initialization]
+          Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
+          Module.send(:include, NewRelic::Agent::MethodTracer)
+        end
+
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
         init_instrumentation

data/lib/new_relic/helper.rb

@@ -63,7 +63,7 @@ module NewRelic
         raise NewRelic::CommandRunFailedError.new("Failed to run command '#{command}': #{message}")
       end
 
-      output.chomp
+      output.chomp if output
     end
 
     # TODO: Open3 defers the actual execution of a binary to Process.spawn,

data/lib/new_relic/recipes/helpers/send_deployment.rb

@@ -29,7 +29,8 @@ module SendDeployment
   end
 
   def fetch_changelog
-    has_scm? ? fetch(:newrelic_changelog) : lookup_changelog
+    newrelic_changelog = fetch(:newrelic_changelog)
+    has_scm? && !newrelic_changelog ? lookup_changelog : newrelic_changelog
   end
 
   def fetch_environment

data/lib/new_relic/traced_thread.rb

@@ -29,7 +29,11 @@ module NewRelic
     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)
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(
+        *args,
+        segment_name: 'Ruby/TracedThread',
+        &block
+      )
     end
   end
 end

data/lib/new_relic/version.rb

@@ -6,8 +6,8 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 8
-    MINOR = 13
-    TINY = 1
+    MINOR = 15
+    TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
   end

data/lib/newrelic_rpm.rb

@@ -20,8 +20,19 @@ require 'new_relic/control'
 if defined?(Rails::VERSION)
   module NewRelic
     class Railtie < Rails::Railtie
-      initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
-        NewRelic::Control.instance.init_plugin(config: app.config)
+      if NewRelic::Agent.config[:defer_rails_initialization]
+        initializer "newrelic_rpm.include_method_tracers", before: :load_config_initializers do |app|
+          Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
+          Module.send(:include, NewRelic::Agent::MethodTracer)
+        end
+
+        initializer "newrelic_rpm.start_plugin", after: :load_config_initializers do |app|
+          NewRelic::Control.instance.init_plugin(config: app.config)
+        end
+      else
+        initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
+          NewRelic::Control.instance.init_plugin(config: app.config)
+        end
       end
     end
   end