datadog 2.36.0 → 2.37.0

data/lib/datadog/symbol_database/component.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require_relative '../symbol_database'
 require_relative 'extractor'
 require_relative 'logger'
 require_relative 'scope_batcher'
 require_relative 'uploader'
 require_relative '../core/utils/time'
+require_relative '../di/fatal_exceptions'
 
 module Datadog
   module SymbolDatabase
@@ -54,21 +56,24 @@ module Datadog
       MODULE_SINGLETON_CLASS_PRED = Module.instance_method(:singleton_class?)
       private_constant :MODULE_SINGLETON_CLASS_PRED
 
-      # Build a new Component if feature is enabled and dependencies met.
+      # Build a new Component if the runtime supports it and dependencies are met.
+      # The caller (Core::Configuration::Components) decides whether the feature is
+      # enabled and only invokes build when it is, so a disabled component is never
+      # constructed. This method gates only on symbol database's own requirements
+      # (supported platform, remote config availability).
       # @param settings [Configuration::Settings] Tracer settings
       # @param agent_settings [Configuration::AgentSettings] Agent configuration
       # @param logger [Logger] Logger instance
       # @param telemetry [Core::Telemetry::Component, nil] Telemetry component for error reporting
-      # @return [Component, nil] Component instance or nil if not enabled/requirements not met
-      def self.build(settings, agent_settings, logger, telemetry: nil)
+      # @param di_active [Proc, nil] Predicate returning whether Dynamic
+      #   Instrumentation is currently active (started). Gates remote-config
+      #   uploads in the nil-default case; nil means "no gate" (standalone
+      #   force_upload contexts).
+      # @return [Component, nil] Component instance or nil if requirements not met
+      def self.build(settings, agent_settings, logger, telemetry: nil, di_active: nil)
         symdb_logger = SymbolDatabase::Logger.new(settings, logger)
 
-        unless settings.respond_to?(:symbol_database) && settings.symbol_database.enabled
-          symdb_logger.debug("symdb: symbol database upload not enabled, skipping")
-          return
-        end
-
-        # Symbol database requires MRI Ruby 2.6+.
+        # Symbol database requires MRI Ruby 2.7+.
         # Configuration accessors (settings.symbol_database.*) remain available on all
         # platforms — only the component (upload) is disabled on unsupported engines/versions.
         # environment_supported? logs the specific reason (engine or version) internally.
@@ -80,7 +85,7 @@ module Datadog
           return nil
         end
 
-        new(settings, agent_settings, symdb_logger, telemetry: telemetry).tap do |component|
+        new(settings, agent_settings, symdb_logger, telemetry: telemetry, di_active: di_active).tap do |component|
           # Defer extraction if force upload mode — wait for app boot to complete
           component.schedule_deferred_upload if settings.symbol_database.internal.force_upload
         end
@@ -93,11 +98,13 @@ module Datadog
       # @param agent_settings [Configuration::AgentSettings] Agent configuration
       # @param logger [Logger] Logger instance
       # @param telemetry [Core::Telemetry::Component, nil] Telemetry component for error reporting
-      def initialize(settings, agent_settings, logger, telemetry: nil)
+      # @param di_active [Proc, nil] Predicate returning whether Dynamic Instrumentation is currently active
+      def initialize(settings, agent_settings, logger, telemetry: nil, di_active: nil)
         @settings = settings
         @agent_settings = agent_settings
         @logger = logger
         @telemetry = telemetry
+        @di_active = di_active
 
         @extractor = Extractor.new(logger: logger, settings: settings)
         @uploader = Uploader.new(settings: settings, agent_settings: agent_settings, logger: logger, telemetry: telemetry)
@@ -136,6 +143,16 @@ module Datadog
         @hot_load_buffer_mutex = Mutex.new
         @hot_load_tracepoint = nil
         @initial_extraction_done = false
+
+        # Sticky record of "remote config (or force mode) wants symbols
+        # uploaded", independent of whether DI is currently active. Set when an
+        # upload is requested and either allowed or deferred by the DI gate;
+        # cleared only when RC explicitly disables uploads (stop_upload). It
+        # survives stop_for_di_disable's scheduler teardown, so
+        # resume_pending_upload can restart uploads after a DI disable->re-enable
+        # cycle even though RC does not re-dispatch the unchanged symbol-database
+        # config.
+        @upload_requested = false
       end
 
       # Schedule a deferred upload that waits for app boot to complete.
@@ -182,6 +199,25 @@ module Datadog
         @scheduler_mutex.synchronize do
           return if @shutdown
 
+          unless upload_allowed?
+            if deferred_by_di_gate?
+              # nil-default case: Symbol Database mirrors Dynamic Instrumentation
+              # and DI is not active. Record the desire and defer; resume_pending_upload
+              # re-attempts when DI is enabled. Without this gate the tracer would
+              # extract and upload symbols for applications that never enabled DI.
+              @upload_requested = true
+              @logger.debug("symdb: upload requested but Dynamic Instrumentation is not active; deferring until DI is enabled")
+            else
+              # Explicit symbol_database.enabled = false: the feature is disabled,
+              # not merely waiting on DI. Clear the desire so resume_pending_upload
+              # does not retry a disabled feature.
+              @upload_requested = false
+              @logger.debug("symdb: upload requested but symbol database upload is disabled; skipping")
+            end
+            return
+          end
+          @upload_requested = true
+
           if @owner_pid != Process.pid
             # Forked child: claim ownership and clear inherited
             # @upload_in_progress. The inherited flag was the parent's
@@ -198,34 +234,55 @@ module Datadog
           @scheduler_cv.signal
           ensure_scheduler_thread
         end
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: error scheduling upload: #{e.class}: #{e.message}" }
         @telemetry&.report(e, description: 'symdb: error scheduling upload')
       end
 
-      # Stop symbol upload (cancel the scheduler) and suppress further hot-load
-      # extraction. Called when remote config sends upload_symbols: false or
-      # deletes the config. Disables the TracePoint :class hook so post-stop
-      # class loads don't re-arm the scheduler, clears the hot-load buffer, and
-      # resets @initial_extraction_done so a future re-enable performs a fresh
-      # extract_all instead of draining an empty buffer.
+      # Stop symbol upload in response to remote config sending
+      # upload_symbols: false or deleting the config: the customer no longer wants
+      # uploads, so clear the sticky @upload_requested desire (a later
+      # resume_pending_upload must not restart it) and tear down the scheduler and
+      # hot-load hook.
       # Thread-safe: can be called concurrently from multiple remote config updates.
-      # The TracePoint teardown sits inside the same @scheduler_mutex critical
-      # section as the @scheduled_at reset, so it is atomic against a concurrent
-      # start_upload (which installs the TracePoint under @scheduler_mutex). Without
-      # that, a stop interleaved with a start could leave an enabled TracePoint
-      # rooted by the VM after stop_upload returned.
       # @return [void]
       def stop_upload
-        @scheduler_mutex.synchronize do
-          @hot_load_tracepoint&.disable
-          @hot_load_tracepoint = nil
-          @scheduled_at = nil
-          @scheduler_signaled = true
-          @scheduler_cv.signal
-        end
-        @hot_load_buffer_mutex.synchronize { @hot_load_buffer.clear }
-        @initial_extraction_done = false
+        @scheduler_mutex.synchronize { @upload_requested = false }
+        suspend_scheduling
+      end
+
+      # Re-attempt a symbol upload that remote config requested but that is not
+      # currently running because Dynamic Instrumentation was inactive — either
+      # deferred at request time, or suspended by stop_for_di_disable when DI was
+      # turned off. Called from the orchestration layer (Tracing::Remote) when DI
+      # is enabled via remote configuration (implicit enablement). No-op unless an
+      # upload was requested and not since disabled. Mirrors DI's
+      # replay_current_probes: RC does not re-dispatch the unchanged
+      # symbol-database config on DI re-enable, so the tracer restarts the upload
+      # from its own retained desire.
+      # @return [void]
+      def resume_pending_upload
+        requested = @scheduler_mutex.synchronize { @upload_requested }
+        start_upload if requested
+        nil
+      end
+
+      # Stop uploading when Dynamic Instrumentation is disabled via remote
+      # configuration. Only the nil-default (follows-DI) case stops; an explicit
+      # symbol_database.enabled = true and force_upload are independent of DI and
+      # keep running. Called from the orchestration layer (Tracing::Remote) so
+      # Symbol Database's TracePoint and scheduler don't keep uploading after DI
+      # is turned off. No-op if uploads were never started.
+      # @return [void]
+      def stop_for_di_disable
+        return if @settings.symbol_database.internal.force_upload
+        return unless @settings.symbol_database.enabled.nil?
+
+        # Suspend, don't stop: preserve @upload_requested so resume_pending_upload
+        # restarts the upload when DI is re-enabled and RC never re-sends the
+        # (unchanged) symbol-database config.
+        suspend_scheduling
       end
 
       # Block until this Component finishes an extract+upload after this call,
@@ -374,23 +431,79 @@ module Datadog
 
       private
 
-      # Check whether the runtime environment supports symbol database upload.
-      # Only MRI Ruby 2.6+ is supported. JRuby and TruffleRuby are not supported
-      # because ObjectSpace iteration and Method#source_location behave differently.
-      # Configuration accessors remain available on all platforms — this only gates
-      # the component (upload) itself.
+      # Tear down the scheduler and hot-load hook without clearing the sticky
+      # @upload_requested desire, so resume_pending_upload can restart uploads
+      # that RC still wants. Disables the TracePoint :class hook so post-stop
+      # class loads don't re-arm the scheduler, clears the hot-load buffer, and
+      # resets @initial_extraction_done so a future resume performs a fresh
+      # extract_all instead of draining an empty buffer.
+      # The TracePoint teardown sits inside the same @scheduler_mutex critical
+      # section as the @scheduled_at reset, so it is atomic against a concurrent
+      # start_upload (which installs the TracePoint under @scheduler_mutex). Without
+      # that, a stop interleaved with a start could leave an enabled TracePoint
+      # rooted by the VM after this returned.
+      # @return [void]
+      def suspend_scheduling
+        @scheduler_mutex.synchronize do
+          @hot_load_tracepoint&.disable
+          @hot_load_tracepoint = nil
+          @scheduled_at = nil
+          @scheduler_signaled = true
+          @scheduler_cv.signal
+        end
+        @hot_load_buffer_mutex.synchronize { @hot_load_buffer.clear }
+        @initial_extraction_done = false
+        nil
+      end
+
+      # Whether a remote-config-triggered upload may proceed now.
+      #
+      # force_upload and an explicit `symbol_database.enabled = true` both mean
+      # "upload regardless of Dynamic Instrumentation". Only the nil-default case
+      # — where Symbol Database mirrors DI — is gated on DI actually being active,
+      # so the tracer never extracts symbols for an application that never
+      # enabled Dynamic Instrumentation.
+      # @return [bool]
+      def upload_allowed?
+        return true if @settings.symbol_database.internal.force_upload
+
+        case @settings.symbol_database.enabled
+        when true then true
+        when false then false
+        # steep:ignore NoMethod — Steep does not narrow @di_active to non-nil after the .nil? check
+        else @di_active.nil? || @di_active.call # steep:ignore NoMethod
+        end
+      end
+
+      # Whether upload is currently blocked specifically by the nil-default
+      # DI-active gate — the only case that defers and retries via
+      # resume_pending_upload. An explicit symbol_database.enabled = false is a
+      # disabled feature, not a deferral, so it clears @upload_requested and is
+      # not retried. force_upload and explicit true are never gated, so they are
+      # never deferred.
+      # @return [bool]
+      def deferred_by_di_gate?
+        return false if @settings.symbol_database.internal.force_upload
+        return false unless @settings.symbol_database.enabled.nil?
+
+        # After the guards above, upload_allowed? reduces to the DI-active gate,
+        # so a disallowed upload here is precisely a DI-gate deferral.
+        !upload_allowed?
+      end
+
+      # Check whether the runtime environment supports symbol database upload,
+      # logging the reason when it does not.
       # @param logger [Logger]
       # @return [Boolean]
       def self.environment_supported?(logger)
+        return true if SymbolDatabase.supported_runtime?
+
         if RUBY_ENGINE != 'ruby'
           logger.debug { "symdb: not supported on #{RUBY_ENGINE}, skipping" }
-          return false
-        end
-        if RubyVersion.is?('< 2.6')
-          logger.debug { "symdb: requires Ruby 2.6+, running #{RUBY_VERSION}, skipping" }
-          return false
+        else
+          logger.debug { "symdb: requires Ruby 2.7+, running #{RUBY_VERSION}, skipping" }
         end
-        true
+        false
       end
       private_class_method :environment_supported?
 
@@ -454,7 +567,8 @@ module Datadog
 
           extract_and_upload
         end
-      rescue => e
+      rescue Exception => e # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(e)
         @logger.debug { "symdb: scheduler error: #{e.class}: #{e.message}" }
         @telemetry&.report(e, description: 'symdb: scheduler error')
       end
@@ -507,7 +621,8 @@ module Datadog
             @last_upload_scope_count = extracted_count
             @last_upload_time_cv.broadcast
           end
-        rescue => e
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           @logger.debug { "symdb: extraction error: #{e.class}: #{e.message}" }
           @telemetry&.report(e, description: 'symdb: extraction error')
           @mutex.synchronize do
@@ -557,7 +672,8 @@ module Datadog
           mod = tp.self
           next if MODULE_SINGLETON_CLASS_PRED.bind(mod).call
           component.send(:enqueue_hot_load, mod)
-        rescue => e
+        rescue Exception => e # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(e)
           # Logger or telemetry can themselves raise (custom logger
           # implementation, telemetry worker in an unexpected state). The
           # :class TracePoint fires inside customer class bodies, so the
@@ -566,7 +682,8 @@ module Datadog
           begin
             logger.debug { "symdb: hot-load hook error: #{e.class}: #{e.message}" }
             telemetry&.report(e, description: 'symdb: hot-load hook error')
-          rescue
+          rescue Exception => report_exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(report_exc)
             nil
           end
         end

data/lib/datadog/symbol_database/configuration.rb

@@ -7,11 +7,11 @@ module Datadog
       # Configuration settings for symbol database upload feature.
       #
       # Public environment variable:
-      # - DD_SYMBOL_DATABASE_UPLOAD_ENABLED (default: false) - Feature gate
+      # - DD_SYMBOL_DATABASE_UPLOAD_ENABLED - Feature gate, tri-state
+      #   (true/false/nil). See the :enabled option.
       #
       # Extended into: Core::Configuration::Settings (via extend)
       # Accessed as: Datadog.configuration.symbol_database.enabled
-      # Used by: Component.build (checks if feature enabled)
       module Settings
         # Hook called when this module is extended into a class.
         # @param base [Class, Module] The class or module being extended
@@ -28,10 +28,18 @@ module Datadog
           base.class_eval do
             # steep:ignore:start
             settings :symbol_database do
+              # @return [Boolean, nil]
+              # When nil (the default), symbol database mirrors Dynamic
+              # Instrumentation: it is advertised and built alongside DI, but
+              # only extracts and uploads symbols when DI is actually enabled
+              # (via DD_DYNAMIC_INSTRUMENTATION_ENABLED or implicit enablement
+              # through the DI UI). Set true/false explicitly via
+              # DD_SYMBOL_DATABASE_UPLOAD_ENABLED or c.symbol_database.enabled to
+              # override: true uploads regardless of DI, false disables entirely.
               option :enabled do |o|
-                o.type :bool
                 o.env 'DD_SYMBOL_DATABASE_UPLOAD_ENABLED'
-                o.default false
+                o.default nil
+                o.type :bool, nilable: true
               end
 
               # Settings in the 'internal' group are for internal Datadog

data/lib/datadog/symbol_database/extensions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration'
+require_relative 'configuration'
+
+module Datadog
+  module SymbolDatabase
+    # Registers the symbol_database settings group on core's Settings.
+    module Extensions
+      # Extends core Settings with the symbol_database settings group.
+      # @return [void]
+      def self.activate!
+        Core::Configuration::Settings.extend(Configuration::Settings)
+      end
+    end
+  end
+end
+
+Datadog::SymbolDatabase::Extensions.activate!