ddtrace 0.34.1 → 1.23.1

data/lib/ddtrace/contrib/grpc/datadog_interceptor.rb

@@ -1,74 +0,0 @@
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      # :nodoc:
-      module DatadogInterceptor
-        # :nodoc:
-        class Base < ::GRPC::Interceptor
-          attr_accessor :datadog_pin
-
-          def initialize(options = {})
-            add_datadog_pin! { |c| yield(c) if block_given? }
-          end
-
-          def request_response(**keywords)
-            trace(keywords) { yield }
-          end
-
-          def client_streamer(**keywords)
-            trace(keywords) { yield }
-          end
-
-          def server_streamer(**keywords)
-            trace(keywords) { yield }
-          end
-
-          def bidi_streamer(**keywords)
-            trace(keywords) { yield }
-          end
-
-          private
-
-          def add_datadog_pin!
-            Pin.new(
-              service_name,
-              app: Ext::APP,
-              app_type: Datadog::Ext::AppTypes::WEB,
-              tracer: tracer
-            ).tap do |pin|
-              yield(pin) if block_given?
-              pin.onto(self)
-            end
-          end
-
-          def datadog_configuration
-            Datadog.configuration[:grpc]
-          end
-
-          def tracer
-            (datadog_pin && datadog_pin.tracer) || datadog_configuration[:tracer]
-          end
-
-          def service_name
-            (datadog_pin && datadog_pin.service_name) || datadog_configuration[:service_name]
-          end
-
-          def analytics_enabled?
-            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
-          end
-
-          def analytics_sample_rate
-            datadog_configuration[:analytics_sample_rate]
-          end
-        end
-
-        require_relative 'datadog_interceptor/client'
-        require_relative 'datadog_interceptor/server'
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Datadog
-  module Contrib
-    module GRPC
-      # gRPC integration constants
-      module Ext
-        APP = 'grpc'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_GRPC_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_GRPC_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'grpc'.freeze
-        SPAN_CLIENT = 'grpc.client'.freeze
-        SPAN_SERVICE = 'grpc.service'.freeze
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/grpc/configuration/settings'
-require 'ddtrace/contrib/grpc/patcher'
-
-module Datadog
-  module Contrib
-    module GRPC
-      # Description of gRPC integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('1.7.0')
-
-        register_as :grpc, auto_patch: true
-
-        def self.version
-          Gem.loaded_specs['grpc'] && Gem.loaded_specs['grpc'].version
-        end
-
-        def self.loaded?
-          !defined?(::GRPC).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/grpc/intercept_with_datadog.rb

@@ -1,49 +0,0 @@
-require_relative 'datadog_interceptor'
-
-module Datadog
-  module Contrib
-    module GRPC
-      # :nodoc:
-      # The `#intercept!` method is implemented in gRPC; this module
-      # will be prepended to the original class, effectively injecting
-      # our tracing middleware into the head of the call chain.
-      module InterceptWithDatadog
-        def intercept!(type, args = {})
-          if should_prepend?
-            datadog_interceptor = choose_datadog_interceptor(args)
-
-            @interceptors.unshift(datadog_interceptor.new) if datadog_interceptor
-
-            @trace_started = true
-          end
-
-          super
-        end
-
-        private
-
-        def should_prepend?
-          !trace_started? && !already_prepended?
-        end
-
-        def trace_started?
-          defined?(@trace_started) && @trace_started
-        end
-
-        def already_prepended?
-          @interceptors.any? do |interceptor|
-            interceptor.class.ancestors.include?(Datadog::Contrib::GRPC::DatadogInterceptor::Base)
-          end
-        end
-
-        def choose_datadog_interceptor(args)
-          if args.key?(:metadata)
-            Datadog::Contrib::GRPC::DatadogInterceptor::Client
-          elsif args.key?(:call)
-            Datadog::Contrib::GRPC::DatadogInterceptor::Server
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      # Patcher enables patching of 'grpc' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          require 'ddtrace/propagation/grpc_propagator'
-          require 'ddtrace/contrib/grpc/datadog_interceptor'
-          require 'ddtrace/contrib/grpc/intercept_with_datadog'
-
-          add_pin!
-
-          prepend_interceptor
-        end
-
-        def add_pin!
-          DeprecatedPin.new(
-            get_option(:service_name),
-            app: Ext::APP,
-            app_type: Datadog::Ext::AppTypes::WEB,
-            tracer: get_option(:tracer)
-          ).onto(::GRPC)
-        end
-
-        def prepend_interceptor
-          ::GRPC::InterceptionContext
-            .send(:prepend, Datadog::Contrib::GRPC::InterceptWithDatadog)
-        end
-
-        def get_option(option)
-          Datadog.configuration[:grpc].get_option(option)
-        end
-
-        # Implementation of deprecated Pin, which raises warnings when accessed.
-        # To be removed when support for Datadog::Pin with GRPC is removed.
-        class DeprecatedPin < Datadog::Pin
-          include Datadog::DeprecatedPin
-
-          DEPRECATION_WARNING = %(
-            Use of Datadog::Pin with GRPC is DEPRECATED.
-            Upgrade to the configuration API using the migration guide here:
-            https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-          def tracer=(tracer)
-            Datadog.configuration[:grpc][:tracer] = tracer
-          end
-
-          def service_name=(service_name)
-            Datadog.configuration[:grpc][:service_name] = service_name
-          end
-
-          def log_deprecation_warning(method_name)
-            do_once(method_name) do
-              Datadog::Logger.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/http/circuit_breaker.rb

@@ -1,63 +0,0 @@
-module Datadog
-  module Contrib
-    module HTTP
-      # HTTP integration circuit breaker behavior
-      # For avoiding recursive traces.
-      module CircuitBreaker
-        def should_skip_tracing?(req, address, port, tracer)
-          return true if datadog_http_request?(req, address, port, tracer)
-
-          # we don't want a "shotgun" effect with two nested traces for one
-          # logical get, and request is likely to call itself recursively
-          active = tracer.active_span
-          return true if active && (active.name == Ext::SPAN_REQUEST)
-
-          false
-        end
-
-        # We don't want to trace our own call to the API (they use net/http)
-        # TODO: We don't want this kind of coupling with the transport.
-        #       Remove this when transport implements its own "skip tracing" mechanism.
-        def datadog_http_request?(req, address, port, tracer)
-          transport = tracer.writer.transport
-
-          transport_hostname = nil
-          transport_port = nil
-
-          # Get settings from transport, if available.
-          case transport
-          when Datadog::Transport::HTTP::Client
-            adapter = transport.current_api.adapter
-            if adapter.is_a?(Datadog::Transport::HTTP::Adapters::Net)
-              transport_hostname = adapter.hostname.to_s
-              transport_port = adapter.port.to_i
-            end
-          end
-
-          # When we know the host & port (from the URI) we use it, else (most-likely
-          # called with a block) rely on the URL at the end.
-          if req.respond_to?(:uri) && req.uri
-            if req.uri.host.to_s == transport_hostname &&
-               req.uri.port.to_i == transport_port
-              return true
-            end
-          elsif address && port &&
-                address.to_s == transport_hostname &&
-                port.to_i == transport_port
-            return true
-          end
-
-          false
-        end
-
-        def should_skip_distributed_tracing?(pin)
-          if pin.config && pin.config.key?(:distributed_tracing)
-            return !pin.config[:distributed_tracing]
-          end
-
-          !Datadog.configuration[:http][:distributed_tracing]
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/http/ext'
-
-module Datadog
-  module Contrib
-    module HTTP
-      module Configuration
-        # Custom settings for the HTTP integration
-        class Settings < Contrib::Configuration::Settings
-          option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 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/http/ext.rb

@@ -1,14 +0,0 @@
-module Datadog
-  module Contrib
-    module HTTP
-      # HTTP integration constants
-      module Ext
-        APP = 'net/http'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_HTTP_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_HTTP_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'net/http'.freeze
-        SPAN_REQUEST = 'http.request'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/http/instrumentation.rb

@@ -1,170 +0,0 @@
-require 'uri'
-require 'ddtrace/pin'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/http_annotation_helper'
-
-module Datadog
-  module Contrib
-    module HTTP
-      # Instrumentation for Net::HTTP
-      module Instrumentation
-        def self.included(base)
-          base.send(:prepend, InstanceMethods)
-        end
-
-        # Span hook invoked after request is completed.
-        def self.after_request(&block)
-          if block_given?
-            # Set hook
-            @after_request = block
-          else
-            # Get hook
-            @after_request ||= nil
-          end
-        end
-
-        # InstanceMethods - implementing instrumentation
-        module InstanceMethods
-          include Datadog::Contrib::HttpAnnotationHelper
-
-          def request(req, body = nil, &block) # :yield: +response+
-            host, = host_and_port(req)
-            request_options = datadog_configuration(host)
-            pin = datadog_pin(request_options)
-            return super(req, body, &block) unless pin && pin.tracer
-
-            if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, pin.tracer)
-              return super(req, body, &block)
-            end
-
-            pin.tracer.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span|
-              begin
-                # even though service_name might already be in request_options,
-                # we need to capture the name from the pin since it could be
-                # overridden
-                request_options[:service_name] = pin.service_name
-                span.service = service_name(host, request_options)
-                span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
-                span.resource = req.method
-
-                if pin.tracer.enabled && !Datadog::Contrib::HTTP.should_skip_distributed_tracing?(pin)
-                  Datadog::HTTPPropagator.inject!(span.context, req)
-                end
-
-                # Add additional request specific tags to the span.
-                annotate_span_with_request!(span, req, request_options)
-              rescue StandardError => e
-                Datadog::Logger.log.error("error preparing span for http request: #{e}")
-              ensure
-                response = super(req, body, &block)
-              end
-
-              # Add additional response specific tags to the span.
-              annotate_span_with_response!(span, response)
-
-              # Invoke hook, if set.
-              unless Contrib::HTTP::Instrumentation.after_request.nil?
-                Contrib::HTTP::Instrumentation.after_request.call(span, self, req, response)
-              end
-
-              response
-            end
-          end
-
-          def annotate_span_with_request!(span, request, request_options)
-            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, request.method)
-
-            host, port = host_and_port(request)
-            span.set_tag(Datadog::Ext::NET::TARGET_HOST, host)
-            span.set_tag(Datadog::Ext::NET::TARGET_PORT, port.to_s)
-
-            # Set analytics sample rate
-            set_analytics_sample_rate(span, request_options)
-          end
-
-          def annotate_span_with_response!(span, response)
-            return unless response && response.code
-
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.code)
-
-            case response.code.to_i
-            when 400...599
-              span.set_error(response)
-            end
-          end
-
-          def annotate_span_with_error!(span, error)
-            span.set_error(error)
-          end
-
-          def set_analytics_sample_rate(span, request_options)
-            return unless analytics_enabled?(request_options)
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate(request_options))
-          end
-
-          def datadog_pin(config = Datadog.configuration[:http])
-            service = config[:service_name]
-            tracer = config[:tracer]
-
-            @datadog_pin ||= begin
-              Datadog::Pin.new(service, app: Ext::APP, app_type: Datadog::Ext::AppTypes::WEB, tracer: tracer)
-            end
-
-            # this shockingly poor code exists to solve the case where someone
-            # calls datadog_pin on this object before running a request, which
-            # would cause the :default config to be used. If a request is then
-            # run for a hostname that matches a different configuration, we
-            # would use the wrong configs since the pin is memoized.
-            # The solution is to detect if we are using the default config and
-            # apply the new config if necessary, while still allowing custom
-            # values to be supplied
-            if @datadog_pin.service_name == default_datadog_pin.service_name && @datadog_pin.service_name != service
-              @datadog_pin.service = service
-            end
-            if @datadog_pin.tracer == default_datadog_pin.tracer && @datadog_pin.tracer != tracer
-              @datadog_pin.tracer = tracer
-            end
-
-            @datadog_pin
-          end
-
-          def default_datadog_pin
-            config = Datadog.configuration[:http]
-            service = config[:service_name]
-            tracer = config[:tracer]
-            @default_datadog_pin ||= begin
-              Datadog::Pin.new(service, app: Ext::APP, app_type: Datadog::Ext::AppTypes::WEB, tracer: tracer)
-            end
-          end
-
-          private
-
-          def host_and_port(request)
-            if request.respond_to?(:uri) && request.uri
-              [request.uri.host, request.uri.port]
-            else
-              [@address, @port]
-            end
-          end
-
-          def datadog_configuration(host = :default)
-            Datadog.configuration[:http, host]
-          end
-
-          def analytics_enabled?(request_options)
-            Contrib::Analytics.enabled?(request_options[:analytics_enabled])
-          end
-
-          def analytics_sample_rate(request_options)
-            request_options[:analytics_sample_rate]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-require 'ddtrace/version'
-
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/http/configuration/settings'
-require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
-require 'ddtrace/contrib/http/patcher'
-require 'ddtrace/contrib/http/circuit_breaker'
-
-module Datadog
-  module Contrib
-    # HTTP integration
-    module HTTP
-      extend CircuitBreaker
-
-      # Description of HTTP integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Datadog::VERSION::MINIMUM_RUBY_VERSION
-
-        register_as :http, auto_patch: true
-
-        def self.version
-          Gem::Version.new(RUBY_VERSION)
-        end
-
-        def self.loaded?
-          !defined?(::Net::HTTP).nil?
-        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/http/patcher.rb

@@ -1,26 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/http/ext'
-require 'ddtrace/contrib/http/instrumentation'
-
-module Datadog
-  module Contrib
-    # Datadog Net/HTTP integration.
-    module HTTP
-      # Patcher enables patching of 'net/http' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        # patch applies our patch if needed
-        def patch
-          ::Net::HTTP.send(:include, Instrumentation)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/http_annotation_helper.rb

@@ -1,10 +0,0 @@
-module Datadog
-  module Contrib
-    # Contains methods helpful for tracing/annotating HTTP request libraries
-    module HttpAnnotationHelper
-      def service_name(hostname, configuration_options)
-        configuration_options[:split_by_domain] ? hostname : configuration_options[:service_name]
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/integration.rb

@@ -1,16 +0,0 @@
-require 'ddtrace/contrib/configurable'
-require 'ddtrace/contrib/patchable'
-require 'ddtrace/contrib/registerable'
-
-module Datadog
-  module Contrib
-    # Base provides features that are shared across all integrations
-    module Integration
-      def self.included(base)
-        base.send(:include, Configurable)
-        base.send(:include, Patchable)
-        base.send(:include, Registerable)
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/mongodb/ext'
-
-module Datadog
-  module Contrib
-    module MongoDB
-      module Configuration
-        # Custom settings for the MongoDB integration
-        class Settings < Contrib::Configuration::Settings
-          DEFAULT_QUANTIZE = { show: [:collection, :database, :operation] }.freeze
-
-          option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
-            o.lazy
-          end
-
-          option :quantize, default: DEFAULT_QUANTIZE
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Datadog
-  module Contrib
-    module MongoDB
-      # MongoDB integration constants
-      module Ext
-        APP = 'mongodb'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_MONGO_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_MONGO_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'mongodb'.freeze
-        SPAN_COMMAND = 'mongo.cmd'.freeze
-        SPAN_TYPE_COMMAND = 'mongodb'.freeze
-        TAG_COLLECTION = 'mongodb.collection'.freeze
-        TAG_DB = 'mongodb.db'.freeze
-        TAG_OPERATION = 'mongodb.operation'.freeze
-        TAG_QUERY = 'mongodb.query'.freeze
-        TAG_ROWS = 'mongodb.rows'.freeze
-      end
-    end
-  end
-end