datadog 2.12.2 → 2.14.0

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

@@ -42,7 +42,7 @@ module Datadog
               #
               # The tracer will try to find distributed headers in the order they are present in the list provided to this option.
               # The first format to have valid data present will be used.
-              #
+              # Baggage style is a special case, as it will always be extracted in addition if present.
               # @default `DD_TRACE_PROPAGATION_STYLE_EXTRACT` environment variable (comma-separated list),
               #   otherwise `['datadog','b3multi','b3']`.
               # @return [Array<String>]
@@ -53,6 +53,7 @@ module Datadog
                   [
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
+                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE,
                   ]
                 )
                 o.after_set do |styles|
@@ -74,6 +75,7 @@ module Datadog
                 o.default [
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE,
                 ]
                 o.after_set do |styles|
                   # Make values case-insensitive
@@ -186,7 +188,7 @@ module Datadog
               # It is not supported by our backend yet. Do not enable it.
               option :trace_id_128_bit_logging_enabled do |o|
                 o.env Tracing::Configuration::Ext::Correlation::ENV_TRACE_ID_128_BIT_LOGGING_ENABLED
-                o.default false
+                o.default true
                 o.type :bool
               end
 
@@ -249,6 +251,20 @@ module Datadog
                 o.type :bool
               end
 
+              # Forces the tracer to always send span events with the native span events format
+              # regardless of the agent support. This is useful in agent-less setups.
+              #
+              # When set to `nil`, the default, the agent will be queried for
+              # native span events support.
+              #
+              # @default `DD_TRACE_NATIVE_SPAN_EVENTS` environment variable, otherwise `false`
+              # @return [Boolean,nil]
+              option :native_span_events do |o|
+                o.env Tracing::Configuration::Ext::ENV_NATIVE_SPAN_EVENTS
+                o.default nil
+                o.type :bool, nilable: true
+              end
+
               # A custom sampler instance.
               # The object must respect the {Datadog::Tracing::Sampling::Sampler} interface.
               # @default `nil`

data/lib/datadog/tracing/context_provider.rb

@@ -49,7 +49,7 @@ module Datadog
       # To support multiple tracers simultaneously, each {Datadog::Tracing::FiberLocalContext}
       # instance has its own fiber-local variable.
       def initialize
-        @key = "datadog_context_#{FiberLocalContext.next_instance_id}".to_sym
+        @key = :"datadog_context_#{FiberLocalContext.next_instance_id}"
 
         self.local = Context.new
       end

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

@@ -22,7 +22,7 @@ module Datadog
           end
 
           def configure(options = {})
-            self.class.options.each do |name, _value|
+            self.class.options.each_key do |name|
               self[name] = options[name] if options.key?(name)
             end
 

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -110,11 +110,10 @@ module Datadog
 
               datadog_tag_request
 
-              if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(datadog_trace)
-                datadog_trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
-              end
-
-              if datadog_configuration[:distributed_tracing]
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: datadog_configuration,
+                trace: datadog_trace
+              )
                 @datadog_original_headers ||= {}
                 Contrib::HTTP.inject(datadog_trace, @datadog_original_headers)
                 self.headers = @datadog_original_headers

data/lib/datadog/tracing/contrib/excon/middleware.rb

@@ -30,10 +30,12 @@ module Datadog
                 trace = Tracing.active_trace
                 datum[:datadog_span] = span
                 annotate!(span, datum)
-                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: @options,
+                  trace: trace
+                )
+                  propagate!(trace, span, datum)
                 end
-                propagate!(trace, span, datum) if distributed_tracing?
 
                 span
               end

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

@@ -48,6 +48,7 @@ module Datadog
 
         module Messaging
           TAG_SYSTEM = 'messaging.system'
+          TAG_DESTINATION = 'messaging.destination'
           PEER_SERVICE_SOURCES = Array[Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -29,10 +29,12 @@ module Datadog
 
             Tracing.trace(Ext::SPAN_REQUEST, on_error: request_options[:on_error]) do |span, trace|
               annotate!(span, env, request_options)
-              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: request_options,
+                trace: trace
+              )
+                propagate!(trace, span, env)
               end
-              propagate!(trace, span, env) if request_options[:distributed_tracing] && Tracing.enabled?
               app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
             end
           end

data/lib/datadog/tracing/contrib/grpc/datadog_interceptor/client.rb

@@ -81,7 +81,13 @@ module Datadog
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-              GRPC.inject(trace, metadata) if distributed_tracing?
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                pin_config: Datadog.configuration_for(self),
+                global_config: datadog_configuration,
+                trace: trace
+              )
+                GRPC.inject(trace, metadata)
+              end
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             rescue StandardError => e
               Datadog.logger.debug("GRPC client trace failed: #{e}")

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

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

data/lib/datadog/tracing/contrib/http/circuit_breaker.rb

@@ -27,21 +27,6 @@ module Datadog
             !!(request[Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION] ||
               request[Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST])
           end
-
-          def should_skip_distributed_tracing?(client_config)
-            if Datadog.configuration.appsec.standalone.enabled
-              # Skip distributed tracing so that we don't bill distributed traces in case of absence of
-              # upstream ASM event (_dd.p.appsec:1) and no local security event (which sets _dd.p.appsec:1 locally).
-              # If there is an ASM event, we still have to check if distributed tracing is enabled or not
-              return true unless Tracing.active_trace
-
-              return true if Tracing.active_trace.get_tag(Datadog::AppSec::Ext::TAG_DISTRIBUTED_APPSEC_EVENT) != '1'
-            end
-
-            return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
-
-            !Datadog.configuration.tracing[:http][:distributed_tracing]
-          end
         end
       end
     end

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

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

data/lib/datadog/tracing/contrib/http/instrumentation.rb

@@ -35,11 +35,11 @@ module Datadog
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
                 span.resource = req.method
 
-                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
-                end
-
-                if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
+                if Tracing::Distributed::PropagationPolicy.enabled?(
+                  pin_config: client_config,
+                  global_config: Datadog.configuration.tracing[:http],
+                  trace: trace
+                )
                   Contrib::HTTP.inject(trace, req)
                 end
 

data/lib/datadog/tracing/contrib/httpclient/instrumentation.rb

@@ -30,11 +30,11 @@ module Datadog
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
-                  if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                    trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
-                  end
-
-                  if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
+                  if Tracing::Distributed::PropagationPolicy.enabled?(
+                    pin_config: client_config,
+                    global_config: Datadog.configuration.tracing[:httpclient],
+                    trace: trace
+                  )
                     Contrib::HTTP.inject(trace, req.header)
                   end
 
@@ -123,12 +123,6 @@ module Datadog
               Contrib::Analytics.enabled?(request_options[:analytics_enabled])
             end
 
-            def should_skip_distributed_tracing?(client_config)
-              return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
-
-              !Datadog.configuration.tracing[:httpclient][:distributed_tracing]
-            end
-
             def set_analytics_sample_rate(span, request_options)
               return unless analytics_enabled?(request_options)
 

data/lib/datadog/tracing/contrib/httprb/instrumentation.rb

@@ -30,12 +30,14 @@ module Datadog
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
-                  if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                    trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                  if Tracing::Distributed::PropagationPolicy.enabled?(
+                    pin_config: client_config,
+                    global_config: Datadog.configuration.tracing[:httprb],
+                    trace: trace
+                  )
+                    Contrib::HTTP.inject(trace, req)
                   end
 
-                  Contrib::HTTP.inject(trace, req) if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
-
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
@@ -135,12 +137,6 @@ module Datadog
               Datadog.logger
             end
 
-            def should_skip_distributed_tracing?(client_config)
-              return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
-
-              !Datadog.configuration.tracing[:httprb][:distributed_tracing]
-            end
-
             def set_analytics_sample_rate(span, request_options)
               return unless analytics_enabled?(request_options)
 

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        module Configuration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            option :service_name
+
+            option :distributed_tracing, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# 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_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 = EMPTY_HASH, &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/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