datadog 2.45.0 → 2.46.0

data/lib/datadog/open_feature/activation.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require_relative "agentless/configuration_source"
+require_relative "component"
+require_relative "configuration/agentless_endpoint"
+require_relative "configuration/source"
+require_relative "remote"
+
+module Datadog
+  module OpenFeature
+    # Owns eager Remote Configuration and lazy agentless delivery activation.
+    class Activation
+      attr_reader :component, :failure
+
+      def initialize(settings, agent_settings, remote, logger:, telemetry:)
+        @settings = settings
+        @agent_settings = agent_settings
+        @remote = remote
+        @logger = logger
+        @telemetry = telemetry
+        @component = nil
+        @configuration_source = nil
+        @delivery_source = nil
+        @remote_receivers = nil
+        @failure = nil
+        @providers = {}.compare_by_identity
+        @activated = false
+        @delivery_started = false
+        @shutdown = false
+        @mutex = Mutex.new
+      end
+
+      def activate(provider)
+        @mutex.synchronize do
+          return if @shutdown
+          return unless open_feature_available?
+
+          @providers[provider] = true
+          return @component if @activated && @delivery_started
+          return if @activated
+
+          resolution = Configuration::Source.resolve(@settings, logger: @logger)
+          activate_delivery(resolution)
+        end
+      end
+
+      def startup!
+        start!
+        OpenFeature.reattach(self)
+      rescue => e
+        # Feature Flags is optional and must never interrupt library startup.
+        report_failure(e, "Feature Flags delivery failed to start")
+      end
+
+      def start!
+        @mutex.synchronize do
+          return if @shutdown || @activated
+          return unless open_feature_available?
+
+          resolution = Configuration::Source.resolve(@settings, logger: @logger)
+          return unless resolution.enabled? && resolution.source == Configuration::Source::REMOTE_CONFIG
+
+          activate_delivery(resolution)
+        end
+      end
+
+      def activated?
+        @mutex.synchronize { @activated }
+      end
+
+      def providers
+        @mutex.synchronize { @providers.keys }
+      end
+
+      def after_fork
+        inherited_providers, component = @mutex.synchronize do
+          @shutdown ? [[], nil] : [@providers.keys, @component]
+        end
+        inherited_providers.each { |provider| provider.send(:after_fork, component) }
+
+        configuration_source = @mutex.synchronize do
+          if @shutdown || !@delivery_started
+            nil
+          else
+            (@delivery_source == Configuration::Source::REMOTE_CONFIG) ? @remote : @configuration_source
+          end
+        end
+
+        configuration_source&.start
+        nil
+      rescue => e
+        # Feature Flags is optional and must never interrupt other post-fork handlers.
+        report_failure(e, "Feature Flags delivery failed to restart after fork")
+      end
+
+      def deactivate(provider)
+        configuration_source, component = @mutex.synchronize do
+          return if @shutdown
+          return unless @providers.delete(provider)
+          return unless @providers.empty?
+          if @delivery_source == Configuration::Source::REMOTE_CONFIG && @delivery_started
+            # Remote Configuration is process-scoped and may already hold configuration needed by the next provider.
+            [nil, nil]
+          else
+            previous_source = @configuration_source
+            previous_component = @component
+            @component = nil
+            @configuration_source = nil
+            @delivery_source = nil
+            @activated = false
+            @delivery_started = false
+            @failure = nil
+            [previous_source, previous_component]
+          end
+        end
+
+        configuration_source&.stop
+        component&.shutdown!
+      end
+
+      def shutdown!
+        configuration_source, component = @mutex.synchronize do
+          return if @shutdown
+
+          @shutdown = true
+          [@configuration_source, @component]
+        end
+
+        configuration_source&.stop
+        configuration_received = @mutex.synchronize do
+          !@providers.empty? && !!component&.configuration_received?
+        end
+        configuration_changed(Component::CONFIGURATION_LOST) if configuration_received
+        component&.shutdown!
+      end
+
+      private
+
+      def report_failure(error, description)
+        @logger.error("#{description}: #{error.class}: #{error.message}")
+        @telemetry.report(error, description: description)
+      end
+
+      def open_feature_available?
+        @settings.respond_to?(:open_feature) && @settings.respond_to?(:feature_flags)
+      end
+
+      def activate_delivery(resolution)
+        @activated = true
+        unless resolution.enabled?
+          @failure = "Feature Flags are disabled"
+          return
+        end
+
+        component = Component.build(
+          @settings,
+          @agent_settings,
+          resolution: resolution,
+          on_configuration_change: ->(event) { configuration_changed(event) },
+          logger: @logger,
+          telemetry: @telemetry,
+        )
+        unless component
+          @failure = "Feature Flags are unavailable on this runtime"
+          return
+        end
+
+        @component = component
+        @delivery_source = resolution.source
+        @delivery_started = start_delivery(resolution.source)
+        return component if @delivery_started
+
+        component.shutdown!
+        @component = nil
+        @delivery_source = nil
+        nil
+      rescue
+        configuration_source = @configuration_source
+        failed_component = @component
+        @component = nil
+        @configuration_source = nil
+        @delivery_source = nil
+        @activated = false
+        @delivery_started = false
+        @failure = nil
+        begin
+          configuration_source&.stop
+        ensure
+          failed_component&.shutdown!
+        end
+        raise
+      end
+
+      def start_delivery(source)
+        case source
+        when Configuration::Source::AGENTLESS
+          start_agentless
+        when Configuration::Source::REMOTE_CONFIG
+          start_remote_configuration
+        else
+          @failure = "Feature Flags configuration source is unavailable"
+          false
+        end
+      end
+
+      def start_agentless
+        component = @component
+        return false unless component
+
+        endpoint = Configuration::AgentlessEndpoint.build(
+          site: @settings.site,
+          environment: @settings.env,
+          base_url: @settings.feature_flags.agentless.base_url,
+          logger: @logger,
+        )
+        unless endpoint
+          @failure = "Feature Flags agentless endpoint is unavailable"
+          return false
+        end
+
+        configuration_source = Agentless::ConfigurationSource.build(
+          @settings,
+          endpoint: endpoint,
+          apply: ->(configuration) { component.reconfigure!(configuration) },
+          logger: @logger,
+        )
+        unless configuration_source
+          @failure = "Feature Flags agentless delivery could not start"
+          return false
+        end
+
+        @configuration_source = configuration_source
+        started = configuration_source.start
+        @failure = "Feature Flags agentless delivery could not start" unless started
+        started
+      end
+
+      def start_remote_configuration
+        remote = @remote
+        unless remote
+          @failure = "Feature Flags Remote Configuration is unavailable"
+          @logger.warn(
+            "#{@failure}. To enable Remote Configuration, " \
+              "see https://docs.datadoghq.com/remote_configuration/."
+          )
+          return false
+        end
+
+        receivers = @remote_receivers ||= Remote.receivers(
+          @telemetry,
+          component_provider: -> { @mutex.synchronize { @component } },
+        )
+        remote.register(
+          capabilities: Remote.capabilities,
+          products: Remote.products,
+          receivers: receivers,
+        )
+        remote.start
+        true
+      end
+
+      def configuration_changed(event)
+        providers = @mutex.synchronize { @providers.keys }
+        providers.each { |provider| provider.send(:configuration_changed, event) }
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/component.rb

@@ -3,6 +3,7 @@
 require_relative "transport"
 require_relative "evaluation_engine"
 require_relative "../core/utils/time"
+require_relative "configuration/source"
 require_relative "exposures/buffer"
 require_relative "exposures/worker"
 require_relative "exposures/deduplicator"
@@ -20,19 +21,13 @@ module Datadog
       CONFIGURATION_READY = :ready
       CONFIGURATION_TIMEOUT = :timeout
       CONFIGURATION_SHUTDOWN = :shutdown
+      CONFIGURATION_CHANGED = :changed
+      CONFIGURATION_LOST = :lost
 
       attr_reader :engine, :flag_eval_metrics_hook, :flag_eval_evp_hook, :span_enrichment_hook
 
-      def self.build(settings, agent_settings, logger:, telemetry:)
-        return unless settings.respond_to?(:open_feature) && settings.open_feature.enabled
-
-        unless settings.respond_to?(:remote) && settings.remote.enabled
-          message = "OpenFeature could not be enabled as Remote Configuration is currently disabled. " \
-            "To enable Remote Configuration, see https://docs.datadoghq.com/remote_configuration/."
-
-          logger.warn(message)
-          return
-        end
+      def self.build(settings, agent_settings, resolution:, on_configuration_change:, logger:, telemetry:)
+        return unless resolution.enabled?
 
         unless ["ruby", "truffleruby"].include?(RUBY_ENGINE)
           message = "OpenFeature could not be enabled as MRI is required, " \
@@ -51,10 +46,16 @@ module Datadog
           return
         end
 
-        new(settings, agent_settings, logger: logger, telemetry: telemetry)
+        new(
+          settings,
+          agent_settings,
+          on_configuration_change: on_configuration_change,
+          logger: logger,
+          telemetry: telemetry,
+        )
       end
 
-      def initialize(settings, agent_settings, logger:, telemetry:)
+      def initialize(settings, agent_settings, logger:, telemetry:, on_configuration_change: nil)
         transport = Transport::HTTP.build(agent_settings: agent_settings, logger: logger)
         @worker = Exposures::Worker.new(settings: settings, transport: transport, telemetry: telemetry, logger: logger)
 
@@ -65,6 +66,7 @@ module Datadog
         @logger = logger
         @settings = settings
         @agent_settings = agent_settings
+        @on_configuration_change = on_configuration_change
         @flag_eval_metrics_hook = create_flag_eval_metrics_hook
         @flag_eval_evp_hook = create_flag_eval_evp_hook
         @span_enrichment_hook = create_span_enrichment_hook
@@ -77,7 +79,7 @@ module Datadog
       end
 
       def reconfigure!(configuration)
-        @reconfiguration_mutex.synchronize do
+        event = @reconfiguration_mutex.synchronize do
           return if configuration_shutdown?
 
           @engine.reconfigure!(configuration)
@@ -85,19 +87,28 @@ module Datadog
           @configuration_mutex.synchronize do
             return if @configuration_shutdown
 
+            previously_received = @configuration_received
             @configuration_received = !configuration.nil?
             @configuration_condition.broadcast
+
+            if @configuration_received
+              previously_received ? CONFIGURATION_CHANGED : CONFIGURATION_READY
+            elsif previously_received
+              CONFIGURATION_LOST
+            end
           end
         end
+
+        @on_configuration_change&.call(event) if event
       end
 
-      def wait_for_configuration
+      def wait_for_configuration(&cancelled)
         timeout_seconds = @settings.feature_flags.initialization_timeout_ms / 1000.0
         deadline = Core::Utils::Time.get_time + timeout_seconds
 
         @configuration_mutex.synchronize do
           loop do
-            return CONFIGURATION_SHUTDOWN if @configuration_shutdown
+            return CONFIGURATION_SHUTDOWN if @configuration_shutdown || cancelled&.call
             return CONFIGURATION_READY if @configuration_received
 
             remaining = deadline - Core::Utils::Time.get_time
@@ -108,6 +119,11 @@ module Datadog
         end
       end
 
+      def wake_configuration_waiters
+        @configuration_mutex.synchronize { @configuration_condition.broadcast }
+        nil
+      end
+
       def configuration_received?
         @configuration_mutex.synchronize { @configuration_received }
       end