ddtrace 0.34.1 → 1.23.1

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

@@ -1,140 +0,0 @@
-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 Transport::Traces::Response
-
-          def initialize(http_response, options = {})
-            super(http_response)
-            @service_rates = options.fetch(:service_rates, nil)
-          end
-        end
-
-        # Extensions for HTTP client
-        module Client
-          def send_traces(traces)
-            request = Transport::Traces::Request.new(traces)
-
-            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
-
-            # 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.count.to_s
-
-              # Encode body & type
-              env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
-              env.body = env.request.parcel.encode_with(encoder)
-
-              # Query for response
-              http_response = super(env, &block)
-
-              # Process the response
-              response_options = {}.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)
-                  if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
-                    options[:service_rates] = body[SERVICE_RATE_KEY]
-                  end
-                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/http.rb

@@ -1,91 +0,0 @@
-require 'ddtrace/version'
-require 'ddtrace/ext/runtime'
-require 'ddtrace/ext/transport'
-
-require 'ddtrace/runtime/container'
-
-require 'ddtrace/transport/http/builder'
-require 'ddtrace/transport/http/api'
-
-require 'ddtrace/transport/http/adapters/net'
-require 'ddtrace/transport/http/adapters/test'
-require 'ddtrace/transport/http/adapters/unix_socket'
-
-module Datadog
-  module Transport
-    # Namespace for HTTP transport components
-    module HTTP
-      module_function
-
-      # Builds a new Transport::HTTP::Client
-      def new(&block)
-        Builder.new(&block).to_client
-      end
-
-      # Builds a new Transport::HTTP::Client with default settings
-      # Pass a block to override any settings.
-      def default(options = {})
-        new do |transport|
-          transport.adapter :net_http, default_hostname, default_port
-          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], fallback: API::V2
-          transport.api API::V2, apis[API::V2]
-
-          # 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)
-
-            # Execute on_build callback
-            options[:on_build].call(transport) if options[:on_build].is_a?(Proc)
-          end
-
-          # 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
-        }.tap do |headers|
-          # Add container ID, if present.
-          container_id = Datadog::Runtime::Container.container_id
-          unless container_id.nil?
-            headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id
-          end
-        end
-      end
-
-      def default_hostname
-        ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST, Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
-      end
-
-      def default_port
-        ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT, Datadog::Ext::Transport::HTTP::DEFAULT_PORT).to_i
-      end
-
-      # Add adapters to registry
-      Builder::REGISTRY.set(Adapters::Net, :net_http)
-      Builder::REGISTRY.set(Adapters::Test, :test)
-      Builder::REGISTRY.set(Adapters::UnixSocket, :unix)
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-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.log.debug(message)
-          else
-            Datadog::Logger.log.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

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

@@ -1,44 +0,0 @@
-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
-        end
-
-        # Extensions for HTTP client
-        module Client
-          def send_traces(traces)
-            # Build a request
-            req = Transport::Traces::Request.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
-
-        # Add traces behavior to transport components
-        IO::Client.send(:include, Traces::Client)
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/io.rb

@@ -1,26 +0,0 @@
-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::V2)
-        )
-      end
-    end
-  end
-end

data/lib/ddtrace/transport/parcel.rb

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

data/lib/ddtrace/transport/request.rb

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

@@ -1,49 +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
-    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
-    end
-  end
-end

data/lib/ddtrace/transport/statistics.rb

@@ -1,72 +0,0 @@
-require 'ddtrace/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
-        Diagnostics::Health.metrics.send_metrics(
-          metrics_for_response(response).values
-        )
-      end
-
-      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?
-        end
-      end
-
-      def update_stats_from_exception!(exception)
-        stats.internal_error += 1
-        stats.consecutive_errors += 1
-
-        # Send health metrics
-        Diagnostics::Health.metrics.send_metrics(
-          metrics_for_exception(exception).values
-        )
-      end
-
-      def metrics_for_exception(_exception)
-        { api_errors: 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

data/lib/ddtrace/transport/traces.rb

@@ -1,33 +0,0 @@
-require 'ddtrace/transport/parcel'
-require 'ddtrace/transport/request'
-
-module Datadog
-  module Transport
-    module Traces
-      # Data transfer object for trace data
-      class Parcel
-        include Transport::Parcel
-
-        def count
-          data.length
-        end
-
-        def encode_with(encoder)
-          encoder.encode_traces(data)
-        end
-      end
-
-      # Traces request
-      class Request < Transport::Request
-        def initialize(traces)
-          super(Parcel.new(traces))
-        end
-      end
-
-      # Traces response
-      module Response
-        attr_reader :service_rates
-      end
-    end
-  end
-end

data/lib/ddtrace/utils/database.rb

@@ -1,25 +0,0 @@
-module Datadog
-  module Utils
-    # Common database-related utility functions.
-    module Database
-      VENDOR_DEFAULT = 'defaultdb'.freeze
-      VENDOR_POSTGRES = 'postgres'.freeze
-      VENDOR_SQLITE = 'sqlite'.freeze
-
-      module_function
-
-      def normalize_vendor(vendor)
-        case vendor
-        when nil
-          VENDOR_DEFAULT
-        when 'postgresql'
-          VENDOR_POSTGRES
-        when 'sqlite3'
-          VENDOR_SQLITE
-        else
-          vendor
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/utils/time.rb

@@ -1,14 +0,0 @@
-module Datadog
-  module Utils
-    # Common database-related utility functions.
-    module Time
-      PROCESS_TIME_SUPPORTED = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1.0')
-
-      module_function
-
-      def get_time
-        PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : ::Time.now.to_f
-      end
-    end
-  end
-end

data/lib/ddtrace/utils.rb

@@ -1,65 +0,0 @@
-require 'ddtrace/utils/database'
-
-module Datadog
-  # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
-  module Utils
-    STRING_PLACEHOLDER = ''.encode(::Encoding::UTF_8).freeze
-    # We use a custom random number generator because we want no interference
-    # with the default one. Using the default prng, we could break code that
-    # would rely on srand/rand sequences.
-
-    # Return a span id
-    def self.next_id
-      reset! if was_forked?
-
-      @rnd.rand(Datadog::Span::MAX_ID)
-    end
-
-    def self.reset!
-      @pid = Process.pid
-      @rnd = Random.new
-    end
-
-    def self.was_forked?
-      Process.pid != @pid
-    end
-
-    private_class_method :reset!, :was_forked?
-
-    reset!
-
-    def self.truncate(value, size, omission = '...'.freeze)
-      string = value.to_s
-
-      return string if string.size <= size
-
-      string = string.slice(0, size - 1)
-
-      if size < omission.size
-        string[0, size] = omission
-      else
-        string[size - omission.size, size] = omission
-      end
-
-      string
-    end
-
-    def self.utf8_encode(str, options = {})
-      str = str.to_s
-
-      if options[:binary]
-        # This option is useful for "gracefully" displaying binary data that
-        # often contains text such as marshalled objects
-        str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
-      elsif str.encoding == ::Encoding::UTF_8
-        str
-      else
-        str.encode(::Encoding::UTF_8)
-      end
-    rescue => e
-      Logger.log.debug("Error encoding string in UTF-8: #{e}")
-
-      options.fetch(:placeholder, STRING_PLACEHOLDER)
-    end
-  end
-end