ddtrace 0.12.1 → 0.13.0.beta1

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

@@ -0,0 +1,50 @@
+require 'ddtrace/ext/app_types'
+
+module Datadog
+  module Contrib
+    module Excon
+      # Responsible for hooking the instrumentation into Excon
+      module Patcher
+        include Base
+
+        DEFAULT_SERVICE = 'excon'.freeze
+
+        register_as :excon
+        option :tracer, default: Datadog.tracer
+        option :service_name, default: DEFAULT_SERVICE
+        option :distributed_tracing, default: false
+        option :split_by_domain, default: false
+        option :error_handler, default: nil
+
+        @patched = false
+
+        module_function
+
+        def patch
+          return @patched if patched? || !compatible?
+
+          require 'ddtrace/contrib/excon/middleware'
+
+          add_middleware
+
+          @patched = true
+        rescue => e
+          Tracer.log.error("Unable to apply Excon integration: #{e}")
+          @patched
+        end
+
+        def patched?
+          @patched
+        end
+
+        def compatible?
+          defined?(::Excon)
+        end
+
+        def add_middleware
+          ::Excon.defaults[:middlewares] = Middleware.around_default_stack
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Datadog
+  module Contrib
+    module GRPC
+      # :nodoc:
+      module DatadogInterceptor
+        # :nodoc:
+        class Base < ::GRPC::Interceptor
+          attr_accessor :datadog_pin
+
+          def initialize(options = {})
+            datadog_pin_configuration { |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 datadog_pin_configuration
+            pin = default_datadog_pin
+
+            if block_given?
+              pin = Pin.new(
+                pin.service_name,
+                app: pin.app,
+                app_type: pin.app_type,
+                tracer: pin.tracer
+              )
+
+              yield(pin)
+            end
+
+            pin.onto(self)
+
+            pin
+          end
+
+          def default_datadog_pin
+            Pin.get_from(::GRPC)
+          end
+
+          def tracer
+            datadog_pin.tracer
+          end
+        end
+
+        require_relative 'datadog_interceptor/client'
+        require_relative 'datadog_interceptor/server'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Datadog
+  module Contrib
+    module GRPC
+      module DatadogInterceptor
+        # The DatadogInterceptor::Client implements the tracing strategy
+        # for gRPC client-side endpoitns. This middleware compoent will
+        # inject trace context information into gRPC metadata prior to
+        # sending the request to the server.
+        class Client < Base
+          def trace(keywords)
+            keywords[:metadata] ||= {}
+
+            options = {
+              span_type: Datadog::Ext::GRPC::TYPE,
+              service: datadog_pin.service_name,
+              resource: format_resource(keywords[:method])
+            }
+
+            tracer.trace('grpc.client', options) do |span|
+              annotate!(span, keywords[:metadata])
+
+              yield
+            end
+          end
+
+          private
+
+          def annotate!(span, metadata)
+            metadata.each do |header, value|
+              span.set_tag(header, value)
+            end
+
+            Datadog::GRPCPropagator
+              .inject!(span.context, metadata)
+          rescue StandardError => e
+            Datadog::Tracer.log.debug("GRPC client trace failed: #{e}")
+          end
+
+          def format_resource(proto_method)
+            proto_method.downcase
+                        .split('/')
+                        .reject(&:empty?)
+                        .join('.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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::GRPC::TYPE,
+              service: datadog_pin.service_name,
+              resource: format_resource(keywords[:method])
+            }
+            metadata = keywords[:call].metadata
+
+            set_distributed_context!(tracer, metadata)
+
+            tracer.trace('grpc.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::Tracer.log.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
+          rescue StandardError => e
+            Datadog::Tracer.log.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/intercept_with_datadog.rb

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

@@ -0,0 +1,62 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    module GRPC
+      SERVICE = 'grpc'.freeze
+
+      # Patcher enables patching of 'grpc' module.
+      module Patcher
+        include Base
+        register_as :grpc, auto_patch: true
+        option :tracer, default: Datadog.tracer
+        option :service_name, default: SERVICE
+
+        @patched = false
+
+        module_function
+
+        def patch
+          return false unless compatible?
+          return @patched if @patched
+
+          require 'ddtrace/ext/grpc'
+          require 'ddtrace/propagation/grpc_propagator'
+          require 'ddtrace/contrib/grpc/datadog_interceptor'
+          require 'ddtrace/contrib/grpc/intercept_with_datadog'
+
+          add_pin
+          prepend_interceptor
+
+          @patched = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error("Unable to apply gRPC integration: #{e}")
+        ensure
+          @patched
+        end
+
+        def compatible?
+          defined?(::GRPC::VERSION) && Gem::Version.new(::GRPC::VERSION) >= Gem::Version.new('0.10.0')
+        end
+
+        def patched?
+          @patched
+        end
+
+        def add_pin
+          Pin.new(
+            get_option(:service_name),
+            app: 'grpc',
+            app_type: 'grpc',
+            tracer: get_option(:tracer)
+          ).onto(::GRPC)
+        end
+
+        def prepend_interceptor
+          ::GRPC::InterceptionContext
+            .prepend(Datadog::Contrib::GRPC::InterceptWithDatadog)
+        end
+      end
+    end
+  end
+end

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

@@ -48,8 +48,6 @@ module Datadog
         include Base
         register_as :http, auto_patch: true
         option :distributed_tracing, default: false
-        option :service_name, default: SERVICE
-        option :tracer, default: Datadog.tracer
 
         @patched = false
 
@@ -66,7 +64,7 @@ module Datadog
               require 'ddtrace/ext/net'
               require 'ddtrace/ext/distributed'
 
-              patch_http
+              patch_http()
 
               @patched = true
             rescue StandardError => e
@@ -76,7 +74,7 @@ module Datadog
           @patched
         end
 
-        # patched? tells whether patch has been successfully applied
+        # patched? tells wether patch has been successfully applied
         def patched?
           @patched
         end
@@ -86,27 +84,27 @@ module Datadog
         # rubocop:disable Metrics/AbcSize
         def patch_http
           ::Net::HTTP.class_eval do
-            alias_method :request_without_datadog, :request
-            remove_method :request
-
-            def datadog_pin
-              @datadog_pindatadog_pin ||= begin
-                service = Datadog.configuration[:http][:service_name]
-                tracer = Datadog.configuration[:http][:tracer]
+            alias_method :initialize_without_datadog, :initialize
+            Datadog::Patcher.without_warnings do
+              remove_method :initialize
+            end
 
-                Datadog::Pin.new(service, app: APP, app_type: Datadog::Ext::AppTypes::WEB, tracer: tracer)
-              end
+            def initialize(*args)
+              pin = Datadog::Pin.new(SERVICE, app: APP, app_type: Datadog::Ext::AppTypes::WEB)
+              pin.onto(self)
+              initialize_without_datadog(*args)
             end
 
+            alias_method :request_without_datadog, :request
+            remove_method :request
+
             def request(req, body = nil, &block) # :yield: +response+
-              pin = datadog_pin
+              pin = Datadog::Pin.get_from(self)
               return request_without_datadog(req, body, &block) unless pin && pin.tracer
 
               transport = pin.tracer.writer.transport
-
-              if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
-                return request_without_datadog(req, body, &block)
-              end
+              return request_without_datadog(req, body, &block) if
+                Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
 
               pin.tracer.trace(NAME) do |span|
                 begin

data/lib/ddtrace/contrib/racecar/event.rb

@@ -0,0 +1,61 @@
+require 'ddtrace/contrib/active_support/notifications/event'
+
+module Datadog
+  module Contrib
+    module Racecar
+      # Defines basic behaviors for an ActiveRecord event.
+      module Event
+        def self.included(base)
+          base.send(:include, ActiveSupport::Notifications::Event)
+          base.send(:extend, ClassMethods)
+        end
+
+        # Class methods for Racecar events.
+        # Note, they share the same process method and before_trace method.
+        module ClassMethods
+          def subscription(*args)
+            super.tap do |subscription|
+              subscription.before_trace { ensure_clean_context! }
+            end
+          end
+
+          def span_options
+            { service: configuration[:service_name] }
+          end
+
+          def tracer
+            configuration[:tracer]
+          end
+
+          def configuration
+            Datadog.configuration[:racecar]
+          end
+
+          def process(span, event, _id, payload)
+            span.service = configuration[:service_name]
+            span.resource = payload[:consumer_class]
+
+            span.set_tag('kafka.topic', payload[:topic])
+            span.set_tag('kafka.consumer', payload[:consumer_class])
+            span.set_tag('kafka.partition', payload[:partition])
+            span.set_tag('kafka.offset', payload[:offset]) if payload.key?(:offset)
+            span.set_tag('kafka.first_offset', payload[:first_offset]) if payload.key?(:first_offset)
+            span.set_tag('kafka.message_count', payload[:message_count]) if payload.key?(:message_count)
+            span.set_error(payload[:exception_object]) if payload[:exception_object]
+          end
+
+          private
+
+          # Context objects are thread-bound.
+          # If Racecar re-uses threads, context from a previous trace
+          # could leak into the new trace. This "cleans" current context,
+          # preventing such a leak.
+          def ensure_clean_context!
+            return unless configuration[:tracer].call_context.current_span
+            configuration[:tracer].provider.context = Context.new
+          end
+        end
+      end
+    end
+  end
+end