datadog 2.8.0 → 2.39.0

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

@@ -1,89 +1,181 @@
 # frozen_string_literal: true
 
-require_relative 'cgroup'
+require_relative "cgroup"
+require_relative "ext"
 
 module Datadog
   module Core
     module Environment
       # For container environments
       module Container
-        UUID_PATTERN = '[0-9a-f]{8}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{12}'
-        CONTAINER_PATTERN = '[0-9a-f]{64}'
+        UUID_PATTERN = "[0-9a-f]{8}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{4}[-_]?[0-9a-f]{12}"
+        CONTAINER_PATTERN = "[0-9a-f]{64}"
 
         PLATFORM_REGEX = /(?<platform>.*?)(?:.slice)?$/.freeze
         POD_REGEX = /(?<pod>(pod)?#{UUID_PATTERN})(?:.slice)?$/.freeze
         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|
-            begin
-              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])
-                    task_uid = parts[-2][POD_REGEX, :pod] || parts[1][POD_REGEX, :pod]
-                  else
-                    container_id = parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
-                  end
-                end
+        # 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
 
-                # If container ID wasn't found, ignore.
-                # Path might describe a non-container environment.
-                next if container_id.nil?
+        # 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}: #{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
 
-                descriptor.platform = platform
-                descriptor.container_id = container_id
-                descriptor.task_uid = task_uid
+            platform = parts[0][PLATFORM_REGEX, :platform]
 
-                break
+            # 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]
+                end
+              else
+                # Fall back to Fargate regex
+                container_id = parts[-1][FARGATE_14_CONTAINER_REGEX, :container]
               end
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Error while parsing container info. Cause: #{e.class.name} #{e.message} " \
-                "Location: #{Array(e.backtrace).first}"
-              )
+            end
+
+            # 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
           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}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          @entry = Entry.new unless defined?(@entry)
+          @entry
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
 module Datadog
   module Core
@@ -51,7 +51,7 @@ module Datadog
             $PROGRAM_NAME.end_with?(RSPEC_PROGRAM_NAME)
           end
 
-          RSPEC_PROGRAM_NAME = '/rspec'
+          RSPEC_PROGRAM_NAME = "/rspec"
           private_constant :RSPEC_PROGRAM_NAME
 
           # Check if Minitest is present and installed to run.
@@ -83,7 +83,7 @@ module Datadog
             !!defined?(::Spring) || rails_env_development?
           end
 
-          RAILS_ENV_DEVELOPMENT = Set['development', 'test'].freeze
+          RAILS_ENV_DEVELOPMENT = Set["development", "test"].freeze
           private_constant :RAILS_ENV_DEVELOPMENT
 
           # By default, every Rails application has three environments: `development`, `test`, and `production`.

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../datadog/version'
+require_relative "../../../datadog/version"
 
 module Datadog
   module Core
@@ -9,36 +9,47 @@ module Datadog
       module Ext
         # e.g for CRuby '3.0.1', for JRuby '9.2.19.0', for TruffleRuby '21.1.0'
         ENGINE_VERSION = if defined?(RUBY_ENGINE_VERSION)
-                           RUBY_ENGINE_VERSION
-                         else
-                           # CRuby < 2.3 doesn't support RUBY_ENGINE_VERSION
-                           RUBY_VERSION
-                         end
+          RUBY_ENGINE_VERSION
+        else
+          # CRuby < 2.3 doesn't support RUBY_ENGINE_VERSION
+          RUBY_VERSION
+        end
 
-        ENV_API_KEY = 'DD_API_KEY'
-        ENV_ENVIRONMENT = 'DD_ENV'
-        ENV_SERVICE = 'DD_SERVICE'
-        ENV_OTEL_SERVICE = 'OTEL_SERVICE_NAME'
-        ENV_SITE = 'DD_SITE'
-        ENV_TAGS = 'DD_TAGS'
-        ENV_OTEL_RESOURCE_ATTRIBUTES = 'OTEL_RESOURCE_ATTRIBUTES'
-        ENV_VERSION = 'DD_VERSION'
+        ENV_API_KEY = "DD_API_KEY"
+        ENV_ENVIRONMENT = "DD_ENV"
+        ENV_EXTERNAL_ENV = "DD_EXTERNAL_ENV"
+        ENV_HOSTNAME = "DD_HOSTNAME"
+        ENV_SERVICE = "DD_SERVICE"
+        ENV_SITE = "DD_SITE"
+        ENV_TAGS = "DD_TAGS"
+        ENV_VERSION = "DD_VERSION"
         FALLBACK_SERVICE_NAME =
           begin
-            File.basename($PROGRAM_NAME, '.*')
-          rescue StandardError
-            'ruby'
+            File.basename($PROGRAM_NAME, ".*")
+          rescue
+            "ruby"
           end.freeze
 
-        LANG = 'ruby'
+        LANG = "ruby"
         LANG_ENGINE = RUBY_ENGINE
         LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}"
         LANG_PLATFORM = RUBY_PLATFORM
         LANG_VERSION = RUBY_VERSION
+        PROCESS_TYPE = "script" # Out of the options [jar, script, class, executable], we consider Ruby to always be a script
         RUBY_ENGINE = ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
-        TAG_ENV = 'env'
-        TAG_SERVICE = 'service'
-        TAG_VERSION = 'version'
+        TAG_ENV = "env"
+        TAG_ENTRYPOINT_BASEDIR = "entrypoint.basedir"
+        TAG_ENTRYPOINT_NAME = "entrypoint.name"
+        TAG_ENTRYPOINT_WORKDIR = "entrypoint.workdir"
+        TAG_ENTRYPOINT_TYPE = "entrypoint.type"
+        TAG_RAILS_APPLICATION = "rails.application"
+        TAG_PROCESS_TAGS = "_dd.tags.process"
+        TAG_SERVICE = "service"
+        # Service name was automatically populated by this library
+        TAG_SVC_AUTO = "svc.auto"
+        # Service name was explicitly configured by the library user
+        TAG_SVC_USER = "svc.user"
+        TAG_VERSION = "version"
 
         GEM_DATADOG_VERSION = Datadog::VERSION::STRING
       end

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

@@ -1,23 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../git/ext'
-require_relative '../utils/url'
+require_relative "../git/ext"
+require_relative "../utils/url"
 
 module Datadog
   module Core
+    # Environment
     module Environment
       # Retrieves git repository information from environment variables
       module Git
         def self.git_repository_url
           return @git_repository_url if defined?(@git_repository_url)
 
-          @git_repository_url = Utils::Url.filter_basic_auth(ENV[Datadog::Core::Git::Ext::ENV_REPOSITORY_URL])
+          @git_repository_url = Utils::Url.filter_basic_auth(DATADOG_ENV[Datadog::Core::Git::Ext::ENV_REPOSITORY_URL])
         end
 
         def self.git_commit_sha
           return @git_commit_sha if defined?(@git_commit_sha)
 
-          @git_commit_sha = ENV[Datadog::Core::Git::Ext::ENV_COMMIT_SHA]
+          @git_commit_sha = DATADOG_ENV[Datadog::Core::Git::Ext::ENV_COMMIT_SHA]
         end
       end
     end

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require 'securerandom'
+require "securerandom"
 
-require_relative 'ext'
-require_relative '../utils/forking'
+require_relative "../configuration/config_helper"
+require_relative "ext"
+require_relative "../utils/forking"
 
 module Datadog
   module Core
@@ -13,18 +14,39 @@ module Datadog
       module Identity
         extend Core::Utils::Forking
 
+        ENV_ROOT_SESSION_ID = "_DD_ROOT_RB_SESSION_ID"
+        ENV_PARENT_SESSION_ID = "_DD_PARENT_RB_SESSION_ID"
+
         module_function
 
-        # Retrieves number of classes from runtime
+        @root_runtime_id = DATADOG_ENV[ENV_ROOT_SESSION_ID]&.freeze
+        @parent_runtime_id = DATADOG_ENV[ENV_PARENT_SESSION_ID]&.freeze
+
         def id
           @id ||= ::SecureRandom.uuid.freeze
 
-          # Check if runtime has changed, e.g. forked.
-          after_fork! { @id = ::SecureRandom.uuid.freeze }
+          after_fork! do
+            # Order matters: capture @id before overwriting
+            @parent_runtime_id = @id
+            @root_runtime_id ||= @id
+            @id = ::SecureRandom.uuid.freeze
+          end
 
           @id
         end
 
+        def root_runtime_id
+          @root_runtime_id
+        end
+
+        def parent_runtime_id
+          @parent_runtime_id
+        end
+
+        def runtime_propagation_envs
+          {ENV_ROOT_SESSION_ID => root_runtime_id || id, ENV_PARENT_SESSION_ID => id}.freeze
+        end
+
         def pid
           ::Process.pid
         end
@@ -54,25 +76,39 @@ module Datadog
           Core::Environment::Ext::GEM_DATADOG_VERSION
         end
 
-        # Returns tracer version, comforming to https://semver.org/spec/v2.0.0.html
+        # Returns the tracer version in SemVer-2 form (https://semver.org/spec/v2.0.0.html).
+        #
+        # Converts the RubyGems-style version returned by {.gem_datadog_version}
+        # (dot-separated prerelease/build segments, e.g. "2.34.0.dev") into the
+        # SemVer-2 form expected by cross-language Datadog consumers (hyphen-separated
+        # prerelease, "+" build metadata, e.g. "2.34.0-dev").
+        #
+        # Called by reporters that emit a tracer version on the wire and must match
+        # the format used by other-language tracers:
+        # - process discovery memfd (`Core::ProcessDiscovery.get_metadata` → `tracer_version`)
+        # - telemetry payloads (`Core::Telemetry::Request#application`)
+        # - remote configuration client identification (`Core::Remote::Client#tracer_version`)
+        #
+        # Use {.gem_datadog_version} (not this method) when a RubyGems-style string is
+        # required (e.g. gem-internal contexts, gemspec interop).
         def gem_datadog_version_semver2
-          major, minor, patch, rest = gem_datadog_version.split('.', 4)
+          major, minor, patch, rest = gem_datadog_version.split(".", 4)
 
           semver = "#{major}.#{minor}.#{patch}"
 
           return semver unless rest
 
-          pre = ''
-          build = ''
+          pre = ""
+          build = ""
 
-          rest.split('.').tap do |segments|
+          rest.split(".").tap do |segments|
             if segments.length >= 4
-              pre   = "-#{segments.shift}"
-              build = "+#{segments.join('.')}"
+              pre = "-#{segments.shift}"
+              build = "+#{segments.join(".")}"
             elsif segments.length == 1
               pre = "-#{segments.shift}"
             else
-              build = "+#{segments.join('.')}"
+              build = "+#{segments.join(".")}"
             end
           end
 

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'etc'
+require "etc"
 
-require_relative 'identity'
+require_relative "identity"
 
 module Datadog
   module Core
@@ -13,32 +13,32 @@ module Datadog
 
         # @return [String] ISA of host; `uname -m`
         def architecture
-          Identity.lang_version >= '2.2' ? Etc.uname[:machine] : Gem::Platform.local.cpu
+          (Identity.lang_version >= "2.2") ? Etc.uname[:machine] : Gem::Platform.local.cpu
         end
 
         # @return [String] name of host; `uname -n`
         def hostname
-          Identity.lang_version >= '2.2' ? Etc.uname[:nodename] : nil
+          (Identity.lang_version >= "2.2") ? Etc.uname[:nodename] : nil
         end
 
         # System name, normally `Linux` or `Darwin` (but 'Mac OS X' on JRuby);
         # @return [String] name of kernel; `uname -s`.
         def kernel_name
-          Identity.lang_version >= '2.2' ? Etc.uname[:sysname] : Gem::Platform.local.os.capitalize
+          (Identity.lang_version >= "2.2") ? Etc.uname[:sysname] : Gem::Platform.local.os.capitalize
         end
 
         # @return [String] kernel release; `uname -r`
         def kernel_release
-          if Identity.lang_engine == 'jruby'
+          if Identity.lang_engine == "jruby"
             Etc.uname[:version] # Java's `os.version` maps to `uname -r`
-          elsif Identity.lang_version >= '2.2'
+          elsif Identity.lang_version >= "2.2"
             Etc.uname[:release]
           end
         end
 
         # @return [String] kernel version; `uname -v`
         def kernel_version
-          Etc.uname[:version] if Identity.lang_engine != 'jruby' && Identity.lang_version >= '2.2'
+          Etc.uname[:version] if Identity.lang_engine != "jruby" && Identity.lang_version >= "2.2"
         end
       end
     end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "ext"
+require_relative "../tag_normalizer"
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves process level information such that it can be attached to various payloads
+      #
+      # @api private
+      module Process
+        # Returns a comma-separated string of normalized key:value pairs.
+        # Includes svc.user or svc.auto based on whether the service was explicitly configured.
+        # @return [String]
+        def self.serialized
+          tags.join(",").freeze
+        end
+
+        # Returns an array of normalized key:value pair strings.
+        # Includes svc.user or svc.auto based on whether the service was explicitly configured.
+        # @return [Array<String>]
+        def self.tags
+          tags = []
+
+          workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_WORKDIR}:#{workdir}" unless workdir.empty?
+
+          entry_name = TagNormalizer.normalize_process_value(entrypoint_name.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_NAME}:#{entry_name}" unless entry_name.empty?
+
+          basedir = TagNormalizer.normalize_process_value(entrypoint_basedir.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_BASEDIR}:#{basedir}" unless basedir.empty?
+
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
+
+          if defined?(@rails_application_name)
+            rails_name = TagNormalizer.normalize_process_value(@rails_application_name.to_s)
+            tags << "#{Environment::Ext::TAG_RAILS_APPLICATION}:#{rails_name}" unless rails_name.empty?
+          end
+
+          if defined?(@service_user_configured)
+            if @service_user_configured
+              tags << "#{Environment::Ext::TAG_SVC_USER}:true"
+            else
+              svc = TagNormalizer.normalize_process_value(@service_name.to_s)
+              tags << "#{Environment::Ext::TAG_SVC_AUTO}:#{svc}" unless svc.empty?
+            end
+          end
+
+          tags.freeze
+        end
+
+        # Called via after_set on option :service in settings.rb whenever the service value changes.
+        # @param name [String] the service name
+        # @param user_configured [Boolean] whether the service was explicitly set by the user
+        # @return [void]
+        def self.set_service(name, user_configured:)
+          @service_name = name
+          @service_user_configured = user_configured
+        end
+
+        # Sets the rails application name from other places in code
+        # @param name [String] the rails application name
+        # @return [void]
+        def self.rails_application_name=(name)
+          @rails_application_name = name
+        end
+
+        # Returns the last segment of the working directory of the process
+        # Example: /app/myapp -> myapp
+        # @return [String] the last segment of the working directory
+        def self.entrypoint_workdir
+          return @entrypoint_workdir if defined?(@entrypoint_workdir)
+
+          @entrypoint_workdir = File.basename(Dir.pwd)
+        end
+
+        # Returns the entrypoint type of the process
+        # In Ruby, the entrypoint type is always 'script'
+        # @return [String] the type of the process, which is fixed in Ruby
+        def self.entrypoint_type
+          Environment::Ext::PROCESS_TYPE
+        end
+
+        # Returns the basename of the script being run
+        # Example 1: /bin/mybin -> mybin
+        # Example 2: ruby /test/myapp.rb -> myapp.rb
+        # @return [String] the basename of the script
+        #
+        # @note Determining true entrypoint name is rather complicated. This method
+        # is the initial implementation but it does not produce optimal output in all cases.
+        # For example, all Rails applications launched via `rails server` get `rails`
+        # as their entrypoint name.
+        # We might improve the behavior in the future if there is customer demand for it.
+        def self.entrypoint_name
+          return @entrypoint_name if defined?(@entrypoint_name)
+
+          @entrypoint_name = File.basename($0)
+        end
+
+        # Returns the last segment of the directory containing the script
+        # Example 1: /bin/mybin -> bin
+        # Example 2: ruby /test/myapp.rb -> test
+        # @return [String] the last segment of the base directory of the script
+        #
+        # @note As with entrypoint name, determining true entrypoint directory is complicated.
+        # This method has an initial implementation that does not necessarily return good
+        # results in all cases. For example, for Rails applications launched via `rails server`
+        # the entrypoint basedir is `bin` which is not very helpful.
+        # We might improve this in the future if there is customer demand.
+        def self.entrypoint_basedir
+          return @entrypoint_basedir if defined?(@entrypoint_basedir)
+
+          @entrypoint_basedir = File.basename(File.expand_path(File.dirname($0)))
+        end
+
+        private_class_method :entrypoint_workdir, :entrypoint_type, :entrypoint_name, :entrypoint_basedir
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'socket'
-require_relative '../utils/forking'
+require "socket"
+require_relative "../utils/forking"
 
 module Datadog
   module Core
@@ -18,6 +18,19 @@ module Datadog
 
           @hostname ||= ::Socket.gethostname.freeze
         end
+
+        # Returns the resolved hostname when `report_hostname` is enabled:
+        # the configured DD_HOSTNAME if set, otherwise the system hostname.
+        # Returns nil when `report_hostname` is disabled or no hostname is available.
+        def resolved_hostname(settings)
+          return nil unless settings.tracing.report_hostname
+
+          configured = settings.hostname
+          return configured if configured && !configured.empty?
+
+          resolved_hostname = hostname
+          resolved_hostname if resolved_hostname && !resolved_hostname.empty?
+        end
       end
     end
   end