newrelic_rpm 6.6.0.358 → 6.11.0

data/lib/new_relic/agent/database.rb

@@ -133,10 +133,9 @@ module NewRelic
       ]
 
       SQL_COMMENT_REGEX = Regexp.new('/\*.*?\*/', Regexp::MULTILINE).freeze
-      EMPTY_STRING      = ''.freeze
 
       def parse_operation_from_query(sql)
-        sql = Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, EMPTY_STRING)
+        sql = Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, NewRelic::EMPTY_STR)
         if sql =~ /(\w+)/
           op = $1.downcase
           return op if KNOWN_OPERATIONS.include?(op)

data/lib/new_relic/agent/datastores/mongo.rb

@@ -12,7 +12,7 @@ module NewRelic
         end
 
         def self.is_monitoring_enabled?
-          defined?(::Mongo::Monitoring)
+          defined?(::Mongo::Monitoring) # @since 2.1.0
         end
 
         def self.is_unsupported_2x?

data/lib/new_relic/agent/datastores/mongo/event_formatter.rb

@@ -13,7 +13,7 @@ module NewRelic
           OBFUSCATE_KEYS = [ 'filter', 'query', 'pipeline' ].freeze
 
           # Keys that will get completely removed from the statement.
-          BLACKLISTED_KEYS = [ 'deletes', 'documents', 'updates' ].freeze
+          DENYLISTED_KEYS = [ 'deletes', 'documents', 'updates' ].freeze
 
           def self.format(command_name, database_name, command)
             return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
@@ -25,7 +25,7 @@ module NewRelic
             }
 
             command.each do |key, value|
-              next if BLACKLISTED_KEYS.include?(key)
+              next if DENYLISTED_KEYS.include?(key)
               if OBFUSCATE_KEYS.include?(key)
                 obfuscated = obfuscate(value)
                 result[key] = obfuscated if obfuscated

data/lib/new_relic/agent/datastores/mongo/obfuscator.rb

@@ -8,31 +8,31 @@ module NewRelic
       module Mongo
         module Obfuscator
 
-          WHITELIST = [:operation].freeze
+          ALLOWLIST = [:operation].freeze
 
-          def self.obfuscate_statement(source, whitelist = WHITELIST)
+          def self.obfuscate_statement(source, allowlist = ALLOWLIST)
             if source.is_a? Hash
               obfuscated = {}
               source.each do |key, value|
-                if whitelist.include?(key)
+                if allowlist.include?(key)
                   obfuscated[key] = value
                 else
-                  obfuscated[key] = obfuscate_value(value, whitelist)
+                  obfuscated[key] = obfuscate_value(value, allowlist)
                 end
               end
               obfuscated
             else
-              obfuscate_value(source, whitelist)
+              obfuscate_value(source, allowlist)
             end
           end
 
           QUESTION_MARK = '?'.freeze
 
-          def self.obfuscate_value(value, whitelist = WHITELIST)
+          def self.obfuscate_value(value, allowlist = ALLOWLIST)
             if value.is_a?(Hash)
-              obfuscate_statement(value, whitelist)
+              obfuscate_statement(value, allowlist)
             elsif value.is_a?(Array)
-              value.map {|v| obfuscate_value(v, whitelist)}
+              value.map {|v| obfuscate_value(v, allowlist)}
             else
               QUESTION_MARK
             end

data/lib/new_relic/agent/distributed_tracing.rb

@@ -1,8 +1,15 @@
 # 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.
+# frozen_string_literal: true
 
-require 'new_relic/agent/distributed_trace_payload'
+require_relative 'distributed_tracing/cross_app_payload'
+require_relative 'distributed_tracing/cross_app_tracing'
+
+require_relative 'distributed_tracing/distributed_trace_transport_type'
+require_relative 'distributed_tracing/distributed_trace_payload'
+
+require_relative 'distributed_tracing/trace_context'
 
 module NewRelic
   module Agent
@@ -14,8 +21,9 @@ module NewRelic
     #
     # @api public
     module DistributedTracing
+      extend NewRelic::SupportabilityHelper
       extend self
-
+      
       # Create a payload object containing the current transaction's
       # tracing properties (e.g., duration, priority).  You can use
       # this object to generate headers to inject into a network
@@ -27,10 +35,19 @@ module NewRelic
       #                                   could not create the payload
       #
       # @api public
+      #
+      # @deprecated See {#create_distributed_trace_headers} instead.
+      #
       def create_distributed_trace_payload
-        if transaction = Transaction.tl_current
-          transaction.create_distributed_trace_payload
+        Deprecator.deprecate :create_distributed_trace_payload, :create_distributed_trace_headers
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to create New Relic distributed trace payload"
+          return nil
         end
+
+        return unless transaction = Transaction.tl_current
+        transaction.distributed_tracer.create_distributed_trace_payload
       rescue => e
         NewRelic::Agent.logger.error 'error during create_distributed_trace_payload', e
         nil
@@ -53,15 +70,147 @@ module NewRelic
       # @return nil
       #
       # @api public
+      #
+      # @deprecated See {#accept_distributed_trace_headers} instead
+      #
       def accept_distributed_trace_payload payload
-        if transaction = Transaction.tl_current
-          transaction.accept_distributed_trace_payload(payload)
+        Deprecator.deprecate :accept_distributed_trace_payload, :accept_distributed_trace_headers
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to accept New Relic distributed trace payload"
+          return nil
         end
+
+        return unless transaction = Transaction.tl_current
+        transaction.distributed_tracer.accept_distributed_trace_payload(payload)
         nil
       rescue => e
         NewRelic::Agent.logger.error 'error during accept_distributed_trace_payload', e
         nil
       end
+
+
+      # Adds the Distributed Trace headers so that the downstream service can participate in a
+      # distributed trace. This method should be called every time an outbound call is made
+      # since the header payload contains a timestamp.
+      #
+      # Distributed Tracing must be enabled to use this method.
+      #
+      # +insert_distributed_trace_headers+ always inserts W3C trace context headers and inserts
+      # New Relic distributed tracing header by default. New Relic headers may be suppressed by
+      # setting +exclude_new_relic_header+ to +true+ in your configuration file.
+      #
+      # @param headers           [Hash]     Is a Hash to which the distributed trace headers 
+      #                                     will be inserted.
+      #
+      # @return           {Transaction}     The transaction the headers were inserted from,
+      #                                     or +nil+ if headers were not inserted.
+      #
+      # @api public
+      #
+      def insert_distributed_trace_headers headers={}
+        record_api_supportability_metric(:insert_distributed_trace_headers)
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to insert distributed trace headers"
+          return nil
+        end
+
+        return unless valid_api_argument_class? headers, "headers", Hash
+
+        return unless transaction = Transaction.tl_current
+
+        transaction.distributed_tracer.insert_headers headers
+        transaction
+      rescue => e
+        NewRelic::Agent.logger.error 'error during insert_distributed_trace_headers', e
+        nil
+      end
+
+      # Accepts distributed tracing headers from any source that has been packaged 
+      # as a Ruby Hash, thereby allowing the user to manually inject distributed
+      # tracing headers.  It is optimized to process +HTTP_TRACEPARENT+, +HTTP_TRACESTATE+, 
+      # and +HTTP_NEWRELIC+ as the given Hash keys.  which is the most common scenario 
+      # from Rack middleware in most Ruby applications.  However, the Hash keys are 
+      # case-insensitive and the "HTTP_" prefixes may also be omitted.
+      #
+      # Calling this method is not necessary in a typical HTTP trace as
+      # distributed tracing is already handled by the agent.
+      #
+      # When used, invoke this method as early as possible in a transaction's life-cycle
+      # as calling after the headers are already created will have no effect.
+      #
+      # This method accepts both W3C trace context and New Relic distributed tracing headers.
+      # When both are present, only the W3C headers are utilized.  When W3C trace context 
+      # headers are present, New Relic headers are ignored regardless if W3C trace context
+      # headers are valid and parsable.  
+      #
+      # @param headers         [Hash]     Incoming distributed trace headers as a Ruby 
+      #                                   Hash object.  Hash keys are expected to be one of
+      #                                   +TRACEPARENT+, +TRACESTATE+, +NEWRELIC+ and are 
+      #                                   case-insensitive, with or without "HTTP_" prefixes.
+      #
+      #                                   either as a JSON string or as a
+      #                                   header-friendly string returned from
+      #                                   {DistributedTracePayload#http_safe}
+      #
+      # @param transport_Type  [String]   May be one of:  +HTTP+, +HTTPS+, +Kafka+, +JMS+,
+      #                                   +IronMQ+, +AMQP+, +Queue+, +Other+.  Values are
+      #                                   case sensitive.  All other values result in +Unknown+
+      #
+      # @return {Transaction} if successful, +nil+ otherwise
+      #
+      # @api public
+      #
+      def accept_distributed_trace_headers headers, transport_type = NewRelic::HTTP
+        record_api_supportability_metric(:accept_distributed_trace_headers)
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to accept distributed trace headers"
+          return nil
+        end
+
+        return unless valid_api_argument_class? headers, "headers", Hash
+        return unless valid_api_argument_class? transport_type, "transport_type", String
+
+        return unless transaction = Transaction.tl_current
+
+        # assume we have Rack conforming keys when transport_type is HTTP(S)
+        # otherwise, fish for key/value pairs regardless of prefix and case-sensitivity.
+        hdr = if transport_type.start_with? NewRelic::HTTP
+          headers
+        else 
+          # start with the most common case first
+          hdr = {
+            NewRelic::HTTP_TRACEPARENT_KEY => headers[NewRelic::TRACEPARENT_KEY],
+            NewRelic::HTTP_TRACESTATE_KEY => headers[NewRelic::TRACESTATE_KEY], 
+            NewRelic::HTTP_NEWRELIC_KEY => headers[NewRelic::NEWRELIC_KEY]
+          } 
+          
+          # when not found, search for any casing for trace context headers, ignoring potential prefixes
+          hdr[NewRelic::HTTP_TRACEPARENT_KEY] ||= variant_key_value headers, NewRelic::TRACEPARENT_KEY
+          hdr[NewRelic::HTTP_TRACESTATE_KEY] ||= variant_key_value headers, NewRelic::TRACESTATE_KEY
+          hdr[NewRelic::HTTP_NEWRELIC_KEY] ||= variant_key_value headers, NewRelic::CANDIDATE_NEWRELIC_KEYS
+          hdr
+        end
+
+        transaction.distributed_tracer.accept_incoming_request hdr, transport_type
+        transaction
+      rescue => e
+        NewRelic::Agent.logger.error 'error during accept_distributed_trace_headers', e
+        nil
+      end
+    
+      private
+
+      def has_variant_key? key, variants
+        key.to_s.downcase.end_with?(*Array(variants))
+      end
+
+      def variant_key_value headers, variants
+        (headers.detect{|k, v| has_variant_key?(k, variants)} || NewRelic::EMPTY_ARRAY)[1]
+      end
+
     end
   end
 end

data/lib/new_relic/agent/{cross_app_tracing.rb → distributed_tracing/cross_app_tracing.rb}

@@ -2,6 +2,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.
+# frozen_string_literal: true
 
 require 'json'
 
@@ -9,23 +10,22 @@ module NewRelic
   module Agent
     module CrossAppTracing
       # The cross app response header for "outgoing" calls
-      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
 
       # The cross app id header for "outgoing" calls
-      NR_ID_HEADER = 'X-NewRelic-ID'.freeze
+      NR_ID_HEADER = 'X-NewRelic-ID'
 
       # The cross app transaction header for "outgoing" calls
-      NR_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
 
-      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'.freeze
-      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'.freeze
-      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
+      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'
+      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'
+      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'
 
       attr_accessor :is_cross_app_caller, :cross_app_payload, :cat_path_hashes
 
       def is_cross_app_caller?
-        @is_cross_app_caller = false unless defined? @is_cross_app_caller
-        @is_cross_app_caller
+        @is_cross_app_caller ||= false
       end
 
       def is_cross_app_callee?
@@ -37,28 +37,61 @@ module NewRelic
       end
 
       def cat_trip_id
-        cross_app_payload && cross_app_payload.referring_trip_id || guid
+        cross_app_payload && cross_app_payload.referring_trip_id || transaction.guid
+      end
+
+      def cross_app_monitor
+        NewRelic::Agent.instance.monitors.cross_app_monitor
       end
 
       def cat_path_hash
         referring_path_hash = cat_referring_path_hash || '0'
         seed = referring_path_hash.to_i(16)
-        result = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
+        result = cross_app_monitor.path_hash(transaction.best_name, seed)
         record_cat_path_hash(result)
         result
       end
 
+      def insert_cross_app_header request
+        return unless CrossAppTracing.cross_app_enabled?
+        @is_cross_app_caller = true
+        txn_guid  = transaction.guid
+        trip_id   = cat_trip_id
+        path_hash = cat_path_hash
+
+        insert_request_headers request, txn_guid, trip_id, path_hash
+      end
+
       def add_message_cat_headers headers
-        self.is_cross_app_caller = true
-        CrossAppTracing.insert_message_headers headers,
-                                               guid,
-                                               cat_trip_id,
-                                               cat_path_hash,
-                                               raw_synthetics_header
+        return unless CrossAppTracing.cross_app_enabled?
+        @is_cross_app_caller = true
+        insert_message_headers headers, 
+          transaction.guid, 
+          cat_trip_id, 
+          cat_path_hash, 
+          transaction.raw_synthetics_header
+      end
+
+      def record_cross_app_metrics
+        if (id = cross_app_payload && cross_app_payload.id)
+          app_time_in_seconds = [Time.now.to_f - transaction.start_time.to_f, 0.0].max
+          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
+        end
+      end
+
+      def assign_cross_app_intrinsics
+        transaction.attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
+        transaction.attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
       end
 
       private
 
+      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
+        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(Agent.config[:cross_process_id])
+        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
+        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
+      end
+
       def record_cat_path_hash(hash)
         @cat_path_hashes ||= []
         if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
@@ -75,8 +108,8 @@ module NewRelic
           payload[:referring_transaction_guid] = referring_guid
         end
 
-        return unless include_guid?
-        payload[:guid] = guid
+        return unless transaction.include_guid?
+        payload[:guid] = transaction.guid
 
         return unless is_cross_app?
         trip_id             = cat_trip_id
@@ -96,18 +129,6 @@ module NewRelic
         end
       end
 
-      def assign_cross_app_intrinsics
-        attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
-        attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
-      end
-
-      def record_cross_app_metrics
-        if (id = cross_app_payload && cross_app_payload.id)
-          app_time_in_seconds = [Time.now.to_f - @start_time.to_f, 0.0].max
-          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
-        end
-      end
-
       ###############
       module_function
       ###############
@@ -119,7 +140,7 @@ module NewRelic
       end
 
       def valid_cross_process_id?
-        if NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
+        if Agent.config[:cross_process_id] && Agent.config[:cross_process_id].length > 0
           true
         else
           NewRelic::Agent.logger.debug "No cross_process_id configured"
@@ -128,7 +149,7 @@ module NewRelic
       end
 
       def valid_encoding_key?
-        if NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
+        if Agent.config[:encoding_key] && Agent.config[:encoding_key].length > 0
           true
         else
           NewRelic::Agent.logger.debug "No encoding_key set"
@@ -143,7 +164,7 @@ module NewRelic
       end
 
       def obfuscator
-        @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(Agent.config[:encoding_key])
       end
 
       def insert_request_headers request, txn_guid, trip_id, path_hash
@@ -188,12 +209,6 @@ module NewRelic
         !!(xp_id =~ /\A\d+#\d+\z/)
       end
 
-      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
-        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(NewRelic::Agent.config[:cross_process_id])
-        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
-        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
-      end
-
       def message_has_crossapp_request_header? headers
         !!headers[NR_MESSAGE_BROKER_ID_HEADER]
       end
@@ -217,15 +232,15 @@ module NewRelic
       def assign_intrinsic_transaction_attributes state
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
-        return unless (transaction       = state.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        return unless (txn = state.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
-        if (cross_app_id = cross_app_payload.id)
-          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
+        if (cross_app_id = payload.id)
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
         end
 
-        if (referring_guid = cross_app_payload.referring_guid)
-          transaction.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
+        if (referring_guid = payload.referring_guid)
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
         end
       end
     end