ddtrace 0.49.0 → 1.12.1

data/lib/datadog/tracing/contrib/utils/quantization/hash.rb

@@ -0,0 +1,109 @@
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        module Quantization
+          # Quantization for Hash
+          module Hash
+            PLACEHOLDER = '?'.freeze
+            EXCLUDE_KEYS = [].freeze
+            SHOW_KEYS = [].freeze
+            DEFAULT_OPTIONS = {
+              exclude: EXCLUDE_KEYS,
+              show: SHOW_KEYS,
+              placeholder: PLACEHOLDER
+            }.freeze
+
+            module_function
+
+            def format(hash_obj, options = {})
+              options ||= {}
+              format!(hash_obj, options)
+            rescue StandardError
+              options[:placeholder] || PLACEHOLDER
+            end
+
+            def format!(hash_obj, options = {})
+              options ||= {}
+              options = merge_options(DEFAULT_OPTIONS, options)
+              format_hash(hash_obj, options)
+            end
+
+            def format_hash(hash_obj, options = {})
+              case hash_obj
+              when ::Hash
+                return {} if options[:exclude] == :all
+                return hash_obj if options[:show] == :all
+
+                hash_obj.each_with_object({}) do |(key, value), quantized|
+                  if options[:show].any?(&indifferent_equals(key))
+                    quantized[key] = value
+                  elsif options[:exclude].none?(&indifferent_equals(key))
+                    quantized[key] = format_value(value, options)
+                  end
+                end
+              else
+                format_value(hash_obj, options)
+              end
+            end
+
+            def format_value(value, options = {})
+              return value if options[:show] == :all
+
+              case value
+              when ::Hash
+                format_hash(value, options)
+              when Array
+                # If any are objects, format them.
+                format_array(value, options)
+              else
+                options[:placeholder]
+              end
+            end
+
+            def format_array(value, options)
+              if value.any? { |v| v.class <= ::Hash || v.class <= Array }
+                first_entry = format_value(value.first, options)
+                value.size > 1 ? [first_entry, options[:placeholder]] : [first_entry]
+                # Otherwise short-circuit and return single placeholder
+              else
+                [options[:placeholder]]
+              end
+            end
+
+            def merge_options(original, additional)
+              {}.tap do |options|
+                # Show
+                # If either is :all, value becomes :all
+                options[:show] =  if original[:show] == :all || additional[:show] == :all
+                                    :all
+                                  else
+                                    (original[:show] || []).dup.concat(additional[:show] || []).uniq
+                                  end
+
+                # Exclude
+                # If either is :all, value becomes :all
+                options[:exclude] = if original[:exclude] == :all || additional[:exclude] == :all
+                                      :all
+                                    else
+                                      (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
+                                    end
+
+                options[:placeholder] = additional[:placeholder] || original[:placeholder]
+              end
+            end
+
+            def indifferent_equals(value)
+              value = convert_value(value)
+              ->(compared_value) { value == convert_value(compared_value) }
+            end
+
+            def convert_value(value)
+              value.is_a?(Symbol) ? value.to_s : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/utils/quantization/http.rb

@@ -0,0 +1,177 @@
+require 'uri'
+require 'set'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        module Quantization
+          # Quantization for HTTP resources
+          module HTTP
+            PLACEHOLDER = '?'.freeze
+
+            # taken from Ruby https://github.com/ruby/uri/blob/eaf89cc31619d49e67c64d0b58ea9dc38892d175/lib/uri/rfc3986_parser.rb
+            # but adjusted to parse only <scheme>://<host>:<port>/ components
+            # and stop there, since we don't care about the path, query string,
+            # and fragment components
+            RFC3986_URL_BASE = /\A(?<URI>(?<scheme>[A-Za-z][+\-.0-9A-Za-z]*+):(?<hier-part>\/\/(?<authority>(?:(?<userinfo>(?:%\h\h|[!$&-.0-;=A-Z_a-z~])*+)@)?(?<host>(?<IP-literal>\[(?:(?<IPv6address>(?:\h{1,4}:){6}(?<ls32>\h{1,4}:\h{1,4}|(?<IPv4address>(?<dec-octet>[1-9]\d|1\d{2}|2[0-4]\d|25[0-5]|\d)\.\g<dec-octet>\.\g<dec-octet>\.\g<dec-octet>))|::(?:\h{1,4}:){5}\g<ls32>|\h{1,4}?::(?:\h{1,4}:){4}\g<ls32>|(?:(?:\h{1,4}:)?\h{1,4})?::(?:\h{1,4}:){3}\g<ls32>|(?:(?:\h{1,4}:){,2}\h{1,4})?::(?:\h{1,4}:){2}\g<ls32>|(?:(?:\h{1,4}:){,3}\h{1,4})?::\h{1,4}:\g<ls32>|(?:(?:\h{1,4}:){,4}\h{1,4})?::\g<ls32>|(?:(?:\h{1,4}:){,5}\h{1,4})?::\h{1,4}|(?:(?:\h{1,4}:){,6}\h{1,4})?::)|(?<IPvFuture>v\h++\.[!$&-.0-;=A-Z_a-z~]++))\])|\g<IPv4address>|(?<reg-name>(?:%\h\h|[!$&-.0-9;=A-Z_a-z~])*+))(?::(?<port>\d*+))?)))(?:\/|\z)/.freeze # rubocop:disable Style/RegexpLiteral, Layout/LineLength
+
+            module_function
+
+            def url(url, options = {})
+              url!(url, options)
+            rescue StandardError
+              placeholder = options[:placeholder] || PLACEHOLDER
+
+              options[:base] == :exclude ? placeholder : "#{base_url(url)}/#{placeholder}"
+            end
+
+            def base_url(url, options = {})
+              if (m = RFC3986_URL_BASE.match(url))
+                m[1]
+              else
+                ''
+              end
+            end
+
+            def url!(url, options = {})
+              options ||= {}
+
+              URI.parse(url).tap do |uri|
+                # Format the query string
+                if uri.query
+                  query = query(uri.query, options[:query])
+                  uri.query = (!query.nil? && query.empty? ? nil : query)
+                end
+
+                # Remove any URI fragments
+                uri.fragment = nil unless options[:fragment] == :show
+
+                if options[:base] == :exclude
+                  uri.host = nil
+                  uri.port = nil
+                  uri.scheme = nil
+                end
+              end.to_s
+            end
+
+            def query(query, options = {})
+              query!(query, options)
+            rescue StandardError
+              options[:placeholder] || PLACEHOLDER
+            end
+
+            def query!(query, options = {})
+              options ||= {}
+              options[:obfuscate] = {} if options[:obfuscate] == :internal
+              options[:show] = options[:show] || (options[:obfuscate] ? :all : [])
+              options[:exclude] = options[:exclude] || []
+
+              # Short circuit if query string is meant to exclude everything
+              # or if the query string is meant to include everything
+              return '' if options[:exclude] == :all
+
+              unless options[:show] == :all && !(options[:obfuscate] && options[:exclude])
+                query = collect_query(query, uniq: true) do |key, value|
+                  if options[:exclude].include?(key)
+                    [nil, nil]
+                  else
+                    value = options[:show] == :all || options[:show].include?(key) ? value : nil
+                    [key, value]
+                  end
+                end
+              end
+
+              options[:obfuscate] ? obfuscate_query(query, options[:obfuscate]) : query
+            end
+
+            # Iterate over each key value pair, yielding to the block given.
+            # Accepts :uniq option, which keeps uniq copies of keys without values.
+            # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
+            def collect_query(query, options = {})
+              return query unless block_given?
+
+              uniq = options[:uniq].nil? ? false : options[:uniq]
+              keys = Set.new
+
+              delims = query.scan(/(^|&|;)/).flatten
+              query.split(/[&;]/).collect.with_index do |pairs, i|
+                key, value = pairs.split('=', 2)
+                key, value = yield(key, value, delims[i])
+                if uniq && keys.include?(key)
+                  ''
+                elsif key && value
+                  "#{delims[i]}#{key}=#{value}"
+                elsif key
+                  "#{delims[i]}#{key}".tap { keys << key }
+                # rubocop:disable Lint/DuplicateBranch
+                else
+                  ''
+                end
+                # rubocop:enable Lint/DuplicateBranch
+              end.join.sub(/^[&;]/, '')
+            end
+
+            private_class_method :collect_query
+
+            # Scans over the query string and obfuscates sensitive data by
+            # replacing matches with an opaque value
+            def obfuscate_query(query, options = {})
+              options[:regex] = nil if options[:regex] == :internal
+              re = options[:regex] || OBFUSCATOR_REGEX
+              with = options[:with] || OBFUSCATOR_WITH
+
+              query.gsub(re, with)
+            end
+
+            private_class_method :obfuscate_query
+
+            OBFUSCATOR_WITH = '<redacted>'.freeze
+
+            # rubocop:disable Layout/LineLength
+            OBFUSCATOR_REGEX = %r{
+              (?: # JSON-ish leading quote
+                 (?:"|%22)?
+              )
+              (?: # common keys
+                 (?:old_?|new_?)?p(?:ass)?w(?:or)?d(?:1|2)? # pw, password variants
+                |pass(?:_?phrase)?  # pass, passphrase variants
+                |secret
+                |(?: # key, key_id variants
+                     api_?
+                    |private_?
+                    |public_?
+                    |access_?
+                    |secret_?
+                 )key(?:_?id)?
+                |token
+                |consumer_?(?:id|key|secret)
+                |sign(?:ed|ature)?
+                |auth(?:entication|orization)?
+              )
+              (?:
+                 # '=' query string separator, plus value til next '&' separator
+                 (?:\s|%20)*(?:=|%3D)[^&]+
+                 # JSON-ish '": "somevalue"', key being handled with case above, without the opening '"'
+                |(?:"|%22)                                     # closing '"' at end of key
+                 (?:\s|%20)*(?::|%3A)(?:\s|%20)*               # ':' key-value spearator, with surrounding spaces
+                 (?:"|%22)                                     # opening '"' at start of value
+                 (?:%2[^2]|%[^2]|[^"%])+                       # value
+                 (?:"|%22)                                     # closing '"' at end of value
+              )
+             |(?: # other common secret values
+                 bearer(?:\s|%20)+[a-z0-9._\-]+
+                |token(?::|%3A)[a-z0-9]{13}
+                |gh[opsu]_[0-9a-zA-Z]{36}
+                |ey[I-L](?:[\w=-]|%3D)+\.ey[I-L](?:[\w=-]|%3D)+(?:\.(?:[\w.+/=-]|%3D|%2F|%2B)+)?
+                |-{5}BEGIN(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY-{5}[^\-]+-{5}END(?:[a-z\s]|%20)+PRIVATE(?:\s|%20)KEY(?:-{5})?(?:\n|%0A)?
+                |(?:ssh-(?:rsa|dss)|ecdsa-[a-z0-9]+-[a-z0-9]+)(?:\s|%20)*(?:[a-z0-9/.+]|%2F|%5C|%2B){100,}(?:=|%3D)*(?:(?:\s+)[a-z0-9._-]+)?
+              )
+            }ix.freeze
+            # rubocop:enable Layout/LineLength
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../tracing'
+require_relative 'contrib/registry'
+require_relative 'contrib/extensions'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Registry is a global, declarative repository of all available integrations.
+      #
+      # Integrations should register themselves with the registry as early as
+      # possible as the initial tracer configuration can only activate integrations
+      # if they have already been registered.
+      #
+      # Despite that, integrations *can* be appended to the registry at any point
+      # of the program execution. Newly appended integrations can then be
+      # activated during tracer reconfiguration.
+      #
+      # The registry does not depend on runtime configuration and registered integrations
+      # must execute correctly after successive configuration changes.
+      # The registered integrations themselves can depend on the stateful configuration
+      # of the tracer.
+      #
+      # `Datadog.registry` is a helper accessor to this constant, but it's only available
+      # after the tracer has complete initialization. Use `Datadog::Tracing::Contrib::REGISTRY` instead
+      # of `Datadog.registry` when you code might be called during tracer initialization.
+      REGISTRY = Registry.new
+    end
+  end
+end
+
+require_relative 'contrib/action_cable/integration'
+require_relative 'contrib/action_mailer/integration'
+require_relative 'contrib/action_pack/integration'
+require_relative 'contrib/action_view/integration'
+require_relative 'contrib/active_model_serializers/integration'
+require_relative 'contrib/active_job/integration'
+require_relative 'contrib/active_record/integration'
+require_relative 'contrib/active_support/integration'
+require_relative 'contrib/aws/integration'
+require_relative 'contrib/concurrent_ruby/integration'
+require_relative 'contrib/dalli/integration'
+require_relative 'contrib/delayed_job/integration'
+require_relative 'contrib/elasticsearch/integration'
+require_relative 'contrib/ethon/integration'
+require_relative 'contrib/excon/integration'
+require_relative 'contrib/faraday/integration'
+require_relative 'contrib/grape/integration'
+require_relative 'contrib/graphql/integration'
+require_relative 'contrib/grpc/integration'
+require_relative 'contrib/hanami/integration'
+require_relative 'contrib/http/integration'
+require_relative 'contrib/httpclient/integration'
+require_relative 'contrib/httprb/integration'
+require_relative 'contrib/integration'
+require_relative 'contrib/kafka/integration'
+require_relative 'contrib/lograge/integration'
+require_relative 'contrib/mongodb/integration'
+require_relative 'contrib/mysql2/integration'
+require_relative 'contrib/pg/integration'
+require_relative 'contrib/presto/integration'
+require_relative 'contrib/qless/integration'
+require_relative 'contrib/que/integration'
+require_relative 'contrib/racecar/integration'
+require_relative 'contrib/rack/integration'
+require_relative 'contrib/rails/integration'
+require_relative 'contrib/rake/integration'
+require_relative 'contrib/redis/integration'
+require_relative 'contrib/resque/integration'
+require_relative 'contrib/rest_client/integration'
+require_relative 'contrib/roda/integration'
+require_relative 'contrib/semantic_logger/integration'
+require_relative 'contrib/sequel/integration'
+require_relative 'contrib/shoryuken/integration'
+require_relative 'contrib/sidekiq/integration'
+require_relative 'contrib/sinatra/integration'
+require_relative 'contrib/sneakers/integration'
+require_relative 'contrib/stripe/integration'
+require_relative 'contrib/sucker_punch/integration'

data/lib/datadog/tracing/correlation.rb

@@ -0,0 +1,111 @@
+require_relative 'utils'
+require_relative 'metadata/ext'
+
+module Datadog
+  module Tracing
+    # Contains behavior for managing correlations with tracing
+    # e.g. Retrieve a correlation to the current trace for logging, etc.
+    module Correlation
+      # Represents current trace state with key identifiers
+      # @public_api
+      class Identifier
+        LOG_ATTR_ENV = 'dd.env'.freeze
+        LOG_ATTR_SERVICE = 'dd.service'.freeze
+        LOG_ATTR_SPAN_ID = 'dd.span_id'.freeze
+        LOG_ATTR_TRACE_ID = 'dd.trace_id'.freeze
+        LOG_ATTR_VERSION = 'dd.version'.freeze
+
+        attr_reader \
+          :env,
+          :service,
+          :span_id,
+          :span_name,
+          :span_resource,
+          :span_service,
+          :span_type,
+          :trace_id,
+          :trace_name,
+          :trace_resource,
+          :trace_service,
+          :version
+
+        # @!visibility private
+        def initialize(
+          env: nil,
+          service: nil,
+          span_id: nil,
+          span_name: nil,
+          span_resource: nil,
+          span_service: nil,
+          span_type: nil,
+          trace_id: nil,
+          trace_name: nil,
+          trace_resource: nil,
+          trace_service: nil,
+          version: nil
+        )
+          # Dup and freeze strings so they aren't modified by reference.
+          @env = Core::Utils::SafeDup.frozen_dup(env || Datadog.configuration.env)
+          @service = Core::Utils::SafeDup.frozen_dup(service || Datadog.configuration.service)
+          @span_id = span_id || 0
+          @span_name = Core::Utils::SafeDup.frozen_dup(span_name)
+          @span_resource = Core::Utils::SafeDup.frozen_dup(span_resource)
+          @span_service = Core::Utils::SafeDup.frozen_dup(span_service)
+          @span_type = Core::Utils::SafeDup.frozen_dup(span_type)
+          @trace_id = trace_id || 0
+          @trace_name = Core::Utils::SafeDup.frozen_dup(trace_name)
+          @trace_resource = Core::Utils::SafeDup.frozen_dup(trace_resource)
+          @trace_service = Core::Utils::SafeDup.frozen_dup(trace_service)
+          @version = Core::Utils::SafeDup.frozen_dup(version || Datadog.configuration.version)
+        end
+
+        def to_log_format
+          @log_format ||= begin
+            attributes = []
+            attributes << "#{LOG_ATTR_ENV}=#{env}" unless env.nil?
+            attributes << "#{LOG_ATTR_SERVICE}=#{service}"
+            attributes << "#{LOG_ATTR_VERSION}=#{version}" unless version.nil?
+            attributes << "#{LOG_ATTR_TRACE_ID}=#{logging_trace_id}"
+            attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
+            attributes.join(' ')
+          end
+        end
+
+        private
+
+        def logging_trace_id
+          @logging_trace_id ||=
+            if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled &&
+                !Tracing::Utils::TraceId.to_high_order(@trace_id).zero?
+              Kernel.format('%032x', trace_id)
+            else
+              Tracing::Utils::TraceId.to_low_order(@trace_id)
+            end
+        end
+      end
+
+      module_function
+
+      # Produces a CorrelationIdentifier from the TraceDigest provided
+      #
+      # DEV: can we memoize this object, give it can be common to
+      # use a correlation multiple times, specially in the context of logging?
+      # @!visibility private
+      def identifier_from_digest(digest)
+        return Identifier.new unless digest
+
+        Identifier.new(
+          span_id: digest.span_id,
+          span_name: digest.span_name,
+          span_resource: digest.span_resource,
+          span_service: digest.span_service,
+          span_type: digest.span_type,
+          trace_id: digest.trace_id,
+          trace_name: digest.trace_name,
+          trace_resource: digest.trace_resource,
+          trace_service: digest.trace_service
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Datadog
+  module Tracing
+    module Diagnostics
+      # @public_api
+      module Ext
+        # Health
+        module Health
+          # Metrics
+          module Metrics
+            METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
+            METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
+            METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
+            METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'.freeze
+            METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'.freeze
+            METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'.freeze
+            METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'.freeze
+            METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'.freeze
+            METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
+            METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
+            METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
+            METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
+            METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
+            METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
+            METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
+            METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
+            METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
+            METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
+            METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/diagnostics/health.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Diagnostics
+      # Health-related diagnostics
+      module Health
+        # Health metrics for diagnostics
+        module Metrics
+          def self.extended(base)
+            base.class_eval do
+              count :api_errors, Ext::Health::Metrics::METRIC_API_ERRORS
+              count :api_requests, Ext::Health::Metrics::METRIC_API_REQUESTS
+              count :api_responses, Ext::Health::Metrics::METRIC_API_RESPONSES
+              count :error_context_overflow, Ext::Health::Metrics::METRIC_ERROR_CONTEXT_OVERFLOW
+              count :error_instrumentation_patch, Ext::Health::Metrics::METRIC_ERROR_INSTRUMENTATION_PATCH
+              count :error_span_finish, Ext::Health::Metrics::METRIC_ERROR_SPAN_FINISH
+              count :error_unfinished_spans, Ext::Health::Metrics::METRIC_ERROR_UNFINISHED_SPANS
+              count :instrumentation_patched, Ext::Health::Metrics::METRIC_INSTRUMENTATION_PATCHED
+              count :queue_accepted, Ext::Health::Metrics::METRIC_QUEUE_ACCEPTED
+              count :queue_accepted_lengths, Ext::Health::Metrics::METRIC_QUEUE_ACCEPTED_LENGTHS
+              count :queue_dropped, Ext::Health::Metrics::METRIC_QUEUE_DROPPED
+              count :traces_filtered, Ext::Health::Metrics::METRIC_TRACES_FILTERED
+              count :transport_trace_too_large, Ext::Health::Metrics::METRIC_TRANSPORT_TRACE_TOO_LARGE
+              count :transport_chunked, Ext::Health::Metrics::METRIC_TRANSPORT_CHUNKED
+              count :writer_cpu_time, Ext::Health::Metrics::METRIC_WRITER_CPU_TIME
+
+              gauge :queue_length, Ext::Health::Metrics::METRIC_QUEUE_LENGTH
+              gauge :queue_max_length, Ext::Health::Metrics::METRIC_QUEUE_MAX_LENGTH
+              gauge :queue_spans, Ext::Health::Metrics::METRIC_QUEUE_SPANS
+              gauge :sampling_service_cache_length, Ext::Health::Metrics::METRIC_SAMPLING_SERVICE_CACHE_LENGTH
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+require_relative '../trace_digest'
+require_relative '../utils'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # B3 multi header-style trace propagation.
+      # @see https://github.com/openzipkin/b3-propagation#multiple-headers
+      class B3Multi
+        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 = Helpers.parse_hex_id(fetcher[@trace_id_key])
+
+          # Return early if this propagation is not valid
+          return if trace_id.nil? || trace_id <= 0 || trace_id > Tracing::Utils::TraceId::MAX
+
+          span_id = Helpers.parse_hex_id(fetcher[@span_id_key])
+
+          # Return early if this propagation is not valid
+          return if span_id.nil? || span_id <= 0 || span_id >= Tracing::Utils::EXTERNAL_MAX_ID
+
+          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
+          sampling_priority = Helpers.parse_decimal_id(fetcher[@sampled_key])
+
+          TraceDigest.new(
+            trace_id: trace_id,
+            span_id: span_id,
+            trace_sampling_priority: sampling_priority
+          )
+        end
+      end
+    end
+  end
+end