datadog 2.7.1 → 2.17.0

data/lib/datadog/tracing/contrib/karafka/distributed/propagation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../../distributed/fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3_multi'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/none'
+require_relative '../../../distributed/trace_context'
+require_relative '../../../configuration/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        module Distributed
+          # Extracts and injects propagation through Kafka message headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize(
+              propagation_style_inject:,
+              propagation_style_extract:,
+              propagation_extract_first:
+            )
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER =>
+                    Tracing::Distributed::B3Multi.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
+                    Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                },
+                propagation_style_inject: propagation_style_inject,
+                propagation_style_extract: propagation_style_extract,
+                propagation_extract_first: propagation_extract_first
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/ext.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_KARAFKA_ENABLED'
+
+          SPAN_MESSAGE_CONSUME = 'karafka.consume'
+          SPAN_WORKER_PROCESS = 'worker.process'
+
+          TAG_CONSUMER = 'kafka.consumer'
+          TAG_TOPIC = 'kafka.topic'
+          TAG_PARTITION = 'kafka.partition'
+          TAG_OFFSET = 'kafka.offset'
+          TAG_OFFSET_LAG = 'kafka.offset_lag'
+          TAG_MESSAGE_COUNT = 'kafka.message_count'
+          TAG_MESSAGE_KEY = 'kafka.message_key'
+          TAG_SYSTEM = 'kafka'
+
+          TAG_OPERATION_PROCESS_BATCH = 'consumer.process_batch'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/integration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Description of Kafka integration
+        class Integration
+          include Contrib::Integration
+
+          # Minimum version of the Karafka library that we support
+          # https://karafka.io/docs/Versions-Lifecycle-and-EOL/#versioning-strategy
+          MINIMUM_VERSION = Gem::Version.new('2.3.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :karafka, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['karafka']&.version
+          end
+
+          def self.loaded?
+            !defined?(::Karafka).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/monitor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Custom monitor for Karafka.
+        # Creating a custom monitor, instead of subscribing to an event
+        # (e.g. `Karafka.monitor.subscribe 'worker.processed'`),
+        # is required because event subscriptions cannot wrap the event execution (`yield`).
+        module Monitor
+          TRACEABLE_EVENTS = %w[
+            worker.processed
+          ].freeze
+
+          def instrument(event_id, payload = {}, &block)
+            return super unless TRACEABLE_EVENTS.include?(event_id)
+
+            Datadog::Tracing.trace(Ext::SPAN_WORKER_PROCESS) do |span|
+              job = payload[:job]
+              job_type = fetch_job_type(job.class)
+              consumer = job.executor.topic.consumer
+
+              action = case job_type
+                       when 'Periodic', 'PeriodicNonBlocking'
+                         'tick'
+                       when 'Shutdown'
+                         'shutdown'
+                       when 'Revoked', 'RevokedNonBlocking'
+                         'revoked'
+                       when 'Idle'
+                         'idle'
+                       when 'Eofed', 'EofedNonBlocking'
+                         'eofed'
+                       else
+                         'consume'
+                       end
+
+              span.resource = "#{consumer}##{action}"
+
+              if action == 'consume'
+                span.set_tag(Ext::TAG_MESSAGE_COUNT, job.messages.count)
+                span.set_tag(Ext::TAG_PARTITION, job.executor.partition)
+                span.set_tag(Ext::TAG_OFFSET, job.messages.first.metadata.offset)
+                span.set_tag(Ext::TAG_CONSUMER, consumer)
+                span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, job.executor.topic.name)
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+              end
+
+              super
+            end
+          end
+
+          private
+
+          def fetch_job_type(job_class)
+            @job_types_cache ||= {}
+            @job_types_cache[job_class] ||= job_class.to_s.split('::').last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/patcher.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Patch to add tracing to Karafka::Messages::Messages
+        module MessagesPatch
+          def configuration
+            Datadog.configuration.tracing[:karafka]
+          end
+
+          def propagation
+            @propagation ||= Contrib::Karafka::Distributed::Propagation.new
+          end
+
+          # `each` is the most popular access point to Karafka messages,
+          # but not the only one
+          #  Other access patterns do not have a straightforward tracing avenue
+          # (e.g. `my_batch_operation messages.payloads`)
+          # @see https://github.com/karafka/karafka/blob/b06d1f7c17818e1605f80c2bb573454a33376b40/README.md?plain=1#L29-L35
+          def each(&block)
+            @messages_array.each do |message|
+              if configuration[:distributed_tracing]
+                headers = if message.metadata.respond_to?(:raw_headers)
+                            message.metadata.raw_headers
+                          else
+                            message.metadata.headers
+                          end
+                trace_digest = Karafka.extract(headers)
+                Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
+              end
+
+              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
+                span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
+                span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                span.resource = message.topic
+
+                yield message
+              end
+            end
+          end
+        end
+
+        # Patcher enables patching of 'karafka' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'monitor'
+
+            ::Karafka::Instrumentation::Monitor.prepend(Monitor)
+            ::Karafka::Messages::Messages.prepend(MessagesPatch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+require_relative 'karafka/integration'
+require_relative 'karafka/distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `Karafka` integration public API
+      module Karafka
+        def self.inject(digest, data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register('karafka') do |config|
+          tracing = config.tracing
+          tracing.propagation_style
+
+          @propagation = Karafka::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/mongodb/configuration/settings.rb

@@ -48,6 +48,14 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            # Serializes the command to JSON format, which is the desired format for the agent and Datadog UI.
+            # Setting this to false is deprecated and does not have any advantages.
+            option :json_command do |o|
+              o.type :bool
+              o.env Ext::ENV_JSON_COMMAND
+              o.default false
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/mongodb/ext.rb

@@ -13,6 +13,7 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_MONGO_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MONGO_ANALYTICS_SAMPLE_RATE'
+          ENV_JSON_COMMAND = 'DD_TRACE_MONGO_JSON_COMMAND'
           DEFAULT_PEER_SERVICE_NAME = 'mongodb'
           SPAN_COMMAND = 'mongo.cmd'
           SPAN_TYPE_COMMAND = 'mongodb'

data/lib/datadog/tracing/contrib/mongodb/integration.rb

@@ -17,6 +17,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :mongo, auto_patch: true
+          def self.gem_name
+            'mongo'
+          end
 
           def self.version
             Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../ext'
@@ -30,7 +32,7 @@ module Datadog
 
             # build a quantized Query using the Parser module
             query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
-            serialized_query = query.to_s
+            serialized_query = serialize_query(query)
 
             if datadog_configuration[:peer_service]
               span.set_tag(
@@ -109,6 +111,21 @@ module Datadog
 
           private
 
+          def serialize_query(query)
+            if datadog_configuration[:json_command]
+              query.to_json
+            else
+              # Incorrect Hash#to_s serialization. The Mongo command should only be encoded as JSON.
+              # This code path should be removed, and is only kept to avoid a breaking change.
+              Datadog::Core.log_deprecation(key: :mongo_json_command) do
+                'MongoDB integration: `json_command: false` causes invalid command serialization. '\
+                'Use `json_command: true` or `DD_TRACE_MONGO_JSON_COMMAND=1` instead.'
+              end
+
+              query.to_s
+            end
+          end
+
           def get_span(event)
             Thread.current[:datadog_mongo_span] \
               && Thread.current[:datadog_mongo_span][event.request_id]

data/lib/datadog/tracing/contrib/opensearch/configuration/settings.rb

@@ -46,6 +46,23 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            option :resource_pattern do |o|
+              o.type :string
+              o.env Ext::ENV_RESOURCE_PATTERN
+              o.default Ext::DEFAULT_RESOURCE_PATTERN
+              o.setter do |value|
+                next value if Ext::VALID_RESOURCE_PATTERNS.include?(value)
+
+                Datadog.logger.warn(
+                  "Invalid resource pattern: #{value}. " \
+                  "Supported values are: #{Ext::VALID_RESOURCE_PATTERNS.join(' | ')}. " \
+                  "Using default value: #{Ext::DEFAULT_RESOURCE_PATTERN}."
+                )
+
+                Ext::DEFAULT_RESOURCE_PATTERN
+              end
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/opensearch/ext.rb

@@ -13,6 +13,15 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_OPENSEARCH_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_OPENSEARCH_ANALYTICS_SAMPLE_RATE'
+          ENV_RESOURCE_PATTERN = 'DD_TRACE_OPENSEARCH_RESOURCE_PATTERN'
+          ABSOLUTE_RESOURCE_PATTERN = 'absolute'
+          RELATIVE_RESOURCE_PATTERN = 'relative'
+          VALID_RESOURCE_PATTERNS = [
+            ABSOLUTE_RESOURCE_PATTERN,
+            RELATIVE_RESOURCE_PATTERN
+          ].freeze
+          # Default should be changed to RELATIVE in 3.0 to match the Elasticsearch integration
+          DEFAULT_RESOURCE_PATTERN = ABSOLUTE_RESOURCE_PATTERN
           DEFAULT_PEER_SERVICE_NAME = 'opensearch'
           SPAN_QUERY = 'opensearch.query'
           SPAN_TYPE_QUERY = 'opensearch'

data/lib/datadog/tracing/contrib/opensearch/integration.rb

@@ -16,6 +16,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :opensearch, auto_patch: true
+          def self.gem_name
+            'opensearch-ruby'
+          end
 
           def self.version
             Gem.loaded_specs['opensearch-ruby'] \

data/lib/datadog/tracing/contrib/opensearch/patcher.rb

@@ -77,7 +77,11 @@ module Datadog
                   span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host) if host
 
                   # Define span resource
-                  quantized_url = OpenSearch::Quantize.format_url(url)
+                  quantized_url = if datadog_configuration[:resource_pattern] == Ext::RELATIVE_RESOURCE_PATTERN
+                                    OpenSearch::Quantize.format_url(url.path)
+                                  else # Default to Ext::ABSOLUTE_RESOURCE_PATTERN
+                                    OpenSearch::Quantize.format_url(url)
+                                  end
                   span.resource = "#{method} #{quantized_url}"
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e

data/lib/datadog/tracing/contrib/patcher.rb

@@ -20,8 +20,11 @@ module Datadog
         # @public_api
         module CommonMethods
           attr_accessor \
-            :patch_error_result,
-            :patch_successful
+            :patch_error_result
+
+          def patch_successful
+            !!@patch_successful
+          end
 
           def patch_name
             self.class != Class && self.class != Module ? self.class.name : name

data/lib/datadog/tracing/contrib/presto/integration.rb

@@ -16,6 +16,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :presto
+          def self.gem_name
+            'presto-client'
+          end
 
           def self.version
             Gem.loaded_specs['presto-client'] && Gem.loaded_specs['presto-client'].version

data/lib/datadog/tracing/contrib/rack/header_collection.rb

@@ -31,7 +31,17 @@ module Datadog
           end
 
           def self.to_rack_header(name)
-            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+            key = name.to_s.upcase.gsub(/[-\s]/, '_')
+            case key
+            when 'CONTENT_TYPE', 'CONTENT_LENGTH'
+              # NOTE: The Rack spec says:
+              # > The environment must not contain the keys HTTP_CONTENT_TYPE or HTTP_CONTENT_LENGTH
+              # > (use the versions without HTTP_).
+              # See https://github.com/rack/rack/blob/e217a399eb116362710aac7c5b8dc691ea2189b3/SPEC.rdoc?plain=1#L119-L121
+              key
+            else
+              "HTTP_#{key}"
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/rack/integration.rb

@@ -3,7 +3,7 @@
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'
-require_relative '../rails/utils'
+require_relative '../../../core/contrib/rails/utils'
 
 module Datadog
   module Tracing
@@ -33,7 +33,7 @@ module Datadog
           # enabled by rails integration so should only auto instrument
           # if detected that it is being used without rails
           def auto_instrument?
-            !Contrib::Rails::Utils.railtie_supported?
+            !Core::Contrib::Rails::Utils.railtie_supported?
           end
 
           def new_configuration

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -43,7 +43,7 @@ module Datadog
             # so that all spans will be added to the distributed trace.
             if configuration[:distributed_tracing]
               trace_digest = Contrib::HTTP.extract(env)
-              Tracing.continue_trace!(trace_digest)
+              Tracing.continue_trace!(trace_digest) if trace_digest
             end
 
             TraceProxyMiddleware.call(env, configuration) do

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -17,7 +17,7 @@ module Datadog
 
           module_function
 
-          def get_request_start(env, now = Time.now.utc)
+          def get_request_start(env, now = Core::Utils::Time.now.utc)
             header = env[REQUEST_START] || env[QUEUE_START]
             return unless header
 

data/lib/datadog/tracing/contrib/rails/framework.rb

@@ -9,7 +9,7 @@ require_relative '../active_support/integration'
 require_relative '../grape/endpoint'
 require_relative '../lograge/integration'
 require_relative 'ext'
-require_relative 'utils'
+require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/integration'
 
 module Datadog
@@ -41,7 +41,7 @@ module Datadog
               # being executed, but here we know better, get it from Rails config.
               # Don't set this if service has been explicitly provided by the user.
               if datadog_config.service_without_fallback.nil?
-                datadog_config.service = rails_config[:service_name] || Utils.app_name
+                datadog_config.service = rails_config[:service_name] || Core::Contrib::Rails::Utils.app_name
               end
 
               activate_rack!(datadog_config, rails_config)

data/lib/datadog/tracing/contrib/rails/patcher.rb

@@ -6,7 +6,7 @@ require_relative 'framework'
 require_relative 'log_injection'
 require_relative 'middlewares'
 require_relative 'runner'
-require_relative 'utils'
+require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/patcher'
 
 module Datadog

data/lib/datadog/tracing/contrib/rest_client/integration.rb

@@ -16,6 +16,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :rest_client
+          def self.gem_name
+            'rest-client'
+          end
 
           def self.version
             Gem.loaded_specs['rest-client'] && Gem.loaded_specs['rest-client'].version

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -25,10 +25,12 @@ module Datadog
               return super(&block) unless Tracing.enabled?
 
               datadog_trace_request(uri) do |_span, trace|
-                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                if Tracing::Distributed::PropagationPolicy.enabled?(
+                  global_config: datadog_configuration,
+                  trace: trace
+                )
+                  Contrib::HTTP.inject(trace, processed_headers)
                 end
-                Contrib::HTTP.inject(trace, processed_headers) if datadog_configuration[:distributed_tracing]
 
                 super(&block)
               end

data/lib/datadog/tracing/contrib/sidekiq/client_tracer.rb

@@ -24,7 +24,12 @@ module Datadog
             resource = job_resource(job)
 
             Datadog::Tracing.trace(Ext::SPAN_PUSH, service: @sidekiq_service) do |span, trace_op|
-              Sidekiq.inject(trace_op, job) if configuration[:distributed_tracing]
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: configuration,
+                trace: trace_op
+              )
+                Sidekiq.inject(trace_op, job)
+              end
 
               span.resource = resource
 

data/lib/datadog/tracing/contrib/sidekiq/distributed/propagation.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../../distributed/fetcher'
 require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/propagation_policy'
 require_relative '../../../distributed/b3_multi'
 require_relative '../../../distributed/b3_single'
 require_relative '../../../distributed/datadog'
@@ -31,6 +32,8 @@ module Datadog
                     Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
                     Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
                 },
                 propagation_style_inject: propagation_style_inject,

data/lib/datadog/tracing/contrib/sidekiq/server_tracer.rb

@@ -61,7 +61,7 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_RETRY_COUNT, job['retry_count'])
               span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
               span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
-              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
+              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Core::Utils::Time.now.utc.to_f - job['enqueued_at'].to_f))
 
               args = job['args']
               if args && !args.empty?

data/lib/datadog/tracing/contrib/span_attribute_schema.rb

@@ -21,9 +21,14 @@ module Datadog
         end
 
         def self.set_peer_service!(span, sources)
+          config = Datadog.configuration.tracing.contrib
+
+          # If `peer_service_defaults` is disabled, we only read peer service from an explicitly set `peer.service` tag
+          sources = Datadog::Tracing::Contrib::SpanAttributeSchema::REFLEXIVE_SOURCES unless config.peer_service_defaults
+
           # Acquire all peer.service values as well as any potential remapping
           peer_service_val, peer_service_source = set_peer_service_from_source(span, sources)
-          remap_val = Datadog.configuration.tracing.contrib.peer_service_mapping[peer_service_val]
+          remap_val = config.peer_service_mapping[peer_service_val]
 
           # Only continue to setting peer.service if actual source is found
           return false unless peer_service_source