ddtrace 0.54.2 → 1.0.0.beta1

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

@@ -1,80 +0,0 @@
-# typed: ignore
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/integration'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      module DatadogInterceptor
-        # The DatadogInterceptor::Server implements the tracing strategy
-        # for gRPC server-side endpoints. When the datadog fields have been
-        # added to the gRPC call metadata, this middleware component will
-        # extract any client-side tracing information, attempting to associate
-        # its tracing context with a parent client-side context
-        class Server < Base
-          def trace(keywords)
-            options = {
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-              service: service_name,
-              resource: format_resource(keywords[:method]),
-              on_error: error_handler
-            }
-            metadata = keywords[:call].metadata
-
-            set_distributed_context!(tracer, metadata)
-
-            tracer.trace(Ext::SPAN_SERVICE, options) do |span|
-              annotate!(span, metadata)
-
-              yield
-            end
-          end
-
-          private
-
-          def set_distributed_context!(tracer, metadata)
-            tracer.provider.context = Datadog::GRPCPropagator
-                                      .extract(metadata)
-          rescue StandardError => e
-            Datadog.logger.debug(
-              "unable to propagate GRPC metadata to context: #{e}"
-            )
-          end
-
-          def annotate!(span, metadata)
-            metadata.each do |header, value|
-              next if reserved_headers.include?(header)
-
-              span.set_tag(header, value)
-            end
-
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-            # Measure service stats
-            Contrib::Analytics.set_measured(span)
-          rescue StandardError => e
-            Datadog.logger.debug("GRPC client trace failed: #{e}")
-          end
-
-          def reserved_headers
-            [Datadog::Ext::DistributedTracing::GRPC_METADATA_TRACE_ID,
-             Datadog::Ext::DistributedTracing::GRPC_METADATA_PARENT_ID,
-             Datadog::Ext::DistributedTracing::GRPC_METADATA_SAMPLING_PRIORITY]
-          end
-
-          def format_resource(proto_method)
-            proto_method.owner
-                        .to_s
-                        .downcase
-                        .split('::')
-                        .<<(proto_method.name)
-                        .join('.')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# typed: ignore
-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, &block)
-            trace(keywords, &block)
-          end
-
-          def client_streamer(**keywords, &block)
-            trace(keywords, &block)
-          end
-
-          def server_streamer(**keywords, &block)
-            trace(keywords, &block)
-          end
-
-          def bidi_streamer(**keywords, &block)
-            trace(keywords, &block)
-          end
-
-          private
-
-          def add_datadog_pin!
-            Pin.new(
-              service_name,
-              app: Ext::APP,
-              app_type: Datadog::Ext::AppTypes::WEB,
-              tracer: -> { datadog_configuration[: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
-
-          def error_handler
-            datadog_configuration[:error_handler]
-          end
-        end
-
-        require_relative 'datadog_interceptor/client'
-        require_relative 'datadog_interceptor/server'
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module GRPC
-      # gRPC integration constants
-      module Ext
-        APP = 'grpc'.freeze
-        ENV_ENABLED = 'DD_TRACE_GRPC_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRPC_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_GRPC_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRPC_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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,39 +0,0 @@
-# typed: false
-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,50 +0,0 @@
-# typed: true
-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,34 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      # Patcher enables patching of 'grpc' module.
-      module Patcher
-        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-        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'
-
-          prepend_interceptor
-        end
-
-        def prepend_interceptor
-          ::GRPC::InterceptionContext
-            .prepend(Datadog::Contrib::GRPC::InterceptWithDatadog)
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module HTTP
-      # HTTP integration circuit breaker behavior
-      # For avoiding recursive traces.
-      module CircuitBreaker
-        def should_skip_tracing?(request, tracer)
-          return true if datadog_http_request?(request)
-
-          # 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 soft-check on HTTP requests.
-        #       Remove this when transport implements its own "skip tracing" mechanism.
-        def datadog_http_request?(request)
-          if request[Datadog::Ext::Transport::HTTP::HEADER_META_TRACER_VERSION]
-            true
-          else
-            false
-          end
-        end
-
-        def should_skip_distributed_tracing?(pin)
-          return !pin.config[:distributed_tracing] if pin.config && pin.config.key?(:distributed_tracing)
-
-          !Datadog.configuration[:http][:distributed_tracing]
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# typed: false
-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 :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/http/ext.rb

@@ -1,18 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module HTTP
-      # HTTP integration constants
-      module Ext
-        APP = 'net/http'.freeze
-        ENV_ENABLED = 'DD_TRACE_HTTP_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_HTTP_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_HTTP_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_HTTP_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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,180 +0,0 @@
-# typed: false
-require 'uri'
-require 'ddtrace/pin'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/integration'
-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.prepend(InstanceMethods)
-        end
-
-        # Span hook invoked after request is completed.
-        def self.after_request(&block)
-          if block
-            # Set hook
-            @after_request = block
-          else
-            # Get hook
-            @after_request ||= nil
-          end
-        end
-
-        # InstanceMethods - implementing instrumentation
-        module InstanceMethods
-          include Datadog::Contrib::HttpAnnotationHelper
-
-          # :yield: +response+
-          def request(req, body = nil, &block)
-            host, = host_and_port(req)
-            request_options = datadog_configuration(host)
-            pin = datadog_pin(request_options)
-            return super(req, body, &block) unless pin && pin.tracer
-
-            return super(req, body, &block) if Datadog::Contrib::HTTP.should_skip_tracing?(req, pin.tracer)
-
-            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.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)
-
-            # Tag as an external peer service
-            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-            # 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 ||= Datadog::Pin.new(
-              service,
-              app: Ext::APP,
-              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-              tracer: -> { config[:tracer] }
-            )
-
-            # 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]
-            @default_datadog_pin ||= Datadog::Pin.new(
-              service,
-              app: Ext::APP,
-              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-              tracer: -> { config[:tracer] }
-            )
-          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,46 +0,0 @@
-# typed: false
-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,27 +0,0 @@
-# typed: true
-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.include(Instrumentation)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/http_annotation_helper.rb

@@ -1,11 +0,0 @@
-# typed: true
-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