ddtrace 0.50.0 → 1.0.0

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

@@ -0,0 +1,63 @@
+# typed: false
+
+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/object_set.rb

@@ -0,0 +1,43 @@
+# typed: true
+
+require 'datadog/core/utils/sequence'
+
+module Datadog
+  module Core
+    module Utils
+      # Acts as a unique dictionary of objects
+      class ObjectSet
+        # You can provide a block that defines how the key
+        # for this message type is resolved.
+        def initialize(seed = 0, &block)
+          @sequence = Sequence.new(seed)
+          @items = {}
+          @key_block = block
+        end
+
+        # Submit an array of arguments that define the message.
+        # If they match an existing message, it will return the
+        # matching object. If it doesn't match, it will yield to
+        # the block with the next ID & args given.
+        def fetch(*args)
+          # TODO: Array hashing is **really** expensive, we probably want to get rid of it in the future
+          key = @key_block ? @key_block.call(*args) : args.hash
+          @items[key] ||= yield(@sequence.next, *args)
+        end
+
+        def length
+          @items.length
+        end
+
+        def objects
+          @items.values
+        end
+
+        def freeze
+          super
+          @items.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# typed: 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,27 @@
+# typed: false
+
+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
+            end
+          end
+
+          using RefineNil
+        end
+
+        def self.frozen_or_dup(v)
+          v.frozen? ? v : v.dup
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,49 @@
+# typed: true
+
+require 'datadog/core/utils/sequence'
+
+module Datadog
+  module Core
+    module Utils
+      # Tracks strings and returns IDs
+      class StringTable
+        def initialize
+          @sequence = Sequence.new
+          @ids = { ''.freeze => @sequence.next }
+        end
+
+        # Returns an ID for the string
+        def fetch(string)
+          @ids[string.to_s] ||= @sequence.next
+        end
+
+        # Returns the canonical copy of this string
+        # Typically used for psuedo interning; reduce
+        # identical copies of a string to one object.
+        def fetch_string(string)
+          return nil if string.nil?
+
+          # Co-erce to string
+          string = string.to_s
+
+          # Add to string table if no match
+          @ids[string] = @sequence.next unless @ids.key?(string)
+
+          # Get and return matching string in table
+          # NOTE: Have to resolve the key and retrieve from table again
+          #       because "string" argument is not same object as string key.
+          id = @ids[string]
+          @ids.key(id)
+        end
+
+        def [](id)
+          @ids.key(id)
+        end
+
+        def strings
+          @ids.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# typed: 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
+        #
+        # @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
+          before = get_time
+          yield
+          after = get_time
+          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.rb

@@ -0,0 +1,115 @@
+# typed: true
+
+require 'datadog/core/utils/forking'
+require 'datadog/tracing/span'
+
+module Datadog
+  module Core
+    # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
+    # @public_api
+    module Utils
+      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_MAX_ID) # TODO: This should never return zero
+      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`.
+      # `omission` replaces the end of the output if
+      # `value.to_s` does not fit in `size`, to signify
+      # truncation.
+      #
+      # If `omission.size` is larger than `size`, the output
+      # will still be `omission.size` in length.
+      # @!visibility private
+      def self.truncate(value, size, omission = '...'.freeze)
+        string = value.to_s
+
+        return string if string.size <= size
+
+        string = string.slice(0, size - 1)
+
+        if size < omission.size
+          string[0, size] = omission
+        else
+          string[size - omission.size, size] = omission
+        end
+
+        string
+      end
+
+      # Ensure `str` is a valid UTF-8, ready to be
+      # sent through the tracer transport.
+      #
+      # @param [String,#to_s] str object to be converted to a UTF-8 string
+      # @param [Boolean] binary whether to expect binary data in the `str` parameter
+      # @param [String] placeholder string to be returned when encoding fails
+      # @return a UTF-8 string version of `str`
+      # @!visibility private
+      def self.utf8_encode(str, binary: false, placeholder: EMPTY_STRING)
+        str = str.to_s
+
+        if binary
+          # This option is useful for "gracefully" displaying binary data that
+          # often contains text such as marshalled objects
+          str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+        elsif str.encoding == ::Encoding::UTF_8
+          str
+        elsif str.empty?
+          # DEV Optimization as `nil.to_s` is a very common source for an empty string,
+          # DEV but it comes encoded as US_ASCII.
+          EMPTY_STRING
+        else
+          str.encode(::Encoding::UTF_8)
+        end
+      rescue => e
+        Datadog.logger.debug("Error encoding string in UTF-8: #{e}")
+
+        placeholder
+      end
+
+      # @!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.
+        v = $VERBOSE
+        $VERBOSE = nil
+        begin
+          yield
+        ensure
+          $VERBOSE = v
+        end
+      end
+
+      # Extracts hostname and port from
+      # a string that contains both, separated by ':'.
+      # @return [String,Integer] hostname and port
+      # @return [nil] if format did not match
+      def self.extract_host_port(host_port)
+        match = /^([^:]+):(\d+)$/.match(host_port)
+        return unless match
+
+        [match[1], match[2].to_i]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# typed: false
+
+#--
+# Copyright (c) 2007-2012 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+# Concatenate together multiple IO objects into a single, composite IO object
+# for purposes of reading as a single stream.
+#
+# @example
+#     crio = CompositeReadIO.new(StringIO.new('one'),
+#                                StringIO.new('two'),
+#                                StringIO.new('three'))
+#     puts crio.read # => "onetwothree"
+module Datadog
+  module Core
+    module Vendor
+      module Multipart
+        module Post
+          class CompositeReadIO
+            # Create a new composite-read IO from the arguments, all of which should
+            # respond to #read in a manner consistent with IO.
+            def initialize(*ios)
+              @ios = ios.flatten
+              @index = 0
+            end
+
+            # Read from IOs in order until `length` bytes have been received.
+            def read(length = nil, outbuf = nil)
+              got_result = false
+              outbuf = outbuf ? outbuf.replace("") : ""
+
+              while io = current_io
+                if result = io.read(length)
+                  got_result ||= !result.nil?
+                  result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
+                  outbuf << result
+                  length -= result.length if length
+                  break if length == 0
+                end
+                advance_io
+              end
+              (!got_result && length) ? nil : outbuf
+            end
+
+            def rewind
+              @ios.each { |io| io.rewind }
+              @index = 0
+            end
+
+            private
+
+            def current_io
+              @ios[@index]
+            end
+
+            def advance_io
+              @index += 1
+            end
+          end
+
+          # Convenience methods for dealing with files and IO that are to be uploaded.
+          class UploadIO
+            attr_reader :content_type, :original_filename, :local_path, :io, :opts
+
+            # Create an upload IO suitable for including in the params hash of a
+            # Net::HTTP::Post::Multipart.
+            #
+            # Can take two forms. The first accepts a filename and content type, and
+            # opens the file for reading (to be closed by finalizer).
+            #
+            # The second accepts an already-open IO, but also requires a third argument,
+            # the filename from which it was opened (particularly useful/recommended if
+            # uploading directly from a form in a framework, which often save the file to
+            # an arbitrarily named RackMultipart file in /tmp).
+            #
+            # @example
+            #     UploadIO.new("file.txt", "text/plain")
+            #     UploadIO.new(file_io, "text/plain", "file.txt")
+            def initialize(filename_or_io, content_type, filename = nil, opts = {})
+              io = filename_or_io
+              local_path = ""
+              if io.respond_to? :read
+                # in Ruby 1.9.2, StringIOs no longer respond to path
+                # (since they respond to :length, so we don't need their local path, see parts.rb:41)
+                local_path = filename_or_io.respond_to?(:path) ? filename_or_io.path : "local.path"
+              else
+                io = File.open(filename_or_io)
+                local_path = filename_or_io
+              end
+              filename ||= local_path
+
+              @content_type = content_type
+              @original_filename = File.basename(filename)
+              @local_path = local_path
+              @io = io
+              @opts = opts
+            end
+
+            def self.convert!(io, content_type, original_filename, local_path)
+              raise ArgumentError, "convert! has been removed. You must now wrap IOs " \
+                "using:\nUploadIO.new(filename_or_io, content_type, " \
+                "filename=nil)\nPlease update your code."
+            end
+
+            def method_missing(*args)
+              @io.send(*args)
+            end
+
+            def respond_to?(meth, include_all = false)
+              @io.respond_to?(meth, include_all) || super(meth, include_all)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# typed: false
+
+#--
+# Copyright (c) 2007-2013 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+require 'datadog/core/vendor/multipart-post/multipart/post/parts'
+require 'datadog/core/vendor/multipart-post/multipart/post/composite_read_io'
+require 'securerandom'
+
+module Datadog
+  module Core
+    module Vendor
+      module Multipart
+        module Post
+          module Multipartable
+            def self.secure_boundary
+              # https://tools.ietf.org/html/rfc7230
+              #      tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+              #                     / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+              #                     / DIGIT / ALPHA
+
+              # https://tools.ietf.org/html/rfc2046
+              #      bcharsnospace := DIGIT / ALPHA / "'" / "(" / ")" /
+              #                       "+" / "_" / "," / "-" / "." /
+              #                       "/" / ":" / "=" / "?"
+
+              "--#{SecureRandom.uuid}"
+            end
+
+            def initialize(path, params, headers={}, boundary = Multipartable.secure_boundary)
+              headers = headers.clone # don't want to modify the original variable
+              parts_headers = headers.delete(:parts) || {}
+              super(path, headers)
+              parts = params.map do |k,v|
+                case v
+                when Array
+                  v.map {|item| Parts::Part.new(boundary, "#{k}[]", item, parts_headers[k]) }
+                else
+                  Parts::Part.new(boundary, k, v, parts_headers[k])
+                end
+              end.flatten
+              parts << Parts::EpiloguePart.new(boundary)
+              ios = parts.map {|p| p.to_io }
+              self.set_content_type(headers["Content-Type"] || "multipart/form-data",
+                                    { "boundary" => boundary })
+              self.content_length = parts.inject(0) {|sum,i| sum + i.length }
+              self.body_stream = CompositeReadIO.new(*ios)
+
+              @boundary = boundary
+            end
+
+            attr :boundary
+          end
+        end
+      end
+    end
+  end
+end