newrelic_rpm 6.8.0.360 → 8.13.1

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/rpm/blob/master/LICENSE for complete details.
+# 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.
@@ -33,48 +32,49 @@ module NewRelic
         COLON = ':'.freeze
         COMMA = ','.freeze
         CLOSING_BRACE = '}'.freeze
+        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 = '{'
+        def call(severity, time, progname, msg)
+          message = String.new('{')
           if app_name
-            add_key_value message, ENTITY_NAME_KEY, app_name
+            add_key_value(message, ENTITY_NAME_KEY, app_name)
             message << COMMA
           end
-          add_key_value message, ENTITY_TYPE_KEY, ENTITY_TYPE
+          add_key_value(message, ENTITY_TYPE_KEY, ENTITY_TYPE)
           message << COMMA
-          add_key_value message, HOSTNAME_KEY, Hostname.get
+          add_key_value(message, HOSTNAME_KEY, Hostname.get)
 
           if entity_guid = Agent.config[:entity_guid]
             message << COMMA
-            add_key_value message, ENTITY_GUID_KEY, entity_guid
+            add_key_value(message, ENTITY_GUID_KEY, entity_guid)
           end
 
           if trace_id = Tracer.trace_id
             message << COMMA
-            add_key_value message, TRACE_ID_KEY, trace_id
+            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
+            add_key_value(message, SPAN_ID_KEY, span_id)
           end
 
           message << COMMA
           message << QUOTE << MESSAGE_KEY << QUOTE << COLON << escape(msg)
           message << COMMA
-          add_key_value message, LOG_LEVEL_KEY, severity
+          add_key_value(message, LOG_LEVEL_KEY, severity)
           if progname
             message << COMMA
-            add_key_value message, LOG_NAME_KEY, progname
+            add_key_value(message, LOG_NAME_KEY, progname)
           end
 
           message << COMMA
-          message << QUOTE << TIMESTAMP_KEY << QUOTE << COLON << time.to_f.to_s
+          message << QUOTE << TIMESTAMP_KEY << QUOTE << COLON << (time.to_f * 1000).round.to_s
           message << CLOSING_BRACE << NEWLINE
         end
 
@@ -82,16 +82,21 @@ module NewRelic
           @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
+          message.to_json
         end
 
         def clear_tags!
@@ -99,7 +104,6 @@ module NewRelic
         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,12 +120,21 @@ module NewRelic
       #
       # @api public
       class DecoratingLogger < (defined?(::ActiveSupport) && defined?(::ActiveSupport::Logger) ? ::ActiveSupport::Logger : ::Logger)
-
         alias :write :info
 
-        def initialize *args
-          super
-          self.formatter = DecoratingFormatter.new
+        # 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"
+          def initialize(*args)
+            super(*args)
+            self.formatter = DecoratingFormatter.new
+          end
+        else
+          def initialize(*args, **kwargs)
+            super(*args, **kwargs)
+            self.formatter = DecoratingFormatter.new
+          end
         end
       end
     end

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/rpm/blob/master/LICENSE for complete details.
+# 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,6 +1,7 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
 require 'new_relic/agent/transaction'
 
 module NewRelic
@@ -13,11 +14,11 @@ module NewRelic
     module Messaging
       extend self
 
-      ATTR_DESTINATION = AttributeFilter::DST_TRANSACTION_EVENTS |
-                         AttributeFilter::DST_TRANSACTION_TRACER |
-                         AttributeFilter::DST_ERROR_COLLECTOR
+      RABBITMQ_TRANSPORT_TYPE = "RabbitMQ"
 
-      EMPTY_STRING = ''.freeze
+      ATTR_DESTINATION = AttributeFilter::DST_TRANSACTION_EVENTS |
+        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
@@ -51,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,
@@ -108,44 +109,40 @@ 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
-            consume_message_headers headers, txn, state
+            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
@@ -153,7 +150,7 @@ module NewRelic
         begin
           txn.finish if txn
         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
 
@@ -183,17 +180,14 @@ 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
@@ -245,19 +239,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,
@@ -270,8 +258,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
 
@@ -298,7 +286,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
@@ -312,24 +300,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
@@ -338,7 +325,7 @@ 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 << Transaction::MessageBrokerSegment::TYPES[destination_type]
@@ -364,77 +351,6 @@ module NewRelic
 
         transaction_name
       end
-
-      RABBITMQ_TRANSPORT_TYPE = "RabbitMQ".freeze
-
-      def consume_message_headers headers, transaction, state
-        consume_distributed_tracing_headers headers, transaction
-        consume_cross_app_tracing_headers headers, state
-
-        assign_synthetics_header headers[CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER], transaction
-      rescue => e
-        NewRelic::Agent.logger.error "Error in consume_message_headers", e
-      end
-
-      def decode_txn_info headers, transaction_state
-        encoded_id = headers[CrossAppTracing::NR_MESSAGE_BROKER_ID_HEADER]
-
-        decoded_id = if encoded_id.nil?
-                       EMPTY_STRING
-                     else
-                       CrossAppTracing.obfuscator.deobfuscate(encoded_id)
-                     end
-
-        if CrossAppTracing.trusted_valid_cross_app_id?(decoded_id) && transaction_state.current_transaction
-          txn_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER]
-          txn        = transaction_state.current_transaction
-          txn_info   = ::JSON.load(CrossAppTracing.obfuscator.deobfuscate(txn_header))
-          payload    = CrossAppPayload.new(decoded_id, txn, txn_info)
-
-          txn.cross_app_payload = payload
-        end
-      rescue => e
-        NewRelic::Agent.logger.debug("Failure deserializing encoded header in #{self.class}, #{e.class}, #{e.message}")
-        nil
-      end
-
-      CANDIDATE_HEADERS = ['newrelic'.freeze, 'NEWRELIC'.freeze, 'Newrelic'.freeze]
-
-      def consume_distributed_tracing_headers headers, transaction
-        if Agent.config[:'distributed_tracing.enabled']
-          return unless newrelic_trace_key = CANDIDATE_HEADERS.detect do |key|
-            headers.has_key?(key)
-          end
-
-          return unless payload = headers[newrelic_trace_key]
-
-          if transaction.accept_distributed_trace_payload payload
-            transaction.distributed_trace_payload.caller_transport_type = RABBITMQ_TRANSPORT_TYPE
-          end
-        end
-      end
-
-      def consume_cross_app_tracing_headers headers, state
-        if CrossAppTracing.cross_app_enabled? && CrossAppTracing.message_has_crossapp_request_header?(headers)
-          decode_txn_info headers, state
-          CrossAppTracing.assign_intrinsic_transaction_attributes state
-        end
-      end
-
-      def assign_synthetics_header synthetics_header, transaction
-        if synthetics_header and
-           incoming_payload = ::JSON.load(CrossAppTracing.obfuscator.deobfuscate(synthetics_header)) and
-           SyntheticsMonitor.is_valid_payload?(incoming_payload) and
-           SyntheticsMonitor.is_supported_version?(incoming_payload) and
-           SyntheticsMonitor.is_trusted?(incoming_payload)
-
-          transaction.raw_synthetics_header = synthetics_header
-          transaction.synthetics_payload = incoming_payload
-        end
-      rescue => e
-        NewRelic::Agent.logger.error "Error in assign_synthetics_header", e
-      end
-
     end
   end
 end