datadog 2.4.0 → 2.44.0

data/lib/datadog/core/utils/at_fork_monkey_patch.rb

@@ -6,8 +6,30 @@ module Datadog
       # Monkey patches `Kernel#fork` and similar functions, adding an `at_fork` callback mechanism which
       # is used to restart observability after the VM forks (e.g. in multiprocess Ruby apps).
       module AtForkMonkeyPatch
-        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant Used to store blocks to run, mutable by design.
-        private_constant :AT_FORK_CHILD_BLOCKS
+        class Callback
+          attr_reader :block, :group
+
+          def initialize(block, group = nil)
+            @block = block
+            @group = group
+            freeze
+          end
+        end
+        private_constant :Callback
+
+        EMPTY_AT_FORK_BLOCKS = {
+          before: [].freeze,
+          parent: [].freeze,
+          child: [].freeze,
+        }.freeze
+        private_constant :EMPTY_AT_FORK_BLOCKS
+
+        @at_fork_blocks = EMPTY_AT_FORK_BLOCKS
+
+        # Serializes copy-on-write registry updates. Fork dispatch only reads the
+        # latest immutable registry reference and never acquires this mutex.
+        AT_FORK_REGISTRY_MUTEX = Mutex.new
+        private_constant :AT_FORK_REGISTRY_MUTEX
 
         def self.supported?
           Process.respond_to?(:fork)
@@ -16,7 +38,7 @@ module Datadog
         def self.apply!
           return false unless supported?
 
-          if RUBY_VERSION < '3.1'
+          if RubyVersion.is?("< 3.1")
             [
               ::Process.singleton_class, # Process.fork
               ::Kernel.singleton_class,  # Kernel.fork
@@ -31,43 +53,147 @@ module Datadog
           true
         end
 
-        def self.run_at_fork_blocks(stage)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
+        # Runs the callbacks copied for one fork lifecycle. Before callbacks
+        # stop at the first failure; parent and child callbacks all run before
+        # the first failure is re-raised.
+        def self.run_at_fork_blocks(stage, snapshot:, started: nil)
+          callbacks = blocks_for(snapshot, stage)
+          if stage == :before
+            return callbacks.each do |callback|
+              started[callback.group] = true if started && callback.group
+              callback.block.call
+            end
+          end
+
+          error = nil
+          callbacks.each do |callback|
+            next if started && callback.group && !started.key?(callback.group)
 
-          AT_FORK_CHILD_BLOCKS.each(&:call)
+            callback.block.call
+          rescue Exception => e # rubocop:disable Lint/RescueException -- finish cleanup, then re-raise the first failure
+            error ||= e
+          end
+          raise error if error
         end
 
+        def self.run_parent_cleanup(snapshot, started, fork_error)
+          run_at_fork_blocks(:parent, snapshot: snapshot, started: started)
+        rescue Exception => cleanup_error # rubocop:disable Lint/RescueException -- preserve the original fork failure
+          Datadog.logger.warn do
+            "Parent at-fork cleanup failed while handling #{fork_error.class}: " \
+              "#{cleanup_error.class}: #{cleanup_error.message}"
+          end
+        end
+        private_class_method :run_parent_cleanup
+
+        # Registers a block to run at the given fork +stage+ (+:before+,
+        # +:parent+, or +:child+).
+        #
+        # Returns the registered block so callers can keep a handle to it and
+        # later deregister it via {.remove_at_fork}.
         def self.at_fork(stage, &block)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
-          raise(ArgumentError, 'Missing block argument') unless block
+          raise(ArgumentError, "Missing block argument") unless block
+
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            @at_fork_blocks = current.merge(
+              stage => (blocks_for(current, stage) + [Callback.new(block)]).freeze
+            ).freeze
+          end
 
-          AT_FORK_CHILD_BLOCKS << block
+          block
+        end
 
-          true
+        # Registers one before/parent/child callback triplet atomically relative
+        # to the snapshots taken by fork dispatch.
+        def self.at_fork_blocks(before:, parent:, child:)
+          blocks = {before: before, parent: parent, child: child}
+          group = Object.new.freeze
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            @at_fork_blocks = {
+              before: (current.fetch(:before) + [Callback.new(before, group)]).freeze,
+              parent: (current.fetch(:parent) + [Callback.new(parent, group)]).freeze,
+              child: (current.fetch(:child) + [Callback.new(child, group)]).freeze,
+            }.freeze
+          end
+          blocks
         end
 
+        # Deregisters a block previously registered with {.at_fork} for the given
+        # +stage+. It is a no-op (does not raise) when +block+ was never
+        # registered (or was already removed). Raises +ArgumentError+ for an
+        # unknown stage, matching the {.at_fork} contract.
+        def self.remove_at_fork(stage, block)
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            callbacks = blocks_for(current, stage)
+            @at_fork_blocks = current.merge(
+              stage => callbacks.reject { |callback| callback.block.equal?(block) }.freeze
+            ).freeze
+          end
+
+          nil
+        end
+
+        # Returns the immutable callback registry for one fork lifecycle.
+        # Copy-on-write updates publish a new reference, so registrations made
+        # afterwards apply only to the next lifecycle without locking this read.
+        def self.snapshot_at_fork_blocks
+          @at_fork_blocks
+        end
+
+        def self.replace_at_fork_blocks(snapshot)
+          AT_FORK_REGISTRY_MUTEX.synchronize { @at_fork_blocks = snapshot }
+        end
+        private_class_method :replace_at_fork_blocks
+
+        def self.blocks_for(snapshot, stage)
+          case stage
+          when :before, :parent, :child then snapshot.fetch(stage)
+          else raise(ArgumentError, "Unsupported stage #{stage}")
+          end
+        end
+        private_class_method :blocks_for
+
         # Adds `at_fork` behavior; see parent module for details.
         module KernelMonkeyPatch
           def fork
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+
             # If a block is provided, it must be wrapped to trigger callbacks.
             child_block = if block_given?
-                            proc do
-                              AtForkMonkeyPatch.run_at_fork_blocks(:child)
-
-                              # Invoke original block
-                              yield
-                            end
-                          end
-
-            # Start fork
-            # If a block is provided, use the wrapped version.
-            result = child_block.nil? ? super : super(&child_block)
+              proc do
+                AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+
+                # Invoke original block
+                yield
+              end
+            end
+
+            begin
+              # Run pre-fork callbacks in the parent, just before forking.
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+
+              # Start fork. If a block is provided, use the wrapped version.
+              result = child_block.nil? ? super : super(&child_block)
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork or a before-fork callback failed and we are still in
+              # the parent. Restore any state set up by earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
             # When fork gets called without a block, it returns twice:
             # If we're in the fork, result = nil: trigger child callbacks.
-            # If we're in the parent, result = pid: we do nothing.
+            # If we're in the parent, result = pid: trigger parent callbacks.
             # (If it gets called with a block, it only returns on the parent)
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if result.nil?
+            if result.nil?
+              AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent, snapshot: snapshot)
+            end
 
             result
           end
@@ -78,9 +204,23 @@ module Datadog
           # Hook provided by Ruby 3.1+ for observability libraries that want to know about fork, see
           # https://github.com/ruby/ruby/pull/5017 and https://bugs.ruby-lang.org/issues/17795
           def _fork
-            pid = super
-
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if pid == 0
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+            begin
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+              pid = super
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork or a before-fork callback failed, so no child was
+              # created. Restore state set up by any earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
+
+            if pid == 0
+              AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent, snapshot: snapshot)
+            end
 
             pid
           end
@@ -89,9 +229,21 @@ module Datadog
           # keeps executing code in the child process, killing off the parent, thus effectively replacing it.
           # This is not covered by `_fork` and thus we have some extra code for it.
           def daemon(*args)
-            result = super
-
-            AtForkMonkeyPatch.run_at_fork_blocks(:child)
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+            begin
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+              result = super
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # `daemon` or a before-fork callback failed, so the original
+              # process survives. Restore state set up by earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
+
+            # `daemon` kills the parent, so there is no surviving parent to run
+            # `:parent` callbacks in; only the child continues executing.
+            AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
 
             result
           end

data/lib/datadog/core/utils/base64_codec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Base64 encoding/decoding without using the `base64` gem,
+      # which is no longer a default gem since Ruby 3.4.
+      module Base64Codec
+        def self.encode64(bin)
+          [bin].pack("m")
+        end
+
+        def self.strict_encode64(bin)
+          [bin].pack("m0")
+        end
+
+        def self.strict_decode64(str)
+          str.unpack1("m0") #: String # 'm0' format always returns a String
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/duration.rb

@@ -6,43 +6,43 @@ module Datadog
       # Helper methods for parsing string values into Numeric
       module Duration
         def self.call(value, base: :s)
-          cast = if value.include?('.')
-                   method(:Float)
-                 else
-                   method(:Integer)
-                 end
+          cast = if value.include?(".")
+            method(:Float)
+          else
+            method(:Integer)
+          end
 
           scale = case base
-                  when :s
-                    1_000_000_000
-                  when :ms
-                    1_000_000
-                  when :us
-                    1000
-                  when :ns
-                    1
-                  else
-                    raise ArgumentError, "invalid base: #{base.inspect}"
-                  end
+          when :s
+            1_000_000_000
+          when :ms
+            1_000_000
+          when :us
+            1000
+          when :ns
+            1
+          else
+            raise ArgumentError, "invalid base: #{base.inspect}"
+          end
 
           result = case value
-                   when /^(\d+(?:\.\d+)?)h$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 * 60 / scale
-                   when /^(\d+(?:\.\d+)?)m$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 / scale
-                   when /^(\d+(?:\.\d+)?)s$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000_000 / scale
-                   when /^(\d+(?:\.\d+)?)ms$/
-                     cast.call(Regexp.last_match(1)) * 1_000_000 / scale
-                   when /^(\d+(?:\.\d+)?)us$/
-                     cast.call(Regexp.last_match(1)) * 1_000 / scale
-                   when /^(\d+(?:\.\d+)?)ns$/
-                     cast.call(Regexp.last_match(1)) / scale
-                   when /^(\d+(?:\.\d+)?)$/
-                     cast.call(Regexp.last_match(1))
-                   else
-                     raise ArgumentError, "invalid duration: #{value.inspect}"
-                   end
+          when /^(\d+(?:\.\d+)?)h$/
+            cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 * 60 / scale
+          when /^(\d+(?:\.\d+)?)m$/
+            cast.call(Regexp.last_match(1)) * 1_000_000_000 * 60 / scale
+          when /^(\d+(?:\.\d+)?)s$/
+            cast.call(Regexp.last_match(1)) * 1_000_000_000 / scale
+          when /^(\d+(?:\.\d+)?)ms$/
+            cast.call(Regexp.last_match(1)) * 1_000_000 / scale
+          when /^(\d+(?:\.\d+)?)us$/
+            cast.call(Regexp.last_match(1)) * 1_000 / scale
+          when /^(\d+(?:\.\d+)?)ns$/
+            cast.call(Regexp.last_match(1)) / scale
+          when /^(\d+(?:\.\d+)?)$/
+            cast.call(Regexp.last_match(1))
+          else
+            raise ArgumentError, "invalid duration: #{value.inspect}"
+          end
           # @type var result: Numeric
           result.round
         end

data/lib/datadog/core/utils/enumerable_compat.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Bring newer Enumerable methods to older Ruby versions.
+      module EnumerableCompat
+        def self.filter_map(array, &block)
+          if array.respond_to?(:filter_map)
+            # DEV Supported since Ruby 2.7, saves an intermediate object creation
+            array.filter_map(&block)
+          elsif array.is_a?(Enumerator::Lazy)
+            # You would think that .compact would work here, but it does not:
+            # the result of .map could be an Enumerator::Lazy instance which
+            # does not implement #compact on Ruby 2.5/2.6.
+            array.map(&block).reject do |item|
+              item.nil?
+            end
+          else
+            array.each_with_object([]) do |item, memo|
+              new_item = block.call(item)
+              memo.push(new_item) unless new_item.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/fnv.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      module FNV
+        # FNV-1a 64-bit non-cryptographic hash function.
+        # @see https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash Algorithm
+        # @see https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV_hash_parameters Prime and Offset Basis
+
+        FNV_OFFSET_BASIS = 14695981039346656037
+        FNV_PRIME = 1099511628211
+        FNV_64_BIT_MASK = 0xFFFFFFFFFFFFFFFF
+
+        def self.fnv1_64(data)
+          hash_value = FNV_OFFSET_BASIS
+          data.each_byte do |byte|
+            hash_value ^= byte
+            hash_value = (hash_value * FNV_PRIME) & FNV_64_BIT_MASK
+          end
+          hash_value
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/forking.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../ruby_version"
+
 module Datadog
   module Core
     module Utils
@@ -45,14 +47,14 @@ module Datadog
           # object will cause forking to not be detected in the fork when it should have.
           #
           # This wrapper prevents this by initializing the fork PID when the object is created.
-          if RUBY_VERSION >= '3'
+          if RubyVersion.is?(">= 3")
             def initialize(*args, **kwargs, &block)
-              super(*args, **kwargs, &block)
+              super
               update_fork_pid!
             end
           else
             def initialize(*args, &block)
-              super(*args, &block)
+              super
               update_fork_pid!
             end
           end

data/lib/datadog/core/utils/hash.rb

@@ -3,30 +3,7 @@
 module Datadog
   module Core
     module Utils
-      # Refinements for {Hash}.
       module Hash
-        # This refinement ensures modern rubies are allowed to use newer,
-        # simpler, and more performant APIs.
-        module Refinement
-          # Introduced in Ruby 2.4
-          unless ::Hash.method_defined?(:compact)
-            refine ::Hash do
-              def compact
-                reject { |_k, v| v.nil? }
-              end
-            end
-          end
-
-          # Introduced in Ruby 2.4
-          unless ::Hash.method_defined?(:compact!)
-            refine ::Hash do
-              def compact!
-                reject! { |_k, v| v.nil? }
-              end
-            end
-          end
-        end
-
         # A minimal {Hash} wrapper that provides case-insensitive access
         # to hash keys, without the overhead of copying the original hash.
         #

data/lib/datadog/core/utils/lru_cache.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Datadog
+  module Core
+    module Utils
+      # An LRU (Least Recently Used) cache implementation that relies on the
+      # Ruby 1.9+ `Hash` implementation that guarantees insertion order.
+      #
+      # WARNING: This implementation is NOT thread-safe and should be used
+      #          in a single-threaded context or guarded by Mutex.
+      class LRUCache
+        extend Forwardable
+
+        def_delegators :@store, :clear, :empty?
+
+        def initialize(max_size)
+          raise ArgumentError, "max_size must be an Integer" unless max_size.is_a?(Integer)
+          raise ArgumentError, "max_size must be greater than 0" if max_size <= 0
+
+          @max_size = max_size
+          @store = {}
+        end
+
+        # NOTE: Accessing a key moves it to the end of the list.
+        def [](key)
+          if (entry = @store.delete(key))
+            @store[key] = entry
+          end
+        end
+
+        def []=(key, value)
+          if @store.delete(key)
+            @store[key] = value
+          else
+            # NOTE: evict the oldest entry if store reached the maximum allowed size
+            @store.shift if @store.size >= @max_size
+            @store[key] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/utils/network.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'ipaddr'
+require "ipaddr"
 
 module Datadog
   module Core
@@ -13,6 +13,7 @@ module Datadog
           true-client-ip
           x-client-ip
           x-forwarded
+          forwarded
           forwarded-for
           x-cluster-client-ip
           fastly-client-ip
@@ -20,6 +21,8 @@ module Datadog
           cf-connecting-ipv6
         ].freeze
 
+        CGNAT_IP_RANGE = IPAddr.new("100.64.0.0/10")
+
         class << self
           # Returns a client IP associated with the request if it was
           #   retrieved successfully.
@@ -32,7 +35,7 @@ module Datadog
           def stripped_ip_from_request_headers(headers, ip_headers_to_check: DEFAULT_IP_HEADERS_NAMES)
             ip = ip_header(headers, ip_headers_to_check)
 
-            ip ? ip.to_s : nil
+            ip&.to_s
           end
 
           # @param [String] IP value.
@@ -40,7 +43,7 @@ module Datadog
           # @return [nil] when no valid IP value found.
           def stripped_ip(ip)
             ip = ip_to_ipaddr(ip)
-            ip ? ip.to_s : nil
+            ip&.to_s
           end
 
           private
@@ -52,10 +55,10 @@ module Datadog
             return unless ip
 
             clean_ip = if likely_ipv4?(ip)
-                         strip_ipv4_port(ip)
-                       else
-                         strip_zone_specifier(strip_ipv6_port(ip))
-                       end
+              strip_ipv4_port(ip)
+            else
+              strip_zone_specifier(strip_ipv6_port(ip))
+            end
 
             begin
               IPAddr.new(clean_ip)
@@ -72,7 +75,9 @@ module Datadog
 
               next unless value
 
-              ips = value.split(',')
+              ips = value.split(",")
+              ips = process_forwarded_header_values(ips) if name == "forwarded"
+
               ips.each do |ip|
                 parsed_ip = ip_to_ipaddr(ip.strip)
 
@@ -83,20 +88,36 @@ module Datadog
             nil
           end
 
+          def process_forwarded_header_values(values)
+            values.each_with_object([]) do |value, acc|
+              value.downcase!
+
+              value.split(";").each do |tuple_str|
+                tuple_str.strip!
+                next unless tuple_str.start_with?("for=")
+
+                tuple_str.delete_prefix!("for=")
+                tuple_str.delete!('"')
+
+                acc << tuple_str
+              end
+            end
+          end
+
           # Returns whether the given value is more likely to be an IPv4 than an IPv6 address.
           #
           # This is done by checking if a dot (`'.'`) character appears before a colon (`':'`) in the value.
           # The rationale is that in valid IPv6 addresses, colons will always preced dots,
           #   and in valid IPv4 addresses dots will always preced colons.
           def likely_ipv4?(value)
-            dot_index = value.index('.') || value.size
-            colon_index = value.index(':') || value.size
+            dot_index = value.index(".") || value.size
+            colon_index = value.index(":") || value.size
 
             dot_index < colon_index
           end
 
           def strip_zone_specifier(ipv6)
-            ipv6.gsub(/%.*/, '')
+            ipv6.gsub(/%.*/, "")
           end
 
           def strip_ipv6_port(ip)
@@ -108,11 +129,11 @@ module Datadog
           end
 
           def strip_ipv4_port(ip)
-            ip.gsub(/:\d+\z/, '')
+            ip.gsub(/:\d+\z/, "")
           end
 
           def global_ip?(parsed_ip)
-            parsed_ip && !parsed_ip.private? && !parsed_ip.loopback? && !parsed_ip.link_local?
+            parsed_ip && !parsed_ip.private? && !parsed_ip.loopback? && !parsed_ip.link_local? && !CGNAT_IP_RANGE.include?(parsed_ip)
           end
         end
       end

data/lib/datadog/core/utils/only_once.rb

@@ -3,7 +3,7 @@
 module Datadog
   module Core
     module Utils
-      # Helper class to execute something only once such as not repeating warning logs, and instrumenting classes
+      # Helper class to execute something only once, such as not repeating warning logs and instrumenting classes
       # only once.
       #
       # Thread-safe when used correctly (e.g. be careful of races when lazily initializing instances of this class).