newrelic_rpm 6.10.0.364 → 8.15.0

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,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/abstract_segment'
 require 'new_relic/agent/span_event_primitive'
@@ -13,32 +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, :attributes
+        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
-          @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
-          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?
@@ -59,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'
 
@@ -12,7 +12,7 @@ module NewRelic
 
         attr_reader :start_time, :root_node
         attr_accessor :transaction_name, :guid, :attributes,
-                      :node_count, :finished, :threshold, :profile
+          :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
@@ -50,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
@@ -75,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|
@@ -87,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
@@ -103,25 +107,25 @@ 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
 
-        def trace_tree attributes_hash
+        def trace_tree(attributes_hash)
           [
             NewRelic::Coerce.float(self.start_time),
             NewRelic::EMPTY_HASH,

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,25 +25,25 @@ 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

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

@@ -1,6 +1,5 @@
-# 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
 
 module NewRelic
@@ -21,59 +20,60 @@ module NewRelic
           end
         end
 
-        SUPPORTABILITY_PREFIX             = "Supportability/TraceContext"
-        CREATE_PREFIX                     = "#{SUPPORTABILITY_PREFIX}/Create"
-        ACCEPT_PREFIX                     = "#{SUPPORTABILITY_PREFIX}/Accept"
-        TRACESTATE_PREFIX                 = "#{SUPPORTABILITY_PREFIX}/TraceState"
+        SUPPORTABILITY_PREFIX = "Supportability/TraceContext"
+        CREATE_PREFIX = "#{SUPPORTABILITY_PREFIX}/Create"
+        ACCEPT_PREFIX = "#{SUPPORTABILITY_PREFIX}/Accept"
+        TRACESTATE_PREFIX = "#{SUPPORTABILITY_PREFIX}/TraceState"
 
-        CREATE_SUCCESS_METRIC             = "#{CREATE_PREFIX}/Success"
-        CREATE_EXCEPTION_METRIC           = "#{CREATE_PREFIX}/Exception"
+        CREATE_SUCCESS_METRIC = "#{CREATE_PREFIX}/Success"
+        CREATE_EXCEPTION_METRIC = "#{CREATE_PREFIX}/Exception"
 
-        ACCEPT_SUCCESS_METRIC             = "#{ACCEPT_PREFIX}/Success"
-        ACCEPT_EXCEPTION_METRIC           = "#{ACCEPT_PREFIX}/Exception"
-        IGNORE_MULTIPLE_ACCEPT_METRIC     = "#{ACCEPT_PREFIX}/Ignored/Multiple"
+        ACCEPT_SUCCESS_METRIC = "#{ACCEPT_PREFIX}/Success"
+        ACCEPT_EXCEPTION_METRIC = "#{ACCEPT_PREFIX}/Exception"
+        IGNORE_MULTIPLE_ACCEPT_METRIC = "#{ACCEPT_PREFIX}/Ignored/Multiple"
         IGNORE_ACCEPT_AFTER_CREATE_METRIC = "#{ACCEPT_PREFIX}/Ignored/CreateBeforeAccept"
 
-        NO_NR_ENTRY_TRACESTATE_METRIC     = "#{TRACESTATE_PREFIX}/NoNrEntry"
+        NO_NR_ENTRY_TRACESTATE_METRIC = "#{TRACESTATE_PREFIX}/NoNrEntry"
         INVALID_TRACESTATE_PAYLOAD_METRIC = "#{TRACESTATE_PREFIX}/InvalidNrEntry"
 
         attr_accessor :trace_context_header_data
-        attr_reader   :trace_state_payload
+        attr_reader :trace_state_payload
 
-        def trace_parent_header_present? request
+        def trace_parent_header_present?(request)
           request[NewRelic::HTTP_TRACEPARENT_KEY]
         end
 
-        def accept_trace_context_incoming_request request
+        def accept_trace_context_incoming_request(request)
           header_data = NewRelic::Agent::DistributedTracing::TraceContext.parse(
             format: NewRelic::FORMAT_RACK,
             carrier: request,
-            trace_state_entry_key: AccountHelpers.trace_state_entry_key,
+            trace_state_entry_key: AccountHelpers.trace_state_entry_key
           )
           return if header_data.nil?
 
-          accept_trace_context header_data
+          accept_trace_context(header_data)
         end
         private :accept_trace_context_incoming_request
 
-        def insert_trace_context_header header, format=NewRelic::FORMAT_NON_RACK
+        def insert_trace_context_header(header, format = NewRelic::FORMAT_NON_RACK)
           return unless Agent.config[:'distributed_tracing.enabled']
 
-          NewRelic::Agent::DistributedTracing::TraceContext.insert \
+          NewRelic::Agent::DistributedTracing::TraceContext.insert( \
             format: format,
             carrier: header,
             trace_id: transaction.trace_id.rjust(32, '0').downcase,
             parent_id: transaction.current_segment.guid,
             trace_flags: transaction.sampled? ? 0x1 : 0x0,
             trace_state: create_trace_state
+          )
 
           @trace_context_inserted = true
 
-          NewRelic::Agent.increment_metric CREATE_SUCCESS_METRIC
+          NewRelic::Agent.increment_metric(CREATE_SUCCESS_METRIC)
           true
         rescue Exception => e
-          NewRelic::Agent.increment_metric CREATE_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Failed to create trace context payload", e
+          NewRelic::Agent.increment_metric(CREATE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to create trace context payload", e)
           false
         end
 
@@ -82,9 +82,10 @@ module NewRelic
           payload = create_trace_state_payload
 
           if payload
-            entry = NewRelic::Agent::DistributedTracing::TraceContext.create_trace_state_entry \
+            entry = NewRelic::Agent::DistributedTracing::TraceContext.create_trace_state_entry( \
               entry_key,
               payload.to_s
+            )
           else
             entry = NewRelic::EMPTY_STR
           end
@@ -94,37 +95,37 @@ module NewRelic
 
         def create_trace_state_payload
           unless Agent.config[:'distributed_tracing.enabled']
-            NewRelic::Agent.logger.warn "Not configured to create WC3 trace context payload"
+            NewRelic::Agent.logger.warn("Not configured to create WC3 trace context payload")
             return
           end
 
-
           span_guid = Agent.config[:'span_events.enabled'] ? transaction.current_segment.guid : nil
-          transaction_guid = Agent.config[:'analytics_events.enabled'] ? transaction.guid : nil
+          transaction_guid = Agent.config[:'transaction_events.enabled'] ? transaction.guid : nil
 
-          TraceContextPayload.create \
+          TraceContextPayload.create( \
             parent_account_id: Agent.config[:account_id],
             parent_app_id: Agent.config[:primary_application_id],
             transaction_id: transaction_guid,
             sampled: transaction.sampled?,
             priority: float!(transaction.priority, NewRelic::PRIORITY_PRECISION),
             id: span_guid
+          )
         end
 
         def assign_trace_state_payload
           payload = @trace_context_header_data.trace_state_payload
           unless payload
-            NewRelic::Agent.increment_metric NO_NR_ENTRY_TRACESTATE_METRIC
+            NewRelic::Agent.increment_metric(NO_NR_ENTRY_TRACESTATE_METRIC)
             return false
           end
           unless payload.valid?
-            NewRelic::Agent.increment_metric INVALID_TRACESTATE_PAYLOAD_METRIC
+            NewRelic::Agent.increment_metric(INVALID_TRACESTATE_PAYLOAD_METRIC)
             return false
           end
           @trace_state_payload = payload
         end
 
-        def accept_trace_context header_data
+        def accept_trace_context(header_data)
           return if ignore_trace_context?
 
           @trace_context_header_data = header_data
@@ -139,20 +140,20 @@ module NewRelic
             transaction.sampled = payload.sampled
             transaction.priority = payload.priority if payload.priority
           end
-          NewRelic::Agent.increment_metric ACCEPT_SUCCESS_METRIC
+          NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
         rescue => e
-          NewRelic::Agent.increment_metric ACCEPT_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Failed to accept trace context payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to accept trace context payload", e)
           false
         end
 
         def ignore_trace_context?
           if trace_context_header_data
-            NewRelic::Agent.increment_metric IGNORE_MULTIPLE_ACCEPT_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)
             return true
           elsif trace_context_inserted?
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_AFTER_CREATE_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_AFTER_CREATE_METRIC)
             return true
           end
           false
@@ -161,7 +162,6 @@ module NewRelic
         def trace_context_inserted?
           @trace_context_inserted ||= false
         end
-
       end
     end
   end