newrelic_rpm 9.2.2 → 9.5.0

data/lib/new_relic/agent/new_relic_service.rb

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'timeout'
 require 'new_relic/agent/audit_logger'
 require 'new_relic/agent/new_relic_service/encoders'
 require 'new_relic/agent/new_relic_service/marshaller'
@@ -19,7 +18,13 @@ module NewRelic
 
       # These include Errno connection errors, and all indicate that the
       # underlying TCP connection may be in a bad state.
-      CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
+      CONNECTION_ERRORS = [Net::OpenTimeout, Net::ReadTimeout, EOFError, SystemCallError, SocketError]
+      # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until Ruby 2.6.
+      #       Once support for Ruby 2.5 is dropped, we should simply include
+      #       Net::WriteTimeout in the connection errors array directly instead
+      #       of with a conditional
+      CONNECTION_ERRORS << Net::WriteTimeout if defined?(Net::WriteTimeout)
+      CONNECTION_ERRORS.freeze
 
       # The maximum number of times to attempt an HTTP request
       MAX_ATTEMPTS = 2
@@ -319,13 +324,15 @@ module NewRelic
 
       def start_connection(conn)
         NewRelic::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
-        Timeout.timeout(@request_timeout) { conn.start }
-        conn
+        conn.start
       end
 
       def setup_connection_timeouts(conn)
-        # We use Timeout explicitly instead of this
-        conn.read_timeout = nil
+        conn.open_timeout = @request_timeout
+        conn.read_timeout = @request_timeout
+        # TODO: MAJOR VERSION - #write_timeout= requires Ruby 2.6+, so remove
+        #       the conditional check once support for Ruby 2.5 is dropped
+        conn.write_timeout = @request_timeout if conn.respond_to?(:write_timeout=)
 
         if conn.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
           conn.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
@@ -362,8 +369,8 @@ module NewRelic
         conn = create_http_connection
         start_connection(conn)
         conn
-      rescue Timeout::Error
-        ::NewRelic::Agent.logger.info('Timeout while attempting to connect. You may need to install system-level CA Certificates, as the ruby agent no longer includes these.')
+      rescue Net::OpenTimeout
+        ::NewRelic::Agent.logger.info('Timed out while attempting to connect. For SSL issues, you may need to install system-level CA Certificates to be used by Net::HTTP.')
         raise
       end
 
@@ -436,13 +443,9 @@ module NewRelic
       end
 
       def attempt_request(request, opts)
-        response = nil
         conn = http_connection
         ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{opts[:uri]} with #{request.method}")
-        Timeout.timeout(@request_timeout) do
-          response = conn.request(request)
-        end
-        response
+        conn.request(request)
       end
 
       def handle_error_response(response, endpoint)
@@ -450,7 +453,9 @@ module NewRelic
         when Net::HTTPRequestTimeOut,
              Net::HTTPTooManyRequests,
              Net::HTTPInternalServerError,
-             Net::HTTPServiceUnavailable
+             Net::HTTPServiceUnavailable,
+             Net::OpenTimeout,
+             Net::ReadTimeout
           handle_server_connection_exception(response, endpoint)
         when Net::HTTPBadRequest,
              Net::HTTPForbidden,
@@ -471,9 +476,20 @@ module NewRelic
         when Net::HTTPGone
           handle_gone_response(response, endpoint)
         else
-          record_endpoint_attempts_supportability_metrics(endpoint)
-          record_error_response_supportability_metrics(response.code)
-          raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until
+          #       Ruby 2.6, so it can't be included in the case statement
+          #       as a constant and instead needs to be found here. Once
+          #       support for Ruby 2.5 is dropped, we should have
+          #       Net::WriteTimeout sit in the 'when' clause above alongside
+          #       Net::OpenTimeout and Net::ReadTimeout and this entire if/else
+          #       conditional can be removed.
+          if response.respond_to?(:name) && response.name == 'Net::WriteTimeout'
+            handle_server_connection_exception(response, endpoint)
+          else
+            record_endpoint_attempts_supportability_metrics(endpoint)
+            record_error_response_supportability_metrics(response.code)
+            raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          end
         end
         response
       end

data/lib/new_relic/agent/pipe_service.rb

@@ -15,7 +15,7 @@ module NewRelic
         if @pipe && @pipe.parent_pid != $$
           @pipe.after_fork_in_child
         else
-          NewRelic::Agent.logger.error('No communication channel to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.')
+          NewRelic::Agent.logger.error('No communication channel to parent process, please see https://docs.newrelic.com/docs/apm/agents/ruby-agent/background-jobs/resque-instrumentation/ for more information.')
         end
       end
 

data/lib/new_relic/agent/tracer.rb

@@ -66,9 +66,10 @@ module NewRelic
         #
         # @api public
         def transaction_sampled?
-          if txn = current_transaction
-            txn.sampled?
-          end
+          txn = current_transaction
+          return false unless txn
+
+          txn.sampled?
         end
         alias_method :sampled?, :transaction_sampled?
 
@@ -419,10 +420,10 @@ module NewRelic
           NewRelic::Agent.config[:'instrumentation.thread.tracing']
         end
 
-        def thread_block_with_current_transaction(*args, segment_name:, parent: nil, &block)
+        def thread_block_with_current_transaction(segment_name:, parent: nil, &block)
           parent ||= current_segment
           current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
-          proc do
+          proc do |*args|
             begin
               if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn

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

@@ -24,6 +24,9 @@ module NewRelic
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
+        CALLBACK = :@callback
+        SEGMENT = 'segment'
+
         def initialize(name = nil, start_time = nil)
           @name = name
           @starting_segment_key = NewRelic::Agent::Tracer.current_segment_key
@@ -49,6 +52,7 @@ module NewRelic
           @code_function = nil
           @code_lineno = nil
           @code_namespace = nil
+          invoke_callback
         end
 
         def start
@@ -327,6 +331,54 @@ module NewRelic
             Tracer.state
           end
         end
+
+        # for segment callback usage info, see self.set_segment_callback
+        def invoke_callback
+          return unless self.class.instance_variable_defined?(CALLBACK)
+
+          NewRelic::Agent.logger.debug("Invoking callback for #{self.class.name}...")
+          self.class.instance_variable_get(CALLBACK).call
+        end
+
+        # Setting and invoking a segment callback
+        # =======================================
+        # Each individual segment class such as `ExternalRequestSegment` allows
+        # for exactly one instance of a `Proc` (meaning a proc or lambda) to be
+        # set as a callback. A callback can be set on a segment class by calling
+        # `.set_segment_callback` with a proc or lambda as the only argument.
+        # If set, the callback will be invoked with `#call` at segment class
+        # initialization time.
+        #
+        # Example usage:
+        #   callback = -> { puts 'Hello, World! }
+        #   ExternalRequestSegment.set_segment_callback(callback)
+        #   ExternalRequestSegment.new(library, uri, procedure)
+        #
+        # A callback set on a segment class will only be called when that
+        # specific segment class is initialized. Other segment classes will not
+        # be impacted.
+        #
+        # Great caution should be taken in the defining of the callback block
+        # to not have the block perform anything too time consuming or resource
+        # intensive in order to keep the New Relic Ruby agent operating
+        # normally.
+        #
+        # Given that callbacks are user defined, they must be set entirely at
+        # the user's own risk. It is recommended that each callback use
+        # conditional logic that only performs work for certain qualified
+        # segments. It is recommended that each callback be thoroughly tested
+        # in non-production environments before being introduced to production
+        # environments.
+        def self.set_segment_callback(callback_proc)
+          unless callback_proc.is_a?(Proc)
+            NewRelic::Agent.logger.error("#{self}.#{__method__}: expected an argument of type Proc, " \
+                                         "got #{callback_proc.class}")
+            return
+          end
+
+          NewRelic::Agent.record_api_supportability_metric(:set_segment_callback)
+          instance_variable_set(CALLBACK, callback_proc)
+        end
       end
     end
   end

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

@@ -8,11 +8,17 @@ module NewRelic
   module Agent
     class Transaction
       class RequestAttributes
-        attr_reader :request_path, :referer, :accept, :content_length, :content_type,
-          :host, :port, :user_agent, :request_method
+        # the HTTP standard has "referrer" mispelled as "referer"
+        attr_reader :accept, :content_length, :content_type, :host, :other_headers, :port, :referer, :request_method,
+          :request_path, :user_agent
 
         HTTP_ACCEPT_HEADER_KEY = 'HTTP_ACCEPT'.freeze
 
+        BASE_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE HTTP_ACCEPT HTTP_REFERER HTTP_USER_AGENT PATH_INFO REMOTE_HOST
+          REQUEST_METHOD REQUEST_URI SERVER_PORT].freeze
+
+        ATTRIBUTE_PREFIX = 'request.headers.'
+
         def initialize(request)
           @request_path = path_from_request(request)
           @referer = referer_from_request(request)
@@ -23,6 +29,7 @@ module NewRelic
           @port = port_from_request(request)
           @user_agent = attribute_from_request(request, :user_agent)
           @request_method = attribute_from_request(request, :request_method)
+          @other_headers = other_headers_from_request(request)
         end
 
         def assign_agent_attributes(txn)
@@ -31,14 +38,17 @@ module NewRelic
             AttributeFilter::DST_ERROR_COLLECTOR
 
           if referer
-            txn.add_agent_attribute(:'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR)
+            destinations = allow_other_headers? ? default_destinations : AttributeFilter::DST_ERROR_COLLECTOR
+            txn.add_agent_attribute(:'request.headers.referer', referer, destinations)
           end
 
           if request_path
-            txn.add_agent_attribute(:'request.uri',
-              request_path,
-              AttributeFilter::DST_TRANSACTION_TRACER |
-                AttributeFilter::DST_ERROR_COLLECTOR)
+            destinations = if allow_other_headers?
+              default_destinations
+            else
+              AttributeFilter::DST_TRANSACTION_TRACER | AttributeFilter::DST_ERROR_COLLECTOR
+            end
+            txn.add_agent_attribute(:'request.uri', request_path, destinations)
           end
 
           if accept
@@ -64,6 +74,14 @@ module NewRelic
           if request_method
             txn.add_agent_attribute(:'request.method', request_method, default_destinations)
           end
+
+          if port && allow_other_headers?
+            txn.add_agent_attribute(:'request.headers.port', port, default_destinations)
+          end
+
+          other_headers.each do |header, value|
+            txn.add_agent_attribute(header, value, default_destinations)
+          end
         end
 
         private
@@ -116,6 +134,26 @@ module NewRelic
             env[key]
           end
         end
+
+        def allow_other_headers?
+          NewRelic::Agent.config[:allow_all_headers] && !NewRelic::Agent.config[:high_security]
+        end
+
+        def other_headers_from_request(request)
+          # confirm that `request` is an instance of `Rack::Request` by checking
+          # for #each_header
+          return NewRelic::EMPTY_HASH unless allow_other_headers? && request.respond_to?(:each_header)
+
+          request.each_header.with_object({}) do |(header, value), hash|
+            next if BASE_HEADERS.include?(header)
+
+            hash[formatted_header(header)] = value
+          end
+        end
+
+        def formatted_header(raw_name)
+          "#{ATTRIBUTE_PREFIX}#{NewRelic::LanguageSupport.camelize_with_first_letter_downcased(raw_name)}".to_sym
+        end
       end
     end
   end

data/lib/new_relic/agent/transaction.rb

@@ -31,11 +31,12 @@ module NewRelic
       RAKE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Rake/"
       MESSAGE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Message/"
       RACK_PREFIX = "#{CONTROLLER_PREFIX}Rack/"
+      RODA_PREFIX = "#{CONTROLLER_PREFIX}Roda/"
       SINATRA_PREFIX = "#{CONTROLLER_PREFIX}Sinatra/"
       GRAPE_PREFIX = "#{CONTROLLER_PREFIX}Grape/"
       ACTION_CABLE_PREFIX = "#{CONTROLLER_PREFIX}ActionCable/"
 
-      WEB_TRANSACTION_CATEGORIES = [:web, :controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
+      WEB_TRANSACTION_CATEGORIES = %i[action_cable controller grape middleware rack roda sinatra web uri].freeze
 
       MIDDLEWARE_SUMMARY_METRICS = ['Middleware/all'].freeze
       WEB_SUMMARY_METRIC = 'HttpDispatcher'
@@ -289,7 +290,7 @@ module NewRelic
       end
 
       def sampled?
-        return unless Agent.config[:'distributed_tracing.enabled']
+        return false unless Agent.config[:'distributed_tracing.enabled']
 
         if @sampled.nil?
           @sampled = NewRelic::Agent.instance.adaptive_sampler.sampled?
@@ -545,8 +546,8 @@ module NewRelic
       end
 
       def user_defined_rules_ignore?
-        return unless request_path
-        return if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
+        return false unless request_path
+        return false if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
 
         rules.any? do |rule|
           request_path.match(rule)

data/lib/new_relic/agent/utilization/vendor.rb

@@ -75,14 +75,12 @@ module NewRelic
           processed_headers = headers
           raise if processed_headers.value?(:error)
 
-          Timeout.timeout(1) do
-            response = nil
-            Net::HTTP.start(endpoint.host, endpoint.port) do |http|
-              req = Net::HTTP::Get.new(endpoint, processed_headers)
-              response = http.request(req)
-            end
-            response
+          response = nil
+          Net::HTTP.start(endpoint.host, endpoint.port, open_timeout: 1, read_timeout: 1) do |http|
+            req = Net::HTTP::Get.new(endpoint, processed_headers)
+            response = http.request(req)
           end
+          response
         rescue
           NewRelic::Agent.logger.debug("#{vendor_name} environment not detected")
         end

data/lib/new_relic/agent.rb

@@ -58,6 +58,7 @@ module NewRelic
     require 'new_relic/agent/deprecator'
     require 'new_relic/agent/logging'
     require 'new_relic/agent/distributed_tracing'
+    require 'new_relic/agent/attribute_pre_filtering'
     require 'new_relic/agent/attribute_processing'
     require 'new_relic/agent/linking_metadata'
     require 'new_relic/agent/local_log_decorator'
@@ -213,6 +214,17 @@ module NewRelic
       record_metric(metric_name, value)
     end
 
+    def record_instrumentation_invocation(library)
+      record_metric_once("Supportability/#{library}/Invoked")
+    end
+
+    # see ActiveSupport::Inflector.demodulize
+    def base_name(klass_name)
+      return klass_name unless ridx = klass_name.rindex('::')
+
+      klass_name[(ridx + 2), klass_name.length]
+    end
+
     SUPPORTABILITY_INCREMENT_METRIC = 'Supportability/API/increment_metric'.freeze
 
     # Increment a simple counter metric.
@@ -298,7 +310,7 @@ module NewRelic
 
     # Set a callback proc for determining an error's error group name
     #
-    # @param [Proc] the callback proc
+    # @param callback_proc [Proc] the callback proc
     #
     # Typically this method should be called only once to set a callback for
     # use with all noticed errors. If it is called multiple times, each new
@@ -649,6 +661,43 @@ module NewRelic
       end
     end
 
+    # Add custom attributes to log events for the current agent instance.
+    #
+    # @param [Hash] params    A Hash of attributes to attach to log
+    #                         events. The agent accepts up to 240 custom
+    #                         log event attributes.
+    #
+    #                         Keys will be coerced into Strings and must
+    #                         be less than 256 characters. Keys longer
+    #                         than 255 characters will be truncated.
+    #
+    #                         Values may be Strings, Symbols, numeric
+    #                         values or Booleans and must be less than
+    #                         4095 characters. If the value is a String
+    #                         or a Symbol, values longer than 4094
+    #                         characters will be truncated. If the value
+    #                         exceeds 4094 characters and is of a
+    #                         different class, the attribute pair will
+    #                         be dropped.
+    #
+    #                         This API can be called multiple times.
+    #                         If the same key is passed more than once,
+    #                         the value associated with the last call
+    #                         will be preserved.
+    #
+    #                         Attribute pairs with empty or nil contents
+    #                         will be dropped.
+    # @api public
+    def add_custom_log_attributes(params)
+      record_api_supportability_metric(:add_custom_log_attributes)
+
+      if params.is_a?(Hash)
+        NewRelic::Agent.agent.log_event_aggregator.add_custom_attributes(params)
+      else
+        NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_log_attributes. Expected Hash but got #{params.class}.")
+      end
+    end
+
     # Set the user id for the current transaction. When present, this value will be included in the agent attributes for transaction and error events as 'enduser.id'.
     #
     # @param [String] user_id    The user id to add to the current transaction attributes

data/lib/new_relic/cli/command.rb

@@ -60,6 +60,7 @@ module NewRelic
         extra = []
         options = ARGV.options do |opts|
           script_name = File.basename($0)
+          # TODO: MAJOR VERSION - remove newrelic_cmd, deprecated since version 2.13
           if /newrelic_cmd$/.match?(script_name)
             $stdout.puts "warning: the 'newrelic_cmd' script has been renamed 'newrelic'"
             script_name = 'newrelic'

data/lib/new_relic/control/class_methods.rb

@@ -49,19 +49,13 @@ module NewRelic
           # maybe it is already loaded by some external system
           # i.e. rpm_contrib or user extensions?
         end
-        NewRelic::Control::Frameworks.const_get(camelize(framework.to_s))
+        NewRelic::Control::Frameworks.const_get(NewRelic::LanguageSupport.camelize(framework.to_s))
       end
 
       # The root directory for the plugin or gem
       def newrelic_root
         File.expand_path(File.join('..', '..', '..', '..'), __FILE__)
       end
-
-      def camelize(snake_case_name)
-        snake_case_name.gsub(/(\_|^)[a-z]/) do |substring|
-          substring[-1].capitalize!
-        end
-      end
     end
     extend ClassMethods
   end

data/lib/new_relic/control/frameworks/roda.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
+
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Roda
+      class Roda < NewRelic::Control::Frameworks::Ruby
+        protected
+
+        def install_shim
+          super
+          ::Roda.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/dependency_detection.rb

@@ -27,6 +27,8 @@ module DependencyDetection
     @items.each do |item|
       if item.dependencies_satisfied?
         item.execute
+      else
+        item.configure_as_unsatisfied unless item.disabled_configured?
       end
     end
   end
@@ -62,6 +64,10 @@ module DependencyDetection
       !executed and check_dependencies
     end
 
+    def configure_as_unsatisfied
+      NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = :unsatisfied
+    end
+
     def source_location_for(klass, method_name)
       Object.instance_method(:method).bind(klass.allocate).call(method_name).source_location.to_s
     end

data/lib/new_relic/language_support.rb

@@ -78,6 +78,11 @@ module NewRelic
       camelized.split(/\-|\_/).map(&:capitalize).join
     end
 
+    def camelize_with_first_letter_downcased(string)
+      camelized = camelize(string)
+      camelized[0].downcase.concat(camelized[1..-1])
+    end
+
     def bundled_gem?(gem_name)
       defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?(gem_name)
     rescue => e

data/lib/new_relic/latest_changes.rb

@@ -8,7 +8,7 @@ module NewRelic
       File.join(File.dirname(__FILE__), '..', '..', 'CHANGELOG.md')
     end
 
-    FOOTER = <<'EOS'
+    FOOTER = <<EOS
     See https://github.com/newrelic/newrelic-ruby-agent/blob/main/CHANGELOG.md for a full list of
     changes.
 EOS

data/lib/new_relic/noticed_error.rb

@@ -13,7 +13,7 @@ class NewRelic::NoticedError
   attr_accessor :path, :timestamp, :message, :exception_class_name,
     :request_uri, :request_port, :file_name, :line_number,
     :stack_trace, :attributes_from_notice_error, :attributes,
-    :expected
+    :expected, :transaction_id
 
   attr_reader :error_group, :exception_id, :is_internal
 
@@ -45,6 +45,7 @@ class NewRelic::NoticedError
     @is_internal = (exception.class < NewRelic::Agent::InternalAgentError)
 
     extract_class_name_and_message_from(exception)
+    @transaction_id = NewRelic::Agent::Tracer&.current_transaction&.guid
 
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
@@ -79,11 +80,13 @@ class NewRelic::NoticedError
   include NewRelic::Coerce
 
   def to_collector_array(encoder = nil)
-    [NewRelic::Helper.time_to_millis(timestamp),
+    arr = [NewRelic::Helper.time_to_millis(timestamp),
       string(path),
       string(message),
       string(exception_class_name),
       processed_attributes]
+    arr << @transaction_id if @transaction_id
+    arr
   end
 
   # Note that we process attributes lazily and store the result. This is because

data/lib/new_relic/rack/agent_hooks.rb

@@ -23,7 +23,7 @@ module NewRelic::Rack
   #
   class AgentHooks < AgentMiddleware
     def self.needed?
-      !NewRelic::Agent.config[:disable_middleware_instrumentation]
+      NewRelic::Agent.config[:disable_middleware_instrumentation]
     end
 
     def traced_call(env)

data/lib/new_relic/rack/agent_middleware.rb

@@ -26,22 +26,6 @@ module NewRelic
         prefix = ::NewRelic::Agent::Instrumentation::ControllerInstrumentation::TransactionNamer.prefix_for_category(nil, @category)
         "#{prefix}#{self.class.name}/call"
       end
-
-      # If middleware tracing is disabled, we'll still inject our agent-specific
-      # middlewares, and still trace those, but we don't want to capture HTTP
-      # response codes, since middleware that's outside of ours might change the
-      # response code before it goes back to the client.
-      def capture_http_response_code(state, result)
-        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
-
-        super
-      end
-
-      def capture_response_content_type(state, result)
-        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
-
-        super
-      end
     end
   end
 end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -143,7 +143,7 @@ module NewRelic
       end
 
       # Per "The Response > The Body" section of Rack spec, we should close
-      # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
+      # if our response is able. https://github.com/rack/rack/blob/main/SPEC.rdoc
       def close_old_response(response)
         response.close if response.respond_to?(:close)
       end

data/lib/new_relic/supportability_helper.rb

@@ -13,6 +13,7 @@ module NewRelic
       :insert_distributed_trace_headers,
       :accept_distributed_trace_headers,
       :add_custom_attributes,
+      :add_custom_log_attributes,
       :add_custom_span_attributes,
       :add_instrumentation,
       :add_method_tracer,
@@ -45,6 +46,7 @@ module NewRelic
       :recording_web_transaction?,
       :require_test_helper,
       :set_error_group_callback,
+      :set_segment_callback,
       :set_sql_obfuscator,
       :set_transaction_name,
       :set_user_id,

data/lib/new_relic/traced_thread.rb

@@ -22,15 +22,14 @@ module NewRelic
     # @api public
     def initialize(*args, &block)
       NewRelic::Agent.record_api_supportability_metric(:traced_thread)
-      traced_block = create_traced_block(*args, &block)
+      traced_block = create_traced_block(&block)
       super(*args, &traced_block)
     end
 
-    def create_traced_block(*args, &block)
+    def create_traced_block(&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,
         segment_name: 'Ruby/TracedThread',
         &block
       )

data/lib/new_relic/version.rb

@@ -6,8 +6,8 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 9
-    MINOR = 2
-    TINY = 2
+    MINOR = 5
+    TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
   end