datadog 2.30.0 → 2.45.0

data/lib/datadog/open_feature/provider.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require 'open_feature/sdk'
+require_relative "ext"
+require_relative "../core/utils/time"
+require "open_feature/sdk"
 
 module Datadog
   module OpenFeature
     # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
     #
+    # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics and EVP hook support.
+    #
+    # Hook lifecycle note: FlagEvalEVPHook is returned from #hooks so EVP uses the SDK-final
+    # EvaluationDetails. This matches FlagEvalMetricsHook and records defaults/errors produced
+    # by OpenFeature hook failures or post-provider type validation.
+    #
     # 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
@@ -51,7 +58,7 @@ module Datadog
     #   # => 'Welcome back!'
     #   ```
     class Provider
-      NAME = 'Datadog Feature Flagging Provider'
+      NAME = "Datadog Feature Flagging Provider"
 
       attr_reader :metadata
 
@@ -67,6 +74,14 @@ module Datadog
         # no-op
       end
 
+      def hooks
+        component = Datadog.send(:components).open_feature
+        [
+          component&.flag_eval_metrics_hook,
+          component&.flag_eval_evp_hook,
+        ].compact
+      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
@@ -94,46 +109,125 @@ module Datadog
       private
 
       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.
+        eval_time_ms = (Core::Utils::Time.now.to_f * 1000).to_i
+        flag_meta = nil
+
         engine = OpenFeature.engine
-        return component_not_configured_default(default_value) if engine.nil?
+        return component_not_configured_default(default_value, eval_time_ms) if engine.nil?
+
+        result = fetch_engine_value(engine, flag_key, default_value, expected_type, evaluation_context)
+
+        # Build metadata before branching so provider-returned details carry eval-entry time.
+        flag_meta = build_flag_metadata(result, eval_time_ms)
+
+        if result.error?
+          return sdk_error_details(default_value, result.error_code, result.error_message, result.reason, flag_meta)
+        end
 
-        result = engine.fetch_value(
+        # Drive APM span enrichment directly from the evaluation path. This is the only reliable
+        # way to attach `ffe_*` tags across all supported OpenFeature SDK versions, since older
+        # SDKs do not dispatch provider hooks. Guarded so enrichment can never break evaluation.
+        enrich_span(flag_key, result, evaluation_context)
+
+        sdk_success_details(result, flag_meta)
+      rescue => e
+        error_message = "#{e.class}: #{e.message}"
+        error_result = Datadog::OpenFeature::ResolutionDetails.build_error(
+          value: default_value,
+          error_code: Ext::GENERAL,
+          error_message: error_message
+        )
+        error_flag_meta = flag_meta
+        error_flag_meta ||= build_flag_metadata(
+          error_result, eval_time_ms || (Core::Utils::Time.now.to_f * 1000).to_i
+        )
+
+        sdk_error_details(default_value, Ext::GENERAL, error_message, Ext::ERROR, error_flag_meta)
+      end
+
+      def fetch_engine_value(engine, flag_key, default_value, expected_type, evaluation_context)
+        engine.fetch_value(
           flag_key,
           default_value: default_value,
           expected_type: expected_type,
           evaluation_context: evaluation_context
         )
+      end
 
-        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
-
+      def sdk_success_details(result, flag_meta)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: result.value,
           variant: result.variant,
           reason: result.reason,
-          flag_metadata: result.flag_metadata
+          flag_metadata: flag_meta,
         )
-      rescue => e
+      end
+
+      def sdk_error_details(default_value, error_code, error_message, reason, flag_meta = {})
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: default_value,
-          error_code: Ext::GENERAL,
-          error_message: "#{e.class}: #{e.message}",
-          reason: Ext::ERROR
+          error_code: error_code,
+          error_message: error_message,
+          reason: reason,
+          flag_metadata: flag_meta
         )
       end
 
-      def component_not_configured_default(value)
+      def build_flag_metadata(result, eval_time_ms)
+        metadata = result.flag_metadata&.dup || {}
+        metadata[Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA] =
+          metadata[Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA] == true
+        allocation_key = result.allocation_key
+        metadata[Ext::METADATA_ALLOCATION_KEY] = allocation_key if allocation_key && !allocation_key.empty?
+
+        # Eval-time stamped at provider entry; the EVP hook reads 'dd.eval.timestamp_ms' for
+        # accurate first/last_evaluation bounds (it falls back to hook-fire time when absent).
+        metadata["dd.eval.timestamp_ms"] = eval_time_ms
+
+        metadata
+      end
+
+      # Dispatch span enrichment from the evaluation path in a never-throw
+      # wrapper. Reads the split serial id / do-log flag directly off the Datadog
+      # `ResolutionDetails` struct and the targeting key off the built evaluation
+      # context. A nil hook (gate off or component absent) is a no-op.
+      def enrich_span(flag_key, result, evaluation_context)
+        hook = span_enrichment_hook
+        return unless hook
+
+        # Hook resolved first so the common gate-off path short-circuits without
+        # resolving the tracer. With the gate on but no active trace there is
+        # nowhere to attach tags, so skip before building the capture call.
+        return unless Datadog::Tracing.active_trace
+
+        hook.capture(
+          flag_key: flag_key,
+          variant: result.variant,
+          value: result.value,
+          serial_id: result.serial_id,
+          do_log: result.log? || false,
+          targeting_key: evaluation_context&.targeting_key,
+        )
+      rescue => e
+        Datadog.logger.debug { "OpenFeature: span enrichment dispatch failed: #{e.class}: #{e.message}" }
+      end
+
+      def span_enrichment_hook
+        Datadog.send(:components).open_feature&.span_enrichment_hook
+      end
+
+      def component_not_configured_default(value, eval_time_ms)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: value,
           error_code: Ext::PROVIDER_FATAL,
           error_message: "Datadog's OpenFeature component must be configured",
-          reason: Ext::ERROR
+          reason: Ext::ERROR,
+          flag_metadata: {
+            "dd.eval.timestamp_ms" => eval_time_ms,
+            Ext::METADATA_OBSERVE_FULL_EVALUATION_DATA => false,
+          }
         )
       end
     end

data/lib/datadog/open_feature/remote.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../core/remote/dispatcher'
+require_relative "../core/remote/dispatcher"
 
 module Datadog
   module OpenFeature
@@ -8,7 +8,7 @@ module Datadog
     module Remote
       class << self
         FFE_FLAG_CONFIGURATION_RULES = 1 << 46
-        FFE_PRODUCTS = ['FFE_FLAGS'].freeze
+        FFE_PRODUCTS = ["FFE_FLAGS"].freeze
         FFE_CAPABILITIES = [FFE_FLAG_CONFIGURATION_RULES].freeze
 
         def capabilities
@@ -19,11 +19,11 @@ module Datadog
           FFE_PRODUCTS
         end
 
-        def receivers(telemetry)
+        def receivers(telemetry, component_provider:)
           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
+            component = component_provider.call
+            next unless component
 
             changes.each do |change|
               content = repository[change.path]
@@ -38,15 +38,15 @@ module Datadog
               when :insert, :update
                 begin
                   # @type var content: Core::Remote::Configuration::Content
-                  engine.reconfigure!(read_content(content))
+                  component.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
-                  content.errored("Error applying OpenFeature configuration: #{e.message}")
+                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{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)
+                component.reconfigure!(nil)
               end
             end
           end

data/lib/datadog/open_feature/resolution_details.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
+require_relative "ext"
 
 module Datadog
   module OpenFeature
@@ -15,6 +15,7 @@ module Datadog
       :error_message,
       :flag_metadata,
       :allocation_key,
+      :serial_id,
       :extra_logging,
       :log?,
       :error?,
@@ -27,7 +28,8 @@ module Datadog
           error_message: error_message,
           reason: reason,
           error?: true,
-          log?: false
+          log?: false,
+          serial_id: nil
         ).freeze
       end
     end

data/lib/datadog/open_feature/transport.rb

@@ -1,29 +1,59 @@
 # frozen_string_literal: true
 
-require_relative '../core/encoding'
-require_relative '../core/transport/http'
-require_relative '../core/transport/http/env'
-require_relative '../core/transport/http/api/endpoint'
-require_relative '../core/transport/http/api/instance'
-require_relative '../core/transport/parcel'
-require_relative '../core/transport/request'
+require_relative "../core/encoding"
+require_relative "../core/evp"
+require_relative "../core/transport/http"
+require_relative "../core/transport/http/env"
+require_relative "../core/transport/http/api/endpoint"
+require_relative "../core/transport/http/api/instance"
+require_relative "../core/transport/parcel"
+require_relative "../core/transport/request"
+require_relative "../version"
 
 module Datadog
   module OpenFeature
     module Transport
       class HTTP
+        # API spec for the EVP exposures endpoint.
         class Spec
           def initialize
             @endpoint = Core::Transport::HTTP::API::Endpoint.new(
-              :post, '/evp_proxy/v2/api/v2/exposures'
+              :post, "/evp_proxy/v2/api/v2/exposures"
             )
           end
 
           # TODO rename to send_request?
           def call(env, &block)
             @endpoint.call(env) do |request_env|
-              request_env.headers['Content-Type'] = env.request.parcel.content_type
-              request_env.headers['X-Datadog-EVP-Subdomain'] = 'event-platform-intake'
+              request_env.headers["Content-Type"] = env.request.parcel.content_type
+              request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
+                Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.headers["DD-EVP-ORIGIN"] = "dd-trace-rb"
+              request_env.headers["DD-EVP-ORIGIN-VERSION"] = Datadog::VERSION::STRING
+              request_env.body = env.request.parcel.data
+
+              block.call(request_env)
+            end
+          end
+        end
+
+        # API spec for the EVP flagevaluation endpoint.
+        # Path: /evp_proxy/v2/api/v2/flagevaluation
+        # Header: X-Datadog-EVP-Subdomain: event-platform-intake (same as exposures)
+        class FlagevaluationsSpec
+          def initialize
+            @endpoint = Core::Transport::HTTP::API::Endpoint.new(
+              :post, "/evp_proxy/v2/api/v2/flagevaluation"
+            )
+          end
+
+          def call(env, &block)
+            @endpoint.call(env) do |request_env|
+              request_env.headers["Content-Type"] = env.request.parcel.content_type
+              request_env.headers[Core::EVP::SUBDOMAIN_HEADER_NAME] =
+                Core::EVP::EVENT_PLATFORM_INTAKE_SUBDOMAIN
+              request_env.headers["DD-EVP-ORIGIN"] = "dd-trace-rb"
+              request_env.headers["DD-EVP-ORIGIN-VERSION"] = Datadog::VERSION::STRING
               request_env.body = env.request.parcel.data
 
               block.call(request_env)
@@ -35,7 +65,15 @@ module Datadog
           Core::Transport::HTTP.build(
             agent_settings: agent_settings,
             logger: logger
-          ) { |t| t.api('exposures', HTTP::Spec.new) }.to_transport(self)
+          ) { |t| t.api("exposures", HTTP::Spec.new) }.to_transport(self)
+        end
+
+        # Build a transport instance for the flagevaluation EVP endpoint.
+        def self.build_flagevaluations(agent_settings:, logger:)
+          Core::Transport::HTTP.build(
+            agent_settings: agent_settings,
+            logger: logger
+          ) { |t| t.api("flagevaluations", HTTP::FlagevaluationsSpec.new) }.to_transport(self)
         end
 
         def initialize(apis, default_api, logger:)
@@ -55,7 +93,28 @@ module Datadog
             @api.call(env)
           end
         rescue => e
-          message = "Internal error during request. Cause: #{e.class.name} #{e.message} " \
+          message = "Internal error during request. Cause: #{e.class}: #{e.message} " \
+                    "Location: #{Array(e.backtrace).first}"
+          @logger.debug(message)
+
+          Core::Transport::InternalErrorResponse.new(e)
+        end
+
+        # POST a flag evaluations batch to /evp_proxy/v2/api/v2/flagevaluation.
+        # Mirrors send_exposures; uses the FlagevaluationsSpec endpoint.
+        def send_flag_evaluations(payload)
+          encoder = Core::Encoding::JSONEncoder
+          parcel = Core::Transport::Parcel.new(
+            encoder.encode(payload),
+            content_type: encoder.content_type
+          )
+          request = Core::Transport::Request.new(parcel)
+
+          @api.endpoint.call(Core::Transport::HTTP::Env.new(request)) do |env|
+            @api.call(env)
+          end
+        rescue => e
+          message = "Internal error during request. Cause: #{e.class}: #{e.message} " \
                     "Location: #{Array(e.backtrace).first}"
           @logger.debug(message)
 

data/lib/datadog/open_feature.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'core/configuration'
-require_relative 'open_feature/configuration'
+require_relative "core/configuration"
+require_relative "open_feature/configuration"
 
 module Datadog
   # A namespace for the OpenFeature component.

data/lib/datadog/opentelemetry/api/baggage.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'trace/span'
-require_relative '../../tracing/trace_operation'
-require_relative '../trace'
+require_relative "trace/span"
+require_relative "../../tracing/trace_operation"
+require_relative "../trace"
 
 module Datadog
   module OpenTelemetry

data/lib/datadog/opentelemetry/api/context.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'trace/span'
-require_relative '../../tracing/trace_operation'
-require_relative '../trace'
+require_relative "trace/span"
+require_relative "../../tracing/trace_operation"
+require_relative "../trace"
 
 module Datadog
   module OpenTelemetry
@@ -143,7 +143,7 @@ module Datadog
             unless calls_matched
               ::OpenTelemetry.handle_error(
                 exception: ::OpenTelemetry::Context::DetachError.new(
-                  'calls to detach should match corresponding calls to attach.'
+                  "calls to detach should match corresponding calls to attach."
                 )
               )
             end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../core/configuration/ext'
+require_relative "../../core/configuration/ext"
 
 module Datadog
   module OpenTelemetry
@@ -13,9 +13,9 @@ module Datadog
 
         def self.normalize_temporality_preference(env_var_name)
           proc do |value|
-            if value && value.to_s.downcase != 'delta' && value.to_s.downcase != 'cumulative'
+            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'
+              "delta"
             else
               value
             end
@@ -24,10 +24,10 @@ module Datadog
 
         def self.normalize_protocol(env_var_name)
           proc do |value|
-            if value && value.to_s.downcase != 'http/protobuf'
+            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'
+            "http/protobuf"
           end
         end
 
@@ -36,9 +36,9 @@ module Datadog
             return {} if value.nil? || value.empty?
 
             headers = {}
-            header_items = value.split(',')
+            header_items = value.split(",")
             header_items.each do |key_value|
-              key, header_value = key_value.split('=', 2)
+              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}")
@@ -64,27 +64,28 @@ module Datadog
               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'
+                  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.env "OTEL_EXPORTER_OTLP_TIMEOUT"
                   o.default 10_000
                 end
 
                 option :headers do |o|
+                  o.skip_telemetry true
                   o.type :hash
-                  o.env 'OTEL_EXPORTER_OTLP_HEADERS'
+                  o.env "OTEL_EXPORTER_OTLP_HEADERS"
                   o.default { {} }
-                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_HEADERS'))
+                  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.env "OTEL_EXPORTER_OTLP_ENDPOINT"
                   o.default nil
                 end
               end
@@ -95,59 +96,125 @@ module Datadog
                 # 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.env "DD_METRICS_OTEL_ENABLED"
                   o.default false
                 end
 
                 option :exporter do |o|
                   o.type :string
-                  o.env 'OTEL_METRICS_EXPORTER'
-                  o.default 'otlp'
+                  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.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.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'))
+                  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.env "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"
                   o.default nil
                 end
 
                 option :headers do |o|
+                  o.skip_telemetry true
                   o.type :hash, nilable: true
-                  o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
+                  o.env "OTEL_EXPORTER_OTLP_METRICS_HEADERS"
                   o.default nil
-                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_METRICS_HEADERS'))
+                  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.env "OTEL_EXPORTER_OTLP_METRICS_TIMEOUT"
                   o.default 10000
                 end
 
                 option :protocol do |o|
                   o.type :string, nilable: true
-                  o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
+                  o.env "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL"
+                  o.default "http/protobuf"
+                  o.setter(&Settings.normalize_protocol("OTEL_EXPORTER_OTLP_METRICS_PROTOCOL"))
+                end
+              end
+
+              settings :logs do
+                option :enabled do |o|
+                  o.type :bool
+                  o.env "DD_LOGS_OTEL_ENABLED"
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env "OTEL_LOGS_EXPORTER"
+                  o.default "otlp"
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash, nilable: true
+                  o.env "OTEL_EXPORTER_OTLP_LOGS_HEADERS"
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser("OTEL_EXPORTER_OTLP_LOGS_HEADERS"))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT"
+                  o.default 10_000
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL"
                   o.default "http/protobuf"
-                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
+                  o.setter(&Settings.normalize_protocol("OTEL_EXPORTER_OTLP_LOGS_PROTOCOL"))
+                end
+
+                option :max_queue_size do |o|
+                  o.type :int
+                  o.env "OTEL_BLRP_MAX_QUEUE_SIZE"
+                  o.default 2048
+                end
+
+                option :schedule_delay_millis do |o|
+                  o.type :int
+                  o.env "OTEL_BLRP_SCHEDULE_DELAY"
+                  o.default 1000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env "OTEL_BLRP_EXPORT_TIMEOUT"
+                  o.default 30_000
+                end
+
+                option :max_export_batch_size do |o|
+                  o.type :int
+                  o.env "OTEL_BLRP_MAX_EXPORT_BATCH_SIZE"
+                  o.default 512
                 end
               end
             end

data/lib/datadog/opentelemetry/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Ext
+      EXPORTER_NONE = "none"
+    end
+  end
+end