datadog 2.20.0 → 2.26.0

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

@@ -8,8 +8,18 @@ module Datadog
       module Event
         # Telemetry class for the 'app-started' event
         class AppStarted < Base
-          def initialize(agent_settings:)
-            @agent_settings = agent_settings
+          def initialize(components:)
+            # To not hold a reference to the component tree, generate
+            # the event payload here in the constructor.
+            #
+            # Important: do not store data that contains (or is derived from)
+            # the runtime_id or sequence numbers.
+            # This event is reused when a process forks, but in the
+            # child process the runtime_id would be different and sequence
+            # number is reset.
+            @configuration = configuration(components.settings, components.agent_settings)
+            @install_signature = install_signature(components.settings)
+            @products = products(components)
           end
 
           def type
@@ -18,27 +28,37 @@ module Datadog
 
           def payload
             {
-              products: products,
-              configuration: configuration,
-              install_signature: install_signature,
+              products: @products,
+              configuration: @configuration,
+              install_signature: @install_signature,
               # DEV: Not implemented yet
               # error: error, # Start-up errors
             }
           end
 
+          # Whether the event is actually the app-started event.
+          # For the app-started event we follow up by sending
+          # app-dependencies-loaded, if the event is
+          # app-client-configuration-change we don't send
+          # app-dependencies-loaded.
+          def app_started?
+            true
+          end
+
           private
 
-          def products
-            # @type var products: Hash[Symbol, Hash[Symbol, Hash[Symbol, String | Integer] | bool | nil]]
+          def products(components)
+            # @type var products: telemetry_products
             products = {
               appsec: {
-                enabled: Datadog::AppSec.enabled?,
+                # TODO take appsec status out of component tree?
+                enabled: components.settings.appsec.enabled,
               },
               profiler: {
-                enabled: Datadog::Profiling.enabled?,
+                enabled: !!components.profiler&.enabled?,
               },
               dynamic_instrumentation: {
-                enabled: defined?(Datadog::DI) && Datadog::DI.respond_to?(:enabled?) && Datadog::DI.enabled?,
+                enabled: !!components.dynamic_instrumentation,
               }
             }
 
@@ -73,12 +93,11 @@ module Datadog
 
           # standard:disable Metrics/AbcSize
           # standard:disable Metrics/MethodLength
-          def configuration
-            config = Datadog.configuration
+          def configuration(settings, agent_settings)
             seq_id = Event.configuration_sequence.next
 
             # tracing.writer_options.buffer_size and tracing.writer_options.flush_interval have the same origin.
-            writer_option_origin = get_telemetry_origin(config, 'tracing.writer_options')
+            writer_option_origin = get_telemetry_origin(settings, 'tracing.writer_options')
 
             list = [
               # Only set using env var as of June 2025
@@ -100,59 +119,78 @@ module Datadog
               ),
 
               # Mix of env var, programmatic and default config, so we use unknown
-              conf_value('DD_AGENT_TRANSPORT', agent_transport, seq_id, 'unknown'),
+              conf_value('DD_AGENT_TRANSPORT', agent_transport(agent_settings), seq_id, 'unknown'), # rubocop:disable CustomCops/EnvStringValidationCop
 
               # writer_options is defined as an option that has a Hash value.
               conf_value(
                 'tracing.writer_options.buffer_size',
-                to_value(config.tracing.writer_options[:buffer_size]),
+                to_value(settings.tracing.writer_options[:buffer_size]),
                 seq_id,
                 writer_option_origin
               ),
               conf_value(
                 'tracing.writer_options.flush_interval',
-                to_value(config.tracing.writer_options[:flush_interval]),
+                to_value(settings.tracing.writer_options[:flush_interval]),
                 seq_id,
                 writer_option_origin
               ),
 
-              conf_value('DD_AGENT_HOST', config.agent.host, seq_id, get_telemetry_origin(config, 'agent.host')),
+              conf_value('DD_AGENT_HOST', settings.agent.host, seq_id, get_telemetry_origin(settings, 'agent.host')),
               conf_value(
                 'DD_TRACE_SAMPLE_RATE',
-                to_value(config.tracing.sampling.default_rate),
+                to_value(settings.tracing.sampling.default_rate),
                 seq_id,
-                get_telemetry_origin(config, 'tracing.sampling.default_rate')
+                get_telemetry_origin(settings, 'tracing.sampling.default_rate')
               ),
               conf_value(
                 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED',
-                config.tracing.contrib.global_default_service_name.enabled,
+                settings.tracing.contrib.global_default_service_name.enabled,
                 seq_id,
-                get_telemetry_origin(config, 'tracing.contrib.global_default_service_name.enabled')
+                get_telemetry_origin(settings, 'tracing.contrib.global_default_service_name.enabled')
               ),
               conf_value(
                 'DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED',
-                config.tracing.contrib.peer_service_defaults,
+                settings.tracing.contrib.peer_service_defaults,
                 seq_id,
-                get_telemetry_origin(config, 'tracing.contrib.peer_service_defaults')
+                get_telemetry_origin(settings, 'tracing.contrib.peer_service_defaults')
               ),
               conf_value(
                 'DD_TRACE_DEBUG',
-                config.diagnostics.debug,
+                settings.diagnostics.debug,
                 seq_id,
-                get_telemetry_origin(config, 'diagnostics.debug')
+                get_telemetry_origin(settings, 'diagnostics.debug')
               )
             ]
 
             peer_service_mapping_str = ''
-            unless config.tracing.contrib.peer_service_mapping.empty?
-              peer_service_mapping = config.tracing.contrib.peer_service_mapping
+            unless settings.tracing.contrib.peer_service_mapping.empty?
+              peer_service_mapping = settings.tracing.contrib.peer_service_mapping
               peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
             end
             list << conf_value(
               'DD_TRACE_PEER_SERVICE_MAPPING',
               peer_service_mapping_str,
               seq_id,
-              get_telemetry_origin(config, 'tracing.contrib.peer_service_mapping')
+              get_telemetry_origin(settings, 'tracing.contrib.peer_service_mapping')
+            )
+
+            # OpenTelemetry configuration options (using environment variable names)
+            otel_exporter_headers_string = settings.opentelemetry.exporter.headers&.map { |key, value| "#{key}=#{value}" }&.join(',')
+            otel_exporter_metrics_headers_string = settings.opentelemetry.metrics.headers&.map { |key, value| "#{key}=#{value}" }&.join(',')
+            list.push(
+              conf_value('OTEL_EXPORTER_OTLP_ENDPOINT', settings.opentelemetry.exporter.endpoint, seq_id, get_telemetry_origin(settings, 'opentelemetry.exporter.endpoint')),
+              conf_value('OTEL_EXPORTER_OTLP_HEADERS', otel_exporter_headers_string, seq_id, get_telemetry_origin(settings, 'opentelemetry.exporter.headers')),
+              conf_value('OTEL_EXPORTER_OTLP_PROTOCOL', settings.opentelemetry.exporter.protocol, seq_id, get_telemetry_origin(settings, 'opentelemetry.exporter.protocol')),
+              conf_value('OTEL_EXPORTER_OTLP_TIMEOUT', settings.opentelemetry.exporter.timeout_millis, seq_id, get_telemetry_origin(settings, 'opentelemetry.exporter.timeout_millis')),
+              conf_value('DD_METRICS_OTEL_ENABLED', settings.opentelemetry.metrics.enabled, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.enabled')),
+              conf_value('OTEL_METRICS_EXPORTER', settings.opentelemetry.metrics.exporter, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.exporter')),
+              conf_value('OTEL_EXPORTER_OTLP_METRICS_ENDPOINT', settings.opentelemetry.metrics.endpoint, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.endpoint')),
+              conf_value('OTEL_EXPORTER_OTLP_METRICS_HEADERS', otel_exporter_metrics_headers_string, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.headers')),
+              conf_value('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL', settings.opentelemetry.metrics.protocol, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.protocol')),
+              conf_value('OTEL_EXPORTER_OTLP_METRICS_TIMEOUT', settings.opentelemetry.metrics.timeout_millis, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.timeout_millis')),
+              conf_value('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE', settings.opentelemetry.metrics.temporality_preference, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.temporality_preference')),
+              conf_value('OTEL_METRIC_EXPORT_INTERVAL', settings.opentelemetry.metrics.export_interval_millis, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.export_interval_millis')),
+              conf_value('OTEL_METRIC_EXPORT_TIMEOUT', settings.opentelemetry.metrics.export_timeout_millis, seq_id, get_telemetry_origin(settings, 'opentelemetry.metrics.export_timeout_millis')),
             )
 
             # Whitelist of configuration options to send in additional payload object
@@ -160,9 +198,9 @@ module Datadog
               split_option = option_path.split('.')
               list << conf_value(
                 option_path,
-                to_value(config.dig(*split_option)),
+                to_value(settings.dig(*split_option)),
                 seq_id,
-                get_telemetry_origin(config, option_path)
+                get_telemetry_origin(settings, option_path)
               )
             end
 
@@ -177,38 +215,38 @@ module Datadog
             list.push(
               conf_value('instrumentation_source', instrumentation_source, seq_id, 'code'),
               conf_value('DD_INJECT_FORCE', Core::Environment::VariableHelpers.env_to_bool('DD_INJECT_FORCE', false), seq_id, 'env_var'),
-              conf_value('DD_INJECTION_ENABLED', ENV['DD_INJECTION_ENABLED'] || '', seq_id, 'env_var'),
+              conf_value('DD_INJECTION_ENABLED', DATADOG_ENV['DD_INJECTION_ENABLED'] || '', seq_id, 'env_var'),
             )
 
             # Add some more custom additional payload values here
-            if config.logger.instance
+            if settings.logger.instance
               list << conf_value(
                 'logger.instance',
-                config.logger.instance.class.to_s,
+                settings.logger.instance.class.to_s,
                 seq_id,
-                get_telemetry_origin(config, 'logger.instance')
+                get_telemetry_origin(settings, 'logger.instance')
               )
             end
-            if config.respond_to?('appsec')
+            if settings.respond_to?('appsec')
               list << conf_value(
                 'appsec.enabled',
-                config.dig('appsec', 'enabled'),
+                settings.dig('appsec', 'enabled'),
                 seq_id,
-                get_telemetry_origin(config, 'appsec.enabled')
+                get_telemetry_origin(settings, 'appsec.enabled')
               )
               list << conf_value(
                 'appsec.sca_enabled',
-                config.dig('appsec', 'sca_enabled'),
+                settings.dig('appsec', 'sca_enabled'),
                 seq_id,
-                get_telemetry_origin(config, 'appsec.sca_enabled')
+                get_telemetry_origin(settings, 'appsec.sca_enabled')
               )
             end
-            if config.respond_to?('ci')
+            if settings.respond_to?('ci')
               list << conf_value(
                 'ci.enabled',
-                config.dig('ci', 'enabled'),
+                settings.dig('ci', 'enabled'),
                 seq_id,
-                get_telemetry_origin(config, 'ci.enabled')
+                get_telemetry_origin(settings, 'ci.enabled')
               )
             end
 
@@ -218,8 +256,8 @@ module Datadog
           # standard:enable Metrics/AbcSize
           # standard:enable Metrics/MethodLength
 
-          def agent_transport
-            adapter = @agent_settings.adapter
+          def agent_transport(agent_settings)
+            adapter = agent_settings.adapter
             if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
               'UDS'
             else
@@ -239,6 +277,7 @@ module Datadog
           # - `default`: set when the user has not set any configuration for the key (defaults to a value)
           # - `unknown`: set for cases where it is difficult/not possible to determine the source of a config.
           def conf_value(name, value, seq_id, origin)
+            # @type var result: telemetry_configuration
             result = {name: name, value: value, origin: origin, seq_id: seq_id}
             if origin == 'fleet_stable_config'
               fleet_id = Core::Configuration::StableConfig.configuration.dig(:fleet, :id)
@@ -260,23 +299,22 @@ module Datadog
             end
           end
 
-          def install_signature
-            config = Datadog.configuration
+          def install_signature(settings)
             {
-              install_id: config.dig('telemetry', 'install_id'),
-              install_type: config.dig('telemetry', 'install_type'),
-              install_time: config.dig('telemetry', 'install_time'),
+              install_id: settings.dig('telemetry', 'install_id'),
+              install_type: settings.dig('telemetry', 'install_type'),
+              install_time: settings.dig('telemetry', 'install_time'),
             }
           end
 
-          def get_telemetry_origin(config, config_path)
+          def get_telemetry_origin(settings, config_path)
             split_option = config_path.split('.')
             option_name = split_option.pop
             return 'unknown' if option_name.nil?
 
             # @type var parent_setting: Core::Configuration::Options
             # @type var option: Core::Configuration::Option
-            parent_setting = config.dig(*split_option)
+            parent_setting = settings.dig(*split_option)
             option = parent_setting.send(:resolve_option, option_name.to_sym)
             option.precedence_set&.origin || 'unknown'
           end

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

@@ -28,13 +28,36 @@ module Datadog
         # and app-closing events.
         class SynthAppClientConfigurationChange < AppStarted
           def type
-            'app-client-configuration-change'
+            if reset?
+              super
+            else
+              'app-client-configuration-change'
+            end
           end
 
           def payload
-            {
-              configuration: configuration,
-            }
+            if reset?
+              super
+            else
+              {
+                configuration: @configuration,
+              }
+            end
+          end
+
+          def app_started?
+            reset?
+          end
+
+          # Revert this event to a "regular" AppStarted event.
+          #
+          # Used in after_fork to send the AppStarted event in child processes.
+          def reset!
+            @reset = true
+          end
+
+          def reset?
+            defined?(@reset) && !!@reset
           end
         end
       end

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

@@ -26,6 +26,7 @@ require_relative 'event/base'
 require_relative 'event/app_client_configuration_change'
 require_relative 'event/app_closing'
 require_relative 'event/app_dependencies_loaded'
+require_relative 'event/app_endpoints_loaded'
 require_relative 'event/app_heartbeat'
 require_relative 'event/app_integrations_change'
 require_relative 'event/app_started'

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

@@ -14,8 +14,8 @@ module Datadog
       #   read: lib/datadog/core/telemetry/logging.rb
       module Logger
         class << self
-          def report(exception, level: :error, description: nil, pii_safe: false)
-            instance&.report(exception, level: level, description: description, pii_safe: pii_safe)
+          def report(exception, level: :error, description: nil)
+            instance&.report(exception, level: level, description: description)
           end
 
           def error(description)

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

@@ -45,17 +45,11 @@ module Datadog
           end
         end
 
-        def report(exception, level: :error, description: nil, pii_safe: false)
+        def report(exception, level: :error, description: nil)
           # Anonymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
           message = +"#{exception.class.name || exception.class.inspect}" # standard:disable Style/RedundantInterpolation
 
-          exception_message = pii_safe ? exception.message : nil
-
-          if description || exception_message
-            message << ':'
-            message << " #{description}" if description
-            message << " (#{exception.message})" if exception_message
-          end
+          message << ": #{description}" if description
 
           event = Event::Log.new(
             message: message,

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

@@ -6,8 +6,11 @@ module Datadog
   module Core
     module Telemetry
       # MetricsManager aggregates and flushes metrics and distributions
+      #
+      # @api private
       class MetricsManager
         attr_reader :enabled
+        attr_reader :collections
 
         def initialize(aggregation_interval:, enabled:)
           @interval = aggregation_interval
@@ -68,6 +71,12 @@ module Datadog
           @enabled = false
         end
 
+        def clear
+          @mutex.synchronize do
+            @collections = {}
+          end
+        end
+
         private
 
         def fetch_or_create_collection(namespace)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../environment/platform'
+require_relative '../environment/process'
 require_relative '../utils/hash'
 
 module Datadog
@@ -11,9 +12,9 @@ module Datadog
         class << self
           using Core::Utils::Hash::Refinement
 
-          def build_payload(event, seq_id, api_version: 'v2', debug: false)
+          def build_payload(event, seq_id, debug: false)
             hash = {
-              api_version: api_version,
+              api_version: 'v2',
               application: application,
               debug: debug,
               host: host,
@@ -43,7 +44,7 @@ module Datadog
               tracer_version = "#{tracer_version}-ci-#{::Datadog::CI::VERSION::STRING}"
             end
 
-            {
+            app = {
               env: config.env,
               language_name: Core::Environment::Ext::LANG,
               language_version: Core::Environment::Ext::LANG_VERSION,
@@ -53,6 +54,10 @@ module Datadog
               service_version: config.version,
               tracer_version: tracer_version
             }
+
+            tag_process_tags!(app, config)
+
+            app
           end
 
           def host
@@ -64,6 +69,15 @@ module Datadog
               kernel_version: Core::Environment::Platform.kernel_version
             }
           end
+
+          def tag_process_tags!(app, config)
+            return unless config.experimental_propagate_process_tags_enabled
+
+            process_tags = Core::Environment::Process.serialized
+            return if process_tags.empty?
+
+            app[:process_tags] = process_tags
+          end
         end
       end
     end

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

@@ -2,9 +2,8 @@
 
 require_relative '../../../transport/http/api/endpoint'
 require_relative '../../../transport/http/api/instance'
-require_relative '../../../transport/http/api/spec'
+require_relative '../../../transport/http/client'
 require_relative '../../../transport/request'
-require_relative 'client'
 
 module Datadog
   module Core
@@ -12,35 +11,7 @@ module Datadog
       module Transport
         module HTTP
           module Telemetry
-            module Client
-              def send_telemetry_payload(request)
-                send_request(request) do |api, env| # steep:ignore
-                  api.send_telemetry(env)
-                end
-              end
-            end
-
             module API
-              class Instance < Core::Transport::HTTP::API::Instance
-                def send_telemetry(env)
-                  raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('telemetry', self) unless spec.is_a?(Telemetry::API::Spec)
-
-                  spec.send_telemetry(env) do |request_env|
-                    call(request_env)
-                  end
-                end
-              end
-
-              class Spec < Core::Transport::HTTP::API::Spec
-                attr_accessor :telemetry
-
-                def send_telemetry(env, &block)
-                  raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('telemetry', self) if telemetry.nil?
-
-                  telemetry.call(env, &block)
-                end
-              end
-
               class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
                 HEADER_CONTENT_TYPE = 'Content-Type'
 
@@ -64,12 +35,12 @@ module Datadog
                   super
                 end
 
-                def headers(request_type:, api_key:, api_version: 'v2')
+                def headers(request_type:, api_key:)
                   {
                     Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
                     # Provided by encoder
                     # 'Content-Type' => 'application/json',
-                    'DD-Telemetry-API-Version' => api_version,
+                    'DD-Telemetry-API-Version' => 'v2',
                     'DD-Telemetry-Request-Type' => request_type,
                     'DD-Client-Library-Language' => Core::Environment::Ext::LANG,
                     'DD-Client-Library-Version' => Core::Environment::Identity.gem_datadog_version_semver2,
@@ -83,8 +54,6 @@ module Datadog
               end
             end
           end
-
-          HTTP::Client.include(Telemetry::Client)
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'telemetry'
-require_relative 'http/api'
+require_relative '../../encoding'
 require_relative '../../transport/http'
+require_relative 'telemetry'
 
 module Datadog
   module Core
@@ -10,6 +10,16 @@ module Datadog
       module Transport
         # Namespace for HTTP transport components
         module HTTP
+          AGENT_TELEMETRY = Telemetry::API::Endpoint.new(
+            '/telemetry/proxy/api/v2/apmtelemetry',
+            Core::Encoding::JSONEncoder,
+          )
+
+          AGENTLESS_TELEMETRY = Telemetry::API::Endpoint.new(
+            '/api/v2/apmtelemetry',
+            Core::Encoding::JSONEncoder,
+          )
+
           module_function
 
           # Builds a new Transport::HTTP::Client with default settings
@@ -18,18 +28,14 @@ module Datadog
             agent_settings:,
             logger:,
             api_key: nil,
-            api_version: nil,
             headers: nil
           )
-            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+            Core::Transport::HTTP.build(
               logger: logger,
               agent_settings: agent_settings,
-              api_version: api_version,
-              headers: headers) do |transport|
-              apis = API.defaults
-
-              transport.api API::AGENTLESS_TELEMETRY, apis[API::AGENTLESS_TELEMETRY]
-
+              headers: headers
+            ) do |transport|
+              transport.api 'agentless_telemetry', AGENTLESS_TELEMETRY
               # Call block to apply any customization, if provided
               yield(transport) if block_given?
             end.to_transport(Core::Telemetry::Transport::Telemetry::Transport).tap do |transport|
@@ -42,15 +48,14 @@ module Datadog
           def agent_telemetry(
             agent_settings:,
             logger:,
-            api_version: nil,
             headers: nil
           )
-            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+            Core::Transport::HTTP.build(
               logger: logger,
-              agent_settings: agent_settings, api_version: api_version, headers: headers) do |transport|
-              apis = API.defaults
-
-              transport.api API::AGENT_TELEMETRY, apis[API::AGENT_TELEMETRY]
+              agent_settings: agent_settings,
+              headers: headers
+            ) do |transport|
+              transport.api 'agent_telemetry', AGENT_TELEMETRY
 
               # Call block to apply any customization, if provided
               yield(transport) if block_given?

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../transport/parcel'
-require_relative 'http/client'
+require_relative '../../transport/transport'
 require_relative 'http/telemetry'
 
 module Datadog
@@ -24,23 +24,15 @@ module Datadog
             end
           end
 
-          class Transport
-            attr_reader :client, :apis, :default_api, :current_api_id, :logger
+          class Transport < Core::Transport::Transport
             attr_accessor :api_key
 
-            def initialize(apis, default_api, logger:)
-              @apis = apis
-              @logger = logger
-
-              @client = HTTP::Client.new(@apis[default_api], logger: logger)
-            end
-
             def send_telemetry(request_type:, payload:)
               json = JSON.dump(payload)
               parcel = EncodedParcel.new(json)
               request = Request.new(request_type, parcel, api_key)
 
-              @client.send_telemetry_payload(request)
+              @client.send_request(:telemetry, request)
               # Perform no error checking here
             end
           end