ddtrace 1.14.0 → 1.15.0

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

@@ -1,85 +0,0 @@
-require_relative '../statistics'
-require_relative 'response'
-
-module Datadog
-  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

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

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

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../traces'
-
-require_relative 'response'
-require_relative 'client'
-
-module Datadog
-  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 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

data/lib/ddtrace/transport/io.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../datadog/core/encoding'
-require_relative 'io/client'
-require_relative 'io/traces'
-
-module Datadog
-  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

data/lib/ddtrace/transport/parcel.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Transport
-    # Data transfer object for generic data
-    # @abstract
-    module Parcel
-      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,15 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Transport
-    # Defines request for transport operations
-    class Request
-      attr_reader \
-        :parcel
-
-      def initialize(parcel = nil)
-        @parcel = parcel
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/response.rb

@@ -1,60 +0,0 @@
-module Datadog
-  module Transport
-    # Defines abstract response for transport operations
-    module Response
-      def payload
-        nil
-      end
-
-      def ok?
-        nil
-      end
-
-      def unsupported?
-        nil
-      end
-
-      def not_found?
-        nil
-      end
-
-      def client_error?
-        nil
-      end
-
-      def server_error?
-        nil
-      end
-
-      def internal_error?
-        nil
-      end
-
-      def inspect
-        "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
-        "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
-        "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
-        "payload:#{payload}"
-      end
-    end
-
-    # A generic error response for internal errors
-    class InternalErrorResponse
-      include Response
-
-      attr_reader :error
-
-      def initialize(error)
-        @error = error
-      end
-
-      def internal_error?
-        true
-      end
-
-      def inspect
-        "#{super}, error_type:#{error.class} error:#{error}"
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/serializable_trace.rb

@@ -1,122 +0,0 @@
-require 'json'
-require 'msgpack'
-require 'datadog/tracing/utils'
-
-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 { |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

data/lib/ddtrace/transport/statistics.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../datadog/core/metrics/metric'
-require_relative '../../datadog/core/diagnostics/health'
-
-module Datadog
-  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