ddtrace 0.50.0 → 1.0.0

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

@@ -1,4 +1,6 @@
-require 'ddtrace/encoding'
+# typed: false
+
+require 'datadog/core/encoding'
 
 require 'ddtrace/transport/http/api/map'
 require 'ddtrace/transport/http/api/spec'
@@ -13,7 +15,6 @@ module Datadog
         # Default API versions
         V4 = 'v0.4'.freeze
         V3 = 'v0.3'.freeze
-        V2 = 'v0.2'.freeze
 
         module_function
 
@@ -22,23 +23,17 @@ module Datadog
             V4 => Spec.new do |s|
               s.traces = Traces::API::Endpoint.new(
                 '/v0.4/traces'.freeze,
-                Encoding::MsgpackEncoder,
+                Core::Encoding::MsgpackEncoder,
                 service_rates: true
               )
             end,
             V3 => Spec.new do |s|
               s.traces = Traces::API::Endpoint.new(
                 '/v0.3/traces'.freeze,
-                Encoding::MsgpackEncoder
+                Core::Encoding::MsgpackEncoder
               )
             end,
-            V2 => Spec.new do |s|
-              s.traces = Traces::API::Endpoint.new(
-                '/v0.2/traces'.freeze,
-                Encoding::JSONEncoder
-              )
-            end
-          ].with_fallbacks(V4 => V3, V3 => V2)
+          ].with_fallbacks(V4 => V3)
         end
       end
     end

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

@@ -1,3 +1,6 @@
+# typed: true
+
+require 'datadog/core/configuration/agent_settings_resolver'
 require 'ddtrace/transport/http/adapters/registry'
 require 'ddtrace/transport/http/api/map'
 require 'ddtrace/transport/http/api/instance'
@@ -32,14 +35,20 @@ module Datadog
           yield(self) if block_given?
         end
 
-        def adapter(type, *args)
-          @default_adapter = if type.is_a?(Symbol)
-                               registry_klass = REGISTRY.get(type)
-                               raise UnknownAdapterError, type if registry_klass.nil?
+        def adapter(config, *args, **kwargs)
+          @default_adapter = case config
+                             when Core::Configuration::AgentSettingsResolver::AgentSettings
+                               registry_klass = REGISTRY.get(config.adapter)
+                               raise UnknownAdapterError, config.adapter if registry_klass.nil?
+
+                               registry_klass.build(config)
+                             when Symbol
+                               registry_klass = REGISTRY.get(config)
+                               raise UnknownAdapterError, config if registry_klass.nil?
 
-                               registry_klass.new(*args)
+                               registry_klass.new(*args, **kwargs)
                              else
-                               type
+                               config
                              end
         end
 

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

@@ -1,3 +1,5 @@
+# typed: true
+
 require 'ddtrace/transport/http/statistics'
 require 'ddtrace/transport/http/env'
 
@@ -26,7 +28,8 @@ module Datadog
 
           response
         rescue StandardError => e
-          message = "Internal error during HTTP transport request. Cause: #{e.message} Location: #{e.backtrace.first}"
+          message =
+            "Internal error during HTTP transport request. Cause: #{e.message} Location: #{Array(e.backtrace).first}"
 
           # Log error
           if stats.consecutive_errors > 0

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

@@ -1,3 +1,5 @@
+# typed: true
+
 module Datadog
   module Transport
     module HTTP

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

@@ -1,3 +1,5 @@
+# typed: false
+
 require 'forwardable'
 require 'ddtrace/transport/response'
 

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

@@ -1,3 +1,5 @@
+# typed: true
+
 require 'ddtrace/transport/statistics'
 
 module Datadog

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

@@ -1,8 +1,12 @@
+# typed: false
+
 require 'json'
 
 require 'ddtrace/transport/traces'
+require 'ddtrace/transport/http/client'
 require 'ddtrace/transport/http/response'
 require 'ddtrace/transport/http/api/endpoint'
+require 'ddtrace/transport/http/api/instance'
 
 module Datadog
   module Transport

data/lib/ddtrace/transport/http.rb

@@ -1,21 +1,33 @@
-require 'ddtrace/version'
-require 'ddtrace/ext/runtime'
-require 'ddtrace/ext/transport'
-
-require 'ddtrace/runtime/container'
+# typed: true
 
-require 'ddtrace/transport/http/builder'
-require 'ddtrace/transport/http/api'
+require 'uri'
 
+require 'datadog/core/environment/container'
+require 'datadog/core/environment/ext'
+require 'ddtrace/transport/ext'
 require 'ddtrace/transport/http/adapters/net'
 require 'ddtrace/transport/http/adapters/test'
 require 'ddtrace/transport/http/adapters/unix_socket'
-require 'uri'
+require 'ddtrace/transport/http/api'
+require 'ddtrace/transport/http/builder'
+require 'ddtrace/version'
 
 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)
+
+      # NOTE: Due to... legacy reasons... This class likes having a default `AgentSettings` instance to fall back to.
+      # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
+      # represents only settings specified via environment variables + the usual defaults.
+      #
+      # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
+      DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
+        Datadog::Core::Configuration::Settings.new,
+        logger: nil,
+      )
+
       module_function
 
       # Builds a new Transport::HTTP::Client
@@ -25,28 +37,18 @@ module Datadog
 
       # Builds a new Transport::HTTP::Client with default settings
       # Pass a block to override any settings.
-      def default(agent_settings: Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS, **options)
+      def default(
+        agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+        **options
+      )
         new do |transport|
-          transport.adapter(
-            default_adapter,
-            agent_settings.hostname,
-            agent_settings.port,
-            timeout: agent_settings.timeout_seconds,
-            ssl: agent_settings.ssl
-          )
+          transport.adapter(agent_settings)
           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
-          transport.api API::V3, apis[API::V3], fallback: API::V2
-          transport.api API::V2, apis[API::V2]
+          transport.api API::V3, apis[API::V3]
 
           # Apply any settings given by options
           unless options.empty?
@@ -65,19 +67,19 @@ module Datadog
 
       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::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+          Datadog::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+          Datadog::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER => Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+          Datadog::Transport::Ext::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
-          headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          container_id = Datadog::Core::Environment::Container.container_id
+          headers[Datadog::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
         end
       end
 
       def default_adapter
-        :net_http
+        Transport::Ext::HTTP::ADAPTER
       end
 
       def default_hostname(logger: Datadog.logger)
@@ -86,7 +88,7 @@ module Datadog
           'be removed on a future ddtrace release.'
         )
 
-        Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS.hostname
+        DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
       end
 
       def default_port(logger: Datadog.logger)
@@ -95,7 +97,7 @@ module Datadog
           'be removed on a future ddtrace release.'
         )
 
-        Datadog::Configuration::AgentSettingsResolver::ENVIRONMENT_AGENT_SETTINGS.port
+        DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
       end
 
       def default_url(logger: Datadog.logger)
@@ -108,9 +110,9 @@ module Datadog
       end
 
       # Add adapters to registry
-      Builder::REGISTRY.set(Adapters::Net, :net_http)
-      Builder::REGISTRY.set(Adapters::Test, :test)
-      Builder::REGISTRY.set(Adapters::UnixSocket, :unix)
+      Builder::REGISTRY.set(Adapters::Net, Transport::Ext::HTTP::ADAPTER)
+      Builder::REGISTRY.set(Adapters::Test, Transport::Ext::Test::ADAPTER)
+      Builder::REGISTRY.set(Adapters::UnixSocket, Transport::Ext::UnixSocket::ADAPTER)
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# typed: true
+
 require 'ddtrace/transport/statistics'
 require 'ddtrace/transport/io/response'
 
@@ -38,7 +40,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

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

@@ -1,3 +1,5 @@
+# typed: true
+
 require 'ddtrace/transport/response'
 
 module Datadog

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

@@ -1,3 +1,5 @@
+# typed: false
+
 require 'ddtrace/transport/traces'
 
 require 'ddtrace/transport/io/response'
@@ -20,6 +22,8 @@ module Datadog
 
         # 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))
@@ -64,7 +68,7 @@ module Datadog
 
           def encode_trace(trace)
             # Convert each trace to hash
-            trace.map(&:to_hash).tap do |spans|
+            trace.spans.map(&:to_hash).tap do |spans|
               # Convert IDs to hexadecimal
               spans.each do |span|
                 ENCODED_IDS.each do |id|

data/lib/ddtrace/transport/io.rb

@@ -1,4 +1,6 @@
-require 'ddtrace/encoding'
+# typed: true
+
+require 'datadog/core/encoding'
 require 'ddtrace/transport/io/client'
 require 'ddtrace/transport/io/traces'
 
@@ -18,7 +20,7 @@ module Datadog
       def default(options = {})
         new(
           options.fetch(:out, $stdout),
-          options.fetch(:encoder, Encoding::JSONEncoder)
+          options.fetch(:encoder, Core::Encoding::JSONEncoder)
         )
       end
     end

data/lib/ddtrace/transport/parcel.rb

@@ -1,7 +1,12 @@
+# typed: true
+
 module Datadog
   module Transport
     # Data transfer object for generic data
+    # @abstract
     module Parcel
+      include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
       attr_reader \
         :data
 

data/lib/ddtrace/transport/request.rb

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

data/lib/ddtrace/transport/response.rb

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

data/lib/ddtrace/transport/serializable_trace.rb

@@ -0,0 +1,118 @@
+# typed: true
+
+require 'json'
+require 'msgpack'
+
+module Datadog
+  module Transport
+    # Adds serialization functions to a {Datadog::TraceSegment}
+    class SerializableTrace
+      attr_reader \
+        :trace
+
+      def initialize(trace)
+        @trace = trace
+      end
+
+      # MessagePack serializer interface. Making this object
+      # respond to `#to_msgpack` allows it to be automatically
+      # serialized by MessagePack.
+      #
+      # This is more efficient than doing +MessagePack.pack(span.to_hash)+
+      # as we don't have to create an intermediate Hash.
+      #
+      # @param packer [MessagePack::Packer] serialization buffer, can be +nil+ with JRuby
+      def to_msgpack(packer = nil)
+        # As of 1.3.3, JRuby implementation doesn't pass an existing packer
+        trace.spans.map { |s| SerializableSpan.new(s) }.to_msgpack(packer)
+      end
+
+      # JSON serializer interface.
+      # Used by older version of the transport.
+      def to_json(*args)
+        trace.spans.map(&:to_hash).to_json(*args)
+      end
+    end
+
+    # Adds serialization functions to a {Datadog::Span}
+    class SerializableSpan
+      attr_reader \
+        :span
+
+      def initialize(span)
+        @span = span
+      end
+
+      # MessagePack serializer interface. Making this object
+      # respond to `#to_msgpack` allows it to be automatically
+      # serialized by MessagePack.
+      #
+      # This is more efficient than doing +MessagePack.pack(span.to_hash)+
+      # as we don't have to create an intermediate Hash.
+      #
+      # @param packer [MessagePack::Packer] serialization buffer, can be +nil+ with JRuby
+      # rubocop:disable Metrics/AbcSize
+      def to_msgpack(packer = nil)
+        packer ||= MessagePack::Packer.new
+
+        number_of_elements_to_write = 10
+
+        if span.stopped?
+          packer.write_map_header(number_of_elements_to_write + 2) # Set header with how many elements in the map
+
+          packer.write('start')
+          packer.write(time_nano(span.start_time))
+
+          packer.write('duration')
+          packer.write(duration_nano(span.duration))
+        else
+          packer.write_map_header(number_of_elements_to_write) # Set header with how many elements in the map
+        end
+
+        # DEV: We use strings as keys here, instead of symbols, as
+        # DEV: MessagePack will ultimately convert them to strings.
+        # DEV: By providing strings directly, we skip this indirection operation.
+        packer.write('span_id')
+        packer.write(span.id)
+        packer.write('parent_id')
+        packer.write(span.parent_id)
+        packer.write('trace_id')
+        packer.write(span.trace_id)
+        packer.write('name')
+        packer.write(span.name)
+        packer.write('service')
+        packer.write(span.service)
+        packer.write('resource')
+        packer.write(span.resource)
+        packer.write('type')
+        packer.write(span.type)
+        packer.write('meta')
+        packer.write(span.meta)
+        packer.write('metrics')
+        packer.write(span.metrics)
+        packer.write('error')
+        packer.write(span.status)
+        packer
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # JSON serializer interface.
+      # Used by older version of the transport.
+      def to_json(*args)
+        span.to_hash.to_json(*args)
+      end
+
+      # Used for serialization
+      # @return [Integer] in nanoseconds since Epoch
+      def time_nano(time)
+        time.to_i * 1000000000 + time.nsec
+      end
+
+      # Used for serialization
+      # @return [Integer] in nanoseconds since Epoch
+      def duration_nano(duration)
+        (duration * 1e9).to_i
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/statistics.rb

@@ -1,4 +1,7 @@
-require 'ddtrace/diagnostics/health'
+# typed: true
+
+require 'datadog/core/metrics/metric'
+require 'datadog/core/diagnostics/health'
 
 module Datadog
   module Transport
@@ -27,8 +30,8 @@ module Datadog
 
       def metrics_for_response(response)
         {}.tap do |metrics|
-          metrics[:api_errors] = Metrics::Metric.new(:api_errors, nil, 1) if response.internal_error?
-          metrics[:api_responses] = Metrics::Metric.new(:api_responses, nil, 1) unless response.internal_error?
+          metrics[:api_errors] = Core::Metrics::Metric.new(:api_errors, nil, 1) if response.internal_error?
+          metrics[:api_responses] = Core::Metrics::Metric.new(:api_responses, nil, 1) unless response.internal_error?
         end
       end
 
@@ -43,7 +46,7 @@ module Datadog
       end
 
       def metrics_for_exception(_exception)
-        { api_errors: Metrics::Metric.new(:api_errors, nil, 1) }
+        { api_errors: Core::Metrics::Metric.new(:api_errors, nil, 1) }
       end
 
       # Stat counts

data/lib/ddtrace/transport/trace_formatter.rb

@@ -0,0 +1,187 @@
+# typed: true
+
+require 'datadog/core/environment/identity'
+require 'datadog/core/environment/socket'
+require 'datadog/core/runtime/ext'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/trace_segment'
+
+module Datadog
+  module Transport
+    # Prepares traces for transport
+    class TraceFormatter
+      attr_reader \
+        :root_span,
+        :trace
+
+      def self.format!(trace)
+        new(trace).format!
+      end
+
+      def initialize(trace)
+        @trace = trace
+        @root_span = find_root_span(trace)
+      end
+
+      # Modifies a trace so suitable for transport
+      def format!
+        return unless trace
+        return trace unless root_span
+
+        # Because the trace API does not support
+        # trace metadata, we must put our trace
+        # metadata on the root span. This "root span"
+        # is needed by the agent/API to ingest the trace.
+
+        # Apply generic trace tags. Any more specific value will be overridden
+        # by the subsequent calls below.
+        set_trace_tags!
+
+        set_resource!
+
+        tag_agent_sample_rate!
+        tag_hostname!
+        tag_lang!
+        tag_origin!
+        tag_process_id!
+        tag_rule_sample_rate!
+        tag_runtime_id!
+        tag_rate_limiter_rate!
+        tag_sample_rate!
+        tag_sampling_priority!
+
+        trace
+      end
+
+      protected
+
+      def set_resource!
+        # If the trace resource is undefined, or the root span wasn't
+        # specified, don't set this. We don't want to overwrite the
+        # resource of a span that is in the middle of the trace.
+        return if trace.resource.nil? || partial?
+
+        root_span.resource = trace.resource
+      end
+
+      def set_trace_tags!
+        # If the root span wasn't specified, don't set this. We don't want to
+        # misset or overwrite the tags of a span that is in the middle of the
+        # trace.
+        return if partial?
+
+        root_span.set_tags(trace.send(:meta))
+        root_span.set_tags(trace.send(:metrics))
+      end
+
+      def tag_agent_sample_rate!
+        return unless trace.agent_sample_rate
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::Sampling::TAG_AGENT_RATE,
+          trace.agent_sample_rate
+        )
+      end
+
+      def tag_hostname!
+        return unless trace.hostname
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::NET::TAG_HOSTNAME,
+          trace.hostname
+        )
+      end
+
+      def tag_lang!
+        return if trace.lang.nil? || root_span.get_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE)
+
+        root_span.set_tag(
+          Core::Runtime::Ext::TAG_LANG,
+          trace.lang
+        )
+      end
+
+      def tag_origin!
+        return unless trace.origin
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::Distributed::TAG_ORIGIN,
+          trace.origin
+        )
+      end
+
+      def tag_process_id!
+        return unless trace.process_id
+
+        root_span.set_tag(
+          Core::Runtime::Ext::TAG_PID,
+          trace.process_id
+        )
+      end
+
+      def tag_rate_limiter_rate!
+        return unless trace.rate_limiter_rate
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::Sampling::TAG_RATE_LIMITER_RATE,
+          trace.rate_limiter_rate
+        )
+      end
+
+      def tag_rule_sample_rate!
+        return unless trace.rule_sample_rate
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::Sampling::TAG_RULE_SAMPLE_RATE,
+          trace.rule_sample_rate
+        )
+      end
+
+      def tag_runtime_id!
+        return unless trace.runtime_id
+
+        root_span.set_tag(
+          Core::Runtime::Ext::TAG_ID,
+          trace.runtime_id
+        )
+      end
+
+      def tag_sample_rate!
+        return unless trace.sample_rate
+
+        root_span.set_tag(
+          Tracing::Metadata::Ext::Sampling::TAG_SAMPLE_RATE,
+          trace.sample_rate
+        )
+      end
+
+      def tag_sampling_priority!
+        return unless trace.sampling_priority
+
+        root_span.set_metric(
+          Tracing::Metadata::Ext::Distributed::TAG_SAMPLING_PRIORITY,
+          trace.sampling_priority
+        )
+      end
+
+      private
+
+      def partial?
+        !@found_root_span
+      end
+
+      def find_root_span(trace)
+        # TODO: Should we memoize this?
+        #       Would be safe, but `spans` is mutable, so if
+        #       the root span were removed, it would be a stale reference.
+        #       Figure out a better way to deal with this.
+        root_span_id = trace.send(:root_span_id)
+        root_span = trace.spans.find { |s| s.id == root_span_id } if root_span_id
+        @found_root_span = !root_span.nil?
+
+        # when root span is not found, fall back to last span (partial flush)
+        root_span || trace.spans.last
+      end
+    end
+  end
+end