datadog 2.17.0 → 2.18.0

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/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

@@ -25,7 +25,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 +64,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 +73,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(config), 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 +144,55 @@ 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
-            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
-              ),
-            )
-            list << conf_value('logger.instance', config.logger.instance.class.to_s, seq_id) if config.logger.instance
+            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
@@ -145,13 +209,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 +250,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)
@@ -111,7 +122,8 @@ module Datadog
               # 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,
+                instance_vars = Instrumenter.get_instance_variables(self)
+                serializer.serialize_args(args, kwargs, instance_vars,
                   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
@@ -149,6 +161,7 @@ module Datadog
               # 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,
+                instance_vars: probe.capture_snapshot? ? Instrumenter.get_instance_variables(self) : nil,
                 serialized_entry_args: entry_args)
               rv
             else
@@ -298,8 +311,20 @@ module Datadog
               probe.file == tp.path || probe.file_matches?(tp.path)
             )
               if rate_limiter.nil? || rate_limiter.allow?
+                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
+                instance_vars = if probe.capture_snapshot?
+                  serializer.serialize_vars(Instrumenter.get_instance_variables(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,
+                  locals: locals, instance_vars: instance_vars,
+                  path: tp.path, caller_locations: caller_locations)
               end
             end
           rescue => exc
@@ -371,6 +396,31 @@ module Datadog
         end
       end
 
+      class << self
+        def get_instance_variables(object)
+          {}.tap do |hash|
+            object.instance_variables.each do |var|
+              hash[var] = object.instance_variable_get(var)
+            end
+          end
+        end
+
+        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

data/lib/datadog/di/probe_notification_builder.rb

@@ -39,39 +39,50 @@ module Datadog
       end
 
       # Duration is in seconds.
+      # path is the actual path of the instrumented file.
       def build_executed(probe,
-        trace_point: nil, rv: nil, duration: nil, caller_locations: nil,
-        args: nil, kwargs: nil, serialized_entry_args: nil)
-        snapshot = if probe.line? && probe.capture_snapshot?
-          if trace_point.nil?
-            raise "Cannot create snapshot because there is no trace point"
-          end
-          get_local_variables(trace_point)
-        end
-        # TODO check how many stack frames we should be keeping/sending,
-        # this should be all frames for enriched probes and no frames for
-        # non-enriched probes?
-        build_snapshot(probe, rv: rv, snapshot: snapshot,
+        path: nil, rv: nil, duration: nil, caller_locations: nil,
+        locals: nil, args: nil, kwargs: nil, instance_vars: nil,
+        serialized_entry_args: nil)
+        build_snapshot(probe, rv: rv, locals: locals,
           # Actual path of the instrumented file.
-          path: trace_point&.path,
-          duration: duration, caller_locations: caller_locations, args: args, kwargs: kwargs,
+          path: path,
+          duration: duration,
+          # TODO check how many stack frames we should be keeping/sending,
+          # this should be all frames for enriched probes and no frames for
+          # non-enriched probes?
+          caller_locations: caller_locations,
+          args: args, kwargs: kwargs, instance_vars: instance_vars,
           serialized_entry_args: serialized_entry_args)
       end
 
-      def build_snapshot(probe, rv: nil, snapshot: nil, path: nil,
-        duration: nil, caller_locations: nil, args: nil, kwargs: nil,
+      def build_snapshot(probe, rv: nil, locals: nil, path: nil,
+        duration: nil, caller_locations: nil,
+        args: nil, kwargs: nil, instance_vars: nil,
         serialized_entry_args: nil)
         # TODO also verify that non-capturing probe does not pass
         # snapshot or vars/args into this method
         captures = if probe.capture_snapshot?
           if probe.method?
+            return_arguments = {
+              "@return": serializer.serialize_value(rv,
+                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),
+            }
+            if instance_vars
+              return_arguments.update(
+                serializer.serialize_vars(instance_vars,
+                  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
             {
               entry: {
                 # standard:disable all
                 arguments: if serialized_entry_args
                   serialized_entry_args
                 else
-                  (args || kwargs) && serializer.serialize_args(args, kwargs,
+                  (args || kwargs) && serializer.serialize_args(args, kwargs, instance_vars,
                     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,
@@ -79,20 +90,14 @@ module Datadog
                 # standard:enable all
               },
               return: {
-                arguments: {
-                  "@return": serializer.serialize_value(rv,
-                    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),
-                },
+                arguments: return_arguments,
                 throwable: nil,
               },
             }
           elsif probe.line?
             {
-              lines: snapshot && {
-                probe.line_no => {locals: serializer.serialize_vars(snapshot,
-                  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,)},
+              lines: locals && {
+                probe.line_no => {locals: locals.merge(instance_vars || {})},
               },
             }
           end
@@ -194,21 +199,6 @@ module Datadog
         (Core::Utils::Time.now.to_f * 1000).to_i
       end
 
-      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
-
       def active_trace
         if defined?(Datadog::Tracing)
           Datadog::Tracing.active_trace

data/lib/datadog/di/probe_notifier_worker.rb

@@ -183,7 +183,15 @@ module Datadog
       end
 
       def do_send_snapshot(batch)
-        snapshot_transport.send_input(batch)
+        snapshot_transport.send_input(batch, tags)
+      end
+
+      def tags
+        # DEV: The tags could be cached but they need to be recreated
+        # when process forks (since the child receives new runtime IDs).
+        Core::TagBuilder.tags(settings).merge(
+          'debugger_version' => Core::Environment::Identity.gem_datadog_version,
+        )
       end
 
       [