ddtrace 1.9.0 → 1.10.1

data/lib/datadog/profiling/scheduler.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../core/utils/time'
 
 require_relative '../core/worker'

data/lib/datadog/profiling/stack_recorder.rb

@@ -1,12 +1,10 @@
-# typed: false
-
 module Datadog
   module Profiling
     # Stores stack samples in a native libdatadog data structure and expose Ruby-level serialization APIs
     # Note that `record_sample` is only accessible from native code.
     # Methods prefixed with _native_ are implemented in `stack_recorder.c`
     class StackRecorder
-      def initialize
+      def initialize(cpu_time_enabled:, alloc_samples_enabled:)
         # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
         # It prevents multiple Ruby threads calling serialize at the same time -- something like
         # `10.times { Thread.new { stack_recorder.serialize } }`.
@@ -14,6 +12,8 @@ module Datadog
         # C-level mutexes (that there is a single serializer thread), we add it here as an extra safeguard against it
         # accidentally happening.
         @no_concurrent_synchronize_mutex = Mutex.new
+
+        self.class._native_initialize(self, cpu_time_enabled, alloc_samples_enabled)
       end
 
       def serialize
@@ -66,11 +66,6 @@ module Datadog
         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

data/lib/datadog/profiling/tag_builder.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../core/utils'
 
 module Datadog

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Profiling
     module Tasks

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Profiling
     module Tasks

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../../core/utils/only_once'
 require_relative '../ext/forking'
 

data/lib/datadog/profiling/trace_identifiers/ddtrace.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: true
-
 require_relative '../../tracing'
 require_relative '../../tracing/metadata/ext'
 

data/lib/datadog/profiling/trace_identifiers/helper.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: true
-
 require_relative 'ddtrace'
 
 module Datadog

data/lib/datadog/profiling.rb

@@ -1,11 +1,9 @@
-# typed: true
-
 require_relative 'core'
 require_relative 'core/environment/variable_helpers'
 require_relative 'core/utils/only_once'
 
 module Datadog
-  # Contains profiler for generating stack profiles, etc.
+  # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
   module Profiling
     GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
     private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
@@ -41,6 +39,39 @@ module Datadog
       !!profiler
     end
 
+    # Returns an ever-increasing counter of the number of allocations observed by the profiler in this thread.
+    #
+    # Note 1: This counter may not start from zero on new threads. It should only be used to measure how many
+    # allocations have happened between two calls to this API:
+    # ```
+    # allocations_before = Datadog::Profiling.allocation_count
+    # do_some_work()
+    # allocations_after = Datadog::Profiling.allocation_count
+    # puts "Allocations during do_some_work: #{allocations_after - allocations_before}"
+    # ```
+    # (This is similar to some OS-based time representations.)
+    #
+    # Note 2: All fibers in the same thread will share the same counter values.
+    #
+    # Only available when the profiler is running, the new CPU Profiling 2.0 profiler is in use, and allocation-related
+    # features are not disabled via configuration.
+    # For instructions on enabling CPU Profiling 2.0 see the ddtrace release notes.
+    #
+    # @return [Integer] number of allocations observed in the current thread.
+    # @return [nil] when not available.
+    # @public_api
+    def self.allocation_count
+      # This no-op implementation is used when profiling failed to load.
+      # It gets replaced inside #replace_noop_allocation_count.
+      nil
+    end
+
+    private_class_method def self.replace_noop_allocation_count
+      def self.allocation_count # rubocop:disable Lint/DuplicateMethods, Lint/NestedMethodDefinition (On purpose!)
+        Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+      end
+    end
+
     private_class_method def self.native_library_compilation_skipped?
       skipped_reason = try_reading_skipped_reason_file
 
@@ -65,7 +96,7 @@ module Datadog
       # NOTE: On environments where protobuf is already loaded, we skip the check. This allows us to support environments
       # where no Gem.loaded_version is NOT available but customers are able to load protobuf; see for instance
       # https://github.com/teamcapybara/capybara/commit/caf3bcd7664f4f2691d0ca9ef3be9a2a954fecfb
-      if !defined?(::Google::Protobuf) && Gem.loaded_specs['google-protobuf'].nil?
+      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].nil?
         "Missing google-protobuf dependency; please add `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
       end
     end
@@ -74,12 +105,16 @@ module Datadog
       # See above for why we skip the check when protobuf is already loaded; note that when protobuf was already loaded
       # we skip the version check to avoid the call to Gem.loaded_specs. Unfortunately, protobuf does not seem to
       # expose the gem version constant elsewhere, so in that setup we are not able to check the version.
-      if !defined?(::Google::Protobuf) && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
+      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
         'Your google-protobuf is too old; ensure that you have google-protobuf >= 3.0 by ' \
         "adding `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
       end
     end
 
+    private_class_method def self.protobuf_already_loaded?
+      defined?(::Google::Protobuf) && !defined?(::Protobuf)
+    end
+
     private_class_method def self.protobuf_failed_to_load?
       unless protobuf_loaded_successfully?
         'There was an error loading the google-protobuf library; see previous warning message for details'
@@ -105,7 +140,7 @@ module Datadog
         # NOTE: We use Kernel#warn here because this code gets run BEFORE Datadog.logger is actually set up.
         # In the future it'd be nice to shuffle the logger startup to happen first to avoid this special case.
         Kernel.warn(
-          '[DDTRACE] Error while loading google-protobuf gem. ' \
+          '[ddtrace] Error while loading google-protobuf gem. ' \
           "Cause: '#{e.class.name} #{e.message}' Location: '#{Array(e.backtrace).first}'. " \
           'This can happen when google-protobuf is missing its native components. ' \
           'To fix this, try removing and reinstalling the gem, forcing it to recompile the components: ' \
@@ -147,12 +182,12 @@ module Datadog
 
       require_relative 'profiling/ext/forking'
       require_relative 'profiling/collectors/code_provenance'
-      require_relative 'profiling/collectors/cpu_and_wall_time'
       require_relative 'profiling/collectors/cpu_and_wall_time_worker'
       require_relative 'profiling/collectors/dynamic_sampling_rate'
       require_relative 'profiling/collectors/idle_sampling_helper'
       require_relative 'profiling/collectors/old_stack'
       require_relative 'profiling/collectors/stack'
+      require_relative 'profiling/collectors/thread_context'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/old_recorder'
       require_relative 'profiling/exporter'
@@ -165,6 +200,8 @@ module Datadog
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'
 
+      replace_noop_allocation_count
+
       true
     end
 

data/lib/datadog/tracing/analytics.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative 'metadata/ext'
 
 module Datadog

data/lib/datadog/tracing/buffer.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../core'
 require_relative '../core/environment/ext'
 require_relative '../core/buffer/thread_safe'
@@ -10,8 +8,6 @@ module Datadog
   module Tracing
     # Health metrics for trace buffers.
     module MeasuredBuffer
-      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
       def initialize(*_)
         super
 

data/lib/datadog/tracing/client_ip.rb

@@ -1,164 +1,61 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative '../core/configuration'
+require_relative '../core/utils/network'
 require_relative 'metadata/ext'
 require_relative 'span'
 
-require 'ipaddr'
-
 module Datadog
   module Tracing
     # Common functions for supporting the `http.client_ip` span attribute.
     module ClientIp
-      DEFAULT_IP_HEADERS_NAMES = %w[
-        x-forwarded-for
-        x-real-ip
-        x-client-ip
-        x-forwarded
-        x-cluster-client-ip
-        forwarded-for
-        forwarded
-        via
-        true-client-ip
-      ].freeze
-
-      TAG_MULTIPLE_IP_HEADERS = '_dd.multiple-ip-headers'.freeze
-
-      # Sets the `http.client_ip` tag on the given span.
-      #
-      # This function respects the user's settings: if they disable the client IP tagging,
-      #   or provide a different IP header name.
-      #
-      # If multiple IP headers are present in the request, this function will instead set
-      #   the `_dd.multiple-ip-headers` tag with the names of the present headers,
-      #   and **NOT** set the `http.client_ip` tag.
-      #
-      # @param [Span] span The span that's associated with the request.
-      # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
-      # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
-      def self.set_client_ip_tag(span, headers: nil, remote_ip: nil)
-        return unless configuration.enabled
-
-        set_client_ip_tag!(span, headers: headers, remote_ip: remote_ip)
-      end
-
-      # Forcefully sets the `http.client_ip` tag on the given span.
-      #
-      # This function ignores the user's `enabled` setting.
-      #
-      # @param [Span] span The span that's associated with the request.
-      # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
-      # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
-      def self.set_client_ip_tag!(span, headers: nil, remote_ip: nil)
-        result = raw_ip_from_request(headers, remote_ip)
-
-        if result.raw_ip
-          ip = strip_decorations(result.raw_ip)
-          return unless valid_ip?(ip)
-
-          span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP, ip)
-        elsif result.multiple_ip_headers
-          span.set_tag(TAG_MULTIPLE_IP_HEADERS, result.multiple_ip_headers.keys.join(','))
+      class << self
+        # Sets the `http.client_ip` tag on the given span.
+        #
+        # This function respects the user's settings: if they disable the client IP tagging,
+        #   or provide a different IP header name.
+        #
+        # @param [Span] span The span that's associated with the request.
+        # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
+        # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
+        def set_client_ip_tag(span, headers: nil, remote_ip: nil)
+          return unless configuration.enabled
+
+          set_client_ip_tag!(span, headers: headers, remote_ip: remote_ip)
         end
-      end
-
-      IpExtractionResult = Struct.new(:raw_ip, :multiple_ip_headers)
-
-      # Returns a result struct that holds the raw client IP associated with the request if it was
-      #   retrieved successfully.
-      #
-      # The client IP is looked up by the following logic:
-      # * If the user has configured a header name, return that header's value.
-      # * If exactly one of the known IP headers is present, return that header's value.
-      # * If none of the known IP headers are present, return the remote IP from the request.
-      #
-      # If more than one of the known IP headers is present, the result will have a `multiple_ip_headers`
-      #   field with the name of the present IP headers.
-      #
-      # @param [Datadog::Core::HeaderCollection, #get, nil] headers The request headers
-      # @param [String] remote_ip The remote IP of the request.
-      # @return [IpExtractionResult] A struct that holds the unprocessed IP value,
-      #   or `nil` if it wasn't found. Additionally, the `multiple_ip_headers` fields will hold the
-      #   name of known IP headers present in the request if more than one of these were found.
-      def self.raw_ip_from_request(headers, remote_ip)
-        return IpExtractionResult.new(headers && headers.get(configuration.header_name), nil) if configuration.header_name
-
-        headers_present = ip_headers(headers)
-
-        case headers_present.size
-        when 0
-          IpExtractionResult.new(remote_ip, nil)
-        when 1
-          IpExtractionResult.new(headers_present.values.first, nil)
-        else
-          IpExtractionResult.new(nil, headers_present)
-        end
-      end
 
-      # Removes any port notations or zone specifiers from the IP address without
-      #   verifying its validity.
-      def self.strip_decorations(address)
-        return strip_ipv4_port(address) if likely_ipv4?(address)
-
-        address = strip_ipv6_port(address)
-
-        strip_zone_specifier(address)
-      end
-
-      def self.strip_zone_specifier(ipv6)
-        ipv6.gsub(/%.*/, '')
-      end
-
-      def self.strip_ipv4_port(ip)
-        ip.gsub(/:\d+\z/, '')
-      end
-
-      def self.strip_ipv6_port(ip)
-        if /\[(.*)\](?::\d+)?/ =~ ip
-          Regexp.last_match(1)
-        else
-          ip
+        # Forcefully sets the `http.client_ip` tag on the given span.
+        #
+        # This function ignores the user's `enabled` setting.
+        #
+        # @param [Span] span The span that's associated with the request.
+        # @param [HeaderCollection, #get, nil] headers A collection with the request headers.
+        # @param [String, nil] remote_ip The remote IP the request associated with the span is sent to.
+        def set_client_ip_tag!(span, headers: nil, remote_ip: nil)
+          ip = extract_client_ip(headers, remote_ip)
+
+          span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_CLIENT_IP, ip) if ip
         end
-      end
-
-      # Returns whether the given value is more likely to be an IPv4 than an IPv6 address.
-      #
-      # This is done by checking if a dot (`'.'`) character appears before a colon (`':'`) in the value.
-      # The rationale is that in valid IPv6 addresses, colons will always preced dots,
-      #   and in valid IPv4 addresses dots will always preced colons.
-      def self.likely_ipv4?(value)
-        dot_index = value.index('.') || value.size
-        colon_index = value.index(':') || value.size
-
-        dot_index < colon_index
-      end
 
-      # Determines whether the given string is a valid IPv4 or IPv6 address.
-      def self.valid_ip?(ip)
-        # Client IPs should not have subnet masks even though IPAddr can parse them.
-        return false if ip.include?('/')
+        def extract_client_ip(headers, remote_ip)
+          if headers && configuration.header_name
+            return Datadog::Core::Utils::Network.stripped_ip_from_request_headers(
+              headers,
+              ip_headers_to_check: Array(configuration.header_name)
+            )
+          end
 
-        begin
-          IPAddr.new(ip)
+          ip_from_headers = Datadog::Core::Utils::Network.stripped_ip_from_request_headers(headers) if headers
 
-          true
-        rescue IPAddr::Error
-          false
+          ip_from_headers || Datadog::Core::Utils::Network.stripped_ip(remote_ip)
         end
-      end
 
-      def self.ip_headers(headers)
-        return {} unless headers
+        private
 
-        DEFAULT_IP_HEADERS_NAMES.each_with_object({}) do |name, result|
-          value = headers.get(name)
-          result[name] = value unless value.nil?
+        def configuration
+          Datadog.configuration.tracing.client_ip
         end
       end
-
-      def self.configuration
-        Datadog.configuration.tracing.client_ip
-      end
     end
   end
 end

data/lib/datadog/tracing/component.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative 'tracer'
+require_relative 'flush'
+require_relative 'sync_writer'
+require_relative 'sampling/span/rule_parser'
+require_relative 'sampling/span/sampler'
+
+module Datadog
+  module Tracing
+    # Tracing component
+    module Component
+      def build_tracer(settings, agent_settings)
+        # If a custom tracer has been provided, use it instead.
+        # Ignore all other options (they should already be configured.)
+        tracer = settings.tracing.instance
+        return tracer unless tracer.nil?
+
+        # Apply test mode settings if test mode is activated
+        if settings.tracing.test_mode.enabled
+          trace_flush = build_test_mode_trace_flush(settings)
+          sampler = build_test_mode_sampler
+          writer = build_test_mode_writer(settings, agent_settings)
+        else
+          trace_flush = build_trace_flush(settings)
+          sampler = build_sampler(settings)
+          writer = build_writer(settings, agent_settings)
+        end
+
+        subscribe_to_writer_events!(writer, sampler, settings.tracing.test_mode.enabled)
+
+        Tracing::Tracer.new(
+          default_service: settings.service,
+          enabled: settings.tracing.enabled,
+          trace_flush: trace_flush,
+          sampler: sampler,
+          span_sampler: build_span_sampler(settings),
+          writer: writer,
+          tags: build_tracer_tags(settings),
+        )
+      end
+
+      def build_trace_flush(settings)
+        if settings.tracing.partial_flush.enabled
+          Tracing::Flush::Partial.new(
+            min_spans_before_partial_flush: settings.tracing.partial_flush.min_spans_threshold
+          )
+        else
+          Tracing::Flush::Finished.new
+        end
+      end
+
+      # TODO: Sampler should be a top-level component.
+      # It is currently part of the Tracer initialization
+      # process, but can take a variety of options (including
+      # a fully custom instance) that makes the Tracer
+      # initialization process complex.
+      def build_sampler(settings)
+        if (sampler = settings.tracing.sampler)
+          if settings.tracing.priority_sampling == false
+            sampler
+          else
+            ensure_priority_sampling(sampler, settings)
+          end
+        elsif settings.tracing.priority_sampling == false
+          Tracing::Sampling::RuleSampler.new(
+            rate_limit: settings.tracing.sampling.rate_limit,
+            default_sample_rate: settings.tracing.sampling.default_rate
+          )
+        else
+          Tracing::Sampling::PrioritySampler.new(
+            base_sampler: Tracing::Sampling::AllSampler.new,
+            post_sampler: Tracing::Sampling::RuleSampler.new(
+              rate_limit: settings.tracing.sampling.rate_limit,
+              default_sample_rate: settings.tracing.sampling.default_rate
+            )
+          )
+        end
+      end
+
+      def ensure_priority_sampling(sampler, settings)
+        if sampler.is_a?(Tracing::Sampling::PrioritySampler)
+          sampler
+        else
+          Tracing::Sampling::PrioritySampler.new(
+            base_sampler: sampler,
+            post_sampler: Tracing::Sampling::RuleSampler.new(
+              rate_limit: settings.tracing.sampling.rate_limit,
+              default_sample_rate: settings.tracing.sampling.default_rate
+            )
+          )
+        end
+      end
+
+      # TODO: Writer should be a top-level component.
+      # It is currently part of the Tracer initialization
+      # process, but can take a variety of options (including
+      # a fully custom instance) that makes the Tracer
+      # initialization process complex.
+      def build_writer(settings, agent_settings)
+        if (writer = settings.tracing.writer)
+          return writer
+        end
+
+        Tracing::Writer.new(agent_settings: agent_settings, **settings.tracing.writer_options)
+      end
+
+      def subscribe_to_writer_events!(writer, sampler, test_mode)
+        return unless writer.respond_to?(:events) # Check if it's a custom, external writer
+
+        writer.events.after_send.subscribe(&WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK)
+
+        return unless sampler.is_a?(Tracing::Sampling::PrioritySampler)
+
+        # DEV: We need to ignore priority sampling updates coming from the agent in test mode
+        # because test mode wants to *unconditionally* sample all traces.
+        #
+        # This can cause trace metrics to be overestimated, but that's a trade-off we take
+        # here to achieve 100% sampling rate.
+        return if test_mode
+
+        writer.events.after_send.subscribe(&writer_update_priority_sampler_rates_callback(sampler))
+      end
+
+      WRITER_RECORD_ENVIRONMENT_INFORMATION_CALLBACK = lambda do |_, responses|
+        Core::Diagnostics::EnvironmentLogger.log!(responses)
+      end
+
+      # Create new lambda for writer callback,
+      # capture the current sampler in the callback closure.
+      def writer_update_priority_sampler_rates_callback(sampler)
+        lambda do |_, responses|
+          response = responses.last
+
+          next unless response && !response.internal_error? && response.service_rates
+
+          sampler.update(response.service_rates, decision: Tracing::Sampling::Ext::Decision::AGENT_RATE)
+        end
+      end
+
+      def build_span_sampler(settings)
+        rules = Tracing::Sampling::Span::RuleParser.parse_json(settings.tracing.sampling.span_rules)
+        Tracing::Sampling::Span::Sampler.new(rules || [])
+      end
+
+      private
+
+      def build_tracer_tags(settings)
+        settings.tags.dup.tap do |tags|
+          tags[Core::Environment::Ext::TAG_ENV] = settings.env unless settings.env.nil?
+          tags[Core::Environment::Ext::TAG_VERSION] = settings.version unless settings.version.nil?
+        end
+      end
+
+      def build_test_mode_trace_flush(settings)
+        # If context flush behavior is provided, use it instead.
+        settings.tracing.test_mode.trace_flush || build_trace_flush(settings)
+      end
+
+      def build_test_mode_sampler
+        # Do not sample any spans for tests; all must be preserved.
+        # Set priority sampler to ensure the agent doesn't drop any traces.
+        Tracing::Sampling::PrioritySampler.new(
+          base_sampler: Tracing::Sampling::AllSampler.new,
+          post_sampler: Tracing::Sampling::AllSampler.new
+        )
+      end
+
+      def build_test_mode_writer(settings, agent_settings)
+        # Flush traces synchronously, to guarantee they are written.
+        writer_options = settings.tracing.test_mode.writer_options || {}
+        Tracing::SyncWriter.new(agent_settings: agent_settings, **writer_options)
+      end
+    end
+  end
+end

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

@@ -1,5 +1,3 @@
-# typed: true
-
 module Datadog
   module Tracing
     module Configuration
@@ -7,6 +5,7 @@ module Datadog
       # e.g. Env vars, default values, enums, etc...
       module Ext
         ENV_ENABLED = 'DD_TRACE_ENABLED'.freeze
+        ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'.freeze
 
         # @public_api
         module Analytics
@@ -16,6 +15,7 @@ module Datadog
         # @public_api
         module Correlation
           ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'.freeze
+          ENV_TRACE_ID_128_BIT_LOGGING_ENABLED = 'DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED'.freeze
         end
 
         # @public_api

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../../tracing/configuration/ext'
 
 module Datadog
@@ -175,6 +173,26 @@ module Datadog
                 o.lazy
               end
 
+              # Enable 128 bit trace id generation.
+              #
+              # @default `DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED` environment variable, otherwise `false`
+              # @return [Boolean]
+              option :trace_id_128_bit_generation_enabled do |o|
+                o.default { env_to_bool(Tracing::Configuration::Ext::ENV_TRACE_ID_128_BIT_GENERATION_ENABLED, false) }
+                o.lazy
+              end
+
+              # Enable 128 bit trace id injected for logging.
+              #
+              # @default `DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED` environment variable, otherwise `false`
+              # @return [Boolean]
+              #
+              # It is not supported by our backend yet. Do not enable it.
+              option :trace_id_128_bit_logging_enabled do |o|
+                o.default { env_to_bool(Tracing::Configuration::Ext::Correlation::ENV_TRACE_ID_128_BIT_LOGGING_ENABLED, false) }
+                o.lazy
+              end
+
               # A custom tracer instance.
               #
               # It must respect the contract of {Datadog::Tracing::Tracer}.

data/lib/datadog/tracing/context.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../core/utils/forking'
 
 module Datadog

data/lib/datadog/tracing/context_provider.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require_relative '../core/utils/sequence'
 require_relative 'context'
 

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../../configuration/settings'
 require_relative '../ext'