ddtrace 1.4.2 → 1.19.0

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

@@ -1,5 +1,3 @@
-# typed: false
-
 module Datadog
   module Core
     module Utils

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: true
-
 module Datadog
   module Core
     module Utils

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

@@ -1,25 +1,48 @@
-# typed: false
+require_relative '../backport'
 
 module Datadog
   module Core
     module Utils
       # Helper methods for safer dup
       module SafeDup
-        if RUBY_VERSION < '2.2' # nil.dup only fails in Ruby 2.1
-          # Ensures #initialize can call nil.dup safely
-          module RefineNil
-            refine NilClass do
-              def dup
-                self
-              end
+        # 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
 
-          using RefineNil
-        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_or_dup(v)
-          v.frozen? ? v : v.dup
+          def self.frozen_dup(v)
+            v.frozen? ? v : Core::BackportFrom24.dup(v).freeze
+          end
         end
       end
     end

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Core

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

@@ -1,12 +1,10 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Core
     module Utils
       # Common database-related utility functions.
       module Time
-        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-
         module_function
 
         # Current monotonic time

data/lib/datadog/core/utils.rb

@@ -1,7 +1,4 @@
-# typed: true
-
 require_relative 'utils/forking'
-require_relative '../tracing/span'
 
 module Datadog
   module Core
@@ -11,26 +8,6 @@ module Datadog
       extend Forking
 
       EMPTY_STRING = ''.encode(::Encoding::UTF_8).freeze
-      # We use a custom random number generator because we want no interference
-      # with the default one. Using the default prng, we could break code that
-      # would rely on srand/rand sequences.
-
-      # Return a randomly generated integer, valid as a Span ID or Trace ID.
-      # This method is thread-safe and fork-safe.
-      def self.next_id
-        after_fork! { reset! }
-        id_rng.rand(Tracing::Span::RUBY_ID_RANGE)
-      end
-
-      def self.id_rng
-        @id_rng ||= Random.new
-      end
-
-      def self.reset!
-        @id_rng = Random.new
-      end
-
-      private_class_method :id_rng, :reset!
 
       # Stringifies `value` and ensures the outcome is
       # string is no longer than `size`.
@@ -90,7 +67,7 @@ module Datadog
       # @!visibility private
       def self.without_warnings
         # This is typically used when monkey patching functions such as
-        # intialize, which Ruby advices you not to. Use cautiously.
+        # initialize, which Ruby advices you not to. Use cautiously.
         v = $VERBOSE
         $VERBOSE = nil
         begin

data/lib/datadog/core/vendor/ipaddr.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2002 Hajimu UMEMOTO <ume@mahoroba.org>
+# Copyright (c) 2007-2017 Akinori MUSHA <knu@iDaemons.org>
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+module Datadog
+  module Core
+    module Vendor
+      # vendor code from https://github.com/ruby/ipaddr/blob/master/lib/ipaddr.rb
+      # Ruby version below 2.5 does not have the IpAddr#private? method
+      # We have to vendor the code because ruby versions below 2.5 did not extract ipaddr as a gem
+      # So we can not specify a specific version for ipaddr for ruby versions: 2.1, 2.2, 2.3, 2.4
+      module IPAddr
+        class << self
+          def private?(ip)
+            addr = ip.instance_variable_get(:@addr)
+
+            case ip.family
+            when Socket::AF_INET
+              addr & 0xff000000 == 0x0a000000 ||    # 10.0.0.0/8
+                addr & 0xfff00000 == 0xac100000 ||  # 172.16.0.0/12
+                addr & 0xffff0000 == 0xc0a80000     # 192.168.0.0/16
+            when Socket::AF_INET6
+              addr & 0xfe00_0000_0000_0000_0000_0000_0000_0000 == 0xfc00_0000_0000_0000_0000_0000_0000_0000
+            else
+              raise ::IPAddr::AddressFamilyError, 'unsupported address family'
+            end
+          end
+
+          def link_local?(ip)
+            addr = ip.instance_variable_get(:@addr)
+
+            case ip.family
+            when Socket::AF_INET
+              addr & 0xffff0000 == 0xa9fe0000 # 169.254.0.0/16
+            when Socket::AF_INET6
+              addr & 0xffc0_0000_0000_0000_0000_0000_0000_0000 == 0xfe80_0000_0000_0000_0000_0000_0000_0000
+            else
+              raise ::IPAddr::AddressFamilyError, 'unsupported address family'
+            end
+          end
+
+          def loopback?(ip)
+            addr = ip.instance_variable_get(:@addr)
+
+            case ip.family
+            when Socket::AF_INET
+              addr & 0xff000000 == 0x7f000000
+            when Socket::AF_INET6
+              addr == 1
+            else
+              raise ::IPAddr::AddressFamilyError, 'unsupported address family'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/vendor/multipart-post/multipart/post/composite_read_io.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 #--
 # Copyright (c) 2007-2012 Nick Sieger.
 # See the file README.txt included with the distribution for

data/lib/datadog/core/vendor/multipart-post/multipart/post/multipartable.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 #--
 # Copyright (c) 2007-2013 Nick Sieger.
 # See the file README.txt included with the distribution for

data/lib/datadog/core/vendor/multipart-post/multipart/post/parts.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 #--
 # Copyright (c) 2007-2013 Nick Sieger.
 # See the file README.txt included with the distribution for

data/lib/datadog/core/vendor/multipart-post/multipart/post/version.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 module Datadog
   module Core
     module Vendor

data/lib/datadog/core/vendor/multipart-post/multipart/post.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 module Datadog
   module Core
     module Vendor

data/lib/datadog/core/vendor/multipart-post/multipart.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 #--
 # Copyright (c) 2007-2013 Nick Sieger.
 # See the file README.txt included with the distribution for

data/lib/datadog/core/vendor/multipart-post/net/http/post/multipart.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 #--
 # Copyright (c) 2007-2012 Nick Sieger.
 # See the file README.txt included with the distribution for

data/lib/datadog/core/worker.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Core

data/lib/datadog/core/workers/async.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../logger'
 
 module Datadog
@@ -8,12 +6,15 @@ module Datadog
       module Async
         # Adds threading behavior to workers
         # to run tasks asynchronously.
-        # rubocop:disable Metrics/ModuleLength
         module Thread
           FORK_POLICY_STOP = :stop
           FORK_POLICY_RESTART = :restart
           SHUTDOWN_TIMEOUT = 1
 
+          # This single shared mutex is used to avoid concurrency issues during the
+          # initialization of per-instance lazy-initialized mutexes.
+          MUTEX_INIT = Mutex.new
+
           def self.included(base)
             base.prepend(PrependedMethods)
           end
@@ -89,7 +90,7 @@ module Datadog
             :result
 
           def mutex
-            @mutex ||= Mutex.new
+            (defined?(@mutex) && @mutex) || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
           end
 
           def after_fork
@@ -102,7 +103,7 @@ module Datadog
             :pid
 
           def mutex_after_fork
-            @mutex_after_fork ||= Mutex.new
+            (defined?(@mutex_after_fork) && @mutex_after_fork) || MUTEX_INIT.synchronize { @mutex_after_fork ||= Mutex.new }
           end
 
           def worker
@@ -146,6 +147,7 @@ module Datadog
               # rubocop:enable Lint/RescueException
             end
             @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+            @worker.thread_variable_set(:fork_safe, true)
 
             nil
           end
@@ -175,7 +177,6 @@ module Datadog
             end
           end
         end
-        # rubocop:enable Metrics/ModuleLength
       end
     end
   end

data/lib/datadog/core/workers/interval_loop.rb

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 module Datadog
   module Core
@@ -10,6 +10,10 @@ module Datadog
         BACK_OFF_MAX = 5
         BASE_INTERVAL = 1
 
+        # This single shared mutex is used to avoid concurrency issues during the
+        # initialization of per-instance lazy-initialized mutexes.
+        MUTEX_INIT = Mutex.new
+
         def self.included(base)
           base.prepend(PrependedMethods)
         end
@@ -82,7 +86,7 @@ module Datadog
           :loop_base_interval
 
         def mutex
-          @mutex ||= Mutex.new
+          @mutex || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
         end
 
         private

data/lib/datadog/core/workers/polling.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative 'async'
 require_relative 'interval_loop'
 
@@ -8,7 +6,7 @@ module Datadog
     module Workers
       # Adds polling (async looping) behavior to workers
       module Polling
-        SHUTDOWN_TIMEOUT = 1
+        DEFAULT_SHUTDOWN_TIMEOUT = 1
 
         def self.included(base)
           base.include(Workers::IntervalLoop)
@@ -23,7 +21,7 @@ module Datadog
           end
         end
 
-        def stop(force_stop = false, timeout = SHUTDOWN_TIMEOUT)
+        def stop(force_stop = false, timeout = DEFAULT_SHUTDOWN_TIMEOUT)
           if running?
             # Attempt graceful stop and wait
             stop_loop

data/lib/datadog/core/workers/queue.rb

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 module Datadog
   module Core

data/lib/datadog/core/workers/runtime_metrics.rb

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../runtime/metrics'