ddtrace 1.14.0 → 1.16.0

data/lib/datadog/tracing/transport/http.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../../core/environment/container'
+require_relative '../../core/environment/ext'
+require_relative '../../core/transport/ext'
+require_relative '../../core/transport/http/adapters/net'
+require_relative '../../core/transport/http/adapters/test'
+require_relative '../../core/transport/http/adapters/unix_socket'
+require_relative 'http/api'
+require_relative 'http/builder'
+require_relative '../../../ddtrace/version'
+
+module Datadog
+  module Tracing
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        # 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
+        def new(&block)
+          Builder.new(&block).to_transport
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def default(
+          agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+          **options
+        )
+          new do |transport|
+            transport.adapter(agent_settings)
+            transport.headers default_headers
+
+            apis = API.defaults
+
+            transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
+            transport.api API::V3, apis[API::V3]
+
+            # Apply any settings given by options
+            unless options.empty?
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+              transport.headers options[:headers] if options.key?(:headers)
+            end
+
+            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
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
+              Datadog::Core::Environment::Ext::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        def default_adapter
+          Datadog::Core::Transport::Ext::HTTP::ADAPTER
+        end
+
+        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.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
+        end
+
+        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.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
+        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
+        Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Net, Datadog::Core::Transport::Ext::HTTP::ADAPTER)
+        Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Test, Datadog::Core::Transport::Ext::Test::ADAPTER)
+        Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
+          Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
+        )
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../statistics'
+require_relative 'response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # Encodes and writes tracer data to IO
+        class Client
+          include Transport::Statistics
+
+          attr_reader \
+            :encoder,
+            :out
+
+          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 do a standard encode/write/response.
+            response = if block_given?
+                         yield(out, request)
+                       else
+                         @request_block.call(out, request)
+                       end
+
+            # Update statistics
+            update_stats_from_response!(response)
+
+            # Return response
+            response
+          rescue StandardError => e
+            message =
+              "Internal error during IO transport request. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+
+            # Log error
+            if stats.consecutive_errors > 0
+              Datadog.logger.debug(message)
+            else
+              Datadog.logger.error(message)
+            end
+
+            # Update statistics
+            update_stats_from_exception!(e)
+
+            InternalErrorResponse.new(e)
+          end
+
+          def encode_data(encoder, request)
+            request.parcel.encode_with(encoder)
+          end
+
+          def write_data(out, data)
+            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_block.call(encoder, request)
+
+            # Write to IO
+            result = @write_block.call(out, data)
+
+            # Generate a response
+            @response_block.call(request, data, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # Response from HTTP transport for traces
+        class Response
+          include Datadog::Core::Transport::Response
+
+          attr_reader \
+            :result
+
+          def initialize(result)
+            @result = result
+          end
+
+          def ok?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/traces.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative '../../transport/traces'
+require_relative '../../../core/transport/parcel'
+require_relative 'response'
+require_relative 'client'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # IO transport behavior for traces
+        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
+            def send_traces(traces)
+              # Build a request
+              req = Transport::Traces::Request.new(Parcel.new(traces))
+
+              [send_request(req) do |out, request|
+                # Encode trace data
+                data = encode_data(encoder, request)
+
+                # Write to IO
+                result = if block_given?
+                           yield(out, data)
+                         else
+                           write_data(out, data)
+                         end
+
+                # Generate response
+                Traces::Response.new(result)
+              end]
+            end
+          end
+
+          # Encoder for IO-specific trace encoding
+          # API compliant when used with {JSONEncoder}.
+          module Encoder
+            ENCODED_IDS = [
+              :trace_id,
+              :span_id,
+              :parent_id
+            ].freeze
+
+            # Encodes a list of traces
+            def encode_traces(encoder, traces)
+              trace_hashes = traces.map do |trace|
+                encode_trace(trace)
+              end
+
+              # Wrap traces & encode them
+              encoder.encode(traces: trace_hashes)
+            end
+
+            private
+
+            def encode_trace(trace)
+              # Convert each trace to hash
+              trace.spans.map(&:to_hash).tap do |spans|
+                # Convert IDs to hexadecimal
+                spans.each do |span|
+                  ENCODED_IDS.each do |id|
+                    span[id] = span[id].to_s(16) if span.key?(id)
+                  end
+                end
+              end
+            end
+          end
+
+          # Transfer object for list of traces
+          class Parcel
+            include Datadog::Core::Transport::Parcel
+            include Encoder
+
+            def count
+              data.length
+            end
+
+            def encode_with(encoder)
+              encode_traces(encoder, data)
+            end
+          end
+
+          # Add traces behavior to transport components
+          IO::Client.include(Traces::Client)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../core/encoding'
+require_relative 'io/client'
+require_relative 'io/traces'
+
+module Datadog
+  module Tracing
+    module Transport
+      # Namespace for IO transport components
+      module IO
+        module_function
+
+        # Builds a new Transport::IO::Client
+        def new(out, encoder)
+          Client.new(out, encoder)
+        end
+
+        # Builds a new Transport::IO::Client with default settings
+        # Pass options to override any settings.
+        def default(options = {})
+          new(
+            options.fetch(:out, $stdout),
+            options.fetch(:encoder, Core::Encoding::JSONEncoder)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/serializable_trace.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'msgpack'
+require 'datadog/tracing/utils'
+
+module Datadog
+  module Tracing
+    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 { |s| SerializableSpan.new(s).to_hash }.to_json(*args)
+        end
+      end
+
+      # Adds serialization functions to a {Datadog::Span}
+      class SerializableSpan
+        attr_reader \
+          :span
+
+        def initialize(span)
+          @span = span
+          @trace_id = Tracing::Utils::TraceId.to_low_order(span.trace_id)
+        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(@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)
+          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
+
+        def to_hash
+          span.to_hash.merge(trace_id: @trace_id)
+        end
+
+        # Used for serialization
+        # @return [Integer] in nanoseconds since Epoch
+        def duration_nano(duration)
+          (duration * 1e9).to_i
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/statistics.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../../core/metrics/metric'
+require_relative '../../core/diagnostics/health'
+
+module Datadog
+  module Tracing
+    module Transport
+      # Tracks statistics for transports
+      module Statistics
+        def stats
+          @stats ||= Counts.new
+        end
+
+        def update_stats_from_response!(response)
+          if response.ok?
+            stats.success += 1
+            stats.consecutive_errors = 0
+          else
+            stats.client_error += 1 if response.client_error?
+            stats.server_error += 1 if response.server_error?
+            stats.internal_error += 1 if response.internal_error?
+            stats.consecutive_errors += 1
+          end
+
+          # Send health metrics
+          Datadog.health_metrics.send_metrics(
+            metrics_for_response(response).values
+          )
+        end
+
+        def metrics_for_response(response)
+          {}.tap do |metrics|
+            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
+
+        def update_stats_from_exception!(exception)
+          stats.internal_error += 1
+          stats.consecutive_errors += 1
+
+          # Send health metrics
+          Datadog.health_metrics.send_metrics(
+            metrics_for_exception(exception).values
+          )
+        end
+
+        def metrics_for_exception(_exception)
+          { api_errors: Core::Metrics::Metric.new(:api_errors, nil, 1) }
+        end
+
+        # Stat counts
+        class Counts
+          attr_accessor \
+            :success,
+            :client_error,
+            :server_error,
+            :internal_error,
+            :consecutive_errors
+
+          def initialize
+            reset!
+          end
+
+          def reset!
+            @success = 0
+            @client_error = 0
+            @server_error = 0
+            @internal_error = 0
+            @consecutive_errors = 0
+          end
+        end
+      end
+    end
+  end
+end