newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/transaction/message_broker_segment.rb

@@ -1,24 +1,24 @@
-# 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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/segment'
-require 'new_relic/agent/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
 
 module NewRelic
   module Agent
     class Transaction
       class MessageBrokerSegment < Segment
-        CONSUME  = 'Consume'.freeze
+        CONSUME = 'Consume'.freeze
         EXCHANGE = 'Exchange'.freeze
-        NAMED    = 'Named/'.freeze
-        PRODUCE  = 'Produce'.freeze
-        QUEUE    = 'Queue'.freeze
-        PURGE    = 'Purge'.freeze
-        SLASH    = '/'.freeze
-        TEMP     = 'Temp'.freeze
-        TOPIC    = 'Topic'.freeze
-        UNKNOWN  = 'Unknown'.freeze
+        NAMED = 'Named/'.freeze
+        PRODUCE = 'Produce'.freeze
+        QUEUE = 'Queue'.freeze
+        PURGE = 'Purge'.freeze
+        SLASH = '/'.freeze
+        TEMP = 'Temp'.freeze
+        TOPIC = 'Topic'.freeze
+        UNKNOWN = 'Unknown'.freeze
 
         DESTINATION_TYPES = [
           :exchange,
@@ -36,35 +36,29 @@ module NewRelic
         }
 
         TYPES = {
-          exchange:        EXCHANGE,
+          exchange: EXCHANGE,
           temporary_queue: QUEUE,
-          queue:           QUEUE,
+          queue: QUEUE,
           temporary_topic: TOPIC,
-          topic:           TOPIC,
-          unknown:         EXCHANGE
+          topic: TOPIC,
+          unknown: EXCHANGE
         }
 
         METRIC_PREFIX = 'MessageBroker/'.freeze
 
         attr_reader :action,
-                    :destination_name,
-                    :destination_type,
-                    :library,
-                    :headers
-
-        def initialize action: nil,
-                       library: nil,
-                       destination_type: nil,
-                       destination_name: nil,
-                       headers: nil,
-                       parameters: nil,
-                       start_time: nil
-
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: action' if action.nil?
-          raise ArgumentError, 'missing required argument: library' if library.nil?
-          raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-          raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+          :destination_name,
+          :destination_type,
+          :library,
+          :headers
+
+        def initialize(action:,
+          library:,
+          destination_type:,
+          destination_name:,
+          headers: nil,
+          parameters: nil,
+          start_time: nil)
 
           @action = action
           @library = library
@@ -72,11 +66,12 @@ module NewRelic
           @destination_name = destination_name
           @headers = headers
           super(nil, nil, start_time)
-          params.merge! parameters if parameters
+          params.merge!(parameters) if parameters
         end
 
         def name
           return @name if @name
+
           @name = METRIC_PREFIX + library
           @name << SLASH << TYPES[destination_type] << SLASH << ACTIONS[action] << SLASH
 
@@ -89,21 +84,14 @@ module NewRelic
           @name
         end
 
-        NEWRELIC_TRACE_KEY = "newrelic".freeze
-
-        def insert_distributed_trace_header
-          return unless Agent.config[:'distributed_tracing.enabled']
-          payload = transaction.create_distributed_trace_payload
-          headers[NEWRELIC_TRACE_KEY] = payload.http_safe if payload
-        end
-
         def transaction_assigned
           if headers && transaction && action == :produce && record_metrics?
-            insert_distributed_trace_header
-            transaction.add_message_cat_headers headers if CrossAppTracing.cross_app_enabled?
+            transaction.distributed_tracer.insert_distributed_trace_header(headers)
+            transaction.distributed_tracer.insert_cat_headers(headers)
+            transaction.distributed_tracer.log_request_headers(headers)
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error during message header processing", e
+          NewRelic::Agent.logger.error("Error during message header processing", e)
         end
       end
     end

data/lib/new_relic/agent/transaction/request_attributes.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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/http_clients/uri_util'
 
@@ -9,60 +9,60 @@ module NewRelic
     class Transaction
       class RequestAttributes
         attr_reader :request_path, :referer, :accept, :content_length, :content_type,
-                    :host, :port, :user_agent, :request_method
+          :host, :port, :user_agent, :request_method
 
         HTTP_ACCEPT_HEADER_KEY = "HTTP_ACCEPT".freeze
 
-        def initialize request
-          @request_path = path_from_request request
-          @referer = referer_from_request request
-          @accept = attribute_from_env request, HTTP_ACCEPT_HEADER_KEY
-          @content_length = content_length_from_request request
-          @content_type = attribute_from_request request, :content_type
-          @host = attribute_from_request request, :host
-          @port = port_from_request request
-          @user_agent = attribute_from_request request, :user_agent
-          @request_method = attribute_from_request request, :request_method
+        def initialize(request)
+          @request_path = path_from_request(request)
+          @referer = referer_from_request(request)
+          @accept = attribute_from_env(request, HTTP_ACCEPT_HEADER_KEY)
+          @content_length = content_length_from_request(request)
+          @content_type = attribute_from_request(request, :content_type)
+          @host = attribute_from_request(request, :host)
+          @port = port_from_request(request)
+          @user_agent = attribute_from_request(request, :user_agent)
+          @request_method = attribute_from_request(request, :request_method)
         end
 
-        def assign_agent_attributes txn
-         default_destinations = AttributeFilter::DST_TRANSACTION_TRACER|
-                                AttributeFilter::DST_TRANSACTION_EVENTS|
-                                AttributeFilter::DST_ERROR_COLLECTOR
+        def assign_agent_attributes(txn)
+          default_destinations = AttributeFilter::DST_TRANSACTION_TRACER |
+            AttributeFilter::DST_TRANSACTION_EVENTS |
+            AttributeFilter::DST_ERROR_COLLECTOR
 
           if referer
-            txn.add_agent_attribute :'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR
+            txn.add_agent_attribute(:'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR)
           end
 
           if request_path
-            txn.add_agent_attribute :'request.uri',
-                                    request_path,
-                                    AttributeFilter::DST_TRANSACTION_TRACER |
-                                    AttributeFilter::DST_ERROR_COLLECTOR
+            txn.add_agent_attribute(:'request.uri',
+              request_path,
+              AttributeFilter::DST_TRANSACTION_TRACER |
+                AttributeFilter::DST_ERROR_COLLECTOR)
           end
 
           if accept
-            txn.add_agent_attribute :'request.headers.accept', accept, default_destinations
+            txn.add_agent_attribute(:'request.headers.accept', accept, default_destinations)
           end
 
           if content_length
-            txn.add_agent_attribute :'request.headers.contentLength', content_length, default_destinations
+            txn.add_agent_attribute(:'request.headers.contentLength', content_length, default_destinations)
           end
 
           if content_type
-            txn.add_agent_attribute :'request.headers.contentType', content_type, default_destinations
+            txn.add_agent_attribute(:'request.headers.contentType', content_type, default_destinations)
           end
 
           if host
-            txn.add_agent_attribute :'request.headers.host', host, default_destinations
+            txn.add_agent_attribute(:'request.headers.host', host, default_destinations)
           end
 
           if user_agent
-            txn.add_agent_attribute :'request.headers.userAgent', user_agent, default_destinations
+            txn.add_agent_attribute(:'request.headers.userAgent', user_agent, default_destinations)
           end
 
           if request_method
-            txn.add_agent_attribute :'request.method', request_method, default_destinations
+            txn.add_agent_attribute(:'request.method', request_method, default_destinations)
           end
         end
 
@@ -71,9 +71,9 @@ module NewRelic
         # Make a safe attempt to get the referer from a request object, generally successful when
         # it's a Rack request.
 
-        def referer_from_request request
+        def referer_from_request(request)
           if referer = attribute_from_request(request, :referer)
-            HTTPClients::URIUtil.strip_query_string referer.to_s
+            HTTPClients::URIUtil.strip_query_string(referer.to_s)
           end
         end
 
@@ -87,31 +87,31 @@ module NewRelic
 
         ROOT_PATH = "/".freeze
 
-        def path_from_request request
+        def path_from_request(request)
           path = attribute_from_request(request, :path) || ''
           path = HTTPClients::URIUtil.strip_query_string(path)
           path.empty? ? ROOT_PATH : path
         end
 
-        def content_length_from_request request
+        def content_length_from_request(request)
           if content_length = attribute_from_request(request, :content_length)
             content_length.to_i
           end
         end
 
-        def port_from_request request
+        def port_from_request(request)
           if port = attribute_from_request(request, :port)
             port.to_i
           end
         end
 
-        def attribute_from_request request, attribute_method
-          if request.respond_to? attribute_method
+        def attribute_from_request(request, attribute_method)
+          if request.respond_to?(attribute_method)
             request.send(attribute_method)
           end
         end
 
-        def attribute_from_env request, key
+        def attribute_from_env(request, key)
           if env = attribute_from_request(request, :env)
             env[key]
           end

data/lib/new_relic/agent/transaction/segment.rb

@@ -1,9 +1,10 @@
-# 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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/abstract_segment'
 require 'new_relic/agent/span_event_primitive'
+require 'new_relic/agent/attributes'
 
 module NewRelic
   module Agent
@@ -12,27 +13,59 @@ module NewRelic
         # unscoped_metrics can be nil, a string, or array. we do this to save
         # object allocations. if allocations weren't important then we would
         # initialize it as an array that would be empty, have one item, or many items.
-        attr_reader :unscoped_metrics
+        attr_reader :unscoped_metrics, :custom_transaction_attributes
 
-        def initialize name=nil, unscoped_metrics=nil, start_time=nil
+        def initialize(name = nil, unscoped_metrics = nil, start_time = nil)
           @unscoped_metrics = unscoped_metrics
-          super name, start_time
+          super(name, start_time)
+        end
+
+        def attributes
+          @attributes ||= Attributes.new(NewRelic::Agent.instance.attribute_filter)
+        end
+
+        def add_agent_attribute(key, value, default_destinations = AttributeFilter::DST_SPAN_EVENTS)
+          attributes.add_agent_attribute(key, value, default_destinations)
+        end
+
+        def self.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+          if segment = NewRelic::Agent::Tracer.current_segment
+            segment.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+          else
+            NewRelic::Agent.logger.debug("Attempted to merge untrusted attributes without segment")
+          end
+        end
+
+        def merge_untrusted_agent_attributes(agent_attributes, prefix, default_destinations)
+          return if agent_attributes.nil?
+
+          attributes.merge_untrusted_agent_attributes(agent_attributes, prefix, default_destinations)
+        end
+
+        def add_custom_attributes(p)
+          attributes.merge_custom_attributes(p)
+        end
+
+        def self.finish(segment)
+          return unless segment
+
+          segment.finish
         end
 
         private
 
         def record_metrics
           if record_scoped_metric?
-            metric_cache.record_scoped_and_unscoped name, duration, exclusive_duration
+            metric_cache.record_scoped_and_unscoped(name, duration, exclusive_duration)
           else
-            append_unscoped_metric name
+            append_unscoped_metric(name)
           end
           if unscoped_metrics
-            metric_cache.record_unscoped unscoped_metrics, duration, exclusive_duration
+            metric_cache.record_unscoped(unscoped_metrics, duration, exclusive_duration)
           end
         end
 
-        def append_unscoped_metric metric
+        def append_unscoped_metric(metric)
           if @unscoped_metrics
             if Array === @unscoped_metrics
               if unscoped_metrics.frozen?
@@ -53,8 +86,11 @@ module NewRelic
         end
 
         def record_span_event
+          # don't record a span event if the transaction is ignored
+          return if transaction.ignore?
+
           aggregator = ::NewRelic::Agent.agent.span_event_aggregator
-          priority   = transaction.priority
+          priority = transaction.priority
 
           aggregator.record(priority: priority) do
             SpanEventPrimitive.for_segment(self)

data/lib/new_relic/agent/transaction/slowest_sample_buffer.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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/transaction_sample_buffer'
 
@@ -8,7 +8,6 @@ module NewRelic
   module Agent
     class Transaction
       class SlowestSampleBuffer < TransactionSampleBuffer
-
         CAPACITY = 1
 
         def capacity
@@ -18,7 +17,6 @@ module NewRelic
         def allow_sample?(sample)
           sample.threshold && sample.duration >= sample.threshold
         end
-
       end
     end
   end

data/lib/new_relic/agent/transaction/synthetics_sample_buffer.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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/transaction_sample_buffer'
 

data/lib/new_relic/agent/transaction/trace.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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/trace_node'
 
@@ -11,8 +11,8 @@ module NewRelic
         class FinishedTraceError < StandardError; end
 
         attr_reader :start_time, :root_node
-        attr_accessor :transaction_name, :guid, :xray_session_id, :attributes,
-                      :node_count, :finished, :threshold, :profile
+        attr_accessor :transaction_name, :guid, :attributes,
+          :node_count, :finished, :threshold, :profile
 
         ROOT = "ROOT".freeze
 
@@ -31,7 +31,8 @@ module NewRelic
           node_count = 0
           each_node do |node|
             next if node == root_node
-            node_count +=1
+
+            node_count += 1
           end
           node_count
         end
@@ -40,11 +41,6 @@ module NewRelic
           self.root_node.duration
         end
 
-        def forced?
-          return true if NewRelic::Coerce.int_or_nil(xray_session_id)
-          false
-        end
-
         def synthetics_resource_id
           intrinsic_attributes = attributes.intrinsic_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
           intrinsic_attributes[:synthetics_resource_id]
@@ -55,7 +51,8 @@ module NewRelic
         end
 
         def create_node(time_since_start, metric_name = nil)
-          raise FinishedTraceError.new "Can't create additional node for finished trace." if self.finished
+          raise FinishedTraceError.new("Can't create additional node for finished trace.") if self.finished
+
           self.node_count += 1
           NewRelic::Agent::Transaction::TraceNode.new(metric_name, time_since_start)
         end
@@ -80,6 +77,7 @@ module NewRelic
 
         def collect_explain_plans!
           return unless NewRelic::Agent::Database.should_collect_explain_plans?
+
           threshold = NewRelic::Agent.config[:'transaction_tracer.explain_threshold']
 
           each_node do |node|
@@ -92,6 +90,7 @@ module NewRelic
         def prepare_sql_for_transmission!
           each_node do |node|
             next unless node[:sql]
+
             node[:sql] = node[:sql].safe_sql
           end
         end
@@ -108,31 +107,29 @@ module NewRelic
           @root_node.each_node_with_nest_tracking(&block)
         end
 
-        AGENT_ATTRIBUTES_KEY     = 'agentAttributes'.freeze
-        USER_ATTRIBUTES_KEY      = 'userAttributes'.freeze
+        AGENT_ATTRIBUTES_KEY = 'agentAttributes'.freeze
+        USER_ATTRIBUTES_KEY = 'userAttributes'.freeze
         INTRINSIC_ATTRIBUTES_KEY = 'intrinsics'.freeze
 
         def attributes_for_tracer_destination
           destination = NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER
 
-          agent_attributes     = self.attributes.agent_attributes_for(destination)
-          custom_attributes    = self.attributes.custom_attributes_for(destination)
+          agent_attributes = self.attributes.agent_attributes_for(destination)
+          custom_attributes = self.attributes.custom_attributes_for(destination)
           intrinsic_attributes = self.attributes.intrinsic_attributes_for(destination)
 
           {
-            AGENT_ATTRIBUTES_KEY     => agent_attributes,
-            USER_ATTRIBUTES_KEY      => custom_attributes,
+            AGENT_ATTRIBUTES_KEY => agent_attributes,
+            USER_ATTRIBUTES_KEY => custom_attributes,
             INTRINSIC_ATTRIBUTES_KEY => intrinsic_attributes
           }
         end
 
-        EMPTY_HASH = {}.freeze
-
-        def trace_tree attributes_hash
+        def trace_tree(attributes_hash)
           [
             NewRelic::Coerce.float(self.start_time),
-            EMPTY_HASH,
-            EMPTY_HASH,
+            NewRelic::EMPTY_HASH,
+            NewRelic::EMPTY_HASH,
             self.root_node.to_array,
             attributes_hash
           ]
@@ -148,8 +145,8 @@ module NewRelic
             encoder.encode(trace_tree(attributes_hash)),
             NewRelic::Coerce.string(self.guid),
             nil,
-            forced?,
-            NewRelic::Coerce.int_or_nil(xray_session_id),
+            false, # forced?,
+            nil, # NewRelic::Coerce.int_or_nil(xray_session_id),
             NewRelic::Coerce.string(self.synthetics_resource_id)
           ]
         end

data/lib/new_relic/agent/transaction/trace_builder.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.
+# frozen_string_literal: true
 
 require 'new_relic/helper'
 require 'new_relic/agent/transaction/trace'
@@ -12,10 +12,10 @@ module NewRelic
       module TraceBuilder
         extend self
 
-        def build_trace transaction
-          trace = Trace.new transaction.start_time
+        def build_trace(transaction)
+          trace = Trace.new(transaction.start_time)
           trace.root_node.exit_timestamp = transaction.end_time - transaction.start_time
-          copy_attributes transaction, trace
+          copy_attributes(transaction, trace)
           first, *rest = transaction.segments
           relationship_map = rest.group_by { |s| s.parent }
           trace.root_node.children << process_segments(transaction, first, trace.root_node, relationship_map)
@@ -25,30 +25,29 @@ module NewRelic
         private
 
         # recursively builds a transaction trace from the flat list of segments
-        def process_segments transaction, segment, parent, relationship_map
-          current = create_trace_node transaction, segment, parent
+        def process_segments(transaction, segment, parent, relationship_map)
+          current = create_trace_node(transaction, segment, parent)
 
           if children = relationship_map[segment]
             current.children = children.map! do |child|
-              process_segments transaction, child, current, relationship_map
+              process_segments(transaction, child, current, relationship_map)
             end
           end
 
           current
         end
 
-        def create_trace_node transaction, segment, parent
+        def create_trace_node(transaction, segment, parent)
           relative_start = segment.start_time - transaction.start_time
           relative_end = segment.end_time - transaction.start_time
-          TraceNode.new segment.name, relative_start, relative_end, segment.params, parent
+          TraceNode.new(segment.name, relative_start, relative_end, segment.params, parent)
         end
 
-        def copy_attributes transaction, trace
+        def copy_attributes(transaction, trace)
           trace.transaction_name = transaction.best_name
           trace.guid = transaction.guid
           trace.attributes = transaction.attributes
           trace.threshold = transaction.threshold
-          trace.xray_session_id = transaction.xray_session_id
           trace.finished = true
         end
       end