newrelic_rpm 9.18.0 → 9.20.0

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

@@ -32,7 +32,7 @@ module NewRelic
 
       def deserialize_header(encoded_header, key)
         decoded_header = obfuscator.deobfuscate(encoded_header)
-        ::JSON.load(decoded_header)
+        ::JSON.parse(decoded_header)
       rescue => err
         # If we have a failure of any type here, just return nil and carry on
         NewRelic::Agent.logger.debug("Failure deserializing encoded header '#{key}' in #{self.class}, #{err.class}, #{err.message}")

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

@@ -35,7 +35,7 @@ module NewRelic
       end
 
       def load_json(header, key)
-        ::JSON.load(header)
+        ::JSON.parse(header)
       rescue => err
         NewRelic::Agent.logger.debug("Failure loading json header '#{key}' in #{self.class}, #{err.class}, #{err.message}")
         nil

data/lib/new_relic/agent/new_relic_service/json_marshaller.rb

@@ -19,7 +19,7 @@ module NewRelic
         def warn_for_yajl
           if defined?(::Yajl)
             require 'yajl/version'
-            if Gem::Version.new(::Yajl::VERSION) < OK_YAJL_VERSION
+            if NewRelic::Helper.version_satisfied?(::Yajl::VERSION, '<', OK_YAJL_VERSION)
               ::NewRelic::Agent.logger.warn("Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available.")
             end
           end
@@ -42,7 +42,7 @@ module NewRelic
             return nil
           end
 
-          return_value(::JSON.load(data))
+          return_value(::JSON.parse(data))
         rescue => e
           ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} encountered loading collector response: #{data}")
           raise

data/lib/new_relic/agent/opentelemetry/context/propagation/trace_propagator.rb

@@ -0,0 +1,66 @@
+# 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 OpenTelemetry
+      module Context
+        module Propagation
+          class TracePropagator
+            # The carrier is the object carrying the headers
+            # The context argument is a no-op, as the OpenTelemetry context is not used
+            # The setter argument is a no-op, added for consistency with the OpenTelemetry API
+            def inject(carrier, context: ::OpenTelemetry::Context.current, setter: nil)
+              # TODO: determine if we need to update this method to take Context into account
+              NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(carrier)
+            end
+
+            # The return value for this method should be an instance of the
+            # OpenTelemetry Context class. The return value of
+            # #accept_distributed_trace_headers is a transaction, so we cannot
+            # use it to extract the context.
+            def extract(carrier, context: ::OpenTelemetry::Context.current, getter: ::OpenTelemetry::Context::Propagation.text_map_getter)
+              carrier_format = determine_format(getter)
+              trace_context = NewRelic::Agent::DistributedTracing::TraceContext.parse(
+                carrier: carrier,
+                format: carrier_format,
+                trace_state_entry_key: Transaction::TraceContext::AccountHelpers.trace_state_entry_key
+              )
+              tp = trace_context.trace_parent
+              span_context = ::OpenTelemetry::Trace::SpanContext.new(
+                trace_id: tp['trace_id'],
+                span_id: tp['parent_id'],
+                trace_flags: tp['trace_flags'],
+                tracestate: trace_context.trace_state_payload,
+                remote: true
+              )
+              span = ::OpenTelemetry::Trace.non_recording_span(span_context)
+
+              ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)
+            rescue StandardError => e
+              NewRelic::Agent.logger.error("Unable to extract context: #{e.message}")
+              context
+            end
+
+            private
+
+            # The getter is the way OpenTelemetry handles Rack vs. non-Rack
+            # formats. Rather than using their parser, get the class info we
+            # need to do things the New Relic way
+            def determine_format(getter)
+              case getter
+              when ::OpenTelemetry::Context::Propagation::RackEnvGetter
+                FORMAT_RACK
+              when defined?(::OpenTelemetry::Common) && ::OpenTelemetry::Common::Propagation::RackEnvGetter
+                FORMAT_RACK
+              else
+                FORMAT_NON_RACK
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/context/propagation.rb

@@ -0,0 +1,15 @@
+# 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 OpenTelemetry
+      module Context
+        module Propagation
+          require_relative 'propagation/trace_propagator'
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/context.rb

@@ -0,0 +1,13 @@
+# 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 OpenTelemetry
+      module Context
+        require_relative 'context/propagation'
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/trace/span.rb

@@ -0,0 +1,31 @@
+# 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 OpenTelemetry
+      module Trace
+        class Span < ::OpenTelemetry::Trace::Span
+          attr_accessor :finishable
+
+          def finish(end_timestamp: nil)
+            finishable&.finish
+          end
+
+          def set_attribute(key, value)
+            NewRelic::Agent.add_custom_span_attributes(key => value)
+          end
+
+          def add_attributes(attributes)
+            NewRelic::Agent.add_custom_span_attributes(attributes)
+          end
+
+          def record_exception(exception, attributes: nil)
+            NewRelic::Agent.notice_error(exception, attributes: attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/trace/tracer.rb

@@ -0,0 +1,129 @@
+# 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 OpenTelemetry
+      module Trace
+        class Tracer < ::OpenTelemetry::Trace::Tracer
+          def initialize(name = nil, version = nil)
+            @name = name || ''
+            @version = version || ''
+          end
+
+          def start_span(name, with_parent: nil, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
+            parent_otel_context = ::OpenTelemetry::Trace.current_span(with_parent).context
+
+            finishable = if can_start_transaction?(parent_otel_context)
+              return if internal_span_kind_with_invalid_parent?(kind, parent_otel_context)
+
+              nr_item = NewRelic::Agent::Tracer.start_transaction_or_segment(name: name, category: :otel)
+              add_remote_context_to_txn(nr_item, parent_otel_context)
+              nr_item
+            else
+              NewRelic::Agent::Tracer.start_segment(name: name)
+            end
+
+            otel_span = get_otel_span_from_finishable(finishable)
+            otel_span.finishable = finishable
+            add_remote_context_to_otel_span(otel_span, parent_otel_context)
+            otel_span.add_attributes(attributes) if attributes
+            otel_span
+          end
+
+          def in_span(name, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
+            span = start_span(name, attributes: attributes, links: links, start_timestamp: start_timestamp, kind: kind)
+            begin
+              yield
+            rescue => e
+              # TODO: Update for segment errors if finishable is a segment
+              NewRelic::Agent.notice_error(e)
+              raise
+            end
+          ensure
+            span&.finish
+          end
+
+          private
+
+          def get_otel_span_from_finishable(finishable)
+            case finishable
+            when NewRelic::Agent::Transaction
+              finishable.segments.first.instance_variable_get(:@otel_span)
+            when NewRelic::Agent::Transaction::Segment
+              finishable.instance_variable_get(:@otel_span)
+            else
+              NewRelic::Agent.logger.warn('Tracer#get_otel_span_from_finishable failed to get span from finishable - finishable is not a transaction or segment')
+              nil
+            end
+          end
+
+          def can_start_transaction?(parent_otel_context)
+            parent_otel_context.remote? || !parent_otel_context.valid?
+          end
+
+          def internal_span_kind_with_invalid_parent?(kind, parent_otel_context)
+            !parent_otel_context.valid? && kind == :internal
+          end
+
+          def transaction_and_remote_parent?(txn, parent_otel_context)
+            txn.is_a?(NewRelic::Agent::Transaction) && parent_otel_context.remote?
+          end
+
+          def add_remote_context_to_txn(txn, parent_otel_context)
+            return unless transaction_and_remote_parent?(txn, parent_otel_context)
+
+            txn.trace_id = parent_otel_context.trace_id
+            txn.parent_span_id = parent_otel_context.span_id
+
+            set_tracestate(txn.distributed_tracer, parent_otel_context)
+          end
+
+          def set_tracestate(distributed_tracer, otel_context)
+            case otel_context.tracestate
+            when ::OpenTelemetry::Trace::Tracestate
+              set_otel_trace_state(distributed_tracer, otel_context)
+            when NewRelic::Agent::TraceContextPayload
+              set_nr_trace_state(distributed_tracer, otel_context)
+            end
+          end
+
+          def set_nr_trace_state(distributed_tracer, otel_context)
+            distributed_tracer.instance_variable_set(:@trace_state_payload, otel_context.tracestate)
+            distributed_tracer.parent_transaction_id = distributed_tracer.trace_state_payload.transaction_id
+            distributed_tracer.determine_sampling_decision(otel_context.tracestate, otel_context.trace_flags)
+          end
+
+          def set_otel_trace_state(distributed_tracer, otel_context)
+            nr_entry = otel_context.tracestate.value(Transaction::TraceContext::AccountHelpers.trace_state_entry_key)
+            return unless nr_entry
+
+            nr_payload = NewRelic::Agent::TraceContextPayload.from_s(nr_entry)
+            distributed_tracer.instance_variable_set(:@trace_state_payload, nr_payload)
+            distributed_tracer.parent_transaction_id = distributed_tracer.trace_state_payload.transaction_id
+            trace_flags = parse_trace_flags(otel_context.trace_flags)
+            distributed_tracer.determine_sampling_decision(nr_payload, trace_flags)
+          end
+
+          def parse_trace_flags(trace_flags)
+            case trace_flags
+            when String
+              trace_flags
+            when Integer
+              trace_flags.to_s
+            when ::OpenTelemetry::Trace::TraceFlags
+              trace_flags.sampled? ? '01' : '00'
+            end
+          end
+
+          def add_remote_context_to_otel_span(otel_span, parent_otel_context)
+            return unless transaction_and_remote_parent?(otel_span.finishable, parent_otel_context)
+
+            otel_span.context.instance_variable_set(:@trace_id, otel_span.finishable.trace_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/trace/tracer_provider.rb

@@ -0,0 +1,18 @@
+# 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 OpenTelemetry
+      module Trace
+        class TracerProvider < ::OpenTelemetry::Trace::TracerProvider
+          # TODO: Add a registration mechanism for tracers like exists in the SDK
+          def tracer(name = nil, version = nil)
+            @tracer ||= Tracer.new(name, version)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/trace.rb

@@ -0,0 +1,15 @@
+# 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 OpenTelemetry
+      module Trace
+        require_relative 'trace/tracer_provider'
+        require_relative 'trace/tracer'
+        require_relative 'trace/span'
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/transaction_patch.rb

@@ -0,0 +1,69 @@
+# 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 OpenTelemetry
+      module TransactionPatch
+        attr_accessor :opentelemetry_context
+
+        def initialize(_category, _options)
+          @opentelemetry_context = {}
+          super
+        end
+
+        def set_current_segment(new_segment)
+          @current_segment_lock.synchronize do
+            unless opentelemetry_context.empty?
+              ::OpenTelemetry::Context.detach(opentelemetry_context[otel_current_span_key])
+            end
+
+            span = find_or_create_span(new_segment)
+            ctx = ::OpenTelemetry::Context.current.set_value(otel_current_span_key, span)
+            token = ::OpenTelemetry::Context.attach(ctx)
+
+            opentelemetry_context[otel_current_span_key] = token
+          end
+
+          super
+        end
+
+        def remove_current_segment_by_thread_id(id)
+          # make sure the context is fully detached when the transaction ends
+          @current_segment_lock.synchronize do
+            ::OpenTelemetry::Context.detach(opentelemetry_context[otel_current_span_key])
+            opentelemetry_context.delete(id)
+          end
+
+          super
+        end
+
+        private
+
+        def find_or_create_span(segment)
+          if segment.instance_variable_defined?(:@otel_span)
+            segment.instance_variable_get(:@otel_span)
+          else
+            span = Trace::Span.new(span_context: span_context_from_segment(segment))
+            segment.instance_variable_set(:@otel_span, span)
+            span
+          end
+        end
+
+        def span_context_from_segment(segment)
+          ::OpenTelemetry::Trace::SpanContext.new(
+            trace_id: segment.transaction.trace_id,
+            span_id: segment.guid,
+            remote: false
+          )
+        end
+
+        def otel_current_span_key
+          # CURRENT_SPAN_KEY is a private constant
+          ::OpenTelemetry::Trace.const_get(:CURRENT_SPAN_KEY)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry_bridge.rb

@@ -0,0 +1,32 @@
+# 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
+    class OpenTelemetryBridge
+      def initialize
+        # no-op without OpenTelemetry API & config
+        return unless defined?(OpenTelemetry) &&
+          NewRelic::Agent.config[:'opentelemetry_bridge.enabled']
+
+        OpenTelemetryBridge.install
+      end
+
+      private
+
+      def self.install
+        require 'opentelemetry' # requires the opentelemetry-api gem
+        require_relative 'opentelemetry/trace'
+        require_relative 'opentelemetry/transaction_patch'
+        require_relative 'opentelemetry/context'
+
+        # TODO: Add a warning if SDK gem is installed
+
+        ::OpenTelemetry.tracer_provider = OpenTelemetry::Trace::TracerProvider.new
+        Transaction.prepend(OpenTelemetry::TransactionPatch)
+        ::OpenTelemetry.propagation = OpenTelemetry::Context::Propagation::TracePropagator.new
+      end
+    end
+  end
+end

data/lib/new_relic/agent/parameter_filtering.rb

@@ -9,7 +9,7 @@ module NewRelic
 
       ACTION_DISPATCH_PARAMETER_FILTER ||= 'action_dispatch.parameter_filter'.freeze
 
-      if defined?(Rails) && Gem::Version.new(::Rails::VERSION::STRING) >= Gem::Version.new('5.0.0')
+      if defined?(Rails) && NewRelic::Helper.version_satisfied?(::Rails::VERSION::STRING, '>=', '5.0.0')
         Rails.application.config.to_prepare do
           RAILS_FILTER_CLASS ||= if defined?(ActiveSupport::ParameterFilter)
             ActiveSupport::ParameterFilter

data/lib/new_relic/agent/samplers/cpu_sampler.rb

@@ -42,7 +42,7 @@ module NewRelic
           # Process.times on JRuby < 1.7.0 reports wall clock elapsed time,
           # not actual cpu time used, so this sampler can only be used on JRuby >= 1.7.0.
           if defined?(JRuby)
-            return JRUBY_VERSION >= '1.7.0'
+            return NewRelic::Helper.version_satisfied?(JRUBY_VERSION, '>=', '1.7.0')
           end
 
           true

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -50,7 +50,7 @@ module NewRelic
             begin
               NewRelic::Helper.run_command('uname -s').downcase
             rescue NewRelic::CommandRunFailedError, NewRelic::CommandExecutableNotFoundError
-              'unknown'
+              NewRelic::UNKNOWN_LOWER
             end
           else
             RUBY_PLATFORM.downcase

data/lib/new_relic/agent/span_event_primitive.rb

@@ -40,10 +40,12 @@ module NewRelic
       SERVER_ADDRESS_KEY = 'server.address'
       SERVER_PORT_KEY = 'server.port'
       SPAN_KIND_KEY = 'span.kind'
+      STACKTRACE_KEY = 'code.stacktrace'
       ENTRY_POINT_KEY = 'nr.entryPoint'
       TRUSTED_PARENT_KEY = 'trustedParentId'
       TRACING_VENDORS_KEY = 'tracingVendors'
       TRANSACTION_NAME_KEY = 'transaction.name'
+      THREAD_ID_KEY = 'thread.id'
 
       # Strings for static values of the event structure
       EVENT_TYPE = 'Span'
@@ -121,6 +123,10 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, DB_STATEMENT_MAX_BYTES)
         end
 
+        if segment.params[:backtrace]
+          agent_attributes[STACKTRACE_KEY] = segment.params[:backtrace]
+        end
+
         [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
@@ -135,7 +141,8 @@ module NewRelic
           PRIORITY_KEY => segment.transaction.priority,
           TIMESTAMP_KEY => milliseconds_since_epoch(segment),
           DURATION_KEY => segment.duration,
-          NAME_KEY => segment.name
+          NAME_KEY => segment.name,
+          THREAD_ID_KEY => segment.thread_id
         }
 
         # with infinite-tracing, transactions may or may not be sampled!

data/lib/new_relic/agent/tracer.rb

@@ -247,7 +247,7 @@ module NewRelic
           log_error('start_segment', exception)
         end
 
-        UNKNOWN = 'Unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN
         OTHER = 'other'.freeze
 
         # Creates and starts a datastore segment used to time

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

@@ -19,7 +19,7 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key, :thread_id
         attr_accessor :name, :parent, :children_time, :transaction, :transaction_name, :llm_event
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
@@ -30,6 +30,7 @@ module NewRelic
         def initialize(name = nil, start_time = nil)
           @name = name
           @starting_segment_key = NewRelic::Agent::Tracer.current_segment_key
+          @thread_id = Thread.current.object_id
           @transaction_name = nil
           @transaction = nil
           @guid = NewRelic::Agent::GuidGenerator.generate_guid

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

@@ -11,7 +11,7 @@ module NewRelic
   module Agent
     class Transaction
       class DatastoreSegment < Segment
-        UNKNOWN = 'unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN_LOWER
 
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
         attr_accessor :database_name, :record_sql

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

@@ -35,7 +35,7 @@ module NewRelic
         end
 
         def caller_transport_type
-          @caller_transport_type ||= 'Unknown'
+          @caller_transport_type ||= NewRelic::UNKNOWN
         end
 
         def accept_transport_type_from_api(value)
@@ -127,7 +127,7 @@ module NewRelic
         def consume_message_synthetics_headers(headers)
           synthetics_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER]
           if synthetics_header and
-              incoming_payload = ::JSON.load(deobfuscate(synthetics_header)) and
+              incoming_payload = ::JSON.parse(deobfuscate(synthetics_header)) and
               SyntheticsMonitor.is_valid_payload?(incoming_payload) and
               SyntheticsMonitor.is_supported_version?(incoming_payload) and
               SyntheticsMonitor.is_trusted?(incoming_payload)
@@ -167,7 +167,7 @@ module NewRelic
           return unless CrossAppTracing.trusted_valid_cross_app_id?(decoded_id)
 
           txn_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER]
-          txn_info = ::JSON.load(deobfuscate(txn_header))
+          txn_info = ::JSON.parse(deobfuscate(txn_header))
           payload = CrossAppPayload.new(decoded_id, transaction, txn_info)
 
           @cross_app_payload = payload

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

@@ -18,7 +18,7 @@ module NewRelic
         STREAM = 'Stream'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
-        UNKNOWN = 'Unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN
 
         DESTINATION_TYPES = [
           :exchange,

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

@@ -43,12 +43,7 @@ module NewRelic
           end
 
           if request_path
-            destinations = if allow_other_headers?
-              default_destinations
-            else
-              AttributeFilter::DST_TRANSACTION_TRACER | AttributeFilter::DST_ERROR_COLLECTOR
-            end
-            txn.add_agent_attribute(:'request.uri', request_path, destinations)
+            txn.add_agent_attribute(:'request.uri', request_path, default_destinations)
           end
 
           if accept

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

@@ -136,10 +136,8 @@ module NewRelic
 
           transaction.distributed_tracer.parent_transaction_id = payload.transaction_id
 
-          unless payload.sampled.nil?
-            transaction.sampled = payload.sampled
-            transaction.priority = payload.priority if payload.priority
-          end
+          determine_sampling_decision(payload, header_data.trace_parent['trace_flags'])
+
           NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
         rescue => e
@@ -148,6 +146,37 @@ module NewRelic
           false
         end
 
+        def determine_sampling_decision(payload, trace_flags)
+          if trace_flags == '01'
+            set_priority_and_sampled(NewRelic::Agent.config[:'distributed_tracing.sampler.remote_parent_sampled'], payload)
+          elsif trace_flags == '00'
+            set_priority_and_sampled(NewRelic::Agent.config[:'distributed_tracing.sampler.remote_parent_not_sampled'], payload)
+          else
+            use_nr_tracestate_sampled(payload)
+          end
+        rescue
+          use_nr_tracestate_sampled(payload)
+        end
+
+        def use_nr_tracestate_sampled(payload)
+          unless payload.sampled.nil?
+            transaction.sampled = payload.sampled
+            transaction.priority = payload.priority if payload.priority
+          end
+        end
+
+        def set_priority_and_sampled(config, payload)
+          if config == 'always_on'
+            transaction.sampled = true
+            transaction.priority = 2.0
+          elsif config == 'always_off'
+            transaction.sampled = false
+            transaction.priority = 0
+          else # default
+            use_nr_tracestate_sampled(payload)
+          end
+        end
+
         def ignore_trace_context?
           if trace_context_header_data
             NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -150,7 +150,7 @@ module NewRelic
           # rubocop:disable Style/SafeNavigation
           transaction_name = transaction_name = Tracer.current_transaction &&
             Tracer.current_transaction.best_name ||
-            'unknown'
+            NewRelic::UNKNOWN_LOWER
           # rubocop:enable Style/SafeNavigation
           NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
         end