datadog 2.8.0 → 2.39.0

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'uri'
-require 'set'
+require "uri"
+require "set"
 
 module Datadog
   module Tracing
@@ -10,29 +10,29 @@ module Datadog
         module Quantization
           # Quantization for HTTP resources
           module HTTP
-            PLACEHOLDER = '?'
+            PLACEHOLDER = "?"
 
             # 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
+            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 Layout/LineLength
 
             module_function
 
             def url(url, options = {})
               url!(url, options)
-            rescue StandardError
+            rescue
               placeholder = options[:placeholder] || PLACEHOLDER
 
-              options[:base] == :exclude ? placeholder : "#{base_url(url)}/#{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
 
@@ -43,7 +43,7 @@ module Datadog
                 # Format the query string
                 if uri.query
                   query = query(uri.query, options[:query])
-                  uri.query = (!query.nil? && query.empty? ? nil : query)
+                  uri.query = ((!query.nil? && query.empty?) ? nil : query)
                 end
 
                 # Remove any URI fragments
@@ -59,7 +59,7 @@ module Datadog
 
             def query(query, options = {})
               query!(query, options)
-            rescue StandardError
+            rescue
               options[:placeholder] || PLACEHOLDER
             end
 
@@ -71,14 +71,14 @@ module Datadog
 
               # 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
+              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
+                    value = (options[:show] == :all || options[:show].include?(key)) ? value : nil
                     [key, value]
                   end
                 end
@@ -98,20 +98,20 @@ module Datadog
 
               delims = query.scan(/(^|&|;)/).flatten
               query.split(/[&;]/).collect.with_index do |pairs, i|
-                key, value = pairs.split('=', 2)
+                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.join.sub(/^[&;]/, "")
             end
 
             private_class_method :collect_query
@@ -128,7 +128,7 @@ module Datadog
 
             private_class_method :obfuscate_query
 
-            OBFUSCATOR_WITH = '<redacted>'
+            OBFUSCATOR_WITH = "<redacted>"
 
             # rubocop:disable Layout/LineLength
             OBFUSCATOR_REGEX = %r{

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../../configuration/settings"
+require_relative "../ext"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        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 do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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 WaterDrop
+        module Distributed
+          # Extracts and injects propagation through Kafka message headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize(
+              propagation_style_inject:,
+              propagation_style_extract:,
+              propagation_behavior_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_BAGGAGE =>
+                    Tracing::Distributed::Baggage.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_behavior_extract: propagation_behavior_extract,
+                propagation_extract_first: propagation_extract_first
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Ext
+          ENV_ENABLED = "DD_TRACE_WATERDROP_ENABLED"
+          ENV_DISTRIBUTED_TRACING = "DD_TRACE_WATERDROP_DISTRIBUTED_TRACING"
+
+          SPAN_PRODUCER = "karafka.produce"
+
+          TAG_PRODUCER = "kafka.producer"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+require_relative "configuration/settings"
+require_relative "patcher"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Description of WaterDrop integration
+        class Integration
+          include Contrib::Integration
+
+          # WaterDrop added class-level instrumentation in version 2.8.8.rc1
+          MINIMUM_VERSION = Gem::Version.new("2.8.8.rc1")
+
+          register_as :waterdrop, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs["waterdrop"]&.version
+          end
+
+          def self.loaded?
+            !defined?(::WaterDrop).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/waterdrop/middleware.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "ext"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Middleware to propagate tracing context in messages produced by WaterDrop
+        module Middleware
+          class << self
+            def call(message)
+              trace_op = Datadog::Tracing.active_trace
+
+              if trace_op && Datadog::Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: configuration,
+                trace: trace_op
+              )
+                WaterDrop.inject(trace_op.to_digest, message[:headers] ||= {})
+              end
+
+              if Datadog::DataStreams.enabled?
+                Datadog::DataStreams.set_produce_checkpoint(
+                  type: "kafka",
+                  destination: message[:topic],
+                  auto_instrumentation: true
+                ) do |key, value|
+                  message[:headers] ||= {}
+                  message[:headers][key] = value
+                end
+              end
+
+              message
+            end
+
+            private
+
+            def configuration
+              Datadog.configuration.tracing[:waterdrop]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../patcher"
+require_relative "ext"
+require_relative "distributed/propagation"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Patcher enables patching of 'waterdrop' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative "producer"
+            require_relative "middleware"
+
+            ::WaterDrop::Producer.prepend(Producer)
+            ::WaterDrop.instrumentation.subscribe("producer.configured") do |event|
+              producer = event[:producer]
+              add_middleware(producer)
+
+              if Datadog.configuration.data_streams.enabled
+                producer.monitor.subscribe("message.acknowledged") do |ack_event|
+                  if Datadog::DataStreams.enabled?
+                    payload = ack_event.payload
+                    Datadog::DataStreams.track_kafka_produce(payload[:topic], payload[:partition], payload[:offset])
+                  end
+                end
+              end
+            end
+          end
+
+          def add_middleware(producer)
+            included_middlewares = producer.middleware.instance_variable_get(:@steps)
+            producer.middleware.append(Middleware) unless included_middlewares.include?(Middleware)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop/producer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "ext"
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Producer integration for WaterDrop
+        module Producer
+          %i[
+            produce_many_sync
+            produce_many_async
+            produce_sync
+            produce_async
+          ].each do |method|
+            define_method(method) do |messages|
+              Datadog::Tracing.trace(Ext::SPAN_PRODUCER, resource: "waterdrop.#{__method__}") do
+                extract_span_tags(messages)
+                super(messages)
+              end
+            end
+          end
+
+          private
+
+          def extract_span_tags(messages)
+            messages = [messages] if messages.is_a?(Hash)
+            span = Datadog::Tracing.active_span
+            return unless span
+
+            topics = []
+            partitions = []
+            messages.each do |message|
+              topics << message[:topic]
+              partitions << message[:partition] if message.key?(:partition)
+            end
+
+            span.set_tag(Ext::TAG_PRODUCER, id)
+            span.set_tag(Contrib::Karafka::Ext::TAG_MESSAGE_COUNT, messages.size)
+            span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Contrib::Karafka::Ext::TAG_SYSTEM)
+
+            span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, topics.uniq.sort.join(","))
+            span.set_tag(Contrib::Karafka::Ext::TAG_PARTITION, partitions.uniq.sort.join(",")) if partitions.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "component"
+require_relative "waterdrop/integration"
+require_relative "waterdrop/distributed/propagation"
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `WaterDrop` integration public API
+      module WaterDrop
+        def self.inject(digest, data)
+          raise "Please invoke Datadog.configure at least once before calling this method" unless @propagation
+
+          # Steep: https://github.com/soutaro/steep/issues/477
+          # @type ivar @propagation: WaterDrop::Distributed::Propagation
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise "Please invoke Datadog.configure at least once before calling this method" unless @propagation
+
+          # Steep: https://github.com/soutaro/steep/issues/477
+          # @type ivar @propagation: WaterDrop::Distributed::Propagation
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register("waterdrop") do |config|
+          tracing = config.tracing
+          tracing.propagation_style
+
+          @propagation = WaterDrop::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_behavior_extract: tracing.propagation_behavior_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../tracing'
-require_relative 'contrib/registry'
-require_relative 'contrib/extensions'
+require_relative "../tracing"
+require_relative "contrib/registry"
+require_relative "contrib/extensions"
 
 module Datadog
   module Tracing
@@ -30,52 +30,62 @@ module Datadog
   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'
-require_relative 'contrib/hanami/integration'
-require_relative 'contrib/http'
-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/opensearch/integration'
-require_relative 'contrib/pg/integration'
-require_relative 'contrib/presto/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'
-require_relative 'contrib/sinatra/integration'
-require_relative 'contrib/sneakers/integration'
-require_relative 'contrib/stripe/integration'
-require_relative 'contrib/sucker_punch/integration'
-require_relative 'contrib/trilogy/integration'
+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"
+require_relative "contrib/hanami/integration"
+require_relative "contrib/http"
+require_relative "contrib/httpclient/integration"
+require_relative "contrib/httprb/integration"
+require_relative "contrib/integration"
+require_relative "contrib/kafka/integration"
+require_relative "contrib/waterdrop"
+require_relative "contrib/karafka"
+require_relative "contrib/lograge/integration"
+require_relative "contrib/mongodb/integration"
+require_relative "contrib/mysql2/integration"
+require_relative "contrib/opensearch/integration"
+require_relative "contrib/pg/integration"
+require_relative "contrib/presto/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"
+require_relative "contrib/sinatra/integration"
+require_relative "contrib/sneakers/integration"
+require_relative "contrib/stripe/integration"
+require_relative "contrib/sucker_punch/integration"
+require_relative "contrib/trilogy/integration"
+
+# This list is used to determine if an integration is a built-in integration,
+# and prevent sending telemetry for custom integrations.
+# To do this, we get the list of registered integrations at this point and freeze it.
+# Later, when custom integrations are registered, they will not be included in this list.
+# .uniq to handle aliases, as we can register the same integration multiple times with different names.
+Datadog::Tracing::Contrib::BUILT_IN_INTEGRATIONS =
+  Datadog::Tracing::Contrib::REGISTRY.map { |entry| entry.klass }.uniq.freeze

data/lib/datadog/tracing/correlation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'utils'
-require_relative '../core/logging/ext'
+require_relative "utils"
+require_relative "../core/logging/ext"
 
 module Datadog
   module Tracing
@@ -13,12 +13,12 @@ module Datadog
       # Represents current trace state with key identifiers
       # @public_api
       class Identifier
-        LOG_ATTR_ENV = 'dd.env'
-        LOG_ATTR_SERVICE = 'dd.service'
-        LOG_ATTR_SPAN_ID = 'dd.span_id'
-        LOG_ATTR_TRACE_ID = 'dd.trace_id'
-        LOG_ATTR_VERSION = 'dd.version'
-        LOG_ATTR_SOURCE = 'ddsource'
+        LOG_ATTR_ENV = "dd.env"
+        LOG_ATTR_SERVICE = "dd.service"
+        LOG_ATTR_SPAN_ID = "dd.span_id"
+        LOG_ATTR_TRACE_ID = "dd.trace_id"
+        LOG_ATTR_VERSION = "dd.version"
+        LOG_ATTR_SOURCE = "ddsource"
 
         attr_reader \
           :env,
@@ -68,7 +68,7 @@ module Datadog
             attributes << "#{LOG_ATTR_TRACE_ID}=#{trace_id}"
             attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
             attributes << "#{LOG_ATTR_SOURCE}=#{Core::Logging::Ext::DD_SOURCE}"
-            attributes.join(' ')
+            attributes.join(" ")
           end
         end
 
@@ -94,9 +94,16 @@ module Datadog
       end
 
       def format_trace_id(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)
+        if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled
+          format_trace_id_128(trace_id)
+        else
+          Tracing::Utils::TraceId.to_low_order(trace_id).to_s
+        end
+      end
+
+      def format_trace_id_128(trace_id)
+        if !Tracing::Utils::TraceId.to_high_order(trace_id).zero?
+          Kernel.format("%032x", trace_id)
         else
           Tracing::Utils::TraceId.to_low_order(trace_id).to_s
         end