datadog 2.17.0 → 2.19.0

data/lib/datadog/core/remote/configuration/repository.rb

@@ -237,6 +237,10 @@ module Datadog
                 @path = path
                 @previous = previous
               end
+
+              def type
+                :delete
+              end
             end
 
             # Insert change
@@ -247,6 +251,10 @@ module Datadog
                 @path = path
                 @content = content
               end
+
+              def type
+                :insert
+              end
             end
 
             # Update change
@@ -258,6 +266,10 @@ module Datadog
                 @content = content
                 @previous = previous
               end
+
+              def type
+                :update
+              end
             end
           end
 

data/lib/datadog/core/tag_builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'environment/socket'
+require_relative 'environment/identity'
+require_relative 'environment/git'
+
+module Datadog
+  module Core
+    # This module builds a hash of tags.
+    #
+    # When changing or adding the tags, make sure they are kept in sync with
+    # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/
+    # (Datadog internal link).
+    #
+    # @api private
+    module TagBuilder
+      def self.fixed_environment_tags
+        @fixed_environment_tags ||= {
+          'language' => Environment::Identity.lang,
+          'runtime' => Environment::Identity.lang, # Known to be duplicated from language above
+          'runtime_engine' => Environment::Identity.lang_engine,
+          'runtime_platform' => Environment::Identity.lang_platform,
+          'runtime_version' => Environment::Identity.lang_version,
+          'library_version' => Environment::Identity.gem_datadog_version,
+          'git.repository_url' => Environment::Git.git_repository_url,
+          'git.commit.sha' => Environment::Git.git_commit_sha,
+        }.compact.freeze
+      end
+
+      def self.tags(settings)
+        # Note that user tags get overwritten by our tags, and also
+        # that user tags do not get compacted (nil values are sent as
+        # empty strings).
+        settings.tags.merge(fixed_environment_tags).merge({
+          # Hostname can possibly change during application runtime.
+          'host' => Environment::Socket.hostname,
+          # Runtime ID changes upon a fork.
+          'runtime-id' => Environment::Identity.id,
+          # Process ID changes upon a fork.
+          'process_id' => Process.pid.to_s,
+          # Unified service tagging.
+          'env' => settings.env,
+          'service' => settings.service,
+          'version' => settings.version,
+        }.compact)
+      end
+
+      def self.serialize_tags(tags)
+        # DEV: Should there be some sort of escaping done here?
+        tags.map do |key, value|
+          "#{key}:#{value}"
+        end.join(',')
+      end
+    end
+  end
+end

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

@@ -62,7 +62,9 @@ module Datadog
           return unless @enabled
 
           @transport = if settings.telemetry.agentless_enabled
-            agent_settings = Core::Configuration::AgentlessSettingsResolver.call(
+            # We don't touch the `agent_settings` since we still want the telemetry payloads to refer to the original
+            # settings, even though the telemetry itself may be using a different path.
+            telemetry_specific_agent_settings = Core::Configuration::AgentlessSettingsResolver.call(
               settings,
               host_prefix: 'instrumentation-telemetry-intake',
               url_override: settings.telemetry.agentless_url_override,
@@ -70,7 +72,7 @@ module Datadog
               logger: logger,
             )
             Telemetry::Transport::HTTP.agentless_telemetry(
-              agent_settings: agent_settings,
+              agent_settings: telemetry_specific_agent_settings,
               logger: logger,
               # api_key should have already validated to be
               # not nil by +build+ method above.
@@ -96,6 +98,8 @@ module Datadog
             logger: logger,
             shutdown_timeout: settings.telemetry.shutdown_timeout_seconds,
           )
+
+          @agent_settings = agent_settings
         end
 
         def disable!
@@ -107,9 +111,9 @@ module Datadog
           return if !@enabled
 
           initial_event = if initial_event_is_change
-            Event::SynthAppClientConfigurationChange.new
+            Event::SynthAppClientConfigurationChange.new(agent_settings: @agent_settings)
           else
-            Event::AppStarted.new
+            Event::AppStarted.new(agent_settings: @agent_settings)
           end
 
           @worker.start(initial_event)

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

@@ -37,6 +37,7 @@ module Datadog
               }
             end
 
+            # DEV: This seems unnecessary (we send the state of sca_enabled for each remote config change)
             unless config.dig('appsec', 'sca_enabled').nil?
               res << {
                 name: 'appsec.sca_enabled',

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

@@ -8,6 +8,10 @@ module Datadog
       module Event
         # Telemetry class for the 'app-started' event
         class AppStarted < Base
+          def initialize(agent_settings:)
+            @agent_settings = agent_settings
+          end
+
           def type
             'app-started'
           end
@@ -25,7 +29,7 @@ module Datadog
           private
 
           def products
-            # @type var products: Hash[Symbol, Hash[Symbol, Object]]
+            # @type var products: Hash[Symbol, Hash[Symbol, Hash[Symbol, String | Integer] | bool | nil]]
             products = {
               appsec: {
                 enabled: Datadog::AppSec.enabled?,
@@ -64,6 +68,7 @@ module Datadog
             tracing.partial_flush.min_spans_threshold
             tracing.report_hostname
             tracing.sampling.rate_limit
+            apm.tracing.enabled
           ].freeze
 
           # standard:disable Metrics/AbcSize
@@ -72,23 +77,70 @@ module Datadog
             config = Datadog.configuration
             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')
+
             list = [
+              # Only set using env var as of June 2025
               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),
+              # Set by the customer application (eg. `require 'datadog/auto_instrument'`)
+              conf_value(
+                'tracing.auto_instrument.enabled',
+                !defined?(Datadog::AutoInstrument::LOADED).nil?,
+                seq_id,
+                'code'
+              ),
+              conf_value(
+                'tracing.opentelemetry.enabled',
+                !defined?(Datadog::OpenTelemetry::LOADED).nil?,
+                seq_id,
+                'code'
+              ),
+
+              # Mix of env var, programmatic and default config, so we use unknown
+              conf_value('DD_AGENT_TRANSPORT', agent_transport, seq_id, 'unknown'),
+
+              # 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]),
+                seq_id,
+                writer_option_origin
+              ),
+              conf_value(
+                'tracing.writer_options.flush_interval',
+                to_value(config.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_TRACE_SAMPLE_RATE',
+                to_value(config.tracing.sampling.default_rate),
+                seq_id,
+                get_telemetry_origin(config, 'tracing.sampling.default_rate')
+              ),
               conf_value(
                 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED',
                 config.tracing.contrib.global_default_service_name.enabled,
-                seq_id
+                seq_id,
+                get_telemetry_origin(config, 'tracing.contrib.global_default_service_name.enabled')
               ),
               conf_value(
                 'DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED',
                 config.tracing.contrib.peer_service_defaults,
-                seq_id
+                seq_id,
+                get_telemetry_origin(config, 'tracing.contrib.peer_service_defaults')
               ),
+              conf_value(
+                'DD_TRACE_DEBUG',
+                config.diagnostics.debug,
+                seq_id,
+                get_telemetry_origin(config, 'diagnostics.debug')
+              )
             ]
 
             peer_service_mapping_str = ''
@@ -96,39 +148,69 @@ module Datadog
               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)
+            list << conf_value(
+              'DD_TRACE_PEER_SERVICE_MAPPING',
+              peer_service_mapping_str,
+              seq_id,
+              get_telemetry_origin(config, 'tracing.contrib.peer_service_mapping')
+            )
 
             # 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)
+            TARGET_OPTIONS.each do |option_path|
+              split_option = option_path.split('.')
+              list << conf_value(
+                option_path,
+                to_value(config.dig(*split_option)),
+                seq_id,
+                get_telemetry_origin(config, option_path)
+              )
             end
 
-            # Add some more custom additional payload values here
+            instrumentation_source = if Datadog.const_defined?(:SingleStepInstrument, false) &&
+                Datadog::SingleStepInstrument.const_defined?(:LOADED, false) &&
+                Datadog::SingleStepInstrument::LOADED
+              'ssi'
+            else
+              'manual'
+            end
+            # Track ssi configurations
             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
-              ),
-              conf_value(
-                'tracing.writer_options.flush_interval',
-                to_value(config.tracing.writer_options[:flush_interval]),
-                seq_id
-              ),
-              conf_value(
-                'tracing.opentelemetry.enabled',
-                !defined?(Datadog::OpenTelemetry::LOADED).nil?,
-                seq_id
-              ),
+              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'),
             )
-            list << conf_value('logger.instance', config.logger.instance.class.to_s, seq_id) if config.logger.instance
+
+            # Add some more custom additional payload values here
+            if config.logger.instance
+              list << conf_value(
+                'logger.instance',
+                config.logger.instance.class.to_s,
+                seq_id,
+                get_telemetry_origin(config, 'logger.instance')
+              )
+            end
             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)
+              list << conf_value(
+                'appsec.enabled',
+                config.dig('appsec', 'enabled'),
+                seq_id,
+                get_telemetry_origin(config, 'appsec.enabled')
+              )
+              list << conf_value(
+                'appsec.sca_enabled',
+                config.dig('appsec', 'sca_enabled'),
+                seq_id,
+                get_telemetry_origin(config, 'appsec.sca_enabled')
+              )
+            end
+            if config.respond_to?('ci')
+              list << conf_value(
+                'ci.enabled',
+                config.dig('ci', 'enabled'),
+                seq_id,
+                get_telemetry_origin(config, 'ci.enabled')
+              )
             end
-            list << conf_value('ci.enabled', config.dig('ci', 'enabled'), seq_id) if config.respond_to?('ci')
 
             list.reject! { |entry| entry[:value].nil? }
             list
@@ -136,8 +218,8 @@ module Datadog
           # standard:enable Metrics/AbcSize
           # standard:enable Metrics/MethodLength
 
-          def agent_transport(config)
-            adapter = Core::Configuration::AgentSettingsResolver.call(config).adapter
+          def agent_transport
+            adapter = @agent_settings.adapter
             if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
               'UDS'
             else
@@ -145,13 +227,27 @@ 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 :
+          # - `fleet_stable_config`: configuration is set via the fleet automation Datadog UI
+          # - `local_stable_config`: configuration set via a user-managed file
+          # - `env_var`: configurations that are set through environment variables
+          # - `jvm_prop`: JVM system properties passed on the command line
+          # - `code`: configurations that are set through the customer application
+          # - `dd_config`: set by the dd.yaml file or json
+          # - `remote_config`: values that are set using remote config
+          # - `app.config`: only applies to .NET
+          # - `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)
+            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_value(value)
@@ -172,6 +268,18 @@ module Datadog
               install_time: config.dig('telemetry', 'install_time'),
             }
           end
+
+          def get_telemetry_origin(config, 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)
+            option = parent_setting.send(:resolve_option, option_name.to_sym)
+            option.precedence_set&.origin || 'unknown'
+          end
         end
       end
     end

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)
-            instance&.report(exception, level: level, description: description)
+          def report(exception, level: :error, description: nil, pii_safe: false)
+            instance&.report(exception, level: level, description: description, pii_safe: pii_safe)
           end
 
           def error(description)
@@ -34,9 +34,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,17 @@ module Datadog
           end
         end
 
-        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
+        def report(exception, level: :error, description: nil, pii_safe: false)
+          # 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
 
           event = Event::Log.new(
             message: message,

data/lib/datadog/core/transport/http/adapters/net.rb

@@ -48,7 +48,7 @@ module Datadog
             end
 
             def get(env)
-              get = ::Net::HTTP::Get.new(env.path, env.headers)
+              get = ::Net::HTTP::Get.new(net_http_path_from_env(env), env.headers)
 
               # Connect and send the request
               http_response = open do |http|
@@ -63,7 +63,7 @@ module Datadog
               post = nil
 
               if env.form.nil? || env.form.empty?
-                post = ::Net::HTTP::Post.new(env.path, env.headers)
+                post = ::Net::HTTP::Post.new(net_http_path_from_env(env), env.headers)
                 post.body = env.body
               else
                 post = ::Datadog::Core::Vendor::Net::HTTP::Post::Multipart.new(
@@ -86,6 +86,21 @@ module Datadog
               "http://#{hostname}:#{port}?timeout=#{timeout}"
             end
 
+            def net_http_path_from_env(env)
+              path = env.path
+              case query = env.query
+              when Hash
+                path = path + '?' + URI.encode_www_form(query)
+              when String
+                path = path + '?' + query
+              when nil
+                # Nothing
+              else
+                raise ArgumentError, "Invalid type for query: #{query}"
+              end
+              path
+            end
+
             # Raised when called with an unknown HTTP method
             class UnknownHTTPMethod < StandardError
               attr_reader :verb

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/agent_settings_resolver'
+require_relative '../../configuration/agent_settings'
 require_relative 'adapters/registry'
 require_relative 'api/map'
 
@@ -41,7 +41,7 @@ module Datadog
 
           def adapter(config, *args, **kwargs)
             @default_adapter = case config
-            when Core::Configuration::AgentSettingsResolver::AgentSettings
+            when Core::Configuration::AgentSettings
               registry_klass = REGISTRY.get(config.adapter)
               raise UnknownAdapterError, config.adapter if registry_klass.nil?
 

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

@@ -32,6 +32,14 @@ module Datadog
             self[:path] = value
           end
 
+          def query
+            self[:query]
+          end
+
+          def query=(value)
+            self[:query] = value
+          end
+
           def body
             self[:body]
           end

data/lib/datadog/core/utils.rb

@@ -66,6 +66,13 @@ module Datadog
         placeholder
       end
 
+      def self.encode_tags(hash)
+        # Make sure everything is an utf-8 string, to avoid encoding issues in downstream
+        hash.each_with_object({}) do |(key, value), h|
+          h[utf8_encode(key)] = utf8_encode(value)
+        end
+      end
+
       # @!visibility private
       def self.without_warnings
         # This is typically used when monkey patching functions such as

data/lib/datadog/di/instrumenter.rb

@@ -52,6 +52,17 @@ module Datadog
     # (however, Probe instances can be replaced by OpenStruct instances
     # providing the same interface with not much effort).
     #
+    # Instrumenter (this class) is responsible for building snapshots.
+    # This is because to capture values on method entry, those values need to
+    # be duplicated or serialized into immutable values to prevent their
+    # modification by the instrumented method. Therefore this class must
+    # do at least some serialization/snapshot building and to keep the code
+    # well-encapsulated, all serialization/snapshot building should thus be
+    # initiated from this class rather than downstream code.
+    #
+    # As a consequence of Instrumenter building snapshots, it should not
+    # expose TracePoint objects to any downstream code.
+    #
     # @api private
     class Instrumenter
       def initialize(settings, serializer, logger, code_tracker: nil, telemetry: nil)
@@ -110,8 +121,8 @@ module Datadog
             if rate_limiter.nil? || rate_limiter.allow?
               # Arguments may be mutated by the method, therefore
               # they need to be serialized prior to method invocation.
-              entry_args = if probe.capture_snapshot?
-                serializer.serialize_args(args, kwargs,
+              serialized_entry_args = if probe.capture_snapshot?
+                serializer.serialize_args(args, kwargs, self,
                   depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
                   attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count)
               end
@@ -148,8 +159,10 @@ module Datadog
               caller_locs = method_frame + caller_locations # steep:ignore
               # TODO capture arguments at exit
               # & is to stop steep complaints, block is always present here.
-              block&.call(probe: probe, rv: rv, duration: duration, caller_locations: caller_locs,
-                serialized_entry_args: entry_args)
+              block&.call(probe: probe, rv: rv,
+                duration: duration, caller_locations: caller_locs,
+                target_self: self,
+                serialized_entry_args: serialized_entry_args)
               rv
             else
               # stop standard from trying to mess up my code
@@ -298,8 +311,21 @@ module Datadog
               probe.file == tp.path || probe.file_matches?(tp.path)
             )
               if rate_limiter.nil? || rate_limiter.allow?
+                serialized_locals = if probe.capture_snapshot?
+                  serializer.serialize_vars(Instrumenter.get_local_variables(tp),
+                    depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                    attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+                end
+                if probe.capture_snapshot?
+                  serializer.serialize_value(tp.self,
+                    depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                    attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+                end
                 # & is to stop steep complaints, block is always present here.
-                block&.call(probe: probe, trace_point: tp, caller_locations: caller_locations)
+                block&.call(probe: probe,
+                  serialized_locals: serialized_locals,
+                  target_self: tp.self,
+                  path: tp.path, caller_locations: caller_locations)
               end
             end
           rescue => exc
@@ -371,6 +397,23 @@ module Datadog
         end
       end
 
+      class << self
+        def get_local_variables(trace_point)
+          # binding appears to be constructed on access, therefore
+          # 1) we should attempt to cache it and
+          # 2) we should not call +binding+ until we actually need variable values.
+          binding = trace_point.binding
+
+          # steep hack - should never happen
+          return {} unless binding
+
+          binding.local_variables.each_with_object({}) do |name, map|
+            value = binding.local_variable_get(name)
+            map[name] = value
+          end
+        end
+      end
+
       private
 
       attr_reader :lock