newrelic_rpm 6.4.0.356 → 6.9.0.363

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

@@ -0,0 +1,126 @@
+# 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.
+
+require 'new_relic/coerce'
+
+module NewRelic
+  module Agent
+    class TraceContextPayload
+      VERSION = 0
+      PARENT_TYPE = 0
+      DELIMITER = "-".freeze
+      SUPPORTABILITY_PARSE_EXCEPTION = "Supportability/TraceContext/Parse/Exception".freeze
+
+      TRUE_CHAR = '1'.freeze
+      FALSE_CHAR = '0'.freeze
+
+      PARENT_TYPES = %w(App Browser Mobile).map(&:freeze).freeze
+
+      class << self
+        def create version: VERSION,
+                   parent_type: PARENT_TYPE,
+                   parent_account_id: nil,
+                   parent_app_id: nil,
+                   id: nil,
+                   transaction_id: nil,
+                   sampled: nil,
+                   priority: nil,
+                   timestamp: now_ms
+
+          new version, parent_type, parent_account_id, parent_app_id, id,
+              transaction_id, sampled, priority, timestamp
+        end
+
+        include NewRelic::Coerce
+
+        def from_s payload_string
+          attrs = payload_string.split(DELIMITER)
+
+          payload = create \
+            version: int!(attrs[0]),
+            parent_type: int!(attrs[1]),
+            parent_account_id: attrs[2],
+            parent_app_id: attrs[3],
+            id: value_or_nil(attrs[4]),
+            transaction_id: value_or_nil(attrs[5]),
+            sampled: value_or_nil(attrs[6]) ? boolean_int!(attrs[6]) == 1 : nil,
+            priority: float!(attrs[7]),
+            timestamp: int!(attrs[8])
+          handle_invalid_payload message: 'payload missing attributes' unless payload.valid?
+          payload
+        rescue => e
+          handle_invalid_payload error: e
+          raise
+        end
+
+        private
+
+        def now_ms
+          (Time.now.to_f * 1000).round
+        end
+
+        def handle_invalid_payload error: nil, message: nil
+          NewRelic::Agent.increment_metric SUPPORTABILITY_PARSE_EXCEPTION
+          if error
+            NewRelic::Agent.logger.warn "Error parsing trace context payload", error
+          elsif message
+            NewRelic::Agent.logger.warn "Error parsing trace context payload: #{message}"
+          end
+        end
+      end
+
+      attr_accessor :version,
+                    :parent_type_id,
+                    :parent_account_id,
+                    :parent_app_id,
+                    :id,
+                    :transaction_id,
+                    :sampled,
+                    :priority,
+                    :timestamp
+
+      alias_method :sampled?, :sampled
+
+      def initialize version, parent_type_id, parent_account_id, parent_app_id,
+                     id, transaction_id, sampled, priority, timestamp
+        @version = version
+        @parent_type_id = parent_type_id
+        @parent_account_id = parent_account_id
+        @parent_app_id = parent_app_id
+        @id = id
+        @transaction_id = transaction_id
+        @sampled = sampled
+        @priority = priority
+        @timestamp = timestamp
+      end
+
+      def parent_type
+        @parent_type_string ||= PARENT_TYPES[@parent_type_id]
+      end
+
+      def valid?
+        version \
+          && parent_type_id \
+          && !parent_account_id.empty? \
+          && !parent_app_id.empty? \
+          && timestamp
+      rescue
+        false
+      end
+
+      def to_s
+        result = version.to_s
+        result << DELIMITER << parent_type_id.to_s
+        result << DELIMITER << parent_account_id
+        result << DELIMITER << parent_app_id
+        result << DELIMITER << (id || NewRelic::EMPTY_STR)
+        result << DELIMITER << (transaction_id || NewRelic::EMPTY_STR)
+        result << DELIMITER << (sampled ? TRUE_CHAR : FALSE_CHAR)
+        result << DELIMITER << priority.to_s
+        result << DELIMITER << timestamp.to_s
+        result
+      end
+    end
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -18,9 +18,9 @@ module NewRelic
       attr_reader :error_trace_aggregator, :error_event_aggregator
 
       # Returns a new error collector
-      def initialize
+      def initialize events
         @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
-        @error_event_aggregator = ErrorEventAggregator.new
+        @error_event_aggregator = ErrorEventAggregator.new events
 
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
@@ -74,7 +74,7 @@ module NewRelic
       end
 
       def self.ignore_error_filter
-        @ignore_filter
+        defined?(@ignore_filter) ? @ignore_filter : nil
       end
 
       # errors is an array of Exception Class Names
@@ -227,13 +227,11 @@ module NewRelic
         truncated_trace
       end
 
-      EMPTY_STRING = ''.freeze
-
       def create_noticed_error(exception, options)
-        error_metric = options.delete(:metric) || EMPTY_STRING
+        error_metric = options.delete(:metric) || NewRelic::EMPTY_STR
 
         noticed_error = NewRelic::NoticedError.new(error_metric, exception)
-        noticed_error.request_uri = options.delete(:uri) || EMPTY_STRING
+        noticed_error.request_uri = options.delete(:uri) || NewRelic::EMPTY_STR
         noticed_error.request_port = options.delete(:port)
         noticed_error.attributes  = options.delete(:attributes)
 

data/lib/new_relic/agent/error_event_aggregator.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 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/transaction_error_primitive'
@@ -10,16 +11,18 @@ require 'new_relic/agent/priority_sampled_buffer'
 module NewRelic
   module Agent
     class ErrorEventAggregator < EventAggregator
+      include NewRelic::Coerce
 
       named :ErrorEventAggregator
       capacity_key :'error_collector.max_event_samples_stored'
-      enabled_key :'error_collector.capture_events'
+      enabled_keys :'error_collector.enabled',
+                   :'error_collector.capture_events'
       buffer_class PrioritySampledBuffer
 
       def record noticed_error, transaction_payload = nil
         return unless enabled?
 
-        priority = (transaction_payload && transaction_payload[:priority]) || rand.round(6)
+        priority = float!((transaction_payload && transaction_payload[:priority]) || rand)
 
         @lock.synchronize do
           @buffer.append(priority: priority) do

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -91,6 +91,7 @@ module NewRelic
 
       def register_config_callbacks
         Agent.config.register_callback(:'error_collector.enabled') do |enabled|
+          reset! if enabled == false
           ::NewRelic::Agent.logger.debug "Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service."
         end
       end

data/lib/new_relic/agent/event_aggregator.rb

@@ -8,20 +8,6 @@ module NewRelic
   module Agent
     class EventAggregator
       class << self
-        # This architecture requires that every aggregator
-        # implementation provide its own `named`, `capacity_key`, and
-        # `enabled_...` settings.  In particular, we do not allow
-        # subclasses to share these values from an intermediate
-        # superclass.
-
-        def inherited(subclass)
-          # Prevent uninitialized variable warnings; we have to do
-          # this as soon as the subclass is defined, before its
-          # implementor calls enabled_key() or enabled_fn().
-          subclass.instance_variable_set(:@enabled_key, nil)
-          subclass.instance_variable_set(:@enabled_fn,  nil)
-        end
-
         def named named = nil
           named ? @named = named.to_s.freeze : @named
         end
@@ -30,10 +16,25 @@ module NewRelic
           key ? @capacity_key = key : @capacity_key
         end
 
-        def enabled_key key = nil
-          key ? @enabled_key = key : @enabled_key
+        # An aggregator can specify one or more keys to check to see if it is
+        # enabled. Multiple keys will be &&'d and the enabled status of the
+        # aggregator will be reset when agent configuration changes.
+
+        def enabled_keys *keys
+          if keys.empty?
+            @enabled_keys ||= []
+          else
+            @enabled_keys = Array(keys)
+            @enabled_fn = ->(){ @enabled_keys.all? { |k| Agent.config[k] } }
+          end
         end
 
+        alias_method :enabled_key, :enabled_keys
+
+        # This can be used instead of `enabled_key(s)` for more fine grained
+        # control over whether an aggregator should be enabled. The enabled fn
+        # will be reevaluated after configuration changes
+
         def enabled_fn fn = nil
           fn ? @enabled_fn = fn : @enabled_fn
         end
@@ -47,13 +48,13 @@ module NewRelic
         end
       end
 
-      def initialize
+      def initialize events
         @lock = Mutex.new
         @buffer = self.class.buffer_class.new NewRelic::Agent.config[self.class.capacity_key]
-        @enabled = false
+        @enabled = self.class.enabled_fn ? self.class.enabled_fn.call : false
         @notified_full = false
         register_capacity_callback
-        register_enabled_callback
+        register_enabled_callback events
         after_initialize
       end
 
@@ -66,7 +67,6 @@ module NewRelic
       end
 
       def enabled?
-        return self.class.enabled_fn.call if self.class.enabled_fn
         @enabled
       end
 
@@ -126,18 +126,12 @@ module NewRelic
         end
       end
 
-      def register_enabled_callback
-        unless self.class.enabled_key || self.class.enabled_fn
-          ::NewRelic::Agent.logger.warn "#{self.class.named} needs an enabled_key or an enabled_fn."
-        end
-
-        return if self.class.enabled_fn
-
-        NewRelic::Agent.config.register_callback(self.class.enabled_key) do |enabled|
-          # intentionally unsynchronized for liveness
-          @enabled = enabled
-          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{enabled ? '' : 'not '}be sent to the New Relic service."
-        end
+      def register_enabled_callback events
+        events.subscribe(:server_source_configuration_added) {
+          @enabled = self.class.enabled_fn.call
+          reset! if @enabled == false
+          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{@enabled ? '' : 'not '}be sent to the New Relic service."
+        }
       end
 
       def notify_if_full

data/lib/new_relic/agent/external.rb

@@ -3,8 +3,8 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/agent/transaction/tracing'
-require 'new_relic/agent/cross_app_tracing'
-require 'new_relic/agent/cross_app_payload'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_payload'
 
 module NewRelic
   module Agent
@@ -78,7 +78,7 @@ module NewRelic
             #
             if txn_info = rmd[NON_HTTP_CAT_TXN_HEADER]
               payload = CrossAppPayload.new(id, transaction, txn_info)
-              transaction.cross_app_payload = payload
+              transaction.distributed_tracer.cross_app_payload = payload
 
               CrossAppTracing.assign_intrinsic_transaction_attributes state
             end
@@ -112,16 +112,16 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        return unless (transaction = Tracer.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        return unless (txn = Tracer.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
         # must freeze the name since we're responding with it
         #
-        transaction.freeze_name_and_execute_if_not_ignored do
+        txn.freeze_name_and_execute_if_not_ignored do
           # build response payload
           #
           rmd = {
-            NewRelicAppData: cross_app_payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
+            NewRelicAppData: payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
           }
 
           # obfuscate the generated response metadata JSON

data/lib/new_relic/agent/guid_generator.rb

@@ -0,0 +1,28 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module GuidGenerator
+
+      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+
+      module_function
+
+      # This method intentionally does not use SecureRandom, because it relies
+      # on urandom, which raises an exception in MRI when the interpreter runs
+      # out of allocated file descriptors.
+      # The guids generated by this method may not be _secure_, but they are
+      # random enough for our purposes.
+      def generate_guid length = 16
+        guid = ''
+        length.times do |a|
+          guid << HEX_DIGITS[rand(16)]
+        end
+        guid
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/action_cable_subscriber.rb

@@ -47,10 +47,9 @@ module NewRelic
         end
 
         DOT_ACTION_CABLE = '.action_cable'.freeze
-        EMPTY_STRING = ''.freeze
 
         def action_name(name)
-          name.gsub DOT_ACTION_CABLE, EMPTY_STRING
+          name.gsub DOT_ACTION_CABLE, NewRelic::EMPTY_STR
         end
 
         def notice_error(payload)

data/lib/new_relic/agent/instrumentation/active_record_notifications.rb

@@ -13,18 +13,13 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveRecordNotifications
-        module BaseExtensions41
-          def self.included(base)
-            base.class_eval do
-              alias_method :log_without_performance_improvement, :log
-              alias_method :log, :log_with_performance_improvement
-            end
-          end
+        SQL_ACTIVE_RECORD = 'sql.active_record'.freeze
 
+        module BaseExtensions4x
           # https://github.com/rails/rails/blob/4-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L371
-          def log_with_performance_improvement(sql, name = "SQL", binds = [], statement_name = nil)
+          def log(sql, name = "SQL", binds = [], statement_name = nil)
             @instrumenter.instrument(
-              "sql.active_record",
+              SQL_ACTIVE_RECORD,
               :sql            => sql,
               :name           => name,
               :connection_id  => object_id,
@@ -32,22 +27,20 @@ module NewRelic
               :statement_name => statement_name,
               :binds          => binds) { yield }
           rescue => e
-            raise translate_exception(e, sql)
+            # The translate_exception_class method got introduced in 4.1
+            if ::ActiveRecord::VERSION::MINOR == 0
+              raise translate_exception(e, sql)
+            else
+              raise translate_exception_class(e, sql)
+            end
           end
         end
 
         module BaseExtensions50
-          def self.included(base)
-            base.class_eval do
-              alias_method :log_without_performance_improvement, :log
-              alias_method :log, :log_with_performance_improvement
-            end
-          end
-
           # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L582
-          def log_with_performance_improvement(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
             @instrumenter.instrument(
-              "sql.active_record",
+              SQL_ACTIVE_RECORD,
               sql:               sql,
               name:              name,
               binds:             binds,
@@ -61,17 +54,10 @@ module NewRelic
         end
 
         module BaseExtensions51
-          def self.included(base)
-            base.class_eval do
-              alias_method :log_without_performance_improvement, :log
-              alias_method :log, :log_with_performance_improvement
-            end
-          end
-
           # https://github.com/rails/rails/blob/5-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L603
-          def log_with_performance_improvement(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
             @instrumenter.instrument(
-              "sql.active_record",
+              SQL_ACTIVE_RECORD,
               sql:               sql,
               name:              name,
               binds:             binds,
@@ -154,19 +140,19 @@ DependencyDetection.defer do
 
   executes do
     if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
-
-      activerecord_extension = if ::ActiveRecord::VERSION::MAJOR.to_i == 4
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions41
-      elsif ::ActiveRecord::VERSION::MAJOR.to_i == 5
-        if ::ActiveRecord::VERSION::MINOR.to_i == 0
-          ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
-        elsif ::ActiveRecord::VERSION::MINOR.to_i >= 1
-          ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
-        end
+      major_version = ::ActiveRecord::VERSION::MAJOR.to_i
+      minor_version = ::ActiveRecord::VERSION::MINOR.to_i
+
+      activerecord_extension = if major_version == 4
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
+      elsif major_version == 5 && minor_version == 0
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+      elsif major_version == 5 && minor_version == 1
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
       end
 
       unless activerecord_extension.nil?
-        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, activerecord_extension)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
       end
     end
   end