datadog 2.23.0 → 2.25.0

data/lib/datadog/core/configuration/components.rb

@@ -14,6 +14,7 @@ require_relative '../remote/component'
 require_relative '../../tracing/component'
 require_relative '../../profiling/component'
 require_relative '../../appsec/component'
+require_relative '../../ai_guard/component'
 require_relative '../../di/component'
 require_relative '../../open_feature/component'
 require_relative '../../error_tracking/component'
@@ -107,6 +108,7 @@ module Datadog
           :error_tracking,
           :dynamic_instrumentation,
           :appsec,
+          :ai_guard,
           :agent_info,
           :data_streams,
           :open_feature
@@ -143,6 +145,7 @@ module Datadog
           @runtime_metrics = self.class.build_runtime_metrics_worker(settings, @logger, telemetry)
           @health_metrics = self.class.build_health_metrics(settings, @logger, telemetry)
           @appsec = Datadog::AppSec::Component.build_appsec_component(settings, telemetry: telemetry)
+          @ai_guard = Datadog::AIGuard::Component.build(settings, logger: @logger, telemetry: telemetry)
           @open_feature = OpenFeature::Component.build(settings, agent_settings, logger: @logger, telemetry: telemetry)
           @dynamic_instrumentation = Datadog::DI::Component.build(settings, agent_settings, @logger, telemetry: telemetry)
           @error_tracking = Datadog::ErrorTracking::Component.build(settings, @tracer, @logger)
@@ -209,6 +212,9 @@ module Datadog
           # Decommission AppSec
           appsec&.shutdown!
 
+          # Shutdown AIGuard component
+          ai_guard&.shutdown!
+
           # Shutdown the old tracer, unless it's still being used.
           # (e.g. a custom tracer instance passed in.)
           tracer.shutdown! unless replacement && tracer.equal?(replacement.tracer)

data/lib/datadog/core/configuration/config_helper.rb

@@ -9,7 +9,7 @@ module Datadog
       class ConfigHelper
         def initialize(
           source_env: ENV,
-          supported_configurations: SUPPORTED_CONFIGURATIONS,
+          supported_configurations: SUPPORTED_CONFIGURATION_NAMES,
           aliases: ALIASES,
           alias_to_canonical: ALIAS_TO_CANONICAL,
           raise_on_unknown_env_var: false

data/lib/datadog/core/configuration/deprecations.rb

@@ -21,12 +21,12 @@ module Datadog
         end
 
         private_class_method def self.log_deprecated_environment_variables(logger, source_env, source_name, deprecations, alias_to_canonical)
-          deprecations.each do |deprecated_env_var, message|
+          deprecations.each do |deprecated_env_var|
             next unless source_env.key?(deprecated_env_var)
 
             Datadog::Core.log_deprecation(disallowed_next_major: false, logger: logger) do
               "#{deprecated_env_var} #{source_name} variable is deprecated" +
-                (alias_to_canonical[deprecated_env_var] ? ", use #{alias_to_canonical[deprecated_env_var]} instead." : ". #{message}.")
+                (alias_to_canonical[deprecated_env_var] ? ", use #{alias_to_canonical[deprecated_env_var]} instead." : ".")
             end
           end
         end

data/lib/datadog/core/configuration/option_definition.rb

@@ -42,7 +42,8 @@ module Datadog
         # Acts as DSL for building OptionDefinitions
         # @public_api
         class Builder
-          InvalidOptionError = Class.new(StandardError)
+          # Steep: https://github.com/soutaro/steep/issues/1880
+          InvalidOptionError = Class.new(StandardError) # steep:ignore IncompatibleAssignment
 
           attr_reader \
             :helpers
@@ -119,7 +120,8 @@ module Datadog
             env_parser(&options[:env_parser]) if options.key?(:env_parser)
             after_set(&options[:after_set]) if options.key?(:after_set)
             resetter(&options[:resetter]) if options.key?(:resetter)
-            setter(&options[:setter]) if options.key?(:setter)
+            # Steep: https://github.com/soutaro/steep/issues/1979
+            setter(&options[:setter]) if options.key?(:setter) # steep:ignore BlockTypeMismatch
             type(options[:type], **(options[:type_options] || {})) if options.key?(:type)
           end
 

data/lib/datadog/core/configuration/options.rb

@@ -40,14 +40,16 @@ module Datadog
 
           def default_helpers(name)
             option_name = name.to_sym
-            # @type var opt_getter: Configuration::OptionDefinition::helper_proc
-            opt_getter = proc do
+            # Steep: https://github.com/soutaro/steep/issues/335
+            # @type var opt_getter: Configuration::OptionDefinition::generic_proc
+            opt_getter = proc do # steep:ignore IncompatibleAssignment
               # These Procs uses `get/set_option`, but we only add them to the OptionDefinition helpers here.
               # Steep is right that these methods are not defined, but we only run these Procs in instance context.
               get_option(option_name) # steep:ignore NoMethod
             end
-            # @type var opt_setter: Configuration::OptionDefinition::helper_proc
-            opt_setter = proc do |value|
+            # Steep: https://github.com/soutaro/steep/issues/335
+            # @type var opt_setter: Configuration::OptionDefinition::generic_proc
+            opt_setter = proc do |value| # steep:ignore IncompatibleAssignment
               set_option(option_name, value) # steep:ignore NoMethod
             end
             {
@@ -127,7 +129,8 @@ module Datadog
           end
         end
 
-        InvalidOptionError = Class.new(StandardError)
+        # Steep: https://github.com/soutaro/steep/issues/1880
+        InvalidOptionError = Class.new(StandardError) # steep:ignore IncompatibleAssignment
       end
     end
   end

data/lib/datadog/core/configuration/settings.rb

@@ -170,6 +170,20 @@ module Datadog
           o.env Core::Environment::Ext::ENV_ENVIRONMENT
         end
 
+        # Configuration for container environments. For internal use only.
+        # @!visibility private
+        settings :container do
+          # Data supplied by the container runner to assist in uniquely identifying this process.
+          # Used in [Origin Detection](https://docs.datadoghq.com/developers/dogstatsd/unix_socket/?tab=host#origin-detection)
+          #
+          # @default `DD_EXTERNAL_ENV` environment variable, otherwise `nil`
+          # @return [String,nil]
+          option :external_env do |o|
+            o.type :string, nilable: true
+            o.env Core::Environment::Ext::ENV_EXTERNAL_ENV
+          end
+        end
+
         # Internal {Datadog::Statsd} metrics collection.
         #
         # @public_api
@@ -293,9 +307,6 @@ module Datadog
             #       for Ruby versions 2.x, 3.1.4+, 3.2.3+ and 3.3.0+
             #       (more details in {Datadog::Profiling::Component.enable_gc_profiling?})
             #
-            # @warn Due to a VM bug in the Ractor implementation (https://bugs.ruby-lang.org/issues/19112) this feature
-            #       stops working when Ractors get garbage collected.
-            #
             # @default `DD_PROFILING_GC_ENABLED` environment variable, otherwise `true`
             option :gc_enabled do |o|
               o.type :bool

data/lib/datadog/core/configuration/supported_configurations.rb

@@ -8,8 +8,13 @@ require 'set'
 module Datadog
   module Core
     module Configuration
-      SUPPORTED_CONFIGURATIONS =
+      SUPPORTED_CONFIGURATION_NAMES =
         Set["DD_AGENT_HOST",
+          "DD_AI_GUARD_ENABLED",
+          "DD_AI_GUARD_ENDPOINT",
+          "DD_AI_GUARD_MAX_CONTENT_SIZE",
+          "DD_AI_GUARD_MAX_MESSAGES_LENGTH",
+          "DD_AI_GUARD_TIMEOUT",
           "DD_API_KEY",
           "DD_API_SECURITY_ENABLED",
           "DD_API_SECURITY_ENDPOINT_COLLECTION_ENABLED",
@@ -34,6 +39,7 @@ module Datadog
           "DD_APPSEC_TRACE_RATE_LIMIT",
           "DD_APPSEC_WAF_DEBUG",
           "DD_APPSEC_WAF_TIMEOUT",
+          "DD_APP_KEY",
           "DD_CRASHTRACKING_ENABLED",
           "DD_DATA_STREAMS_ENABLED",
           "DD_DBM_PROPAGATION_MODE",
@@ -47,6 +53,7 @@ module Datadog
           "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE",
           "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED",
           "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED",
+          "DD_EXTERNAL_ENV",
           "DD_GIT_COMMIT_SHA",
           "DD_GIT_REPOSITORY_URL",
           "DD_HEALTH_METRICS_ENABLED",

data/lib/datadog/core/environment/cgroup.rb

@@ -10,40 +10,67 @@ module Datadog
       # about the current Linux container identity.
       # @see https://man7.org/linux/man-pages/man7/cgroups.7.html
       module Cgroup
-        LINE_REGEX = /^(\d+):([^:]*):(.+)$/.freeze
-
-        Descriptor = Struct.new(
-          :id,
-          :groups,
+        # A parsed cgroup entry from /proc/<pid>/cgroup
+        Entry = Struct.new(
+          :hierarchy,
+          :controllers,
           :path,
-          :controllers
+          :inode
         )
 
         module_function
 
-        def descriptors(process = 'self')
-          [].tap do |descriptors|
-            filepath = "/proc/#{process}/cgroup"
-
-            if File.exist?(filepath)
-              File.foreach("/proc/#{process}/cgroup") do |line|
-                line = line.strip
-                descriptors << parse(line) unless line.empty?
-              end
-            end
-          rescue => e
-            Datadog.logger.error(
-              "Error while parsing cgroup. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-            )
+        # Parses the /proc/self/cgroup file,
+        # @return [Array<Entry>] one entry for each valid cgroup line
+        def entries
+          filepath = '/proc/self/cgroup'
+          return [] unless File.exist?(filepath)
+
+          ret = []
+          File.foreach(filepath) do |entry_line|
+            ret << parse(entry_line) unless entry_line.empty?
           end
+          ret
         end
 
-        def parse(line)
-          id, groups, path = line.scan(LINE_REGEX).first
+        # Parses a single cgroup entry from /proc/<pid>/cgroup.
+        #
+        # Files can have cgroup v1 and v2 entries mixed. Their format is the same.
+        #
+        # Each entry has 3 colon-separated fields:
+        #   hierarchy-ID:controllers:path
+        # Examples:
+        #   10:memory:/docker/1234567890abcdef (cgroup v1)
+        #   0::/docker/1234567890abcdef (cgroup v2)
+        #
+        # @see https://man7.org/linux/man-pages/man7/cgroups.7.html#:~:text=%2Fproc%2Fpid%2Fcgroup
+        # @return [Entry]
+        def parse(entry_line)
+          hierarchy, controllers, path = entry_line.split(':', 3)
 
-          Descriptor.new(id, groups, path).tap do |descriptor|
-            descriptor.controllers = groups.split(',') unless groups.nil?
-          end
+          Entry.new(
+            hierarchy,
+            controllers,
+            path,
+            inode_for(controllers, path)
+          )
+        end
+
+        # We can find the container inode by running a file stat on the cgroup filesystem path.
+        # Example:
+        #   For the entry `0:cpu:/docker/abc123`,
+        #   we read `stat -c '%i' /sys/fs/cgroup/cpu/docker/abc123`
+        def inode_for(controllers, path)
+          return if controllers.nil? || path.nil?
+
+          # In cgroup v1, when multiple controllers are co-mounted, the controllers
+          # becomes part of the directory name (with commas preserved).
+          # Example entry:
+          #   For the line "10:cpu,cpuacct:/docker/abc123", the path is
+          #   "/sys/fs/cgroup/cpu,cpuacct/docker/abc123"
+          inode_path = File.join('/sys/fs/cgroup', controllers, path)
+
+          File.stat(inode_path).ino if File.exist?(inode_path)
         end
       end
     end

data/lib/datadog/core/environment/container.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'cgroup'
+require_relative 'ext'
 
 module Datadog
   module Core
@@ -15,73 +16,166 @@ module Datadog
         CONTAINER_REGEX = /(?<container>#{UUID_PATTERN}|#{CONTAINER_PATTERN})(?:.scope)?$/.freeze
         FARGATE_14_CONTAINER_REGEX = /(?<container>[0-9a-f]{32}-[0-9]{1,10})/.freeze
 
-        Descriptor = Struct.new(
+        # From https://github.com/torvalds/linux/blob/5859a2b1991101d6b978f3feb5325dad39421f29/include/linux/proc_ns.h#L41-L49
+        # Currently, the host namespace inode number is hardcoded.
+        # We use it to determine if we're running in the host namespace.
+        # This detection approach does not work when running in
+        # ["Docker-in-Docker"](https://www.docker.com/resources/docker-in-docker-containerized-ci-workflows-dockercon-2023/).
+        HOST_CGROUP_NAMESPACE_INODE = 0xEFFFFFFB
+
+        Entry = Struct.new(
           :platform,
+          :task_uid,
           :container_id,
-          :task_uid
+          :inode
         )
 
         module_function
 
+        # Returns HTTP headers representing container information.
+        # These can used in any Datadog request that requires origin detection.
+        # This is the recommended method to call to get container information.
+        def to_headers
+          headers = {}
+          headers["Datadog-Container-ID"] = container_id if container_id
+          headers["Datadog-Entity-ID"] = entity_id if entity_id
+          headers["Datadog-External-Env"] = external_env if external_env
+          headers
+        end
+
+        # Container ID, prefixed with "ci-" or Inode, prefixed with "in-".
+        def entity_id
+          if container_id
+            "ci-#{container_id}"
+          elsif inode
+            "in-#{inode}"
+          end
+        end
+
+        # External data supplied by the Datadog Cluster Agent Admission Controller.
+        # @see {Ext::ENV_EXTERNAL_ENV} for more details.
+        def external_env
+          Datadog.configuration.container.external_env
+        end
+
+        # The container orchestration platform or runtime environment.
+        #
+        # Examples: Docker, Kubernetes, AWS Fargate, LXC, etc.
+        #
+        # @return [String, nil] The platform name (e.g., "docker", "kubepods", "fargate"), or nil if not containerized
         def platform
-          descriptor.platform
+          entry.platform
         end
 
+        # The unique identifier of the current container in the container environment.
+        #
+        # @return [String, nil] The container ID, or nil if not running in a containerized environment
         def container_id
-          descriptor.container_id
+          entry.container_id
         end
 
+        # The unique identifier of the task or pod containing this container.
+        #
+        # In Kubernetes, this is the Pod UID; in AWS ECS/Fargate, the task ID.
+        # Used to identify higher-level workloads beyond this container,
+        # enabling correlation across container restarts and multi-container applications.
+        #
+        # @return [String, nil] The task/pod UID, or nil if not available in the current environment
         def task_uid
-          descriptor.task_uid
+          entry.task_uid
         end
 
-        def descriptor
-          @descriptor ||= Descriptor.new.tap do |descriptor|
-            Cgroup.descriptors.each do |cgroup_descriptor|
-              # Parse container data from cgroup descriptor
-              path = cgroup_descriptor.path
-              next if path.nil?
-
-              # Split path into parts
-              parts = path.split('/')
-              parts.shift # Remove leading empty part
-
-              # Read info from path
-              next if parts.empty?
-
-              platform = parts[0][PLATFORM_REGEX, :platform]
-              container_id, task_uid = nil
-
-              case parts.length
-              when 0..1
-                next
-              when 2
-                container_id = parts[-1][CONTAINER_REGEX, :container] \
-                              || parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
-              else
-                if (container_id = parts[-1][CONTAINER_REGEX, :container])
+        # A unique identifier for the execution context (container or host namespace).
+        #
+        # Used as a fallback identifier when {#container_id} is unavailable.
+        #
+        # @return [Integer, nil] The namespace inode, or nil if unavailable
+        def inode
+          entry.inode
+        end
+
+        # Checks if the current process is running on the host cgroup namespace.
+        # This indicates that the process is not running inside a container.
+        # When unsure, we return `false` (not running on host).
+        def running_on_host?
+          return @running_on_host if defined?(@running_on_host)
+
+          @running_on_host = begin
+            if File.exist?('/proc/self/ns/cgroup')
+              File.stat('/proc/self/ns/cgroup').ino == HOST_CGROUP_NAMESPACE_INODE
+            else
+              false
+            end
+          rescue => e
+            Datadog.logger.debug(
+              "Error while checking cgroup namespace. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            )
+            false
+          end
+        end
+
+        # All cgroup entries have the same container identity.
+        # The first valid one is sufficient.
+        # v2 entries are preferred over v1.
+        def entry
+          return @entry if defined?(@entry)
+
+          # Scan all v2 entries first, only then falling back to v1 entries.
+          #
+          # To do this, we {Enumerable#partition} the list between v1 and v2,
+          # with a `true` predicate for v2 entries, making v2 first
+          # partition returned.
+          #
+          # All v2 entries have the `hierarchy` set to zero.
+          # v1 entries have a non-zero `hierarchy`.
+          entries = Cgroup.entries.partition { |d| d.hierarchy == '0' }.flatten(1)
+          entries.each do |entry_obj|
+            path = entry_obj.path
+            next unless path
+
+            # To ease handling, remove the emtpy leading "",
+            # as `path` starts with a "/".
+            path.delete_prefix!('/')
+            parts = path.split('/')
+
+            # With not path information, we can still use the inode
+            if parts.empty? && entry_obj.inode && !running_on_host?
+              return @entry = Entry.new(nil, nil, nil, entry_obj.inode)
+            end
+
+            platform = parts[0][PLATFORM_REGEX, :platform]
+
+            # Extract container_id and task_uid based on path structure
+            container_id = task_uid = nil
+            if parts.length >= 2
+              # Try standard container regex first
+              if (container_id = parts[-1][CONTAINER_REGEX, :container])
+                # For 3+ parts, also extract task_uid
+                if parts.length > 2
                   task_uid = parts[-2][POD_REGEX, :pod] || parts[1][POD_REGEX, :pod]
-                else
-                  container_id = parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
                 end
+              else
+                # Fall back to Fargate regex
+                container_id = parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
               end
+            end
 
-              # If container ID wasn't found, ignore.
-              # Path might describe a non-container environment.
-              next if container_id.nil?
-
-              descriptor.platform = platform
-              descriptor.container_id = container_id
-              descriptor.task_uid = task_uid
-
-              break
+            # container_id is a better container identifier than inode.
+            # We MUST only populate one of them, to avoid container identification ambiguity.
+            if container_id
+              return @entry = Entry.new(platform, task_uid, container_id)
+            elsif entry_obj.inode && !running_on_host?
+              return @entry = Entry.new(platform, task_uid, nil, entry_obj.inode)
             end
-          rescue => e
-            Datadog.logger.error(
-              "Error while parsing container info. Cause: #{e.class.name} #{e.message} " \
-              "Location: #{Array(e.backtrace).first}"
-            )
           end
+
+          @entry = Entry.new # Empty entry if no valid cgroup entry is found
+        rescue => e
+          Datadog.logger.debug(
+            "Error while reading container entry. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          @entry = Entry.new unless defined?(@entry)
+          @entry
         end
       end
     end

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

@@ -17,6 +17,7 @@ module Datadog
 
         ENV_API_KEY = 'DD_API_KEY'
         ENV_ENVIRONMENT = 'DD_ENV'
+        ENV_EXTERNAL_ENV = 'DD_EXTERNAL_ENV'
         ENV_SERVICE = 'DD_SERVICE'
         ENV_SITE = 'DD_SITE'
         ENV_TAGS = 'DD_TAGS'

data/lib/datadog/core/environment/process.rb

@@ -14,6 +14,14 @@ module Datadog
         # @return [String] comma-separated normalized key:value pairs
         def self.serialized
           return @serialized if defined?(@serialized)
+
+          @serialized = tags.join(',').freeze
+        end
+
+        # This method returns an array in the format ["k1:v1","k2:v2","k3:v3"]
+        # @return [Array<String>] array of normalized key:value pairs
+        def self.tags
+          return @tags if defined?(@tags)
           tags = []
 
           workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
@@ -27,7 +35,7 @@ module Datadog
 
           tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
 
-          @serialized = tags.join(',').freeze
+          @tags = tags.freeze
         end
 
         # Returns the last segment of the working directory of the process

data/lib/datadog/core/error.rb

@@ -13,12 +13,12 @@ module Datadog
           case value
           # A Ruby {Exception} is the most common parameter type.
           when Exception then new(value.class, value.message, full_backtrace(value))
-          # steep:ignore:start
-          # Steep doesn't like an array with up to 3 elements to be passed here: it thinks the array is unbounded.
-          when Array then new(*value)
-          # Steep can not follow the logic inside the lambda, thus it doesn't know `value` responds to `:message`.
-          when ->(v) { v.respond_to?(:message) } then new(value.class, value.message)
-          # steep:ignore:end
+          # Steep: Steep doesn't like an array with up to 3 elements to be passed here: it thinks the array is unbounded.
+          when Array then new(*value) # steep:ignore UnexpectedPositionalArgument
+          when ->(v) { v.respond_to?(:message) }
+            # Steep: Steep can not follow the logic inside the lambda, thus it doesn't know `value` responds to `:message`.
+            # @type var value: _ContainsMessage
+            new(value.class, value.message)
           when String then new(nil, value)
           when Error then value
           else Error.new # Blank error

data/lib/datadog/core/pin.rb

@@ -44,12 +44,16 @@ module Datadog
       def onto(obj)
         unless obj.respond_to? :datadog_pin=
           obj.define_singleton_method(:datadog_pin=) do |pin|
+            # Steep: https://github.com/soutaro/steep/issues/380
+            # @type self: PinnedObject
             @datadog_pin = pin
           end
         end
 
         unless obj.respond_to? :datadog_pin
           obj.define_singleton_method(:datadog_pin) do
+            # Steep: https://github.com/soutaro/steep/issues/380
+            # @type self: PinnedObject
             @datadog_pin
           end
         end

data/lib/datadog/core/rate_limiter.rb

@@ -81,6 +81,10 @@ module Datadog
 
         return current_window_rate if @prev_conforming_messages.nil? || @prev_total_messages.nil?
 
+        # Steep: Due to https://github.com/soutaro/steep/issues/477,
+        # the previous nil check does not narrow type to Integer
+        # The annotation fixes the typing error, but it takes effect in the method
+        # @type ivar @prev_total_messages: Integer
         (@conforming_messages.to_f + @prev_conforming_messages.to_f) / (@total_messages + @prev_total_messages)
       end
 
@@ -154,7 +158,11 @@ module Datadog
         if @current_window.nil?
           @current_window = now
         # If more than 1 second has past since last window, reset
-        elsif now - @current_window >= 1
+        #
+        # Steep: @current_window is a Float, but for some reason annotations does not work here
+        # Once a fix will be out for nil checks on instance variables, we can remove the ignore comment
+        # https://github.com/soutaro/steep/issues/477
+        elsif now - @current_window >= 1 # steep:ignore UnresolvedOverloading
           @prev_conforming_messages = @conforming_messages
           @prev_total_messages = @total_messages
           @conforming_messages = 0

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

@@ -14,10 +14,11 @@ module Datadog
 
         class SyncError < StandardError; end
 
-        attr_reader :transport, :repository, :id, :dispatcher, :logger
+        attr_reader :transport, :repository, :id, :dispatcher, :settings, :logger
 
-        def initialize(transport, capabilities, logger: Datadog.logger, repository: Configuration::Repository.new)
+        def initialize(transport, capabilities, settings:, logger:, repository: Configuration::Repository.new)
           @transport = transport
+          @settings = settings
           @logger = logger
 
           @repository = repository
@@ -97,7 +98,9 @@ module Datadog
               content = contents.find_content(path, target)
 
               # abort entirely if matching content not found
-              raise SyncError, "no valid content for target at path '#{path}'" if content.nil?
+              if content.nil?
+                raise SyncError, "no valid content for target at path '#{path}'"
+              end
 
               # to be added or updated << config
               # TODO: metadata (hash, version, etc...)
@@ -153,14 +156,19 @@ module Datadog
             language: Core::Environment::Identity.lang,
             tracer_version: tracer_version,
             service: service_name,
-            env: Datadog.configuration.env,
+            env: settings.env,
             tags: client_tracer_tags,
           }
 
-          app_version = Datadog.configuration.version
+          app_version = settings.version
 
           client_tracer[:app_version] = app_version if app_version
 
+          if settings.experimental_propagate_process_tags_enabled
+            process_tags = Core::Environment::Process.tags
+            client_tracer[:process_tags] = process_tags if process_tags.any?
+          end
+
           {
             client: {
               state: {
@@ -184,7 +192,7 @@ module Datadog
         end
 
         def service_name
-          Datadog.configuration.remote.service || Datadog.configuration.service
+          settings.remote.service || settings.service
         end
 
         def tracer_version