newrelic_rpm 6.15.0 → 8.0.0

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

@@ -13,12 +13,13 @@ module NewRelic
           :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',
-          :span_event_data => :'span_events.max_samples_stored'
         }
 
         def from_config(config)
-          {:harvest_limits => EVENT_HARVEST_CONFIG_KEY_MAPPING.inject({}) do
-            |connect_payload, (connect_payload_key, config_key)|
+          {:harvest_limits =>
+            EVENT_HARVEST_CONFIG_KEY_MAPPING.merge(
+              :span_event_data => :'span_events.max_samples_stored'
+            ).inject({}) do |connect_payload, (connect_payload_key, config_key)|
               connect_payload[connect_payload_key] = config[config_key]
               connect_payload
             end
@@ -27,16 +28,31 @@ module NewRelic
 
         def to_config_hash(connect_reply)
           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)|
-              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 = transform_event_harvest_config_keys(connect_reply, event_harvest_interval)
           config_hash[:event_report_period] = event_harvest_interval
+          config_hash = transform_span_event_harvest_config(config_hash, connect_reply)
+          config_hash
+        end
+
+        private
+
+        def transform_event_harvest_config_keys(connect_reply, event_harvest_interval)
+          EVENT_HARVEST_CONFIG_KEY_MAPPING.inject({}) do |event_harvest_config, (connect_payload_key, config_key)|
+            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
+        end
+
+        def transform_span_event_harvest_config(config_hash, connect_reply)
+          if span_harvest = connect_reply['span_event_harvest_config']
+            config_hash[:'span_events.max_samples_stored'] = span_harvest['harvest_limit'] if span_harvest['harvest_limit']
+            config_hash[:'event_report_period.span_event_data'] = span_harvest['report_period_ms'] if span_harvest['report_period_ms']
+          end
+
           config_hash
         end
       end

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

@@ -15,7 +15,6 @@ module NewRelic
   module Agent
     module Configuration
       class Manager
-
         # Defining these explicitly saves object allocations that we incur
         # if we use Forwardable and def_delegators.
         def [](key)
@@ -23,7 +22,7 @@ module NewRelic
         end
 
         def has_key?(key)
-          @cache.has_key?[key]
+          @cache.has_key? key
         end
 
         def keys
@@ -80,6 +79,7 @@ module NewRelic
           was_finished = finished_configuring?
 
           invoke_callbacks(:add, source)
+
           case source
           when SecurityPolicySource then @security_policy_source = source
           when HighSecuritySource   then @high_security_source   = source
@@ -159,7 +159,6 @@ module NewRelic
         def invoke_callbacks(direction, source)
           return unless source
           source.keys.each do |key|
-
             if @cache[key] != source[key]
               @callbacks[key].each do |proc|
                 if direction == :add
@@ -345,7 +344,7 @@ module NewRelic
         end
 
         def reset_cache
-          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+          @cache = Hash.new { |hash,key| hash[key] = self.fetch(key) }
         end
 
         def log_config(direction, source)

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

@@ -79,8 +79,9 @@ 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'
+          :'span_events.max_samples_stored' => 'Supportability/SpanEvent/Limit',
+          :event_report_period => 'Supportability/EventHarvest/ReportPeriod',
+          :'event_report_period.span_event_data' => 'Supportability/SpanEvent/ReportPeriod',
         }
 
         def add_event_harvest_config(merged_settings, connect_reply)

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

@@ -11,6 +11,10 @@ module NewRelic
         attr_accessor :file_path, :failures
         attr_reader :generated_for_user, :license_key
 
+        # These are configuration options that have a value of a Hash
+        # This is used in YamlSource#dot_flattened prevent flattening these values
+        CONFIG_WITH_HASH_VALUE = ['expected_messages', 'ignore_messages']
+
         def initialize(path, env)
           @path = path
           config    = {}
@@ -99,7 +103,12 @@ module NewRelic
 
         def process_yaml(file, env, config, path)
           if file
-            confighash = YAML.load(file)
+            confighash = if YAML.respond_to?(:unsafe_load)
+                           YAML.unsafe_load(file)
+                         else 
+                           YAML.load(file)
+                         end
+
             unless confighash.key?(env)
               log_failure("Config file at #{path} doesn't include a '#{env}' section!")
             end
@@ -141,6 +150,18 @@ module NewRelic
           ::NewRelic::Agent.logger.error(*messages)
           messages.each { |message| @failures << message }
         end
+
+        def dot_flattened(nested_hash, names=[], result={})
+          nested_hash.each do |key, val|
+            next if val == nil
+            if val.respond_to?(:has_key?) && !CONFIG_WITH_HASH_VALUE.include?(key)
+              dot_flattened(val, names + [key], result)
+            else
+              result[(names + [key]).join('.')] = val
+            end
+          end
+          result
+        end
       end
     end
   end

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

@@ -48,8 +48,10 @@ module NewRelic
           environment_report
         end
 
-        def environment_metadata
-          ENV.select {|k, v| k =~ /^NEW_RELIC_METADATA_/}
+        def environment_metadata 
+          env_copy = {}
+          ENV.keys.each {|k| env_copy[k] = ENV[k] if k =~ /^NEW_RELIC_METADATA_/}
+          env_copy
         end
 
         def local_host

data/lib/new_relic/agent/custom_event_aggregator.rb

@@ -46,7 +46,8 @@ module NewRelic
 
       def create_event(type, priority, attributes)
         [
-          { TYPE => type, TIMESTAMP => Time.now.to_i,
+          { TYPE => type,
+            TIMESTAMP => Process.clock_gettime(Process::CLOCK_REALTIME).to_i,
             PRIORITY => priority
           },
           AttributeProcessing.flatten_and_coerce(attributes)

data/lib/new_relic/agent/database.rb

@@ -228,9 +228,12 @@ module NewRelic
         def explain
           return unless explainable?
           handle_exception_in_explain do
-            start = Time.now
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             plan = @explainer.call(self)
-            ::NewRelic::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
+            ::NewRelic::Agent.record_metric(
+              "Supportability/Database/execute_explain_plan",
+              Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            )
             return process_resultset(plan, adapter) if plan
           end
         end

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

@@ -7,22 +7,17 @@ module NewRelic
     module Datastores
       module Mongo
         def self.is_supported_version?
-          # No version constant in < 2.0 versions of Mongo :(
-          defined?(::Mongo) && (defined?(::Mongo::MongoClient) || is_monitoring_enabled?)
-        end
-
-        def self.is_monitoring_enabled?
-          defined?(::Mongo::Monitoring) # @since 2.1.0
+          defined?(::Mongo) && is_monitoring_enabled?
         end
 
         def self.is_unsupported_2x?
-          defined?(::Mongo::VERSION) && Gem::Version.new(::Mongo::VERSION).segments[0] == 2 &&
+          defined?(::Mongo::VERSION) &&
+            Gem::Version.new(::Mongo::VERSION).segments[0] == 2 &&
             !self.is_monitoring_enabled?
         end
 
-        def self.is_version_1_10_or_later?
-          # Again, no VERSION constant in 1.x, so we have to rely on constant checks
-          defined?(::Mongo::CollectionOperationWriter)
+        def self.is_monitoring_enabled?
+          defined?(::Mongo::Monitoring) # @since 2.1.0
         end
       end
     end

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

@@ -6,11 +6,7 @@ module NewRelic
   module Agent
     module Datastores
       module Redis
-        MULTI_OPERATION = 'multi'
-        PIPELINE_OPERATION = 'pipeline'
         BINARY_DATA_PLACEHOLDER = "<binary data>"
-        PRODUCT_NAME = 'Redis'
-        CONNECT = 'connect'
 
         MAXIMUM_COMMAND_LENGTH = 1000
         MAXIMUM_ARGUMENT_LENGTH = 64

data/lib/new_relic/agent/datastores.rb

@@ -21,7 +21,7 @@ module NewRelic
       # query content into Transaction Traces. Use wrap if you want to provide
       # that functionality.
       #
-      # @param [Class] clazz the class to instrument
+      # @param [Class] klass the class to instrument
       #
       # @param [String, Symbol] method_name the name of instance method to
       #   instrument
@@ -33,16 +33,16 @@ module NewRelic
       #
       # @api public
       #
-      def self.trace(clazz, method_name, product, operation = method_name)
+      def self.trace(klass, method_name, product, operation = method_name)
         NewRelic::Agent.record_api_supportability_metric(:trace)
 
-        clazz.class_eval do
+        klass.class_eval do
           method_name_without_newrelic = "#{method_name}_without_newrelic"
 
-          if NewRelic::Helper.instance_methods_include?(clazz, method_name) &&
-             !NewRelic::Helper.instance_methods_include?(clazz, method_name_without_newrelic)
+          if NewRelic::Helper.instance_methods_include?(klass, method_name) &&
+             !NewRelic::Helper.instance_methods_include?(klass, method_name_without_newrelic)
 
-            visibility = NewRelic::Helper.instance_method_visibility(clazz, method_name)
+            visibility = NewRelic::Helper.instance_method_visibility(klass, method_name)
 
             alias_method method_name_without_newrelic, method_name
 
@@ -123,7 +123,7 @@ module NewRelic
         ensure
           begin
             if callback
-              elapsed_time = (Time.now - segment.start_time).to_f
+              elapsed_time = Process.clock_gettime(Process::CLOCK_REALTIME) - segment.start_time
               callback.call(result, segment.name, elapsed_time)
             end
           ensure

data/lib/new_relic/agent/distributed_tracing/cross_app_payload.rb

@@ -19,15 +19,15 @@ module NewRelic
       end
 
       def as_json_array(content_length)
-        queue_time_in_seconds = [transaction.queue_time.to_f, 0.0].max
-        start_time_in_seconds = [transaction.start_time.to_f, 0.0].max
-        app_time_in_seconds   = Time.now.to_f - start_time_in_seconds
+        queue_time_in_seconds = [transaction.queue_time, 0.0].max
+        start_time_in_seconds = [transaction.start_time, 0.0].max
+        app_time_in_seconds   = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
 
         [
           NewRelic::Agent.config[:cross_process_id],
           transaction.best_name,
-          queue_time_in_seconds.to_f,
-          app_time_in_seconds.to_f,
+          queue_time_in_seconds,
+          app_time_in_seconds,
           content_length,
           transaction.guid,
           false

data/lib/new_relic/agent/distributed_tracing/cross_app_tracing.rb

@@ -54,6 +54,7 @@ module NewRelic
 
       def insert_cross_app_header headers
         return unless CrossAppTracing.cross_app_enabled?
+
         @is_cross_app_caller = true
         txn_guid  = transaction.guid
         trip_id   = cat_trip_id
@@ -65,17 +66,20 @@ module NewRelic
       def add_message_cat_headers headers
         return unless CrossAppTracing.cross_app_enabled?
         @is_cross_app_caller = true
-        insert_message_headers headers, 
-          transaction.guid, 
-          cat_trip_id, 
-          cat_path_hash, 
+        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
+          app_time_in_seconds = [
+            Process.clock_gettime(Process::CLOCK_REALTIME) - transaction.start_time,
+            0.0
+          ].max
+          NewRelic::Agent.record_metric("ClientApplication/#{id}/all", app_time_in_seconds)
         end
       end
 

data/lib/new_relic/agent/distributed_tracing/distributed_trace_attributes.rb

@@ -64,7 +64,6 @@ module NewRelic
           destination[PARENT_TYPE_KEY] = trace_payload.parent_type
           destination[PARENT_APP_KEY] = trace_payload.parent_app_id
           destination[PARENT_ACCOUNT_ID_KEY] = trace_payload.parent_account_id
-
           destination[PARENT_TRANSPORT_DURATION_KEY] = transaction.calculate_transport_duration trace_payload
 
           if parent_transaction_id = transaction.distributed_tracer.parent_transaction_id

data/lib/new_relic/agent/distributed_tracing/distributed_trace_payload.rb

@@ -50,7 +50,7 @@ module NewRelic
 
           payload.id = current_segment_id(transaction)
           payload.transaction_id = transaction.guid
-          payload.timestamp = (Time.now.to_f * 1000).round
+          payload.timestamp = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
           payload.trace_id = transaction.trace_id
           payload.sampled = transaction.sampled?
           payload.priority = transaction.priority

data/lib/new_relic/agent/distributed_tracing/trace_context_payload.rb

@@ -57,7 +57,7 @@ module NewRelic
         private
 
         def now_ms
-          (Time.now.to_f * 1000).round
+          Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
         end
 
         def handle_invalid_payload error: nil, message: nil

data/lib/new_relic/agent/distributed_tracing.rb

@@ -24,72 +24,6 @@ module NewRelic
       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
-      # request, so that the downstream service can participate in a
-      # distributed trace.
-      #
-      # @return [DistributedTracePayload] Payload for the current
-      #                                   transaction, or +nil+ if we
-      #                                   could not create the payload
-      #
-      # @api public
-      #
-      # @deprecated See {#create_distributed_trace_headers} instead.
-      #
-      def 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
-      end
-
-      # Decode a JSON string containing distributed trace properties
-      # (e.g., calling application, priority) and apply them to the
-      # current transaction.  You can use it to receive distributed
-      # tracing information protocols the agent does not already
-      # support.
-      #
-      # This method will fail if you call it after calling
-      # {#create_distributed_trace_payload}.
-      #
-      # @param payload [String] Incoming distributed trace payload,
-      #                         either as a JSON string or as a
-      #                         header-friendly string returned from
-      #                         {DistributedTracePayload#http_safe}
-      #
-      # @return nil
-      #
-      # @api public
-      #
-      # @deprecated See {#accept_distributed_trace_headers} instead
-      #
-      def 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.

data/lib/new_relic/agent/error_collector.rb

@@ -22,23 +22,18 @@ module NewRelic
         @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
         @error_event_aggregator = ErrorEventAggregator.new events
 
-        # lookup of exception class names to ignore.  Hash for fast access
-        @ignore = {}
-
-        initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
-
-        Agent.config.register_callback(:'error_collector.ignore_errors') do |ignore_errors|
-          initialize_ignored_errors(ignore_errors)
+        @error_filter = NewRelic::Agent::ErrorFilter.new
+
+        %w(
+          ignore_errors ignore_classes ignore_messages ignore_status_codes
+          expected_classes expected_messages expected_status_codes
+        ).each do |w|
+          Agent.config.register_callback(:"error_collector.#{w}") do |value|
+            @error_filter.load_from_config(w, value)
+          end
         end
       end
 
-      def initialize_ignored_errors(ignore_errors)
-        @ignore.clear
-        ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
-        ignore_errors.each { |error| error.strip! }
-        ignore(ignore_errors)
-      end
-
       def enabled?
         error_trace_aggregator.enabled? || error_event_aggregator.enabled?
       end
@@ -76,30 +71,39 @@ module NewRelic
         defined?(@ignore_filter) ? @ignore_filter : nil
       end
 
-      # errors is an array of Exception Class Names
-      #
       def ignore(errors)
-        errors.each do |error|
-          @ignore[error] = true
-          ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}'")
-        end
+        @error_filter.ignore(errors)
+      end
+
+      def ignore?(ex, status_code = nil)
+        @error_filter.ignore?(ex, status_code)
+      end
+
+      def expect(errors)
+        @error_filter.expect(errors)
+      end
+
+      def expected?(ex, status_code = nil)
+        @error_filter.expected?(ex, status_code)
+      end
+
+      def load_error_filters
+        @error_filter.load_all
+      end
+
+      def reset_error_filters
+        @error_filter.reset
       end
 
       # Checks the provided error against the error filter, if there
       # is an error filter
-      def filtered_by_error_filter?(error)
+      def ignored_by_filter_proc?(error)
         respond_to?(:ignore_filter_proc) && !ignore_filter_proc(error)
       end
 
-      # Checks the array of error names and the error filter against
-      # the provided error
-      def filtered_error?(error)
-        @ignore[error.class.name] || filtered_by_error_filter?(error)
-      end
-
       # an error is ignored if it is nil or if it is filtered
-      def error_is_ignored?(error)
-        error && filtered_error?(error)
+      def error_is_ignored?(error, status_code = nil)
+        error && (@error_filter.ignore?(error, status_code) || ignored_by_filter_proc?(error))
       rescue => e
         NewRelic::Agent.logger.error("Error '#{error}' will NOT be ignored. Exception '#{e}' while determining whether to ignore or not.", e)
         false
@@ -174,11 +178,18 @@ module NewRelic
         end
       end
 
-      def skip_notice_error?(exception)
+      def increment_expected_error_count!(state, exception)
+        stats_engine = NewRelic::Agent.agent.stats_engine
+        stats_engine.record_unscoped_metrics(state, ['ErrorsExpected/all']) do |stats|
+          stats.increment_count
+        end
+      end
+
+      def skip_notice_error?(exception, status_code = nil)
         disabled? ||
-        error_is_ignored?(exception) ||
         exception.nil? ||
-        exception_tagged_with?(EXCEPTION_TAG_IVAR, exception)
+        exception_tagged_with?(EXCEPTION_TAG_IVAR, exception) ||
+        error_is_ignored?(exception, status_code)
       end
 
       # calls a method on an object, if it responds to it - used for
@@ -210,13 +221,17 @@ module NewRelic
 
       # See NewRelic::Agent.notice_error for options and commentary
       def notice_error(exception, options={}, span_id=nil)
-        return if skip_notice_error?(exception)
+        state = ::NewRelic::Agent::Tracer.state
+        transaction = state.current_transaction
+        status_code = transaction ? transaction.http_response_code : nil
 
-        tag_exception(exception)
+        return if skip_notice_error?(exception, status_code)
 
-        state = ::NewRelic::Agent::Tracer.state
+        tag_exception(exception)
 
-        unless options[:expected]
+        if options[:expected] || @error_filter.expected?(exception, status_code)
+          increment_expected_error_count!(state, exception)
+        else
           increment_error_count!(state, exception, options)
         end
 
@@ -258,7 +273,7 @@ module NewRelic
         noticed_error.line_number = sense_method(exception, :line_number)
         noticed_error.stack_trace = truncate_trace(extract_stack_trace(exception))
 
-        noticed_error.expected = !! options.delete(:expected)
+        noticed_error.expected = !!options.delete(:expected) || expected?(exception)
 
         noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}