ddtrace 1.6.1 → 1.7.0

data/lib/datadog/profiling/collectors/old_stack.rb

@@ -218,6 +218,13 @@ module Datadog
           )
         end
 
+        def reset_after_fork
+          recorder.reset_after_fork
+
+          # NOTE: We could perhaps also call #reset_cpu_time_tracking here, although it's not needed because we always
+          # call in in #start.
+        end
+
         private
 
         # If the profiler is started for a while, stopped and then restarted OR whenever the process forks, we need to

data/lib/datadog/profiling/exporter.rb

@@ -70,6 +70,11 @@ module Datadog
         !duration_below_threshold?(last_flush_finish_at || created_at, time_provider.now.utc)
       end
 
+      def reset_after_fork
+        @last_flush_finish_at = time_provider.now.utc
+        nil
+      end
+
       private
 
       def duration_below_threshold?(start, finish)

data/lib/datadog/profiling/old_recorder.rb

@@ -73,6 +73,14 @@ module Datadog
         [start, finish, encoded_pprof]
       end
 
+      def reset_after_fork
+        Datadog.logger.debug('Resetting OldRecorder in child process after fork')
+
+        # NOTE: A bit of a heavy-handed approach, but it doesn't happen often and this class will be removed soon anyway
+        serialize
+        nil
+      end
+
       # Error when event of an unknown type is used with the OldRecorder
       class UnknownEventError < StandardError
         attr_reader :event_class

data/lib/datadog/profiling/profiler.rb

@@ -4,6 +4,8 @@ module Datadog
   module Profiling
     # Profiling entry point, which coordinates collectors and a scheduler
     class Profiler
+      include Datadog::Core::Utils::Forking
+
       attr_reader \
         :collectors,
         :scheduler
@@ -14,6 +16,11 @@ module Datadog
       end
 
       def start
+        after_fork! do
+          collectors.each(&:reset_after_fork)
+          scheduler.reset_after_fork
+        end
+
         collectors.each(&:start)
         scheduler.start
       end

data/lib/datadog/profiling/scheduler.rb

@@ -66,13 +66,6 @@ module Datadog
         end
       end
 
-      def after_fork
-        # Clear any existing profiling state.
-        # We don't want the child process to report profiling data from its parent.
-        Datadog.logger.debug('Flushing exporter in child process #after_fork and discarding data')
-        exporter.flush
-      end
-
       # Configure Workers::IntervalLoop to not report immediately when scheduler starts
       #
       # When a scheduler gets created (or reset), we don't want it to immediately try to flush; we want it to wait for
@@ -86,6 +79,10 @@ module Datadog
         exporter.can_flush?
       end
 
+      def reset_after_fork
+        exporter.reset_after_fork
+      end
+
       private
 
       def flush_and_wait

data/lib/datadog/profiling/stack_recorder.rb

@@ -34,10 +34,32 @@ module Datadog
         end
       end
 
+      def clear
+        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_clear(self) }
+
+        if status == :ok
+          finish_timestamp = result
+
+          Datadog.logger.debug { "Cleared profile at #{finish_timestamp}" }
+
+          finish_timestamp
+        else
+          error_message = result
+
+          Datadog.logger.error("Failed to clear profiling data: #{error_message}")
+
+          nil
+        end
+      end
+
       # Used only for Ruby 2.2 which doesn't have the native `rb_time_timespec_new` API; called from native code
       def self.ruby_time_from(timespec_seconds, timespec_nanoseconds)
         Time.at(0).utc + timespec_seconds + (timespec_nanoseconds.to_r / 1_000_000_000)
       end
+
+      def reset_after_fork
+        self.class._native_reset_after_fork(self)
+      end
     end
   end
 end

data/lib/datadog/profiling/tasks/setup.rb

@@ -55,13 +55,6 @@ module Datadog
           if Process.respond_to?(:at_fork)
             Process.at_fork(:child) do
               begin
-                # When Ruby forks, clock IDs for each of the threads
-                # will change. We can only update these IDs from the
-                # execution context of the thread that owns it.
-                # This hook will update the IDs for the main thread
-                # after a fork occurs.
-                Thread.current.send(:update_native_ids) if Thread.current.respond_to?(:update_native_ids, true)
-
                 # Restart profiler, if enabled
                 Profiling.start_if_enabled
               rescue StandardError => e

data/lib/datadog/tracing/contrib/delayed_job/plugin.rb

@@ -35,6 +35,8 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
 
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
               yield job
             end
           end
@@ -59,6 +61,8 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENQUEUE)
 
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
+
               yield job
             end
           end

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

@@ -2,6 +2,7 @@
 
 require_relative '../../../../tracing'
 require_relative '../../../metadata/ext'
+require_relative '../distributed/propagation'
 require_relative '../../analytics'
 require_relative '../ext'
 require_relative '../../ext'
@@ -55,7 +56,7 @@ module Datadog
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-              Tracing::Propagation::GRPC.inject!(trace, metadata) if distributed_tracing?
+              Distributed::Propagation::INSTANCE.inject!(trace, metadata) if distributed_tracing?
             rescue StandardError => e
               Datadog.logger.debug("GRPC client trace failed: #{e}")
             end

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

@@ -1,9 +1,8 @@
 # typed: ignore
 
 require_relative '../../../../tracing'
-require_relative '../../../distributed/headers/ext'
 require_relative '../../../metadata/ext'
-require_relative '../../../propagation/grpc'
+require_relative '../distributed/propagation'
 require_relative '../../analytics'
 require_relative '../ext'
 require_relative '../../ext'
@@ -45,7 +44,7 @@ module Datadog
             private
 
             def set_distributed_context!(metadata)
-              Tracing.continue_trace!(Tracing::Propagation::GRPC.extract(metadata))
+              Tracing.continue_trace!(Distributed::Propagation::INSTANCE.extract(metadata))
             rescue StandardError => e
               Datadog.logger.debug(
                 "unable to propagate GRPC metadata to context: #{e}"
@@ -54,11 +53,14 @@ module Datadog
 
             def annotate!(span, metadata)
               metadata.each do |header, value|
-                next if reserved_headers.include?(header)
+                # Datadog propagation headers are considered internal implementation detail.
+                next if header.to_s.start_with?(Tracing::Distributed::Datadog::TAGS_PREFIX)
 
                 span.set_tag(header, value)
               end
 
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SERVICE)
 
@@ -71,14 +73,6 @@ module Datadog
               Datadog.logger.debug("GRPC client trace failed: #{e}")
             end
 
-            def reserved_headers
-              [
-                Tracing::Distributed::Headers::Ext::GRPC_METADATA_TRACE_ID,
-                Tracing::Distributed::Headers::Ext::GRPC_METADATA_PARENT_ID,
-                Tracing::Distributed::Headers::Ext::GRPC_METADATA_SAMPLING_PRIORITY
-              ]
-            end
-
             def format_resource(proto_method)
               proto_method
                 .owner

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative '../../../distributed/fetcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GRPC
+        module Distributed
+          # Retrieves values from the gRPC metadata.
+          # One metadata key can be associated with multiple values.
+          #
+          # @see https://github.com/grpc/grpc-go/blob/56ac86fa0f3940cb79946ce2c6e56f7ee7ecae84/Documentation/grpc-metadata.md#constructing-metadata
+          class Fetcher < Tracing::Distributed::Fetcher
+            def [](key)
+              # Metadata values are normally integrals but can also be
+              # arrays when multiple values are associated with the same key.
+              value = super(key)
+              value.is_a?(::Array) ? value[0] : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative 'fetcher'
+require_relative '../../../distributed/b3'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GRPC
+        module Distributed
+          # Extracts and injects propagation through gRPC metadata.
+          # @see https://github.com/grpc/grpc-go/blob/v1.50.1/Documentation/grpc-metadata.md
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3 =>
+                    Tracing::Distributed::B3.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Fetcher)
+                })
+            end
+
+            # DEV: Singleton kept until a larger refactor is performed.
+            # DEV: See {Datadog::Tracing::Distributed::Propagation#initialize} for more information.
+            INSTANCE = Propagation.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,8 +19,6 @@ module Datadog
           end
 
           def patch
-            require_relative '../../propagation/grpc'
-            require_relative 'datadog_interceptor'
             require_relative 'intercept_with_datadog'
 
             prepend_interceptor

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: false
+# typed: false
+
+require_relative '../../../distributed/fetcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module HTTP
+        module Distributed
+          # Retrieves Rack formatted headers from HTTP headers.
+          class Fetcher < Tracing::Distributed::Fetcher
+            # TODO: Don't assume Rack format.
+            #       Make distributed tracing headers apathetic.
+            # DEV: Should we try to parse both verbatim an Rack-formatted headers,
+            # DEV: given Rack-formatted is the most common format in Ruby?
+            def [](name)
+              rack_header = "HTTP-#{name}"
+              rack_header.upcase!
+              rack_header.tr!('-'.freeze, '_'.freeze)
+
+              hdr = super(rack_header)
+
+              # Only return the value if it is not an empty string
+              hdr if hdr != ''
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative 'fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module HTTP
+        module Distributed
+          # Extracts and injects propagation through HTTP headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3 =>
+                    Tracing::Distributed::B3.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Fetcher)
+                })
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/consumer_event.rb

@@ -10,6 +10,7 @@ module Datadog
             super
 
             span.set_tag(Ext::TAG_GROUP, payload[:group_id])
+            span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
           end
         end
       end

data/lib/datadog/tracing/contrib/kafka/events/produce_operation/send_messages.rb

@@ -20,6 +20,7 @@ module Datadog
 
                 span.set_tag(Ext::TAG_MESSAGE_COUNT, payload[:message_count]) if payload.key?(:message_count)
                 span.set_tag(Ext::TAG_SENT_MESSAGE_COUNT, payload[:sent_message_count]) if payload.key?(:sent_message_count)
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
               end
 
               module_function

data/lib/datadog/tracing/contrib/kafka/events/producer/deliver_messages.rb

@@ -23,6 +23,7 @@ module Datadog
                 if payload.key?(:delivered_message_count)
                   span.set_tag(Ext::TAG_DELIVERED_MESSAGE_COUNT, payload[:delivered_message_count])
                 end
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
               end
 
               module_function

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

@@ -33,6 +33,8 @@ module Datadog
 
             span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
 
+            span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
             span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
             span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
 

data/lib/datadog/tracing/contrib/que/tracer.rb

@@ -33,6 +33,8 @@ module Datadog
               request_span.set_tag(Ext::TAG_JOB_ARGS, job.que_attrs[:args]) if configuration[:tag_args]
               request_span.set_tag(Ext::TAG_JOB_DATA, job.que_attrs[:data]) if configuration[:tag_data]
 
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
               set_sample_rate(request_span)
               Contrib::Analytics.set_measured(request_span)
 

data/lib/datadog/tracing/contrib/racecar/events/batch.rb

@@ -25,7 +25,10 @@ module Datadog
             end
 
             def span_options
-              super.merge(tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_BATCH })
+              super.merge(
+                tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_BATCH,
+                        Tracing::Metadata::Ext::TAG_KIND => Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER }
+              )
             end
           end
         end

data/lib/datadog/tracing/contrib/racecar/events/message.rb

@@ -25,7 +25,10 @@ module Datadog
             end
 
             def span_options
-              super.merge(tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_MESSAGE })
+              super.merge(
+                tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_MESSAGE,
+                        Tracing::Metadata::Ext::TAG_KIND => Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER }
+              )
             end
           end
         end

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

@@ -45,6 +45,7 @@ module Datadog
             # Tag this span as belonging to Rack
             frontend_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
             frontend_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_SERVER_QUEUE)
+            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
             # Set peer service (so its not believed to belong to this app)
             frontend_span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, configuration[:web_service_name])
@@ -157,6 +158,7 @@ module Datadog
 
             request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])

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

@@ -26,6 +26,7 @@ module Datadog
                 span.span_type = Contrib::Redis::Ext::TYPE
                 span.resource = get_command(args)
                 Contrib::Redis::Tags.set_common_tags(self, span)
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
                 response = super
               end
@@ -43,6 +44,7 @@ module Datadog
                 span.resource = commands.any? ? commands.join("\n") : '(none)'
                 span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
                 Contrib::Redis::Tags.set_common_tags(self, span)
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
                 response = super
               end

data/lib/datadog/tracing/contrib/resque/resque_job.rb

@@ -41,6 +41,8 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
 
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])

data/lib/datadog/tracing/contrib/shoryuken/tracer.rb

@@ -37,6 +37,8 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_ATTRIBUTES, sqs_msg.attributes) if sqs_msg.respond_to?(:attributes)
               span.set_tag(Ext::TAG_JOB_BODY, body) if configuration[:tag_body]
 
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
               yield
             end
           end

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

@@ -28,6 +28,11 @@ module Datadog
               span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PUSH)
 
+              span.set_tag(
+                Datadog::Tracing::Metadata::Ext::TAG_KIND,
+                Datadog::Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER
+              )
+
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])

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

@@ -40,6 +40,11 @@ module Datadog
               span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
 
+              span.set_tag(
+                Datadog::Tracing::Metadata::Ext::TAG_KIND,
+                Datadog::Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER
+              )
+
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])

data/lib/datadog/tracing/contrib/sneakers/tracer.rb

@@ -41,6 +41,8 @@ module Datadog
 
               request_span.set_tag(Ext::TAG_JOB_BODY, deserialized_msg) if configuration[:tag_body]
 
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
               @app.call(deserialized_msg, delivery_info, metadata, handler)
             end
           end

data/lib/datadog/tracing/distributed/b3.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative 'helpers'
+require_relative '../trace_digest'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # B3-style trace propagation.
+      # @see https://github.com/openzipkin/b3-propagation#multiple-headers
+      class B3
+        B3_TRACE_ID_KEY = 'x-b3-traceid'
+        B3_SPAN_ID_KEY = 'x-b3-spanid'
+        B3_SAMPLED_KEY = 'x-b3-sampled'
+
+        def initialize(
+          fetcher:,
+          trace_id_key: B3_TRACE_ID_KEY,
+          span_id_key: B3_SPAN_ID_KEY,
+          sampled_key: B3_SAMPLED_KEY
+        )
+          @trace_id_key = trace_id_key
+          @span_id_key = span_id_key
+          @sampled_key = sampled_key
+          @fetcher = fetcher
+        end
+
+        def inject!(digest, data = {})
+          return if digest.nil?
+
+          # DEV: We need these to be hex encoded
+          data[@trace_id_key] = digest.trace_id.to_s(16)
+          data[@span_id_key] = digest.span_id.to_s(16)
+
+          if digest.trace_sampling_priority
+            sampling_priority = Helpers.clamp_sampling_priority(
+              digest.trace_sampling_priority
+            )
+            data[@sampled_key] = sampling_priority.to_s
+          end
+
+          data
+        end
+
+        def extract(data)
+          # DEV: B3 doesn't have "origin"
+          fetcher = @fetcher.new(data)
+          trace_id = fetcher.id(@trace_id_key, base: 16)
+          span_id = fetcher.id(@span_id_key, base: 16)
+          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
+          sampling_priority = fetcher.number(@sampled_key)
+
+          # Return early if this propagation is not valid
+          return unless trace_id && span_id
+
+          TraceDigest.new(
+            trace_id: trace_id,
+            span_id: span_id,
+            trace_sampling_priority: sampling_priority
+          )
+        end
+      end
+    end
+  end
+end