newrelic_rpm 6.15.0 → 9.7.1

data/lib/new_relic/agent/log_once.rb

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

data/lib/new_relic/agent/log_priority.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/agent/event_aggregator'
+
+# Stateless calculation of priority for a given log event
+module NewRelic
+  module Agent
+    module LogPriority
+      extend self
+
+      def priority_for(txn)
+        return txn.priority if txn
+
+        rand.round(NewRelic::PRIORITY_PRECISION)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/logging.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'json'
 require 'new_relic/agent/hostname'
@@ -8,7 +8,6 @@ require 'new_relic/agent/hostname'
 module NewRelic
   module Agent
     module Logging
-
       # This class can be used as the formatter for an existing logger.  It
       # decorates log messages with trace and entity metadata, and formats each
       # log messages as a JSON object.
@@ -23,83 +22,128 @@ module NewRelic
       #
       # @api public
       class DecoratingFormatter < ::Logger::Formatter
-        TIMESTAMP_KEY = 'timestamp'.freeze
-        MESSAGE_KEY = 'message'.freeze
-        LOG_LEVEL_KEY = 'log.level'.freeze
-        LOG_NAME_KEY = 'logger.name'.freeze
-        NEWLINE = "\n".freeze
-
-        QUOTE = '"'.freeze
-        COLON = ':'.freeze
-        COMMA = ','.freeze
-        CLOSING_BRACE = '}'.freeze
+        MESSAGE_ELEMENT = 'message'
+        LOG_LEVEL_ELEMENT = 'log_level'
+        PROG_NAME_ELEMENT = 'prog_name'
+        ELEMENTS = ['app_name', 'entity_type', 'hostname', 'entity_guid', 'trace_id', 'span_id', MESSAGE_ELEMENT,
+          LOG_LEVEL_ELEMENT, PROG_NAME_ELEMENT].freeze
+        TIMESTAMP_KEY = 'timestamp'
+        MESSAGE_KEY = 'message'
+        LOG_LEVEL_KEY = 'log.level'
+        LOG_NAME_KEY = 'logger.name'
+        NEWLINE = "\n"
+
+        QUOTE = '"'
+        COLON = ':'
+        COMMA = ','
+        CLOSING_BRACE = '}'
+        REPLACEMENT_CHAR = '�'
 
         def initialize
-          Agent.config.register_callback :app_name do
+          Agent.config.register_callback(:app_name) do
             @app_name = nil
           end
         end
 
-        def call severity, time, progname, msg
-          message = '{'
-          if app_name
-            add_key_value message, ENTITY_NAME_KEY, app_name
-            message << COMMA
+        def call(severity, time, progname, msg)
+          message = +'{'
+          ELEMENTS.each do |element|
+            args = case element
+                   when MESSAGE_ELEMENT then [message, msg]
+                   when LOG_LEVEL_ELEMENT then [message, severity]
+                   when PROG_NAME_ELEMENT then [message, progname]
+                   else [message]
+            end
+
+            send("add_#{element}", *args)
           end
-          add_key_value message, ENTITY_TYPE_KEY, ENTITY_TYPE
           message << COMMA
-          add_key_value message, HOSTNAME_KEY, Hostname.get
+          message << QUOTE << TIMESTAMP_KEY << QUOTE << COLON << (time.to_f * 1000).round.to_s
+          message << CLOSING_BRACE << NEWLINE
+        end
 
-          if entity_guid = Agent.config[:entity_guid]
-            message << COMMA
-            add_key_value message, ENTITY_GUID_KEY, entity_guid
-          end
+        def clear_tags!
+          # No-op; just avoiding issues with act-fluent-logger-rails
+        end
 
-          if trace_id = Tracer.trace_id
-            message << COMMA
-            add_key_value message, TRACE_ID_KEY, trace_id
-          end
-          if span_id = Tracer.span_id
-            message << COMMA
-            add_key_value message, SPAN_ID_KEY, span_id
-          end
+        private
+
+        def add_app_name(message)
+          return unless app_name
 
+          add_key_value(message, ENTITY_NAME_KEY, app_name)
+          message << COMMA
+        end
+
+        def add_entity_type(message)
+          add_key_value(message, ENTITY_TYPE_KEY, ENTITY_TYPE)
+          message << COMMA
+        end
+
+        def add_hostname(message)
+          add_key_value(message, HOSTNAME_KEY, Hostname.get)
+        end
+
+        def add_entity_guid(message)
+          return unless entity_guid = Agent.config[:entity_guid]
+
+          message << COMMA
+          add_key_value(message, ENTITY_GUID_KEY, entity_guid)
+        end
+
+        def add_trace_id(message)
+          return unless trace_id = Tracer.trace_id
+
+          message << COMMA
+          add_key_value(message, TRACE_ID_KEY, trace_id)
+        end
+
+        def add_span_id(message)
+          return unless span_id = Tracer.span_id
+
+          message << COMMA
+          add_key_value(message, SPAN_ID_KEY, span_id)
+        end
+
+        def add_message(message, msg)
           message << COMMA
           message << QUOTE << MESSAGE_KEY << QUOTE << COLON << escape(msg)
           message << COMMA
-          add_key_value message, LOG_LEVEL_KEY, severity
-          if progname
-            message << COMMA
-            add_key_value message, LOG_NAME_KEY, progname
-          end
+        end
+
+        def add_log_level(message, severity)
+          add_key_value(message, LOG_LEVEL_KEY, severity)
+        end
+
+        def add_prog_name(message, progname)
+          return unless progname
 
           message << COMMA
-          message << QUOTE << TIMESTAMP_KEY << QUOTE << COLON << (time.to_f * 1000).round.to_s
-          message << CLOSING_BRACE << NEWLINE
+          add_key_value(message, LOG_NAME_KEY, progname)
         end
 
         def app_name
           @app_name ||= Agent.config[:app_name][0]
         end
 
-        def add_key_value message, key, value
+        def add_key_value(message, key, value)
           message << QUOTE << key << QUOTE << COLON << QUOTE << value << QUOTE
         end
 
-        def escape message
-          if String === message
-            message.to_json
-          else
-            message.inspect.to_json
+        def escape(message)
+          message = message.to_s unless message.is_a?(String)
+          unless message.encoding == Encoding::UTF_8 && message.valid_encoding?
+            message = message.encode(
+              Encoding::UTF_8,
+              invalid: :replace,
+              undef: :replace,
+              replace: REPLACEMENT_CHAR
+            )
           end
-        end
-
-        def clear_tags!
-          # No-op; just avoiding issues with act-fluent-logger-rails
+          message.to_json
         end
       end
 
-
       # This logger decorates logs with trace and entity metadata, and emits log
       # messages formatted as JSON objects.  It extends the Logger class from
       # the Ruby standard library, and accepts the same constructor parameters.
@@ -116,13 +160,12 @@ module NewRelic
       #
       # @api public
       class DecoratingLogger < (defined?(::ActiveSupport) && defined?(::ActiveSupport::Logger) ? ::ActiveSupport::Logger : ::Logger)
-
         alias :write :info
 
         # Positional and Keyword arguments are separated beginning with Ruby 2.7
         # Signature of ::Logger constructor changes in Ruby 2.4 to have both positional and keyword args
         # We pivot on Ruby 2.7 for widest supportability with least amount of hassle.
-        if RUBY_VERSION < "2.7.0"
+        if RUBY_VERSION < '2.7.0'
           def initialize(*args)
             super(*args)
             self.formatter = DecoratingFormatter.new

data/lib/new_relic/agent/memory_logger.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # Base class for startup logging and testing in multiverse
 
@@ -44,7 +44,7 @@ module NewRelic
         messages << [:debug, msgs, blk]
       end
 
-      def log_exception(level, e, backtrace_level=level)
+      def log_exception(level, e, backtrace_level = level)
         messages << [:log_exception, [level, e, backtrace_level]]
       end
 

data/lib/new_relic/agent/messaging.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
@@ -15,11 +14,11 @@ module NewRelic
     module Messaging
       extend self
 
-      RABBITMQ_TRANSPORT_TYPE = "RabbitMQ"
+      RABBITMQ_TRANSPORT_TYPE = 'RabbitMQ'
 
       ATTR_DESTINATION = AttributeFilter::DST_TRANSACTION_EVENTS |
-                         AttributeFilter::DST_TRANSACTION_TRACER |
-                         AttributeFilter::DST_ERROR_COLLECTOR
+        AttributeFilter::DST_TRANSACTION_TRACER |
+        AttributeFilter::DST_ERROR_COLLECTOR
 
       # Start a MessageBroker segment configured to trace a messaging action.
       # Finishing this segment will handle timing and recording of the proper
@@ -53,12 +52,12 @@ module NewRelic
       # @api public
       #
       def start_message_broker_segment(action: nil,
-                                       library: nil,
-                                       destination_type: nil,
-                                       destination_name: nil,
-                                       headers: nil,
-                                       parameters: nil,
-                                       start_time: nil)
+        library: nil,
+        destination_type: nil,
+        destination_name: nil,
+        headers: nil,
+        parameters: nil,
+        start_time: nil)
 
         Tracer.start_message_broker_segment(
           action: action,
@@ -110,52 +109,49 @@ module NewRelic
       #
       # @api public
       #
-      def wrap_message_broker_consume_transaction library: nil,
-                                                  destination_type: nil,
-                                                  destination_name: nil,
-                                                  headers: nil,
-                                                  routing_key: nil,
-                                                  queue_name: nil,
-                                                  exchange_type: nil,
-                                                  reply_to: nil,
-                                                  correlation_id: nil
-
-        # ruby 2.0.0 does not support required kwargs
-        raise ArgumentError, 'missing required argument: library' if library.nil?
-        raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-        raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+      def wrap_message_broker_consume_transaction(library:,
+        destination_type:,
+        destination_name:,
+        headers: nil,
+        routing_key: nil,
+        queue_name: nil,
+        exchange_type: nil,
+        reply_to: nil,
+        correlation_id: nil)
 
         state = Tracer.state
         return yield if state.current_transaction
+
         txn = nil
 
         begin
-          txn_name = transaction_name library, destination_type, destination_name
+          txn_name = transaction_name(library, destination_type, destination_name)
 
-          txn = Tracer.start_transaction name: txn_name, category: :message
+          txn = Tracer.start_transaction(name: txn_name, category: :message)
 
           if headers
-            txn.distributed_tracer.consume_message_headers headers, state, RABBITMQ_TRANSPORT_TYPE
+            txn.distributed_tracer.consume_message_headers(headers, state, RABBITMQ_TRANSPORT_TYPE)
             CrossAppTracing.reject_messaging_cat_headers(headers).each do |k, v|
-              txn.add_agent_attribute :"message.headers.#{k}", v, AttributeFilter::DST_NONE unless v.nil?
+              txn.add_agent_attribute(:"message.headers.#{k}", v, AttributeFilter::DST_NONE) unless v.nil?
             end
           end
 
-          txn.add_agent_attribute :'message.routingKey', routing_key, ATTR_DESTINATION if routing_key
-          txn.add_agent_attribute :'message.exchangeType', exchange_type, AttributeFilter::DST_NONE if exchange_type
-          txn.add_agent_attribute :'message.correlationId', correlation_id, AttributeFilter::DST_NONE if correlation_id
-          txn.add_agent_attribute :'message.queueName', queue_name, ATTR_DESTINATION if queue_name
-          txn.add_agent_attribute :'message.replyTo', reply_to, AttributeFilter::DST_NONE if reply_to
+          txn.add_agent_attribute(:'message.routingKey', routing_key, ATTR_DESTINATION) if routing_key
+          txn.add_agent_attribute(:'message.exchangeType', exchange_type, AttributeFilter::DST_NONE) if exchange_type
+          txn.add_agent_attribute(:'message.correlationId', correlation_id, AttributeFilter::DST_NONE) if correlation_id
+          txn.add_agent_attribute(:'message.queueName', queue_name, ATTR_DESTINATION) if queue_name
+          txn.add_agent_attribute(:'message.replyTo', reply_to, AttributeFilter::DST_NONE) if reply_to
         rescue => e
-          NewRelic::Agent.logger.error "Error starting Message Broker consume transaction", e
+          NewRelic::Agent.logger.error('Error starting Message Broker consume transaction', e)
         end
 
         yield
       ensure
         begin
-          txn.finish if txn
+          # the following line needs else branch coverage
+          txn.finish if txn # rubocop:disable Style/SafeNavigation
         rescue => e
-          NewRelic::Agent.logger.error "Error stopping Message Broker consume transaction", e
+          NewRelic::Agent.logger.error('Error stopping Message Broker consume transaction', e)
         end
       end
 
@@ -185,20 +181,18 @@ module NewRelic
       #
       # @api public
       #
-      def start_amqp_publish_segment(library: nil,
-                                     destination_name: nil,
-                                     headers: nil,
-                                     routing_key: nil,
-                                     reply_to: nil,
-                                     correlation_id: nil,
-                                     exchange_type: nil)
-
-        # ruby 2.0.0 does not support required kwargs
-        raise ArgumentError, 'missing required argument: library' if library.nil?
-        raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+      def start_amqp_publish_segment(library:,
+        destination_name:,
+        headers: nil,
+        routing_key: nil,
+        reply_to: nil,
+        correlation_id: nil,
+        exchange_type: nil)
+
         raise ArgumentError, 'missing required argument: headers' if headers.nil? && CrossAppTracing.cross_app_enabled?
 
-        original_headers = headers.nil? ? nil : headers.dup
+        # The following line needs else branch coverage
+        original_headers = headers.nil? ? nil : headers.dup # rubocop:disable Style/SafeNavigation
 
         segment = Tracer.start_message_broker_segment(
           action: :produce,
@@ -247,19 +241,13 @@ module NewRelic
       #
       # @api public
       #
-      def start_amqp_consume_segment(library: nil,
-                                     destination_name: nil,
-                                     delivery_info: nil,
-                                     message_properties: nil,
-                                     exchange_type: nil,
-                                     queue_name: nil,
-                                     start_time: nil)
-
-        # ruby 2.0.0 does not support required kwargs
-        raise ArgumentError, 'missing required argument: library' if library.nil?
-        raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
-        raise ArgumentError, 'missing required argument: delivery_info' if delivery_info.nil?
-        raise ArgumentError, 'missing required argument: message_properties' if message_properties.nil?
+      def start_amqp_consume_segment(library:,
+        destination_name:,
+        delivery_info:,
+        message_properties:,
+        exchange_type: nil,
+        queue_name: nil,
+        start_time: nil)
 
         segment = Tracer.start_message_broker_segment(
           action: :consume,
@@ -272,8 +260,8 @@ module NewRelic
 
         if segment_parameters_enabled?
           if message_properties[:headers] && !message_properties[:headers].empty?
-            non_cat_headers = CrossAppTracing.reject_messaging_cat_headers message_properties[:headers]
-            non_synth_headers = SyntheticsMonitor.reject_messaging_synthetics_header non_cat_headers
+            non_cat_headers = CrossAppTracing.reject_messaging_cat_headers(message_properties[:headers])
+            non_synth_headers = SyntheticsMonitor.reject_messaging_synthetics_header(non_cat_headers)
             segment.params[:headers] = non_synth_headers unless non_synth_headers.empty?
           end
 
@@ -300,7 +288,7 @@ module NewRelic
       # @param message_properties [Hash] Metadata about the message and opaque
       #   application-level data (optional)
       #
-      # @param exchange_type [Symbol] Type of AMQP exchange the message was recieved
+      # @param exchange_type [Symbol] Type of AMQP exchange the message was received
       #   from (see NewRelic::Agent::Transaction::MessageBrokerSegment::DESTINATION_TYPES)
       #
       # @param queue_name [String] name of the AMQP queue on which the message was
@@ -314,24 +302,23 @@ module NewRelic
       #
       # @api public
       #
-      def wrap_amqp_consume_transaction library: nil,
-                                        destination_name: nil,
-                                        delivery_info: nil,
-                                        message_properties: nil,
-                                        exchange_type: nil,
-                                        queue_name: nil,
-                                        &block
-
-        wrap_message_broker_consume_transaction library: library,
-                                                destination_type: :exchange,
-                                                destination_name: Instrumentation::Bunny.exchange_name(destination_name),
-                                                routing_key: delivery_info[:routing_key],
-                                                reply_to: message_properties[:reply_to],
-                                                queue_name: queue_name,
-                                                exchange_type: exchange_type,
-                                                headers: message_properties[:headers],
-                                                correlation_id: message_properties[:correlation_id],
-                                                &block
+      def wrap_amqp_consume_transaction(library: nil,
+        destination_name: nil,
+        delivery_info: nil,
+        message_properties: nil,
+        exchange_type: nil,
+        queue_name: nil,
+        &block)
+
+        wrap_message_broker_consume_transaction(library: library,
+          destination_type: :exchange,
+          destination_name: Instrumentation::Bunny.exchange_name(destination_name),
+          routing_key: delivery_info[:routing_key],
+          reply_to: message_properties[:reply_to],
+          queue_name: queue_name,
+          exchange_type: exchange_type,
+          headers: message_properties[:headers],
+          correlation_id: message_properties[:correlation_id], &block)
       end
 
       private
@@ -340,11 +327,11 @@ module NewRelic
         NewRelic::Agent.config[:'message_tracer.segment_parameters.enabled']
       end
 
-      def transaction_name library, destination_type, destination_name
+      def transaction_name(library, destination_type, destination_name)
         transaction_name = Transaction::MESSAGE_PREFIX + library
-        transaction_name << Transaction::MessageBrokerSegment::SLASH
+        transaction_name << NewRelic::SLASH
         transaction_name << Transaction::MessageBrokerSegment::TYPES[destination_type]
-        transaction_name << Transaction::MessageBrokerSegment::SLASH
+        transaction_name << NewRelic::SLASH
 
         case destination_type
         when :queue
@@ -366,7 +353,6 @@ module NewRelic
 
         transaction_name
       end
-
     end
   end
 end