datadog 2.33.0 → 2.34.0

data/lib/datadog/opentelemetry/metrics.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
 require_relative '../core/configuration/ext'
-require_relative '../core/environment/socket'
+require_relative 'ext'
+require_relative 'signal_configuration'
 
 module Datadog
   module OpenTelemetry
     class Metrics
-      EXPORTER_NONE = 'none'
+      include SignalConfiguration
 
       def self.initialize!(components)
         new(components).configure_metrics_sdk
         true
       rescue => exc
-        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
+        components.logger.warn("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
         false
       end
 
@@ -41,38 +42,9 @@ module Datadog
 
       private
 
-      def create_resource
-        resource_attributes = {}
-
-        @settings.tags&.each do |key, value|
-          otel_key = case key
-          when 'service' then 'service.name'
-          when 'env' then 'deployment.environment'
-          when 'version' then 'service.version'
-          else key
-          end
-          resource_attributes[otel_key] = value
-        end
-
-        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
-        resource_attributes['deployment.environment'] = @settings.env if @settings.env
-        resource_attributes['service.version'] = @settings.version if @settings.version
-
-        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings)
-        if hostname
-          if hostname == @settings.hostname
-            resource_attributes['host.name'] = hostname
-          elsif !resource_attributes.key?('host.name')
-            resource_attributes['host.name'] = hostname
-          end
-        end
-
-        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
-      end
-
       def configure_metric_reader(provider)
         exporter_name = @settings.opentelemetry.metrics.exporter
-        return if exporter_name == EXPORTER_NONE
+        return if exporter_name == Ext::EXPORTER_NONE
 
         configure_otlp_exporter(provider)
       rescue => e
@@ -88,15 +60,16 @@ module Datadog
         require_relative 'sdk/metrics_exporter'
 
         metrics_config = @settings.opentelemetry.metrics
-        endpoint = get_metrics_config_with_fallback(
+        endpoint = config_or_exporter_fallback(
+          signal: :metrics,
           option_name: :endpoint,
           computed_default: default_metrics_endpoint
         )
-        timeout = get_metrics_config_with_fallback(option_name: :timeout_millis)
-        headers = get_metrics_config_with_fallback(option_name: :headers)
+        timeout = config_or_exporter_fallback(signal: :metrics, option_name: :timeout_millis)
+        headers = config_or_exporter_fallback(signal: :metrics, option_name: :headers)
         # OpenTelemetry SDK only supports http/protobuf protocol.
         # TODO: Add support for http/json and grpc.
-        # protocol = get_metrics_config_with_fallback(option_name: :protocol)
+        # protocol = config_or_exporter_fallback(signal: :metrics, option_name: :protocol)
         exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
           endpoint: endpoint,
           timeout: timeout / 1000.0,
@@ -112,15 +85,6 @@ module Datadog
       rescue LoadError => e
         @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
-
-      # Returns metrics config value if explicitly set, otherwise falls back to exporter config or computed default value.
-      def get_metrics_config_with_fallback(option_name:, computed_default: nil)
-        if @settings.opentelemetry.metrics.using_default?(option_name)
-          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
-        else
-          @settings.opentelemetry.metrics.public_send(option_name)
-        end
-      end
     end
   end
 end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -30,6 +30,16 @@ module Datadog
           [SpanProcessor.new]
         end
 
+        # SDK 1.6.0+ calls logs_configuration_hook from configure.
+        # https://github.com/open-telemetry/opentelemetry-ruby/blob/opentelemetry-sdk/v1.6.0/sdk/lib/opentelemetry/sdk/configurator.rb#L152
+        # Older supported SDK versions do not, so we call it explicitly as a fallback.
+        # The flag prevents double-calling on newer SDK versions.
+        def configure
+          @datadog_logs_hook_called = false
+          super
+          logs_configuration_hook unless @datadog_logs_hook_called
+        end
+
         def metrics_configuration_hook
           components = Datadog.send(:components)
           return super unless components.settings.opentelemetry.metrics.enabled
@@ -45,15 +55,45 @@ module Datadog
           super unless success
         end
 
+        def logs_configuration_hook
+          @datadog_logs_hook_called = true
+          components = Datadog.send(:components)
+          unless components.settings.opentelemetry.logs.enabled
+            super if defined?(super)
+            return
+          end
+
+          begin
+            require 'opentelemetry-logs-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry logs gems: #{exc.class}: #{exc.message}")
+            return
+          end
+
+          success = Datadog::OpenTelemetry::Logs.initialize!(components)
+          unless success
+            components.logger.warn('Falling back to OpenTelemetry default logs configuration')
+            super if defined?(super)
+          end
+        end
+
         # Prepend to ConfiguratorPatch (not Configurator) so our hook runs first.
         begin
           require 'opentelemetry-metrics-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
         rescue LoadError
         end
 
+        begin
+          require 'opentelemetry-logs-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Logs::ConfiguratorPatch)
+        rescue LoadError
+        end
+
         if defined?(::OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
           ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.ancestors.include?(self)
         end
+        if defined?(::OpenTelemetry::SDK::Logs::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Logs::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Logs::ConfiguratorPatch.ancestors.include?(self)
+        end
         ::OpenTelemetry::SDK::Configurator.prepend(self) unless ::OpenTelemetry::SDK::Configurator.ancestors.include?(self)
       end
     end

data/lib/datadog/opentelemetry/sdk/logs_exporter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_logs'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class LogsExporter < ::OpenTelemetry::Exporter::OTLP::Logs::LogsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.logs_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.logs_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.logs_export_failures'
+        METRIC_LOG_RECORDS = 'otel.log_records'
+        TELEMETRY_NAMESPACE = 'tracers'
+        TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
+
+        def export(log_records, timeout: nil)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_LOG_RECORDS, log_records.size, tags: TELEMETRY_TAGS)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
+          result
+        rescue => e
+          Datadog.logger.warn("Failed to export OpenTelemetry Logs: #{e.class}: #{e.message}")
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
+          raise
+        end
+
+        private
+
+        def telemetry
+          Datadog.send(:components).telemetry
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+require_relative '../core/environment/socket'
+
+module Datadog
+  module OpenTelemetry
+    # Shared resource building and signal-specific config fallback logic for Logs and Metrics.
+    module SignalConfiguration
+      private
+
+      def create_resource
+        resource_attributes = {}
+
+        @settings.tags&.each do |key, value| # steep:ignore
+          otel_key = case key
+          when 'service' then 'service.name'
+          when 'env' then 'deployment.environment'
+          when 'version' then 'service.version'
+          else key
+          end
+          resource_attributes[otel_key] = value
+        end
+
+        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME # steep:ignore
+        resource_attributes['deployment.environment'] = @settings.env if @settings.env # steep:ignore
+        resource_attributes['service.version'] = @settings.version if @settings.version # steep:ignore
+
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        if hostname
+          if hostname == @settings.hostname # steep:ignore
+            resource_attributes['host.name'] = hostname
+          elsif !resource_attributes.key?('host.name')
+            resource_attributes['host.name'] = hostname
+          end
+        end
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      # Returns the signal-specific option value when explicitly set,
+      # otherwise falls back to the general OTLP exporter config or computed_default.
+      def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
+        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        if signal_settings.using_default?(option_name)
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+        else
+          signal_settings.public_send(option_name)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -23,6 +23,7 @@ require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK
 require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
 require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+require_relative 'opentelemetry/logs' if defined?(OpenTelemetry::SDK::Logs)
 
 module Datadog
   # Datadog OpenTelemetry integration.

data/lib/datadog/symbol_database/component.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require_relative 'extractor'
+require_relative 'logger'
+require_relative 'scope_batcher'
+require_relative 'uploader'
+require_relative '../core/utils/time'
+
+module Datadog
+  module SymbolDatabase
+    # Main coordinator for symbol database upload functionality.
+    #
+    # Responsibilities:
+    # - Lifecycle management: Initialization, shutdown, upload triggering
+    # - Coordination: Connects Extractor → ScopeBatcher → Uploader
+    # - Remote config handling: start_upload called by Remote module on config changes
+    # - Debounce: extraction is deferred by EXTRACT_DEBOUNCE_INTERVAL seconds so
+    #   reconfigurations during boot coalesce into a single extraction on the
+    #   final Component instance.
+    #
+    # Upload flow:
+    # 1. Remote config sends upload_symbols: true (or force_upload mode)
+    # 2. start_upload called — schedules extraction EXTRACT_DEBOUNCE_INTERVAL
+    #    seconds in the future on a per-instance scheduler thread.
+    # 3. When the timer fires (no further start_upload calls reset it),
+    #    extract_and_upload runs: ObjectSpace iteration → Extractor → ScopeBatcher.
+    # 4. ScopeBatcher batches and triggers Uploader.
+    # 5. A class-level flag is set so subsequent Component instances created via
+    #    Datadog reconfiguration do not re-upload.
+    #
+    # Created by: Components#initialize (in Core::Configuration::Components)
+    # Accessed by: Remote config receiver via Datadog.send(:components).symbol_database
+    # Requires: Remote config enabled (unless force mode)
+    #
+    # @api private
+    class Component
+      # Debounce window for extraction. Multiple start_upload calls within this
+      # window coalesce; the timer fires once after the window of inactivity.
+      # Long enough to absorb reconfiguration cascades during Rails boot.
+      EXTRACT_DEBOUNCE_INTERVAL = 5  # seconds
+
+      # Class-level state: tracks whether any Component instance in this process
+      # has performed an extract+upload. Survives Component replacement during
+      # Datadog reconfiguration so duplicate uploads are prevented.
+      @uploaded_this_process = false
+      @upload_done_mutex = Mutex.new
+      @upload_done_cv = ConditionVariable.new
+
+      class << self
+        attr_reader :upload_done_mutex, :upload_done_cv
+
+        # Whether any Component instance in this process has completed an
+        # upload. Cross-instance flag — used to dedupe uploads across
+        # Component rebuilds within a single Ruby process.
+        # @return [Boolean]
+        def uploaded_this_process?
+          @upload_done_mutex.synchronize { @uploaded_this_process }
+        end
+
+        # Mark the current process as having completed a symbol upload.
+        # Called by the Component instance that successfully completes an
+        # upload; subsequent start_upload calls on any instance short-circuit.
+        # @return [void]
+        def mark_uploaded
+          @upload_done_mutex.synchronize do
+            @uploaded_this_process = true
+            @upload_done_cv.broadcast
+          end
+        end
+
+        # Reset class-level upload state. Test-only.
+        # @api private
+        def reset_uploaded_this_process_for_tests!
+          @upload_done_mutex.synchronize { @uploaded_this_process = false }
+        end
+      end
+
+      # Build a new Component if feature is enabled and dependencies met.
+      # @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)
+        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+.
+        # 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.
+        return nil unless environment_supported?(symdb_logger)
+
+        # Requires remote config (unless force mode)
+        if !settings.remote&.enabled && !settings.symbol_database.internal.force_upload
+          symdb_logger.debug("symdb: remote config not available and force_upload not set, skipping")
+          return nil
+        end
+
+        new(settings, agent_settings, symdb_logger, telemetry: telemetry).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
+      end
+
+      attr_reader :settings, :logger, :last_upload_time, :last_upload_scope_count, :upload_in_progress
+
+      # Initialize component.
+      # @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
+      def initialize(settings, agent_settings, logger, telemetry: nil)
+        @settings = settings
+        @agent_settings = agent_settings
+        @logger = logger
+        @telemetry = telemetry
+
+        @extractor = Extractor.new(logger: logger, settings: settings)
+        @uploader = Uploader.new(settings: settings, agent_settings: agent_settings, logger: logger, telemetry: telemetry)
+        @scope_batcher = ScopeBatcher.new(@uploader, logger: logger)
+
+        @last_upload_time = nil
+        @last_upload_scope_count = nil
+        @mutex = Mutex.new
+        @upload_in_progress = false
+        @upload_in_progress_cv = ConditionVariable.new
+        @shutdown = false
+
+        # Per-instance scheduler state. The scheduler thread is started lazily
+        # on the first start_upload call.
+        @scheduler_mutex = Mutex.new
+        @scheduler_cv = ConditionVariable.new
+        @scheduled_at = nil
+        @scheduler_signaled = false
+        @scheduler_thread = nil
+      end
+
+      # Schedule a deferred upload that waits for app boot to complete.
+      #
+      # In Rails: registers ActiveSupport.on_load(:after_initialize). When the
+      # hook has already fired (e.g., this Component was built by a reconfigure
+      # after Rails finished initializing), the callback runs immediately.
+      #
+      # In non-Rails: triggers start_upload immediately.
+      #
+      # Each Component registers its own callback. Old Components that have
+      # been shut down short-circuit in start_upload via @shutdown.
+      # Cross-process deduplication is handled by the class-level
+      # uploaded_this_process? flag, not by guarding registration.
+      #
+      # @return [void]
+      def schedule_deferred_upload
+        if defined?(::ActiveSupport) && defined?(::Rails::Railtie)
+          # Capture self — on_load runs the block via instance_exec on the
+          # loaded object (Rails::Application), so a bare `start_upload`
+          # would resolve against it.
+          component = self
+          logger = @logger
+          ::ActiveSupport.on_load(:after_initialize) do
+            # Only auto-trigger when Rails has eager-loaded application
+            # classes during initialization. In dev (eager_load=false)
+            # there is nothing complete to extract; the auto-deferred
+            # upload would race with explicit triggers and produce
+            # under-extracted uploads.
+            if defined?(::Rails) && ::Rails.application&.config&.eager_load # steep:ignore NoMethod
+              component.start_upload
+            else
+              logger.debug { "symdb: skipping auto-deferred upload (eager_load disabled)" }
+            end
+          end
+        else
+          start_upload
+        end
+      end
+
+      # Whether this component has been shut down.
+      # @return [Boolean]
+      def shutdown?
+        @scheduler_mutex.synchronize { @shutdown }
+      end
+
+      # Schedule symbol upload (triggered by remote config or force mode).
+      # The actual extraction is debounced by EXTRACT_DEBOUNCE_INTERVAL seconds —
+      # subsequent calls within the window restart the timer.
+      # Thread-safe: can be called concurrently from multiple remote config updates.
+      # @return [void]
+      def start_upload
+        return if Component.uploaded_this_process?
+
+        @scheduler_mutex.synchronize do
+          return if @shutdown
+
+          @scheduled_at = Datadog::Core::Utils::Time.get_time + EXTRACT_DEBOUNCE_INTERVAL
+          @scheduler_signaled = true
+          @scheduler_cv.signal
+          ensure_scheduler_thread
+        end
+      rescue => 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).
+      # Thread-safe: can be called concurrently from multiple remote config updates.
+      # @return [void]
+      def stop_upload
+        @scheduler_mutex.synchronize do
+          @scheduled_at = nil
+          @scheduler_signaled = true
+          @scheduler_cv.signal
+        end
+      end
+
+      # Block until any Component in this process has finished an extract+upload,
+      # or until the timeout elapses. Used by short-lived scripts that trigger
+      # an upload via force_upload and need to wait before exiting.
+      # @param timeout [Numeric] Maximum seconds to wait
+      # @return [Boolean] true if an upload completed; false on timeout
+      def wait_for_idle(timeout: 30)
+        deadline = Datadog::Core::Utils::Time.get_time + timeout
+        Component.upload_done_mutex.synchronize do
+          # Read @uploaded_this_process directly: we already hold
+          # Component.upload_done_mutex here, and uploaded_this_process?
+          # would try to re-acquire it (non-reentrant), deadlocking.
+          until Component.instance_variable_get(:@uploaded_this_process)
+            remaining = deadline - Datadog::Core::Utils::Time.get_time
+            return false if remaining <= 0
+            Component.upload_done_cv.wait(Component.upload_done_mutex, remaining)
+          end
+        end
+        true
+      end
+
+      # Shutdown component and cleanup resources.
+      # Cancels the per-instance scheduler so any pending debounced extraction
+      # is dropped. Waits for an in-flight extraction to complete before
+      # returning. Does not touch class-level state, so a sibling Component
+      # built after shutdown can still upload.
+      # @return [void]
+      def shutdown!
+        @scheduler_mutex.synchronize do
+          @shutdown = true
+          @scheduler_signaled = true
+          @scheduler_cv.signal
+        end
+        @scheduler_thread&.join(5)
+        @scheduler_thread = nil
+
+        @mutex.synchronize do
+          if @upload_in_progress
+            @upload_in_progress_cv.wait(@mutex, 5)
+          end
+        end
+
+        @scope_batcher.shutdown
+      end
+
+      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.
+      # @param logger [Logger]
+      # @return [Boolean]
+      def self.environment_supported?(logger)
+        if RUBY_ENGINE != 'ruby'
+          logger.debug { "symdb: not supported on #{RUBY_ENGINE}, skipping" }
+          return false
+        end
+        if RUBY_VERSION < '2.6'
+          logger.debug { "symdb: requires Ruby 2.6+, running #{RUBY_VERSION}, skipping" }
+          return false
+        end
+        true
+      end
+      private_class_method :environment_supported?
+
+      # Start the scheduler thread if not already running.
+      # Must be called from within @scheduler_mutex.synchronize.
+      # @return [void]
+      def ensure_scheduler_thread
+        return if @scheduler_thread&.alive?
+        @scheduler_thread = Thread.new { scheduler_loop }
+      end
+
+      # Scheduler thread main loop. Waits for the debounce window to elapse,
+      # then runs extract_and_upload exactly once for this Component.
+      # @return [void]
+      def scheduler_loop
+        loop do
+          # should_fire = true means the debounce deadline elapsed without further
+          # signals; extract_and_upload runs once after the mutex is released.
+          should_fire = false
+
+          @scheduler_mutex.synchronize do
+            return if @shutdown
+            return if Component.uploaded_this_process?
+
+            # Copy to local so Steep narrows `Float?` to `Float` in the else branch.
+            # Steep does not track narrowing on instance variables across nil checks.
+            scheduled_at = @scheduled_at
+            if scheduled_at.nil?
+              # Nothing scheduled (e.g. stop_upload cleared it). Wait
+              # indefinitely for a signal, then re-evaluate on next loop.
+              @scheduler_signaled = false
+              @scheduler_cv.wait(@scheduler_mutex)
+            else
+              remaining = scheduled_at - Datadog::Core::Utils::Time.get_time
+              if remaining > 0
+                # Wait until the debounce deadline. Any signal (start_upload,
+                # stop_upload, shutdown!) wakes us early; we always re-loop
+                # and recompute rather than firing immediately on wake.
+                @scheduler_signaled = false
+                @scheduler_cv.wait(@scheduler_mutex, remaining)
+              else
+                # Deadline elapsed without further signal — fire after releasing the mutex.
+                should_fire = true
+              end
+            end
+          end
+
+          # `next` inside `synchronize` only exits the synchronize block — not the
+          # surrounding loop. Use an explicit flag so the loop only fires
+          # extract_and_upload when the debounce deadline has actually elapsed.
+          next unless should_fire
+
+          # Outside the mutex.
+          return if @shutdown
+          if Component.uploaded_this_process?
+            return
+          end
+
+          extract_and_upload
+          Component.mark_uploaded
+          return
+        end
+      rescue => e
+        @logger.debug { "symdb: scheduler error: #{e.class}: #{e.message}" }
+        @telemetry&.report(e, description: 'symdb: scheduler error')
+      end
+
+      # Extract symbols from all loaded modules and upload.
+      # @return [void]
+      def extract_and_upload
+        @mutex.synchronize { @upload_in_progress = true }
+
+        begin
+          @logger.trace { "symdb: starting extraction and upload" }
+          start_time = Datadog::Core::Utils::Time.get_time
+
+          # Extract symbols from all loaded modules grouped by source file.
+          # extract_all handles ObjectSpace iteration, filtering, and FQN-based nesting.
+          file_scopes = @extractor.extract_all
+          extracted_count = 0
+          file_scopes.each do |scope|
+            @scope_batcher.add_scope(scope)
+            extracted_count += 1
+            log_scope_tree(scope, 0)
+          end
+
+          @logger.debug do
+            extraction_duration = Datadog::Core::Utils::Time.get_time - start_time
+            targetable_count = count_targetable_methods(file_scopes)
+            "symdb: extracted #{extracted_count} scopes (#{targetable_count} methods with targetable lines) in #{'%.2f' % extraction_duration}s"
+          end
+
+          # Flush any remaining scopes (triggers upload)
+          @scope_batcher.flush
+
+          @last_upload_time = Datadog::Core::Utils::Time.now
+          @last_upload_scope_count = extracted_count
+        rescue => e
+          @logger.debug { "symdb: extraction error: #{e.class}: #{e.message}" }
+          @telemetry&.report(e, description: 'symdb: extraction error')
+        ensure
+          @mutex.synchronize do
+            @upload_in_progress = false
+            @upload_in_progress_cv.signal
+          end
+        end
+      end
+
+      def log_scope_tree(scope, depth)
+        indent = '  ' * depth
+        @logger.trace { "symdb:   #{indent}#{scope.scope_type} #{scope.name}" }
+        scope.scopes&.each { |child| log_scope_tree(child, depth + 1) }
+      end
+
+      def count_targetable_methods(file_scopes)
+        count = 0
+        file_scopes.each do |file_scope|
+          file_scope.scopes&.each do |class_or_module|
+            class_or_module.scopes&.each do |method_scope|
+              count += 1 if method_scope.scope_type == 'METHOD' && method_scope.targetable_lines?
+            end
+          end
+        end
+        count
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/configuration.rb

@@ -7,7 +7,7 @@ module Datadog
       # Configuration settings for symbol database upload feature.
       #
       # Public environment variable:
-      # - DD_SYMBOL_DATABASE_UPLOAD_ENABLED (default: true) - Feature gate
+      # - DD_SYMBOL_DATABASE_UPLOAD_ENABLED (default: false) - Feature gate
       #
       # Extended into: Core::Configuration::Settings (via extend)
       # Accessed as: Datadog.configuration.symbol_database.enabled
@@ -31,7 +31,7 @@ module Datadog
               option :enabled do |o|
                 o.type :bool
                 o.env 'DD_SYMBOL_DATABASE_UPLOAD_ENABLED'
-                o.default true
+                o.default false
               end
 
               # Settings in the 'internal' group are for internal Datadog