newrelic_rpm 9.2.0 → 9.5.0

data/lib/new_relic/agent/log_event_attributes.rb

@@ -0,0 +1,115 @@
+# 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
+    class LogEventAttributes
+      MAX_ATTRIBUTE_COUNT = 240 # limit is 255, assume we send 15
+      ATTRIBUTE_KEY_CHARACTER_LIMIT = 255
+      ATTRIBUTE_VALUE_CHARACTER_LIMIT = 4094
+
+      def add_custom_attributes(attributes)
+        return if defined?(@custom_attribute_limit_reached) && @custom_attribute_limit_reached
+
+        attributes.each do |key, value|
+          next if absent?(key) || absent?(value)
+
+          add_custom_attribute(key, value)
+        end
+      end
+
+      def custom_attributes
+        @custom_attributes ||= {}
+      end
+
+      private
+
+      class TruncationError < StandardError
+        attr_reader :attribute, :limit
+
+        def initialize(attribute, limit, msg = "Can't truncate")
+          @attribute = attribute
+          @limit = limit
+          super(msg)
+        end
+      end
+
+      class InvalidTypeError < StandardError
+        attr_reader :attribute
+
+        def initialize(attribute, msg = 'Invalid attribute type')
+          @attribute = attribute
+          super(msg)
+        end
+      end
+
+      def absent?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+      def add_custom_attribute(key, value)
+        if custom_attributes.size >= MAX_ATTRIBUTE_COUNT
+          NewRelic::Agent.logger.warn(
+            'Too many custom log attributes defined. ' \
+            "Only taking the first #{MAX_ATTRIBUTE_COUNT}."
+          )
+          @custom_attribute_limit_reached = true
+          return
+        end
+
+        @custom_attributes.merge!(truncate_attributes(key_to_string(key), value))
+      end
+
+      def key_to_string(key)
+        key.is_a?(String) ? key : key.to_s
+      end
+
+      def truncate_attribute(attribute, limit)
+        case attribute
+        when Integer
+          if attribute.digits.length > limit
+            raise TruncationError.new(attribute, limit)
+          end
+        when Float
+          if attribute.to_s.length > limit
+            raise TruncationError.new(attribute, limit)
+          end
+        when String, Symbol
+          if attribute.length > limit
+            attribute = attribute.slice(0..(limit - 1))
+          end
+        when TrueClass, FalseClass
+          attribute
+        else
+          raise InvalidTypeError.new(attribute)
+        end
+
+        attribute
+      end
+
+      def truncate_attributes(key, value)
+        key = truncate_attribute(key, ATTRIBUTE_KEY_CHARACTER_LIMIT)
+        value = truncate_attribute(value, ATTRIBUTE_VALUE_CHARACTER_LIMIT)
+
+        {key => value}
+      rescue TruncationError => e
+        NewRelic::Agent.logger.warn(
+          "Dropping custom log attribute #{key} => #{value} \n" \
+          "Length exceeds character limit of #{e.limit}. " \
+          "Can't truncate: #{e.attribute}"
+        )
+
+        {}
+      rescue InvalidTypeError => e
+        NewRelic::Agent.logger.warn(
+          "Dropping custom log attribute #{key} => #{value} \n" \
+          "Invalid type of #{e.attribute.class} given. " \
+          "Can't send #{e.attribute}."
+        )
+
+        {}
+      end
+    end
+  end
+end

data/lib/new_relic/agent/logging.rb

@@ -62,6 +62,10 @@ module NewRelic
           message << CLOSING_BRACE << NEWLINE
         end
 
+        def clear_tags!
+          # No-op; just avoiding issues with act-fluent-logger-rails
+        end
+
         private
 
         def add_app_name(message)
@@ -138,10 +142,6 @@ module NewRelic
           end
           message.to_json
         end
-
-        def clear_tags!
-          # No-op; just avoiding issues with act-fluent-logger-rails
-        end
       end
 
       # This logger decorates logs with trace and entity metadata, and emits log

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -46,13 +46,15 @@ module NewRelic
         cache_key = "#{object.object_id}#{method_name}".freeze
         return @code_information[cache_key] if @code_information.key?(cache_key)
 
-        namespace, location, is_class_method = namespace_and_location(object, method_name.to_sym)
+        info = namespace_and_location(object, method_name.to_sym)
+        return ::NewRelic::EMPTY_HASH if info.empty?
 
+        namespace, location, is_class_method = info
         @code_information[cache_key] = {filepath: location.first,
                                         lineno: location.last,
                                         function: "#{'self.' if is_class_method}#{method_name}",
                                         namespace: namespace}.freeze
-      rescue => e
+      rescue StandardError => e
         ::NewRelic::Agent.logger.warn("Unable to determine source code info for '#{object}', " \
                                         "method '#{method_name}' - #{e.class}: #{e.message}")
         ::NewRelic::Agent.increment_metric(SOURCE_CODE_INFORMATION_FAILURE_METRIC, 1)
@@ -66,10 +68,10 @@ module NewRelic
       end
 
       # The string representation of a singleton class looks like
-      # '#<Class:MyModule::MyClass>'. Return the 'MyModule::MyClass' part of
-      # that string
+      # '#<Class:MyModule::MyClass>', or '#<Class:MyModule::MyClass(id: integer, attribute: string)>'
+      # Return the 'MyModule::MyClass' part of that string
       def klass_name(object)
-        name = Regexp.last_match(1) if object.to_s =~ /^#<Class:(.*)>$/
+        name = Regexp.last_match(1) if object.to_s =~ /^#<Class:([\w:]+).*>$/
         return name if name
 
         raise "Unable to glean a class name from string '#{object}'"
@@ -101,6 +103,9 @@ module NewRelic
         klass = object.singleton_class? ? klassify_singleton(object) : object
         name = klass.name || '(Anonymous)'
         is_class_method = false
+
+        return controller_info(klass, name, is_class_method) if controller_without_method?(klass, method_name)
+
         method = if (klass.instance_methods + klass.private_instance_methods).include?(method_name)
           klass.instance_method(method_name)
         else
@@ -109,6 +114,22 @@ module NewRelic
         end
         [name, method.source_location, is_class_method]
       end
+
+      # Rails controllers can be a special case because by default, controllers in Rails
+      # automatically render views with names that correspond to valid routes. This means
+      # that a controller method may not have a corresponding method in the controller class.
+      def controller_without_method?(klass, method_name)
+        defined?(Rails) &&
+          defined?(ApplicationController) &&
+          klass < ApplicationController &&
+          !klass.method_defined?(method_name)
+      end
+
+      def controller_info(klass, name, is_class_method)
+        path = Rails.root.join("app/controllers/#{klass.name.underscore}.rb")
+
+        File.exist?(path) ? [name, [path.to_s, 1], is_class_method] : []
+      end
     end
   end
 end

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,12 +420,12 @@ 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
+              if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn
                 current_txn.async = true
                 segment_name += "/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']

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/tracing.rb

@@ -29,6 +29,12 @@ module NewRelic
           else
             segment.record_on_finish = true
             ::NewRelic::Agent.logger.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
+
+            if finished?
+              ::NewRelic::Agent.logger.debug("Transaction #{best_name} has finished but segments still being created, resetting state.")
+              NewRelic::Agent::Tracer.state.reset
+              NewRelic::Agent.record_metric('Supportability/Transaction/SegmentLimitReachedAfterFinished/ResetState', 1)
+            end
           end
           segment.transaction_assigned
         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?
@@ -439,6 +440,10 @@ module NewRelic
         segments.first
       end
 
+      def finished?
+        initial_segment&.finished?
+      end
+
       def create_initial_segment(options = {})
         segment = create_segment(@default_name, options)
         segment.record_scoped_metric = false
@@ -541,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'