datadog 2.36.0 → 2.38.0

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

@@ -46,6 +46,38 @@ module Datadog
             Core::Diagnostics::Health::Metrics.new(telemetry: telemetry, logger: logger, **options)
           end
 
+          # Decides whether to build the SymbolDatabase component, for the
+          # tri-state symbol_database.enabled setting: true/false are explicit
+          # overrides; nil (the default) mirrors Dynamic Instrumentation by
+          # building whenever DI's component was built. dynamic_instrumentation
+          # is DI's build result — nil only when DI is explicitly disabled or the
+          # runtime can't support it (Rails development mode, missing C
+          # extension, remote config off, non-MRI). Under the always-build model
+          # it is non-nil even when the DI setting defaults to off, so a built
+          # SymbolDatabase component is inert until an upload is actually
+          # permitted: the component's own gate (see Component#upload_allowed?)
+          # only extracts and uploads when DI is truly active or the customer
+          # opted in explicitly. This mirrors DI advertising/building a component
+          # by default while installing no probes until it is enabled.
+          # force_upload (internal/testing) always builds, since it uploads
+          # regardless of DI or the enabled setting.
+          # @param settings [Configuration::Settings]
+          # @param dynamic_instrumentation [DI::Component, nil]
+          # @return [Boolean]
+          def enable_symbol_database?(settings, dynamic_instrumentation)
+            # The symbol_database settings group is only registered on the full
+            # library load path; a partial load (e.g. require 'datadog/di') leaves
+            # it absent, in which case the feature cannot be enabled.
+            return false unless settings.respond_to?(:symbol_database)
+
+            # force_upload uploads unconditionally, so the component must be built
+            # even when the setting is nil and DI's component was not built.
+            return true if settings.symbol_database.internal.force_upload
+
+            # nil (the default) follows whether DI's component was built.
+            Datadog::SymbolDatabase.resolve_enabled(settings.symbol_database.enabled, !dynamic_instrumentation.nil?)
+          end
+
           def build_logger(settings)
             logger = settings.logger.instance || Core::Logger.new($stderr)
             logger.level = settings.diagnostics.debug ? ::Logger::DEBUG : settings.logger.level
@@ -174,10 +206,31 @@ module Datadog
           @ai_guard = Datadog::AIGuard::Component.build(settings, logger: @logger, telemetry: telemetry)
           @open_feature = OpenFeature::Component.build(settings, agent_settings, logger: @logger, telemetry: telemetry)
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
-          @symbol_database = Datadog::SymbolDatabase::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
+          # Only build symbol database when enabled, so a disabled component is
+          # never constructed.
+          @symbol_database =
+            if self.class.enable_symbol_database?(settings, @dynamic_instrumentation)
+              # di_active is a live predicate, not a snapshot: DI may start after
+              # this component is built (implicit enablement via remote config).
+              # Symbol Database holds only this opaque proc, never a DI reference,
+              # so the two modules stay independent — the orchestration layer
+              # owns the cross-feature knowledge.
+              Datadog::SymbolDatabase::Component.build(
+                settings, agent_settings, @logger,
+                telemetry: telemetry,
+                di_active: -> { dynamic_instrumentation&.started? || false },
+              )
+            end
           @error_tracking = Datadog::ErrorTracking::Component.build(settings, @tracer, @logger)
           @data_streams = self.class.build_data_streams(settings, agent_settings, @logger, @agent_info)
-          @environment_logger_extra[:dynamic_instrumentation_enabled] = !!@dynamic_instrumentation
+          # Reflects "the customer configured DI to be on" — true iff the
+          # component was built AND the env-var-driven enabled flag is set.
+          # This is the post-initialize / pre-startup value visible to tests
+          # that don't call startup!. Production overwrites this in startup!
+          # below with `dynamic_instrumentation&.started?`, which also accounts
+          # for RC-driven enablement carried over via ComponentsState.
+          @environment_logger_extra[:dynamic_instrumentation_enabled] =
+            !!(@dynamic_instrumentation && settings.dynamic_instrumentation.enabled)
 
           # Configure non-privileged components.
           Datadog::Tracing::Contrib::Component.configure(settings)
@@ -228,11 +281,25 @@ module Datadog
             remote.start
           end
 
+          # Start DI component if enabled by env var or if it was implicitly enabled
+          # (via RC) in the previous Components instance. dynamic_instrumentation is
+          # non-nil only when Component.build's preconditions passed (Ruby 2.6+ MRI,
+          # etc.), which is exactly the condition under which di/base.rb is loaded
+          # and DI.activate_tracking is defined.
+          if dynamic_instrumentation
+            if settings.dynamic_instrumentation.enabled || old_state&.di_implicitly_enabled?
+              DI.activate_tracking
+              dynamic_instrumentation.start!
+            end
+          end
+
           # This should stay here, not in initialize. During reconfiguration, the order of the calls is:
           # initialize new components, shutdown old components, startup new components.
           # Because this is a singleton, if we call it in initialize, it will be shutdown right away.
           Core::ProcessDiscovery.publish(settings)
 
+          @environment_logger_extra[:dynamic_instrumentation_enabled] = dynamic_instrumentation&.started? || false
+
           Core::Diagnostics::EnvironmentLogger.collect_and_log!(@environment_logger_extra)
         end
 
@@ -309,9 +376,22 @@ module Datadog
 
         # Returns the current state of various components.
         def state
+          # di_implicitly_enabled distinguishes RC-driven start from explicit
+          # start (env var or programmatic) so that an explicit
+          # `enabled = false` on reconfiguration can take effect.
+          #
+          # using_default? — not `!enabled` — because Datadog.configure has
+          # already mutated the singleton settings by the time #state runs,
+          # so `!enabled` would treat a customer's explicit
+          # `enabled = false` as "implicitly enabled" and restart DI.
+          # using_default? asks "did the customer ever touch this setting",
+          # which is the right question for RC carry-over.
+          di_implicit = dynamic_instrumentation&.started? &&
+            @settings.dynamic_instrumentation.using_default?(:enabled)
           ComponentsState.new(
             telemetry_enabled: telemetry.enabled,
             remote_started: remote&.started?,
+            di_implicitly_enabled: di_implicit || false,
           )
         end
       end

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

@@ -5,9 +5,10 @@ module Datadog
     module Configuration
       # Stores the state of component tree when replacing the tree.
       class ComponentsState
-        def initialize(telemetry_enabled:, remote_started:)
+        def initialize(telemetry_enabled:, remote_started:, di_implicitly_enabled: false)
           @telemetry_enabled = !!telemetry_enabled
           @remote_started = !!remote_started
+          @di_implicitly_enabled = !!di_implicitly_enabled
         end
 
         def telemetry_enabled?
@@ -17,6 +18,10 @@ module Datadog
         def remote_started?
           @remote_started
         end
+
+        def di_implicitly_enabled?
+          @di_implicitly_enabled
+        end
       end
     end
   end

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

@@ -14,7 +14,6 @@ require_relative '../../profiling/ext'
 
 require_relative '../../tracing/configuration/settings'
 require_relative '../../opentelemetry/configuration/settings'
-require_relative '../../symbol_database/configuration'
 
 module Datadog
   module Core
@@ -825,14 +824,14 @@ module Datadog
         # It must respect the interface of [Datadog::Core::Utils::Time#get_time] method.
         #
         # For [Timecop](https://rubygems.org/gems/timecop), for example,
-        # `->(unit = :float_second) { ::Process.clock_gettime_without_mock(::Process::CLOCK_MONOTONIC, unit) }`
+        # `->(unit = :float_second) { ::Process.clock_gettime_without_mock(Datadog::Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }`
         # allows Datadog features to use the real monotonic time when time is frozen with
         # `Timecop.mock_process_clock = true`.
         #
-        # @default `->(unit = :float_second) { ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, unit)}`
+        # @default `->(unit = :float_second) { ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }`
         # @return [Proc<Numeric>]
         option :get_time_provider do |o|
-          o.default_proc { |unit = :float_second| ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, unit) }
+          o.default_proc { |unit = :float_second| ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }
           o.type :proc
 
           o.after_set do |get_time_provider|
@@ -840,7 +839,7 @@ module Datadog
           end
 
           o.resetter do |_value|
-            ->(unit = :float_second) { ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, unit) }.tap do |default|
+            ->(unit = :float_second) { ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }.tap do |default|
               Core::Utils::Time.get_time_provider = default
             end
           end
@@ -1130,8 +1129,6 @@ module Datadog
         extend Datadog::Tracing::Configuration::Settings
 
         extend Datadog::OpenTelemetry::Configuration::Settings
-
-        extend Datadog::SymbolDatabase::Configuration::Settings
       end
       # standard:enable Metrics/BlockLength
     end

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

@@ -19,6 +19,7 @@ module Datadog
           "DD_API_SECURITY_DOWNSTREAM_BODY_ANALYSIS_SAMPLE_RATE",
           "DD_API_SECURITY_ENABLED",
           "DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED",
+          "DD_API_SECURITY_MAX_DOWNSTREAM_BODY_BYTES",
           "DD_API_SECURITY_MAX_DOWNSTREAM_REQUEST_BODY_ANALYSIS",
           "DD_API_SECURITY_REQUEST_SAMPLE_RATE",
           "DD_API_SECURITY_SAMPLE_DELAY",
@@ -49,6 +50,7 @@ module Datadog
           "DD_DBM_PROPAGATION_MODE",
           "DD_DISABLE_DATADOG_RAILS",
           "DD_DYNAMIC_INSTRUMENTATION_ENABLED",
+          "DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE",
           "DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE",
           "DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS",
           "DD_DYNAMIC_INSTRUMENTATION_REDACTED_TYPES",
@@ -59,6 +61,7 @@ module Datadog
           "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED",
           "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED",
           "DD_EXTERNAL_ENV",
+          "DD_FLAGGING_EVALUATION_COUNTS_ENABLED",
           "DD_GIT_COMMIT_SHA",
           "DD_GIT_REPOSITORY_URL",
           "DD_HEALTH_METRICS_ENABLED",

data/lib/datadog/core/evp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module EVP
+      SUBDOMAIN_HEADER_NAME = 'X-Datadog-EVP-Subdomain'
+      EVENT_PLATFORM_INTAKE_SUBDOMAIN = 'event-platform-intake'
+      PAYLOAD_SIZE_LIMIT_BYTES = 5 * 1024 * 1024
+    end
+  end
+end

data/lib/datadog/core/knuth_sampler.rb

@@ -32,7 +32,9 @@ module Datadog
         @knuth_factor = knuth_factor
 
         rate = rate.to_f
-        unless rate >= 0.0 && rate <= 1.0
+        # Not using `between?` here: it raises on NaN instead of falling back to 1.0 below.
+        # No current caller passes NaN, but this guards against it defensively for future ones.
+        unless rate >= 0.0 && rate <= 1.0 # rubocop:disable Style/ComparableBetween
           Datadog.logger.warn("Sample rate #{rate} is not between 0.0 and 1.0, falling back to 1.0")
           rate = 1.0
         end

data/lib/datadog/core/metrics/client.rb

@@ -157,7 +157,7 @@ module Datadog
           begin
             if send_stats? && !start.nil?
               finished = Utils::Time.get_time
-              distribution(stat, ((finished - start) * 1000), options)
+              distribution(stat, (finished - start) * 1000, options)
             end
           rescue => e
             # TODO: Likely to be redundant, since `distribution` handles its own errors.

data/lib/datadog/core/remote/client/capabilities.rb

@@ -4,6 +4,7 @@ require_relative '../../utils/base64_codec'
 require_relative '../../../appsec/remote'
 require_relative '../../../tracing/remote'
 require_relative '../../../di/remote'
+require_relative '../../../symbol_database'
 require_relative '../../../symbol_database/remote'
 require_relative '../../../open_feature/remote'
 
@@ -35,13 +36,43 @@ module Datadog
               register_receivers(Datadog::AppSec::Remote.receivers(@telemetry))
             end
 
-            if settings.respond_to?(:dynamic_instrumentation) && settings.dynamic_instrumentation.enabled
+            # Tracing must register before DI: on a combined RC dispatch,
+            # the APM_TRACING handler must run first to call
+            # Datadog::DI::Remote.handle_rc_enablement and start the
+            # component before the DI receiver processes LIVE_DEBUGGING
+            # changes against `component.started?`. Reversing the order
+            # silently drops the probe — the remote client only
+            # redispatches on content hash changes.
+            register_capabilities(Datadog::Tracing::Remote.capabilities)
+            register_products(Datadog::Tracing::Remote.products)
+            register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))
+
+            # Skip DI registration entirely when DI is explicitly disabled
+            # (DD_DYNAMIC_INSTRUMENTATION_ENABLED=false) or when the runtime
+            # cannot run DI (JRuby, Ruby 2.5): in either case no component will
+            # run, so advertising bit 38 or the LIVE_DEBUGGING product would
+            # invite probe configs and an enable signal the tracer must refuse.
+            # When the env var is unset (default) on a supported runtime, DI is
+            # registered so RC can enable it.
+            if settings.respond_to?(:dynamic_instrumentation) &&
+                !Datadog::DI::Remote.explicitly_disabled?(settings) &&
+                Datadog::DI.supported_runtime?
               register_capabilities(Datadog::DI::Remote.capabilities)
               register_products(Datadog::DI::Remote.products)
               register_receivers(Datadog::DI::Remote.receivers(@telemetry))
+            end
 
-              # Symbol Database
-              if settings.respond_to?(:symbol_database) && settings.symbol_database.enabled
+            # Skip symbol database registration on runtimes that cannot run it
+            # (JRuby, Ruby < 2.7): DI supports Ruby 2.6 but Symbol Database does
+            # not, so advertising LIVE_DEBUGGING_SYMBOL_DB there would invite
+            # symbol-upload configs the component can never serve.
+            if settings.respond_to?(:symbol_database) && Datadog::SymbolDatabase.supported_runtime?
+              # Symbol database follows DI: when unset it advertises whenever DI
+              # advertises (mirror the DI branch above, including the unset/default
+              # case that RC may enable). An explicit symbol_database.enabled wins.
+              di_enabled = settings.respond_to?(:dynamic_instrumentation) &&
+                !Datadog::DI::Remote.explicitly_disabled?(settings)
+              if Datadog::SymbolDatabase.resolve_enabled(settings.symbol_database.enabled, di_enabled)
                 register_capabilities(Datadog::SymbolDatabase::Remote.capabilities)
                 register_products(Datadog::SymbolDatabase::Remote.products)
                 register_receivers(Datadog::SymbolDatabase::Remote.receivers(@telemetry))
@@ -53,10 +84,6 @@ module Datadog
               register_products(Datadog::OpenFeature::Remote.products)
               register_receivers(Datadog::OpenFeature::Remote.receivers(@telemetry))
             end
-
-            register_capabilities(Datadog::Tracing::Remote.capabilities)
-            register_products(Datadog::Tracing::Remote.products)
-            register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))
           end
 
           def register_capabilities(capabilities)

data/lib/datadog/core/telemetry/event/app_started.rb

@@ -57,7 +57,14 @@ module Datadog
                 enabled: !!components.profiler,
               },
               dynamic_instrumentation: {
-                enabled: !!components.dynamic_instrumentation,
+                # With always-build, the DI component is constructed by
+                # default (when the runtime supports DI, RC is available, and
+                # DI is not explicitly disabled) regardless of whether the
+                # customer turned DI on. Its presence therefore no longer
+                # indicates the enabled state. started? reflects whether DI was
+                # actually enabled by env var or by implicit enablement via
+                # remote config.
+                enabled: components.dynamic_instrumentation&.started? || false,
               }
             }
 

data/lib/datadog/core/transport/http/builder.rb

@@ -108,7 +108,7 @@ module Datadog
 
                 # Resolve fallback and merge headers
                 fallback = api_options.delete(:fallback)
-                api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
+                api_options[:headers] = @default_headers.merge(api_options[:headers] || {})
 
                 # Add API::Instance with all settings
                 instances[key] = API::Instance.new(

data/lib/datadog/core/utils/at_fork_monkey_patch.rb

@@ -6,7 +6,7 @@ module Datadog
       # Monkey patches `Kernel#fork` and similar functions, adding an `at_fork` callback mechanism which
       # is used to restart observability after the VM forks (e.g. in multiprocess Ruby apps).
       module AtForkMonkeyPatch
-        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant Used to store blocks to run, mutable by design.
+        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
         private_constant :AT_FORK_CHILD_BLOCKS
 
         def self.supported?

data/lib/datadog/core/utils/time.rb

@@ -8,11 +8,15 @@ module Datadog
         module_function
 
         # Current monotonic time
+        # On macOS, CLOCK_MONOTONIC only has microsecond precision,
+        # so we use CLOCK_MONOTONIC_RAW which has nanosecond precision instead.
         #
         # @param unit [Symbol] unit for the resulting value, same as ::Process#clock_gettime, defaults to :float_second
         # @return [Float|Integer] timestamp in the requested unit, since some unspecified starting point
+        MONOTONIC_CLOCK_ID = RUBY_PLATFORM.include?("darwin") ? Process::CLOCK_MONOTONIC_RAW : Process::CLOCK_MONOTONIC
+
         def get_time(unit = :float_second)
-          Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+          Process.clock_gettime(MONOTONIC_CLOCK_ID, unit)
         end
 
         # Current wall time.

data/lib/datadog/di/base.rb

@@ -8,6 +8,7 @@
 # are loaded, and also none of the rest of datadog library which also
 # has contrib code in other products.
 
+require_relative 'fatal_exceptions'
 require_relative 'code_tracker'
 
 # Needed since this file can be loaded without core
@@ -53,7 +54,8 @@ module Datadog
           # Activate code tracking by default because line trace points will not work
           # without it.
           Datadog::DI.activate_tracking!
-        rescue => exc
+        rescue Exception => exc # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(exc)
           if defined?(Datadog.logger)
             Datadog.logger.warn { "di: Failed to activate code tracking for DI: #{exc.class}: #{exc.message}" }
           else

data/lib/datadog/di/boot.rb

@@ -6,6 +6,9 @@ require_relative 'error'
 require_relative 'code_tracker'
 require_relative 'component'
 require_relative 'context'
+require_relative 'capture_limits'
+require_relative 'capture_expression'
+require_relative 'capture_expression_evaluator'
 require_relative 'instrumenter'
 require_relative 'probe'
 require_relative 'probe_builder'

data/lib/datadog/di/capture_expression.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "capture_limits"
+
+module Datadog
+  module DI
+    class CaptureExpression
+      def initialize(name:, expr:, limits: nil)
+        @name = name
+        @expr = expr
+        @limits = limits
+      end
+
+      attr_reader :name
+
+      attr_reader :expr
+
+      attr_reader :limits
+    end
+  end
+end

data/lib/datadog/di/capture_expression_evaluator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "capture_expression"
+require_relative "capture_limits"
+require_relative "fatal_exceptions"
+
+module Datadog
+  module DI
+    class CaptureExpressionEvaluator
+      TELEMETRY_NAMESPACE = "dynamic_instrumentation"
+
+      def initialize(settings:, serializer:, logger:, telemetry: nil)
+        @settings = settings
+        @serializer = serializer
+        @logger = logger
+        @telemetry = telemetry
+      end
+
+      attr_reader :settings
+
+      attr_reader :serializer
+
+      attr_reader :logger
+
+      attr_reader :telemetry
+
+      def evaluate(probe, context)
+        budget_ns = settings.dynamic_instrumentation.max_time_to_serialize_ms * 1_000_000
+        deadline_ns = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :nanosecond) + budget_ns
+
+        output = {}
+        evaluation_errors = []
+
+        probe.capture_expressions.each do |capture_expression|
+          name = capture_expression.name
+
+          if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :nanosecond) >= deadline_ns
+            output[name] = {notCapturedReason: "timeout"}
+            telemetry&.inc(TELEMETRY_NAMESPACE, "capture_expressions_skipped_by_timeout", 1)
+            next
+          end
+
+          begin
+            value = capture_expression.expr.evaluate(context)
+            limits = CaptureLimits.resolve(
+              expr_limits: capture_expression.limits,
+              probe: probe,
+              settings: settings,
+            )
+            output[name] = serializer.serialize_value(
+              value, name: name,
+              depth: limits[:depth],
+              attribute_count: limits[:attribute_count],
+              length: limits[:length],
+              collection_size: limits[:collection_size],
+            )
+          rescue Exception => exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(exc)
+            evaluation_errors << {expr: name, message: "#{exc.class}: #{exc.message}"}
+            logger.debug do
+              "di: probe #{probe.id}: capture expression #{name}: evaluation failed: #{exc.class}: #{exc.message}"
+            end
+            telemetry&.report(exc, description: "DI capture-expression evaluation failed")
+          end
+        end
+
+        [output, evaluation_errors]
+      end
+    end
+  end
+end

data/lib/datadog/di/capture_limits.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    class CaptureLimits
+      def initialize(max_reference_depth: nil, max_collection_size: nil,
+        max_length: nil, max_field_count: nil)
+        @max_reference_depth = max_reference_depth
+        @max_collection_size = max_collection_size
+        @max_length = max_length
+        @max_field_count = max_field_count
+      end
+
+      attr_reader :max_reference_depth
+
+      attr_reader :max_collection_size
+
+      attr_reader :max_length
+
+      attr_reader :max_field_count
+
+      def self.resolve(expr_limits:, probe:, settings:)
+        di = settings.dynamic_instrumentation
+        {
+          depth: expr_limits&.max_reference_depth ||
+            probe.max_capture_depth ||
+            di.max_capture_depth,
+          collection_size: expr_limits&.max_collection_size ||
+            probe.max_capture_collection_size ||
+            di.max_capture_collection_size,
+          length: expr_limits&.max_length ||
+            probe.max_capture_string_length ||
+            di.max_capture_string_length,
+          attribute_count: expr_limits&.max_field_count ||
+            probe.max_capture_attribute_count ||
+            di.max_capture_attribute_count,
+        }
+      end
+    end
+  end
+end

data/lib/datadog/di/code_tracker.rb

@@ -3,6 +3,7 @@
 # rubocop:disable Lint/AssignmentInCondition
 
 require_relative 'error'
+require_relative 'fatal_exceptions'
 
 module Datadog
   module DI
@@ -120,7 +121,8 @@ module Datadog
           end
         end
         nil
-      rescue => exc
+      rescue Exception => exc # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(exc)
         # Backfill is best-effort — if it fails, line probes on
         # pre-loaded code won't work but everything else is unaffected.
         if component = DI.current_component
@@ -191,7 +193,8 @@ module Datadog
           # Since this method normally is called from customer applications,
           # rescue any exceptions that might not be handled to not break said
           # customer applications.
-          rescue => exc
+          rescue Exception => exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(exc)
             # Code tracker may be loaded without the rest of DI,
             # in which case DI.component will not yet be defined,
             # but we will have DI.current_component (set to nil).