[FFL-1319] Add feature flags events exposure

.rubocop.yml

@@ -47,6 +47,8 @@ Style:
     - "spec/datadog/kit/**/**"
     - "spec/datadog/profiling*"
     - "spec/datadog/profiling/**/*"
+    - "spec/datadog/open_feature*"
+    - "spec/datadog/open_feature/**/*"
     - "yard/**/*.rb"
 
 Layout:

appraisal/ruby-3.4.rb

@@ -187,7 +187,7 @@
   gem 'resque'
   gem 'roda', '>= 2.0.0'
   gem 'semantic_logger', '~> 4.0'
-  # Note: Sidekiq 8 uses different timestamp formatting compared to prior versions. As long as
+  # NOTE: Sidekiq 8 uses different timestamp formatting compared to prior versions. As long as
   # versions <8 are supported, make sure there's some CI running both older and newer versions.
   gem 'sidekiq', '~> 8'
   gem 'sneakers', '>= 2.12.0'

lib/datadog.rb

@@ -9,6 +9,7 @@
 require_relative 'datadog/appsec'
 require_relative 'datadog/di'
 require_relative 'datadog/data_streams'
+require_relative 'datadog/open_feature'
 
 # Line probes will not work on Ruby < 2.6 because of lack of :script_compiled
 # trace point. Activate DI automatically on supported Ruby versions but

lib/datadog/core/configuration/components.rb

@@ -15,6 +15,7 @@
 require_relative '../../profiling/component'
 require_relative '../../appsec/component'
 require_relative '../../di/component'
+require_relative '../../open_feature/component'
 require_relative '../../error_tracking/component'
 require_relative '../crashtracking/component'
 require_relative '../environment/agent_info'
@@ -106,7 +107,8 @@ def build_data_streams(settings, agent_settings, logger)
           :dynamic_instrumentation,
           :appsec,
           :agent_info,
-          :data_streams
+          :data_streams,
+          :open_feature
 
         def initialize(settings)
           @settings = settings
@@ -140,6 +142,7 @@ def initialize(settings)
           @runtime_metrics = self.class.build_runtime_metrics_worker(settings, @logger, telemetry)
           @health_metrics = self.class.build_health_metrics(settings, @logger, telemetry)
           @appsec = Datadog::AppSec::Component.build_appsec_component(settings, telemetry: telemetry)
+          @open_feature = OpenFeature::Component.build(settings, agent_settings, logger: @logger, telemetry: telemetry)
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
           @error_tracking = Datadog::ErrorTracking::Component.build(settings, @tracer, @logger)
           @data_streams = self.class.build_data_streams(settings, agent_settings, @logger)
@@ -199,6 +202,9 @@ def shutdown!(replacement = nil)
           # Shutdown DI after remote, since remote config triggers DI operations.
           dynamic_instrumentation&.shutdown!
 
+          # Shutdown OpenFeature component
+          open_feature&.shutdown!
+
           # Decommission AppSec
           appsec&.shutdown!
 

lib/datadog/core/configuration/supported_configurations.rb

@@ -43,6 +43,7 @@ module Configuration
          "DD_ENV" => {version: ["A"]},
          "DD_ERROR_TRACKING_HANDLED_ERRORS" => {version: ["A"]},
          "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE" => {version: ["A"]},
+         "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED" => {version: ["A"]},
          "DD_GIT_COMMIT_SHA" => {version: ["A"]},
          "DD_GIT_REPOSITORY_URL" => {version: ["A"]},
          "DD_HEALTH_METRICS_ENABLED" => {version: ["A"]},

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

@@ -3,6 +3,7 @@
 require_relative '../../utils/base64'
 require_relative '../../../appsec/remote'
 require_relative '../../../tracing/remote'
+require_relative '../../../open_feature/remote'
 
 module Datadog
   module Core
@@ -38,6 +39,12 @@ def register(settings)
               register_receivers(Datadog::DI::Remote.receivers(@telemetry))
             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
+
             register_capabilities(Datadog::Tracing::Remote.capabilities)
             register_products(Datadog::Tracing::Remote.products)
             register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))

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

lib/datadog/open_feature/component.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'evaluation_engine'
+require_relative 'exposures/buffer'
+require_relative 'exposures/worker'
+require_relative 'exposures/deduplicator'
+require_relative 'exposures/reporter'
+require_relative 'transport/http'
+
+module Datadog
+  module OpenFeature
+    # This class is the entry point for the OpenFeature component
+    class Component
+      attr_reader :engine
+
+      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/agent/remote_config'
+          logger.warn(message)
+
+          return
+        end
+
+        new(settings, agent_settings, logger: logger, telemetry: telemetry)
+      end
+
+      def initialize(settings, agent_settings, logger:, telemetry:)
+        transport = Transport::HTTP.build(agent_settings: agent_settings, logger: logger)
+        @worker = Exposures::Worker.new(settings: settings, transport: transport, telemetry: telemetry, logger: logger)
+
+        reporter = Exposures::Reporter.new(@worker, telemetry: telemetry, logger: logger)
+        @engine = EvaluationEngine.new(reporter, telemetry: telemetry, logger: logger)
+      end
+
+      def shutdown!
+        @worker.graceful_shutdown
+      end
+    end
+  end
+end

lib/datadog/open_feature/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Configuration
+      # A settings class for the OpenFeature component.
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :open_feature do
+              option :enabled do |o|
+                o.type :bool
+                o.env 'DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED'
+                o.default false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/datadog/open_feature/evaluation_engine.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'noop_evaluator'
+require_relative 'resolution_details'
+
+module Datadog
+  module OpenFeature
+    # This class performs the evaluation of the feature flag
+    class EvaluationEngine
+      ReconfigurationError = Class.new(StandardError)
+
+      ALLOWED_TYPES = %w[boolean string number float integer object].freeze
+
+      def initialize(reporter, telemetry:, logger:)
+        @reporter = reporter
+        @telemetry = telemetry
+        @logger = logger
+
+        @evaluator = NoopEvaluator.new(nil)
+      end
+
+      def fetch_value(flag_key:, default_value:, expected_type:, evaluation_context: nil)
+        unless ALLOWED_TYPES.include?(expected_type)
+          message = "unknown type #{expected_type.inspect}, allowed types #{ALLOWED_TYPES.join(", ")}"
+          return ResolutionDetails.build_error(
+            value: default_value, error_code: Ext::UNKNOWN_TYPE, error_message: message
+          )
+        end
+
+        context = evaluation_context&.fields || {}
+        result = @evaluator.get_assignment(flag_key, default_value, context, expected_type)
+
+        @reporter.report(result, flag_key: flag_key, context: evaluation_context)
+
+        result
+      rescue => e
+        @telemetry.report(e, description: 'OpenFeature: Failed to fetch flag value')
+
+        ResolutionDetails.build_error(
+          value: default_value, error_code: Ext::PROVIDER_FATAL, error_message: e.message
+        )
+      end
+
+      def reconfigure!(configuration)
+        @logger.debug('OpenFeature: Removing configuration') if configuration.nil?
+
+        @evaluator = NoopEvaluator.new(configuration)
+      rescue => e
+        message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
+
+        @logger.error("#{message}, error #{e.inspect}")
+        @telemetry.report(e, description: message)
+
+        raise ReconfigurationError, e.message
+      end
+    end
+  end
+end

lib/datadog/open_feature/exposures/batch_builder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class builds a batch of exposures and context to be sent to the Agent
+      class BatchBuilder
+        def initialize(settings)
+          @context = build_context(settings)
+        end
+
+        def payload_for(events)
+          {
+            context: @context,
+            exposures: events
+          }
+        end
+
+        private
+
+        def build_context(settings)
+          context = {}
+          context[:env] = settings.env if settings.env
+          context[:service] = settings.service if settings.service
+          context[:version] = settings.version if settings.version
+
+          context
+        end
+      end
+    end
+  end
+end

lib/datadog/open_feature/exposures/buffer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../core/buffer/cruby'
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class is a buffer for exposure events that evicts at random and
+      # keeps track of the number of dropped events
+      #
+      # WARNING: This class does not work as intended on JRuby
+      class Buffer < Core::Buffer::CRuby
+        DEFAULT_LIMIT = 1_000
+
+        attr_reader :dropped_count
+
+        def initialize(limit = DEFAULT_LIMIT)
+          @dropped = 0
+          @dropped_count = 0
+
+          super
+        end
+
+        protected
+
+        def drain!
+          drained = super
+
+          @dropped_count = @dropped
+          @dropped = 0
+
+          drained
+        end
+
+        def replace!(item)
+          @dropped += 1
+
+          super
+        end
+      end
+    end
+  end
+end

lib/datadog/open_feature/exposures/deduplicator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../core/utils/lru_cache'
+
+module Datadog
+  module OpenFeature
+    module Exposures
+      # This class is a deduplication buffer based on LRU cache for exposure events
+      class Deduplicator
+        DEFAULT_CACHE_LIMIT = 1_000
+
+        def initialize(limit: DEFAULT_CACHE_LIMIT)
+          @cache = Datadog::Core::Utils::LRUCache.new(limit)
+          @mutex = Mutex.new
+        end
+
+        def duplicate?(key, value)
+          @mutex.synchronize do
+            stored = @cache[key]
+            return true if stored == value
+
+            @cache[key] = value
+          end
+
+          false
+        end
+      end
+    end
+  end
+end