datadog 2.12.1 → 2.19.0

data/lib/datadog/tracing/component.rb

@@ -6,6 +6,7 @@ require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
 require_relative 'sampling/span/sampler'
 require_relative 'diagnostics/environment_logger'
+require_relative 'contrib/component'
 
 module Datadog
   module Tracing
@@ -74,18 +75,11 @@ module Datadog
           return sampler
         end
 
-        # AppSec events are sent to the backend using traces.
-        # Standalone ASM billing means that we don't want to charge clients for APM traces,
-        # so we want to send the minimum amount of traces possible (idealy only traces that contains security events),
-        # but for features such as API Security, we need to send at least one trace per minute,
-        # to keep the service alive on the backend side.
-        if settings.appsec.standalone.enabled
-          post_sampler = Tracing::Sampling::RuleSampler.new(
-            [Tracing::Sampling::SimpleRule.new(sample_rate: 1.0)],
-            rate_limiter: Datadog::Core::TokenBucket.new(1.0 / 60, 1.0),
-            default_sample_rate: 1.0 / 60
-          )
-        end
+        # APM Disablement means that we don't want to send traces that only contains APM data.
+        # Other products can then put the sampling priority to MANUAL_KEEP if they want to keep traces.
+        # (e.g.: AppSec will MANUAL_KEEP traces with AppSec events) and clients will be billed only for those traces.
+        # But to keep the service alive on the backend side, we need to send one trace per minute.
+        post_sampler = build_rate_limit_post_sampler(seconds: 60) unless settings.apm.tracing.enabled
 
         # Sampling rules are provided
         if (rules = settings.tracing.sampling.rules)
@@ -197,6 +191,15 @@ module Datadog
         end
       end
 
+      # Build a post-sampler that limits the rate of traces to one per `seconds`.
+      # E.g.: `build_rate_limit_post_sampler(seconds: 60)` will limit the rate to one trace per minute.
+      def build_rate_limit_post_sampler(seconds:)
+        Tracing::Sampling::RuleSampler.new(
+          rate_limiter: Datadog::Core::TokenBucket.new(1.0 / seconds, 1.0),
+          default_sample_rate: 1.0
+        )
+      end
+
       def build_test_mode_trace_flush(settings)
         # If context flush behavior is provided, use it instead.
         settings.tracing.test_mode.trace_flush || build_trace_flush(settings)

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

@@ -12,6 +12,7 @@ module Datadog
         ENV_OTEL_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER'
         ENV_HEADER_TAGS = 'DD_TRACE_HEADER_TAGS'
         ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
+        ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
 
         # @public_api
         module SpanAttributeSchema
@@ -41,8 +42,13 @@ module Datadog
           # W3C Trace Context
           PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'
 
+          # W3C Baggage
+          # @see https://www.w3.org/TR/baggage/
+          PROPAGATION_STYLE_BAGGAGE = 'baggage'
+
           PROPAGATION_STYLE_SUPPORTED = [PROPAGATION_STYLE_DATADOG, PROPAGATION_STYLE_B3_MULTI_HEADER,
-                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT].freeze
+                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT,
+                                         PROPAGATION_STYLE_BAGGAGE].freeze
 
           # Sets both extract and inject propagation style tho the provided value.
           # Has lower precedence than `DD_TRACE_PROPAGATION_STYLE_INJECT` or

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/action_pack/action_controller/instrumentation.rb

@@ -68,6 +68,12 @@ module Datadog
 
                 span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
                 span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
+                if (runtime = payload[:view_runtime])
+                  span.set_tag(Ext::TAG_VIEW_RUNTIME, runtime)
+                end
+                if (runtime = payload[:db_runtime])
+                  span.set_tag(Ext::TAG_DB_RUNTIME, runtime)
+                end
 
                 exception = payload[:exception_object]
                 if exception.nil?
@@ -118,6 +124,15 @@ module Datadog
                   payload[:exception] = [e.class.name, e.message]
                   payload[:exception_object] = e
                   raise e
+                ensure
+                  # Database and view runtime are available for controllers
+                  # deriving from ActionController::Base.
+                  # They are not defined on controllers deriving from
+                  # ActionController::Metal, unless
+                  # ActionController::Instrumentation is explicitly included
+                  # into the controller class.
+                  payload[:db_runtime] = db_runtime if respond_to?(:db_runtime)
+                  payload[:view_runtime] = view_runtime if respond_to?(:view_runtime)
                 end
               # rubocop:enable Lint/RescueException
               ensure

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/instrumentation.rb

@@ -9,9 +9,12 @@ module Datadog
         module ActionDispatch
           # Instrumentation for ActionDispatch components
           module Instrumentation
+            SCRIPT_NAME_KEY = 'SCRIPT_NAME'
+            FORMAT_SUFFIX = '(.:format)'
+
             module_function
 
-            def set_http_route_tags(route_spec, script_name)
+            def set_http_route_tags(route_spec, route_path)
               return unless Tracing.enabled?
 
               return unless route_spec
@@ -19,10 +22,10 @@ module Datadog
               request_trace = Tracing.active_trace
               return unless request_trace
 
-              request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, route_spec.to_s.gsub(/\(.:format\)\z/, ''))
+              request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, route_spec)
 
-              if script_name && !script_name.empty?
-                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, script_name)
+              if route_path && !route_path.empty?
+                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, route_path)
               end
             end
 
@@ -40,16 +43,17 @@ module Datadog
               # Instrumentation for ActionDispatch::Journey::Router for Rails versions older than 7.1
               module Router
                 def find_routes(req)
+                  # result is an array of [match, parameters, route] tuples
                   result = super
+                  result.each do |_, _, route|
+                    next unless Instrumentation.dispatcher_route?(route)
 
-                  # result is an array of [match, parameters, route] tuples
-                  routes = result.map(&:last)
+                    http_route = route.path.spec.to_s
+                    http_route.delete_suffix!(FORMAT_SUFFIX)
 
-                  routes.each do |route|
-                    if Instrumentation.dispatcher_route?(route)
-                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
-                      break
-                    end
+                    Instrumentation.set_http_route_tags(http_route, req.env[SCRIPT_NAME_KEY])
+
+                    break
                   end
 
                   result
@@ -62,7 +66,10 @@ module Datadog
                 def find_routes(req)
                   super do |match, parameters, route|
                     if Instrumentation.dispatcher_route?(route)
-                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                      http_route = route.path.spec.to_s
+                      http_route.delete_suffix!(FORMAT_SUFFIX)
+
+                      Instrumentation.set_http_route_tags(http_route, req.env[SCRIPT_NAME_KEY])
                     end
 
                     yield [match, parameters, route]

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

@@ -16,6 +16,8 @@ module Datadog
           TAG_OPERATION_CONTROLLER = 'controller'
           TAG_ROUTE_ACTION = 'rails.route.action'
           TAG_ROUTE_CONTROLLER = 'rails.route.controller'
+          TAG_DB_RUNTIME = 'rails.db.runtime'
+          TAG_VIEW_RUNTIME = 'rails.view.runtime'
         end
       end
     end

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

@@ -57,7 +57,7 @@ module Datadog
           end
 
           def reset_resolver_cache
-            @resolver&.reset_cache
+            @resolver&.reset_cache if defined?(@resolver)
           end
 
           Contrib::Component.register('activerecord') do |_config|

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -45,9 +45,15 @@ module Datadog
                 'cache_write_multi.active_support' => { resource: Ext::RESOURCE_CACHE_MSET, multi_key: true }
               }.freeze
 
-              def trace?(event, _payload)
+              def trace?(event, payload)
                 return false if !Tracing.enabled? || !configuration.enabled
 
+                if (cache_store = configuration[:cache_store])
+                  store = cache_backend(payload[:store])
+
+                  return false unless cache_store.include?(store)
+                end
+
                 # DEV-3.0: Backwards compatibility code for the 2.x gem series.
                 # DEV-3.0: See documentation at {Datadog::Tracing::Contrib::ActiveSupport::Cache::Instrumentation}
                 # DEV-3.0: for the complete information about this backwards compatibility code.
@@ -62,7 +68,10 @@ module Datadog
               end
 
               def on_start(span, event, _id, payload)
-                key = payload[:key]
+                # Since Rails 8, `dd_original_keys` contains the denormalized key provided by the user.
+                # In previous versions, the denormalized key is stored in the official `key` attribute.
+                # We fall back to `key`, even in Rails 8, as a defensive measure.
+                key = payload[:dd_original_keys] || payload[:key]
                 store = payload[:store]
 
                 mapping = MAPPING.fetch(event)

data/lib/datadog/tracing/contrib/active_support/cache/instrumentation.rb

@@ -184,6 +184,39 @@ module Datadog
                 super(operation, key, polyfill_options)
               end
             end
+
+            # Save the original, user-supplied cache key, before it gets normalized.
+            #
+            # Normalized keys can include internal implementation detail,
+            # for example FileStore keys include temp directory names, which
+            # changes on every run, making it impossible to group by the cache key afterward.
+            # Also, the user is never exposed to the normalized key, and only sets/gets using the
+            # original key.
+            module PreserveOriginalKey
+              # Stores the original keys in the options hash, as an array of keys.
+              # It's important to keep all the keys for multi-key operations.
+              # For single-key operations, the key is stored as an array of a single element.
+              def normalize_key(key, options)
+                orig_keys = options[:dd_original_keys] || []
+                orig_keys << key
+                options[:dd_original_keys] = orig_keys
+
+                super
+              end
+
+              # Ensure we don't pollute the default Store instance `options` in {PreserveOriginalKey#normalize_key}.
+              # In most cases, `merged_options` returns a new hash,
+              # but we check for cases where it reuses the instance hash.
+              def merged_options(call_options)
+                ret = super
+
+                if ret.equal?(options)
+                  ret.dup
+                else
+                  ret
+                end
+              end
+            end
           end
         end
       end

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

@@ -22,6 +22,10 @@ module Datadog
             def patch
               Events.subscribe!
 
+              if Integration.version >= Gem::Version.new('8.0.0')
+                ::ActiveSupport::Cache::Store.prepend(Cache::Instrumentation::PreserveOriginalKey)
+              end
+
               # Backfill the `:store` key in the ActiveSupport event payload for older Rails.
               if Integration.version < Gem::Version.new('6.1.0')
                 ::ActiveSupport::Cache::Store.prepend(Cache::Instrumentation::Store)

data/lib/datadog/tracing/contrib/active_support/cache/redis.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../../support'
 require_relative 'patcher'
 
 module Datadog
@@ -34,10 +35,7 @@ module Datadog
               # @see https://github.com/rails/rails/blob/d0dcb8fa6073a0c4d42600c15e82e3bb386b27d3/activesupport/lib/active_support/cache/redis_cache_store.rb#L4
               def patch_redis_cache_store?(meth)
                 Gem.loaded_specs['redis'] &&
-                  # Autoload constants return `constant` for `defined?`, but that doesn't mean they are loaded...
-                  defined?(::ActiveSupport::Cache::RedisCacheStore) &&
-                  # ... to check that we need to call `autoload?` and check if it returns `nil`, meaning it's loaded.
-                  ::ActiveSupport::Cache.autoload?(:RedisCacheStore).nil? &&
+                  Support.fully_loaded?(::ActiveSupport::Cache, :RedisCacheStore) &&
                   ::ActiveSupport::Cache::RedisCacheStore.instance_methods(false).include?(meth)
               end
 

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

@@ -49,6 +49,19 @@ module Datadog
                 o.default true
               end
             end
+
+            # Specifies which cache stores to trace.
+            # Accepts a list, with the same format as `config.cache_store`
+            # (e.g. `memory_store`, `file_store`, or symbols like `:file_store`).
+            # Defaults to `nil`, which traces all cache stores.
+            # @see https://github.com/rails/rails/blob/b7520a13adda46c0cc5f3fb4a4c1726633af2bba/guides/source/caching_with_rails.md?plain=1#L576-L582
+            option :cache_store do |o|
+              o.type :array, nilable: true
+              o.default nil
+              o.after_set do |stores|
+                stores&.map!(&:to_s) # Convert symbols to strings to match the Rails configuration format
+              end
+            end
           end
         end
       end

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

@@ -35,6 +35,16 @@ module Datadog
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
+
+            # Set error on the span if the Response Status Code is in error range
+            if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(context.safely(:status_code))
+              # At this point we do not have any additional diagnostics
+              # besides the HTTP status code which is recorded in the span tags
+              # later in this method.
+              # Just set the span as errored.
+              span.set_error(nil)
+            end
+
             aws_service = span.resource.split('.')[0]
             span.set_tag(Ext::TAG_AWS_SERVICE, aws_service)
             params = context.safely(:params)

data/lib/datadog/tracing/contrib/aws/parsed_context.rb

@@ -26,8 +26,12 @@ module Datadog
             context.params
           end
 
+          def http_response
+            context.http_response
+          end
+
           def status_code
-            context.http_response.status_code
+            http_response.status_code
           end
 
           def http_method

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

@@ -30,16 +30,16 @@ module Datadog
 
               return super(req, body, &block) if Contrib::HTTP.should_skip_tracing?(req)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 span.service = service_name(host, request_options, client_config)
                 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
 
@@ -112,10 +112,6 @@ module Datadog
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def set_analytics_sample_rate(span, request_options)
               return unless analytics_enabled?(request_options)
 

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

@@ -25,16 +25,16 @@ module Datadog
               request_options = datadog_configuration(host)
               client_config = Datadog.configuration_for(self)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 begin
                   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
 
@@ -111,10 +111,6 @@ module Datadog
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def datadog_configuration(host = :default)
               Datadog.configuration.tracing[:httpclient, host]
             end
@@ -123,12 +119,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)