datadog 2.28.0 → 2.41.0

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
+require_relative "ext"
 
 module Datadog
   module Core
@@ -23,7 +23,7 @@ module Datadog
         # Parses the /proc/self/cgroup file,
         # @return [Array<Entry>] one entry for each valid cgroup line
         def entries
-          filepath = '/proc/self/cgroup'
+          filepath = "/proc/self/cgroup"
           return [] unless File.exist?(filepath)
 
           ret = []
@@ -46,7 +46,7 @@ module Datadog
         # @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)
+          hierarchy, controllers, path = entry_line.split(":", 3)
 
           Entry.new(
             hierarchy,
@@ -68,7 +68,7 @@ module Datadog
           # 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)
+          inode_path = File.join("/sys/fs/cgroup", controllers, path)
 
           File.stat(inode_path).ino if File.exist?(inode_path)
         end

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

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require_relative 'cgroup'
-require_relative 'ext'
+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
@@ -101,14 +101,14 @@ module Datadog
           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
+            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}"
+              "Error while checking cgroup namespace. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
             )
             false
           end
@@ -128,15 +128,15 @@ module Datadog
           #
           # 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 = 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('/')
+            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?
@@ -172,7 +172,7 @@ module Datadog
           @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}"
+            "Error while reading container entry. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
           @entry = Entry.new unless defined?(@entry)
           @entry

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
@@ -15,35 +15,41 @@ module Datadog
           RUBY_VERSION
         end
 
-        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'
-        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, '.*')
+            File.basename($PROGRAM_NAME, ".*")
           rescue
-            'ruby'
+            "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
+        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_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'
-        TAG_VERSION = 'version'
+        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/gc.rb

@@ -12,7 +12,7 @@ module Datadog
         end
 
         def available?
-          defined?(::GC) && ::GC.respond_to?(:stat)
+          !!(defined?(::GC) && ::GC.respond_to?(:stat))
         end
       end
     end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../git/ext'
-require_relative '../utils/url'
+require_relative "../git/ext"
+require_relative "../utils/url"
 
 module Datadog
   module Core

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,18 +76,32 @@ 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(".")}"

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative '../tag_normalizer'
+require_relative "ext"
+require_relative "../tag_normalizer"
 
 module Datadog
   module Core
@@ -10,18 +10,17 @@ module Datadog
       #
       # @api private
       module Process
-        # This method returns a key/value part of serialized tags in the format of k1:v1,k2:v2,k3:v3
-        # @return [String] comma-separated normalized key:value pairs
+        # 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
-          return @serialized if defined?(@serialized)
-
-          @serialized = tags.join(',').freeze
+          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
+        # 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
-          return @tags if defined?(@tags)
           tags = []
 
           workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
@@ -35,14 +34,46 @@ module Datadog
 
           tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
 
-          @tags = tags.freeze
+          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
-          File.basename(Dir.pwd)
+          return @entrypoint_workdir if defined?(@entrypoint_workdir)
+
+          @entrypoint_workdir = File.basename(Dir.pwd)
         end
 
         # Returns the entrypoint type of the process
@@ -52,10 +83,10 @@ module Datadog
           Environment::Ext::PROCESS_TYPE
         end
 
-        # Returns the last segment of the base directory of the process
+        # Returns the basename of the script being run
         # Example 1: /bin/mybin -> mybin
-        # Example 2: ruby /test/myapp.rb -> myapp
-        # @return [String] the last segment of base directory of the script
+        # 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.
@@ -63,12 +94,14 @@ module Datadog
         # as their entrypoint name.
         # We might improve the behavior in the future if there is customer demand for it.
         def self.entrypoint_name
-          File.basename($0)
+          return @entrypoint_name if defined?(@entrypoint_name)
+
+          @entrypoint_name = File.basename($0)
         end
 
-        # Returns the last segment of the base directory of the process
+        # Returns the last segment of the directory containing the script
         # Example 1: /bin/mybin -> bin
-        # Example 2: ruby /test/myapp.js -> test
+        # 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.
@@ -77,7 +110,9 @@ module Datadog
         # 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
-          File.basename(File.expand_path(File.dirname($0)))
+          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

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

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

@@ -23,7 +23,7 @@ module Datadog
           if var && DATADOG_ENV.key?(var)
             value = DATADOG_ENV[var].to_s.strip
             value.downcase!
-            value == 'true' || value == '1'
+            value == "true" || value == "1"
           else
             default
           end

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

@@ -56,7 +56,7 @@ module Datadog
         end
 
         def available?
-          defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
+          !!(defined?(::RubyVM) && ::RubyVM.respond_to?(:stat))
         end
       end
     end

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

@@ -59,9 +59,9 @@ module Datadog
         end
 
         def available?
-          defined?(::RubyVM::YJIT) \
+          !!(defined?(::RubyVM::YJIT) \
             && ::RubyVM::YJIT.enabled? \
-            && ::RubyVM::YJIT.respond_to?(:runtime_stats)
+            && ::RubyVM::YJIT.respond_to?(:runtime_stats))
         end
       end
     end