cw-datadog 2.23.0.2

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # 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
+
+        def self.supported?
+          Process.respond_to?(:fork)
+        end
+
+        def self.apply!
+          return false unless supported?
+
+          if RUBY_VERSION < '3.1'
+            [
+              ::Process.singleton_class, # Process.fork
+              ::Kernel.singleton_class,  # Kernel.fork
+              ::Object,                  # fork without explicit receiver (it's defined as a method in ::Kernel)
+              # Note: Modifying Object as we do here is irreversible. During tests, this
+              # change will stick around even if we otherwise stub `Process` and `Kernel`
+            ].each { |target| target.prepend(KernelMonkeyPatch) }
+          end
+
+          ::Process.singleton_class.prepend(ProcessMonkeyPatch)
+
+          true
+        end
+
+        def self.run_at_fork_blocks(stage)
+          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
+
+          AT_FORK_CHILD_BLOCKS.each(&:call)
+        end
+
+        def self.at_fork(stage, &block)
+          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
+          raise(ArgumentError, 'Missing block argument') unless block
+
+          AT_FORK_CHILD_BLOCKS << block
+
+          true
+        end
+
+        # Adds `at_fork` behavior; see parent module for details.
+        module KernelMonkeyPatch
+          def fork
+            # 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)
+
+            # 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 it gets called with a block, it only returns on the parent)
+            AtForkMonkeyPatch.run_at_fork_blocks(:child) if result.nil?
+
+            result
+          end
+        end
+
+        # Adds `at_fork` behavior; see parent module for details.
+        module ProcessMonkeyPatch
+          # 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
+
+            pid
+          end
+
+          # A call to Process.daemon ( https://rubyapi.org/3.1/o/process#method-c-daemon ) forks the current process and
+          # 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)
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for encoding and decoding base64
+      module Base64
+        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')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # 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
+
+          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
+
+          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
+          # @type var result: Numeric
+          result.round
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for managing forking behavior
+      module Forking
+        def self.included(base)
+          base.prepend(ClassExtensions) if base.is_a?(Class)
+        end
+
+        def self.extended(base)
+          # Explicitly update PID here because there's a case where
+          # the code path that lazily updates the PID may not be exercised
+          # until after a fork occurs, thus causing the event to be missed.
+          # By eagerly setting this, we avoid this scenario.
+          base.update_fork_pid!
+        end
+
+        def after_fork!
+          if forked?
+            yield
+            update_fork_pid!
+            true
+          else
+            false
+          end
+        end
+
+        def forked?
+          Process.pid != fork_pid
+        end
+
+        def update_fork_pid!
+          @fork_pid = Process.pid
+        end
+
+        def fork_pid
+          @fork_pid ||= Process.pid
+        end
+
+        # Adds additional functionality for Classes that implement Forking
+        module ClassExtensions
+          # Addresses an edge case where forking before invoking #update_fork_pid! on the
+          # 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'
+            def initialize(*args, **kwargs, &block)
+              super
+              update_fork_pid!
+            end
+          else
+            def initialize(*args, &block)
+              super
+              update_fork_pid!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+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.
+        #
+        # This class should be used when the original hash is short lived *and*
+        # each hash key is only accesses a few times.
+        # For other cases, create a copy of the original hash with the keys
+        # normalized adequate to your use case.
+        class CaseInsensitiveWrapper
+          def initialize(hash)
+            raise ArgumentError, "must be a hash, but was #{hash.class}: #{hash.inspect}" unless hash.is_a?(::Hash)
+
+            @hash = hash
+          end
+
+          def [](key)
+            return nil unless key.is_a?(::String)
+
+            @hash.each do |k, value|
+              return value if key.casecmp(k) == 0
+            end
+
+            nil
+          end
+
+          def key?(key)
+            return false unless key.is_a?(::String)
+
+            @hash.each_key do |k|
+              return true if key.casecmp(k) == 0
+            end
+
+            false
+          end
+
+          def empty?
+            @hash.empty?
+          end
+
+          def length
+            @hash.length
+          end
+
+          def original_hash
+            @hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Datadog
+  module Core
+    module Utils
+      # Common Network utility functions.
+      module Network
+        DEFAULT_IP_HEADERS_NAMES = %w[
+          x-forwarded-for
+          x-real-ip
+          true-client-ip
+          x-client-ip
+          x-forwarded
+          forwarded
+          forwarded-for
+          x-cluster-client-ip
+          fastly-client-ip
+          cf-connecting-ip
+          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.
+          #
+          #
+          # @param [Datadog::Core::HeaderCollection, #get, nil] headers The request headers
+          # @param [Array<String>] list of headers to check.
+          # @return [String] IP value without the port and the zone indentifier.
+          # @return [nil] when no valid IP value found.
+          def stripped_ip_from_request_headers(headers, ip_headers_to_check: DEFAULT_IP_HEADERS_NAMES)
+            ip = ip_header(headers, ip_headers_to_check)
+
+            ip&.to_s
+          end
+
+          # @param [String] IP value.
+          # @return [String] IP value without the port and the zone indentifier.
+          # @return [nil] when no valid IP value found.
+          def stripped_ip(ip)
+            ip = ip_to_ipaddr(ip)
+            ip&.to_s
+          end
+
+          private
+
+          # @param [String] IP value.
+          # @return [IPaddr]
+          # @return [nil] when no valid IP value found.
+          def ip_to_ipaddr(ip)
+            return unless ip
+
+            clean_ip = if likely_ipv4?(ip)
+              strip_ipv4_port(ip)
+            else
+              strip_zone_specifier(strip_ipv6_port(ip))
+            end
+
+            begin
+              IPAddr.new(clean_ip)
+            rescue IPAddr::Error
+              nil
+            end
+          end
+
+          def ip_header(headers, ip_headers_to_check)
+            return unless headers
+
+            ip_headers_to_check.each do |name|
+              value = headers.get(name)
+
+              next unless value
+
+              ips = value.split(',')
+              ips = process_forwarded_header_values(ips) if name == 'forwarded'
+
+              ips.each do |ip|
+                parsed_ip = ip_to_ipaddr(ip.strip)
+
+                return parsed_ip if global_ip?(parsed_ip)
+              end
+            end
+
+            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 < colon_index
+          end
+
+          def strip_zone_specifier(ipv6)
+            ipv6.gsub(/%.*/, '')
+          end
+
+          def strip_ipv6_port(ip)
+            if /\[([^\]]*+)\](?::\d+)?/ =~ ip
+              Regexp.last_match(1)
+            else
+              ip
+            end
+          end
+
+          def strip_ipv4_port(ip)
+            ip.gsub(/:\d+\z/, '')
+          end
+
+          def global_ip?(parsed_ip)
+            parsed_ip && !parsed_ip.private? && !parsed_ip.loopback? && !parsed_ip.link_local? && !CGNAT_IP_RANGE.include?(parsed_ip)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # 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).
+      #
+      # Note: In its current state, this class is not Ractor-safe.
+      # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
+      # including an alternative implementation that is Ractor-safe once spent.
+      class OnlyOnce
+        def initialize
+          @mutex = Mutex.new
+          @ran_once = false
+        end
+
+        def run
+          @mutex.synchronize do
+            return if @ran_once
+
+            @ran_once = true
+
+            yield
+          end
+        end
+
+        def ran?
+          @mutex.synchronize { @ran_once }
+        end
+
+        private
+
+        def reset_ran_once_state_for_tests
+          @mutex.synchronize { @ran_once = false }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'only_once'
+
+module Datadog
+  module Core
+    module Utils
+      # Helper class to execute something with only one successful execution.
+      #
+      # If limit is not provided to the constructor, +run+ will execute the
+      # block an unlimited number of times until the block indicates that it
+      # executed successfully by returning a truthy value. After a block
+      # executes successfully, subsequent +run+ calls will not invoke the
+      # block.
+      #
+      # If a non-zero limit is provided to the constructor, +run+ will
+      # execute the block up to that many times, and will mark the instance
+      # of OnlyOneSuccessful as failed if none of the executions succeeded.
+      #
+      # One consumer of this class is sending the app-started telemetry event.
+      #
+      # Successful execution is determined by the return value of the block:
+      # any truthy value is considered success.
+      #
+      # This class is thread-safe (however, instances of it must also be
+      # created in a thread-safe manner).
+      #
+      # Note: In its current state, this class is not Ractor-safe.
+      # In https://github.com/DataDog/dd-trace-rb/pull/1398#issuecomment-797378810 we have a discussion of alternatives,
+      # including an alternative implementation that is Ractor-safe once spent.
+      class OnlyOnceSuccessful < OnlyOnce
+        def initialize(limit = 0)
+          super()
+
+          @limit = limit
+          @failed = false
+          @retries = 0
+        end
+
+        def run
+          @mutex.synchronize do
+            return if @ran_once
+
+            result = yield
+            @ran_once = !!result
+
+            if !@ran_once && limited?
+              @retries += 1
+              check_limit!
+            end
+
+            result
+          end
+        end
+
+        def success?
+          @mutex.synchronize { @ran_once && !@failed }
+        end
+
+        def failed?
+          @mutex.synchronize { @ran_once && @failed }
+        end
+
+        private
+
+        def check_limit!
+          if @retries >= @limit
+            @failed = true
+            @ran_once = true
+          end
+        end
+
+        def limited?
+          !@limit.nil? && @limit.positive?
+        end
+
+        def reset_ran_once_state_for_tests
+          @mutex.synchronize do
+            @ran_once = false
+            @failed = false
+            @retries = 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for safer dup
+      module SafeDup
+        # String#+@ was introduced in Ruby 2.3
+        def self.frozen_or_dup(v)
+          # For the case of a String we use the methods +@ and -@.
+          # Those methods are only for String objects
+          # they are faster and chepaer on the memory side.
+          # Check the benchmark on
+          # https://github.com/DataDog/dd-trace-rb/pull/2704
+          if v.is_a?(String)
+            # If the string is not frozen, the +(-v) will:
+            # - first create a frozen deduplicated copy with -v
+            # - then it will dup it more efficiently with +v
+            v.frozen? ? v : +(-v)
+          else
+            v.frozen? ? v : v.dup
+          end
+        end
+
+        def self.frozen_dup(v)
+          # For the case of a String we use the methods -@
+          # That method are only for String objects
+          # they are faster and chepaer on the memory side.
+          # Check the benchmark on
+          # https://github.com/DataDog/dd-trace-rb/pull/2704
+          if v.is_a?(String)
+            -v if v
+          else
+            v.frozen? ? v : v.dup.freeze
+          end
+        end
+      end
+    end
+  end
+end