newrelic_rpm 6.6.0.358 → 6.11.0.365

data/lib/new_relic/agent/monitors/distributed_tracing_monitor.rb

@@ -0,0 +1,27 @@
+# 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 DistributedTracing
+      class Monitor < InboundRequestMonitor
+        def on_finished_configuring(events)
+          return unless NewRelic::Agent.config[:'distributed_tracing.enabled']
+          events.subscribe(:before_call, &method(:on_before_call))
+        end
+
+        def on_before_call(request)
+          unless NewRelic::Agent.config[:'distributed_tracing.enabled']
+            NewRelic::Agent.logger.warn "Not configured to accept distributed trace headers" 
+            return
+          end
+
+          return unless txn = Tracer.current_transaction
+
+          txn.distributed_tracer.accept_incoming_request request
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/{inbound_request_monitor.rb → monitors/inbound_request_monitor.rb}

@@ -28,7 +28,7 @@ module NewRelic
       end
 
       def setup_obfuscator
-        @obfuscator = NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+        @obfuscator = Obfuscator.new(Agent.config[:encoding_key])
       end
 
       def deserialize_header(encoded_header, key)

data/lib/new_relic/agent/{synthetics_monitor.rb → monitors/synthetics_monitor.rb}

@@ -2,8 +2,6 @@
 # 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/agent/inbound_request_monitor'
-
 module NewRelic
   module Agent
     class SyntheticsMonitor < InboundRequestMonitor
@@ -40,7 +38,7 @@ module NewRelic
 
         def is_trusted?(incoming_payload)
           account_id = incoming_payload[1]
-          NewRelic::Agent.config[:trusted_account_ids].include?(account_id)
+          Agent.config[:trusted_account_ids].include?(account_id)
         end
 
         def is_valid_payload?(incoming_payload)
@@ -48,7 +46,7 @@ module NewRelic
         end
 
         def reject_messaging_synthetics_header headers
-          headers.reject {|k,_| k == NewRelic::Agent::CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER}
+          headers.reject {|k,_| k == CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER}
         end
 
       end

data/lib/new_relic/agent/new_relic_service.rb

@@ -65,7 +65,6 @@ module NewRelic
         # clear out our cached values whenever the run ID changes.
         #
         reset_remote_method_uris
-
         @agent_id = id
       end
 
@@ -92,14 +91,16 @@ module NewRelic
         token = Agent.config[:security_policies_token]
 
         if token && !token.empty?
-          response = invoke_remote(:preconnect, [{'security_policies_token' => token}])
+          response = invoke_remote(:preconnect, [{'security_policies_token' => token, 'high_security' => false}])
 
           validator = SecurityPolicySettings::Validator.new(response)
           validator.validate_matching_agent_config!
 
           response
+        elsif Agent.config[:high_security]
+          invoke_remote(:preconnect, [{'high_security' => true}])
         else
-          invoke_remote(:preconnect, [])
+          invoke_remote(:preconnect, [{'high_security' => false}])
         end
       end
 
@@ -196,10 +197,10 @@ module NewRelic
         encoding = 'identity'
         if data.size > 64 * 1024
           encoding = Agent.config[:compressed_content_encoding]
-          data = if encoding == 'gzip'
-            Encoders::Compressed::Gzip.encode(data)
-          else
+          data = if encoding == 'deflate'
             Encoders::Compressed::Deflate.encode(data)
+          else
+            Encoders::Compressed::Gzip.encode(data)
           end
         end
         check_post_size(data, endpoint)

data/lib/new_relic/agent/noticible_error.rb

@@ -0,0 +1,22 @@
+# 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
+
+module NewRelic
+  module Agent
+
+    # This class is used for instrumentations that have exceptions or error classes
+    # not derived from Ruby's usual Exception or StandardError or in situations
+    # where we do not have such Exception object to work with.
+    class NoticibleError
+      attr_reader :class_name, :message
+
+      def initialize class_name, message
+        @class_name = class_name
+        @message = message
+      end
+    end
+
+  end
+end

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -12,6 +12,7 @@ module NewRelic
     class SpanEventAggregator < EventAggregator
       named :SpanEventAggregator
       capacity_key :'span_events.max_samples_stored'
+
       enabled_keys :'span_events.enabled',
                    :'distributed_tracing.enabled'
 

data/lib/new_relic/agent/span_event_primitive.rb

@@ -1,12 +1,13 @@
 # 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
 
 # This module builds the data structures necessary to create a Span
 # event for a segment.
 
 require 'new_relic/agent/payload_metric_mapping'
-require 'new_relic/agent/distributed_trace_payload'
+require 'new_relic/agent/distributed_tracing/distributed_trace_payload'
 
 module NewRelic
   module Agent
@@ -15,70 +16,80 @@ module NewRelic
       extend self
 
       # Strings for static keys of the event structure
-      TYPE_KEY             = 'type'.freeze
-      TRACE_ID_KEY         = 'traceId'.freeze
-      GUID_KEY             = 'guid'.freeze
-      PARENT_ID_KEY        = 'parentId'.freeze
-      GRANDPARENT_ID_KEY   = 'grandparentId'.freeze
-      TRANSACTION_ID_KEY   = 'transactionId'.freeze
-      SAMPLED_KEY          = 'sampled'.freeze
-      PRIORITY_KEY         = 'priority'.freeze
-      TIMESTAMP_KEY        = 'timestamp'.freeze
-      DURATION_KEY         = 'duration'.freeze
-      NAME_KEY             = 'name'.freeze
-      CATEGORY_KEY         = 'category'.freeze
-      HTTP_URL_KEY         = 'http.url'.freeze
-      HTTP_METHOD_KEY      = 'http.method'.freeze
-      COMPONENT_KEY        = 'component'.freeze
-      DB_INSTANCE_KEY      = 'db.instance'.freeze
-      DB_STATEMENT_KEY     = 'db.statement'.freeze
-      PEER_ADDRESS_KEY     = 'peer.address'.freeze
-      PEER_HOSTNAME_KEY    = 'peer.hostname'.freeze
-      SPAN_KIND_KEY        = 'span.kind'.freeze
-      ENTRY_POINT_KEY      = 'nr.entryPoint'.freeze
+      ELLIPSIS             = '...'
+      TYPE_KEY             = 'type'
+      TRACE_ID_KEY         = 'traceId'
+      GUID_KEY             = 'guid'
+      PARENT_ID_KEY        = 'parentId'
+      GRANDPARENT_ID_KEY   = 'grandparentId'
+      TRANSACTION_ID_KEY   = 'transactionId'
+      SAMPLED_KEY          = 'sampled'
+      PRIORITY_KEY         = 'priority'
+      TIMESTAMP_KEY        = 'timestamp'
+      DURATION_KEY         = 'duration'
+      NAME_KEY             = 'name'
+      CATEGORY_KEY         = 'category'
+      HTTP_URL_KEY         = 'http.url'
+      HTTP_METHOD_KEY      = 'http.method'
+      HTTP_STATUS_CODE_KEY = 'http.statusCode'
+      COMPONENT_KEY        = 'component'
+      DB_INSTANCE_KEY      = 'db.instance'
+      DB_STATEMENT_KEY     = 'db.statement'
+      PEER_ADDRESS_KEY     = 'peer.address'
+      PEER_HOSTNAME_KEY    = 'peer.hostname'
+      SPAN_KIND_KEY        = 'span.kind'
+      ENTRY_POINT_KEY      = 'nr.entryPoint'
+      TRUSTED_PARENT_KEY   = "trustedParentId"
+      TRACING_VENDORS_KEY  = "tracingVendors"
 
       # Strings for static values of the event structure
-      EVENT_TYPE         = 'Span'.freeze
-      GENERIC_CATEGORY   = 'generic'.freeze
-      HTTP_CATEGORY      = 'http'.freeze
-      DATASTORE_CATEGORY = 'datastore'.freeze
-      CLIENT             = 'client'.freeze
-
-      # To avoid allocations when we have empty custom or agent attributes
-      EMPTY_HASH = {}.freeze
+      EVENT_TYPE         = 'Span'
+      GENERIC_CATEGORY   = 'generic'
+      HTTP_CATEGORY      = 'http'
+      DATASTORE_CATEGORY = 'datastore'
+      CLIENT             = 'client'
+
+      # Builds a Hash of error attributes as well as the Span ID when
+      # an error is present.  Otherwise, returns nil when no error present.
+      def error_attributes segment
+        return if Agent.config[:high_security] || !segment.noticed_error
+        segment.noticed_error.build_error_attributes
+        segment.noticed_error_attributes
+      end
 
-      def for_segment(segment)
+      def for_segment segment
         intrinsics = intrinsics_for(segment)
         intrinsics[CATEGORY_KEY] = GENERIC_CATEGORY
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        [intrinsics, custom_attributes(segment.attributes), error_attributes(segment) || NewRelic::EMPTY_HASH]
       end
 
-      def for_external_request_segment(segment)
+      def for_external_request_segment segment
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY]   = segment.library
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
+        intrinsics[HTTP_STATUS_CODE_KEY] = segment.http_status_code if segment.http_status_code
         intrinsics[CATEGORY_KEY]    = HTTP_CATEGORY
         intrinsics[SPAN_KIND_KEY]   = CLIENT
 
-        agent_attributes = {}
+        agent_attributes = error_attributes(segment) || {}
 
         if allowed?(HTTP_URL_KEY)
           agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
         end
 
-        [intrinsics, EMPTY_HASH, agent_attributes]
+        [intrinsics, custom_attributes(segment.attributes), agent_attributes]
       end
 
-      def for_datastore_segment(segment)
+      def for_datastore_segment segment
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY] = segment.product
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
 
-        agent_attributes = {}
+        agent_attributes = error_attributes(segment) || {}
 
         if segment.database_name && allowed?(DB_INSTANCE_KEY)
           agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
@@ -96,48 +107,70 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
         end
 
-        [intrinsics, EMPTY_HASH, agent_attributes]
+        [intrinsics, custom_attributes(segment.attributes), agent_attributes]
       end
 
       private
 
-      def intrinsics_for(segment)
-        intrinsics =
-        {
+      def intrinsics_for segment
+        intrinsics = {
           TYPE_KEY           => EVENT_TYPE,
           TRACE_ID_KEY       => segment.transaction.trace_id,
           GUID_KEY           => segment.guid,
           TRANSACTION_ID_KEY => segment.transaction.guid,
-          SAMPLED_KEY        => segment.transaction.sampled?,
           PRIORITY_KEY       => segment.transaction.priority,
           TIMESTAMP_KEY      => milliseconds_since_epoch(segment),
           DURATION_KEY       => segment.duration,
           NAME_KEY           => segment.name
         }
 
-        parent_id = parent_guid(segment)
-        intrinsics[PARENT_ID_KEY] = parent_id if parent_id
+        # with infinite-tracing, transactions may or may not be sampled!
+        if segment.transaction.sampled?
+          intrinsics[SAMPLED_KEY] = true
+        end
 
-        intrinsics[ENTRY_POINT_KEY] = true unless segment.parent
+        if segment.parent.nil?
+          intrinsics[ENTRY_POINT_KEY] = true
+          if txn = segment.transaction
+            if header_data = txn.distributed_tracer.trace_context_header_data
+              if trace_state_vendors = header_data.trace_state_vendors
+                intrinsics[TRACING_VENDORS_KEY] = trace_state_vendors unless trace_state_vendors == NewRelic::EMPTY_STR
+              end
+            end
+            if trace_state_payload = txn.distributed_tracer.trace_state_payload
+              intrinsics[TRUSTED_PARENT_KEY] = trace_state_payload.id if trace_state_payload.id
+            end
+          end
+        end
 
+        if parent_id = parent_guid(segment)
+          intrinsics[PARENT_ID_KEY] = parent_id
+        end
         intrinsics
       end
 
-      def parent_guid(segment)
+      def custom_attributes attributes
+        if attributes
+          result = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+          result.freeze
+        else
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def parent_guid segment
         if segment.parent
           segment.parent.guid
-        elsif segment.transaction && segment.transaction.distributed_trace?
-          segment.transaction.distributed_trace_payload.id
+        elsif txn = segment.transaction
+          txn.distributed_tracer.parent_guid
         end
       end
 
-      def milliseconds_since_epoch(segment)
+      def milliseconds_since_epoch segment
         Integer(segment.start_time.to_f * 1000.0)
       end
 
-      ELLIPSIS = '...'.freeze
-
-      def truncate(value, max_size=255)
+      def truncate value, max_size=255
         value = value.to_s
         if value.bytesize > max_size
           value.byteslice(0, max_size - 2).chop! << ELLIPSIS
@@ -146,7 +179,7 @@ module NewRelic
         end
       end
 
-      def allowed?(key)
+      def allowed? key
         NewRelic::Agent.instance.attribute_filter.allows_key?(key, AttributeFilter::DST_SPAN_EVENTS)
       end
     end

data/lib/new_relic/agent/sql_sampler.rb

@@ -159,10 +159,10 @@ module NewRelic
       def distributed_trace_intrinsics(state)
         transaction = state.current_transaction
         params = nil
-        if transaction && transaction.distributed_trace_payload
+        if transaction && transaction.distributed_tracer.distributed_trace_payload
           params = {}
-          payload = transaction.distributed_trace_payload
-          payload.assign_intrinsics transaction, params
+          payload = transaction.distributed_tracer.distributed_trace_payload
+          DistributedTraceIntrinsics.copy_from_transaction transaction, payload, params
           params[PRIORITY] = transaction.priority
         end
         params

data/lib/new_relic/agent/supported_versions.rb

@@ -11,7 +11,7 @@ module NewRelic
       {
         :type        => :ruby,
         :name        => "MRI",
-        :supported   => ["2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0", "~>2.4.0", "~>2.5.0"],
+        :supported   => ["2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0", "~>2.4.0", "~>2.5.0", "~>2.6.0", "~>2.7.0"],
         :deprecated  => ["1.8.6", "1.8.7", "1.9.2", "1.9.3"],
         :url         => "https://www.ruby-lang.org",
         :feed        => "https://www.ruby-lang.org/en/feeds/news.rss",
@@ -119,7 +119,7 @@ module NewRelic
       :activerecord =>
       {
         :type        => :database,
-        :supported   => ["~>3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0", "~>5.0.0", "~>5.1.0"],
+        :supported   => ["~>3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0", "~>5.0.0", "~>5.1.0", "~>6.0.0"],
         :deprecated  => ["~>2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0",],
         :url         => "https://rubygems.org/gems/activerecord",
         :feed        => "https://rubygems.org/gems/activerecord/versions.atom",

data/lib/new_relic/agent/system_info.rb

@@ -170,11 +170,20 @@ module NewRelic
 
         container_id = case cpu_cgroup
         # docker native driver w/out systemd (fs)
-        when /[0-9a-f]{64}/ then $&
+        when /[0-9a-f]{64,}/
+          if $&.length == 64
+            $&
+          else # container ID is too long
+            ::NewRelic::Agent.logger.debug("Ignoring docker ID of invalid length: '#{cpu_cgroup}'")
+            return
+          end
         # docker native driver with systemd
-        when '/'            then nil
+        when '/'              then nil
         # in a cgroup, but we don't recognize its format
-        when /docker/       then
+        when /docker\/.*[^0-9a-f]/ then
+          ::NewRelic::Agent.logger.debug("Cgroup indicates docker but container_id has invalid characters: '#{cpu_cgroup}'")
+          return
+        when /docker/ then
           ::NewRelic::Agent.logger.debug("Cgroup indicates docker but container_id unrecognized: '#{cpu_cgroup}'")
           ::NewRelic::Agent.increment_metric "Supportability/utilization/docker/error"
           return

data/lib/new_relic/agent/tracer.rb

@@ -39,6 +39,38 @@ module NewRelic
           state.current_transaction
         end
 
+        # Returns the trace_id of the current_transaction, or +nil+ if
+        # none exists.
+        #
+        # @api public
+        def current_trace_id
+          if txn = current_transaction
+            txn.trace_id
+          end
+        end
+        alias_method :trace_id, :current_trace_id
+
+        # Returns the id of the current span, or +nil+ if none exists.
+        #
+        # @api public
+        def current_span_id
+          if span = current_segment
+            span.guid
+          end
+        end
+        alias_method :span_id, :current_span_id
+
+        # Returns a boolean indicating whether the current_transaction
+        # is sampled, or +nil+ if there is no current transaction.
+        #
+        # @api public
+        def transaction_sampled?
+          if txn = current_transaction
+            txn.sampled?
+          end
+        end
+        alias_method :sampled?, :transaction_sampled?
+
         # Runs the given block of code in a transaction.
         #
         # @param [String] name reserved for New Relic internal use
@@ -70,9 +102,9 @@ module NewRelic
             # only wrap the yield to be absolutely sure we don't report agent
             # problems as app errors
             yield
-          rescue => e
-            current_transaction.notice_error(e)
-            raise e
+          rescue => exception
+            current_transaction.notice_error(exception)
+            raise
           ensure
             finishable.finish if finishable
           end
@@ -88,7 +120,7 @@ module NewRelic
         #   New-Relic-specific prefix
         #
         # @param [Symbol] category +:web+ for web transactions or
-        #   +:background+ for background transactions
+        #   +:task+ for background transactions
         #
         # @param [Hash] options reserved for New Relic internal use
         #
@@ -125,8 +157,8 @@ module NewRelic
 
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_transaction_or_segment', e)
+        rescue => exception
+          log_error('start_transaction_or_segment', exception)
         end
 
         # Takes name or partial_name and a category.
@@ -158,18 +190,18 @@ module NewRelic
                                             options)
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_transaction', e)
+        rescue => exception
+          log_error('start_transaction', exception)
         end
 
         def create_distributed_trace_payload
           return unless txn = current_transaction
-          txn.create_distributed_trace_payload
+          txn.distributed_tracer.create_distributed_trace_payload
         end
 
         def accept_distributed_trace_payload(payload)
           return unless txn = current_transaction
-          txn.accept_distributed_trace_payload(payload)
+          txn.distributed_tracer.accept_distributed_trace_payload(payload)
         end
 
         # Returns the currently active segment in the transaction in
@@ -219,8 +251,8 @@ module NewRelic
 
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_segment', e)
+        rescue => exception
+          log_error('start_segment', exception)
         end
 
         UNKNOWN = "Unknown".freeze
@@ -278,8 +310,8 @@ module NewRelic
 
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_datastore_segment', e)
+        rescue => exception
+          log_error('start_datastore_segment', exception)
         end
 
         # Creates and starts an external request segment using the
@@ -325,8 +357,23 @@ module NewRelic
 
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_external_request_segment', e)
+        rescue => exception
+          log_error('start_external_request_segment', exception)
+        end
+
+        # Will potentially capture and notice an error at the
+        # segment that was executing when error occurred.
+        # if passed +segment+ is something that doesn't 
+        # respond to +notice_segment_error+ then this method
+        # is effectively just a yield to the given &block
+        def capture_segment_error segment
+          return unless block_given?
+          yield
+        rescue => exception
+          if segment && segment.is_a?(Transaction::AbstractSegment)
+            segment.notice_error exception
+          end
+          raise
         end
 
         # For New Relic internal use only.
@@ -358,8 +405,8 @@ module NewRelic
 
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_datastore_segment', e)
+        rescue => exception
+          log_error('start_datastore_segment', exception)
         end
 
         # This method should only be used by Tracer for access to the