ddtrace 0.49.0 → 1.12.1

data/lib/ddtrace/contrib/elasticsearch/quantize.rb

@@ -1,81 +0,0 @@
-module Datadog
-  module Contrib
-    module Elasticsearch
-      # Quantize contains ES-specific resource quantization tools.
-      module Quantize
-        PLACEHOLDER = '?'.freeze
-        ID_PLACEHOLDER = '\1?'.freeze
-        EXCLUDE_KEYS = [].freeze
-        SHOW_KEYS = [:_index, :_type, :_id].freeze
-        DEFAULT_OPTIONS = {
-          exclude: EXCLUDE_KEYS,
-          show: SHOW_KEYS,
-          placeholder: PLACEHOLDER
-        }.freeze
-
-        module_function
-
-        def format_url(url)
-          sanitize_fragment_with_id(url)
-            .gsub(/(?:\d+)/, PLACEHOLDER)
-        end
-
-        def format_body(body, options = {})
-          format_body!(body, options)
-        rescue StandardError
-          options[:placeholder] || PLACEHOLDER
-        end
-
-        def format_body!(body, options = {})
-          options = merge_options(DEFAULT_OPTIONS, options)
-
-          # Determine if bulk query or not, based on content
-          statements = body.end_with?("\n") ? body.split("\n") : [body]
-
-          # Parse each statement and quantize them.
-          statements.collect do |string|
-            reserialize_json(string, options[:placeholder]) do |obj|
-              Datadog::Quantization::Hash.format(obj, options)
-            end
-          end.join("\n")
-        end
-
-        def merge_options(original, additional)
-          {}.tap do |options|
-            # Show
-            # If either is :all, value becomes :all
-            options[:show] = if original[:show] == :all || additional[:show] == :all
-                               :all
-                             else
-                               (original[:show] || []).dup.concat(additional[:show] || []).uniq
-                             end
-
-            # Exclude
-            options[:exclude] = (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
-          end
-        end
-
-        # Parses a JSON object from a string, passes its value
-        # to the block provided, and dumps its result back to JSON.
-        # If JSON parsing fails, it prints fail_value.
-        def reserialize_json(string, fail_value = PLACEHOLDER)
-          return string unless block_given?
-
-          begin
-            JSON.dump(yield(JSON.parse(string)))
-          rescue JSON::ParserError
-            # If it can't parse/dump, don't raise an error.
-            fail_value
-          end
-        end
-
-        # Sanitizes URL fragment by changing it to ? whenever a number is detected
-        # This is meant as simple heuristic that attempts to detect if particular fragment
-        # represents document Id. This is meant to reduce the cardinality in most frequent cases.
-        def sanitize_fragment_with_id(url)
-          url.gsub(%r{^(/?[^/]*/[^/]*/)(?:[^?/\d]*\d+[^?/]*)}, ID_PLACEHOLDER)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/ethon/configuration/settings.rb

@@ -1,32 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/ethon/ext'
-
-module Datadog
-  module Contrib
-    module Ethon
-      module Configuration
-        # Custom settings for the Ethon integration
-        class Settings < Contrib::Configuration::Settings
-          option :enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-            o.lazy
-          end
-
-          option :analytics_enabled do |o|
-            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :distributed_tracing, default: true
-          option :service_name, default: Ext::SERVICE_NAME
-          option :split_by_domain, default: false
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/ethon/easy_patch.rb

@@ -1,151 +0,0 @@
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/integration'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/contrib/ethon/ext'
-require 'ddtrace/contrib/http_annotation_helper'
-
-module Datadog
-  module Contrib
-    module Ethon
-      # Ethon EasyPatch
-      module EasyPatch
-        def self.included(base)
-          base.send(:prepend, InstanceMethods)
-        end
-
-        # InstanceMethods - implementing instrumentation
-        module InstanceMethods
-          include Datadog::Contrib::HttpAnnotationHelper
-
-          def http_request(url, action_name, options = {})
-            load_datadog_configuration_for(url)
-            return super unless tracer_enabled?
-
-            # It's tricky to get HTTP method from libcurl
-            @datadog_method = action_name.to_s.upcase
-            super
-          end
-
-          def headers=(headers)
-            # Store headers to call this method again when span is ready
-            @datadog_original_headers = headers
-            super
-          end
-
-          def perform
-            load_datadog_configuration_for(url)
-            return super unless tracer_enabled?
-
-            datadog_before_request
-            super
-          end
-
-          def complete
-            return super unless tracer_enabled?
-
-            begin
-              response_options = mirror.options
-              response_code = (response_options[:response_code] || response_options[:code]).to_i
-              if response_code.zero?
-                return_code = response_options[:return_code]
-                message = return_code ? ::Ethon::Curl.easy_strerror(return_code) : 'unknown reason'
-                set_span_error_message("Request has failed: #{message}")
-              else
-                @datadog_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response_code)
-                if Datadog::Ext::HTTP::ERROR_RANGE.cover?(response_code)
-                  set_span_error_message("Request has failed with HTTP error: #{response_code}")
-                end
-              end
-            ensure
-              @datadog_span.finish
-              @datadog_span = nil
-            end
-            super
-          end
-
-          def reset
-            super
-          ensure
-            @datadog_span = nil
-            @datadog_method = nil
-            @datadog_original_headers = nil
-            @datadog_configuration = nil
-          end
-
-          def datadog_before_request(parent_span: nil)
-            load_datadog_configuration_for(url)
-            @datadog_span = datadog_configuration[:tracer].trace(
-              Ext::SPAN_REQUEST,
-              service: uri ? service_name(uri.host, datadog_configuration) : datadog_configuration[:service_name],
-              span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND
-            )
-            @datadog_span.parent = parent_span unless parent_span.nil?
-
-            datadog_tag_request
-
-            if datadog_configuration[:distributed_tracing]
-              @datadog_original_headers ||= {}
-              Datadog::HTTPPropagator.inject!(@datadog_span.context, @datadog_original_headers)
-              self.headers = @datadog_original_headers
-            end
-          end
-
-          def datadog_span_started?
-            instance_variable_defined?(:@datadog_span) && !@datadog_span.nil?
-          end
-
-          private
-
-          attr_reader :datadog_configuration
-
-          def datadog_tag_request
-            span = @datadog_span
-            method = Ext::NOT_APPLICABLE_METHOD
-            method = @datadog_method.to_s if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
-            span.resource = method
-            # Tag as an external peer service
-            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-            this_uri = uri
-            return unless this_uri
-
-            span.set_tag(Datadog::Ext::HTTP::URL, this_uri.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, method)
-            span.set_tag(Datadog::Ext::NET::TARGET_HOST, this_uri.host)
-            span.set_tag(Datadog::Ext::NET::TARGET_PORT, this_uri.port)
-          end
-
-          def set_span_error_message(message)
-            # Sets span error from message, in case there is no exception available
-            @datadog_span.status = Datadog::Ext::Errors::STATUS
-            @datadog_span.set_tag(Datadog::Ext::Errors::MSG, message)
-          end
-
-          def uri
-            URI.parse(url)
-          rescue URI::InvalidURIError
-          end
-
-          def load_datadog_configuration_for(host = :default)
-            @datadog_configuration = Datadog.configuration[:ethon, host]
-          end
-
-          def tracer_enabled?
-            datadog_configuration[:tracer].enabled
-          end
-
-          def analytics_enabled?
-            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
-          end
-
-          def analytics_sample_rate
-            datadog_configuration[:analytics_sample_rate]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/ethon/ext.rb

@@ -1,19 +0,0 @@
-module Datadog
-  module Contrib
-    module Ethon
-      # Ethon integration constants
-      module Ext
-        APP = 'ethon'.freeze
-        ENV_ENABLED = 'DD_TRACE_ETHON_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ETHON_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_ETHON_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ETHON_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_ETHON_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'ethon'.freeze
-        SPAN_REQUEST = 'ethon.request'.freeze
-        SPAN_MULTI_REQUEST = 'ethon.multi.request'.freeze
-        NOT_APPLICABLE_METHOD = 'N/A'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/ethon/integration.rb

@@ -1,43 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/ethon/configuration/settings'
-require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
-require 'ddtrace/contrib/ethon/patcher'
-
-module Datadog
-  module Contrib
-    module Ethon
-      # Description of Ethon integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('0.11.0')
-
-        register_as :ethon
-
-        def self.version
-          Gem.loaded_specs['ethon'] && Gem.loaded_specs['ethon'].version
-        end
-
-        def self.loaded?
-          !defined?(::Ethon::Easy).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-
-        def resolver
-          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/ethon/multi_patch.rb

@@ -1,84 +0,0 @@
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/integration'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/contrib/ethon/ext'
-
-module Datadog
-  module Contrib
-    module Ethon
-      # Ethon MultiPatch
-      module MultiPatch
-        def self.included(base)
-          # No need to prepend here since add method is included into Multi class
-          base.send(:include, InstanceMethods)
-        end
-
-        # InstanceMethods - implementing instrumentation
-        module InstanceMethods
-          def add(easy)
-            handles = super
-            return handles if handles.nil? || !tracer_enabled?
-
-            if datadog_multi_performing?
-              # Start Easy span in case Multi is already performing
-              easy.datadog_before_request(parent_span: datadog_multi_span)
-            end
-            handles
-          end
-
-          def perform
-            if tracer_enabled?
-              easy_handles.each do |easy|
-                easy.datadog_before_request(parent_span: datadog_multi_span) unless easy.datadog_span_started?
-              end
-            end
-            super
-          ensure
-            if tracer_enabled? && datadog_multi_performing?
-              @datadog_multi_span.finish
-              @datadog_multi_span = nil
-            end
-          end
-
-          private
-
-          def datadog_multi_performing?
-            instance_variable_defined?(:@datadog_multi_span) && !@datadog_multi_span.nil?
-          end
-
-          def datadog_multi_span
-            @datadog_multi_span ||= datadog_configuration[:tracer].trace(
-              Ext::SPAN_MULTI_REQUEST,
-              service: datadog_configuration[:service_name]
-            )
-
-            # Tag as an external peer service
-            @datadog_multi_span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, @datadog_multi_span.service)
-
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(@datadog_multi_span, analytics_sample_rate) if analytics_enabled?
-
-            @datadog_multi_span
-          end
-
-          def datadog_configuration
-            Datadog.configuration[:ethon]
-          end
-
-          def tracer_enabled?
-            datadog_configuration[:tracer].enabled
-          end
-
-          def analytics_enabled?
-            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
-          end
-
-          def analytics_sample_rate
-            datadog_configuration[:analytics_sample_rate]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/ethon/patcher.rb

@@ -1,25 +0,0 @@
-module Datadog
-  module Contrib
-    module Ethon
-      # Patcher enables patching of 'ethon' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          require 'ddtrace/ext/app_types'
-          require 'ddtrace/contrib/ethon/easy_patch'
-          require 'ddtrace/contrib/ethon/multi_patch'
-
-          ::Ethon::Easy.send(:include, EasyPatch)
-          ::Ethon::Multi.send(:include, MultiPatch)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/excon/configuration/settings.rb

@@ -1,33 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/excon/ext'
-
-module Datadog
-  module Contrib
-    module Excon
-      module Configuration
-        # Custom settings for the Excon integration
-        class Settings < Contrib::Configuration::Settings
-          option :enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-            o.lazy
-          end
-
-          option :analytics_enabled do |o|
-            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :distributed_tracing, default: true
-          option :error_handler
-          option :service_name, default: Ext::SERVICE_NAME
-          option :split_by_domain, default: false
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/excon/ext.rb

@@ -1,17 +0,0 @@
-module Datadog
-  module Contrib
-    module Excon
-      # Excon integration constants
-      module Ext
-        APP = 'excon'.freeze
-        ENV_ENABLED = 'DD_TRACE_EXCON_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_EXCON_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_EXCON_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_EXCON_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_EXCON_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'excon'.freeze
-        SPAN_REQUEST = 'excon.request'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/excon/integration.rb

@@ -1,43 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/excon/configuration/settings'
-require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
-require 'ddtrace/contrib/excon/patcher'
-
-module Datadog
-  module Contrib
-    module Excon
-      # Description of Excon integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('0.50.0')
-
-        register_as :excon
-
-        def self.version
-          Gem.loaded_specs['excon'] && Gem.loaded_specs['excon'].version
-        end
-
-        def self.loaded?
-          !defined?(::Excon).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-
-        def resolver
-          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/excon/middleware.rb

@@ -1,163 +0,0 @@
-require 'excon'
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/integration'
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/excon/ext'
-require 'ddtrace/contrib/http_annotation_helper'
-
-module Datadog
-  module Contrib
-    module Excon
-      # Middleware implements an excon-middleware for ddtrace instrumentation
-      class Middleware < ::Excon::Middleware::Base
-        include Datadog::Contrib::HttpAnnotationHelper
-
-        DEFAULT_ERROR_HANDLER = lambda do |response|
-          Datadog::Ext::HTTP::ERROR_RANGE.cover?(response[:status])
-        end
-
-        def initialize(stack, options = {})
-          super(stack)
-          @default_options = datadog_configuration.options_hash.merge(options)
-        end
-
-        def request_call(datum)
-          begin
-            unless datum.key?(:datadog_span)
-              @options = build_request_options!(datum)
-              tracer.trace(Ext::SPAN_REQUEST).tap do |span|
-                datum[:datadog_span] = span
-                annotate!(span, datum)
-                propagate!(span, datum) if distributed_tracing?
-              end
-            end
-          rescue StandardError => e
-            Datadog.logger.debug(e.message)
-          end
-
-          @stack.request_call(datum)
-        end
-
-        def response_call(datum)
-          @stack.response_call(datum).tap do |d|
-            handle_response(d)
-          end
-        end
-
-        def error_call(datum)
-          handle_response(datum)
-          @stack.error_call(datum)
-        end
-
-        # Returns a child class of this trace middleware
-        # With options given as defaults.
-        def self.with(options = {})
-          Class.new(self) do
-            @options = options
-
-            # rubocop:disable Style/TrivialAccessors
-            def self.options
-              @options
-            end
-
-            # default_options in this case contains our specific middleware options
-            # so we want it to take precedence in build_request_options
-            def build_request_options!(datum)
-              datadog_configuration(datum[:host]).options_hash.merge(@default_options)
-            end
-
-            def initialize(stack)
-              super(stack, self.class.options)
-            end
-          end
-        end
-
-        # Returns a copy of the default stack with the trace middleware injected
-        def self.around_default_stack
-          ::Excon.defaults[:middlewares].dup.tap do |default_stack|
-            # If the default stack contains a version of the trace middleware already...
-            existing_trace_middleware = default_stack.find { |m| m <= Middleware }
-            default_stack.delete(existing_trace_middleware) if existing_trace_middleware
-
-            # Inject after the ResponseParser middleware
-            response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
-            default_stack.insert(response_middleware_index + 1, self)
-          end
-        end
-
-        private
-
-        def tracer
-          @options[:tracer]
-        end
-
-        def analytics_enabled?
-          Contrib::Analytics.enabled?(@options[:analytics_enabled])
-        end
-
-        def analytics_sample_rate
-          @options[:analytics_sample_rate]
-        end
-
-        def distributed_tracing?
-          @options[:distributed_tracing] == true && tracer.enabled
-        end
-
-        def error_handler
-          @options[:error_handler] || DEFAULT_ERROR_HANDLER
-        end
-
-        def annotate!(span, datum)
-          span.resource = datum[:method].to_s.upcase
-          span.service = service_name(datum[:host], @options)
-          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
-
-          # Tag as an external peer service
-          span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-          # Set analytics sample rate
-          Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-          span.set_tag(Datadog::Ext::HTTP::URL, datum[:path])
-          span.set_tag(Datadog::Ext::HTTP::METHOD, datum[:method].to_s.upcase)
-          span.set_tag(Datadog::Ext::NET::TARGET_HOST, datum[:host])
-          span.set_tag(Datadog::Ext::NET::TARGET_PORT, datum[:port])
-        end
-
-        def handle_response(datum)
-          if datum.key?(:datadog_span)
-            datum[:datadog_span].tap do |span|
-              return span if span.finished?
-
-              if datum.key?(:response)
-                response = datum[:response]
-                span.set_error(["Error #{response[:status]}", response[:body]]) if error_handler.call(response)
-                span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response[:status])
-              end
-              span.set_error(datum[:error]) if datum.key?(:error)
-              span.finish
-              datum.delete(:datadog_span)
-            end
-          end
-        rescue StandardError => e
-          Datadog.logger.debug(e.message)
-        end
-
-        def propagate!(span, datum)
-          Datadog::HTTPPropagator.inject!(span.context, datum[:headers])
-        end
-
-        def build_request_options!(datum)
-          @default_options.merge(datadog_configuration(datum[:host]).options_hash)
-        end
-
-        def datadog_configuration(host = :default)
-          Datadog.configuration[:excon, host]
-        end
-      end
-    end
-  end
-end