newrelic_rpm 6.7.0.359 → 6.12.0.367

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTraceTransportType
+      extend self
+
+      ALLOWABLE_TRANSPORT_TYPES = [
+        NewRelic::UNKNOWN,
+        NewRelic::HTTP,
+        NewRelic::HTTPS,
+        "Kafka",
+        "JMS",
+        "IronMQ",
+        "AMQP",
+        "Queue",
+        "Other",
+      ].freeze
+
+      URL_SCHEMES = {
+        'http'  => NewRelic::HTTP,
+        'https' => NewRelic::HTTPS,
+      }.freeze
+
+      RACK_URL_SCHEME = 'rack.url_scheme'
+
+      def from value
+        ALLOWABLE_TRANSPORT_TYPES.include?(value) ? value : NewRelic::UNKNOWN
+      end
+
+      def for_rack_request request
+        URL_SCHEMES[request[RACK_URL_SCHEME]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'trace_context_payload'
+
+module NewRelic
+  module Agent
+    module DistributedTracing
+      class TraceContext
+        VERSION = 0x0
+
+        COMMA             = ','
+        EQUALS            = '='
+        INVALID_TRACE_ID  = ('0' * 32)
+        INVALID_PARENT_ID = ('0' * 16)
+        INVALID_VERSION   = 'ff'
+
+        TRACE_ID_KEY          = 'trace_id'
+        TRACE_FLAGS_KEY       = 'trace_flags'
+        PARENT_ID_KEY         = 'parent_id'
+        VERSION_KEY           = 'version'
+        UNDEFINED_FIELDS_KEY  = 'undefined_fields'
+
+        TP_VERSION          = "(?<#{VERSION_KEY}>[a-f\\d]{2})"
+        TP_TRACE_ID         = "(?<#{TRACE_ID_KEY}>[a-f\\d]{32})"
+        TP_PARENT_ID        = "(?<#{PARENT_ID_KEY}>[a-f\\d]{16})"
+        TP_TRACE_FLAGS      = "(?<#{TRACE_FLAGS_KEY}>\\d{2})"
+        TP_UNDEFINED_FIELDS = "(?<#{UNDEFINED_FIELDS_KEY}>-[a-zA-Z\\d-]*)"
+        TRACE_PARENT_REGEX  = /\A#{TP_VERSION}-#{TP_TRACE_ID}-#{TP_PARENT_ID}-#{TP_TRACE_FLAGS}#{TP_UNDEFINED_FIELDS}?\z/
+
+        TRACE_PARENT_FORMAT_STRING = "%02x-%s-%s-%02x"
+
+        MAX_TRACE_STATE_SIZE = 512 # bytes
+        MAX_TRACE_STATE_ENTRY_SIZE = 128 # bytes
+
+        SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION = "Supportability/TraceContext/TraceParent/Parse/Exception"
+        SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION  = "Supportability/TraceContext/TraceState/Parse/Exception"
+        SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY = "Supportability/TraceContext/TraceState/InvalidNrEntry"
+
+        class << self
+          def insert format: NewRelic::FORMAT_NON_RACK,
+                     carrier: nil,
+                     parent_id: nil,
+                     trace_id: nil,
+                     trace_flags: nil,
+                     trace_state: nil
+
+            trace_parent_header = trace_parent_header_for_format format
+            carrier[trace_parent_header] = format_trace_parent \
+              trace_id: trace_id,
+              parent_id: parent_id,
+              trace_flags: trace_flags
+
+            trace_state_header = trace_state_header_for_format format
+            carrier[trace_state_header] = trace_state if trace_state && !trace_state.empty?
+          end
+
+          def parse format: NewRelic::FORMAT_NON_RACK,
+                    carrier: nil,
+                    trace_state_entry_key: nil
+            trace_parent = extract_traceparent(format, carrier)
+            unless trace_parent_valid? trace_parent
+              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION
+              return nil
+            end
+
+            begin
+              if header_data = extract_tracestate(format, carrier, trace_state_entry_key)
+                header_data.trace_parent = trace_parent
+                header_data
+              end
+            rescue Exception
+              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION
+              return nil
+            end
+          end
+
+          def create_trace_state_entry entry_key, payload
+            "#{entry_key}=#{payload}".dup
+          end
+
+          private
+
+          def format_trace_parent trace_id: nil,
+                                  parent_id: nil,
+                                  trace_flags: nil
+            sprintf TRACE_PARENT_FORMAT_STRING,
+                    VERSION,
+                    trace_id,
+                    parent_id,
+                    trace_flags
+          end
+
+          def extract_traceparent format, carrier
+            header_name = trace_parent_header_for_format format
+            return unless header = carrier[header_name]
+            if matchdata = header.match(TRACE_PARENT_REGEX)
+              TRACE_PARENT_REGEX.named_captures.inject({}) do |hash, (name, (index))|
+                hash[name] = matchdata[index]
+                hash
+              end
+            end
+          end
+
+          def trace_parent_valid? trace_parent
+            return false if trace_parent.nil?
+            return false if trace_parent[TRACE_ID_KEY] == INVALID_TRACE_ID
+            return false if trace_parent[PARENT_ID_KEY] == INVALID_PARENT_ID
+            return false if trace_parent[VERSION_KEY] == INVALID_VERSION
+            return false if trace_parent[VERSION_KEY].to_i(16) == VERSION && !trace_parent[UNDEFINED_FIELDS_KEY].nil?
+
+            true
+          end
+
+          def trace_parent_header_for_format format
+            if format == NewRelic::FORMAT_RACK
+              NewRelic::HTTP_TRACEPARENT_KEY
+            else
+              NewRelic::TRACEPARENT_KEY
+            end
+          end
+
+          def trace_state_header_for_format format
+            if format == NewRelic::FORMAT_RACK
+              NewRelic::HTTP_TRACESTATE_KEY
+            else
+              NewRelic::TRACESTATE_KEY
+            end
+          end
+
+          def extract_tracestate format, carrier, trace_state_entry_key
+            header_name = trace_state_header_for_format format
+            header = carrier[header_name]
+            return HeaderData.create if header.nil? || header.empty?
+
+            payload = nil
+            trace_state_size = 0
+            trace_state_vendors = String.new
+            trace_state = header.split(COMMA).map(&:strip)
+            trace_state.reject! do |entry|
+              if entry == NewRelic::EMPTY_STR
+                false
+              else
+                vendor_id = entry.slice 0, entry.index(EQUALS)
+                if vendor_id == trace_state_entry_key
+                  payload = entry.slice! trace_state_entry_key.size + 1, entry.size
+                  true
+                else
+                  trace_state_size += entry.size
+                  trace_state_vendors << vendor_id << COMMA
+                  false
+                end
+              end
+            end
+
+            trace_state_vendors.chomp! COMMA
+
+            HeaderData.create trace_state_payload: payload ? decode_payload(payload) : nil,
+                        trace_state_entries: trace_state,
+                        trace_state_size: trace_state_size,
+                        trace_state_vendors: trace_state_vendors
+          end
+
+          def decode_payload payload
+            TraceContextPayload.from_s payload
+          rescue
+            if payload
+              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY
+            end
+            return nil
+          end
+        end
+
+        class HeaderData
+          class << self
+            def create trace_parent: nil,
+                       trace_state_payload: nil,
+                       trace_state_entries: nil,
+                       trace_state_size: 0,
+                       trace_state_vendors: nil
+              new trace_parent, \
+                  trace_state_payload, \
+                  trace_state_entries, \
+                  trace_state_size, \
+                  trace_state_vendors
+            end
+          end
+
+          def initialize trace_parent, trace_state_payload, trace_state_entries, trace_state_size, trace_state_vendors
+            @trace_parent = trace_parent
+            @trace_state = nil
+            @trace_state_entries = trace_state_entries
+            @trace_state_payload = trace_state_payload
+            @trace_state_size = trace_state_size
+            @trace_state_vendors = trace_state_vendors
+          end
+
+          attr_accessor :trace_parent, :trace_state_payload, :trace_state_vendors
+
+          def trace_state trace_state_entry
+            @trace_state ||= join_trace_state trace_state_entry.size
+            @trace_state_entries = nil
+
+            trace_state_entry << @trace_state
+          end
+
+          def trace_id
+            @trace_parent[TRACE_ID_KEY]
+          end
+
+          def parent_id
+            @trace_parent[PARENT_ID_KEY]
+          end
+
+          private
+
+          def join_trace_state trace_state_entry_size
+            return @trace_state || NewRelic::EMPTY_STR if @trace_state_entries.nil? || @trace_state_entries.empty?
+
+            max_size = MAX_TRACE_STATE_SIZE - trace_state_entry_size
+            return @trace_state_entries.join(COMMA).prepend(COMMA) if @trace_state_size < max_size
+
+            joined_trace_state = ''.dup
+
+            used_size = 0
+
+            @trace_state_entries.each do |entry|
+              entry_size = entry.size + 1
+              break if used_size + entry_size > max_size
+              next if entry_size > MAX_TRACE_STATE_ENTRY_SIZE
+
+              joined_trace_state << COMMA << entry
+              used_size += entry_size
+            end
+
+            joined_trace_state
+          end
+
+        end
+
+      end
+    end
+  end
+end

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/newrelic-ruby-agent/blob/main/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 << sprintf("%.6f", priority)
+        result << DELIMITER << timestamp.to_s
+        result
+      end
+    end
+  end
+end

data/lib/new_relic/agent/encoding_normalizer.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # This module was extracted from NewRelic::JSONWrapper
 

data/lib/new_relic/agent/error_collector.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 require 'new_relic/agent/error_trace_aggregator'
 require 'new_relic/agent/error_event_aggregator'
 
@@ -32,7 +32,6 @@ module NewRelic
         end
       end
 
-
       def initialize_ignored_errors(ignore_errors)
         @ignore.clear
         ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
@@ -74,7 +73,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
@@ -117,14 +116,22 @@ module NewRelic
         NewRelic::LanguageSupport.jruby? && exception.respond_to?(:java_class)
       end
 
-      def exception_tagged?(exception)
+      def exception_tagged_with?(ivar, exception)
         return false if exception_is_java_object?(exception)
-        exception.instance_variable_defined?(EXCEPTION_TAG_IVAR)
+        exception.instance_variable_defined?(ivar)
+      end
+
+      def tag_exception_using(ivar, exception)
+        return if exception_is_java_object?(exception) || exception.frozen?
+        begin
+          exception.instance_variable_set(ivar, true)
+        rescue => e
+          NewRelic::Agent.logger.warn("Failed to tag exception: #{exception}: ", e)
+        end
       end
 
       def tag_exception(exception)
-        return if exception_is_java_object?(exception)
-        return if exception.frozen?
+        return if exception_is_java_object?(exception) || exception.frozen?
         begin
           exception.instance_variable_set(EXCEPTION_TAG_IVAR, true)
         rescue => e
@@ -169,9 +176,9 @@ module NewRelic
 
       def skip_notice_error?(exception)
         disabled? ||
-          error_is_ignored?(exception) ||
-          exception.nil? ||
-          exception_tagged?(exception)
+        error_is_ignored?(exception) ||
+        exception.nil? ||
+        exception_tagged_with?(EXCEPTION_TAG_IVAR, exception)
       end
 
       # calls a method on an object, if it responds to it - used for
@@ -191,8 +198,18 @@ module NewRelic
         sense_method(actual_exception, :backtrace) || '<no stack trace>'
       end
 
+      def notice_segment_error(segment, exception, options={})
+        return if skip_notice_error?(exception)
+
+        segment.set_noticed_error create_noticed_error(exception, options)
+        exception
+      rescue => e
+        ::NewRelic::Agent.logger.warn("Failure when capturing segment error '#{exception}':", e)
+        nil
+      end
+
       # See NewRelic::Agent.notice_error for options and commentary
-      def notice_error(exception, options={}) #THREAD_LOCAL_ACCESS
+      def notice_error(exception, options={}, span_id=nil)
         return if skip_notice_error?(exception)
 
         tag_exception(exception)
@@ -205,8 +222,10 @@ module NewRelic
 
         noticed_error = create_noticed_error(exception, options)
         error_trace_aggregator.add_to_error_queue(noticed_error)
-        payload = state.current_transaction ? state.current_transaction.payload : nil
-        error_event_aggregator.record(noticed_error, payload)
+        transaction = state.current_transaction
+        payload = transaction ? transaction.payload : nil
+        span_id ||= (transaction && transaction.current_segment) ? transaction.current_segment.guid : nil
+        error_event_aggregator.record(noticed_error, payload, span_id)
         exception
       rescue => e
         ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", e)
@@ -227,13 +246,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)