datadog 2.39.0 → 2.47.0

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

@@ -14,6 +14,7 @@ module Datadog
           "DD_AI_GUARD_ENDPOINT",
           "DD_AI_GUARD_MAX_CONTENT_SIZE",
           "DD_AI_GUARD_MAX_MESSAGES_LENGTH",
+          "DD_AI_GUARD_REDACTION_ENABLED",
           "DD_AI_GUARD_TIMEOUT",
           "DD_API_KEY",
           "DD_API_SECURITY_DOWNSTREAM_BODY_ANALYSIS_SAMPLE_RATE",
@@ -24,6 +25,7 @@ module Datadog
           "DD_API_SECURITY_REQUEST_SAMPLE_RATE",
           "DD_API_SECURITY_SAMPLE_DELAY",
           "DD_APM_TRACING_ENABLED",
+          "DD_APPSEC_AGENTIC_ONBOARDING",
           "DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING",
           "DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE",
           "DD_APPSEC_BODY_PARSING_SIZE_LIMIT",
@@ -49,6 +51,7 @@ module Datadog
           "DD_DBM_INJECT_SQL_BASEHASH",
           "DD_DBM_PROPAGATION_MODE",
           "DD_DISABLE_DATADOG_RAILS",
+          "DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS",
           "DD_DYNAMIC_INSTRUMENTATION_ENABLED",
           "DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE",
           "DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE",
@@ -59,9 +62,17 @@ module Datadog
           "DD_ERROR_TRACKING_HANDLED_ERRORS",
           "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE",
           "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED",
+          "DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS",
           "DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED",
+          "DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED",
           "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED",
           "DD_EXTERNAL_ENV",
+          "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE",
+          "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL",
+          "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS",
+          "DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS",
+          "DD_FEATURE_FLAGS_ENABLED",
+          "DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED",
           "DD_FLAGGING_EVALUATION_COUNTS_ENABLED",
           "DD_GIT_COMMIT_SHA",
           "DD_GIT_REPOSITORY_URL",
@@ -85,6 +96,7 @@ module Datadog
           "DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED",
           "DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE",
           "DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED",
+          "DD_PROFILING_EXPERIMENTAL_SHOW_CLASSES_ENABLED",
           "DD_PROFILING_EXPERIMENTAL_USE_SYSTEM_DNS",
           "DD_PROFILING_GC_ENABLED",
           "DD_PROFILING_GVL_ENABLED",
@@ -231,6 +243,7 @@ module Datadog
           "DD_TRACE_HTTP_ANALYTICS_ENABLED",
           "DD_TRACE_HTTP_ANALYTICS_SAMPLE_RATE",
           "DD_TRACE_HTTP_CLIENT_ERROR_STATUSES",
+          "DD_TRACE_HTTP_CLIENT_RESOURCE_NAME_QUANTIZE",
           "DD_TRACE_HTTP_DISTRIBUTED_TRACING",
           "DD_TRACE_HTTP_ENABLED",
           "DD_TRACE_HTTP_ERROR_STATUS_CODES",
@@ -263,6 +276,7 @@ module Datadog
           "DD_TRACE_OPENSEARCH_PEER_SERVICE",
           "DD_TRACE_OPENSEARCH_RESOURCE_PATTERN",
           "DD_TRACE_OPENSEARCH_SERVICE_NAME",
+          "DD_TRACE_OTEL_CTX_ENABLED",
           "DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED",
           "DD_TRACE_PEER_SERVICE_MAPPING",
           "DD_TRACE_PG_ANALYTICS_ENABLED",
@@ -388,6 +402,7 @@ module Datadog
 
       ALIASES =
         {"DD_DISABLE_DATADOG_RAILS" => ["DISABLE_DATADOG_RAILS"],
+         "DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS" => ["DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT"],
          "DD_PROFILING_GVL_ENABLED" => ["DD_PROFILING_PREVIEW_GVL_ENABLED"],
          "DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED" => ["DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED"],
          "DD_SERVICE" => ["OTEL_SERVICE_NAME"],
@@ -398,10 +413,11 @@ module Datadog
          "DD_TRACE_SAMPLE_RATE" => ["OTEL_TRACES_SAMPLER"]}.freeze
 
       DEPRECATIONS =
-        Set["DD_PROFILING_PREVIEW_GVL_ENABLED", "DISABLE_DATADOG_RAILS"]
+        Set["DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT", "DD_PROFILING_PREVIEW_GVL_ENABLED", "DISABLE_DATADOG_RAILS"]
 
       ALIAS_TO_CANONICAL =
-        {"DD_PROFILING_PREVIEW_GVL_ENABLED" => "DD_PROFILING_GVL_ENABLED",
+        {"DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT" => "DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS",
+         "DD_PROFILING_PREVIEW_GVL_ENABLED" => "DD_PROFILING_GVL_ENABLED",
          "DD_TRACE_EXPERIMENTAL_RUNTIME_ID_ENABLED" => "DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED",
          "DISABLE_DATADOG_RAILS" => "DD_DISABLE_DATADOG_RAILS",
          "OTEL_LOG_LEVEL" => "DD_TRACE_DEBUG",

data/lib/datadog/core/crashtracking/component.rb

@@ -44,7 +44,11 @@ module Datadog
         # Reports unhandled exceptions to the crash tracker if available and appropriate.
         # This is called from the at_exit hook to report unhandled exceptions.
         def self.report_unhandled_exception(exception)
-          return unless exception && !exception.is_a?(SystemExit) && !exception.is_a?(NoMemoryError)
+          return unless exception &&
+            !exception.is_a?(SystemExit) &&
+            !exception.is_a?(SignalException) &&
+            !exception.is_a?(NoMemoryError) &&
+            !exception.is_a?(SystemStackError)
 
           begin
             crashtracker = Datadog.send(:components, allow_initialization: false)&.crashtracker

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

@@ -75,7 +75,10 @@ module Datadog
               tags: tags,
               runtime_metrics_enabled: runtime_metrics_enabled,
               vm: vm,
-              health_metrics_enabled: health_metrics_enabled
+              health_metrics_enabled: health_metrics_enabled,
+              otlp_traces_export_enabled: otlp_traces_export_enabled,
+              otlp_metrics_export_enabled: otlp_metrics_export_enabled,
+              otlp_logs_export_enabled: otlp_logs_export_enabled,
             }
           end
 
@@ -159,8 +162,40 @@ module Datadog
             !!Datadog.configuration.health_metrics.enabled
           end
 
+          # @return [Boolean] whether the tracer exports traces over OTLP.
+          #   Always false: Ruby exports spans in Datadog's native format and has no OTLP trace exporter.
+          def otlp_traces_export_enabled
+            false
+          end
+
+          # @return [Boolean] whether the tracer exports metrics over OTLP
+          def otlp_metrics_export_enabled
+            metrics = opentelemetry_settings&.metrics
+            # A "none" exporter skips the OTLP metric reader even when metrics are enabled
+            # (mirrors Datadog::OpenTelemetry::Ext::EXPORTER_NONE).
+            !!(metrics&.enabled && metrics.exporter != "none")
+          end
+
+          # @return [Boolean] whether the tracer exports logs over OTLP
+          def otlp_logs_export_enabled
+            logs = opentelemetry_settings&.logs
+            # A "none" exporter skips the OTLP log record processor even when logs are enabled
+            # (mirrors Datadog::OpenTelemetry::Ext::EXPORTER_NONE).
+            !!(logs&.enabled && logs.exporter != "none")
+          end
+
           private
 
+          # The `opentelemetry` settings namespace is registered by core configuration, but access it
+          # defensively so a missing/unregistered namespace defaults to `false` rather than raising.
+          def opentelemetry_settings
+            return unless Datadog.configuration.respond_to?(:opentelemetry)
+
+            Datadog.configuration.opentelemetry
+          rescue
+            nil
+          end
+
           # Outputs "k1:v1,k2:v2,..."
           def hash_serializer(h)
             h.map { |k, v| "#{k}:#{v}" }.join(",")

data/lib/datadog/core/environment/gc.rb

@@ -12,7 +12,7 @@ module Datadog
         end
 
         def available?
-          defined?(::GC) && ::GC.respond_to?(:stat)
+          !!(defined?(::GC) && ::GC.respond_to?(:stat))
         end
       end
     end

data/lib/datadog/core/environment/vm_cache.rb

@@ -56,7 +56,7 @@ module Datadog
         end
 
         def available?
-          defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
+          !!(defined?(::RubyVM) && ::RubyVM.respond_to?(:stat))
         end
       end
     end

data/lib/datadog/core/environment/yjit.rb

@@ -59,9 +59,9 @@ module Datadog
         end
 
         def available?
-          defined?(::RubyVM::YJIT) \
+          !!(defined?(::RubyVM::YJIT) \
             && ::RubyVM::YJIT.enabled? \
-            && ::RubyVM::YJIT.respond_to?(:runtime_stats)
+            && ::RubyVM::YJIT.respond_to?(:runtime_stats))
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Datadog
           :distribution,
           :increment,
           :gauge,
-          :time
+          :time,
         ].each do |metric_type|
           define_method(metric_type) do |name, stat|
             name = name.to_sym

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

@@ -16,8 +16,8 @@ module Datadog
             "#{Ext::TAG_LANG_VERSION}:#{Environment::Identity.lang_version}",
             # TODO: Technically not accurate, if tracing version diverges from datadog gem version
             #       If we extract tracing to its own gem, this needs to be updated.
-            "#{Ext::TAG_TRACER_VERSION}:#{Environment::Identity.gem_datadog_version}"
-          ].freeze
+            "#{Ext::TAG_TRACER_VERSION}:#{Environment::Identity.gem_datadog_version}",
+          ].freeze,
         }.freeze
 
         def metric_options(options = nil)

data/lib/datadog/core/process_discovery.rb

@@ -23,7 +23,11 @@ module Datadog
           metadata = get_metadata(settings)
 
           shutdown!
-          @file_descriptor = _native_store_tracer_metadata(Datadog.logger, **metadata)
+          @file_descriptor = _native_store_tracer_metadata(
+            Datadog.logger,
+            settings.tracing.otel_thread_context_enabled,
+            **metadata
+          )
         end
 
         def shutdown!
@@ -53,7 +57,7 @@ module Datadog
             service_version: settings.version || "",
             # Follows Java: https://github.com/DataDog/dd-trace-java/blob/2ebc964340ac530342cc389ba68ff0f5070d5f9f/dd-trace-core/src/main/java/datadog/trace/core/servicediscovery/ServiceDiscovery.java#L37-L38
             process_tags: settings.experimental_propagate_process_tags_enabled ? Core::Environment::Process.serialized : "",
-            container_id: Core::Environment::Container.container_id || ""
+            container_id: Core::Environment::Container.container_id || "",
           }
         end
       end

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

@@ -6,7 +6,6 @@ require_relative "../../../tracing/remote"
 require_relative "../../../di/remote"
 require_relative "../../../symbol_database"
 require_relative "../../../symbol_database/remote"
-require_relative "../../../open_feature/remote"
 
 module Datadog
   module Core
@@ -14,33 +13,51 @@ module Datadog
       class Client
         # Capabilities
         class Capabilities
-          attr_reader :capabilities, :receivers, :base64_capabilities
-
-          def initialize(settings, telemetry)
+          def initialize(settings, telemetry:)
             @capabilities = []
             @products = []
-            @products_mutex = Mutex.new
             @receivers = []
             @telemetry = telemetry
+            @mutex = Mutex.new
 
             register(settings)
 
-            @base64_capabilities = capabilities_to_base64
+            @base64_capabilities = capabilities_to_base64(@capabilities)
+          end
+
+          def capabilities
+            @mutex.synchronize { @capabilities.dup }
           end
 
           def products
-            @products_mutex.synchronize { @products.dup }
+            @mutex.synchronize { @products.dup }
           end
 
-          def add_products(*products)
-            @products_mutex.synchronize do
-              products.each { |product| @products << product unless @products.include?(product) }
+          def receivers
+            @mutex.synchronize { @receivers.dup }
+          end
+
+          def base64_capabilities
+            @mutex.synchronize { @base64_capabilities }
+          end
+
+          def register_runtime(capabilities:, products:, receivers:)
+            @mutex.synchronize do
+              register_capabilities(capabilities)
+              register_products(products)
+              register_receivers(receivers)
+              @base64_capabilities = capabilities_to_base64(@capabilities)
             end
             nil
           end
 
+          def add_products(*products)
+            @mutex.synchronize { register_products(products) }
+            nil
+          end
+
           def remove_products(*products)
-            @products_mutex.synchronize { products.each { |product| @products.delete(product) } }
+            @mutex.synchronize { products.each { |product| @products.delete(product) } }
             nil
           end
 
@@ -94,27 +111,21 @@ module Datadog
                 end
               end
             end
-
-            if settings.respond_to?(:open_feature) && settings.open_feature.enabled
-              register_capabilities(Datadog::OpenFeature::Remote.capabilities)
-              register_products(Datadog::OpenFeature::Remote.products)
-              register_receivers(Datadog::OpenFeature::Remote.receivers(@telemetry))
-            end
           end
 
           def register_capabilities(capabilities)
-            @capabilities.concat(capabilities)
+            capabilities.each { |capability| @capabilities << capability unless @capabilities.include?(capability) }
           end
 
           def register_receivers(receivers)
-            @receivers.concat(receivers)
+            receivers.each { |receiver| @receivers << receiver unless @receivers.include?(receiver) }
           end
 
           def register_products(products)
-            @products.concat(products)
+            products.each { |product| @products << product unless @products.include?(product) }
           end
 
-          def capabilities_to_base64
+          def capabilities_to_base64(capabilities)
             return "" if capabilities.empty?
 
             cap_to_hexs = capabilities.reduce(:|).to_s(16).tap { |s| s.size.odd? && s.prepend("0") }.scan(/\h\h/)

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

@@ -16,6 +16,12 @@ module Datadog
 
         attr_reader :transport, :repository, :id, :dispatcher, :settings, :logger
 
+        # Whether the initial reconcile is still pending, to run on the first
+        # sync whose response contains targets.
+        #
+        # @return [Boolean]
+        attr_reader :pending_initial_reconcile
+
         def initialize(transport, capabilities, settings:, logger:, repository: Configuration::Repository.new)
           @transport = transport
           @settings = settings
@@ -25,27 +31,52 @@ module Datadog
           @id = SecureRandom.uuid
           @capabilities = capabilities
           @dispatcher = Dispatcher.new(@capabilities.receivers)
+          @pending_initial_reconcile = true
         end
 
+        # Polls the agent for remote configuration, applies the response to
+        # the repository and dispatches the resulting changes to the receivers.
+        #
+        # The agent sends an empty response when it holds no targets newer
+        # than the targets version the client reported. Until the client
+        # applies a response that carries targets, it reports the initial
+        # targets version, so an empty response then means the agent has not
+        # received targets from the backend. The initial reconcile therefore
+        # waits for a response that carries targets.
+        #
+        # @return [void]
+        # @raise [TransportError] when the agent reports an internal error
+        # @raise [SyncError] when the response cannot be applied to the repository
         def sync
           # TODO: Skip sync if no capabilities are registered
           response = transport.send_config(payload)
 
           if response.ok?
-            process_response(response)
+            changes = process_response(response)
+            if pending_initial_reconcile && !response.empty?
+              dispatcher.reconcile(changes, repository)
+              @pending_initial_reconcile = false
+            end
           elsif response.internal_error?
             raise TransportError, response.to_s
           end
+          nil
         end
 
         private
 
+        # Applies an OK response to the repository and returns the resulting
+        # change set, which is empty when the response is empty.
+        #
+        # @param response [Transport::Config::Response] the response returned by the agent
+        # @return [Configuration::Repository::ChangeSet] the changes applied by this response
+        # @raise [SyncError] when the response cannot be applied to the repository
         def process_response(response)
           # when response is completely empty, do nothing as in: leave as is
           if response.empty?
             logger.debug { "remote: empty response => NOOP" }
 
-            return
+            return Configuration::Repository::ChangeSet.new
           end
 
           begin
@@ -61,7 +92,7 @@ module Datadog
           end
 
           # To make sure steep does not complain
-          return unless paths && targets && contents
+          return Configuration::Repository::ChangeSet.new unless paths && targets && contents
 
           # TODO: sometimes it can strangely be so that paths.empty?
           # TODO: sometimes it can strangely be so that targets.empty?
@@ -69,6 +100,14 @@ module Datadog
           apply_config(paths, targets, contents)
         end
 
+        # Applies the response to the repository in a transaction, dispatches the
+        # resulting changes to the receivers and returns them.
+        #
+        # @param paths [Array<Configuration::Path>] ingress paths from the response
+        # @param targets [Configuration::TargetMap] targets keyed by path
+        # @param contents [Configuration::ContentList] contents from the response
+        # @return [Configuration::Repository::ChangeSet] the changes applied by the transaction
+        # @raise [SyncError] when a path has no matching target or content
         def apply_config(paths, targets, contents)
           changes = repository.transaction do |current, transaction|
             # paths to be removed: previously applied paths minus ingress paths
@@ -121,6 +160,8 @@ module Datadog
           else
             dispatcher.dispatch(changes, repository)
           end
+
+          changes
         end
 
         def payload # standard:disable Metrics/MethodLength
@@ -185,7 +226,7 @@ module Datadog
               is_agent: false,
               client_tracer: client_tracer,
               # base64 is needed otherwise the Go agent fails with an unmarshal error
-              capabilities: @capabilities.base64_capabilities
+              capabilities: @capabilities.base64_capabilities,
             },
             cached_target_files: state.cached_target_files,
           }

data/lib/datadog/core/remote/component.rb

@@ -15,7 +15,7 @@ module Datadog
       #
       # @api private
       class Component
-        attr_reader :logger, :client, :healthy, :worker
+        attr_reader :logger, :healthy, :worker
 
         def initialize(settings, capabilities, agent_settings, logger:)
           @logger = logger
@@ -28,6 +28,7 @@ module Datadog
 
           @barrier = Barrier.new(settings.remote.boot_timeout_seconds)
 
+          @client_mutex = Mutex.new
           @client = Client.new(@transport, @capabilities, settings: settings, logger: logger)
           @healthy = false
           logger.debug { "new remote configuration client: #{@client.id} products: #{@capabilities.products.sort.join(", ")}" }
@@ -40,7 +41,7 @@ module Datadog
             end
 
             begin
-              @client.sync
+              client.sync
               @healthy ||= true
             rescue Client::SyncError => e
               # Transient errors due to network or agent. Logged the error but not via telemetry
@@ -60,9 +61,11 @@ module Datadog
               end
 
               # client state is unknown, state might be corrupted
-              @client = Client.new(@transport, @capabilities, settings: settings, logger: logger)
+              new_client = @client_mutex.synchronize do
+                @client = Client.new(@transport, @capabilities, settings: settings, logger: logger)
+              end
               @healthy = false
-              logger.debug { "new remote configuration client: #{@client.id} products: #{@capabilities.products.sort.join(", ")}" }
+              logger.debug { "new remote configuration client: #{new_client.id} products: #{@capabilities.products.sort.join(", ")}" }
 
               # TODO: bail out if too many errors?
             end
@@ -81,6 +84,10 @@ module Datadog
           @worker.started?
         end
 
+        def client
+          @client_mutex.synchronize { @client }
+        end
+
         # If the worker is not initialized, initialize it.
         #
         # Then, waits for one client sync to be executed if `kind` is `:once`.
@@ -96,9 +103,13 @@ module Datadog
         # Recreates the remote configuration client after a fork.
         # This ensures each forked process has a unique client ID and fresh state.
         def after_fork
-          @client = Client.new(@transport, @capabilities, settings: @settings, logger: @logger)
+          @worker.after_fork
+          @barrier = Barrier.new(@settings.remote.boot_timeout_seconds)
+          new_client = @client_mutex.synchronize do
+            @client = Client.new(@transport, @capabilities, settings: @settings, logger: @logger)
+          end
           @healthy = false
-          logger.debug { "remote configuration client recreated after fork: #{@client.id} products: #{@capabilities.products.sort.join(", ")}" }
+          logger.debug { "remote configuration client recreated after fork: #{new_client.id} products: #{@capabilities.products.sort.join(", ")}" }
         end
 
         def add_products(*products)
@@ -109,6 +120,17 @@ module Datadog
           @capabilities.remove_products(*products)
         end
 
+        def register(capabilities:, products:, receivers:)
+          @client_mutex.synchronize do
+            @capabilities.register_runtime(
+              capabilities: capabilities,
+              products: products,
+              receivers: receivers,
+            )
+            @client.dispatcher.add_receivers(*receivers)
+          end
+        end
+
         # Barrier provides a mechanism to fence execution until a condition happens
         class Barrier
           def initialize(timeout = nil)
@@ -190,7 +212,8 @@ module Datadog
           def build(settings, agent_settings, logger:, telemetry:)
             return unless settings.remote.enabled
 
-            new(settings, Client::Capabilities.new(settings, telemetry), agent_settings, logger: logger)
+            capabilities = Client::Capabilities.new(settings, telemetry: telemetry)
+            new(settings, capabilities, agent_settings, logger: logger)
           end
         end
       end

data/lib/datadog/core/remote/configuration/repository.rb

@@ -111,9 +111,9 @@ module Datadog
                   hashes: content.hashes.map do |algorithm, hexdigest|
                     {
                       algorithm: algorithm,
-                      hash: hexdigest
+                      hash: hexdigest,
                     }
-                  end
+                  end,
                 }
               end
             end

data/lib/datadog/core/remote/dispatcher.rb

@@ -5,24 +5,57 @@ module Datadog
     module Remote
       # Repository update dispatcher
       class Dispatcher
-        attr_reader :receivers
-
         def initialize(receivers)
-          @receivers = receivers
+          @receivers = receivers.dup
+          @mutex = Mutex.new
+        end
+
+        def receivers
+          @mutex.synchronize { @receivers.dup }
+        end
+
+        def add_receivers(*receivers)
+          @mutex.synchronize do
+            receivers.each { |receiver| @receivers << receiver unless @receivers.include?(receiver) }
+          end
+          nil
         end
 
         def dispatch(changes, repository)
           receivers.each do |receiver|
-            matching_changes = changes.select { |c| receiver.match?(c.path) }
+            matching = matching_changes(changes, receiver)
+
+            receiver.call(repository, matching) if matching.any?
+          end
+          nil
+        end
+
+        # Calls each receiver that declares initial-reconcile participation and has no
+        # matching change in `changes`, passing an empty change list.
+        def reconcile(changes, repository)
+          receivers.each do |receiver|
+            next unless receiver.initial_reconcile?
 
-            receiver.call(repository, matching_changes) if matching_changes.any?
+            receiver.call(repository, []) unless any_matching?(changes, receiver)
           end
+          nil
+        end
+
+        private
+
+        def matching_changes(changes, receiver)
+          changes.select { |change| receiver.match?(change.path) }
+        end
+
+        def any_matching?(changes, receiver)
+          changes.any? { |change| receiver.match?(change.path) }
         end
 
         # Store Matcher and block to be executed on a match
         class Receiver
-          def initialize(matcher, &block)
+          def initialize(matcher, initial_reconcile: false, &block)
             @block = block
+            @initial_reconcile = initial_reconcile
             @matcher = matcher
           end
 
@@ -30,6 +63,14 @@ module Datadog
             @matcher.match?(path)
           end
 
+          # Whether #reconcile may call this receiver with an empty change
+          # list on the client's first sync. A participating receiver must
+          # act on the repository's current contents when the change list is
+          # empty.
+          def initial_reconcile?
+            @initial_reconcile
+          end
+
           def call(repository, changes)
             @block.call(repository, changes)
           end

data/lib/datadog/core/remote/worker.rb

@@ -70,6 +70,14 @@ module Datadog
           @started
         end
 
+        # Child-only: discard inherited synchronization without starting a thread.
+        def after_fork
+          @mutex = Mutex.new
+          @thr = nil
+          @starting = false
+          @started = false
+        end
+
         private
 
         def poll(interval)