ddtrace 0.45.0 → 0.52.0

data/lib/ddtrace/transport/http.rb

@@ -1,8 +1,9 @@
+# typed: true
 require 'ddtrace/version'
-require 'ddtrace/ext/runtime'
+require 'datadog/core/environment/ext'
 require 'ddtrace/ext/transport'
 
-require 'ddtrace/runtime/container'
+require 'datadog/core/environment/container'
 
 require 'ddtrace/transport/http/builder'
 require 'ddtrace/transport/http/api'
@@ -16,6 +17,8 @@ module Datadog
   module Transport
     # Namespace for HTTP transport components
     module HTTP
+      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
       module_function
 
       # Builds a new Transport::HTTP::Client
@@ -25,11 +28,23 @@ module Datadog
 
       # Builds a new Transport::HTTP::Client with default settings
       # Pass a block to override any settings.
-      def default(options = {})
+      def default(agent_settings: Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS, **options)
         new do |transport|
-          transport.adapter :net_http, default_hostname, default_port
+          transport.adapter(
+            default_adapter,
+            agent_settings.hostname,
+            agent_settings.port,
+            timeout: agent_settings.timeout_seconds,
+            ssl: agent_settings.ssl
+          )
           transport.headers default_headers
 
+          if agent_settings.deprecated_for_removal_transport_configuration_options
+            # The deprecated_for_removal_transport_configuration_options take precedence over any options the caller
+            # specifies
+            options = options.merge(**agent_settings.deprecated_for_removal_transport_configuration_options)
+          end
+
           apis = API.defaults
 
           transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
@@ -38,63 +53,61 @@ module Datadog
 
           # Apply any settings given by options
           unless options.empty?
-            # Change hostname/port
-            if options.key?(:hostname) || options.key?(:port)
-              hostname = options.fetch(:hostname, default_hostname)
-              port = options.fetch(:port, default_port)
-              transport.adapter :net_http, hostname, port
-            end
-
-            # Change default API
             transport.default_api = options[:api_version] if options.key?(:api_version)
-
-            # Add headers
             transport.headers options[:headers] if options.key?(:headers)
+          end
 
-            # Execute on_build callback
-            options[:on_build].call(transport) if options[:on_build].is_a?(Proc)
+          if agent_settings.deprecated_for_removal_transport_configuration_proc
+            agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
           end
 
-          # Call block to apply any customization, if provided.
+          # Call block to apply any customization, if provided
           yield(transport) if block_given?
         end
       end
 
       def default_headers
         {
-          Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Datadog::Ext::Runtime::LANG,
-          Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Datadog::Ext::Runtime::LANG_VERSION,
-          Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Datadog::Ext::Runtime::LANG_INTERPRETER,
-          Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Datadog::Ext::Runtime::TRACER_VERSION
+          Datadog::Ext::Transport::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+          Datadog::Ext::Transport::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+          Datadog::Ext::Transport::HTTP::HEADER_META_LANG_INTERPRETER => Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+          Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION => Datadog::Core::Environment::Ext::TRACER_VERSION
         }.tap do |headers|
           # Add container ID, if present.
-          container_id = Datadog::Runtime::Container.container_id
-          unless container_id.nil?
-            headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id
-          end
+          container_id = Datadog::Core::Environment::Container.container_id
+          headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
         end
       end
 
-      def default_hostname
-        return default_url.hostname if default_url
-
-        ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST, Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
+      def default_adapter
+        :net_http
       end
 
-      def default_port
-        return default_url.port if default_url
+      def default_hostname(logger: Datadog.logger)
+        logger.warn(
+          'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+          'be removed on a future ddtrace release.'
+        )
 
-        ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT, Datadog::Ext::Transport::HTTP::DEFAULT_PORT).to_i
+        Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS.hostname
       end
 
-      def default_url
-        url_env = ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL, nil)
+      def default_port(logger: Datadog.logger)
+        logger.warn(
+          'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+          'be removed on a future ddtrace release.'
+        )
 
-        if url_env
-          uri_parsed = URI.parse(url_env)
+        Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS.port
+      end
 
-          uri_parsed if %w[http https].include?(uri_parsed.scheme)
-        end
+      def default_url(logger: Datadog.logger)
+        logger.warn(
+          'Deprecated for removal: Using #default_url for configuration is deprecated and will ' \
+          'be removed on a future ddtrace release.'
+        )
+
+        nil
       end
 
       # Add adapters to registry

data/lib/ddtrace/transport/io/client.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/statistics'
 require 'ddtrace/transport/io/response'
 
@@ -12,19 +13,24 @@ module Datadog
           :encoder,
           :out
 
-        def initialize(out, encoder)
+        def initialize(out, encoder, options = {})
           @out = out
           @encoder = encoder
+
+          @request_block = options.fetch(:request, method(:send_default_request))
+          @encode_block = options.fetch(:encode, method(:encode_data))
+          @write_block = options.fetch(:write, method(:write_data))
+          @response_block = options.fetch(:response, method(:build_response))
         end
 
         def send_request(request)
           # Write data to IO
           # If block is given, allow it to handle writing
-          # Otherwise use default encoding.
+          # Otherwise do a standard encode/write/response.
           response = if block_given?
                        yield(out, request)
                      else
-                       send_default_request(out, request)
+                       @request_block.call(out, request)
                      end
 
           # Update statistics
@@ -33,7 +39,7 @@ module Datadog
           # Return response
           response
         rescue StandardError => e
-          message = "Internal error during IO transport request. Cause: #{e.message} Location: #{e.backtrace.first}"
+          message = "Internal error during IO transport request. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
 
           # Log error
           if stats.consecutive_errors > 0
@@ -48,8 +54,6 @@ module Datadog
           InternalErrorResponse.new(e)
         end
 
-        protected
-
         def encode_data(encoder, request)
           request.parcel.encode_with(encoder)
         end
@@ -58,17 +62,21 @@ module Datadog
           out.puts(data)
         end
 
+        def build_response(_request, _data, result)
+          IO::Response.new(result)
+        end
+
         private
 
         def send_default_request(out, request)
           # Encode data
-          data = encode_data(encoder, request)
+          data = @encode_block.call(encoder, request)
 
           # Write to IO
-          result = write_data(out, data)
+          result = @write_block.call(out, data)
 
           # Generate a response
-          IO::Response.new(result)
+          @response_block.call(request, data, result)
         end
       end
     end

data/lib/ddtrace/transport/io/response.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/response'
 
 module Datadog
@@ -6,14 +7,12 @@ module Datadog
       # Response from HTTP transport for traces
       class Response
         include Transport::Response
-        include Transport::Traces::Response
 
         attr_reader \
           :result
 
-        def initialize(result, trace_count = 1)
+        def initialize(result)
           @result = result
-          @trace_count = trace_count
         end
 
         def ok?

data/lib/ddtrace/transport/io/traces.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/transport/traces'
 
 require 'ddtrace/transport/io/response'
@@ -10,10 +11,18 @@ module Datadog
       module Traces
         # Response from HTTP transport for traces
         class Response < IO::Response
+          include Transport::Traces::Response
+
+          def initialize(result, trace_count = 1)
+            super(result)
+            @trace_count = trace_count
+          end
         end
 
         # Extensions for HTTP client
         module Client
+          include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
           def send_traces(traces)
             # Build a request
             req = Transport::Traces::Request.new(Parcel.new(traces))
@@ -84,7 +93,7 @@ module Datadog
         end
 
         # Add traces behavior to transport components
-        IO::Client.send(:include, Traces::Client)
+        IO::Client.include(Traces::Client)
       end
     end
   end

data/lib/ddtrace/transport/io.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/encoding'
 require 'ddtrace/transport/io/client'
 require 'ddtrace/transport/io/traces'
@@ -17,7 +18,7 @@ module Datadog
       # Pass options to override any settings.
       def default(options = {})
         new(
-          options.fetch(:out, STDOUT),
+          options.fetch(:out, $stdout),
           options.fetch(:encoder, Encoding::JSONEncoder)
         )
       end

data/lib/ddtrace/transport/parcel.rb

@@ -1,13 +1,20 @@
+# typed: true
 module Datadog
   module Transport
     # Data transfer object for generic data
     module Parcel
+      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
       attr_reader \
         :data
 
       def initialize(data)
         @data = data
       end
+
+      def encode_with(encoder)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/ddtrace/transport/request.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Transport
     # Defines request for transport operations

data/lib/ddtrace/transport/response.rb

@@ -1,3 +1,4 @@
+# typed: false
 module Datadog
   module Transport
     # Defines abstract response for transport operations

data/lib/ddtrace/transport/statistics.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/diagnostics/health'
 
 module Datadog

data/lib/ddtrace/transport/traces.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/transport/parcel'
 require 'ddtrace/transport/request'
 require 'ddtrace/chunker'
@@ -7,7 +8,7 @@ module Datadog
     module Traces
       # Data transfer object for encoded traces
       class EncodedParcel
-        include Transport::Parcel
+        include Datadog::Transport::Parcel
 
         attr_reader :trace_count
 
@@ -22,7 +23,7 @@ module Datadog
       end
 
       # Traces request
-      class Request < Transport::Request
+      class Request < Datadog::Transport::Request
       end
 
       # Traces response
@@ -123,7 +124,21 @@ module Datadog
                 return send_traces(traces)
               end
             end
-          end.force
+          end
+
+          # Force resolution of lazy enumerator.
+          #
+          # The "correct" method to call here would be `#force`,
+          # as this method was created to force the eager loading
+          # of a lazy enumerator.
+          #
+          # Unfortunately, JRuby < 9.2.9.0 erroneously eagerly loads
+          # the lazy Enumerator during intermediate steps.
+          # This forces us to use `#to_a`, as this method works for both
+          # lazy and regular Enumerators.
+          # Using `#to_a` can mask the fact that we expect a lazy
+          # Enumerator.
+          responses = responses.to_a
 
           Datadog.health_metrics.transport_chunked(responses.size)
 
@@ -142,17 +157,20 @@ module Datadog
 
         def downgrade?(response)
           return false unless apis.fallbacks.key?(@current_api_id)
+
           response.not_found? || response.unsupported?
         end
 
         def downgrade!
           downgrade_api_id = apis.fallbacks[@current_api_id]
           raise NoDowngradeAvailableError, @current_api_id if downgrade_api_id.nil?
+
           change_api!(downgrade_api_id)
         end
 
         def change_api!(api_id)
           raise UnknownApiVersionError, api_id unless apis.key?(api_id)
+
           @current_api_id = api_id
           @client = HTTP::Client.new(current_api)
         end

data/lib/ddtrace/utils/compression.rb

@@ -0,0 +1,28 @@
+# typed: true
+require 'zlib'
+
+module Datadog
+  module Utils
+    # Common database-related utility functions.
+    module Compression
+      module_function
+
+      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
+
+      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

data/lib/ddtrace/utils/database.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Utils
     # Common database-related utility functions.

data/lib/ddtrace/utils/forking.rb

@@ -1,9 +1,10 @@
+# typed: false
 module Datadog
   module Utils
     # Helper methods for managing forking behavior
     module Forking
       def self.included(base)
-        base.send(:prepend, ClassExtensions) if base.is_a?(Class)
+        base.prepend(ClassExtensions) if base.is_a?(Class)
       end
 
       def self.extended(base)

data/lib/ddtrace/utils/object_set.rb

@@ -0,0 +1,40 @@
+# typed: true
+require 'ddtrace/utils/sequence'
+
+module Datadog
+  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 = Utils::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

data/lib/ddtrace/utils/only_once.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module Datadog
+  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

data/lib/ddtrace/utils/sequence.rb

@@ -0,0 +1,18 @@
+# typed: true
+module Datadog
+  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

data/lib/ddtrace/utils/string_table.rb

@@ -0,0 +1,46 @@
+# typed: true
+require 'ddtrace/utils/sequence'
+
+module Datadog
+  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

data/lib/ddtrace/utils/time.rb

@@ -1,13 +1,45 @@
+# typed: true
 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')
+      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
 
       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) : ::Time.now.to_f
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      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

data/lib/ddtrace/utils.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/utils/database'
 require 'ddtrace/utils/forking'
 
@@ -11,10 +12,11 @@ module Datadog
     # with the default one. Using the default prng, we could break code that
     # would rely on srand/rand sequences.
 
-    # Return a span id
+    # 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(Datadog::Span::RUBY_MAX_ID)
+      id_rng.rand(Datadog::Span::RUBY_MAX_ID) # TODO: This should never return zero
     end
 
     def self.id_rng
@@ -27,6 +29,14 @@ module Datadog
 
     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.
     def self.truncate(value, size, omission = '...'.freeze)
       string = value.to_s
 
@@ -43,6 +53,8 @@ module Datadog
       string
     end
 
+    # Ensure `str` is a valid UTF-8, ready to be
+    # sent through the tracer transport.
     def self.utf8_encode(str, options = {})
       str = str.to_s