ddtrace 0.13.0 → 0.47.0

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

@@ -0,0 +1,142 @@
+require 'json'
+
+require 'ddtrace/transport/traces'
+require 'ddtrace/transport/http/response'
+require 'ddtrace/transport/http/api/endpoint'
+
+module Datadog
+  module Transport
+    module HTTP
+      # HTTP transport behavior for traces
+      module Traces
+        # Response from HTTP transport for traces
+        class Response
+          include HTTP::Response
+          include Datadog::Transport::Traces::Response
+
+          def initialize(http_response, options = {})
+            super(http_response)
+            @service_rates = options.fetch(:service_rates, nil)
+            @trace_count = options.fetch(:trace_count, 0)
+          end
+        end
+
+        # Extensions for HTTP client
+        module Client
+          def send_payload(request)
+            send_request(request) do |api, env|
+              api.send_traces(env)
+            end
+          end
+        end
+
+        module API
+          # Extensions for HTTP API Spec
+          module Spec
+            attr_reader :traces
+
+            def traces=(endpoint)
+              @traces = endpoint
+            end
+
+            def send_traces(env, &block)
+              raise NoTraceEndpointDefinedError, self if traces.nil?
+
+              traces.call(env, &block)
+            end
+
+            def encoder
+              traces.encoder
+            end
+
+            # Raised when traces sent but no traces endpoint is defined
+            class NoTraceEndpointDefinedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'No trace endpoint is defined for API specification!'
+              end
+            end
+          end
+
+          # Extensions for HTTP API Instance
+          module Instance
+            def send_traces(env)
+              raise TracesNotSupportedError, spec unless spec.is_a?(Traces::API::Spec)
+
+              spec.send_traces(env) do |request_env|
+                call(request_env)
+              end
+            end
+
+            # Raised when traces sent to API that does not support traces
+            class TracesNotSupportedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'Traces not supported for this API!'
+              end
+            end
+          end
+
+          # Endpoint for submitting trace data
+          class Endpoint < HTTP::API::Endpoint
+            HEADER_CONTENT_TYPE = 'Content-Type'.freeze
+            HEADER_TRACE_COUNT = 'X-Datadog-Trace-Count'.freeze
+            SERVICE_RATE_KEY = 'rate_by_service'.freeze
+
+            attr_reader \
+              :encoder
+
+            def initialize(path, encoder, options = {})
+              super(:post, path)
+              @encoder = encoder
+              @service_rates = options.fetch(:service_rates, false)
+            end
+
+            def service_rates?
+              @service_rates == true
+            end
+
+            def call(env, &block)
+              # Add trace count header
+              env.headers[HEADER_TRACE_COUNT] = env.request.parcel.trace_count.to_s
+
+              # Encode body & type
+              env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+              env.body = env.request.parcel.data
+
+              # Query for response
+              http_response = super(env, &block)
+
+              # Process the response
+              response_options = { trace_count: env.request.parcel.trace_count }.tap do |options|
+                # Parse service rates, if configured to do so.
+                if service_rates? && !http_response.payload.to_s.empty?
+                  body = JSON.parse(http_response.payload)
+                  options[:service_rates] = body[SERVICE_RATE_KEY] if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
+                end
+              end
+
+              # Build and return a trace response
+              Traces::Response.new(http_response, response_options)
+            end
+          end
+        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)
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/io.rb

@@ -0,0 +1,26 @@
+require 'ddtrace/encoding'
+require 'ddtrace/transport/io/client'
+require 'ddtrace/transport/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, Encoding::JSONEncoder)
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'ddtrace/transport/statistics'
+require 'ddtrace/transport/io/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)
+          @out = out
+          @encoder = encoder
+        end
+
+        def send_request(request)
+          # Write data to IO
+          # If block is given, allow it to handle writing
+          # Otherwise use default encoding.
+          response = if block_given?
+                       yield(out, request)
+                     else
+                       send_default_request(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.message} Location: #{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
+
+        protected
+
+        def encode_data(encoder, request)
+          request.parcel.encode_with(encoder)
+        end
+
+        def write_data(out, data)
+          out.puts(data)
+        end
+
+        private
+
+        def send_default_request(out, request)
+          # Encode data
+          data = encode_data(encoder, request)
+
+          # Write to IO
+          result = write_data(out, data)
+
+          # Generate a response
+          IO::Response.new(result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'ddtrace/transport/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

@@ -0,0 +1,97 @@
+require 'ddtrace/transport/traces'
+
+require 'ddtrace/transport/io/response'
+require 'ddtrace/transport/io/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.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.send(:include, Traces::Client)
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/parcel.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Transport
+    # Data transfer object for generic data
+    module Parcel
+      attr_reader \
+        :data
+
+      def initialize(data)
+        @data = data
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/request.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Transport
+    # Defines request for transport operations
+    class Request
+      attr_reader \
+        :parcel
+
+      def initialize(parcel)
+        @parcel = parcel
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/response.rb

@@ -0,0 +1,60 @@
+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