datadog 2.8.0 → 2.39.0

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

@@ -20,10 +20,10 @@ module Datadog
         # @return [default] if the environment value is not found
         def env_to_bool(var, default = nil, deprecation_warning: true)
           var = decode_array(var, deprecation_warning)
-          if var && ENV.key?(var)
-            value = ENV[var].to_s.strip
+          if var && DATADOG_ENV.key?(var)
+            value = DATADOG_ENV[var].to_s.strip
             value.downcase!
-            value == 'true' || value == '1' # rubocop:disable Style/MultipleComparison
+            value == "true" || value == "1"
           else
             default
           end
@@ -34,7 +34,7 @@ module Datadog
         def decode_array(var, deprecation_warning)
           if var.is_a?(Array)
             var.find.with_index do |env_var, i|
-              found = ENV.key?(env_var)
+              found = DATADOG_ENV.key?(env_var)
 
               # Check if we are using a non-preferred environment variable
               if deprecation_warning && found && i != 0

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

@@ -54,7 +54,8 @@ module Datadog
 
         # Ratio of YJIT-executed instructions
         def ratio_in_yjit
-          ::RubyVM::YJIT.runtime_stats[:ratio_in_yjit]
+          stats = ::RubyVM::YJIT.runtime_stats
+          stats[:ratio_in_yjit] if stats.key?(:ratio_in_yjit)
         end
 
         def available?

data/lib/datadog/core/error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'utils'
+require_relative "utils"
 
 module Datadog
   module Core
@@ -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: 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:ignore UnexpectedPositionalArgument
+          when ->(v) { v.respond_to?(:message) }
+            # Steep: Steep can not follow the logic inside the lambda, thus it doesn't know `value` responds to `:message`.
+            # @type var value: _ContainsMessage
+            new(value.class, value.message)
           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
@@ -65,17 +70,17 @@ module Datadog
           if trace[0]
             # Add Exception information to error line
             backtrace << trace[0]
-            backtrace << ': '
+            backtrace << ": "
             backtrace << ex.message.to_s
-            backtrace << ' ('
+            backtrace << " ("
             backtrace << ex.class.to_s
-            backtrace << ')'
+            backtrace << ")"
           end
 
           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/evp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module EVP
+      SUBDOMAIN_HEADER_NAME = "X-Datadog-EVP-Subdomain"
+      EVENT_PLATFORM_INTAKE_SUBDOMAIN = "event-platform-intake"
+      PAYLOAD_SIZE_LIMIT_BYTES = 5 * 1024 * 1024
+    end
+  end
+end

data/lib/datadog/core/extensions.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'configuration'
+require_relative "configuration"
 
 # Global namespace that includes all Datadog functionality.
 # @public_api

data/lib/datadog/core/feature_flags.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Datadog
+  module Core
+    # Feature flags evaluation using libdatadog
+    # The classes in this module are defined as C extensions in ext/libdatadog_api/feature_flags.c
+    #
+    # @api private
+    module FeatureFlags
+      # A top-level error raised by the extension
+      class Error < StandardError # rubocop:disable Lint/EmptyClass
+      end
+
+      # Configuration for feature flags evaluation
+      # This class is defined in the C extension
+      class Configuration # rubocop:disable Lint/EmptyClass
+      end
+
+      # Resolution details for a feature flag evaluation
+      # Base class is defined in the C extension, with Ruby methods added here
+      class ResolutionDetails
+        attr_writer :value
+
+        # Get the resolved value, with JSON parsing for object types
+        #
+        # @return [Object] The resolved value (parsed from JSON if object type)
+        # @raise [Datadog::Core::FeatureFlags::Error] If JSON parsing fails
+        def value
+          return @value if defined?(@value)
+
+          # NOTE: Raw value method call doesn't support memoization right now
+          value = raw_value
+
+          # NOTE: Lazy parsing of the JSON is a temporary solution and will be
+          #       moved into C extension
+          @value = json?(value) ? JSON.parse(value) : value
+        rescue JSON::ParserError => e
+          raise Error, "Failed to parse JSON value: #{e.class}: #{e.message}"
+        end
+
+        # Check if the resolution resulted in an error
+        #
+        # @return [Boolean] True if there was an error
+        def error?
+          reason == "ERROR"
+        end
+
+        private
+
+        # NOTE: A JSON raw string will be returned by the `libdatadog` as
+        #       a Ruby String class with a flag type `:object`, otherwise it's
+        #       just a string.
+        def json?(value)
+          flag_type == :object && value.is_a?(String)
+        end
+      end
+    end
+  end
+end

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

@@ -5,11 +5,11 @@ module Datadog
     module Git
       # Defines constants for Git tags
       module Ext
-        TAG_REPOSITORY_URL = '_dd.git.repository_url'
-        TAG_COMMIT_SHA = '_dd.git.commit.sha'
+        TAG_REPOSITORY_URL = "_dd.git.repository_url"
+        TAG_COMMIT_SHA = "_dd.git.commit.sha"
 
-        ENV_REPOSITORY_URL = 'DD_GIT_REPOSITORY_URL'
-        ENV_COMMIT_SHA = 'DD_GIT_COMMIT_SHA'
+        ENV_REPOSITORY_URL = "DD_GIT_REPOSITORY_URL"
+        ENV_COMMIT_SHA = "DD_GIT_COMMIT_SHA"
       end
     end
   end

data/lib/datadog/core/knuth_sampler.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # Deterministic sampler using Knuth multiplicative hash algorithm.
+    #
+    # This sampler provides consistent sampling decisions based on an input value,
+    # ensuring the same input always produces the same sampling decision for a given rate.
+    #
+    # The algorithm multiplies the input by a large prime (Knuth factor), takes modulo
+    # to constrain to a fixed range, and compares against a threshold derived from the sample rate.
+    #
+    # @api private
+    # @see https://en.wikipedia.org/wiki/Hash_function#Multiplicative_hashing
+    class KnuthSampler
+      # Maximum unsigned 64-bit integer for uniform distribution across 64-bit input space.
+      UINT64_MAX = (1 << 64) - 1
+      UINT64_MODULO = 1 << 64
+
+      # Golden ratio constant for optimal distribution.
+      # @see https://en.wikipedia.org/wiki/Hash_function#Fibonacci_hashing
+      DEFAULT_KNUTH_FACTOR = 11400714819323198485
+
+      attr_reader :rate
+
+      # @param rate [Float] Sampling rate between +0.0+ and +1.0+ (inclusive).
+      #   +0.0+ means no samples are kept; +1.0+ means all samples are kept.
+      #   Invalid values fall back to +1.0+ (sample everything).
+      # @param knuth_factor [Integer] Multiplicative constant for hashing.
+      #   Different factors produce different sampling distributions.
+      def initialize(rate = 1.0, knuth_factor: DEFAULT_KNUTH_FACTOR)
+        @knuth_factor = knuth_factor
+
+        rate = rate.to_f
+        # Not using `between?` here: it raises on NaN instead of falling back to 1.0 below.
+        # No current caller passes NaN, but this guards against it defensively for future ones.
+        unless rate >= 0.0 && rate <= 1.0 # rubocop:disable Style/ComparableBetween
+          Datadog.logger.warn("Sample rate #{rate} is not between 0.0 and 1.0, falling back to 1.0")
+          rate = 1.0
+        end
+
+        @rate = rate
+        @threshold = @rate * UINT64_MAX
+      end
+
+      # Determines if the given input should be sampled.
+      #
+      # This method is deterministic: the same input value always produces
+      # the same result for a given sample rate and configuration.
+      #
+      # @param input [Integer] Value to determine sampling decision.
+      #   Typically a trace ID or incrementing counter.
+      # @return [Boolean] +true+ if input should be sampled, +false+ otherwise
+      def sample?(input)
+        ((input * @knuth_factor) % UINT64_MODULO) <= @threshold
+      end
+    end
+  end
+end

data/lib/datadog/core/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module Datadog
   module Core
@@ -9,7 +9,7 @@ module Datadog
     # - adds last caller stack-trace info to know where the message comes from
     # @public_api
     class Logger < ::Logger
-      PREFIX = 'datadog'
+      PREFIX = "datadog"
 
       def initialize(*args, &block)
         super
@@ -18,7 +18,7 @@ module Datadog
       end
 
       def add(severity, message = nil, progname = nil, &block)
-        where = ''
+        where = ""
 
         # We are in debug mode, or this is an error, add stack trace to help debugging
         if debug? || severity >= ::Logger::ERROR
@@ -28,7 +28,7 @@ module Datadog
 
         if message.nil?
           if block
-            super(severity, message, progname) do
+            super(severity, nil, progname) 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/logging/ext.rb

@@ -6,7 +6,7 @@ module Datadog
       module Ext
         # The technology from which the log originated.
         # @see https://docs.datadoghq.com/api/latest/logs/#send-logs
-        DD_SOURCE = 'ruby'
+        DD_SOURCE = "ruby"
       end
     end
   end

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

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../utils/time'
-require_relative '../utils/only_once'
-require_relative '../telemetry/logger'
-require_relative '../configuration/ext'
+require_relative "../utils/time"
+require_relative "../utils/only_once"
+require_relative "../telemetry/logger"
+require_relative "../configuration/ext"
 
-require_relative 'ext'
-require_relative 'options'
-require_relative 'helpers'
-require_relative 'logging'
-require_relative 'metric'
+require_relative "ext"
+require_relative "options"
+require_relative "helpers"
+require_relative "logging"
+require_relative "metric"
 
 module Datadog
   module Core
@@ -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
@@ -37,10 +39,10 @@ module Datadog
         def supported?
           version = dogstatsd_version
 
-          !version.nil? && version >= Gem::Version.new('3.3.0') &&
+          !version.nil? && version >= Gem::Version.new("3.3.0") &&
             # dogstatsd-ruby >= 5.0 & < 5.2.0 has known issues with process forks
             # and do not support the single thread mode we use to avoid this problem.
-            !(version >= Gem::Version.new('5.0') && version < Gem::Version.new('5.3'))
+            !(version >= Gem::Version.new("5.0") && version < Gem::Version.new("5.3"))
         end
 
         def enabled?
@@ -52,15 +54,15 @@ module Datadog
         end
 
         def default_hostname
-          ENV.fetch(Configuration::Ext::Agent::ENV_DEFAULT_HOST, Ext::DEFAULT_HOST)
+          DATADOG_ENV.fetch(Configuration::Ext::Agent::ENV_DEFAULT_HOST, Ext::DEFAULT_HOST)
         end
 
         def default_port
-          ENV.fetch(Configuration::Ext::Metrics::ENV_DEFAULT_PORT, Ext::DEFAULT_PORT).to_i
+          DATADOG_ENV.fetch(Configuration::Ext::Metrics::ENV_DEFAULT_PORT, Ext::DEFAULT_PORT).to_i
         end
 
         def default_statsd_client
-          require 'datadog/statsd'
+          require "datadog/statsd"
 
           # Create a StatsD client that points to the agent.
           #
@@ -72,11 +74,11 @@ module Datadog
           # overhead.
           #
           # 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
+          options = if dogstatsd_version >= Gem::Version.new("5.2")
+            {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(
-            "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send count stat. Cause: #{e.class}: #{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(
-            "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send distribution stat. Cause: #{e.class}: #{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(
-            "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send increment stat. Cause: #{e.class}: #{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(
-            "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+        rescue => e
+          logger.error(
+            "Failed to send gauge stat. Cause: #{e.class}: #{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)
@@ -155,14 +157,14 @@ module Datadog
           begin
             if send_stats? && !start.nil?
               finished = Utils::Time.get_time
-              distribution(stat, ((finished - start) * 1000), options)
+              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(
-              "Failed to send time stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            logger.error(
+              "Failed to send time stat. Cause: #{e.class}: #{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,8 +194,8 @@ module Datadog
 
         def ignored_statsd_warning
           IGNORED_STATSD_ONLY_ONCE.run do
-            Datadog.logger.warn(
-              'Ignoring user-supplied statsd instance as currently-installed version of dogstastd-ruby is incompatible. ' \
+            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."
             )
           end

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

@@ -5,13 +5,13 @@ module Datadog
     module Metrics
       # @public_api
       module Ext
-        DEFAULT_HOST = '127.0.0.1'
+        DEFAULT_HOST = "127.0.0.1"
         DEFAULT_PORT = 8125
 
-        TAG_LANG = 'language'
-        TAG_LANG_INTERPRETER = 'language-interpreter'
-        TAG_LANG_VERSION = 'language-version'
-        TAG_TRACER_VERSION = 'tracer-version'
+        TAG_LANG = "language"
+        TAG_LANG_INTERPRETER = "language-interpreter"
+        TAG_LANG_VERSION = "language-version"
+        TAG_TRACER_VERSION = "tracer-version"
       end
     end
   end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'logger'
-require 'json'
+require "logger"
+require "json"
 
 module Datadog
   module Core
@@ -12,30 +12,30 @@ module Datadog
           attr_accessor :logger
 
           def initialize(logger = nil)
-            @logger = logger || Logger.new($stdout).tap do |l|
+            @logger = logger || Logger.new($stderr).tap do |l|
               l.level = ::Logger::INFO
               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/metrics/options.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative '../environment/ext'
-require_relative '../environment/identity'
+require_relative "ext"
+require_relative "../environment/ext"
+require_relative "../environment/identity"
 
 module Datadog
   module Core

data/lib/datadog/core/pin.rb

@@ -43,18 +43,18 @@ module Datadog
       # rubocop:disable Style/TrivialAccessors
       def onto(obj)
         unless obj.respond_to? :datadog_pin=
-          obj.instance_exec do
-            def datadog_pin=(pin)
-              @datadog_pin = pin
-            end
+          obj.define_singleton_method(:datadog_pin=) do |pin|
+            # Steep: https://github.com/soutaro/steep/issues/380
+            # @type self: PinnedObject
+            @datadog_pin = pin
           end
         end
 
         unless obj.respond_to? :datadog_pin
-          obj.instance_exec do
-            def datadog_pin
-              @datadog_pin
-            end
+          obj.define_singleton_method(:datadog_pin) do
+            # Steep: https://github.com/soutaro/steep/issues/380
+            # @type self: PinnedObject
+            @datadog_pin
           end
         end
 
@@ -63,7 +63,7 @@ module Datadog
       # rubocop:enable Style/TrivialAccessors
 
       def to_s
-        pretty_options = options.to_a.map { |k, v| "#{k}:#{v}" }.join(', ')
+        pretty_options = options.to_a.map { |k, v| "#{k}:#{v}" }.join(", ")
         "Pin(#{pretty_options})"
       end
 

data/lib/datadog/core/process_discovery/tracer_memfd.rb

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