datadog 2.7.1 → 2.18.0

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,11 @@ module Datadog
         extend Options
         extend Helpers
 
-        attr_reader :statsd
+        attr_reader :statsd, :logger, :telemetry
 
-        def initialize(statsd: nil, enabled: true, **_)
+        def initialize(telemetry:, logger: Datadog.logger, statsd: nil, enabled: true, **_)
+          @telemetry = telemetry
+          @logger = logger
           @statsd =
             if supported?
               statsd || default_statsd_client
@@ -73,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
@@ -97,11 +99,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.count(stat, value, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
+        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)
@@ -111,11 +113,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.distribution(stat, value, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
+        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)
@@ -124,11 +126,11 @@ module Datadog
           options = yield if block_given?
 
           statsd.increment(stat, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
+        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)
@@ -138,11 +140,11 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.gauge(stat, value, metric_options(options))
-        rescue StandardError => e
-          Datadog.logger.error(
+        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)
@@ -157,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.
-            Datadog.logger.error(
+            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
 
@@ -171,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
@@ -183,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
@@ -194,7 +194,7 @@ module Datadog
 
         def ignored_statsd_warning
           IGNORED_STATSD_ONLY_ONCE.run do
-            Datadog.logger.warn(
+            logger.warn(
               'Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. ' \
               "To fix this, ensure that you have `gem 'dogstatsd-ruby', '~> 5.3'` on your Gemfile or gems.rb file."
             )

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/tracer_memfd.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    class ProcessDiscovery
+      class TracerMemfd
+        attr_accessor :logger
+
+        def shutdown!
+          ProcessDiscovery._native_close_tracer_memfd(self, logger)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/process_discovery.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'datadog/core/process_discovery/tracer_memfd'
+
+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)
+        memfd = _native_store_tracer_metadata(logger, **metadata)
+        memfd.logger = logger if memfd
+        memfd
+      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/capabilities.rb

@@ -32,6 +32,12 @@ module Datadog
               register_receivers(Datadog::AppSec::Remote.receivers(@telemetry))
             end
 
+            if settings.respond_to?(:dynamic_instrumentation) && settings.dynamic_instrumentation.enabled
+              register_capabilities(Datadog::DI::Remote.capabilities)
+              register_products(Datadog::DI::Remote.products)
+              register_receivers(Datadog::DI::Remote.receivers(@telemetry))
+            end
+
             register_capabilities(Datadog::Tracing::Remote.capabilities)
             register_products(Datadog::Tracing::Remote.products)
             register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))