datadog 2.17.0 → 2.37.0

data/lib/datadog/core/crashtracking/tag_builder.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../tag_builder'
 require_relative '../utils'
-require_relative '../environment/socket'
-require_relative '../environment/identity'
-require_relative '../environment/git'
+require_relative '../environment/process'
 
 module Datadog
   module Core
@@ -11,27 +10,16 @@ module Datadog
       # This module builds a hash of tags
       module TagBuilder
         def self.call(settings)
-          hash = {
-            'host' => Environment::Socket.hostname,
-            'process_id' => Process.pid.to_s,
-            'runtime_engine' => Environment::Identity.lang_engine,
-            'runtime-id' => Environment::Identity.id,
-            'runtime_platform' => Environment::Identity.lang_platform,
-            'runtime_version' => Environment::Identity.lang_version,
-            'env' => settings.env,
-            'service' => settings.service,
-            'version' => settings.version,
-            'git.repository_url' => Environment::Git.git_repository_url,
-            'git.commit.sha' => Environment::Git.git_commit_sha,
+          hash = Core::TagBuilder.tags(settings).merge(
             'is_crash' => 'true',
-            'language' => 'ruby',
-            'library_version' => Core::Environment::Identity.gem_datadog_version,
-          }.compact
+          )
 
-          # Make sure everything is an utf-8 string, to avoid encoding issues in downstream
-          settings.tags.merge(hash).each_with_object({}) do |(key, value), h|
-            h[Utils.utf8_encode(key)] = Utils.utf8_encode(value)
+          if settings.experimental_propagate_process_tags_enabled
+            process_tags = Environment::Process.serialized
+            hash['process_tags'] = process_tags unless process_tags.empty?
           end
+
+          Utils.encode_tags(hash)
         end
       end
     end

data/lib/datadog/core/ddsketch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # Used to access ddsketch APIs.
+    # APIs in this class are implemented as native code.
+    class DDSketch
+      def self.supported?
+        Datadog::Core::LIBDATADOG_API_FAILURE.nil?
+      end
+
+      def initialize
+        unless self.class.supported?
+          raise(ArgumentError, "DDSketch is not supported: #{Datadog::Core::LIBDATADOG_API_FAILURE}")
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/deprecations.rb

@@ -14,10 +14,10 @@ module Datadog
       # @yieldreturn [String] a String with the lazily evaluated deprecation message.
       # @param [Boolean] disallowed_next_major whether this deprecation will be enforced in the next major release.
       # @param [Object] key A unique key for the deprecation. Only the first message with the same key will be logged.
-      def log_deprecation(disallowed_next_major: true, key: nil)
+      def log_deprecation(disallowed_next_major: true, key: nil, logger: Datadog.logger)
         return unless log_deprecation?(key)
 
-        Datadog.logger.warn do
+        logger.warn do
           message = yield
           message += ' This will be enforced in the next major release.' if disallowed_next_major
           message

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

@@ -52,7 +52,9 @@ module Datadog
             log_configuration!('CORE', data.to_json)
           end
         rescue => e
-          logger.warn("Failed to collect core environment information: #{e} Location: #{Array(e.backtrace).first}")
+          logger.warn(
+            "Failed to collect core environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
         end
       end
 

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../utils/fnv'
+require_relative 'process'
+
 module Datadog
   module Core
     module Environment
@@ -59,19 +62,80 @@ module Datadog
           @client = Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
         end
 
-        # Fetches the information from the agent.
+        # Fetches the information from the Trace Agent.
         # @return [Datadog::Core::Remote::Transport::HTTP::Negotiation::Response] the response from the agent
         # @return [nil] if an error occurred while fetching the information
         def fetch
           res = @client.send_info
           return unless res.ok?
 
+          update_propagation_checksum(res)
+
           res
         end
 
         def ==(other)
           other.is_a?(self.class) && other.agent_settings == agent_settings
         end
+
+        # Returns the propagation checksum, comprising of process tags and optionally container tags (from the Trace Agent)
+        # Currently called/used by the DBM code to inject the propagation checksum into the SQL comment.
+        #
+        # This checksum is used for correlation across signals (traces, DBM, data streams, etc.) in environments
+        #
+        # The checksum is populated by the trace transport's periodic fetch calls.
+        # @return [Integer, nil] the FNV hash based on the container and process tags or nil
+        attr_reader :propagation_checksum
+
+        private
+
+        # Trace Agent 7.69.0+ provides a SHA256 checksum in the response header DATADOG-CONTAINER-TAGS-HASH based on the container id computed in Datadog::Core::Environment::Container
+        # This is a short checksum that uniquely identifies this process, its container environment, and
+        # the Datadog agent it connects to.
+        #
+        # This checksum only has to be internally consistent: the same value must be used by every signal
+        # emitted by this process+container+agent combinations). It is not required that this checksum is
+        # consistent with other SDKs.
+        # During calls to the Trace Agent, this checksum is cached but invalidated if a new value is returned
+        # The resulting propagation_checksum uses the container_tags_checksum
+        # https://github.com/DataDog/datadog-agent/pull/38515
+        attr_reader :container_tags_checksum
+
+        # Setting DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED to true enables the following behavior:
+        #  - Computes a propagation checksum from process tags and optionally container tags when tags change
+        #  - This is needed in traces (dsm and dbm related spans), DBM, and DSM.
+        #
+        # Container tags extraction:
+        # Datadog::Core::Environment::Container extracts the container id from the cgroup folder if possible
+        # (note: not currently available in cgroupv2) and sends it to the Trace Agent via the header Datadog-Container-ID.
+        # The Trace Agent takes the container id and looks for matching container tags to compute a SHA256 checksum via the response header DATADOG-CONTAINER-TAGS-HASH
+        # https://github.com/DataDog/datadog-agent/blob/c923da011c8e51c35c0d05b6b10d016521915e7d/pkg/trace/api/info.go#L203-L227
+        #
+        # When deciding whether the propagation checksum should be updated, we need to be aware of some concerns:
+        #     - The tracer fails to send the container id in the first place
+        #     - It is possible that older Trace Agents may not have this specific header
+        #     - It is possible that we don't have access to the value if the Trace Agent is temporarily down. In these cases, we need to check for the value again on the next call to the info endpoint
+        #     - If we have access to the value, we need to check if it changed from the previous value.
+        #     - The Trace Agent runs into a permissions/setup issue.
+        def update_propagation_checksum(res)
+          return unless Datadog.configuration.experimental_propagate_process_tags_enabled
+
+          header_value = res.headers[Core::Transport::Ext::HTTP::HEADER_CONTAINER_TAGS_HASH]
+          new_container_tags_checksum = header_value if header_value && !header_value.empty?
+
+          # if the Trace Agent returns a new value for the checksum, calculate and cache the propagation checksum
+          # If there was no previous propagation_checksum, then we should calculate the checksum by checking the agent and getting process info
+          if @propagation_checksum.nil? || (new_container_tags_checksum && new_container_tags_checksum != @container_tags_checksum)
+            @container_tags_checksum = new_container_tags_checksum
+
+            checksum_input = Process.serialized
+            # Use local variable for Steep type narrowing (helps Steep with type narrowing)
+            container_checksum = @container_tags_checksum
+            checksum_input += container_checksum if container_checksum
+
+            @propagation_checksum = Core::Utils::FNV.fnv1_64(checksum_input)
+          end
+        end
       end
     end
   end

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}: #{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}: #{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,11 +17,11 @@ module Datadog
 
         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_OTEL_SERVICE = 'OTEL_SERVICE_NAME'
         ENV_SITE = 'DD_SITE'
         ENV_TAGS = 'DD_TAGS'
-        ENV_OTEL_RESOURCE_ATTRIBUTES = 'OTEL_RESOURCE_ATTRIBUTES'
         ENV_VERSION = 'DD_VERSION'
         FALLBACK_SERVICE_NAME =
           begin
@@ -35,9 +35,20 @@ module Datadog
         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_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

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

@@ -12,13 +12,13 @@ module Datadog
         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

@@ -2,6 +2,7 @@
 
 require 'securerandom'
 
+require_relative '../configuration/config_helper'
 require_relative 'ext'
 require_relative '../utils/forking'
 
@@ -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,7 +76,21 @@ 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)