datadog 2.45.0 → 2.46.0

data/lib/datadog/open_feature/provider.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "ext"
+require_relative "../open_feature"
 require_relative "../core/utils/time"
 require "open_feature/sdk"
 
 module Datadog
   module OpenFeature
-    # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
+    # OpenFeature feature flagging provider backed by Datadog configuration delivery.
     #
     # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics and EVP hook support.
     #
@@ -24,13 +25,14 @@ module Datadog
     #
     # Example:
     #
-    #   Make sure to enable Remote Configuration and OpenFeature in the Datadog configuration.
+    #   Feature Flags use agentless configuration delivery by default. To use
+    #   Remote Configuration delivery instead, configure the source explicitly.
     #
     #   ```ruby
     #   # FILE: initializers/datadog.rb
     #   Datadog.configure do |config|
     #     config.remote.enabled = true
-    #     config.open_feature.enabled = true
+    #     config.feature_flags.configuration_source = "remote_config"
     #   end
     #   ```
     #
@@ -58,20 +60,110 @@ module Datadog
     #   # => 'Welcome back!'
     #   ```
     class Provider
+      include ::OpenFeature::SDK::Provider::EventEmitter
+
       NAME = "Datadog Feature Flagging Provider"
+      INITIALIZATION_CANCELLED_MESSAGE = "Feature Flags provider initialization was cancelled by shutdown"
 
       attr_reader :metadata
 
       def initialize
         @metadata = ::OpenFeature::SDK::Provider::ProviderMetadata.new(name: NAME).freeze
+        @initialization_mutex = Mutex.new
+        @initializing = false
+        @initialization_thread = nil
+        @awaiting_ready_after_fork = false
+        @initialization_failed = false
+        @provider_error_observed = false
+        @ready_pending = false
+        @ready_dispatch_claimed = false
+        @stale_emitted = false
+        @stale_pending = false
+        @error_handler = nil
+        @initialization_ready_handler = nil
+        @waiting_component = nil
+        @shutdown = false
       end
 
       def init
-        # no-op
+        @initialization_mutex.synchronize do
+          raise INITIALIZATION_CANCELLED_MESSAGE if @shutdown
+
+          @initializing = true
+          @initialization_thread = Thread.current
+          @awaiting_ready_after_fork = false
+          @initialization_failed = false
+          @provider_error_observed = false
+          @ready_pending = false
+          @ready_dispatch_claimed = false
+          @stale_emitted = false
+          @stale_pending = false
+        end
+        ready_handler_installed = install_initialization_ready_handler
+
+        component, failure = OpenFeature.activate_provider(self)
+        cancel_initialization_if_shutdown!
+        fail_initialization(component, failure || "Feature Flags component could not be activated") unless component
+
+        @initialization_mutex.synchronize do
+          raise INITIALIZATION_CANCELLED_MESSAGE if @shutdown
+
+          @waiting_component = component
+        end
+        # Shutdown publishes this flag through the component lock; taking our mutex here would invert lock order.
+        wait_result = component.wait_for_configuration { @shutdown }
+        cancel_initialization_if_shutdown!
+
+        case wait_result
+        when Component::CONFIGURATION_READY
+          @initialization_mutex.synchronize { @initializing = false } unless ready_handler_installed
+        when Component::CONFIGURATION_TIMEOUT
+          message = "Feature Flags provider initialization timed out while waiting for configuration"
+          Datadog.logger.error(message)
+          fail_initialization(component, message)
+        else
+          fail_initialization(component, "Feature Flags provider initialization stopped before configuration arrived")
+        end
+      rescue
+        prepare_initialization_failure(component) if @initialization_mutex.synchronize { @initializing }
+        raise
+      ensure
+        @initialization_mutex.synchronize do
+          @waiting_component = nil
+          # The SDK still owes READY after init returns; the initializing thread owns that dispatch.
+          @initialization_thread = nil unless @initializing
+        end
       end
 
       def shutdown
-        # no-op
+        configuration = @configuration
+        # @type var error_handler: Provider::provider_event_handler?
+        error_handler = nil
+        # @type var initialization_ready_handler: Provider::provider_event_handler?
+        initialization_ready_handler = nil
+        waiting_component = nil #: Component?
+        @initialization_mutex.synchronize do
+          return if @shutdown
+
+          @shutdown = true
+          @initializing = false
+          @initialization_thread = nil
+          error_handler = @error_handler
+          initialization_ready_handler = @initialization_ready_handler
+          waiting_component = @waiting_component
+          @error_handler = nil
+          @initialization_ready_handler = nil
+        end
+
+        waiting_component&.wake_configuration_waiters
+        configuration&.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, error_handler) if error_handler
+        if initialization_ready_handler
+          configuration&.remove_handler(
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
+            initialization_ready_handler,
+          )
+        end
+        OpenFeature.deactivate_provider(self)
       end
 
       def hooks
@@ -108,6 +200,191 @@ module Datadog
 
       private
 
+      def after_fork(component)
+        handler = @initialization_mutex.synchronize do
+          return if @shutdown || !@initializing || @initialization_thread&.alive?
+
+          @initializing = false
+          @initialization_thread = nil
+          @waiting_component = nil
+          @awaiting_ready_after_fork = true
+          @stale_pending = false
+          previous_handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          previous_handler
+        end
+        if handler
+          @configuration&.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler)
+        end
+        configuration_changed(Component::CONFIGURATION_READY) if component&.configuration_received?
+      end
+
+      def fail_initialization(component, message)
+        prepare_initialization_failure(component)
+        cancel_initialization_if_shutdown!
+        raise message.to_s
+      end
+
+      def prepare_initialization_failure(component)
+        cancelled, initialization_ready_handler = @initialization_mutex.synchronize do
+          handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          @stale_pending = false
+          @initializing = false
+          @initialization_thread = nil
+          if @shutdown
+            [true, handler]
+          else
+            @initialization_failed = true
+            @ready_pending ||= !!component&.configuration_received?
+            [false, handler]
+          end
+        end
+        if initialization_ready_handler
+          @configuration&.remove_handler(
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY,
+            initialization_ready_handler,
+          )
+        end
+        return if cancelled
+
+        install_error_handler
+      end
+
+      def cancel_initialization_if_shutdown!
+        cancelled = @initialization_mutex.synchronize do
+          @initializing = false if @shutdown
+          @shutdown
+        end
+        raise INITIALIZATION_CANCELLED_MESSAGE if cancelled
+      end
+
+      def shutdown?
+        @initialization_mutex.synchronize { @shutdown }
+      end
+
+      def install_initialization_ready_handler
+        configuration = @configuration
+        return false unless configuration
+
+        handler = @initialization_mutex.synchronize do
+          return false if @shutdown
+          return true if @initialization_ready_handler
+
+          @initialization_ready_handler = ->(details) { provider_ready(details) }
+        end
+        configuration.add_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler)
+
+        cancelled = @initialization_mutex.synchronize { @shutdown }
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if cancelled
+        return false if cancelled
+
+        true
+      end
+
+      def install_error_handler
+        configuration = @configuration
+        return unless configuration
+
+        handler = @initialization_mutex.synchronize do
+          return if @shutdown
+
+          @error_handler ||= ->(details) { provider_error(details) }
+        end
+        configuration.add_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, handler)
+
+        cancelled = @initialization_mutex.synchronize { @shutdown }
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_ERROR, handler) if cancelled
+      end
+
+      def provider_error(_details)
+        configuration = @configuration
+        return unless configuration
+        return unless configuration.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::ERROR
+
+        emit_ready = @initialization_mutex.synchronize do
+          if @shutdown
+            false
+          else
+            @provider_error_observed = true
+            if @ready_pending && !@ready_dispatch_claimed
+              @ready_dispatch_claimed = true
+            else
+              false
+            end
+          end
+        end
+        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY) if emit_ready
+      end
+
+      def provider_ready(_details)
+        configuration = @configuration
+        return unless configuration
+        return unless configuration.send(:provider_state, self) == ::OpenFeature::SDK::ProviderState::READY
+
+        handler, emit_stale = @initialization_mutex.synchronize do
+          handler = @initialization_ready_handler
+          @initialization_ready_handler = nil
+          @initializing = false
+          @initialization_thread = nil
+          if @stale_pending && !@shutdown
+            @stale_pending = false
+            @stale_emitted = true
+            [handler, true]
+          else
+            [handler, false]
+          end
+        end
+        configuration.remove_handler(::OpenFeature::SDK::ProviderEvent::PROVIDER_READY, handler) if handler
+        emit_event(::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE) if emit_stale
+      end
+
+      def configuration_changed(event)
+        event_type = @initialization_mutex.synchronize do
+          if @shutdown
+            nil
+          elsif event == Component::CONFIGURATION_READY
+            if @initializing
+              @ready_pending = true
+              @stale_pending = false
+              nil
+            elsif @awaiting_ready_after_fork
+              @awaiting_ready_after_fork = false
+              @stale_emitted = false
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            elsif @initialization_failed && !@provider_error_observed
+              @stale_emitted = false
+              @ready_pending = true
+              nil
+            elsif @stale_emitted
+              @stale_emitted = false
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+            elsif @initialization_failed
+              if @provider_error_observed && !@ready_dispatch_claimed
+                @ready_dispatch_claimed = true
+                ::OpenFeature::SDK::ProviderEvent::PROVIDER_READY
+              else
+                @ready_pending = true
+                nil
+              end
+            end
+          elsif event == Component::CONFIGURATION_CHANGED && !@initializing
+            ::OpenFeature::SDK::ProviderEvent::PROVIDER_CONFIGURATION_CHANGED
+          elsif event == Component::CONFIGURATION_LOST
+            @ready_pending = false
+            if @initializing
+              @stale_pending = true
+              nil
+            else
+              @stale_emitted = true
+              ::OpenFeature::SDK::ProviderEvent::PROVIDER_STALE
+            end
+          end
+        end
+
+        emit_event(event_type) if event_type
+      end
+
       def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
         # Stamp evaluation entry time once, here on the eval thread. The EVP path uses this for
         # accurate first/last_evaluation bounds instead of a later hook-fire clock read.

data/lib/datadog/open_feature.rb

@@ -2,6 +2,7 @@
 
 require_relative "core/configuration"
 require_relative "open_feature/configuration"
+require_relative "open_feature/configuration/source"
 
 module Datadog
   # A namespace for the OpenFeature component.
@@ -9,11 +10,40 @@ module Datadog
     Core::Configuration::Settings.extend(Configuration::Settings)
 
     def self.enabled?
-      Datadog.configuration.open_feature.enabled
+      Configuration::Source.resolve(Datadog.configuration).enabled?
     end
 
     def self.engine
       Datadog.send(:components).open_feature&.engine
     end
+
+    def self.activate_provider(provider)
+      # Initialize the component tree before taking its reconfiguration lock.
+      Datadog.send(:components)
+      Datadog.send(:safely_synchronize) do
+        return [nil, nil] if provider.send(:shutdown?)
+
+        components = Datadog.send(:components, allow_initialization: false)
+        activation = components&.send(:open_feature_activation)
+        providers = @adopted_providers ||= {}.compare_by_identity
+        providers[provider] = true
+        [activation&.activate(provider), activation&.failure]
+      end
+    end
+
+    def self.deactivate_provider(provider)
+      Datadog.send(:safely_synchronize) do
+        @adopted_providers&.delete(provider)
+        components = Datadog.send(:components, allow_initialization: false)
+        components&.send(:open_feature_activation)&.deactivate(provider)
+      end
+    end
+
+    # Components startup already holds the non-reentrant reconfiguration lock.
+    def self.reattach(activation)
+      providers = @adopted_providers&.keys || []
+      providers.each { |provider| activation.activate(provider) }
+      nil
+    end
   end
 end

data/lib/datadog/tracing/component.rb

@@ -62,6 +62,20 @@ module Datadog
         end
       end
 
+      def bind_transport_telemetry(tracer, telemetry)
+        return unless tracer.is_a?(Tracing::Tracer)
+
+        writer = tracer.writer
+        return unless writer.respond_to?(:transport)
+
+        transport = writer.transport
+        if transport.is_a?(Transport::Traces::Transport) ||
+            (defined?(Transport::Native::Transport) && transport.is_a?(Transport::Native::Transport))
+          transport.telemetry = telemetry
+        end
+        nil
+      end
+
       def build_sampler(settings)
         # A custom sampler is provided
         if (sampler = settings.tracing.sampler)

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

@@ -258,7 +258,9 @@ module Datadog
 
               option :otel_thread_context_enabled do |o|
                 o.env Tracing::Configuration::Ext::ENV_OTEL_CONTEXT_ENABLED
-                o.default true
+                o.default do
+                  RUBY_ENGINE == "ruby" && RUBY_PLATFORM.include?("linux")
+                end
                 o.type :bool
               end
 

data/lib/datadog/tracing/otel_thread_context.rb

@@ -14,9 +14,11 @@ module Datadog
 
       def self.build(tracing_settings)
         return unless tracing_settings.otel_thread_context_enabled
+        return unless Datadog::Core::LIBDATADOG_API_FAILURE.nil?
 
         instance = new
-        instance if instance.supported? && instance._native_enable
+        instance._native_enable
+        instance
       end
 
       def initialize
@@ -65,10 +67,6 @@ module Datadog
         false
       end
 
-      def supported?
-        Datadog::Core::LIBDATADOG_API_FAILURE.nil? && _native_supported?
-      end
-
       def update_from_trace_op(trace_op)
         active_span = trace_op.active_span
 

data/lib/datadog/tracing/transport/http/telemetry.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "net/http"
+require_relative "../telemetry"
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        class Telemetry < Datadog::Tracing::Transport::Telemetry
+          def initialize(client)
+            super(client, source: "ruby")
+          end
+
+          def batch(traces)
+            return unless @client.enabled? && @client.metrics_manager.enabled
+
+            Batch.new(self, traces)
+          rescue
+            nil
+          end
+
+          class Batch
+            def initialize(reporter, traces)
+              @reporter = reporter
+              @remaining_chunks = traces.length
+              @remaining_spans = traces.sum(&:length)
+              @reporter.record(spans_enqueued_for_serialization: @remaining_spans)
+            end
+
+            def record_oversized_drop(span_count)
+              @remaining_chunks -= 1
+              @remaining_spans -= span_count
+              @reporter.record(chunks_dropped_payload_too_large: 1, spans_dropped_payload_too_large: span_count)
+            end
+
+            def serialization_failed
+              @reporter.record(chunks_dropped_serialization_error: @remaining_chunks,
+                spans_dropped_serialization_error: @remaining_spans,)
+            end
+
+            def sent(request, response, chunks, spans, bytes, fallback:)
+              @reporter.record(requests_count: 1)
+              return if fallback
+
+              @remaining_chunks -= chunks
+              @remaining_spans -= spans
+              observations = {} #: Hash[Symbol, Integer]
+              if (status = request.http_status)
+                observations[:responses_count] = 1
+                observations[:status_code] = status
+              end
+              success = status ? status.between?(200, 299) : request.http_success
+              if success
+                observations[:chunks_sent] = chunks
+                observations[:bytes_sent] = bytes
+              elsif status || success == false
+                observations[:errors_status_code] = 1 if status
+                observations[:chunks_dropped_send_failure] = chunks
+                observations[:spans_dropped_api_error] = spans
+              elsif response.is_a?(Core::Transport::InternalErrorResponse)
+                error = response.error
+                if error.is_a?(ArgumentError) || error.is_a?(TypeError)
+                  observations[:chunks_dropped_serialization_error] = chunks
+                  observations[:spans_dropped_serialization_error] = spans
+                else
+                  observations[:chunks_dropped_send_failure] = chunks
+                  observations[:spans_dropped_api_error] = spans
+                  if error.is_a?(::Timeout::Error) || error.is_a?(Errno::ETIMEDOUT)
+                    observations[:errors_timeout] = 1
+                  elsif network_error?(error)
+                    observations[:errors_network] = 1
+                  end
+                end
+              end
+              @reporter.record(observations)
+            rescue
+              nil
+            end
+
+            private
+
+            def network_error?(error)
+              error.is_a?(SystemCallError) || error.is_a?(IOError) || error.is_a?(SocketError) ||
+                error.is_a?(::Net::ProtocolError) || error.is_a?(::Net::HTTPBadResponse) ||
+                error.is_a?(::Net::HTTPHeaderSyntaxError) ||
+                (defined?(::OpenSSL::SSL::SSLError) && error.is_a?(::OpenSSL::SSL::SSLError))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http/traces.rb

@@ -51,6 +51,8 @@ module Datadog
 
                 # Query for response
                 http_response = super
+                # Delivery succeeded or failed before service-rate parsing can raise.
+                env.request.capture_status(http_response)
 
                 # Process the response
                 response_options = {trace_count: env.request.parcel.trace_count}.tap do |options|

data/lib/datadog/tracing/transport/native/telemetry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../telemetry"
+
+module Datadog
+  module Tracing
+    module Transport
+      module Native
+        class Telemetry < Datadog::Tracing::Transport::Telemetry
+          def initialize(client)
+            super(client, source: "libdatadog")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/native.rb

@@ -4,6 +4,7 @@ require "json"
 require_relative "trace_formatter"
 require_relative "statistics"
 require_relative "span_events_negotiation"
+require_relative "native/telemetry"
 
 module Datadog
   module Tracing
@@ -49,6 +50,16 @@ module Datadog
 
           attr_reader :logger, :url
 
+          def telemetry=(client)
+            @send_mutex.synchronize do
+              if (reporter = @telemetry)
+                reporter.client = client
+              elsif @exporter
+                @telemetry = Telemetry.new(client)
+              end
+            end
+          end
+
           # @param agent_settings [Datadog::Core::Configuration::AgentSettingsResolver::AgentSettings]
           #   Agent connection settings, including the request timeout.
           # @param logger [Logger]
@@ -58,6 +69,7 @@ module Datadog
             end
 
             @logger = logger
+            @telemetry = nil
 
             # Serializes native sends and is held across a fork. See the
             # fork-safety note below.
@@ -226,6 +238,7 @@ module Datadog
                   @exporter&._native_close
                 ensure
                   @fork_hooks = nil
+                  @telemetry = nil
                   @exporter = nil
                   hooks.each do |stage, block|
                     Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
@@ -285,7 +298,9 @@ module Datadog
               exporter = @exporter
               raise "Native transport has been closed" if exporter.nil?
 
-              exporter._native_send_traces(chunks, native_events_supported)
+              exporter._native_send_traces(chunks, native_events_supported) do |observations|
+                @telemetry&.record(observations)
+              end
             end
 
             # Update statistics from the response

data/lib/datadog/tracing/transport/telemetry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Transport
+      class Telemetry
+        # Observation schema: Symbol keys with non-negative Integer values.
+        # COUNTS maps per-send count deltas to [metric name, additional tags].
+        # :bytes_sent is one successful payload's byte-size distribution sample;
+        # record each payload separately rather than summing its samples.
+        # :responses_count requires :status_code; omit both when the code is unknown.
+        # Missing and zero measurements emit nothing. All metrics use namespace
+        # "tracers" and common: true; trace_* metrics gain src_library:<source>, while
+        # span metrics keep their source-free tags.
+        COUNTS = {
+          requests_count: ["trace_api.requests", []],
+          errors_network: ["trace_api.errors", ["type:network"]],
+          errors_timeout: ["trace_api.errors", ["type:timeout"]],
+          errors_status_code: ["trace_api.errors", ["type:status_code"]],
+          chunks_sent: ["trace_chunks_sent", []],
+          chunks_dropped_serialization_error: ["trace_chunks_dropped", ["reason:serialization_error"]],
+          chunks_dropped_send_failure: ["trace_chunks_dropped", ["reason:send_failure"]],
+          chunks_dropped_payload_too_large: ["trace_chunks_dropped", ["reason:payload_too_large"]],
+          spans_enqueued_for_serialization: ["spans_enqueued_for_serialization", []],
+          spans_dropped_serialization_error: ["spans_dropped", ["reason:serialization_error"]],
+          spans_dropped_api_error: ["spans_dropped", ["reason:api_error"]],
+          spans_dropped_payload_too_large: ["spans_dropped", ["reason:payload_too_large"]],
+        }.freeze #: Hash[Symbol, [String, Array[String]]]
+
+        attr_writer :client
+
+        def initialize(client, source:)
+          @client = client
+          @source_tags = ["src_library:#{source}"]
+          @counts = COUNTS.map do |key, (name, tags)|
+            [key, name, name.start_with?("trace_") ? @source_tags + tags : tags]
+          end
+        end
+
+        def record(observations)
+          client = @client
+          return unless client.enabled?
+
+          @counts.each do |key, name, tags|
+            value = observations.fetch(key, 0)
+            client.inc("tracers", name, value, tags: tags) if value > 0
+          end
+          bytes = observations.fetch(:bytes_sent, 0)
+          client.distribution("tracers", "trace_api.bytes", bytes, tags: @source_tags) if bytes > 0
+          responses = observations.fetch(:responses_count, 0)
+          if responses > 0
+            client.inc("tracers", "trace_api.responses", responses,
+              tags: @source_tags + ["status_code:#{observations.fetch(:status_code)}"],)
+          end
+          nil
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end