datadog 2.15.0 → 2.17.0

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

@@ -18,14 +18,6 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `crashtracker.c`
       class Component
-        LIBDATADOG_API_FAILURE =
-          begin
-            require "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}"
-            nil
-          rescue LoadError => e
-            e.message
-          end
-
         ONLY_ONCE = Core::Utils::OnlyOnce.new
 
         def self.build(settings, agent_settings, logger:)
@@ -71,7 +63,7 @@ module Datadog
               # Must NOT reference `self` here, as only the first instance will
               # be captured by the ONLY_ONCE and we want to pick the latest active one
               # (which may have different tags or agent config)
-              Datadog.send(:components).crashtracker&.update_on_fork
+              Datadog.send(:components, allow_initialization: false)&.crashtracker&.update_on_fork
             end
           end
         end
@@ -100,7 +92,8 @@ module Datadog
             path_to_crashtracking_receiver_binary: path_to_crashtracking_receiver_binary,
             ld_library_path: ld_library_path,
             tags_as_array: tags.to_a,
-            upload_timeout_seconds: 1
+            # @ivoanjo: On my machine this needs to be > 5 seconds, and seems to work with 10; the extra 15 is extra margin
+            upload_timeout_seconds: 15,
           )
           logger.debug("Crash tracking action: #{action} successful")
         rescue => e

data/lib/datadog/core/encoding.rb

@@ -54,7 +54,7 @@ module Datadog
         end
 
         def join(encoded_data)
-          "[#{encoded_data.join(',')}]"
+          "[#{encoded_data.join(",")}]"
         end
       end
 

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

@@ -23,20 +23,18 @@ module Datadog
 
         def descriptors(process = 'self')
           [].tap do |descriptors|
-            begin
-              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
+            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
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Error while parsing cgroup. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-              )
             end
+          rescue => e
+            Datadog.logger.error(
+              "Error while parsing cgroup. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            )
           end
         end
 

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

@@ -37,52 +37,50 @@ module Datadog
 
         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]
+            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
-                  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
+                  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?
+              # 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
+              descriptor.platform = platform
+              descriptor.container_id = container_id
+              descriptor.task_uid = task_uid
 
-                break
-              end
-            rescue StandardError => e
-              Datadog.logger.error(
-                "Error while parsing container info. Cause: #{e.class.name} #{e.message} " \
-                "Location: #{Array(e.backtrace).first}"
-              )
+              break
             end
+          rescue => e
+            Datadog.logger.error(
+              "Error while parsing container info. Cause: #{e.class.name} #{e.message} " \
+              "Location: #{Array(e.backtrace).first}"
+            )
           end
         end
       end

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

@@ -9,11 +9,11 @@ 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'
@@ -26,7 +26,7 @@ module Datadog
         FALLBACK_SERVICE_NAME =
           begin
             File.basename($PROGRAM_NAME, '.*')
-          rescue StandardError
+          rescue
             'ruby'
           end.freeze
 

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

@@ -5,6 +5,7 @@ require_relative '../utils/url'
 
 module Datadog
   module Core
+    # Environment
     module Environment
       # Retrieves git repository information from environment variables
       module Git

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

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

@@ -13,18 +13,18 @@ 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`

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

@@ -23,7 +23,7 @@ module Datadog
           if var && ENV.key?(var)
             value = ENV[var].to_s.strip
             value.downcase!
-            value == 'true' || value == '1' # rubocop:disable Style/MultipleComparison
+            value == 'true' || value == '1'
           else
             default
           end

data/lib/datadog/core/error.rb

@@ -11,12 +11,17 @@ module Datadog
       class << self
         def build_from(value)
           case value
-          when Error then value
-          when Array then new(*value)
+          # A Ruby {Exception} is the most common parameter type.
           when Exception then new(value.class, value.message, full_backtrace(value))
-          when ContainsMessage then new(value.class, value.message)
+          # steep:ignore:start
+          # Steep doesn't like an array with up to 3 elements to be passed here: it thinks the array is unbounded.
+          when Array then new(*value)
+          # Steep can not follow the logic inside the lambda, thus it doesn't know `value` responds to `:message`.
+          when ->(v) { v.respond_to?(:message) } then new(value.class, value.message)
+          # steep:ignore:end
           when String then new(nil, value)
-          else BlankError
+          when Error then value
+          else Error.new # Blank error
           end
         end
 
@@ -34,7 +39,7 @@ module Datadog
         # but it's around 3x faster in our benchmark test
         # at `error_spec.rb`.
         def full_backtrace(ex)
-          backtrace = String.new
+          backtrace = +''
           backtrace_for(ex, backtrace)
 
           # Avoid circular causes
@@ -75,7 +80,7 @@ module Datadog
           if trace[1]
             # Ident stack trace for caller lines, to separate
             # them from the main error lines.
-            trace[1..-1].each do |line|
+            trace[1..-1]&.each do |line|
               backtrace << "\n\tfrom "
               backtrace << line
             end
@@ -92,9 +97,6 @@ module Datadog
         @message = Utils.utf8_encode(message)
         @backtrace = Utils.utf8_encode(backtrace)
       end
-
-      BlankError = Error.new
-      ContainsMessage = ->(v) { v.respond_to?(:message) }
     end
   end
 end

data/lib/datadog/core/logger.rb

@@ -28,7 +28,7 @@ module Datadog
 
         if message.nil?
           if block
-            super(severity, message, progname) do
+            super do
               "[#{self.progname}] #{where}#{yield}"
             end
           else
@@ -39,7 +39,7 @@ module Datadog
         end
       end
 
-      alias log add
+      alias_method :log, :add
     end
   end
 end

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

@@ -21,9 +21,10 @@ module Datadog
         extend Options
         extend Helpers
 
-        attr_reader :statsd, :logger
+        attr_reader :statsd, :logger, :telemetry
 
-        def initialize(logger: Datadog.logger, statsd: nil, enabled: true, **_)
+        def initialize(telemetry:, logger: Datadog.logger, statsd: nil, enabled: true, **_)
+          @telemetry = telemetry
           @logger = logger
           @statsd =
             if supported?
@@ -74,10 +75,10 @@ module Datadog
           #
           # Versions < 5.0 are always single-threaded, but do not have the kwarg option.
           options = if dogstatsd_version >= Gem::Version.new('5.2')
-                      { single_thread: true }
-                    else
-                      {}
-                    end
+            {single_thread: true}
+          else
+            {}
+          end
 
           Datadog::Statsd.new(default_hostname, default_port, **options)
         end
@@ -98,11 +99,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.count(stat, value, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send count stat')
+          telemetry.report(e, description: 'Failed to send count stat')
         end
 
         def distribution(stat, value = nil, options = nil, &block)
@@ -112,11 +113,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.distribution(stat, value, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send distribution stat')
+          telemetry.report(e, description: 'Failed to send distribution stat')
         end
 
         def increment(stat, options = nil)
@@ -125,11 +126,11 @@ module Datadog
           options = yield if block_given?
 
           statsd.increment(stat, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send increment stat')
+          telemetry.report(e, description: 'Failed to send increment stat')
         end
 
         def gauge(stat, value = nil, options = nil, &block)
@@ -139,11 +140,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.gauge(stat, value, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
-          Telemetry::Logger.report(e, description: 'Failed to send gauge stat')
+          telemetry.report(e, description: 'Failed to send gauge stat')
         end
 
         def time(stat, options = nil)
@@ -158,12 +159,12 @@ module Datadog
               finished = Utils::Time.get_time
               distribution(stat, ((finished - start) * 1000), options)
             end
-          rescue StandardError => e
+          rescue => e
             # TODO: Likely to be redundant, since `distribution` handles its own errors.
             logger.error(
               "Failed to send time stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
             )
-            Telemetry::Logger.report(e, description: 'Failed to send time stat')
+            telemetry.report(e, description: 'Failed to send time stat')
           end
         end
 
@@ -172,7 +173,7 @@ module Datadog
         end
 
         def close
-          @statsd.close if @statsd && @statsd.respond_to?(:close)
+          @statsd.close if @statsd&.respond_to?(:close)
         end
 
         private
@@ -184,10 +185,8 @@ module Datadog
             defined?(Datadog::Statsd::VERSION) &&
               Datadog::Statsd::VERSION &&
               Gem::Version.new(Datadog::Statsd::VERSION)
-          ) || (
-            Gem.loaded_specs['dogstatsd-ruby'] &&
-              Gem.loaded_specs['dogstatsd-ruby'].version
-          )
+          ) ||
+            Gem.loaded_specs['dogstatsd-ruby']&.version
         end
 
         IGNORED_STATSD_ONLY_ONCE = Utils::OnlyOnce.new

data/lib/datadog/core/metrics/logging.rb

@@ -17,25 +17,25 @@ module Datadog
               l.progname = nil
               l.formatter = proc do |_severity, datetime, _progname, msg|
                 stat = JSON.parse(msg[3..-1]) # Trim off leading progname...
-                "#{JSON.dump(timestamp: datetime.to_i, message: 'Metric sent.', metric: stat)}\n"
+                "#{JSON.dump(timestamp: datetime.to_i, message: "Metric sent.", metric: stat)}\n"
               end
             end
           end
 
           def count(stat, value, options = nil)
-            logger.info({ stat: stat, type: :count, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :count, value: value, options: options}.to_json)
           end
 
           def distribution(stat, value, options = nil)
-            logger.info({ stat: stat, type: :distribution, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :distribution, value: value, options: options}.to_json)
           end
 
           def increment(stat, options = nil)
-            logger.info({ stat: stat, type: :increment, options: options }.to_json)
+            logger.info({stat: stat, type: :increment, options: options}.to_json)
           end
 
           def gauge(stat, value, options = nil)
-            logger.info({ stat: stat, type: :gauge, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :gauge, value: value, options: options}.to_json)
           end
         end
       end

data/lib/datadog/core/process_discovery.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # Class used to store tracer metadata in a native file descriptor.
+    class ProcessDiscovery
+      def self.get_and_store_metadata(settings, logger)
+        if (libdatadog_api_failure = Datadog::Core::LIBDATADOG_API_FAILURE)
+          logger.debug("Cannot enable process discovery: #{libdatadog_api_failure}")
+          return
+        end
+        metadata = get_metadata(settings)
+        _native_store_tracer_metadata(logger, **metadata)
+      end
+
+      # According to the RFC, runtime_id, service_name, service_env, service_version are optional.
+      # In the C method exposed by ddcommon, memfd_create replaces empty strings by None for these fields.
+      private_class_method def self.get_metadata(settings)
+        {
+          schema_version: 1,
+          runtime_id: Core::Environment::Identity.id,
+          tracer_language: Core::Environment::Identity.lang,
+          tracer_version: Core::Environment::Identity.gem_datadog_version_semver2,
+          hostname: Core::Environment::Socket.hostname,
+          service_name: settings.service || '',
+          service_env: settings.env || '',
+          service_version: settings.version || ''
+        }
+      end
+    end
+  end
+end

data/lib/datadog/core/rate_limiter.rb

@@ -13,13 +13,15 @@ module Datadog
       # to be side-effect free.
       #
       # @return [Boolean] whether a resource conforms with the current limit
-      def allow?(size = 1); end
+      def allow?(size = 1)
+      end
 
       # The effective rate limiting ratio based on
       # recent calls to `allow?`.
       #
       # @return [Float] recent allowance ratio
-      def effective_rate; end
+      def effective_rate
+      end
     end
 
     # Implementation of the Token Bucket metering algorithm

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

@@ -11,6 +11,7 @@ module Datadog
       # Client communicates with the agent and sync remote configuration
       class Client
         class TransportError < StandardError; end
+
         class SyncError < StandardError; end
 
         attr_reader :transport, :repository, :id, :dispatcher, :logger
@@ -119,7 +120,7 @@ module Datadog
           end
         end
 
-        def payload # rubocop:disable Metrics/MethodLength
+        def payload # standard:disable Metrics/MethodLength
           state = repository.state
 
           client_tracer_tags = [
@@ -134,12 +135,19 @@ module Datadog
             "ruby.runtime.engine.name:#{RUBY_ENGINE}",
             "ruby.runtime.engine.version:#{ruby_engine_version}",
             "ruby.rubygems.platform.local:#{Gem::Platform.local}",
-            "ruby.gem.libddwaf.version:#{gem_spec('libddwaf').version}",
-            "ruby.gem.libddwaf.platform:#{gem_spec('libddwaf').platform}",
-            "ruby.gem.libdatadog.version:#{gem_spec('libdatadog').version}",
-            "ruby.gem.libdatadog.platform:#{gem_spec('libdatadog').platform}",
+            "ruby.gem.libddwaf.version:#{gem_spec("libddwaf").version}",
+            "ruby.gem.libddwaf.platform:#{gem_spec("libddwaf").platform}",
+            "ruby.gem.libdatadog.version:#{gem_spec("libdatadog").version}",
+            "ruby.gem.libdatadog.platform:#{gem_spec("libdatadog").platform}",
           ]
 
+          if (git_repository_url = Core::Environment::Git.git_repository_url)
+            client_tracer_tags << "git.repository_url:#{git_repository_url}"
+          end
+          if (git_commit_sha = Core::Environment::Git.git_commit_sha)
+            client_tracer_tags << "git.commit.sha:#{git_commit_sha}"
+          end
+
           client_tracer = {
             runtime_id: Core::Environment::Identity.id,
             language: Core::Environment::Identity.lang,
@@ -195,37 +203,37 @@ module Datadog
           return @native_platform unless @native_platform.nil?
 
           os = if RUBY_ENGINE == 'jruby'
-                 os_name = java.lang.System.get_property('os.name')
+            os_name = java.lang.System.get_property('os.name')
 
-                 case os_name
-                 when /linux/i then 'linux'
-                 when /mac/i   then 'darwin'
-                 else os_name
-                 end
-               else
-                 Gem::Platform.local.os
-               end
+            case os_name
+            when /linux/i then 'linux'
+            when /mac/i then 'darwin'
+            else os_name
+            end
+          else
+            Gem::Platform.local.os
+          end
 
           version = if os != 'linux'
-                      nil
-                    elsif RUBY_PLATFORM =~ /linux-(.+)$/
-                      # Old rubygems don't handle non-gnu linux correctly
-                      Regexp.last_match(1)
-                    else
-                      'gnu'
-                    end
+            nil
+          elsif RUBY_PLATFORM =~ /linux-(.+)$/
+            # Old rubygems don't handle non-gnu linux correctly
+            Regexp.last_match(1)
+          else
+            'gnu'
+          end
 
           cpu = if RUBY_ENGINE == 'jruby'
-                  os_arch = java.lang.System.get_property('os.arch')
-
-                  case os_arch
-                  when 'amd64' then 'x86_64'
-                  when 'aarch64' then os == 'darwin' ? 'arm64' : 'aarch64'
-                  else os_arch
-                  end
-                else
-                  Gem::Platform.local.cpu
-                end
+            os_arch = java.lang.System.get_property('os.arch')
+
+            case os_arch
+            when 'amd64' then 'x86_64'
+            when 'aarch64' then (os == 'darwin') ? 'arm64' : 'aarch64'
+            else os_arch
+            end
+          else
+            Gem::Platform.local.cpu
+          end
 
           @native_platform = [cpu, os, version].compact.join('-')
         end

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

@@ -42,7 +42,7 @@ module Datadog
               logger.error do
                 "remote worker client sync error: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
               end
-            rescue StandardError => e
+            rescue => e
               # In case of unexpected errors, reset the negotiation object
               # given external conditions have changed and the negotiation
               # negotiation object stores error logging state that should be reset.
@@ -50,8 +50,8 @@ module Datadog
 
               # Transient errors due to network or agent. Logged the error but not via telemetry
               logger.error do
-                "remote worker error: #{e.class.name} #{e.message} location: #{Array(e.backtrace).first}. "\
-                'reseting client state'
+                "remote worker error: #{e.class.name} #{e.message} location: #{Array(e.backtrace).first}. " \
+                'resetting client state'
               end
 
               # client state is unknown, state might be corrupted