ddtrace 1.7.0 → 1.8.0

data/ext/ddtrace_profiling_native_extension/stack_recorder.c

@@ -175,7 +175,7 @@ static VALUE _native_active_slot(DDTRACE_UNUSED VALUE _self, VALUE recorder_inst
 static VALUE _native_is_slot_one_mutex_locked(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE _native_is_slot_two_mutex_locked(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot);
-static ddog_Timespec time_now();
+static ddog_Timespec time_now(void);
 static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE recorder_instance);
 static void serializer_set_start_timestamp_for_next_profile(struct stack_recorder_state *state, ddog_Timespec timestamp);
 static VALUE _native_record_endpoint(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance, VALUE local_root_span_id, VALUE endpoint);
@@ -239,8 +239,7 @@ static void initialize_slot_concurrency_control(struct stack_recorder_state *sta
   state->slot_two_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
 
   // A newly-created StackRecorder starts with slot one being active for samples, so let's lock slot two
-  int error = pthread_mutex_lock(&state->slot_two_mutex);
-  if (error) rb_syserr_fail(error, "Unexpected failure during pthread_mutex_lock");
+  ENFORCE_SUCCESS_GVL(pthread_mutex_lock(&state->slot_two_mutex));
 
   state->active_slot = 1;
 }
@@ -361,7 +360,7 @@ static struct active_slot_pair sampler_lock_active_profile(struct stack_recorder
 
   for (int attempts = 0; attempts < 2; attempts++) {
     error = pthread_mutex_trylock(&state->slot_one_mutex);
-    if (error && error != EBUSY) rb_syserr_fail(error, "Unexpected failure during sampler_lock_active_profile for slot_one_mutex");
+    if (error && error != EBUSY) ENFORCE_SUCCESS_GVL(error);
 
     // Slot one is active
     if (!error) return (struct active_slot_pair) {.mutex = &state->slot_one_mutex, .profile = state->slot_one_profile};
@@ -369,7 +368,7 @@ static struct active_slot_pair sampler_lock_active_profile(struct stack_recorder
     // If we got here, slot one was not active, let's try slot two
 
     error = pthread_mutex_trylock(&state->slot_two_mutex);
-    if (error && error != EBUSY) rb_syserr_fail(error, "Unexpected failure during sampler_lock_active_profile for slot_two_mutex");
+    if (error && error != EBUSY) ENFORCE_SUCCESS_GVL(error);
 
     // Slot two is active
     if (!error) return (struct active_slot_pair) {.mutex = &state->slot_two_mutex, .profile = state->slot_two_profile};
@@ -380,28 +379,24 @@ static struct active_slot_pair sampler_lock_active_profile(struct stack_recorder
 }
 
 static void sampler_unlock_active_profile(struct active_slot_pair active_slot) {
-  int error = pthread_mutex_unlock(active_slot.mutex);
-  if (error != 0) rb_syserr_fail(error, "Unexpected failure in sampler_unlock_active_profile");
+  ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(active_slot.mutex));
 }
 
 static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state) {
-  int error;
   int previously_active_slot = state->active_slot;
 
   if (previously_active_slot != 1 && previously_active_slot != 2) {
-    rb_raise(rb_eRuntimeError, "Unexpected active_slot state %d in serializer_flip_active_and_inactive_slots", previously_active_slot);
+    grab_gvl_and_raise(rb_eRuntimeError, "Unexpected active_slot state %d in serializer_flip_active_and_inactive_slots", previously_active_slot);
   }
 
   pthread_mutex_t *previously_active = (previously_active_slot == 1) ? &state->slot_one_mutex : &state->slot_two_mutex;
   pthread_mutex_t *previously_inactive = (previously_active_slot == 1) ? &state->slot_two_mutex : &state->slot_one_mutex;
 
   // Release the lock, thus making this slot active
-  error = pthread_mutex_unlock(previously_inactive);
-  if (error) rb_syserr_fail(error, "Unexpected failure during serializer_flip_active_and_inactive_slots for previously_inactive");
+  ENFORCE_SUCCESS_NO_GVL(pthread_mutex_unlock(previously_inactive));
 
   // Grab the lock, thus making this slot inactive
-  error = pthread_mutex_lock(previously_active);
-  if (error) rb_syserr_fail(error, "Unexpected failure during serializer_flip_active_and_inactive_slots for previously_active");
+  ENFORCE_SUCCESS_NO_GVL(pthread_mutex_lock(previously_active));
 
   // Update active_slot
   state->active_slot = (previously_active_slot == 1) ? 2 : 1;
@@ -438,21 +433,23 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {
 
   if (error == 0) {
     // Mutex was unlocked
-    pthread_mutex_unlock(slot_mutex);
+    ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(slot_mutex));
     return Qfalse;
   } else if (error == EBUSY) {
     // Mutex was locked
     return Qtrue;
   } else {
-    rb_syserr_fail(error, "Unexpected failure when checking mutex state");
+    ENFORCE_SUCCESS_GVL(error);
+    rb_raise(rb_eRuntimeError, "Failed to raise exception in test_slot_mutex_state; this should never happen");
   }
 }
 
-// Note that this is using CLOCK_REALTIME (e.g. actual time since unix epoch) and not the CLOCK_MONOTONIC as we use in other parts of the codebase
-static ddog_Timespec time_now() {
+// Note that this is using CLOCK_REALTIME (e.g. actual time since unix epoch) and not the CLOCK_MONOTONIC as we use in
+// monotonic_wall_time_now_ns (used in other parts of the codebase)
+static ddog_Timespec time_now(void) {
   struct timespec current_time;
 
-  if (clock_gettime(CLOCK_REALTIME, &current_time) != 0) rb_sys_fail("Failed to read CLOCK_REALTIME");
+  if (clock_gettime(CLOCK_REALTIME, &current_time) != 0) ENFORCE_SUCCESS_GVL(errno);
 
   return (ddog_Timespec) {.seconds = current_time.tv_sec, .nanoseconds = (uint32_t) current_time.tv_nsec};
 }

data/ext/ddtrace_profiling_native_extension/time_helpers.c

@@ -0,0 +1,17 @@
+#include <errno.h>
+#include <time.h>
+
+#include "ruby_helpers.h"
+#include "time_helpers.h"
+
+// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
+long monotonic_wall_time_now_ns(bool raise_on_failure) {
+  struct timespec current_monotonic;
+
+  if (clock_gettime(CLOCK_MONOTONIC, &current_monotonic) != 0) {
+    if (raise_on_failure) ENFORCE_SUCCESS_GVL(errno);
+    return 0;
+  }
+
+  return current_monotonic.tv_nsec + SECONDS_AS_NS(current_monotonic.tv_sec);
+}

data/ext/ddtrace_profiling_native_extension/time_helpers.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
+#define MILLIS_AS_NS(value) (value * 1000 * 1000L)
+
+#define RAISE_ON_FAILURE true
+#define DO_NOT_RAISE_ON_FAILURE false
+
+// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
+long monotonic_wall_time_now_ns(bool raise_on_failure);

data/lib/datadog/core/configuration/components.rb

@@ -248,6 +248,8 @@ module Datadog
             # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
             if settings.profiling.advanced.force_enable_new_profiler
+              print_new_profiler_warnings
+
               recorder = Datadog::Profiling::StackRecorder.new
               collector = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
                 recorder: recorder,
@@ -331,20 +333,39 @@ module Datadog
           end
 
           def should_enable_gc_profiling?(settings)
-            return true if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3')
-
             # See comments on the setting definition for more context on why it exists.
             if settings.profiling.advanced.force_enable_gc_profiling
-              Datadog.logger.debug(
-                'Profiling time/resources spent in Garbage Collection force enabled. Do not use Ractors in combination ' \
-                'with this option as profiles will be incomplete.'
-              )
+              if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3')
+                Datadog.logger.debug(
+                  'Profiling time/resources spent in Garbage Collection force enabled. Do not use Ractors in combination ' \
+                  'with this option as profiles will be incomplete.'
+                )
+              end
 
               true
             else
               false
             end
           end
+
+          def print_new_profiler_warnings
+            if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
+              Datadog.logger.warn(
+                'New Ruby profiler has been force-enabled. This feature is in beta state. We do not yet recommend ' \
+                'running it in production environments. Please report any issues ' \
+                'you run into to Datadog support or via <https://github.com/datadog/dd-trace-rb/issues/new>!'
+              )
+            else
+              # For more details on the issue, see the "BIG Issue" comment on `gvl_owner` function in
+              # `private_vm_api_access.c`.
+              Datadog.logger.warn(
+                'New Ruby profiler has been force-enabled on a legacy Ruby version (< 2.6). This is not recommended in ' \
+                'production environments, as due to limitations in Ruby APIs, we suspect it may lead to crashes in very ' \
+                'rare situations. Please report any issues you run into to Datadog support or ' \
+                'via <https://github.com/datadog/dd-trace-rb/issues/new>!'
+              )
+            end
+          end
         end
 
         attr_reader \

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

@@ -0,0 +1,18 @@
+# typed: true
+
+module Datadog
+  module Core
+    module Configuration
+      # Constants for configuration settings
+      # e.g. Env vars, default values, enums, etc...
+      module Ext
+        # @public_api
+        module Diagnostics
+          ENV_DEBUG_ENABLED = 'DD_TRACE_DEBUG'.freeze
+          ENV_HEALTH_METRICS_ENABLED = 'DD_HEALTH_METRICS_ENABLED'.freeze
+          ENV_STARTUP_LOGS_ENABLED = 'DD_TRACE_STARTUP_LOGS'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -3,22 +3,27 @@
 require 'logger'
 
 require_relative 'base'
+require_relative 'ext'
 require_relative '../environment/ext'
 require_relative '../runtime/ext'
 require_relative '../telemetry/ext'
 require_relative '../../profiling/ext'
-require_relative '../../tracing/configuration/ext'
+
+require_relative '../../tracing/configuration/settings'
 
 module Datadog
   module Core
     module Configuration
-      # Global configuration settings for the trace library.
+      # Global configuration settings for the Datadog library.
       # @public_api
       # rubocop:disable Metrics/BlockLength
-      # rubocop:disable Layout/LineLength
       class Settings
         include Base
 
+        # TODO: Tracing should manage its own settings.
+        #       Keep this extension here for now to keep things working.
+        extend Datadog::Tracing::Configuration::Settings
+
         # @!visibility private
         def initialize(*_)
           super
@@ -99,7 +104,7 @@ module Datadog
           # @default `DD_TRACE_DEBUG` environment variable, otherwise `false`
           # @return [Boolean]
           option :debug do |o|
-            o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::DD_TRACE_DEBUG, false) }
+            o.default { env_to_bool(Datadog::Core::Configuration::Ext::Diagnostics::ENV_DEBUG_ENABLED, false) }
             o.lazy
             o.on_set do |enabled|
               # Enable rich debug print statements.
@@ -110,7 +115,6 @@ module Datadog
 
           # Internal {Datadog::Statsd} metrics collection.
           #
-          # The list of metrics collected can be found in {Datadog::Core::Diagnostics::Ext::Health::Metrics}.
           # @public_api
           settings :health_metrics do
             # Enable health metrics collection.
@@ -118,7 +122,7 @@ module Datadog
             # @default `DD_HEALTH_METRICS_ENABLED` environment variable, otherwise `false`
             # @return [Boolean]
             option :enabled do |o|
-              o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::Health::Metrics::ENV_ENABLED, false) }
+              o.default { env_to_bool(Datadog::Core::Configuration::Ext::Diagnostics::ENV_HEALTH_METRICS_ENABLED, false) }
               o.lazy
             end
 
@@ -144,7 +148,7 @@ module Datadog
             # @return [Boolean,nil]
             option :enabled do |o|
               # Defaults to nil as we want to know when the default value is being used
-              o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::DD_TRACE_STARTUP_LOGS, nil) }
+              o.default { env_to_bool(Datadog::Core::Configuration::Ext::Diagnostics::ENV_STARTUP_LOGS_ENABLED, nil) }
               o.lazy
             end
           end
@@ -269,7 +273,9 @@ module Datadog
             # If you use Ruby 3.x and your application does not use Ractors (or if your Ruby has been patched), the
             # feature is fully safe to enable and this toggle can be used to do so.
             #
-            # We expect that once the above issue is patched, we'll automatically re-enable the feature on fixed Ruby
+            # Furthermore, currently this feature can add a lot of overhead for GC-heavy workloads.
+            #
+            # We expect the once the above issues are overcome, we'll automatically enable the feature on fixed Ruby
             # versions.
             option :force_enable_gc_profiling do |o|
               o.default { env_to_bool('DD_PROFILING_FORCE_ENABLE_GC', false) }
@@ -408,338 +414,6 @@ module Datadog
           end
         end
 
-        # Tracer specific configurations.
-        # @public_api
-        settings :tracing do
-          # Legacy [App Analytics](https://docs.datadoghq.com/tracing/legacy_app_analytics/) configuration.
-          #
-          # @configure_with {Datadog::Tracing}
-          # @deprecated Use [Trace Retention and Ingestion](https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/)
-          #   controls.
-          # @public_api
-          settings :analytics do
-            # @default `DD_TRACE_ANALYTICS_ENABLED` environment variable, otherwise `nil`
-            # @return [Boolean,nil]
-            option :enabled do |o|
-              o.default { env_to_bool(Tracing::Configuration::Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
-              o.lazy
-            end
-          end
-
-          # [Distributed Tracing](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#distributed-tracing) propagation
-          # style configuration.
-          #
-          # The supported formats are:
-          # * `Datadog`: Datadog propagation format, described by [Distributed Tracing](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#distributed-tracing).
-          # * `B3`: B3 Propagation using multiple headers, described by [openzipkin/b3-propagation](https://github.com/openzipkin/b3-propagation#multiple-headers).
-          # * `B3 single header`: B3 Propagation using a single header, described by [openzipkin/b3-propagation](https://github.com/openzipkin/b3-propagation#single-header).
-          #
-          # @public_api
-          settings :distributed_tracing do
-            # An ordered list of what data propagation styles the tracer will use to extract distributed tracing propagation
-            # data from incoming requests and messages.
-            #
-            # The tracer will try to find distributed headers in the order they are present in the list provided to this option.
-            # The first format to have valid data present will be used.
-            #
-            # @default `DD_PROPAGATION_STYLE_EXTRACT` environment variable (comma-separated list),
-            #   otherwise `['Datadog','B3','B3 single header']`.
-            # @return [Array<String>]
-            option :propagation_extract_style do |o|
-              o.default do
-                # Look for all headers by default
-                env_to_list(
-                  Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_EXTRACT,
-                  [
-                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
-                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3,
-                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER
-                  ],
-                  comma_separated_only: true
-                )
-              end
-
-              o.lazy
-            end
-
-            # The data propagation styles the tracer will use to inject distributed tracing propagation
-            # data into outgoing requests and messages.
-            #
-            # The tracer will inject data from all styles specified in this option.
-            #
-            # @default `DD_PROPAGATION_STYLE_INJECT` environment variable (comma-separated list), otherwise `['Datadog']`.
-            # @return [Array<String>]
-            option :propagation_inject_style do |o|
-              o.default do
-                env_to_list(
-                  Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT,
-                  [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG],
-                  comma_separated_only: true # Only inject Datadog headers by default
-                )
-              end
-
-              o.lazy
-            end
-          end
-
-          # Enable trace collection and span generation.
-          #
-          # You can use this option to disable tracing without having to
-          # remove the library as a whole.
-          #
-          # @default `DD_TRACE_ENABLED` environment variable, otherwise `true`
-          # @return [Boolean]
-          option :enabled do |o|
-            o.default { env_to_bool(Datadog::Core::Diagnostics::Ext::DD_TRACE_ENABLED, true) }
-            o.lazy
-          end
-
-          # A custom tracer instance.
-          #
-          # It must respect the contract of {Datadog::Tracing::Tracer}.
-          # It's recommended to delegate methods to {Datadog::Tracing::Tracer} to ease the implementation
-          # of a custom tracer.
-          #
-          # This option will not return the live tracer instance: it only holds a custom tracing instance, if any.
-          #
-          # For internal use only.
-          #
-          # @default `nil`
-          # @return [Object,nil]
-          option :instance
-
-          # Automatic correlation between tracing and logging.
-          # @see https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#trace-correlation
-          # @return [Boolean]
-          option :log_injection do |o|
-            o.default { env_to_bool(Tracing::Configuration::Ext::Correlation::ENV_LOGS_INJECTION_ENABLED, true) }
-            o.lazy
-          end
-
-          # Configures an alternative trace transport behavior, where
-          # traces can be sent to the agent and backend before all spans
-          # have finished.
-          #
-          # This is useful for long-running jobs or very large traces.
-          #
-          # The trace flame graph will display the partial trace as it is received and constantly
-          # update with new spans as they are flushed.
-          # @public_api
-          settings :partial_flush do
-            # Enable partial trace flushing.
-            #
-            # @default `false`
-            # @return [Boolean]
-            option :enabled, default: false
-
-            # Minimum number of finished spans required in a single unfinished trace before
-            # the tracer will consider that trace for partial flushing.
-            #
-            # This option helps preserve a minimum amount of batching in the
-            # flushing process, reducing network overhead.
-            #
-            # This threshold only applies to unfinished traces. Traces that have finished
-            # are always flushed immediately.
-            #
-            # @default 500
-            # @return [Integer]
-            option :min_spans_threshold, default: 500
-          end
-
-          # Enables {https://docs.datadoghq.com/tracing/trace_retention_and_ingestion/#datadog-intelligent-retention-filter
-          # Datadog intelligent retention filter}.
-          # @default `true`
-          # @return [Boolean,nil]
-          option :priority_sampling
-
-          option :report_hostname do |o|
-            o.default { env_to_bool(Tracing::Configuration::Ext::NET::ENV_REPORT_HOSTNAME, false) }
-            o.lazy
-          end
-
-          # A custom sampler instance.
-          # The object must respect the {Datadog::Tracing::Sampling::Sampler} interface.
-          # @default `nil`
-          # @return [Object,nil]
-          option :sampler
-
-          # Client-side sampling configuration.
-          # @see https://docs.datadoghq.com/tracing/trace_ingestion/mechanisms/
-          # @public_api
-          settings :sampling do
-            # Default sampling rate for the tracer.
-            #
-            # If `nil`, the trace uses an automatic sampling strategy that tries to ensure
-            # the collection of traces that are considered important (e.g. traces with an error, traces
-            # for resources not seen recently).
-            #
-            # @default `DD_TRACE_SAMPLE_RATE` environment variable, otherwise `nil`.
-            # @return [Float,nil]
-            option :default_rate do |o|
-              o.default { env_to_float(Tracing::Configuration::Ext::Sampling::ENV_SAMPLE_RATE, nil) }
-              o.lazy
-            end
-
-            # Rate limit for number of spans per second.
-            #
-            # Spans created above the limit will contribute to service metrics, but won't
-            # have their payload stored.
-            #
-            # @default `DD_TRACE_RATE_LIMIT` environment variable, otherwise 100.
-            # @return [Numeric,nil]
-            option :rate_limit do |o|
-              o.default { env_to_float(Tracing::Configuration::Ext::Sampling::ENV_RATE_LIMIT, 100) }
-              o.lazy
-            end
-
-            # Single span sampling rules.
-            # These rules allow a span to be kept when its encompassing trace is dropped.
-            #
-            # The syntax for single span sampling rules can be found here:
-            # TODO: <Single Span Sampling documentation URL here>
-            #
-            # @default `DD_SPAN_SAMPLING_RULES` environment variable.
-            #   Otherwise, `ENV_SPAN_SAMPLING_RULES_FILE` environment variable.
-            #   Otherwise `nil`.
-            # @return [String,nil]
-            # @public_api
-            option :span_rules do |o|
-              o.default do
-                rules = ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES]
-                rules_file = ENV[Tracing::Configuration::Ext::Sampling::Span::ENV_SPAN_SAMPLING_RULES_FILE]
-
-                if rules
-                  if rules_file
-                    Datadog.logger.warn(
-                      'Both DD_SPAN_SAMPLING_RULES and DD_SPAN_SAMPLING_RULES_FILE were provided: only ' \
-                        'DD_SPAN_SAMPLING_RULES will be used. Please do not provide DD_SPAN_SAMPLING_RULES_FILE when ' \
-                        'also providing DD_SPAN_SAMPLING_RULES as their configuration conflicts. ' \
-                        "DD_SPAN_SAMPLING_RULES_FILE=#{rules_file} DD_SPAN_SAMPLING_RULES=#{rules}"
-                    )
-                  end
-                  rules
-                elsif rules_file
-                  begin
-                    File.read(rules_file)
-                  rescue => e
-                    # `File#read` errors have clear and actionable messages, no need to add extra exception info.
-                    Datadog.logger.warn(
-                      "Cannot read span sampling rules file `#{rules_file}`: #{e.message}." \
-                      'No span sampling rules will be applied.'
-                    )
-                    nil
-                  end
-                end
-              end
-              o.lazy
-            end
-          end
-
-          # [Continuous Integration Visibility](https://docs.datadoghq.com/continuous_integration/) configuration.
-          # @public_api
-          settings :test_mode do
-            # Enable test mode. This allows the tracer to collect spans from test runs.
-            #
-            # It also prevents the tracer from collecting spans in a production environment. Only use in a test environment.
-            #
-            # @default `DD_TRACE_TEST_MODE_ENABLED` environment variable, otherwise `false`
-            # @return [Boolean]
-            option :enabled do |o|
-              o.default { env_to_bool(Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED, false) }
-              o.lazy
-            end
-
-            option :trace_flush do |o|
-              o.default { nil }
-              o.lazy
-            end
-
-            option :writer_options do |o|
-              o.default { {} }
-              o.lazy
-            end
-          end
-
-          # @see file:docs/GettingStarted.md#configuring-the-transport-layer Configuring the transport layer
-          #
-          # A {Proc} that configures a custom tracer transport.
-          # @yield Receives a {Datadog::Transport::HTTP} that can be modified with custom adapters and settings.
-          # @yieldparam [Datadog::Transport::HTTP] t transport to be configured.
-          # @default `nil`
-          # @return [Proc,nil]
-          option :transport_options, default: nil
-
-          # A custom writer instance.
-          # The object must respect the {Datadog::Tracing::Writer} interface.
-          #
-          # This option is recommended for internal use only.
-          #
-          # @default `nil`
-          # @return [Object,nil]
-          option :writer
-
-          # A custom {Hash} with keyword options to be passed to {Datadog::Tracing::Writer#initialize}.
-          #
-          # This option is recommended for internal use only.
-          #
-          # @default `{}`
-          # @return [Hash,nil]
-          option :writer_options, default: ->(_i) { {} }, lazy: true
-
-          # Client IP configuration
-          # @public_api
-          settings :client_ip do
-            # Whether client IP collection is enabled. When enabled client IPs from HTTP requests will
-            #   be reported in traces.
-            #
-            # Usage of the DD_TRACE_CLIENT_IP_HEADER_DISABLED environment variable is deprecated.
-            #
-            # @see https://docs.datadoghq.com/tracing/configure_data_security#configuring-a-client-ip-header
-            #
-            # @default `DD_TRACE_CLIENT_IP_ENABLED` environment variable, otherwise `false`.
-            # @return [Boolean]
-            option :enabled do |o|
-              o.default do
-                disabled = env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_DISABLED)
-
-                enabled = if disabled.nil?
-                            false
-                          else
-                            Datadog.logger.warn { "#{Tracing::Configuration::Ext::ClientIp::ENV_DISABLED} environment variable is deprecated, found set to #{disabled}, use #{Tracing::Configuration::Ext::ClientIp::ENV_ENABLED}=#{!disabled}" }
-
-                            !disabled
-                          end
-
-                # ENABLED env var takes precedence over deprecated DISABLED
-                env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_ENABLED, enabled)
-              end
-              o.lazy
-            end
-
-            # An optional name of a custom header to resolve the client IP from.
-            #
-            # @default `DD_TRACE_CLIENT_IP_HEADER` environment variable, otherwise `nil`.
-            # @return [String,nil]
-            option :header_name do |o|
-              o.default { ENV.fetch(Tracing::Configuration::Ext::ClientIp::ENV_HEADER_NAME, nil) }
-              o.lazy
-            end
-          end
-
-          # Maximum size for the `x-datadog-tags` distributed trace tags header.
-          #
-          # If the serialized size of distributed trace tags is larger than this value, it will
-          # not be parsed if incoming, nor exported if outgoing. An error message will be logged
-          # in this case.
-          #
-          # @default `DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH` environment variable, otherwise `512`
-          # @return [Integer]
-          option :x_datadog_tags_max_length do |o|
-            o.default { env_to_int(Tracing::Configuration::Ext::Distributed::ENV_X_DATADOG_TAGS_MAX_LENGTH, 512) }
-            o.lazy
-          end
-        end
-
         # The `version` tag in Datadog. Use it to enable [Deployment Tracking](https://docs.datadoghq.com/tracing/deployment_tracking/).
         # @see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging
         # @default `DD_VERSION` environment variable, otherwise `nils`
@@ -765,7 +439,6 @@ module Datadog
         end
       end
       # rubocop:enable Metrics/BlockLength
-      # rubocop:enable Layout/LineLength
     end
   end
 end

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

@@ -1,7 +1,7 @@
-# typed: strict
+# typed: ignore
 
-require_relative 'ext'
 require_relative '../metrics/client'
+require_relative '../../tracing/diagnostics/health'
 
 module Datadog
   module Core
@@ -10,26 +10,8 @@ module Datadog
       module Health
         # Health metrics for diagnostics
         class Metrics < Core::Metrics::Client
-          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
+          # TODO: Don't reference this. Have tracing add its metrics behavior.
+          extend Tracing::Diagnostics::Health::Metrics
         end
       end
     end