ddtrace 0.34.1 → 1.23.1

data/lib/datadog/core/transport/response.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      # Defines abstract response for transport operations
+      module Response
+        def payload
+          nil
+        end
+
+        def ok?
+          nil
+        end
+
+        def unsupported?
+          nil
+        end
+
+        def not_found?
+          nil
+        end
+
+        def client_error?
+          nil
+        end
+
+        def server_error?
+          nil
+        end
+
+        def internal_error?
+          nil
+        end
+
+        def inspect
+          "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
+            "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
+            "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
+            "payload:#{payload}"
+        end
+      end
+
+      # A generic error response for internal errors
+      class InternalErrorResponse
+        include Response
+
+        attr_reader :error
+
+        def initialize(error)
+          @error = error
+        end
+
+        def internal_error?
+          true
+        end
+
+        def inspect
+          "#{super}, error_type:#{error.class} error:#{error}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'zlib'
+
+module Datadog
+  module Core
+    module Utils
+      # Compression/decompression utility functions.
+      #
+      # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+      module Compression
+        module_function
+
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+        def gzip(string, level: nil, strategy: nil)
+          sio = StringIO.new
+          sio.binmode
+          gz = Zlib::GzipWriter.new(sio, level, strategy)
+          gz.write(string)
+          gz.close
+          sio.string
+        end
+
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
+        def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
+          sio = StringIO.new(string)
+          gz = Zlib::GzipReader.new(sio, encoding: encoding)
+          gz.read
+        ensure
+          gz && gz.close
+        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,61 @@
+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(*args, **kwargs, &block)
+              update_fork_pid!
+            end
+          else
+            def initialize(*args, &block)
+              super(*args, &block)
+              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/network.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+require_relative '../vendor/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-for
+          x-cluster-client-ip
+          fastly-client-ip
+          cf-connecting-ip
+          cf-connecting-ipv6
+        ].freeze
+
+        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 ? ip.to_s : nil
+          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 ? ip.to_s : nil
+          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.each do |ip|
+                parsed_ip = ip_to_ipaddr(ip.strip)
+
+                return parsed_ip if global_ip?(parsed_ip)
+              end
+            end
+
+            nil
+          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 && !private?(parsed_ip) && !loopback?(parsed_ip) && !link_local?(parsed_ip)
+          end
+
+          # TODO: remove once we drop support for ruby 2.1, 2.2, 2.3, 2.4
+          # replace with ip.private?
+          def private?(ip)
+            Datadog::Core::Vendor::IPAddr.private?(ip)
+          end
+
+          # TODO: remove once we drop support for ruby 2.1, 2.2, 2.3, 2.4
+          # replace with ip.link_local?
+          def link_local?(ip)
+            Datadog::Core::Vendor::IPAddr.link_local?(ip)
+          end
+
+          # TODO: remove once we drop support for ruby 2.1, 2.2, 2.3, 2.4
+          # replace with ip.loopback
+          def loopback?(ip)
+            Datadog::Core::Vendor::IPAddr.loopback?(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/safe_dup.rb

@@ -0,0 +1,50 @@
+require_relative '../backport'
+
+module Datadog
+  module Core
+    module Utils
+      # Helper methods for safer dup
+      module SafeDup
+        # String#+@ was introduced in Ruby 2.3
+        if String.method_defined?(:+@) && String.method_defined?(:-@)
+          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 : Core::BackportFrom24.dup(v)
+            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 : Core::BackportFrom24.dup(v).freeze
+            end
+          end
+        else
+          def self.frozen_or_dup(v)
+            v.frozen? ? v : Core::BackportFrom24.dup(v)
+          end
+
+          def self.frozen_dup(v)
+            v.frozen? ? v : Core::BackportFrom24.dup(v).freeze
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Generates values from a consistent sequence
+      class Sequence
+        def initialize(seed = 0, &block)
+          @seed = seed
+          @current = seed
+          @next_item = block
+        end
+
+        def next
+          next_item = @next_item ? @next_item.call(@current) : @current
+          @current += 1
+          next_item
+        end
+
+        def reset!
+          @current = @seed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Utils
+      # Common database-related utility functions.
+      module Time
+        module_function
+
+        # Current monotonic time
+        #
+        # @param unit [Symbol] unit for the resulting value, same as ::Process#clock_gettime, defaults to :float_second
+        # @return [Numeric] timestamp in the requested unit, since some unspecified starting point
+        def get_time(unit = :float_second)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+        end
+
+        # Current wall time.
+        #
+        # @return [Time] current time object
+        def now
+          ::Time.now
+        end
+
+        # Overrides the implementation of `#now
+        # with the provided callable.
+        #
+        # Overriding the method `#now` instead of
+        # indirectly calling `block` removes
+        # one level of method call overhead.
+        #
+        # @param block [Proc] block that returns a `Time` object representing the current wall time
+        def now_provider=(block)
+          define_singleton_method(:now, &block)
+        end
+
+        def measure(unit = :float_second)
+          before = get_time(unit)
+          yield
+          after = get_time(unit)
+          after - before
+        end
+
+        def as_utc_epoch_ns(time)
+          # we use #to_r instead of #to_f because Float doesn't have enough precision to represent exact nanoseconds, see
+          # https://rubyapi.org/3.0/o/time#method-i-to_f
+          (time.to_r * 1_000_000_000).to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Datadog
+  module Core
+    module Utils
+      # Helpers class that provides methods to process URLs
+      # such as filtering sensitive information.
+      module Url
+        def self.filter_basic_auth(url)
+          return nil if url.nil?
+
+          URI(url).tap do |u|
+            u.user = nil
+            u.password = nil
+          end.to_s
+        # Git scheme: git@github.com:DataDog/dd-trace-rb.git
+        rescue URI::InvalidURIError
+          url
+        end
+      end
+    end
+  end
+end