newrelic_rpm 8.9.0 → 8.10.1

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

@@ -22,17 +22,17 @@ module NewRelic
         end
       end
 
-      def record_metrics_for_transaction transaction
+      def record_metrics_for_transaction(transaction)
         return unless Agent.config[:'distributed_tracing.enabled']
         dt = transaction.distributed_tracer
         payload = dt.distributed_trace_payload || dt.trace_state_payload
 
-        record_caller_by_duration_metrics transaction, payload
-        record_transport_duration_metrics transaction, payload
-        record_errors_by_caller_metrics transaction, payload
+        record_caller_by_duration_metrics(transaction, payload)
+        record_transport_duration_metrics(transaction, payload)
+        record_errors_by_caller_metrics(transaction, payload)
       end
 
-      def prefix_for_metric name, transaction, payload
+      def prefix_for_metric(name, transaction, payload)
         if payload
           "#{name}/" \
           "#{payload.parent_type}/" \
@@ -44,31 +44,31 @@ module NewRelic
         end
       end
 
-      def record_caller_by_duration_metrics transaction, payload
-        prefix = prefix_for_metric "DurationByCaller", transaction, payload
-        record_unscoped_metric transaction, prefix, transaction.duration
+      def record_caller_by_duration_metrics(transaction, payload)
+        prefix = prefix_for_metric("DurationByCaller", transaction, payload)
+        record_unscoped_metric(transaction, prefix, transaction.duration)
       end
 
-      def record_transport_duration_metrics transaction, payload
+      def record_transport_duration_metrics(transaction, payload)
         return unless payload
 
-        prefix = prefix_for_metric "TransportDuration", transaction, payload
-        duration = transaction.calculate_transport_duration payload
-        record_unscoped_metric transaction, prefix, duration
+        prefix = prefix_for_metric("TransportDuration", transaction, payload)
+        duration = transaction.calculate_transport_duration(payload)
+        record_unscoped_metric(transaction, prefix, duration)
       end
 
-      def record_errors_by_caller_metrics transaction, payload
+      def record_errors_by_caller_metrics(transaction, payload)
         return unless transaction.exceptions.size > 0
 
-        prefix = prefix_for_metric "ErrorsByCaller", transaction, payload
-        record_unscoped_metric transaction, prefix, 1
+        prefix = prefix_for_metric("ErrorsByCaller", transaction, payload)
+        record_unscoped_metric(transaction, prefix, 1)
       end
 
       private
 
-      def record_unscoped_metric transaction, prefix, duration
-        transaction.metrics.record_unscoped "#{prefix}/#{ALL_SUFFIX}", duration
-        transaction.metrics.record_unscoped "#{prefix}/#{transaction_type_suffix}", duration
+      def record_unscoped_metric(transaction, prefix, duration)
+        transaction.metrics.record_unscoped("#{prefix}/#{ALL_SUFFIX}", duration)
+        transaction.metrics.record_unscoped("#{prefix}/#{transaction_type_suffix}", duration)
       end
     end
   end

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

@@ -36,7 +36,7 @@ module NewRelic
       PRIORITY_KEY = 'pr'
 
       class << self
-        def for_transaction transaction
+        def for_transaction(transaction)
           return nil unless connected?
 
           payload = new
@@ -57,8 +57,8 @@ module NewRelic
           payload
         end
 
-        def from_json serialized_payload
-          raw_payload = JSON.parse serialized_payload
+        def from_json(serialized_payload)
+          raw_payload = JSON.parse(serialized_payload)
           return raw_payload if raw_payload.nil?
           payload_data = raw_payload[DATA_KEY]
 
@@ -78,9 +78,9 @@ module NewRelic
           payload
         end
 
-        def from_http_safe http_safe_payload
-          decoded_payload = Base64.strict_decode64 http_safe_payload
-          from_json decoded_payload
+        def from_http_safe(http_safe_payload)
+          decoded_payload = Base64.strict_decode64(http_safe_payload)
+          from_json(decoded_payload)
         end
 
         def major_version_matches?(payload)
@@ -89,7 +89,7 @@ module NewRelic
 
         private
 
-        def assign_trusted_account_key payload, account_id
+        def assign_trusted_account_key(payload, account_id)
           trusted_account_key = Agent.config[:trusted_account_key]
 
           if account_id != trusted_account_key
@@ -157,7 +157,7 @@ module NewRelic
       #
       # @api public
       def http_safe
-        Base64.strict_encode64 text
+        Base64.strict_encode64(text)
       end
     end
   end

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

@@ -27,11 +27,11 @@ module NewRelic
 
       RACK_URL_SCHEME = 'rack.url_scheme'
 
-      def from value
+      def from(value)
         ALLOWABLE_TRANSPORT_TYPES.include?(value) ? value : NewRelic::UNKNOWN
       end
 
-      def for_rack_request request
+      def for_rack_request(request)
         URL_SCHEMES[request[RACK_URL_SCHEME]]
       end
     end

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

@@ -40,29 +40,30 @@ module NewRelic
         SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY = "Supportability/TraceContext/TraceState/InvalidNrEntry"
 
         class << self
-          def insert format: NewRelic::FORMAT_NON_RACK,
+          def insert(format: NewRelic::FORMAT_NON_RACK,
             carrier: nil,
             parent_id: nil,
             trace_id: nil,
             trace_flags: nil,
-            trace_state: nil
+            trace_state: nil)
 
-            trace_parent_header = trace_parent_header_for_format format
-            carrier[trace_parent_header] = format_trace_parent \
+            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
+            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,
+          def parse(format: NewRelic::FORMAT_NON_RACK,
             carrier: nil,
-            trace_state_entry_key: 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
+            unless trace_parent_valid?(trace_parent)
+              NewRelic::Agent.increment_metric(SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION)
               return nil
             end
 
@@ -72,29 +73,29 @@ module NewRelic
                 header_data
               end
             rescue Exception
-              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION
+              NewRelic::Agent.increment_metric(SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION)
               return nil
             end
           end
 
-          def create_trace_state_entry entry_key, payload
+          def create_trace_state_entry(entry_key, payload)
             "#{entry_key}=#{payload}".dup
           end
 
           private
 
-          def format_trace_parent trace_id: nil,
+          def format_trace_parent(trace_id: nil,
             parent_id: nil,
-            trace_flags: nil
-            sprintf TRACE_PARENT_FORMAT_STRING,
+            trace_flags: nil)
+            sprintf(TRACE_PARENT_FORMAT_STRING,
               VERSION,
               trace_id,
               parent_id,
-              trace_flags
+              trace_flags)
           end
 
-          def extract_traceparent format, carrier
-            header_name = trace_parent_header_for_format format
+          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))|
@@ -104,7 +105,7 @@ module NewRelic
             end
           end
 
-          def trace_parent_valid? trace_parent
+          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
@@ -114,7 +115,7 @@ module NewRelic
             true
           end
 
-          def trace_parent_header_for_format format
+          def trace_parent_header_for_format(format)
             if format == NewRelic::FORMAT_RACK
               NewRelic::HTTP_TRACEPARENT_KEY
             else
@@ -122,7 +123,7 @@ module NewRelic
             end
           end
 
-          def trace_state_header_for_format format
+          def trace_state_header_for_format(format)
             if format == NewRelic::FORMAT_RACK
               NewRelic::HTTP_TRACESTATE_KEY
             else
@@ -130,8 +131,8 @@ module NewRelic
             end
           end
 
-          def extract_tracestate format, carrier, trace_state_entry_key
-            header_name = trace_state_header_for_format format
+          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?
 
@@ -143,9 +144,9 @@ module NewRelic
               if entry == NewRelic::EMPTY_STR
                 false
               else
-                vendor_id = entry.slice 0, entry.index(EQUALS)
+                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
+                  payload = entry.slice!(trace_state_entry_key.size + 1, entry.size)
                   true
                 else
                   trace_state_size += entry.size
@@ -155,19 +156,19 @@ module NewRelic
               end
             end
 
-            trace_state_vendors.chomp! COMMA
+            trace_state_vendors.chomp!(COMMA)
 
-            HeaderData.create trace_state_payload: payload ? decode_payload(payload) : nil,
+            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
+              trace_state_vendors: trace_state_vendors)
           end
 
-          def decode_payload payload
-            TraceContextPayload.from_s payload
+          def decode_payload(payload)
+            TraceContextPayload.from_s(payload)
           rescue
             if payload
-              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY
+              NewRelic::Agent.increment_metric(SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY)
             end
             return nil
           end
@@ -175,20 +176,20 @@ module NewRelic
 
         class HeaderData
           class << self
-            def create trace_parent: nil,
+            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_vendors: nil)
+              new(trace_parent, \
                 trace_state_payload, \
                 trace_state_entries, \
                 trace_state_size, \
-                trace_state_vendors
+                trace_state_vendors)
             end
           end
 
-          def initialize trace_parent, trace_state_payload, trace_state_entries, trace_state_size, trace_state_vendors
+          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
@@ -199,11 +200,11 @@ module NewRelic
 
           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
+          def trace_state(trace_state_entry)
+            @trace_state ||= join_trace_state(trace_state_entry.size)
             @trace_state_entries = nil
 
-            trace_state_entry << @trace_state
+            trace_state_entry = "#{trace_state_entry}#{@trace_state}"
           end
 
           def trace_id
@@ -216,7 +217,7 @@ module NewRelic
 
           private
 
-          def join_trace_state trace_state_entry_size
+          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

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

@@ -1,6 +1,7 @@
 # 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 'new_relic/coerce'
 
@@ -18,7 +19,7 @@ module NewRelic
       PARENT_TYPES = %w[App Browser Mobile].map(&:freeze).freeze
 
       class << self
-        def create version: VERSION,
+        def create(version: VERSION,
           parent_type: PARENT_TYPE,
           parent_account_id: nil,
           parent_app_id: nil,
@@ -26,18 +27,18 @@ module NewRelic
           transaction_id: nil,
           sampled: nil,
           priority: nil,
-          timestamp: now_ms
+          timestamp: now_ms)
 
-          new version, parent_type, parent_account_id, parent_app_id, id,
-            transaction_id, sampled, priority, timestamp
+          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
+        def from_s(payload_string)
           attrs = payload_string.split(DELIMITER)
 
-          payload = create \
+          payload = create( \
             version: int!(attrs[0]),
             parent_type: int!(attrs[1]),
             parent_account_id: attrs[2],
@@ -47,10 +48,11 @@ module NewRelic
             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?
+          )
+          handle_invalid_payload(message: 'payload missing attributes') unless payload.valid?
           payload
         rescue => e
-          handle_invalid_payload error: e
+          handle_invalid_payload(error: e)
           raise
         end
 
@@ -60,12 +62,12 @@ module NewRelic
           Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
         end
 
-        def handle_invalid_payload error: nil, message: nil
-          NewRelic::Agent.increment_metric SUPPORTABILITY_PARSE_EXCEPTION
+        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
+            NewRelic::Agent.logger.warn("Error parsing trace context payload", error)
           elsif message
-            NewRelic::Agent.logger.warn "Error parsing trace context payload: #{message}"
+            NewRelic::Agent.logger.warn("Error parsing trace context payload: #{message}")
           end
         end
       end
@@ -82,8 +84,8 @@ module NewRelic
 
       alias_method :sampled?, :sampled
 
-      def initialize version, parent_type_id, parent_account_id, parent_app_id,
-        id, transaction_id, sampled, priority, timestamp
+      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

data/lib/new_relic/agent/distributed_tracing.rb

@@ -42,22 +42,22 @@ module NewRelic
       #
       # @api public
       #
-      def insert_distributed_trace_headers headers = {}
+      def insert_distributed_trace_headers(headers = {})
         record_api_supportability_metric(:insert_distributed_trace_headers)
 
         unless Agent.config[:'distributed_tracing.enabled']
-          NewRelic::Agent.logger.warn "Not configured to insert distributed trace headers"
+          NewRelic::Agent.logger.warn("Not configured to insert distributed trace headers")
           return nil
         end
 
-        return unless valid_api_argument_class? headers, "headers", Hash
+        return unless valid_api_argument_class?(headers, "headers", Hash)
 
         return unless transaction = Transaction.tl_current
 
-        transaction.distributed_tracer.insert_headers headers
+        transaction.distributed_tracer.insert_headers(headers)
         transaction
       rescue => e
-        NewRelic::Agent.logger.error 'error during insert_distributed_trace_headers', e
+        NewRelic::Agent.logger.error('error during insert_distributed_trace_headers', e)
         nil
       end
 
@@ -96,22 +96,22 @@ module NewRelic
       #
       # @api public
       #
-      def accept_distributed_trace_headers headers, transport_type = NewRelic::HTTP
+      def accept_distributed_trace_headers(headers, transport_type = NewRelic::HTTP)
         record_api_supportability_metric(:accept_distributed_trace_headers)
 
         unless Agent.config[:'distributed_tracing.enabled']
-          NewRelic::Agent.logger.warn "Not configured to accept distributed trace headers"
+          NewRelic::Agent.logger.warn("Not configured to accept distributed trace headers")
           return nil
         end
 
-        return unless valid_api_argument_class? headers, "headers", Hash
-        return unless valid_api_argument_class? transport_type, "transport_type", String
+        return unless valid_api_argument_class?(headers, "headers", Hash)
+        return unless valid_api_argument_class?(transport_type, "transport_type", String)
 
         return unless transaction = Transaction.tl_current
 
         # assume we have Rack conforming keys when transport_type is HTTP(S)
         # otherwise, fish for key/value pairs regardless of prefix and case-sensitivity.
-        hdr = if transport_type.start_with? NewRelic::HTTP
+        hdr = if transport_type.start_with?(NewRelic::HTTP)
           headers
         else
           # start with the most common case first
@@ -122,26 +122,26 @@ module NewRelic
           }
 
           # when not found, search for any casing for trace context headers, ignoring potential prefixes
-          hdr[NewRelic::HTTP_TRACEPARENT_KEY] ||= variant_key_value headers, NewRelic::TRACEPARENT_KEY
-          hdr[NewRelic::HTTP_TRACESTATE_KEY] ||= variant_key_value headers, NewRelic::TRACESTATE_KEY
-          hdr[NewRelic::HTTP_NEWRELIC_KEY] ||= variant_key_value headers, NewRelic::CANDIDATE_NEWRELIC_KEYS
+          hdr[NewRelic::HTTP_TRACEPARENT_KEY] ||= variant_key_value(headers, NewRelic::TRACEPARENT_KEY)
+          hdr[NewRelic::HTTP_TRACESTATE_KEY] ||= variant_key_value(headers, NewRelic::TRACESTATE_KEY)
+          hdr[NewRelic::HTTP_NEWRELIC_KEY] ||= variant_key_value(headers, NewRelic::CANDIDATE_NEWRELIC_KEYS)
           hdr
         end
 
-        transaction.distributed_tracer.accept_incoming_request hdr, transport_type
+        transaction.distributed_tracer.accept_incoming_request(hdr, transport_type)
         transaction
       rescue => e
-        NewRelic::Agent.logger.error 'error during accept_distributed_trace_headers', e
+        NewRelic::Agent.logger.error('error during accept_distributed_trace_headers', e)
         nil
       end
 
       private
 
-      def has_variant_key? key, variants
+      def has_variant_key?(key, variants)
         key.to_s.downcase.end_with?(*Array(variants))
       end
 
-      def variant_key_value headers, variants
+      def variant_key_value(headers, variants)
         (headers.detect { |k, v| has_variant_key?(k, variants) } || NewRelic::EMPTY_ARRAY)[1]
       end
     end

data/lib/new_relic/agent/encoding_normalizer.rb

@@ -1,6 +1,7 @@
 # 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
 
 # This module was extracted from NewRelic::JSONWrapper
 

data/lib/new_relic/agent/error_collector.rb

@@ -1,6 +1,8 @@
 # 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 'new_relic/agent/error_trace_aggregator'
 require 'new_relic/agent/error_event_aggregator'
 
@@ -18,9 +20,9 @@ module NewRelic
       attr_reader :error_trace_aggregator, :error_event_aggregator
 
       # Returns a new error collector
-      def initialize events
+      def initialize(events)
         @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
-        @error_event_aggregator = ErrorEventAggregator.new events
+        @error_event_aggregator = ErrorEventAggregator.new(events)
 
         @error_filter = NewRelic::Agent::ErrorFilter.new
 
@@ -62,7 +64,7 @@ module NewRelic
         if block
           define_method(:ignore_filter_proc, &block)
         elsif method_defined?(:ignore_filter_proc)
-          remove_method :ignore_filter_proc
+          remove_method(:ignore_filter_proc)
         end
         @ignore_filter
       end
@@ -212,7 +214,7 @@ module NewRelic
       def notice_segment_error(segment, exception, options = {})
         return if skip_notice_error?(exception)
 
-        segment.set_noticed_error create_noticed_error(exception, options)
+        segment.set_noticed_error(create_noticed_error(exception, options))
         exception
       rescue => e
         ::NewRelic::Agent.logger.warn("Failure when capturing segment error '#{exception}':", e)

data/lib/new_relic/agent/error_event_aggregator.rb

@@ -19,7 +19,7 @@ module NewRelic
         :'error_collector.capture_events'
       buffer_class PrioritySampledBuffer
 
-      def record noticed_error, transaction_payload = nil, span_id = nil
+      def record(noticed_error, transaction_payload = nil, span_id = nil)
         return unless enabled?
 
         priority = float!((transaction_payload && transaction_payload[:priority]) || rand)
@@ -34,8 +34,8 @@ module NewRelic
 
       private
 
-      def create_event noticed_error, transaction_payload, span_id
-        TransactionErrorPrimitive.create noticed_error, transaction_payload, span_id
+      def create_event(noticed_error, transaction_payload, span_id)
+        TransactionErrorPrimitive.create(noticed_error, transaction_payload, span_id)
       end
     end
   end

data/lib/new_relic/agent/error_filter.rb

@@ -1,6 +1,7 @@
 # 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

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -2,6 +2,7 @@
 # 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
@@ -92,7 +93,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."
+          ::NewRelic::Agent.logger.debug("Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service.")
         end
       end
     end