datadog 2.22.0 → 2.23.0

data/lib/datadog/open_feature/exposures/reporter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+require_relative 'deduplicator'
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class is responsible for reporting exposures to the Agent
+      class Reporter
+        def initialize(worker, telemetry:, logger:)
+          @worker = worker
+          @logger = logger
+          @telemetry = telemetry
+          @deduplicator = Deduplicator.new
+        end
+
+        # NOTE: Reporting expects evaluation context to be always present, but it
+        #       might be missing depending on the customer way of using flags evaluation API.
+        #       In addition to that the evaluation result must be marked for reporting.
+        def report(result, flag_key:, context:)
+          return false if context.nil?
+          return false unless result.log?
+
+          key = Event.cache_key(result, flag_key: flag_key, context: context)
+          value = Event.cache_value(result, flag_key: flag_key, context: context)
+          return false if @deduplicator.duplicate?(key, value)
+
+          event = Event.build(result, flag_key: flag_key, context: context)
+          @worker.enqueue(event)
+        rescue => e
+          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e.message}" }
+          @telemetry.report(e, description: 'OpenFeature: Failed to report resolution details')
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/exposures/worker.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../../core/utils/time'
+require_relative '../../core/workers/queue'
+require_relative '../../core/workers/polling'
+
+require_relative 'buffer'
+require_relative 'batch_builder'
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class is responsible for sending exposures to the Agent
+      class Worker
+        include Core::Workers::Queue
+        include Core::Workers::Polling
+
+        GRACEFUL_SHUTDOWN_EXTRA_SECONDS = 5
+        GRACEFUL_SHUTDOWN_WAIT_INTERVAL_SECONDS = 0.5
+
+        DEFAULT_FLUSH_INTERVAL_SECONDS = 30
+        DEFAULT_BUFFER_LIMIT = Buffer::DEFAULT_LIMIT
+
+        def initialize(
+          settings:,
+          transport:,
+          telemetry:,
+          logger:,
+          flush_interval_seconds: DEFAULT_FLUSH_INTERVAL_SECONDS,
+          buffer_limit: DEFAULT_BUFFER_LIMIT
+        )
+          @logger = logger
+          @transport = transport
+          @telemetry = telemetry
+          @batch_builder = BatchBuilder.new(settings)
+          @buffer_limit = buffer_limit
+
+          self.buffer = Buffer.new(buffer_limit)
+          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_RESTART
+          self.loop_base_interval = flush_interval_seconds
+          self.enabled = true
+        end
+
+        def start
+          return if !enabled? || running?
+
+          perform
+        end
+
+        def stop(force_stop = false, timeout = Core::Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT)
+          buffer.close if running?
+
+          super
+        end
+
+        def enqueue(event)
+          buffer.push(event)
+          start unless running?
+
+          true
+        end
+
+        def dequeue
+          [buffer.pop, buffer.dropped_count]
+        end
+
+        def perform(*args)
+          events, dropped = args
+          send_events(Array(events), dropped.to_i)
+        end
+
+        def graceful_shutdown
+          return false unless enabled? || !run_loop?
+
+          self.enabled = false
+
+          started = Core::Utils::Time.get_time
+          wait_time = loop_base_interval + GRACEFUL_SHUTDOWN_EXTRA_SECONDS
+
+          loop do
+            break if buffer.empty? && !in_iteration?
+
+            sleep(GRACEFUL_SHUTDOWN_WAIT_INTERVAL_SECONDS)
+            break if Core::Utils::Time.get_time - started > wait_time
+          end
+
+          stop(true)
+        end
+
+        private
+
+        def send_events(events, dropped)
+          return if events.empty?
+
+          if dropped.positive?
+            @logger.debug { "OpenFeature: Resolution details worker dropped #{dropped} event(s) due to full buffer" }
+          end
+
+          payload = @batch_builder.payload_for(events)
+          response = @transport.send_exposures(payload)
+
+          unless response&.ok?
+            @logger.debug { "OpenFeature: Resolution details upload response was not OK: #{response.inspect}" }
+          end
+
+          response
+        rescue => e
+          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e.message}" }
+          @telemetry.report(e, description: 'OpenFeature: Failed to flush resolution details events')
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/ext.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Ext
+      ERROR = 'ERROR'
+      INITIALIZING = 'INITIALIZING'
+      UNKNOWN_TYPE = 'UNKNOWN_TYPE'
+      GENERAL = 'GENERAL'
+      PROVIDER_FATAL = 'PROVIDER_FATAL'
+      PROVIDER_NOT_READY = 'PROVIDER_NOT_READY'
+    end
+  end
+end

data/lib/datadog/open_feature/native_evaluator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../core/feature_flags'
+
+module Datadog
+  module OpenFeature
+    # This class is an interface of evaluation logic using native extension
+    class NativeEvaluator
+      # NOTE: In a currect implementation configuration is expected to be a raw
+      #       JSON string containing feature flags (straight from the remote config)
+      #       in the format expected by `libdatadog` without any modifications
+      def initialize(configuration)
+        @configuration = Core::FeatureFlags::Configuration.new(configuration)
+      end
+
+      # Returns the assignment for a given flag key based on the feature flags
+      # configuration
+      #
+      # @param flag_key [String] The key of the feature flag
+      # @param default_value [Object] The default value to return if the flag is
+      #                              not found or evaluation itself fails
+      # @param expected_type [Symbol] The expected type of the flag
+      # @param context [Hash] The context of the evaluation, containing targeting key
+      #                       and other attributes
+      #
+      # @return [Core::FeatureFlags::ResolutionDetails] The assignment for the flag
+      def get_assignment(flag_key, default_value:, expected_type:, context:)
+        result = @configuration.get_assignment(flag_key, expected_type, context)
+
+        # NOTE: This is a special case when we need to fallback to the default
+        #       value, even tho the evaluation itself doesn't produce an error
+        #       resolution details
+        result.value = default_value if result.variant.nil?
+        result
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/noop_evaluator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'resolution_details'
+
+module Datadog
+  module OpenFeature
+    # This class is a noop interface of evaluation logic
+    class NoopEvaluator
+      def initialize(_configuration)
+        # no-op
+      end
+
+      def get_assignment(_flag_key, default_value:, context:, expected_type:)
+        ResolutionDetails.new(
+          value: default_value,
+          log?: false,
+          error?: true,
+          error_code: Ext::PROVIDER_NOT_READY,
+          error_message: 'Waiting for flags configuration',
+          reason: Ext::ERROR
+        )
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/provider.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require 'open_feature/sdk'
+
+module Datadog
+  module OpenFeature
+    # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
+    #
+    # Implementation follows the OpenFeature contract of Provider SDK.
+    # For details see:
+    #   - https://github.com/open-feature/ruby-sdk/blob/v0.4.1/README.md#develop-a-provider
+    #   - https://github.com/open-feature/ruby-sdk/blob/v0.4.1/lib/open_feature/sdk/provider/no_op_provider.rb
+    #
+    # In the example below you can see how to configure the OpenFeature SDK
+    # https://github.com/open-feature/ruby-sdk to use the Datadog feature flags provider.
+    #
+    # Example:
+    #
+    #   Make sure to enable Remote Configuration and OpenFeature in the Datadog configuration.
+    #
+    #   ```ruby
+    #   # FILE: initializers/datadog.rb
+    #   Datadog.configure do |config|
+    #     config.remote.enabled = true
+    #     config.open_feature.enabled = true
+    #   end
+    #   ```
+    #
+    #   And configure the OpenFeature SDK to use the Datadog feature flagging provider.
+    #
+    #   ```ruby
+    #   # FILE: initializers/open_feature.rb
+    #   require 'open_feature/sdk'
+    #   require 'datadog/open_feature/provider'
+    #
+    #   OpenFeature::SDK.configure do |config|
+    #     config.set_provider(Datadog::OpenFeature::Provider.new)
+    #   end
+    #   ```
+    #
+    #   Now you can create OpenFeature SDK client and use it to fetch feature flag values.
+    #
+    #   ```ruby
+    #   client = OpenFeature::SDK.build_client
+    #   context = OpenFeature::SDK::EvaluationContext.new('email' => 'john.doe@gmail.com')
+    #
+    #   client.fetch_string_value(
+    #     flag_key: 'banner', default_value: 'Greetings!', evaluation_context: context
+    #   )
+    #   # => 'Welcome back!'
+    #   ```
+    class Provider
+      NAME = 'Datadog Feature Flagging Provider'
+
+      attr_reader :metadata
+
+      def initialize
+        @metadata = ::OpenFeature::SDK::Provider::ProviderMetadata.new(name: NAME).freeze
+      end
+
+      def init
+        # no-op
+      end
+
+      def shutdown
+        # no-op
+      end
+
+      def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: :boolean, evaluation_context: evaluation_context)
+      end
+
+      def fetch_string_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: :string, evaluation_context: evaluation_context)
+      end
+
+      def fetch_number_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: :number, evaluation_context: evaluation_context)
+      end
+
+      def fetch_integer_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: :integer, evaluation_context: evaluation_context)
+      end
+
+      def fetch_float_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: :float, evaluation_context: evaluation_context)
+      end
+
+      def fetch_object_value(flag_key:, default_value:, evaluation_context: nil)
+        evaluate(flag_key, default_value: default_value, expected_type: :object, evaluation_context: evaluation_context)
+      end
+
+      private
+
+      def evaluate(flag_key, default_value:, expected_type:, evaluation_context:)
+        engine = OpenFeature.engine
+        return component_not_configured_default(default_value) if engine.nil?
+
+        result = engine.fetch_value(
+          flag_key,
+          default_value: default_value,
+          expected_type: expected_type,
+          evaluation_context: evaluation_context
+        )
+
+        if result.error?
+          return ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+            value: default_value,
+            error_code: result.error_code,
+            error_message: result.error_message,
+            reason: result.reason
+          )
+        end
+
+        ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+          value: result.value,
+          variant: result.variant,
+          reason: result.reason,
+          flag_metadata: result.flag_metadata
+        )
+      rescue => e
+        ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+          value: default_value,
+          error_code: Ext::GENERAL,
+          error_message: "#{e.class}: #{e.message}",
+          reason: Ext::ERROR
+        )
+      end
+
+      def component_not_configured_default(value)
+        ::OpenFeature::SDK::Provider::ResolutionDetails.new(
+          value: value,
+          error_code: Ext::PROVIDER_FATAL,
+          error_message: "Datadog's OpenFeature component must be configured",
+          reason: Ext::ERROR
+        )
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/remote.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../core/remote/dispatcher'
+
+module Datadog
+  module OpenFeature
+    # This module contains the remote configuration functionality for OpenFeature
+    module Remote
+      ReadError = Class.new(StandardError)
+
+      class << self
+        FFE_FLAG_CONFIGURATION_RULES = 1 << 46
+        FFE_PRODUCTS = ['FFE_FLAGS'].freeze
+        FFE_CAPABILITIES = [FFE_FLAG_CONFIGURATION_RULES].freeze
+
+        def capabilities
+          FFE_CAPABILITIES
+        end
+
+        def products
+          FFE_PRODUCTS
+        end
+
+        def receivers(telemetry)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(FFE_PRODUCTS)
+          receiver = Core::Remote::Dispatcher::Receiver.new(matcher) do |repository, changes|
+            engine = OpenFeature.engine
+            next unless engine
+
+            changes.each do |change|
+              content = repository[change.path]
+
+              unless content || change.type == :delete
+                next telemetry.error("OpenFeature: Remote Configuration change is not present on #{change.type}")
+              end
+
+              # NOTE: In the current RC implementation we immediately apply the configuration,
+              #       but that might change if we need to apply patches instead.
+              case change.type
+              when :insert, :update
+                begin
+                  # @type var content: Core::Remote::Configuration::Content
+                  engine.reconfigure!(read_content(content))
+                  content.applied
+                rescue ReadError => e
+                  content.errored("Error reading Remote Configuration content: #{e.message}")
+                rescue EvaluationEngine::ReconfigurationError => e
+                  content.errored("Error applying OpenFeature configuration: #{e.message}")
+                end
+              when :delete
+                # NOTE: For now, we treat deletion as clearing the configuration
+                #       In a multi-config scenario, we might track configs per path
+                engine.reconfigure!(nil)
+              end
+            end
+          end
+
+          [receiver]
+        end
+
+        private
+
+        def read_content(content)
+          data = content.data.read
+          content.data.rewind
+
+          raise ReadError, 'EOF reached' if data.nil?
+
+          data
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/resolution_details.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module OpenFeature
+    # This class is based on the `OpenFeature::SDK::Provider::ResolutionDetails` class
+    #
+    # See: https://github.com/open-feature/ruby-sdk/blob/v0.4.1/lib/open_feature/sdk/provider/resolution_details.rb
+    class ResolutionDetails < Struct.new(
+      :value,
+      :reason,
+      :variant,
+      :error_code,
+      :error_message,
+      :flag_metadata,
+      :allocation_key,
+      :extra_logging,
+      :log?,
+      :error?,
+      keyword_init: true
+    )
+      def self.build_error(value:, error_code:, error_message:, reason: Ext::ERROR)
+        new(
+          value: value,
+          error_code: error_code,
+          error_message: error_message,
+          reason: reason,
+          error?: true,
+          log?: false
+        ).freeze
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/transport.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../core/transport/http'
+require_relative '../core/transport/http/env'
+require_relative '../core/transport/parcel'
+require_relative '../core/transport/request'
+
+module Datadog
+  module OpenFeature
+    module Transport
+      class EncodedParcel
+        include Core::Transport::Parcel
+
+        def encode_with(encoder)
+          encoder.encode(data)
+        end
+      end
+
+      class HTTP
+        class Spec < Core::Transport::HTTP::API::Spec
+          def initialize
+            @endpoint = Core::Transport::HTTP::API::Endpoint.new(
+              :post, '/evp_proxy/v2/api/v2/exposures'
+            )
+
+            super
+          end
+
+          def call(env, &block)
+            @endpoint.call(env) do |request_env|
+              request_env.headers['Content-Type'] = Core::Encoding::JSONEncoder.content_type
+              request_env.headers['X-Datadog-EVP-Subdomain'] = 'event-platform-intake'
+              request_env.body = env.request.parcel.encode_with(Core::Encoding::JSONEncoder)
+
+              block.call(request_env)
+            end
+          end
+        end
+
+        class Instance < Core::Transport::HTTP::API::Instance
+          def send_exposures(env)
+            @spec.call(env) { |request_env| call(request_env) }
+          end
+        end
+
+        def self.build(agent_settings:, logger:)
+          Core::Transport::HTTP.build(
+            api_instance_class: HTTP::Instance,
+            agent_settings: agent_settings,
+            logger: logger
+          ) { |t| t.api('exposures', HTTP::Spec.new) }.to_transport(self)
+        end
+
+        def initialize(apis, default_api, logger:)
+          @api = apis[default_api]
+          @logger = logger
+        end
+
+        def send_exposures(payload)
+          request = Core::Transport::Request.new(EncodedParcel.new(payload))
+          @api.send_exposures(Core::Transport::HTTP::Env.new(request))
+        rescue => e
+          message = "Internal error during request. Cause: #{e.class.name} #{e.message} " \
+                    "Location: #{Array(e.backtrace).first}"
+          @logger.debug(message)
+
+          Core::Transport::InternalErrorResponse.new(e)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'core/configuration'
+require_relative 'open_feature/configuration'
+
+module Datadog
+  # A namespace for the OpenFeature component.
+  module OpenFeature
+    Core::Configuration::Settings.extend(Configuration::Settings)
+
+    def self.enabled?
+      Datadog.configuration.open_feature.enabled
+    end
+
+    def self.engine
+      Datadog.send(:components).open_feature&.engine
+    end
+  end
+end