ddtrace 1.18.0 → 1.23.2

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

@@ -205,6 +205,22 @@ module Datadog
             option :transport
           end
 
+          # Can be used to enable/disable collection of allocation profiles.
+          #
+          # This feature is disabled by default
+          #
+          # @warn Due to bugs in Ruby we only recommend enabling this feature in
+          #       Ruby versions 2.x, 3.1.4+, 3.2.3+ and 3.3.0+
+          #       (more details in {Datadog::Profiling::Component.enable_allocation_profiling?})
+          #
+          # @default `DD_PROFILING_ALLOCATION_ENABLED` environment variable as a boolean, otherwise `false`
+          option :allocation_enabled do |o|
+            o.type :bool
+            o.deprecated_env 'DD_PROFILING_EXPERIMENTAL_ALLOCATION_ENABLED' # TODO: Remove this for dd-trace-rb 2.0
+            o.env 'DD_PROFILING_ALLOCATION_ENABLED'
+            o.default false
+          end
+
           # @public_api
           settings :advanced do
             # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
@@ -212,11 +228,13 @@ module Datadog
             # This was used prior to the GA of the new CPU Profiling 2.0 profiler. The CPU Profiling 2.0 profiler does not
             # use or need this setting and thus it doesn't do anything.
             option :max_events do |o|
-              o.after_set do
-                Datadog.logger.warn(
-                  'The profiling.advanced.max_events setting has been deprecated for removal and no ' \
-                  'longer does anything. Please remove it from your Datadog.configure block.'
-                )
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.max_events setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
               end
             end
 
@@ -248,18 +266,23 @@ module Datadog
 
             # Can be used to disable the gathering of names and versions of gems in use by the service, used to power
             # grouping and categorization of stack traces.
-            option :code_provenance_enabled, default: true
+            option :code_provenance_enabled do |o|
+              o.type :bool
+              o.default true
+            end
 
             # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
             #
             # This was added as a temporary support option in case of issues with the new `Profiling::HttpTransport` class
             # but we're now confident it's working nicely so we've removed the old code path.
             option :legacy_transport_enabled do |o|
-              o.after_set do
-                Datadog.logger.warn(
-                  'The profiling.advanced.legacy_transport_enabled setting has been deprecated for removal and no ' \
-                  'longer does anything. Please remove it from your Datadog.configure block.'
-                )
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.legacy_transport_enabled setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
               end
             end
 
@@ -268,11 +291,13 @@ module Datadog
             # This was used prior to the GA of the new CPU Profiling 2.0 profiler. Using CPU Profiling 2.0 is now the
             # default and this doesn't do anything.
             option :force_enable_new_profiler do |o|
-              o.after_set do
-                Datadog.logger.warn(
-                  'The profiling.advanced.force_enable_new_profiler setting has been deprecated for removal and no ' \
-                  'longer does anything. Please remove it from your Datadog.configure block.'
-                )
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.force_enable_new_profiler setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
               end
             end
 
@@ -281,67 +306,136 @@ module Datadog
             # This was used prior to the GA of the new CPU Profiling 2.0 profiler. Using CPU Profiling 2.0 is now the
             # default and this doesn't do anything.
             option :force_enable_legacy_profiler do |o|
-              o.after_set do
-                Datadog.logger.warn(
-                  'The profiling.advanced.force_enable_legacy_profiler setting has been deprecated for removal and no ' \
-                  'longer does anything. Please remove it from your Datadog.configure block.'
-                )
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.force_enable_legacy_profiler setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block.'
+                  )
+                end
               end
             end
 
-            # Forces enabling of profiling of time/resources spent in Garbage Collection.
+            # @deprecated No longer does anything, and will be removed on dd-trace-rb 2.0.
             #
-            # Note that setting this to "false" (or not setting it) will not prevent the feature from being
-            # being automatically enabled in the future.
+            # GC profiling is now on by default and controlled by {:gc_enabled}.
+            option :force_enable_gc_profiling do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.force_enable_gc_profiling setting has been deprecated for removal and no ' \
+                    'longer does anything (the feature is now on by default). ' \
+                    'Please remove this setting from your Datadog.configure block.'
+                  )
+                end
+              end
+            end
+
+            # Can be used to enable/disable garbage collection profiling.
             #
-            # This feature defaults to off for two reasons:
-            # 1. Currently this feature can add a lot of overhead for GC-heavy workloads.
-            # 2. Although this feature is safe on Ruby 2.x, on Ruby 3.x it can break in applications that make use of
-            #    Ractors due to two Ruby VM bugs:
-            #    https://bugs.ruby-lang.org/issues/19112 AND https://bugs.ruby-lang.org/issues/18464.
-            #    If you use Ruby 3.x and your application does not use Ractors (or if your Ruby has been patched), the
-            #    feature is fully safe to enable and this toggle can be used to do so.
+            # @warn To avoid https://bugs.ruby-lang.org/issues/18464 even when enabled, GC profiling is only started
+            #       for Ruby versions 2.x, 3.1.4+, 3.2.3+ and 3.3.0+
+            #       (more details in {Datadog::Profiling::Component.enable_gc_profiling?})
             #
-            # We expect the once the above issues are overcome, we'll automatically enable the feature on fixed Ruby
-            # versions.
+            # @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_FORCE_ENABLE_GC` environment variable, otherwise `false`
-            option :force_enable_gc_profiling do |o|
-              o.env 'DD_PROFILING_FORCE_ENABLE_GC'
+            # @default `DD_PROFILING_GC_ENABLED` environment variable, otherwise `true`
+            option :gc_enabled do |o|
               o.type :bool
-              o.default false
+              o.env 'DD_PROFILING_GC_ENABLED'
+              o.default true
             end
 
             # Can be used to enable/disable the Datadog::Profiling.allocation_count feature.
             #
-            # This feature is safe and enabled by default on Ruby 2.x, but has a few caveats on Ruby 3.x.
+            # @deprecated Use {:allocation_enabled} (outside of advanced section) instead.
+            option :allocation_counting_enabled do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.allocation_counting_enabled setting has been deprecated for removal and no ' \
+                    'longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'Allocation counting is now controlled by the profiling.allocation_enabled setting instead.'
+                  )
+                end
+              end
+            end
+
+            # @deprecated Use {:allocation_enabled} (outside of advanced section) instead.
+            option :experimental_allocation_enabled do |o|
+              o.type :bool
+              o.default false
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.experimental_allocation_enabled setting has been deprecated for removal and ' \
+                    'no longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'Allocation profiling is now controlled by the profiling.allocation_enabled setting instead.'
+                  )
+                end
+              end
+            end
+
+            # Can be used to enable/disable the collection of heap profiles.
+            #
+            # This feature is alpha and disabled by default
+            #
+            # @warn To enable heap profiling you are required to also enable allocation profiling.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED` environment variable as a boolean, otherwise `false`
+            option :experimental_heap_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED'
+              o.default false
+            end
+
+            # Can be used to enable/disable the collection of heap size profiles.
             #
-            # Caveat 1 (severe):
-            # On Ruby versions 3.0 (all), 3.1.0 to 3.1.3, and 3.2.0 to 3.2.2 this is disabled by default because it
-            # can trigger a VM bug that causes a segmentation fault during garbage collection of Ractors
-            # (https://bugs.ruby-lang.org/issues/18464). We don't recommend using this feature on such Rubies.
-            # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
+            # This feature is alpha and enabled by default when heap profiling is enabled.
             #
-            # Caveat 2 (annoyance):
-            # On all known versions of Ruby 3.x, due to https://bugs.ruby-lang.org/issues/19112, when a ractor gets
-            # garbage collected, Ruby will disable all active tracepoints, which this feature internally relies on.
-            # Thus this feature is only usable if you're not using Ractors.
+            # @warn To enable heap size profiling you are required to also enable allocation and heap profiling.
             #
-            # Caveat 3 (severe):
-            # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
-            # https://github.com/ruby/ruby/pull/7464) so that's an extra reason why it's not safe on those Rubies.
-            # This bug is fixed on Ruby versions 3.2.3 and 3.3.0.
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED` environment variable as a boolean, otherwise
+            # whatever the value of DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED is.
+            option :experimental_heap_size_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED'
+              o.default true # This gets ANDed with experimental_heap_enabled in the profiler component.
+            end
+
+            # Can be used to configure the allocation sampling rate: a sample will be collected every x allocations.
             #
-            # @default `true` on Ruby 2.x and 3.1.4+, 3.2.3+ and 3.3.0+; `false` for Ruby 3.0 and unpatched Rubies.
-            option :allocation_counting_enabled do |o|
-              o.default do
-                RUBY_VERSION.start_with?('2.') ||
-                  (RUBY_VERSION.start_with?('3.1.') && RUBY_VERSION >= '3.1.4') ||
-                  (RUBY_VERSION.start_with?('3.2.') && RUBY_VERSION >= '3.2.3') ||
-                  RUBY_VERSION >= '3.3.'
+            # This feature is now controlled via {:overhead_target_percentage}
+            option :experimental_allocation_sample_rate do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.experimental_allocation_sample_rate setting has been deprecated for removal ' \
+                    'and no longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'Allocation sample rate is now handled by a dynamic sampler which will adjust the sampling rate to ' \
+                    'keep to the configured `profiling.advanced.overhead_target_percentage`.'
+                  )
+                end
               end
             end
 
+            # Can be used to configure the heap sampling rate: a heap sample will be collected for every x allocation
+            # samples.
+            #
+            # The lower the value, the more accuracy in heap tracking but the bigger the overhead. In particular, a
+            # value of 1 will track ALL allocations samples for heap profiles.
+            #
+            # The effective heap sampling rate in terms of allocations (not allocation samples) can be calculated via
+            # effective_heap_sample_rate = allocation_sample_rate * heap_sample_rate.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE` environment variable, otherwise `10`.
+            option :experimental_heap_sample_rate do |o|
+              o.type :int
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE'
+              o.default 10
+            end
+
             # Can be used to disable checking which version of `libmysqlclient` is being used by the `mysql2` gem.
             #
             # This setting is only used when the `mysql2` gem is installed.
@@ -357,9 +451,27 @@ module Datadog
             #
             # @default `DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED` environment variable as a boolean, otherwise `false`
             option :experimental_timeline_enabled do |o|
+              o.after_set do |_, _, precedence|
+                unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+                  Datadog.logger.warn(
+                    'The profiling.advanced.experimental_timeline_enabled setting has been deprecated for removal ' \
+                    'and no longer does anything. Please remove it from your Datadog.configure block. ' \
+                    'The timeline feature counting is now controlled by the `timeline_enabled` setting instead.'
+                  )
+                end
+              end
+            end
+
+            # Controls data collection for the timeline feature.
+            #
+            # If you needed to disable this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>,
+            # so we can fix it!
+            #
+            # @default `DD_PROFILING_TIMELINE_ENABLED` environment variable as a boolean, otherwise `true`
+            option :timeline_enabled do |o|
               o.type :bool
-              o.env 'DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED'
-              o.default false
+              o.env 'DD_PROFILING_TIMELINE_ENABLED'
+              o.default true
             end
 
             # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
@@ -391,6 +503,34 @@ module Datadog
                 end
               end
             end
+
+            # Configures how much wall-time overhead the profiler targets. The profiler will dynamically adjust the
+            # interval between samples it takes so as to try and maintain the property that it spends no longer than
+            # this amount of wall-clock time profiling. For example, with the default value of 2%, the profiler will
+            # try and cause no more than 1.2 seconds per minute of overhead. Decreasing this value will reduce the
+            # accuracy of the data collected. Increasing will impact the application.
+            #
+            # We do not recommend tweaking this value.
+            #
+            # This value should be a percentage i.e. a number between 0 and 100, not 0 and 1.
+            #
+            # @default `DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE` as a float, otherwise 2.0
+            option :overhead_target_percentage do |o|
+              o.type :float
+              o.env 'DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE'
+              o.default 2.0
+            end
+
+            # Controls how often the profiler reports data, in seconds. Cannot be lower than 60 seconds.
+            #
+            # We do not recommend tweaking this value.
+            #
+            # @default `DD_PROFILING_UPLOAD_PERIOD` environment variable, otherwise 60
+            option :upload_period_seconds do |o|
+              o.type :int
+              o.env 'DD_PROFILING_UPLOAD_PERIOD'
+              o.default 60
+            end
           end
 
           # @public_api
@@ -558,6 +698,16 @@ module Datadog
         # Client-side telemetry configuration
         # @public_api
         settings :telemetry do
+          # Whether the bundled Ruby gems as reported through telemetry.
+          #
+          # @default `DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED` environment variable, otherwise `true`.
+          # @return [Boolean]
+          option :dependency_collection do |o|
+            o.type :bool
+            o.env Core::Telemetry::Ext::ENV_DEPENDENCY_COLLECTION
+            o.default true
+          end
+
           # Enable telemetry collection. This allows telemetry events to be emitted to the telemetry API.
           #
           # @default `DD_INSTRUMENTATION_TELEMETRY_ENABLED` environment variable, otherwise `true`.
@@ -592,6 +742,42 @@ module Datadog
             o.env Core::Telemetry::Ext::ENV_HEARTBEAT_INTERVAL
             o.default 60.0
           end
+
+          # The install id of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_ID` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_id do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_ID
+          end
+
+          # The install type of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_TYPE` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_type do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_TYPE
+          end
+
+          # The install time of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_TIME` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_time do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_TIME
+          end
         end
 
         # Remote configuration
@@ -630,6 +816,19 @@ module Datadog
             o.default 5.0
           end
 
+          # Tune remote configuration boot timeout.
+          # Early operations such as requests are blocked until RC is ready. In
+          # order to not block the application indefinitely a timeout is
+          # enforced allowing requests to proceed with the local configuration.
+          #
+          # @default `DD_REMOTE_CONFIG_BOOT_TIMEOUT` environment variable, otherwise `1.0` seconds.
+          # @return [Float]
+          option :boot_timeout_seconds do |o|
+            o.env Core::Remote::Ext::ENV_BOOT_TIMEOUT_SECONDS
+            o.type :float
+            o.default 1.0
+          end
+
           # Declare service name to bind to remote configuration. Use when
           # DD_SERVICE does not match the correct integration for which remote
           # configuration applies.

data/lib/datadog/core/configuration.rb

@@ -81,18 +81,23 @@ module Datadog
         configuration = self.configuration
         yield(configuration)
 
-        safely_synchronize do |write_components|
+        built_components = false
+
+        components = safely_synchronize do |write_components|
           write_components.call(
             if components?
               replace_components!(configuration, @components)
             else
               components = build_components(configuration)
-              components.telemetry.started!
+              built_components = true
               components
             end
           )
         end
 
+        # Should only be called the first time components are built
+        components.telemetry.started! if built_components
+
         configuration
       end
 
@@ -192,9 +197,20 @@ module Datadog
         current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
         return current_components if current_components || !allow_initialization
 
-        safely_synchronize do |write_components|
-          (defined?(@components) && @components) || write_components.call(build_components(configuration))
+        built_components = false
+
+        components = safely_synchronize do |write_components|
+          if defined?(@components) && @components
+            @components
+          else
+            built_components = true
+            write_components.call(build_components(configuration))
+          end
         end
+
+        # Should only be called the first time components are built
+        components.telemetry.started! if built_components && components && components.telemetry
+        components
       end
 
       private

data/lib/datadog/core/diagnostics/environment_logger.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'date'
 require 'json'
 require 'rbconfig'
+require 'time'
 
 module Datadog
   module Core
@@ -58,9 +58,10 @@ module Datadog
       module EnvironmentLogger
         extend EnvironmentLogging
 
-        def self.collect_and_log!
+        def self.collect_and_log!(extra_fields = nil)
           log_once! do
             data = EnvironmentCollector.collect_config!
+            data = data.merge(extra_fields) if extra_fields
             log_configuration!('CORE', data.to_json)
           end
         rescue => e
@@ -91,7 +92,7 @@ module Datadog
 
           # @return [String] current time in ISO8601 format
           def date
-            DateTime.now.iso8601
+            Time.now.utc.iso8601
           end
 
           # Best portable guess of OS information.

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

@@ -5,15 +5,15 @@ module Datadog
     module Environment
       # Retrieves number of classes from runtime
       module ClassCount
-        module_function
-
-        def value
+        def self.value
           ::ObjectSpace.count_objects[:T_CLASS]
         end
 
-        def available?
-          ::ObjectSpace.respond_to?(:count_objects) \
-           && ::ObjectSpace.count_objects.key?(:T_CLASS)
+        def self.available?
+          return @class_count_available if defined?(@class_count_available)
+
+          @class_count_available =
+            ::ObjectSpace.respond_to?(:count_objects) && ::ObjectSpace.count_objects.key?(:T_CLASS)
         end
       end
     end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../git/ext'
+require_relative '../utils/url'
+
+module Datadog
+  module Core
+    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])
+        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]
+        end
+      end
+    end
+  end
+end

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

@@ -56,58 +56,28 @@ module Datadog
 
         # Returns tracer version, comforming to https://semver.org/spec/v2.0.0.html
         def tracer_version_semver2
-          # from ddtrace/version.rb, we have MAJOR.MINOR.PATCH plus optional .PRE and .BUILD
-          # - transform .PRE to -PRE if present
-          # - transform .BUILD to +BUILD if present
-          # - keep triplet segments before that
+          major, minor, patch, rest = tracer_version.split('.', 4)
 
-          m = SEMVER2_RE.match(tracer_version)
+          semver = "#{major}.#{minor}.#{patch}"
 
-          pre = "-#{m[:pre]}" if m[:pre]
-          build = "+gha#{m[:gha_run_id]}.g#{m[:git_sha]}.#{m[:branch].tr('.', '-')}" if m[:build]
+          return semver unless rest
 
-          "#{m[:major]}.#{m[:minor]}.#{m[:patch]}#{pre}#{build}"
-        end
+          pre = ''
+          build = ''
+
+          rest.split('.').tap do |segments|
+            if segments.length >= 4
+              pre   = "-#{segments.shift}"
+              build = "+#{segments.join('.')}"
+            elsif segments.length == 1
+              pre = "-#{segments.shift}"
+            else
+              build = "+#{segments.join('.')}"
+            end
+          end
 
-        SEMVER2_RE = /
-          ^
-          # mandatory segments
-          (?<major>\d+)
-          \.
-          (?<minor>\d+)
-          \.
-          (?<patch>\d+)
-
-          # pre segments start with a value
-          # - containing at least one alpha
-          # - that is not part of our build segments expected values
-          # and stop with a value that is not part of our build segments expected values
-          (?:
-            \.
-            (?<pre>
-              (?!gha)
-              [a-zA-Z0-9]*[a-zA-Z][a-zA-Z0-9]*
-              (?:
-                \.
-                (?!gha)
-                [a-zA-Z0-9]+
-              )*
-            )
-          )?
-
-          # build segments: ours include CI info (`gha`), then git (`g`), then branch name
-          (?:
-            \.
-            (?<build>
-              gha(?<gha_run_id>\d+)
-              \.
-              g(?<git_sha>[a-f0-9]+)
-              \.
-              (?<branch>(?:[a-zA-Z0-9.])+)
-            )
-          )?
-          $
-        /xm.freeze
+          semver + pre + build
+        end
       end
     end
   end

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

@@ -9,12 +9,18 @@ module Datadog
       module Platform
         module_function
 
+        # @return [String] ISA of host; `uname -m`
+        def architecture
+          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
         end
 
-        # @return [String] name of kernel; `uname -s`
+        # 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
         end