ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/ext/redis.rb

@@ -1,17 +0,0 @@
-module Datadog
-  module Ext
-    module Redis
-      # type of the spans
-      TYPE = 'redis'.freeze
-
-      # net extension
-      DB = 'out.redis_db'.freeze
-
-      # raw command
-      RAW_COMMAND = 'redis.raw_command'.freeze
-
-      # pipeline length
-      PIPELINE_LEN = 'redis.pipeline_length'.freeze
-    end
-  end
-end

data/lib/ddtrace/monkey.rb

@@ -1,65 +0,0 @@
-module Datadog
-  # TODO: Remove me!
-  # Monkey was used for monkey-patching 3rd party libs.
-  # It is now DEPRECATED. This API is no-op, and serves only to warn
-  # of its deactivation.
-  module Monkey
-    @registry = Datadog.registry
-
-    DEPRECATION_WARNING = %(
-      Datadog::Monkey has been REMOVED as of version 0.11.1.
-      All calls to Datadog::Monkey are no-ops.
-      *Implementations using Monkey will no longer function*.
-      Upgrade to the new configuration API using the migration guide here:
-      https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-    module_function
-
-    attr_writer :registry
-
-    def registry
-      log_deprecation_warning('Monkey#registry')
-      @registry
-    end
-
-    def autopatch_modules
-      log_deprecation_warning('Monkey#autopatch_modules')
-      {}
-    end
-
-    def patch_all
-      log_deprecation_warning('Monkey#patch_all')
-    end
-
-    def patch_module(m)
-      log_deprecation_warning('Monkey#patch_module')
-    end
-
-    def patch(modules)
-      log_deprecation_warning('Monkey#patch')
-    end
-
-    def get_patched_modules
-      log_deprecation_warning('Monkey#get_patched_modules')
-      {}
-    end
-
-    def without_warnings(&block)
-      log_deprecation_warning('Monkey#without_warnings')
-      Datadog::Patcher.without_warnings(&block)
-    end
-
-    def log_deprecation_warning(method)
-      Datadog::Tracer.log.warn("#{method}:#{DEPRECATION_WARNING}")
-    end
-
-    class << self
-      def registry
-        log_deprecation_warning('Monkey#registry')
-        @registry
-      end
-
-      attr_writer :registry
-    end
-  end
-end

data/lib/ddtrace/propagation/distributed_headers.rb

@@ -1,48 +0,0 @@
-require 'ddtrace/span'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  # DistributedHeaders provides easy access and validation to headers
-  class DistributedHeaders
-    include Ext::DistributedTracing
-
-    def initialize(env)
-      @env = env
-    end
-
-    def valid?
-      # Sampling priority is optional.
-      trace_id && parent_id
-    end
-
-    def trace_id
-      value = header(HTTP_HEADER_TRACE_ID).to_i
-      return if value <= 0 || value >= Span::MAX_ID
-      value
-    end
-
-    def parent_id
-      value = header(HTTP_HEADER_PARENT_ID).to_i
-      return if value <= 0 || value >= Span::MAX_ID
-      value
-    end
-
-    def sampling_priority
-      hdr = header(HTTP_HEADER_SAMPLING_PRIORITY)
-      # It's important to make a difference between no header,
-      # and a header defined to zero.
-      return unless hdr
-      value = hdr.to_i
-      return if value < 0
-      value
-    end
-
-    private
-
-    def header(name)
-      rack_header = "http-#{name}".upcase!.tr('-', '_')
-
-      @env[rack_header]
-    end
-  end
-end

data/lib/ddtrace/provider.rb

@@ -1,21 +0,0 @@
-module Datadog
-  # DefaultContextProvider is a default context provider that retrieves
-  # all contexts from the current thread-local storage. It is suitable for
-  # synchronous programming.
-  class DefaultContextProvider
-    # Initializes the default context provider with a thread-bound context.
-    def initialize
-      @context = Datadog::ThreadLocalContext.new
-    end
-
-    # Sets the current context.
-    def context=(ctx)
-      @context.local = ctx
-    end
-
-    # Return the current context.
-    def context
-      @context.local
-    end
-  end
-end

data/lib/ddtrace/registry.rb

@@ -1,42 +0,0 @@
-require_relative 'registry/registerable'
-
-module Datadog
-  # Registry provides insertion/retrieval capabilities for integrations
-  class Registry
-    include Enumerable
-
-    Entry = Struct.new(:name, :klass, :auto_patch)
-
-    def initialize
-      @data = {}
-      @mutex = Mutex.new
-    end
-
-    def add(name, klass, auto_patch = false)
-      @mutex.synchronize do
-        @data[name] = Entry.new(name, klass, auto_patch).freeze
-      end
-    end
-
-    def each
-      @mutex.synchronize do
-        @data.each { |_, entry| yield(entry) }
-      end
-    end
-
-    def [](name)
-      @mutex.synchronize do
-        entry = @data[name]
-        entry.klass if entry
-      end
-    end
-
-    def to_h
-      @mutex.synchronize do
-        @data.each_with_object({}) do |(_, entry), hash|
-          hash[entry.name] = entry.auto_patch
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/registry/registerable.rb

@@ -1,20 +0,0 @@
-module Datadog
-  class Registry
-    # Registerable provides a convenience method for self-registering
-    module Registerable
-      def self.included(base)
-        base.singleton_class.send(:include, ClassMethods)
-      end
-
-      # ClassMethods
-      module ClassMethods
-        def register_as(name, options = {})
-          registry = options.fetch(:registry, Datadog.registry)
-          auto_patch = options.fetch(:auto_patch, false)
-
-          registry.add(name, self, auto_patch)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/transport.rb

@@ -1,212 +0,0 @@
-require 'thread'
-require 'net/http'
-
-require 'ddtrace/encoding'
-require 'ddtrace/version'
-
-module Datadog
-  # Transport class that handles the spans delivery to the
-  # local trace-agent. The class wraps a Net:HTTP instance
-  # so that the Transport is thread-safe.
-  # rubocop:disable Metrics/ClassLength
-  class HTTPTransport
-    attr_accessor :hostname, :port
-    attr_reader :traces_endpoint, :services_endpoint
-
-    # seconds before the transport timeout
-    TIMEOUT = 1
-
-    # header containing the number of traces in a payload
-    TRACE_COUNT_HEADER = 'X-Datadog-Trace-Count'.freeze
-    RUBY_INTERPRETER = RUBY_VERSION > '1.9' ? RUBY_ENGINE + '-' + RUBY_PLATFORM : 'ruby-' + RUBY_PLATFORM
-
-    API = {
-      V4 = 'v0.4'.freeze => {
-        version: V4,
-        traces_endpoint: '/v0.4/traces'.freeze,
-        services_endpoint: '/v0.4/services'.freeze,
-        encoder: Encoding::MsgpackEncoder,
-        fallback: 'v0.3'.freeze
-      }.freeze,
-      V3 = 'v0.3'.freeze => {
-        version: V3,
-        traces_endpoint: '/v0.3/traces'.freeze,
-        services_endpoint: '/v0.3/services'.freeze,
-        encoder: Encoding::MsgpackEncoder,
-        fallback: 'v0.2'.freeze
-      }.freeze,
-      V2 = 'v0.2'.freeze => {
-        version: V2,
-        traces_endpoint: '/v0.2/traces'.freeze,
-        services_endpoint: '/v0.2/services'.freeze,
-        encoder: Encoding::JSONEncoder
-      }.freeze
-    }.freeze
-
-    private_constant :API
-
-    def initialize(hostname, port, options = {})
-      api_version = options.fetch(:api_version, V3)
-
-      @hostname = hostname
-      @port = port
-      @api = API.fetch(api_version)
-      @encoder = options[:encoder] || @api[:encoder].new
-      @response_callback = options[:response_callback]
-
-      # overwrite the Content-type with the one chosen in the Encoder
-      @headers = options.fetch(:headers, {})
-      @headers['Content-Type'] = @encoder.content_type
-      @headers['Datadog-Meta-Lang'] = 'ruby'
-      @headers['Datadog-Meta-Lang-Version'] = RUBY_VERSION
-      @headers['Datadog-Meta-Lang-Interpreter'] = RUBY_INTERPRETER
-      @headers['Datadog-Meta-Tracer-Version'] = Datadog::VERSION::STRING
-
-      # stats
-      @mutex = Mutex.new
-      @count_success = 0
-      @count_client_error = 0
-      @count_server_error = 0
-      @count_internal_error = 0
-    end
-
-    # route the send to the right endpoint
-    def send(endpoint, data)
-      case endpoint
-      when :services
-        payload = @encoder.encode_services(data)
-        status_code = post(@api[:services_endpoint], payload) do |response|
-          process_callback(:services, response)
-        end
-      when :traces
-        count = data.length
-        payload = @encoder.encode_traces(data)
-        status_code = post(@api[:traces_endpoint], payload, count) do |response|
-          process_callback(:traces, response)
-        end
-      else
-        Datadog::Tracer.log.error("Unsupported endpoint: #{endpoint}")
-        return nil
-      end
-
-      if downgrade?(status_code)
-        downgrade!
-        send(endpoint, data)
-      else
-        status_code
-      end
-    end
-
-    # send data to the trace-agent; the method is thread-safe
-    def post(url, data, count = nil)
-      begin
-        Datadog::Tracer.log.debug("Sending data from process: #{Process.pid}")
-        headers = count.nil? ? {} : { TRACE_COUNT_HEADER => count.to_s }
-        headers = headers.merge(@headers)
-        request = Net::HTTP::Post.new(url, headers)
-        request.body = data
-
-        response = Net::HTTP.start(@hostname, @port, read_timeout: TIMEOUT) { |http| http.request(request) }
-        handle_response(response)
-      rescue StandardError => e
-        Datadog::Tracer.log.error(e.message)
-        500
-      end.tap do
-        yield(response) if block_given?
-      end
-    end
-
-    # Downgrade the connection to a compatibility version of the HTTPTransport;
-    # this method should target a stable API that works whatever is the agent
-    # or the tracing client versions.
-    def downgrade!
-      @mutex.synchronize do
-        fallback_version = @api.fetch(:fallback)
-
-        @api = API.fetch(fallback_version)
-        @encoder = @api[:encoder].new
-        @headers['Content-Type'] = @encoder.content_type
-      end
-    end
-
-    def informational?(code)
-      code.between?(100, 199)
-    end
-
-    def success?(code)
-      code.between?(200, 299)
-    end
-
-    def redirect?(code)
-      code.between?(300, 399)
-    end
-
-    def client_error?(code)
-      code.between?(400, 499)
-    end
-
-    def server_error?(code)
-      code.between?(500, 599)
-    end
-
-    # receiving a 404 means that we're targeting an endpoint that is not available
-    # in the trace agent. Usually this means that we've an up-to-date tracing client,
-    # while running an obsolete agent.
-    # receiving a 415 means that we're using an unsupported content-type with an existing
-    # endpoint. Usually this means that we're using a newer encoder with a previous
-    # endpoint. In both cases, we're going to downgrade the transporter encoder so that
-    # it will target a stable API.
-    def downgrade?(code)
-      return unless @api[:fallback]
-
-      code == 404 || code == 415
-    end
-
-    # handles the server response; here you can log the trace-agent response
-    # or do something more complex to recover from a possible error. This
-    # function is handled within the HTTP mutex.synchronize so it's thread-safe.
-    def handle_response(response)
-      status_code = response.code.to_i
-
-      if success?(status_code)
-        Datadog::Tracer.log.debug('Payload correctly sent to the trace agent.')
-        @mutex.synchronize { @count_success += 1 }
-      elsif downgrade?(status_code)
-        Datadog::Tracer.log.debug("calling the endpoint but received #{status_code}; downgrading the API")
-      elsif client_error?(status_code)
-        Datadog::Tracer.log.error("Client error: #{response.message}")
-        @mutex.synchronize { @count_client_error += 1 }
-      elsif server_error?(status_code)
-        Datadog::Tracer.log.error("Server error: #{response.message}")
-        @mutex.synchronize { @count_server_error += 1 }
-      end
-
-      status_code
-    rescue StandardError => e
-      Datadog::Tracer.log.error(e.message)
-      @mutex.synchronize { @count_internal_error += 1 }
-      500
-    end
-
-    def stats
-      @mutex.synchronize do
-        {
-          success: @count_success,
-          client_error: @count_client_error,
-          server_error: @count_server_error,
-          internal_error: @count_internal_error
-        }
-      end
-    end
-
-    private
-
-    def process_callback(action, response)
-      return unless @response_callback && @response_callback.respond_to?(:call)
-
-      @response_callback.call(action, response, @api)
-    rescue => e
-      Tracer.log.debug("Error processing callback: #{e}")
-    end
-  end
-end