datadog 2.4.0 → 2.44.0

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "ext"
+require_relative "../tag_normalizer"
+
+module Datadog
+  module Core
+    module Environment
+      # Retrieves process level information such that it can be attached to various payloads
+      #
+      # @api private
+      module Process
+        # 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
+          tags.join(",").freeze
+        end
+
+        # 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
+          tags = []
+
+          workdir = TagNormalizer.normalize_process_value(entrypoint_workdir.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_WORKDIR}:#{workdir}" unless workdir.empty?
+
+          entry_name = TagNormalizer.normalize_process_value(entrypoint_name.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_NAME}:#{entry_name}" unless entry_name.empty?
+
+          basedir = TagNormalizer.normalize_process_value(entrypoint_basedir.to_s)
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_BASEDIR}:#{basedir}" unless basedir.empty?
+
+          tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
+
+          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
+          return @entrypoint_workdir if defined?(@entrypoint_workdir)
+
+          @entrypoint_workdir = File.basename(Dir.pwd)
+        end
+
+        # Returns the entrypoint type of the process
+        # In Ruby, the entrypoint type is always 'script'
+        # @return [String] the type of the process, which is fixed in Ruby
+        def self.entrypoint_type
+          Environment::Ext::PROCESS_TYPE
+        end
+
+        # Returns the basename of the script being run
+        # Example 1: /bin/mybin -> mybin
+        # 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.
+        # For example, all Rails applications launched via `rails server` get `rails`
+        # as their entrypoint name.
+        # We might improve the behavior in the future if there is customer demand for it.
+        def self.entrypoint_name
+          return @entrypoint_name if defined?(@entrypoint_name)
+
+          @entrypoint_name = File.basename($0)
+        end
+
+        # Returns the last segment of the directory containing the script
+        # Example 1: /bin/mybin -> bin
+        # 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.
+        # This method has an initial implementation that does not necessarily return good
+        # results in all cases. For example, for Rails applications launched via `rails server`
+        # 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
+          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
+      end
+    end
+  end
+end

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

@@ -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/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

@@ -52,10 +52,16 @@ module Datadog
           ::RubyVM::YJIT.runtime_stats[:yjit_alloc_size]
         end
 
+        # Ratio of YJIT-executed instructions
+        def ratio_in_yjit
+          stats = ::RubyVM::YJIT.runtime_stats
+          stats[:ratio_in_yjit] if stats.key?(:ratio_in_yjit)
+        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

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