ddtrace 0.49.0 → 1.12.1

data/lib/ddtrace/utils/time.rb

@@ -1,45 +0,0 @@
-module Datadog
-  module Utils
-    # Common database-related utility functions.
-    module Time
-      PROCESS_TIME_SUPPORTED = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1.0')
-
-      module_function
-
-      # Current monotonic time.
-      # Falls back to `now` if monotonic clock
-      # is not available.
-      #
-      # @return [Float] in seconds, since some unspecified starting point
-      def get_time
-        PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : now.to_f
-      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
-    end
-  end
-end

data/lib/ddtrace/utils.rb

@@ -1,68 +0,0 @@
-require 'ddtrace/utils/database'
-require 'ddtrace/utils/forking'
-
-module Datadog
-  # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
-  module Utils
-    extend Utils::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 span id
-    def self.next_id
-      after_fork! { reset! }
-      id_rng.rand(Datadog::Span::RUBY_MAX_ID)
-    end
-
-    def self.id_rng
-      @id_rng ||= Random.new
-    end
-
-    def self.reset!
-      @id_rng = Random.new
-    end
-
-    private_class_method :id_rng, :reset!
-
-    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
-
-    def self.utf8_encode(str, options = {})
-      str = str.to_s
-
-      if options[: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}")
-
-      options.fetch(:placeholder, EMPTY_STRING)
-    end
-  end
-end

data/lib/ddtrace/vendor/active_record/connection_specification.rb

@@ -1,301 +0,0 @@
-require 'uri'
-
-# NOTE: This code is copied directly from ActiveRecord.
-#       Its purpose is to resolve connection information.
-#       It exists here only because it doesn't exist in Rails 3.2.
-#       When support for Rails 3.2 is dropped, this can be removed.
-module Datadog
-  module Vendor
-    module ActiveRecord
-      # Copy/paste from:
-      # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_handling.rb
-      module ConnectionHandling
-        RAILS_ENV = -> { (Rails.env if defined?(Rails) && defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
-      end
-
-      # Copy/paste from:
-      # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_adapters/connection_specification.rb
-      module ConnectionAdapters
-        class ConnectionSpecification
-          attr_reader :name, :config, :adapter_method
-
-          def initialize(name, config, adapter_method)
-            @name, @config, @adapter_method = name, config, adapter_method
-          end
-
-          def initialize_dup(original)
-            @config = original.config.dup
-          end
-
-          def to_hash
-            @config.merge(name: @name)
-          end
-
-          # Expands a connection string into a hash.
-          class ConnectionUrlResolver # :nodoc:
-            # == Example
-            #
-            #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
-            #   ConnectionUrlResolver.new(url).to_hash
-            #   # => {
-            #     "adapter"  => "postgresql",
-            #     "host"     => "localhost",
-            #     "port"     => 9000,
-            #     "database" => "foo_test",
-            #     "username" => "foo",
-            #     "password" => "bar",
-            #     "pool"     => "5",
-            #     "timeout"  => "3000"
-            #   }
-            def initialize(url)
-              raise "Database URL cannot be empty" if url.blank?
-              @uri     = uri_parser.parse(url)
-              @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
-              @adapter = "postgresql" if @adapter == "postgres"
-
-              if @uri.opaque
-                @uri.opaque, @query = @uri.opaque.split("?", 2)
-              else
-                @query = @uri.query
-              end
-            end
-
-            # Converts the given URL to a full connection hash.
-            def to_hash
-              config = raw_config.reject { |_, value| value.blank? }
-              config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
-              config
-            end
-
-            private
-
-              def uri
-                @uri
-              end
-
-              def uri_parser
-                @uri_parser ||= URI::Parser.new
-              end
-
-              # Converts the query parameters of the URI into a hash.
-              #
-              #   "localhost?pool=5&reaping_frequency=2"
-              #   # => { "pool" => "5", "reaping_frequency" => "2" }
-              #
-              # returns empty hash if no query present.
-              #
-              #   "localhost"
-              #   # => {}
-              def query_hash
-                Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
-              end
-
-              def raw_config
-                if uri.opaque
-                  query_hash.merge(
-                    "adapter"  => @adapter,
-                    "database" => uri.opaque)
-                else
-                  query_hash.merge(
-                    "adapter"  => @adapter,
-                    "username" => uri.user,
-                    "password" => uri.password,
-                    "port"     => uri.port,
-                    "database" => database_from_path,
-                    "host"     => uri.hostname)
-                end
-              end
-
-              # Returns name of the database.
-              def database_from_path
-                if @adapter == "sqlite3"
-                  # 'sqlite3:/foo' is absolute, because that makes sense. The
-                  # corresponding relative version, 'sqlite3:foo', is handled
-                  # elsewhere, as an "opaque".
-
-                  uri.path
-                else
-                  # Only SQLite uses a filename as the "database" name; for
-                  # anything else, a leading slash would be silly.
-
-                  uri.path.sub(%r{^/}, "")
-                end
-              end
-          end
-
-          ##
-          # Builds a ConnectionSpecification from user input.
-          class Resolver # :nodoc:
-            attr_reader :configurations
-
-            # Accepts a hash two layers deep, keys on the first layer represent
-            # environments such as "production". Keys must be strings.
-            def initialize(configurations)
-              @configurations = configurations
-            end
-
-            # Returns a hash with database connection information.
-            #
-            # == Examples
-            #
-            # Full hash Configuration.
-            #
-            #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-            #   Resolver.new(configurations).resolve(:production)
-            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
-            #
-            # Initialized with URL configuration strings.
-            #
-            #   configurations = { "production" => "postgresql://localhost/foo" }
-            #   Resolver.new(configurations).resolve(:production)
-            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-            #
-            def resolve(config)
-              if config
-                resolve_connection config
-              elsif env = ConnectionHandling::RAILS_ENV.call
-                resolve_symbol_connection env.to_sym
-              else
-                raise AdapterNotSpecified
-              end
-            end
-
-            # Expands each key in @configurations hash into fully resolved hash
-            def resolve_all
-              config = configurations.dup
-
-              if env = ConnectionHandling::DEFAULT_ENV.call
-                env_config = config[env] if config[env].is_a?(Hash) && !(config[env].key?("adapter") || config[env].key?("url"))
-              end
-
-              config.reject! { |k, v| v.is_a?(Hash) && !(v.key?("adapter") || v.key?("url")) }
-              config.merge! env_config if env_config
-
-              config.each do |key, value|
-                config[key] = resolve(value) if value
-              end
-
-              config
-            end
-
-            # Returns an instance of ConnectionSpecification for a given adapter.
-            # Accepts a hash one layer deep that contains all connection information.
-            #
-            # == Example
-            #
-            #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
-            #   spec = Resolver.new(config).spec(:production)
-            #   spec.adapter_method
-            #   # => "sqlite3_connection"
-            #   spec.config
-            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
-            #
-            def spec(config)
-              spec = resolve(config).symbolize_keys
-
-              raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
-
-              # Require the adapter itself and give useful feedback about
-              #   1. Missing adapter gems and
-              #   2. Adapter gems' missing dependencies.
-              path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-              begin
-                require path_to_adapter
-              rescue LoadError => e
-                # We couldn't require the adapter itself. Raise an exception that
-                # points out config typos and missing gems.
-                if e.path == path_to_adapter
-                  # We can assume that a non-builtin adapter was specified, so it's
-                  # either misspelled or missing from Gemfile.
-                  raise e.class, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
-
-                # Bubbled up from the adapter require. Prefix the exception message
-                # with some guidance about how to address it and reraise.
-                else
-                  raise e.class, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
-                end
-              end
-
-              adapter_method = "#{spec[:adapter]}_connection"
-
-              unless ::ActiveRecord::Base.respond_to?(adapter_method)
-                raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-              end
-
-              ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
-            end
-
-            private
-
-              # Returns fully resolved connection, accepts hash, string or symbol.
-              # Always returns a hash.
-              #
-              # == Examples
-              #
-              # Symbol representing current environment.
-              #
-              #   Resolver.new("production" => {}).resolve_connection(:production)
-              #   # => {}
-              #
-              # One layer deep hash of connection values.
-              #
-              #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
-              #   # => { "adapter" => "sqlite3" }
-              #
-              # Connection URL.
-              #
-              #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
-              #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-              #
-              def resolve_connection(spec)
-                case spec
-                when Symbol
-                  resolve_symbol_connection spec
-                when String
-                  resolve_url_connection spec
-                when Hash
-                  resolve_hash_connection spec
-                end
-              end
-
-              # Takes the environment such as +:production+ or +:development+.
-              # This requires that the @configurations was initialized with a key that
-              # matches.
-              #
-              #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
-              #   # => {}
-              #
-              def resolve_symbol_connection(spec)
-                if config = configurations[spec.to_s]
-                  resolve_connection(config).merge("name" => spec.to_s)
-                else
-                  raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
-                end
-              end
-
-              # Accepts a hash. Expands the "url" key that contains a
-              # URL database connection to a full connection
-              # hash and merges with the rest of the hash.
-              # Connection details inside of the "url" key win any merge conflicts
-              def resolve_hash_connection(spec)
-                if spec["url"] && spec["url"] !~ /^jdbc:/
-                  connection_hash = resolve_url_connection(spec.delete("url"))
-                  spec.merge!(connection_hash)
-                end
-                spec
-              end
-
-              # Takes a connection URL.
-              #
-              #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
-              #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-              #
-              def resolve_url_connection(url)
-                ConnectionUrlResolver.new(url).to_hash
-              end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/vendor/multipart-post/multipart/post/composite_read_io.rb

@@ -1,116 +0,0 @@
-#--
-# 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 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

data/lib/ddtrace/vendor/multipart-post/multipart/post/multipartable.rb

@@ -1,57 +0,0 @@
-#--
-# Copyright (c) 2007-2013 Nick Sieger.
-# See the file README.txt included with the distribution for
-# software license details.
-#++
-
-require 'ddtrace/vendor/multipart-post/multipart/post/parts'
-require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
-require 'securerandom'
-
-module Datadog
-  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