ddtrace 0.52.0 → 1.8.0

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

@@ -0,0 +1,104 @@
+# typed: false
+
+require 'sucker_punch'
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Defines instrumentation patches for the `sucker_punch` gem
+        module Instrumentation
+          module_function
+
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/AbcSize
+          def patch!
+            # rubocop:disable Metrics/BlockLength
+            ::SuckerPunch::Job::ClassMethods.class_eval do
+              alias_method :__run_perform_without_datadog, :__run_perform
+              def __run_perform(*args)
+                Datadog::Tracing.send(:tracer).provider.context = Datadog::Tracing::Context.new
+
+                __with_instrumentation(Ext::SPAN_PERFORM) do |span|
+                  span.resource = "PROCESS #{self}"
+
+                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PERFORM)
+
+                  # Set analytics sample rate
+                  if Datadog::Tracing::Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                    Datadog::Tracing::Contrib::Analytics.set_sample_rate(
+                      span,
+                      datadog_configuration[:analytics_sample_rate]
+                    )
+                  end
+
+                  # Measure service stats
+                  Datadog::Tracing::Contrib::Analytics.set_measured(span)
+
+                  __run_perform_without_datadog(*args)
+                end
+              rescue => e
+                ::SuckerPunch.__exception_handler.call(e, self, args)
+              end
+              ruby2_keywords :__run_perform if respond_to?(:ruby2_keywords, true)
+
+              alias_method :__perform_async, :perform_async
+              def perform_async(*args)
+                __with_instrumentation(Ext::SPAN_PERFORM_ASYNC) do |span|
+                  span.resource = "ENQUEUE #{self}"
+
+                  span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PERFORM_ASYNC)
+
+                  # Measure service stats
+                  Datadog::Tracing::Contrib::Analytics.set_measured(span)
+
+                  __perform_async(*args)
+                end
+              end
+              ruby2_keywords :perform_async if respond_to?(:ruby2_keywords, true)
+
+              alias_method :__perform_in, :perform_in
+              def perform_in(interval, *args)
+                __with_instrumentation(Ext::SPAN_PERFORM_IN) do |span|
+                  span.resource = "ENQUEUE #{self}"
+
+                  span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PERFORM_IN)
+
+                  span.set_tag(Ext::TAG_PERFORM_IN, interval)
+
+                  # Measure service stats
+                  Datadog::Tracing::Contrib::Analytics.set_measured(span)
+
+                  __perform_in(interval, *args)
+                end
+              end
+              ruby2_keywords :perform_in if respond_to?(:ruby2_keywords, true)
+
+              private
+
+              def datadog_configuration
+                Datadog.configuration.tracing[:sucker_punch]
+              end
+
+              def __with_instrumentation(name)
+                Datadog::Tracing.trace(name, service: datadog_configuration[:service_name]) do |span|
+                  span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                  span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                  span.set_tag(Ext::TAG_QUEUE, to_s)
+                  yield span
+                end
+              end
+            end
+            # rubocop:enable Metrics/BlockLength
+          end
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: false
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Description of SuckerPunch integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.0.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :sucker_punch, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['sucker_punch'] && Gem.loaded_specs['sucker_punch'].version
+          end
+
+          def self.loaded?
+            !defined?(::SuckerPunch).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: true
+
+require_relative '../patcher'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Patcher enables patching of 'sucker_punch' module.
+        module Patcher
+          include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'exception_handler'
+            require_relative 'instrumentation'
+
+            ExceptionHandler.patch!
+            Instrumentation.patch!
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:sucker_punch].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/utils/database.rb

@@ -0,0 +1,31 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        # Common database-related utility functions.
+        module Database
+          VENDOR_DEFAULT = 'defaultdb'.freeze
+          VENDOR_POSTGRES = 'postgres'.freeze
+          VENDOR_SQLITE = 'sqlite'.freeze
+
+          module_function
+
+          def normalize_vendor(vendor)
+            case vendor
+            when nil
+              VENDOR_DEFAULT
+            when 'postgresql'
+              VENDOR_POSTGRES
+            when 'sqlite3'
+              VENDOR_SQLITE
+            else
+              vendor
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# typed: true
+
+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,181 @@
+# typed: true
+
+require 'uri'
+require 'set'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        module Quantization
+          # Quantization for HTTP resources
+          module HTTP
+            include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+            PLACEHOLDER = '?'.freeze
+
+            # taken from Ruby https://github.com/ruby/uri/blob/ffbab83de6d8748c9454414e02db5317609166eb/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,78 @@
+# typed: 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/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/sucker_punch/integration'

data/lib/datadog/tracing/correlation.rb

@@ -0,0 +1,100 @@
+# typed: true
+
+require_relative '../core'
+
+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_or_dup(env || Datadog.configuration.env).freeze
+          @service = Core::Utils::SafeDup.frozen_or_dup(service || Datadog.configuration.service).freeze
+          @span_id = span_id || 0
+          @span_name = Core::Utils::SafeDup.frozen_or_dup(span_name).freeze
+          @span_resource = Core::Utils::SafeDup.frozen_or_dup(span_resource).freeze
+          @span_service = Core::Utils::SafeDup.frozen_or_dup(span_service).freeze
+          @span_type = Core::Utils::SafeDup.frozen_or_dup(span_type).freeze
+          @trace_id = trace_id || 0
+          @trace_name = Core::Utils::SafeDup.frozen_or_dup(trace_name).freeze
+          @trace_resource = Core::Utils::SafeDup.frozen_or_dup(trace_resource).freeze
+          @trace_service = Core::Utils::SafeDup.frozen_or_dup(trace_service).freeze
+          @version = Core::Utils::SafeDup.frozen_or_dup(version || Datadog.configuration.version).freeze
+        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}=#{trace_id}"
+            attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
+            attributes.join(' ')
+          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