ddtrace 1.12.1 → 1.18.0

data/lib/datadog/core/remote/transport/http.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../../environment/container'
+require_relative '../../environment/ext'
+require_relative '../../transport/ext'
+require_relative '../../transport/http/adapters/net'
+require_relative '../../transport/http/adapters/unix_socket'
+require_relative '../../transport/http/adapters/test'
+
+# TODO: Improve negotiation to allow per endpoint selection
+#
+# Since endpoint negotiation happens at the `API::Spec` level there can not be
+# a mix of endpoints at various versions or versionless without describing all
+# the possible combinations as specs. See http/api.
+#
+# Below should be:
+# require_relative '../../transport/http/api'
+require_relative 'http/api'
+
+# TODO: Decouple transport/http/builder
+#
+# See http/builder
+#
+# Below should be:
+# require_relative '../../transport/http/builder'
+require_relative 'http/builder'
+
+# TODO: Decouple transport/http
+#
+# Because a new transport is required for every (API, Client, Transport)
+# triplet and endpoints cannot be negotiated independently, there can not be a
+# single `default` transport, but only endpoint-specific ones.
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        # Namespace for HTTP transport components
+        module HTTP
+          # NOTE: Due to... legacy reasons... This class likes having a default `AgentSettings` instance to fall back to.
+          # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
+          # represents only settings specified via environment variables + the usual defaults.
+          #
+          # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
+            Datadog::Core::Configuration::Settings.new,
+            logger: nil,
+          )
+
+          module_function
+
+          # Builds a new Transport::HTTP::Client
+          def new(klass, &block)
+            Builder.new(&block).to_transport(klass)
+          end
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def root(
+            agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+            **options
+          )
+            new(Core::Remote::Transport::Negotiation::Transport) do |transport|
+              transport.adapter(agent_settings)
+              transport.headers(default_headers)
+
+              apis = API.defaults
+
+              transport.api API::ROOT, apis[API::ROOT]
+
+              # Apply any settings given by options
+              unless options.empty?
+                transport.default_api = options[:api_version] if options.key?(:api_version)
+                transport.headers options[:headers] if options.key?(:headers)
+              end
+
+              if agent_settings.deprecated_for_removal_transport_configuration_proc
+                agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+              end
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end
+          end
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def v7(
+            agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+            **options
+          )
+            new(Core::Remote::Transport::Config::Transport) do |transport|
+              transport.adapter(agent_settings)
+              transport.headers default_headers
+
+              apis = API.defaults
+
+              transport.api API::V7, apis[API::V7]
+
+              # Apply any settings given by options
+              unless options.empty?
+                transport.default_api = options[:api_version] if options.key?(:api_version)
+                transport.headers options[:headers] if options.key?(:headers)
+              end
+
+              if agent_settings.deprecated_for_removal_transport_configuration_proc
+                agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+              end
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end
+          end
+
+          def default_headers
+            {
+              Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+              Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+              Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION =>
+                Datadog::Core::Environment::Ext::LANG_VERSION,
+              Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+                Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+              Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
+                Datadog::Core::Environment::Ext::TRACER_VERSION
+            }.tap do |headers|
+              # Add container ID, if present.
+              container_id = Datadog::Core::Environment::Container.container_id
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+            end
+          end
+
+          def default_adapter
+            Datadog::Core::Transport::Ext::HTTP::ADAPTER
+          end
+
+          def default_hostname(logger: Datadog.logger)
+            logger.warn(
+              'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+                'be removed on a future ddtrace release.'
+            )
+
+            DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
+          end
+
+          def default_port(logger: Datadog.logger)
+            logger.warn(
+              'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+                'be removed on a future ddtrace release.'
+            )
+
+            DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
+          end
+
+          def default_url(logger: Datadog.logger)
+            logger.warn(
+              'Deprecated for removal: Using #default_url for configuration is deprecated and will ' \
+                'be removed on a future ddtrace release.'
+            )
+
+            nil
+          end
+
+          # Add adapters to registry
+          Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Net, Datadog::Core::Transport::Ext::HTTP::ADAPTER)
+          Builder::REGISTRY.set(
+            Datadog::Core::Transport::HTTP::Adapters::Test,
+            Datadog::Core::Transport::Ext::Test::ADAPTER
+          )
+          Builder::REGISTRY.set(
+            Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
+            Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/{transport → remote/transport}/negotiation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../ddtrace/transport/request'
+require_relative '../../../core/transport/request'
 
 # TODO: Resolve conceptual conundrum
 #
@@ -23,35 +23,37 @@ require_relative '../../../ddtrace/transport/request'
 
 module Datadog
   module Core
-    module Transport
-      module Negotiation
-        # Negotiation request
-        class Request < Datadog::Transport::Request
-        end
+    module Remote
+      module Transport
+        module Negotiation
+          # Negotiation request
+          class Request < Datadog::Core::Transport::Request
+          end
 
-        # Negotiation response
-        module Response
-          attr_reader :version, :endpoints, :config
-        end
+          # Negotiation response
+          module Response
+            attr_reader :version, :endpoints, :config
+          end
 
-        # Negotiation transport
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
+          # Negotiation transport
+          class Transport
+            attr_reader :client, :apis, :default_api, :current_api_id
 
-          def initialize(apis, default_api)
-            @apis = apis
+            def initialize(apis, default_api)
+              @apis = apis
 
-            @client = HTTP::Client.new(current_api)
-          end
+              @client = HTTP::Client.new(current_api)
+            end
 
-          def send_info
-            request = Request.new
+            def send_info
+              request = Request.new
 
-            @client.send_info_payload(request)
-          end
+              @client.send_info_payload(request)
+            end
 
-          def current_api
-            @apis[HTTP::API::ROOT]
+            def current_api
+              @apis[HTTP::API::ROOT]
+            end
           end
         end
       end

data/lib/datadog/core/remote/worker.rb

@@ -28,7 +28,10 @@ module Datadog
 
           @starting = true
 
-          @thr = Thread.new { poll(@interval) }
+          thread = Thread.new { poll(@interval) }
+          thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          thread.thread_variable_set(:fork_safe, true)
+          @thr = thread
 
           @started = true
           @starting = false

data/lib/datadog/core/runtime/ext.rb

@@ -1,26 +1,36 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Runtime
       # @public_api
       module Ext
-        TAG_ID = 'runtime-id'.freeze
-        TAG_LANG = 'language'.freeze
-        TAG_PROCESS_ID = 'process_id'.freeze
+        TAG_ID = 'runtime-id'
+        TAG_LANG = 'language'
+        TAG_PROCESS_ID = 'process_id'
 
         # Metrics
         # @public_api
         module Metrics
-          ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'.freeze
+          ENV_ENABLED = 'DD_RUNTIME_METRICS_ENABLED'
 
-          METRIC_CLASS_COUNT = 'runtime.ruby.class_count'.freeze
-          METRIC_GC_PREFIX = 'runtime.ruby.gc'.freeze
-          METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'.freeze
-          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'.freeze
-          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'.freeze
-          METRIC_CONSTANT_CACHE_INVALIDATIONS = 'runtime.ruby.constant_cache_invalidations'.freeze
-          METRIC_CONSTANT_CACHE_MISSES = 'runtime.ruby.constant_cache_misses'.freeze
+          METRIC_CLASS_COUNT = 'runtime.ruby.class_count'
+          METRIC_GC_PREFIX = 'runtime.ruby.gc'
+          METRIC_THREAD_COUNT = 'runtime.ruby.thread_count'
+          METRIC_GLOBAL_CONSTANT_STATE = 'runtime.ruby.global_constant_state'
+          METRIC_GLOBAL_METHOD_STATE = 'runtime.ruby.global_method_state'
+          METRIC_CONSTANT_CACHE_INVALIDATIONS = 'runtime.ruby.constant_cache_invalidations'
+          METRIC_CONSTANT_CACHE_MISSES = 'runtime.ruby.constant_cache_misses'
+          METRIC_YJIT_CODE_GC_COUNT = 'runtime.ruby.yjit.code_gc_count'
+          METRIC_YJIT_CODE_REGION_SIZE = 'runtime.ruby.yjit.code_region_size'
+          METRIC_YJIT_FREED_CODE_SIZE = 'runtime.ruby.yjit.freed_code_size'
+          METRIC_YJIT_FREED_PAGE_COUNT = 'runtime.ruby.yjit.freed_page_count'
+          METRIC_YJIT_INLINE_CODE_SIZE = 'runtime.ruby.yjit.inline_code_size'
+          METRIC_YJIT_LIVE_PAGE_COUNT = 'runtime.ruby.yjit.live_page_count'
+          METRIC_YJIT_OBJECT_SHAPE_COUNT = 'runtime.ruby.yjit.object_shape_count'
+          METRIC_YJIT_OUTLINED_CODE_SIZE = 'runtime.ruby.yjit.outlined_code_size'
 
-          TAG_SERVICE = 'service'.freeze
+          TAG_SERVICE = 'service'
         end
       end
     end

data/lib/datadog/core/runtime/metrics.rb

@@ -5,6 +5,7 @@ require_relative '../environment/class_count'
 require_relative '../environment/gc'
 require_relative '../environment/thread_count'
 require_relative '../environment/vm_cache'
+require_relative '../environment/yjit'
 
 module Datadog
   module Core
@@ -78,6 +79,8 @@ module Datadog
               )
             end
           end
+
+          flush_yjit_stats
         end
 
         def gc_metrics
@@ -134,6 +137,46 @@ module Datadog
         def gauge_if_not_nil(metric_name, metric_value)
           gauge(metric_name, metric_value) if metric_value
         end
+
+        def flush_yjit_stats
+          # Only on Ruby >= 3.2
+          try_flush do
+            if Core::Environment::YJIT.available?
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_CODE_GC_COUNT,
+                Core::Environment::YJIT.code_gc_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_CODE_REGION_SIZE,
+                Core::Environment::YJIT.code_region_size
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_FREED_CODE_SIZE,
+                Core::Environment::YJIT.freed_code_size
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_FREED_PAGE_COUNT,
+                Core::Environment::YJIT.freed_page_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_INLINE_CODE_SIZE,
+                Core::Environment::YJIT.inline_code_size
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_LIVE_PAGE_COUNT,
+                Core::Environment::YJIT.live_page_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_OBJECT_SHAPE_COUNT,
+                Core::Environment::YJIT.object_shape_count
+              )
+              gauge_if_not_nil(
+                Core::Runtime::Ext::Metrics::METRIC_YJIT_OUTLINED_CODE_SIZE,
+                Core::Environment::YJIT.outlined_code_size
+              )
+            end
+          end
+        end
       end
     end
   end

data/lib/datadog/core/telemetry/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'emitter'
 require_relative 'heartbeat'
 require_relative '../utils/forking'
@@ -16,12 +18,13 @@ module Datadog
         include Core::Utils::Forking
 
         # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
-        def initialize(enabled: true)
+        # @param heartbeat_interval_seconds [Float] How frequently heartbeats will be reported, in seconds.
+        def initialize(heartbeat_interval_seconds:, enabled: true)
           @enabled = enabled
           @emitter = Emitter.new
           @stopped = false
           @unsupported = false
-          @worker = Telemetry::Heartbeat.new(enabled: @enabled) do
+          @worker = Telemetry::Heartbeat.new(enabled: @enabled, heartbeat_interval_seconds: heartbeat_interval_seconds) do
             heartbeat!
           end
         end
@@ -64,6 +67,13 @@ module Datadog
           @emitter.request(:'app-integrations-change')
         end
 
+        # Report configuration changes caused by Remote Configuration.
+        def client_configuration_change!(changes)
+          return if !@enabled || forked?
+
+          @emitter.request('app-client-configuration-change', data: { changes: changes, origin: 'remote_config' })
+        end
+
         private
 
         def heartbeat!

data/lib/datadog/core/telemetry/collector.rb

@@ -11,7 +11,7 @@ require_relative 'v1/dependency'
 require_relative 'v1/host'
 require_relative 'v1/integration'
 require_relative 'v1/product'
-require_relative '../../../ddtrace/transport/ext'
+require_relative '../transport/ext'
 
 module Datadog
   module Core
@@ -43,11 +43,19 @@ module Datadog
 
         # Forms a hash of standard key value pairs to be sent in the app-started event configuration
         def configurations
+          config = Datadog.configuration
           hash = {
-            DD_AGENT_HOST: Datadog.configuration.agent.host,
+            DD_AGENT_HOST: config.agent.host,
             DD_AGENT_TRANSPORT: agent_transport,
-            DD_TRACE_SAMPLE_RATE: format_configuration_value(Datadog.configuration.tracing.sampling.default_rate),
+            DD_TRACE_SAMPLE_RATE: format_configuration_value(config.tracing.sampling.default_rate),
+            DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED: config.tracing.contrib.global_default_service_name.enabled
           }
+          peer_service_mapping_str = ''
+          unless config.tracing.contrib.peer_service_mapping.empty?
+            peer_service_mapping = config.tracing.contrib.peer_service_mapping
+            peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
+          end
+          hash[:DD_TRACE_PEER_SERVICE_MAPPING] = peer_service_mapping_str
           hash.compact!
           hash
         end
@@ -138,6 +146,7 @@ module Datadog
           options['logger.instance'] = configuration.logger.instance.class.to_s
           options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
           options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
+          options['tracing.opentracing.enabled'] = !defined?(Datadog::OpenTracer::LOADED).nil?
           options.compact!
           options
         end
@@ -182,7 +191,7 @@ module Datadog
 
         def agent_transport
           adapter = Core::Configuration::AgentSettingsResolver.call(Datadog.configuration).adapter
-          if adapter == Datadog::Transport::Ext::UnixSocket::ADAPTER
+          if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
             'UDS'
           else
             'TCP'

data/lib/datadog/core/telemetry/emitter.rb

@@ -21,11 +21,13 @@ module Datadog
 
         # Retrieves and emits a TelemetryRequest object based on the request type specified
         # @param request_type [String] the type of telemetry request to collect data for
-        def request(request_type)
+        # @param data [Object] arbitrary object to be passed to the respective `request_type` handler
+        def request(request_type, data: nil)
           begin
             request = Datadog::Core::Telemetry::Event.new.telemetry_request(
               request_type: request_type,
-              seq_id: self.class.sequence.next
+              seq_id: self.class.sequence.next,
+              data: data,
             ).to_h
             @http_transport.request(request_type: request_type.to_s, payload: request.to_json)
           rescue StandardError => e

data/lib/datadog/core/telemetry/event.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require_relative 'collector'
 require_relative 'v1/app_event'
 require_relative 'v1/telemetry_request'
+require_relative 'v2/app_client_configuration_change'
 
 module Datadog
   module Core
@@ -9,7 +12,7 @@ module Datadog
       class Event
         include Telemetry::Collector
 
-        API_VERSION = 'v1'.freeze
+        API_VERSION = 'v1'
 
         attr_reader \
           :api_version
@@ -21,12 +24,13 @@ module Datadog
         # Forms a TelemetryRequest object based on the event request_type
         # @param request_type [String] the type of telemetry request to collect data for
         # @param seq_id [Integer] the ID of the request; incremented each time a telemetry request is sent to the API
-        def telemetry_request(request_type:, seq_id:)
+        # @param data [Object] arbitrary object to be passed to the respective `request_type` handler
+        def telemetry_request(request_type:, seq_id:, data: nil)
           Telemetry::V1::TelemetryRequest.new(
             api_version: @api_version,
             application: application,
             host: host,
-            payload: payload(request_type),
+            payload: payload(request_type, data),
             request_type: request_type,
             runtime_id: runtime_id,
             seq_id: seq_id,
@@ -36,7 +40,7 @@ module Datadog
 
         private
 
-        def payload(request_type)
+        def payload(request_type, data)
           case request_type
           when :'app-started'
             app_started
@@ -44,6 +48,8 @@ module Datadog
             {}
           when :'app-integrations-change'
             app_integrations_change
+          when 'app-client-configuration-change'
+            app_client_configuration_change(data)
           else
             raise ArgumentError, "Request type invalid, received request_type: #{@request_type}"
           end
@@ -61,6 +67,15 @@ module Datadog
         def app_integrations_change
           Telemetry::V1::AppEvent.new(integrations: integrations)
         end
+
+        # DEV: During the transition from V1 to V2, the backend accepts many V2
+        # DEV: payloads through the V1 transport protocol.
+        # DEV: The `app-client-configuration-change` payload is one of them.
+        # DEV: Once V2 is fully implemented, `Telemetry::V2::AppClientConfigurationChange`
+        # DEV: should be reusable without major modifications.
+        def app_client_configuration_change(data)
+          Telemetry::V2::AppClientConfigurationChange.new(data[:changes], origin: data[:origin])
+        end
       end
     end
   end

data/lib/datadog/core/telemetry/ext.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Telemetry
       module Ext
-        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'.freeze
+        ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'
+        ENV_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_HEARTBEAT_INTERVAL'
       end
     end
   end

data/lib/datadog/core/telemetry/heartbeat.rb

@@ -10,13 +10,11 @@ module Datadog
       class Heartbeat < Core::Worker
         include Core::Workers::Polling
 
-        DEFAULT_INTERVAL_SECONDS = 60
-
-        def initialize(enabled: true, interval: DEFAULT_INTERVAL_SECONDS, &block)
+        def initialize(heartbeat_interval_seconds:, enabled: true, &block)
           # Workers::Polling settings
           self.enabled = enabled
           # Workers::IntervalLoop settings
-          self.loop_base_interval = interval
+          self.loop_base_interval = heartbeat_interval_seconds
           self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
           super(&block)
           start

data/lib/datadog/core/telemetry/http/ext.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 module Datadog
   module Core
     module Telemetry
       module Http
         module Ext
-          HEADER_DD_API_KEY = 'DD-API-KEY'.freeze
-          HEADER_CONTENT_TYPE = 'Content-Type'.freeze
-          HEADER_CONTENT_LENGTH = 'Content-Length'.freeze
-          HEADER_DD_TELEMETRY_API_VERSION = 'DD-Telemetry-API-Version'.freeze
-          HEADER_DD_TELEMETRY_REQUEST_TYPE = 'DD-Telemetry-Request-Type'.freeze
+          HEADER_DD_API_KEY = 'DD-API-KEY'
+          HEADER_CONTENT_TYPE = 'Content-Type'
+          HEADER_CONTENT_LENGTH = 'Content-Length'
+          HEADER_DD_TELEMETRY_API_VERSION = 'DD-Telemetry-API-Version'
+          HEADER_DD_TELEMETRY_REQUEST_TYPE = 'DD-Telemetry-Request-Type'
 
-          CONTENT_TYPE_APPLICATION_JSON = 'application/json'.freeze
-          API_VERSION = 'v1'.freeze
+          CONTENT_TYPE_APPLICATION_JSON = 'application/json'
+          API_VERSION = 'v1'
 
-          AGENT_ENDPOINT = '/telemetry/proxy/api/v2/apmtelemetry'.freeze
+          AGENT_ENDPOINT = '/telemetry/proxy/api/v2/apmtelemetry'
         end
       end
     end

data/lib/datadog/core/telemetry/http/transport.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../configuration/settings'
+require_relative '../../transport/ext'
 require_relative 'env'
 require_relative 'ext'
 require_relative 'adapters/net'
@@ -38,6 +39,7 @@ module Datadog
 
           def headers(request_type:, api_version: Http::Ext::API_VERSION)
             {
+              Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
               Http::Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
               Http::Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
               Http::Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,

data/lib/datadog/core/telemetry/v2/app_client_configuration_change.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'request'
+
+module Datadog
+  module Core
+    module Telemetry
+      module V2
+        # Telemetry 'app-client-configuration-change' event.
+        # This request should contain client library configuration that have changes since the app-started event.
+        class AppClientConfigurationChange < Request
+          def initialize(configuration_changes, origin: 'unknown')
+            super('app-client-configuration-change')
+
+            @configuration_changes = configuration_changes
+            @origin = origin
+          end
+
+          # @see [Request#to_h]
+          def to_h
+            super.merge(payload: payload)
+          end
+
+          private
+
+          def payload
+            {
+              configuration: @configuration_changes.map do |name, value|
+                {
+                  name: name,
+                  value: value,
+                  origin: @origin,
+                }
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end