datadog 2.12.2 → 2.15.0

data/lib/datadog/profiling/ext.rb

@@ -26,7 +26,6 @@ module Datadog
           TAG_GIT_REPOSITORY_URL = "git.repository_url"
           TAG_GIT_COMMIT_SHA = "git.commit.sha"
 
-          PPROF_DEFAULT_FILENAME = "rubyprofile.pprof"
           CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end

data/lib/datadog/profiling/flush.rb

@@ -9,10 +9,9 @@ module Datadog
       attr_reader \
         :start,
         :finish,
-        :pprof_file_name,
-        :pprof_data, # gzipped pprof bytes
+        :encoded_profile,
         :code_provenance_file_name,
-        :code_provenance_data, # gzipped json bytes
+        :code_provenance_data,
         :tags_as_array,
         :internal_metadata_json,
         :info_json
@@ -20,8 +19,7 @@ module Datadog
       def initialize(
         start:,
         finish:,
-        pprof_file_name:,
-        pprof_data:,
+        encoded_profile:,
         code_provenance_file_name:,
         code_provenance_data:,
         tags_as_array:,
@@ -30,8 +28,7 @@ module Datadog
       )
         @start = start
         @finish = finish
-        @pprof_file_name = pprof_file_name
-        @pprof_data = pprof_data
+        @encoded_profile = encoded_profile
         @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
         @tags_as_array = tags_as_array

data/lib/datadog/profiling/http_transport.rb

@@ -20,34 +20,21 @@ module Datadog
             [:agent, agent_settings.url].freeze
           end
 
-        status, result = validate_exporter(exporter_configuration)
+        status, result = self.class._native_validate_exporter(exporter_configuration)
 
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
       def export(flush)
-        status, result = do_export(
-          exporter_configuration: exporter_configuration,
-          upload_timeout_milliseconds: @upload_timeout_milliseconds,
-
-          # why "timespec"?
-          # libdatadog represents time using POSIX's struct timespec, see
-          # https://www.gnu.org/software/libc/manual/html_node/Time-Types.html
-          # aka it represents the seconds part separate from the nanoseconds part
-          start_timespec_seconds: flush.start.tv_sec,
-          start_timespec_nanoseconds: flush.start.tv_nsec,
-          finish_timespec_seconds: flush.finish.tv_sec,
-          finish_timespec_nanoseconds: flush.finish.tv_nsec,
-
-          pprof_file_name: flush.pprof_file_name,
-          pprof_data: flush.pprof_data,
-          code_provenance_file_name: flush.code_provenance_file_name,
-          code_provenance_data: flush.code_provenance_data,
-
-          tags_as_array: flush.tags_as_array,
-          internal_metadata_json: flush.internal_metadata_json,
-
-          info_json: flush.info_json
+        status, result = self.class._native_do_export(
+          exporter_configuration,
+          @upload_timeout_milliseconds,
+          flush,
+          # TODO: This is going to be removed once we move to libdatadog 17
+          flush.start.tv_sec,
+          flush.start.tv_nsec,
+          flush.finish.tv_sec,
+          flush.finish.tv_nsec,
         )
 
         if status == :ok
@@ -77,42 +64,6 @@ module Datadog
         site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
       end
 
-      def validate_exporter(exporter_configuration)
-        self.class._native_validate_exporter(exporter_configuration)
-      end
-
-      def do_export(
-        exporter_configuration:,
-        upload_timeout_milliseconds:,
-        start_timespec_seconds:,
-        start_timespec_nanoseconds:,
-        finish_timespec_seconds:,
-        finish_timespec_nanoseconds:,
-        pprof_file_name:,
-        pprof_data:,
-        code_provenance_file_name:,
-        code_provenance_data:,
-        tags_as_array:,
-        internal_metadata_json:,
-        info_json:
-      )
-        self.class._native_do_export(
-          exporter_configuration,
-          upload_timeout_milliseconds,
-          start_timespec_seconds,
-          start_timespec_nanoseconds,
-          finish_timespec_seconds,
-          finish_timespec_nanoseconds,
-          pprof_file_name,
-          pprof_data,
-          code_provenance_file_name,
-          code_provenance_data,
-          tags_as_array,
-          internal_metadata_json,
-          info_json,
-        )
-      end
-
       def config_without_api_key
         "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
       end

data/lib/datadog/profiling/stack_recorder.rb

@@ -63,11 +63,11 @@ module Datadog
         status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          start, finish, encoded_pprof, profile_stats = result
+          start, finish, encoded_profile, profile_stats = result
 
           Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
 
-          [start, finish, encoded_pprof, profile_stats]
+          [start, finish, encoded_profile, profile_stats]
         else
           error_message = result
 
@@ -82,9 +82,9 @@ module Datadog
         status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          _start, _finish, encoded_pprof = result
+          _start, _finish, encoded_profile = result
 
-          encoded_pprof
+          encoded_profile
         else
           error_message = result
 

data/lib/datadog/profiling.rb

@@ -78,8 +78,11 @@ module Datadog
     end
 
     private_class_method def self.replace_noop_allocation_count
-      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
-        Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+      class << self
+        remove_method :allocation_count
+        def allocation_count
+          Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+        end
       end
     end
 
@@ -146,6 +149,7 @@ module Datadog
       require_relative 'profiling/collectors/thread_context'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/exporter'
+      require_relative 'profiling/encoded_profile'
       require_relative 'profiling/flush'
       require_relative 'profiling/scheduler'
       require_relative 'profiling/tasks/setup'

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/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/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