ddtrace 0.52.0 → 1.8.0

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

@@ -0,0 +1,49 @@
+# typed: true
+
+require_relative '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(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.rb

@@ -0,0 +1,94 @@
+# typed: true
+
+require_relative 'utils/forking'
+
+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
+
+      # 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_relative 'parts'
+require_relative '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

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

@@ -0,0 +1,139 @@
+# typed: true
+
+#--
+# Copyright (c) 2007-2013 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+module Datadog
+  module Core
+    module Vendor
+      module Multipart
+        module Post
+          module Parts
+            module Part
+              def self.new(boundary, name, value, headers = {})
+                headers ||= {} # avoid nil values
+                if file?(value)
+                  FilePart.new(boundary, name, value, headers)
+                else
+                  ParamPart.new(boundary, name, value, headers)
+                end
+              end
+
+              def self.file?(value)
+                value.respond_to?(:content_type) && value.respond_to?(:original_filename)
+              end
+
+              def length
+                @part.length
+              end
+
+              def to_io
+                @io
+              end
+            end
+
+            # Represents a parametric part to be filled with given value.
+            class ParamPart
+              include Part
+
+              # @param boundary [String]
+              # @param name [#to_s]
+              # @param value [String]
+              # @param headers [Hash] Content-Type and Content-ID are used, if present.
+              def initialize(boundary, name, value, headers = {})
+                @part = build_part(boundary, name, value, headers)
+                @io = StringIO.new(@part)
+              end
+
+              def length
+                @part.bytesize
+              end
+
+              # @param boundary [String]
+              # @param name [#to_s]
+              # @param value [String]
+              # @param headers [Hash] Content-Type is used, if present.
+              def build_part(boundary, name, value, headers = {})
+                part = ''
+                part << "--#{boundary}\r\n"
+                part << "Content-ID: #{headers["Content-ID"]}\r\n" if headers["Content-ID"]
+                part << "Content-Disposition: form-data; name=\"#{name.to_s}\"\r\n"
+                part << "Content-Type: #{headers["Content-Type"]}\r\n" if headers["Content-Type"]
+                part << "\r\n"
+                part << "#{value}\r\n"
+              end
+            end
+
+            # Represents a part to be filled from file IO.
+            class FilePart
+              include Part
+
+              attr_reader :length
+
+              # @param boundary [String]
+              # @param name [#to_s]
+              # @param io [IO]
+              # @param headers [Hash]
+              def initialize(boundary, name, io, headers = {})
+                file_length = io.respond_to?(:length) ?  io.length : File.size(io.local_path)
+                @head = build_head(boundary, name, io.original_filename, io.content_type, file_length,
+                                  io.respond_to?(:opts) ? io.opts.merge(headers) : headers)
+                @foot = "\r\n"
+                @length = @head.bytesize + file_length + @foot.length
+                @io = CompositeReadIO.new(StringIO.new(@head), io, StringIO.new(@foot))
+              end
+
+              # @param boundary [String]
+              # @param name [#to_s]
+              # @param filename [String]
+              # @param type [String]
+              # @param content_len [Integer]
+              # @param opts [Hash]
+              def build_head(boundary, name, filename, type, content_len, opts = {})
+                opts = opts.clone
+
+                trans_encoding = opts.delete("Content-Transfer-Encoding") || "binary"
+                content_disposition = opts.delete("Content-Disposition") || "form-data"
+
+                part = ''
+                part << "--#{boundary}\r\n"
+                part << "Content-Disposition: #{content_disposition}; name=\"#{name.to_s}\"; filename=\"#{filename}\"\r\n"
+                part << "Content-Length: #{content_len}\r\n"
+                if content_id = opts.delete("Content-ID")
+                  part << "Content-ID: #{content_id}\r\n"
+                end
+
+                if opts["Content-Type"] != nil
+                  part <<  "Content-Type: " + opts["Content-Type"] + "\r\n"
+                else
+                  part << "Content-Type: #{type}\r\n"
+                end
+
+                part << "Content-Transfer-Encoding: #{trans_encoding}\r\n"
+
+                opts.each do |k, v|
+                  part << "#{k}: #{v}\r\n"
+                end
+
+                part << "\r\n"
+              end
+            end
+
+            # Represents the epilogue or closing boundary.
+            class EpiloguePart
+              include Part
+
+              def initialize(boundary)
+                @part = "--#{boundary}--\r\n"
+                @io = StringIO.new(@part)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# typed: strict
+
+module Datadog
+  module Core
+    module Vendor
+      module Multipart
+        module Post
+          VERSION = "2.1.1"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# typed: strict
+
+module Datadog
+  module Core
+    module Vendor
+      module Multipart
+        module Post
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# typed: strict
+
+#--
+# Copyright (c) 2007-2013 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+module Datadog
+  module Core
+    module Vendor
+      module Multipart
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strict
+
+#--
+# Copyright (c) 2007-2012 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+require 'net/http'
+require 'stringio'
+require 'cgi'
+require_relative '../../../multipart/post/parts'
+require_relative '../../../multipart/post/composite_read_io'
+require_relative '../../../multipart/post/multipartable'
+
+module Datadog
+  module Core
+    module Vendor
+      module Net
+        class HTTP
+          class Put
+            class Multipart < ::Net::HTTP::Put
+              include Vendor::Multipart::Post::Multipartable
+            end
+          end
+
+          class Post
+            class Multipart < ::Net::HTTP::Post
+              include Vendor::Multipart::Post::Multipartable
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/worker.rb

@@ -0,0 +1,24 @@
+# typed: true
+
+module Datadog
+  module Core
+    # Base class for work tasks
+    class Worker
+      attr_reader \
+        :task
+
+      def initialize(&block)
+        @task = block
+      end
+
+      def perform(*args)
+        task.call(*args) unless task.nil?
+      end
+
+      protected
+
+      attr_writer \
+        :task
+    end
+  end
+end