datadog 2.21.0 → 2.23.0

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

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    module Configuration
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.normalize_temporality_preference(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'delta' && value.to_s.downcase != 'cumulative'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using delta instead.")
+              'delta'
+            else
+              value
+            end
+          end
+        end
+
+        def self.normalize_protocol(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'http/protobuf'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using http/protobuf instead.")
+            end
+            'http/protobuf'
+          end
+        end
+
+        def self.headers_parser(env_var_name)
+          lambda do |value|
+            return {} if value.nil? || value.empty?
+
+            headers = {}
+            header_items = value.split(',')
+            header_items.each do |key_value|
+              key, header_value = key_value.split('=', 2)
+              # If header is malformed, return an empty hash
+              if key.nil? || header_value.nil?
+                Datadog.logger.warn("#{env_var_name} has malformed header: #{key_value.inspect}")
+                return {}
+              end
+
+              key.strip!
+              header_value.strip!
+              if key.empty? || header_value.empty?
+                Datadog.logger.warn("#{env_var_name} has empty key or value in: #{key_value.inspect}")
+                return {}
+              end
+
+              headers[key] = header_value
+            end
+            headers
+          end
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :opentelemetry do
+              settings :exporter do
+                option :protocol do |o|
+                  o.type :string
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_PROTOCOL'))
+                  o.env 'OTEL_EXPORTER_OTLP_PROTOCOL'
+                  o.default 'http/protobuf'
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_EXPORTER_OTLP_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :headers do |o|
+                  o.type :hash
+                  o.env 'OTEL_EXPORTER_OTLP_HEADERS'
+                  o.default { {} }
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_HEADERS'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_ENDPOINT'
+                  o.default nil
+                end
+              end
+
+              settings :metrics do
+                # Metrics-specific options default to nil to detect unset state.
+                # If a metrics-specific env var (e.g., OTEL_EXPORTER_OTLP_METRICS_TIMEOUT) is not set,
+                # we fall back to the general OTLP env var (e.g., OTEL_EXPORTER_OTLP_TIMEOUT) per OpenTelemetry spec.
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_METRICS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_METRICS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :export_interval_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_INTERVAL'
+                  o.default 10_000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_TIMEOUT'
+                  o.default 7_500
+                end
+
+                option :temporality_preference do |o|
+                  o.type :string
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'
+                  o.default 'delta'
+                  o.setter(&Settings.normalize_temporality_preference('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_METRICS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT'
+                  o.default nil
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
+                  o.default nil
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/metrics.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    class Metrics
+      EXPORTER_NONE = 'none'
+
+      def self.initialize!(components)
+        new(components).configure_metrics_sdk
+        true
+      rescue => exc
+        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc}: #{exc.backtrace.join("\n")}")
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_metrics_sdk
+        provider = ::OpenTelemetry.meter_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+        # The OpenTelemetry SDK defaults to cumulative temporality, but Datadog prefers delta temporality.
+        # Here is an example of how this config is applied: https://github.com/open-telemetry/opentelemetry-ruby/blob/1933d4c18e5f5e45c53fa9e902e58aa91e85cc38/metrics_sdk/lib/opentelemetry/sdk/metrics/aggregation/sum.rb#L14
+        if DATADOG_ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'].nil?
+          ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'] = 'delta' # rubocop:disable CustomCops/EnvUsageCop
+        end
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+        configure_metric_reader(provider)
+        ::OpenTelemetry.meter_provider = provider
+      end
+
+      private
+
+      def create_resource
+        resource_attributes = {}
+        resource_attributes['host.name'] = Datadog::Core::Environment::Socket.hostname if @settings.tracing.report_hostname
+
+        @settings.tags&.each do |key, value|
+          otel_key = case key
+          when 'service' then 'service.name'
+          when 'env' then 'deployment.environment'
+          when 'version' then 'service.version'
+          else key
+          end
+          resource_attributes[otel_key] = value
+        end
+
+        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        resource_attributes['deployment.environment'] = @settings.env if @settings.env
+        resource_attributes['service.version'] = @settings.version if @settings.version
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      def configure_metric_reader(provider)
+        exporter_name = @settings.opentelemetry.metrics.exporter
+        return if exporter_name == EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
+      end
+
+      def resolve_metrics_endpoint
+        metrics_config = @settings.opentelemetry.metrics
+        exporter_config = @settings.opentelemetry.exporter
+
+        return metrics_config.endpoint if metrics_config.endpoint
+        return exporter_config.endpoint if exporter_config.endpoint
+        "#{@agent_ssl ? "https" : "http"}://#{@agent_host}:4318/v1/metrics"
+      end
+
+      def configure_otlp_exporter(provider)
+        require 'opentelemetry/exporter/otlp_metrics'
+        require_relative 'sdk/metrics_exporter'
+
+        metrics_config = @settings.opentelemetry.metrics
+        exporter_config = @settings.opentelemetry.exporter
+        timeout = metrics_config.timeout_millis || exporter_config.timeout_millis
+        headers = metrics_config.headers || exporter_config.headers || {}
+
+        protocol = metrics_config.protocol || exporter_config.protocol
+        exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
+          endpoint: resolve_metrics_endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers,
+          protocol: protocol
+        )
+
+        reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+          exporter: exporter,
+          export_interval_millis: metrics_config.export_interval_millis,
+          export_timeout_millis: metrics_config.export_timeout_millis
+        )
+        provider.add_metric_reader(reader)
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -30,7 +30,31 @@ module Datadog
           [SpanProcessor.new]
         end
 
-        ::OpenTelemetry::SDK::Configurator.prepend(self)
+        def metrics_configuration_hook
+          components = Datadog.send(:components)
+          return super unless components.settings.opentelemetry.metrics.enabled
+
+          begin
+            require 'opentelemetry-metrics-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc}")
+            return super
+          end
+
+          success = Datadog::OpenTelemetry::Metrics.initialize!(components)
+          super unless success
+        end
+
+        # Prepend to ConfiguratorPatch (not Configurator) so our hook runs first.
+        begin
+          require 'opentelemetry-metrics-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        if defined?(::OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.ancestors.include?(self)
+        end
+        ::OpenTelemetry::SDK::Configurator.prepend(self) unless ::OpenTelemetry::SDK::Configurator.ancestors.include?(self)
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_metrics'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class MetricsExporter < ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
+
+        def initialize(endpoint:, timeout:, headers:, protocol:)
+          super(endpoint: endpoint, timeout: timeout, headers: headers)
+          @telemetry_tags = {'protocol' => protocol, 'encoding' => 'protobuf'}
+        end
+
+        def export(metrics, timeout: nil)
+          telemetry&.inc('tracers', METRIC_EXPORT_ATTEMPTS, 1, tags: @telemetry_tags)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          telemetry&.inc('tracers', metric_name, 1, tags: @telemetry_tags)
+          result
+        rescue => e
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
+          telemetry&.inc('tracers', METRIC_EXPORT_FAILURES, 1, tags: @telemetry_tags)
+          raise
+        end
+
+        private
+
+        def telemetry
+          Datadog.send(:components).telemetry
+        end
+      end
+    end
+  end
+end