newrelic_rpm 6.6.0.358 → 6.11.0.365

data/lib/new_relic/agent/configuration/event_harvest_config.rb

@@ -12,7 +12,8 @@ module NewRelic
         EVENT_HARVEST_CONFIG_KEY_MAPPING = {
           :analytic_event_data => :'analytics_events.max_samples_stored',
           :custom_event_data => :'custom_insights_events.max_samples_stored',
-          :error_event_data => :'error_collector.max_event_samples_stored'
+          :error_event_data => :'error_collector.max_event_samples_stored',
+          :span_event_data => :'span_events.max_samples_stored'
         }
 
         def from_config(config)
@@ -25,15 +26,20 @@ module NewRelic
         end
 
         def to_config_hash(connect_reply)
-          config_hash = EVENT_HARVEST_CONFIG_KEY_MAPPING.inject({}) do 
+          event_harvest_interval = connect_reply['event_harvest_config']['report_period_ms'] / 1000
+          config_hash = EVENT_HARVEST_CONFIG_KEY_MAPPING.inject({}) do
             |event_harvest_config, (connect_payload_key, config_key)|
-              event_harvest_config[config_key] = connect_reply['event_harvest_config']['harvest_limits'][connect_payload_key.to_s]
+              if harvest_limit = connect_reply['event_harvest_config']['harvest_limits'][connect_payload_key.to_s]
+                event_harvest_config[config_key] = harvest_limit
+                report_period_key = :"event_report_period.#{connect_payload_key}"
+                event_harvest_config[report_period_key] = event_harvest_interval
+              end
               event_harvest_config
             end
-          config_hash[:event_report_period] = connect_reply['event_harvest_config']['report_period_ms'] / 1000
+          config_hash[:event_report_period] = event_harvest_interval
           config_hash
         end
       end
     end
   end
-end
+end

data/lib/new_relic/agent/configuration/manager.rb

@@ -228,14 +228,6 @@ module NewRelic
           end
         end
 
-        def app_names
-          case NewRelic::Agent.config[:app_name]
-          when Array then NewRelic::Agent.config[:app_name]
-          when String then NewRelic::Agent.config[:app_name].split(';')
-          else []
-          end
-        end
-
         MALFORMED_LABELS_WARNING = "Skipping malformed labels configuration"
         PARSING_LABELS_FAILURE   = "Failure during parsing labels. Ignoring and carrying on with connect."
 

data/lib/new_relic/agent/configuration/server_source.rb

@@ -21,6 +21,7 @@ module NewRelic
           "cross_process_id",
           "data_report_period",
           "encoding_key",
+          "entity_guid",
           "error_beacon",
           "js_agent_file",
           "js_agent_loader",
@@ -69,7 +70,7 @@ module NewRelic
 
         def fix_transaction_threshold(merged_settings)
           # when value is "apdex_f" remove the config and defer to default
-          if merged_settings['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+          if merged_settings['transaction_tracer.transaction_threshold'].to_s =~ /apdex_f/i
             merged_settings.delete('transaction_tracer.transaction_threshold')
           end
         end
@@ -78,6 +79,7 @@ module NewRelic
           :'analytics_events.max_samples_stored' => 'Supportability/EventHarvest/AnalyticEventData/HarvestLimit',
           :'custom_insights_events.max_samples_stored' => 'Supportability/EventHarvest/CustomEventData/HarvestLimit',
           :'error_collector.max_event_samples_stored'=> 'Supportability/EventHarvest/ErrorEventData/HarvestLimit',
+          :'span_events.max_samples_stored'=> 'Supportability/EventHarvest/SpanEventData/HarvestLimit',
           :event_report_period => 'Supportability/EventHarvest/ReportPeriod'
         }
 
@@ -100,7 +102,6 @@ module NewRelic
               || (event_harvest_config['report_period_ms'] / 1000) <= 0
             NewRelic::Agent.logger.warn "Invalid event harvest config found " \
                 "in connect response; using default event report period."
-            NewRelic::Agent.record_metric('Supportability/Agent/Collector/MissingEventHarvestConfig', 1)
             false
           else
             true

data/lib/new_relic/agent/configuration/yaml_source.rb

@@ -12,6 +12,7 @@ module NewRelic
         attr_reader :generated_for_user, :license_key
 
         def initialize(path, env)
+          @path = path
           config    = {}
           @failures = []
 
@@ -111,30 +112,34 @@ module NewRelic
 
         def substitute_transaction_threshold(config)
           if config['transaction_tracer'] &&
-              config['transaction_tracer']['transaction_threshold'] =~ /apdex_f/i
+              config['transaction_tracer']['transaction_threshold'].to_s =~ /apdex_f/i
             # when value is "apdex_f" remove the config and defer to default
             config['transaction_tracer'].delete('transaction_threshold')
           end
         end
 
         def booleanify_values(config, *keys)
-          # auto means defer ro default
+          # auto means defer to default
           keys.each do |option|
-            if config[option] == 'auto'
+            if 'auto' == config[option]
               config.delete(option)
             elsif !config[option].nil? && !is_boolean?(config[option])
-              config[option] = !!(config[option] =~ /yes|on|true/i)
+              coerced_value = !!(config[option].to_s =~ /yes|on|true/i)
+              if !coerced_value
+                log_failure "Unexpected value (#{config[option]}) for '#{option}' in #{@path}"
+              end
+              config[option] = coerced_value
             end
           end
         end
 
         def is_boolean?(value)
-          value == !!value
+          !!value == value
         end
 
         def log_failure(*messages)
           ::NewRelic::Agent.logger.error(*messages)
-          @failures << messages
+          messages.each { |message| @failures << message }
         end
       end
     end

data/lib/new_relic/agent/connect/request_builder.rb

@@ -11,10 +11,11 @@ module NewRelic
 
       class RequestBuilder
 
-        def initialize(new_relic_service, config, event_harvest_config)
+        def initialize(new_relic_service, config, event_harvest_config, environment_report)
           @service = new_relic_service
           @config = config
           @event_harvest_config = event_harvest_config
+          @environment_report = sanitize_environment_report(environment_report)
         end
 
 
@@ -25,16 +26,16 @@ module NewRelic
             :pid           => $$,
             :host          => local_host,
             :display_host  => Agent.config[:'process_host.display_name'],
-            :app_name      => Agent.config.app_names,
+            :app_name      => Agent.config[:app_name],
             :language      => 'ruby',
             :labels        => Agent.config.parsed_labels,
             :agent_version => NewRelic::VERSION::STRING,
-            :environment   => sanitize_environment_report(environment_report),
+            :environment   => @environment_report,
             :metadata      => environment_metadata,
             :settings      => Agent.config.to_collector_hash,
             :high_security => Agent.config[:high_security],
             :utilization   => UtilizationData.new.to_collector_hash,
-            :identifier    => "ruby:#{local_host}:#{Agent.config.app_names.sort.join(',')}",
+            :identifier    => "ruby:#{local_host}:#{Agent.config[:app_name].sort.join(',')}",
             :event_harvest_config => @event_harvest_config
           }
         end
@@ -47,15 +48,6 @@ module NewRelic
           environment_report
         end
 
-        # Checks whether we should send environment info, and if so,
-        # returns the snapshot from the local environment.
-        # Generating the EnvironmentReport has the potential to trigger
-        # require calls in Rails environments, so this method should only
-        # be called synchronously from on the main thread.
-        def environment_report
-          Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
-        end
-
         def environment_metadata
           ENV.select {|k, v| k =~ /^NEW_RELIC_METADATA_/}
         end

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/database/obfuscation_helpers.rb

@@ -11,7 +11,7 @@ module NewRelic
           :double_quotes => /"(?:[^"]|"")*?(?:\\".*|"(?!"))/,
           :dollar_quotes => /(\$(?!\d)[^$]*?\$).*?(?:\1|$)/,
           :uuids => /\{?(?:[0-9a-fA-F]\-*){32}\}?/,
-          :numeric_literals => /\b-?(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
+          :numeric_literals => /-?\b(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
           :boolean_literals => /\b(?:true|false|null)\b/i,
           :hexadecimal_literals => /0x[0-9a-fA-F]+/,
           :comments => /(?:#|--).*?(?=\r|\n|$)/i,

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