ddtrace 0.46.0 → 0.51.0

data/lib/ddtrace/transport/http.rb

@@ -1,8 +1,8 @@
 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'
@@ -25,11 +25,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,61 +50,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
+          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.'
+        )
+
+        Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS.port
+      end
 
-        if url_env
-          uri_parsed = URI.parse(url_env)
+      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.'
+        )
 
-          uri_parsed if %w[http https].include?(uri_parsed.scheme)
-        end
+        nil
       end
 
       # Add adapters to registry

data/lib/ddtrace/transport/http/adapters/net.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/transport/response'
+require 'ddtrace/vendor/multipart-post/net/http/post/multipart'
 
 module Datadog
   module Transport
@@ -9,14 +10,16 @@ module Datadog
           attr_reader \
             :hostname,
             :port,
-            :timeout
+            :timeout,
+            :ssl
 
-          DEFAULT_TIMEOUT = 1
+          DEFAULT_TIMEOUT = 30
 
           def initialize(hostname, port, options = {})
             @hostname = hostname
             @port = port
             @timeout = options[:timeout] || DEFAULT_TIMEOUT
+            @ssl = options.key?(:ssl) ? options[:ssl] == true : false
           end
 
           def open(&block)
@@ -25,6 +28,7 @@ module Datadog
             # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
             req = ::Net::HTTP.new(hostname, port, nil)
 
+            req.use_ssl = ssl
             req.open_timeout = req.read_timeout = timeout
 
             req.start(&block)
@@ -39,8 +43,18 @@ module Datadog
           end
 
           def post(env)
-            post = ::Net::HTTP::Post.new(env.path, env.headers)
-            post.body = env.body
+            post = nil
+
+            if env.form.nil? || env.form.empty?
+              post = ::Net::HTTP::Post.new(env.path, env.headers)
+              post.body = env.body
+            else
+              post = ::Datadog::Vendor::Net::HTTP::Post::Multipart.new(
+                env.path,
+                env.form,
+                env.headers
+              )
+            end
 
             # Connect and send the request
             http_response = open do |http|

data/lib/ddtrace/transport/http/builder.rb

@@ -95,7 +95,7 @@ module Datadog
               api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
 
               # Add API::Instance with all settings
-              instances[key] = API::Instance.new(
+              instances[key] = api_instance_class.new(
                 spec,
                 adapter,
                 api_options
@@ -107,6 +107,10 @@ module Datadog
           end
         end
 
+        def api_instance_class
+          API::Instance
+        end
+
         # Raised when the API key does not match known APIs.
         class UnknownApiError < StandardError
           attr_reader :key

data/lib/ddtrace/transport/http/env.rb

@@ -42,6 +42,14 @@ module Datadog
         def headers=(value)
           self[:headers] = value
         end
+
+        def form
+          self[:form] ||= {}
+        end
+
+        def form=(value)
+          self[:form] = value
+        end
       end
     end
   end

data/lib/ddtrace/transport/http/statistics.rb

@@ -6,8 +6,8 @@ module Datadog
       # Tracks statistics for HTTP transports
       module Statistics
         def self.included(base)
-          base.send(:include, Datadog::Transport::Statistics)
-          base.send(:include, InstanceMethods)
+          base.include(Datadog::Transport::Statistics)
+          base.include(InstanceMethods)
         end
 
         # Instance methods for HTTP statistics

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

@@ -133,9 +133,9 @@ module Datadog
         end
 
         # Add traces behavior to transport components
-        HTTP::Client.send(:include, Traces::Client)
-        HTTP::API::Spec.send(:include, Traces::API::Spec)
-        HTTP::API::Instance.send(:include, Traces::API::Instance)
+        HTTP::Client.include(Traces::Client)
+        HTTP::API::Spec.include(Traces::API::Spec)
+        HTTP::API::Instance.include(Traces::API::Instance)
       end
     end
   end

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

@@ -12,19 +12,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
@@ -48,8 +53,6 @@ module Datadog
           InternalErrorResponse.new(e)
         end
 
-        protected
-
         def encode_data(encoder, request)
           request.parcel.encode_with(encoder)
         end
@@ -58,17 +61,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

@@ -6,14 +6,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

@@ -10,6 +10,12 @@ 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
@@ -84,7 +90,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/parcel.rb

@@ -8,6 +8,10 @@ module Datadog
       def initialize(data)
         @data = data
       end
+
+      def encode_with(encoder)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/ddtrace/transport/traces.rb

@@ -123,7 +123,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)
 

data/lib/ddtrace/utils/compression.rb

@@ -0,0 +1,27 @@
+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/forking.rb

@@ -3,7 +3,7 @@ module Datadog
     # 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,39 @@
+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