datadog 2.17.0 → 2.37.0

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry event class for sending 'app-endpoints' payload
+        class AppEndpointsLoaded < Base
+          def initialize(endpoints, is_first:)
+            @endpoints = endpoints
+            @is_first = !!is_first
+          end
+
+          def type
+            'app-endpoints'
+          end
+
+          def payload
+            {
+              is_first: @is_first,
+              endpoints: @endpoints
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'app_started'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-extended-heartbeat' event
+        class AppExtendedHeartbeat < AppStarted
+          def initialize(settings:, agent_settings:)
+            @configuration = configuration(settings, agent_settings)
+          end
+
+          def type
+            'app-extended-heartbeat'
+          end
+
+          def payload
+            {
+              configuration: @configuration,
+            }
+          end
+
+          def app_started?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,33 +8,63 @@ module Datadog
       module Event
         # Telemetry class for the 'app-started' event
         class AppStarted < Base
+          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
             'app-started'
           end
 
           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, Object]]
+          def products(components)
+            # @type var products: telemetry_products
             products = {
               appsec: {
-                enabled: Datadog::AppSec.enabled?,
+                enabled: !!components.appsec,
               },
               profiler: {
-                enabled: Datadog::Profiling.enabled?,
+                enabled: !!components.profiler,
               },
               dynamic_instrumentation: {
-                enabled: defined?(Datadog::DI) && Datadog::DI.respond_to?(:enabled?) && Datadog::DI.enabled?,
+                # With always-build, the DI component is constructed by
+                # default (when the runtime supports DI, RC is available, and
+                # DI is not explicitly disabled) regardless of whether the
+                # customer turned DI on. Its presence therefore no longer
+                # indicates the enabled state. started? reflects whether DI was
+                # actually enabled by env var or by implicit enablement via
+                # remote config.
+                enabled: components.dynamic_instrumentation&.started? || false,
               }
             }
 
@@ -48,96 +78,103 @@ module Datadog
             products
           end
 
-          TARGET_OPTIONS = %w[
-            dynamic_instrumentation.enabled
-            logger.level
-            profiling.advanced.code_provenance_enabled
-            profiling.advanced.endpoint.collection.enabled
-            profiling.enabled
-            runtime_metrics.enabled
-            tracing.analytics.enabled
-            tracing.propagation_style_extract
-            tracing.propagation_style_inject
-            tracing.enabled
-            tracing.log_injection
-            tracing.partial_flush.enabled
-            tracing.partial_flush.min_spans_threshold
-            tracing.report_hostname
-            tracing.sampling.rate_limit
-          ].freeze
-
-          # standard:disable Metrics/AbcSize
-          # standard:disable Metrics/MethodLength
-          def configuration
-            config = Datadog.configuration
-            seq_id = Event.configuration_sequence.next
-
+          def configuration(settings, agent_settings)
+            # Special values that are not tied to a configuration option
             list = [
-              conf_value('DD_GIT_REPOSITORY_URL', Core::Environment::Git.git_repository_url, seq_id, 'env_var'),
-              conf_value('DD_GIT_COMMIT_SHA', Core::Environment::Git.git_commit_sha, seq_id, 'env_var'),
-
-              conf_value('DD_AGENT_HOST', config.agent.host, seq_id),
-              conf_value('DD_AGENT_TRANSPORT', agent_transport(config), seq_id),
-              conf_value('DD_TRACE_SAMPLE_RATE', to_value(config.tracing.sampling.default_rate), seq_id),
               conf_value(
-                'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED',
-                config.tracing.contrib.global_default_service_name.enabled,
-                seq_id
+                'DD_GIT_REPOSITORY_URL',
+                Core::Environment::Git.git_repository_url,
+                (Core::Environment::Git.git_repository_url ? Configuration::Option::Precedence::ENVIRONMENT : Configuration::Option::Precedence::DEFAULT)
               ),
               conf_value(
-                'DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED',
-                config.tracing.contrib.peer_service_defaults,
-                seq_id
+                'DD_GIT_COMMIT_SHA',
+                Core::Environment::Git.git_commit_sha,
+                (Core::Environment::Git.git_commit_sha ? Configuration::Option::Precedence::ENVIRONMENT : Configuration::Option::Precedence::DEFAULT)
               ),
+
+              # Mix of env var, programmatic and default config, so we use unknown
+              unknown_conf_value('DD_AGENT_TRANSPORT', agent_transport(agent_settings)), # rubocop:disable CustomCops/EnvStringValidationCop
             ]
 
-            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
-            list << conf_value('DD_TRACE_PEER_SERVICE_MAPPING', peer_service_mapping_str, seq_id)
+            # Set by the customer application (eg. `require 'datadog/auto_instrument'`)
+            auto_instrument_enabled = !defined?(Datadog::AutoInstrument::LOADED).nil?
+            list << conf_value(
+              'tracing.auto_instrument.enabled',
+              auto_instrument_enabled,
+              auto_instrument_enabled ? Configuration::Option::Precedence::PROGRAMMATIC : Configuration::Option::Precedence::DEFAULT
+            )
+            opentelemetry_enabled = !defined?(Datadog::OpenTelemetry::LOADED).nil?
+            list << conf_value(
+              'tracing.opentelemetry.enabled',
+              opentelemetry_enabled,
+              opentelemetry_enabled ? Configuration::Option::Precedence::PROGRAMMATIC : Configuration::Option::Precedence::DEFAULT
+            )
 
-            # Whitelist of configuration options to send in additional payload object
-            TARGET_OPTIONS.each do |option|
-              split_option = option.split('.')
-              list << conf_value(option, to_value(config.dig(*split_option)), seq_id)
+            # Track ssi configurations
+            instrumentation_source = if Datadog.const_defined?(:SingleStepInstrument, false) &&
+                Datadog::SingleStepInstrument.const_defined?(:LOADED, false) &&
+                Datadog::SingleStepInstrument::LOADED
+              'ssi'
+            else
+              'manual'
             end
 
-            # Add some more custom additional payload values here
             list.push(
-              conf_value('tracing.auto_instrument.enabled', !defined?(Datadog::AutoInstrument::LOADED).nil?, seq_id),
               conf_value(
-                'tracing.writer_options.buffer_size',
-                to_value(config.tracing.writer_options[:buffer_size]),
-                seq_id
+                'instrumentation_source',
+                instrumentation_source,
+                (instrumentation_source == 'ssi') ? Configuration::Option::Precedence::PROGRAMMATIC : Configuration::Option::Precedence::DEFAULT
               ),
               conf_value(
-                'tracing.writer_options.flush_interval',
-                to_value(config.tracing.writer_options[:flush_interval]),
-                seq_id
+                'DD_INJECT_FORCE',
+                Core::Environment::VariableHelpers.env_to_bool('DD_INJECT_FORCE', false),
+                (DATADOG_ENV.key?('DD_INJECT_FORCE') ? Configuration::Option::Precedence::ENVIRONMENT : Configuration::Option::Precedence::DEFAULT)
               ),
               conf_value(
-                'tracing.opentelemetry.enabled',
-                !defined?(Datadog::OpenTelemetry::LOADED).nil?,
-                seq_id
+                'DD_INJECTION_ENABLED',
+                DATADOG_ENV['DD_INJECTION_ENABLED'] || '',
+                (DATADOG_ENV.key?('DD_INJECTION_ENABLED') ? Configuration::Option::Precedence::ENVIRONMENT : Configuration::Option::Precedence::DEFAULT)
               ),
             )
-            list << conf_value('logger.instance', config.logger.instance.class.to_s, seq_id) if config.logger.instance
-            if config.respond_to?('appsec')
-              list << conf_value('appsec.enabled', config.dig('appsec', 'enabled'), seq_id)
-              list << conf_value('appsec.sca_enabled', config.dig('appsec', 'sca_enabled'), seq_id)
+
+            # Extract writer options as separate configuration payloads.
+            resolve_option(settings, 'tracing.writer_options').values_per_precedence.each do |precedence, value|
+              list << conf_value(
+                'tracing.writer_options.buffer_size',
+                # Steep: Value is always a hash for writer_options (ensured by o.type :hash)
+                to_telemetry_value(value[:buffer_size]), # steep:ignore NoMethod
+                precedence
+              )
+              list << conf_value(
+                'tracing.writer_options.flush_interval',
+                # Steep: Value is always a hash for writer_options (ensured by o.type :hash)
+                to_telemetry_value(value[:flush_interval]), # steep:ignore NoMethod
+                precedence
+              )
+            end
+
+            # Add some more custom additional payload values here
+            if settings.logger.instance
+              logger_instance_option = resolve_option(settings, 'logger.instance')
+              logger_instance_option.values_per_precedence.each do |precedence, value|
+                list << conf_value(option_telemetry_name(logger_instance_option), value.nil? ? nil : value.class.to_s, precedence)
+              end
+            end
+
+            # Configuration options (regular + integration specific)
+            collect_all_configuration_options(settings).each do |option|
+              option.values_per_precedence.each do |precedence, value|
+                list << conf_value(option_telemetry_name(option), to_telemetry_value(value), precedence)
+              end
             end
-            list << conf_value('ci.enabled', config.dig('ci', 'enabled'), seq_id) if config.respond_to?('ci')
 
-            list.reject! { |entry| entry[:value].nil? }
+            # We still want to report nil default and programmatic values as they are valid values
+            list.reject! { |entry| entry[:origin] != 'default' && entry[:origin] != 'code' && entry[:value].nil? }
             list
           end
-          # standard:enable Metrics/AbcSize
-          # standard:enable Metrics/MethodLength
 
-          def agent_transport(config)
-            adapter = Core::Configuration::AgentSettingsResolver.call(config).adapter
+          def agent_transport(agent_settings)
+            adapter = agent_settings.adapter
             if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
               'UDS'
             else
@@ -145,33 +182,110 @@ module Datadog
             end
           end
 
-          def conf_value(name, value, seq_id, origin = 'code')
-            {
-              name: name,
-              value: value,
-              origin: origin,
-              seq_id: seq_id,
-            }
+          # `origin`: Source of the configuration. One of :
+          # - 1: `default`: set when the user has not set any configuration for the key (defaults to a value)
+          # - 2:`local_stable_config`: configuration set via a user-managed file
+          # - 3:`env_var`: configurations that are set through environment variables
+          # - 4:`fleet_stable_config`: configuration is set via the fleet automation Datadog UI
+          # - 5:`code`: configurations that are set through the customer application
+          # - 6:`remote_config`: values that are set using remote config
+          # - 7:`unknown`: set for cases where it is difficult/not possible to determine the source of a config.
+          def conf_value(name, value, precedence)
+            build_conf_value(name, value, precedence.origin, precedence.numeric + 1)
           end
 
-          def to_value(value)
+          def unknown_conf_value(name, value)
+            build_conf_value(name, value, 'unknown', Configuration::Option::Precedence::LIST.size + 1)
+          end
+
+          def build_conf_value(name, value, origin, seq_id)
+            # @type var result: Event::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)
+              result[:config_id] = fleet_id if fleet_id
+            elsif origin == 'local_stable_config'
+              local_id = Core::Configuration::StableConfig.configuration.dig(:local, :id)
+              result[:config_id] = local_id if local_id
+            end
+
+            result
+          end
+
+          def to_telemetry_value(value)
             # TODO: Add float if telemetry starts accepting it
             case value
             when Integer, String, true, false, nil
               value
+            when Hash
+              value.map { |key, entry_value| "#{key}:#{entry_value}" }.join(',')
+            when Array
+              value.join(',')
+            when Module
+              value.name.to_s
             else
-              value.to_s
+              if implements_to_s?(value)
+                value.to_s
+              else
+                value.class.to_s
+              end
             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 collect_all_configuration_options(settings)
+            collect_configuration_options_from(settings).concat(collect_integration_configuration_options(settings.tracing))
+          end
+
+          def collect_integration_configuration_options(tracing_settings)
+            return [] unless tracing_settings.respond_to?(:instrumented_built_in_integrations)
+
+            tracing_settings.instrumented_built_in_integrations.each_with_object([]) do |integration, entries|
+              integration.configurations.each_value do |configuration|
+                entries.concat(collect_configuration_options_from(configuration))
+              end
+            end
+          end
+
+          def collect_configuration_options_from(settings)
+            settings.class.options.each_key.with_object([]) do |name, options|
+              option = settings.send(:resolve_option, name)
+              next if option.definition.skip_telemetry
+
+              if option.settings?
+                options.concat(collect_configuration_options_from(option.get))
+              else
+                options << option
+              end
+            end
+          end
+
+          def option_telemetry_name(option)
+            option.definition.env || option.name_with_settings_path
+          end
+
+          def resolve_option(settings, config_path)
+            split_option = config_path.split('.')
+            option_name = split_option.pop
+            raise ArgumentError, "Invalid config path: #{config_path}" if option_name.nil?
+
+            parent_setting = settings.dig(*split_option)
+            parent_setting.send(:resolve_option, option_name.to_sym)
+          end
+
+          def implements_to_s?(value)
+            value.method(:to_s).owner != Kernel
+          rescue NameError
+            false
+          end
         end
       end
     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

@@ -10,13 +10,6 @@ module Datadog
       #
       # @api private
       module Event
-        extend Core::Utils::Forking
-
-        # returns sequence that increments every time the configuration changes
-        def self.configuration_sequence
-          after_fork! { @sequence = Datadog::Core::Utils::Sequence.new(1) }
-          @sequence ||= Datadog::Core::Utils::Sequence.new(1)
-        end
       end
     end
   end
@@ -25,7 +18,9 @@ end
 require_relative 'event/base'
 require_relative 'event/app_client_configuration_change'
 require_relative 'event/app_closing'
+require_relative 'event/app_extended_heartbeat'
 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/ext.rb

@@ -7,6 +7,7 @@ module Datadog
         ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'
         ENV_METRICS_ENABLED = 'DD_TELEMETRY_METRICS_ENABLED'
         ENV_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_HEARTBEAT_INTERVAL'
+        ENV_EXTENDED_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL'
         ENV_METRICS_AGGREGATION_INTERVAL = 'DD_TELEMETRY_METRICS_AGGREGATION_INTERVAL'
         ENV_DEPENDENCY_COLLECTION = 'DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED'
         ENV_INSTALL_ID = 'DD_INSTRUMENTATION_INSTALL_ID'

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

@@ -14,10 +14,12 @@ module Datadog
       #   read: lib/datadog/core/telemetry/logging.rb
       module Logger
         class << self
+          # (see Datadog::Core::Telemetry::Logging#report)
           def report(exception, level: :error, description: nil)
             instance&.report(exception, level: level, description: description)
           end
 
+          # (see Datadog::Core::Telemetry::Logging#error)
           def error(description)
             instance&.error(description)
           end
@@ -34,9 +36,10 @@ module Datadog
             #
             # The downside is: this leaves us unable to report telemetry during component initialization.
             components = Datadog.send(:components, allow_initialization: false)
+            telemetry = components&.telemetry
 
-            if components&.telemetry
-              components.telemetry
+            if telemetry
+              telemetry
             else
               Datadog.logger.warn(
                 'Failed to send telemetry before components initialization or within components lifecycle'

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

@@ -45,11 +45,20 @@ module Datadog
           end
         end
 
+        # @param exception [Exception] The exception to report
+        # @param level [Symbol] The log level (:error, :warn, :info, :debug)
+        # @param description [String, nil] A low cardinality description, without dynamic data
         def report(exception, level: :error, description: nil)
-          # Annoymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
-          message = +''
-          message << (exception.class.name || exception.class.inspect)
-          message << ': ' << description if description
+          # Anonymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
+          message = +(exception.class.name || exception.class.inspect)
+
+          telemetry_message = message_for_telemetry(exception)
+
+          if description || telemetry_message
+            message << ':'
+            message << " #{description}" if description
+            message << " (#{telemetry_message})" if telemetry_message
+          end
 
           event = Event::Log.new(
             message: message,
@@ -65,6 +74,15 @@ module Datadog
 
           log!(event)
         end
+
+        private
+
+        # A constant string representing the exception
+        def message_for_telemetry(exception)
+          return unless exception.instance_variable_defined?(:@telemetry_message)
+
+          exception.instance_variable_get(:@telemetry_message)
+        end
       end
     end
   end

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
@@ -9,11 +10,9 @@ module Datadog
       # Module defining methods for collecting metadata for telemetry
       module Request
         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 +42,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 +52,10 @@ module Datadog
               service_version: config.version,
               tracer_version: tracer_version
             }
+
+            tag_process_tags!(app, config)
+
+            app
           end
 
           def host
@@ -64,6 +67,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