ddtrace 0.8.2 → 0.9.0

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

@@ -0,0 +1,57 @@
+module Datadog
+  module Contrib
+    # MongoDB module includes classes and functions to instrument MongoDB clients
+    module MongoDB
+      module_function
+
+      # skipped keys are related to command names, since they are already
+      # extracted by the query_builder
+      SKIP_KEYS = [:_id].freeze
+      PLACEHOLDER = '?'.freeze
+
+      # returns a formatted and normalized query
+      def query_builder(command_name, database_name, command)
+        # always skip the command name
+        skip = SKIP_KEYS | [command_name.to_s]
+
+        result = {
+          operation: command_name,
+          database: database_name,
+          collection: command.values.first
+        }
+
+        command.each do |key, value|
+          result[key] = quantize_statement(value, skip) unless skip.include?(key)
+        end
+
+        result
+      end
+
+      # removes the values from the given query; this quantization recursively
+      # replace elements available in a given query, so that Arrays, Hashes and so
+      # on are compacted. It ensures a low cardinality so that it can be used
+      # as a Span resource.
+      def quantize_statement(statement, skip = [])
+        case statement
+        when Hash
+          statement.each_with_object({}) do |(key, value), quantized|
+            quantized[key] = quantize_value(value, skip) unless skip.include?(key)
+          end
+        else
+          quantize_value(statement, skip)
+        end
+      end
+
+      def quantize_value(value, skip = [])
+        case value
+        when Hash
+          quantize_statement(value, skip)
+        when Array
+          quantize_value(value.first, skip)
+        else
+          PLACEHOLDER
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    # MongoDB module includes classes and functions to instrument MongoDB clients
+    module MongoDB
+      APP = 'mongodb'.freeze
+      SERVICE = 'mongodb'.freeze
+
+      # Patcher adds subscribers to the MongoDB driver so that each command is traced.
+      # Use the `Datadog::Monkey.patch_module(:mongodb)` to activate tracing for
+      # this module.
+      module Patcher
+        @patched = false
+
+        module_function
+
+        def patched?
+          @patched
+        end
+
+        def patch
+          # versions prior to 2.1.0 don't support the Monitoring API
+          if !@patched && (defined?(::Mongo::Monitoring::Global) && \
+                  Gem::Version.new(::Mongo::VERSION) >= Gem::Version.new('2.1.0'))
+            begin
+              require 'ddtrace/pin'
+              require 'ddtrace/ext/net'
+              require 'ddtrace/ext/mongo'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/mongodb/parsers'
+              require 'ddtrace/contrib/mongodb/subscribers'
+
+              patch_mongo_client()
+              add_mongo_monitoring()
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply MongoDB integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        def add_mongo_monitoring
+          # Subscribe to all COMMAND queries with our subscriber class
+          ::Mongo::Monitoring::Global.subscribe(
+            ::Mongo::Monitoring::COMMAND,
+            Datadog::Contrib::MongoDB::MongoCommandSubscriber.new
+          )
+        end
+
+        def patch_mongo_client
+          ::Mongo::Client.class_eval do
+            alias_method :initialize_without_datadog, :initialize
+            Datadog::Monkey.without_warnings do
+              remove_method :initialize
+            end
+
+            def initialize(*args, &blk)
+              # attach the Pin instance
+              initialize_without_datadog(*args, &blk)
+              pin = Datadog::Pin.new(SERVICE, app: APP, app_type: Datadog::Ext::AppTypes::DB)
+              pin.onto(self)
+              if pin.tracer && pin.service
+                pin.tracer.set_service_info(pin.service, 'mongodb', pin.app_type)
+              end
+            end
+
+            def datadog_pin
+              # safe-navigation to avoid crashes during each query
+              return unless respond_to? :cluster
+              return unless cluster.respond_to? :addresses
+              return unless cluster.addresses.respond_to? :first
+              Datadog::Pin.get_from(cluster.addresses.first)
+            end
+
+            def datadog_pin=(pin)
+              # safe-navigation to avoid crashes during each query
+              return unless respond_to? :cluster
+              return unless cluster.respond_to? :addresses
+              return unless cluster.addresses.respond_to? :each
+              # attach the PIN to all cluster addresses. One of them is used
+              # when executing a Command and it is attached to the Monitoring
+              # Event instance.
+              cluster.addresses.each { |x| pin.onto(x) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Datadog
+  module Contrib
+    # MongoDB module includes classes and functions to instrument MongoDB clients
+    module MongoDB
+      # `MongoCommandSubscriber` listens to all events from the `Monitoring`
+      # system available in the Mongo driver.
+      class MongoCommandSubscriber
+        def started(event)
+          pin = Datadog::Pin.get_from(event.address)
+          return unless pin && pin.enabled?
+
+          # start a trace and store it in the current thread; using the `operation_id`
+          # is safe since it's a unique id used to link events together. Also only one
+          # thread is involved in this execution so thread-local storage should be safe. Reference:
+          # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/monitoring.rb#L70
+          # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/monitoring/publishable.rb#L38-L56
+          span = pin.tracer.trace('mongo.cmd', service: pin.service, span_type: Datadog::Ext::Mongo::TYPE)
+          Thread.current[:datadog_mongo_span] = span
+
+          # build a quantized Query using the Parser module
+          query = Datadog::Contrib::MongoDB.query_builder(event.command_name, event.database_name, event.command)
+          serialized_query = query.to_s
+
+          # add operation tags; the full query is stored and used as a resource,
+          # since it has been quantized and reduced
+          span.set_tag(Datadog::Ext::Mongo::DB, query[:database])
+          span.set_tag(Datadog::Ext::Mongo::COLLECTION, query[:collection])
+          span.set_tag(Datadog::Ext::Mongo::OPERATION, query[:operation])
+          span.set_tag(Datadog::Ext::Mongo::QUERY, serialized_query)
+          span.set_tag(Datadog::Ext::NET::TARGET_HOST, event.address.host)
+          span.set_tag(Datadog::Ext::NET::TARGET_PORT, event.address.port)
+
+          # set the resource with the quantized query
+          span.resource = serialized_query
+        end
+
+        def failed(event)
+          span = Thread.current[:datadog_mongo_span]
+          return unless span
+
+          # the failure is not a real exception because it's handled by
+          # the framework itself, so we set only the error and the message
+          span.set_error(event)
+        rescue StandardError => e
+          Datadog::Tracer.log.debug("error when handling MongoDB 'failed' event: #{e}")
+        ensure
+          # whatever happens, the Span must be removed from the local storage and
+          # it must be finished to prevent any leak
+          span.finish() unless span.nil?
+          Thread.current[:datadog_mongo_span] = nil
+        end
+
+        def succeeded(event)
+          span = Thread.current[:datadog_mongo_span]
+          return unless span
+
+          # add fields that are available only after executing the query
+          rows = event.reply.fetch('n', nil)
+          span.set_tag(Datadog::Ext::Mongo::ROWS, rows) unless rows.nil?
+        rescue StandardError => e
+          Datadog::Tracer.log.debug("error when handling MongoDB 'succeeded' event: #{e}")
+        ensure
+          # whatever happens, the Span must be removed from the local storage and
+          # it must be finished to prevent any leak
+          span.finish() unless span.nil?
+          Thread.current[:datadog_mongo_span] = nil
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/rails/action_controller.rb

@@ -6,40 +6,40 @@ module Datadog
     module Rails
       # Code used to create and handle 'rails.action_controller' spans.
       module ActionController
-        KEY = 'datadog_actioncontroller'.freeze
-
         def self.instrument
+          # patch Rails core components
+          Datadog::RailsActionPatcher.patch_action_controller
+
           # subscribe when the request processing starts
-          ::ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |*args|
+          ::ActiveSupport::Notifications.subscribe('!datadog.start_processing.action_controller') do |*args|
             start_processing(*args)
           end
 
           # subscribe when the request processing has been completed
-          ::ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
-            process_action(*args)
+          ::ActiveSupport::Notifications.subscribe('!datadog.finish_processing.action_controller') do |*args|
+            finish_processing(*args)
           end
         end
 
-        def self.start_processing(*)
-          return if Thread.current[KEY]
-
+        def self.start_processing(_name, _start, _finish, _id, payload)
+          # trace the execution
           tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
           service = ::Rails.configuration.datadog_trace.fetch(:default_controller_service)
           type = Datadog::Ext::HTTP::TYPE
-          tracer.trace('rails.action_controller', service: service, span_type: type)
+          span = tracer.trace('rails.action_controller', service: service, span_type: type)
 
-          Thread.current[KEY] = true
+          # attach the current span to the tracing context
+          tracing_context = payload.fetch(:tracing_context)
+          tracing_context[:dd_request_span] = span
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
         end
 
-        def self.process_action(_name, start, finish, _id, payload)
-          return unless Thread.current[KEY]
-          Thread.current[KEY] = false
-
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          span = tracer.active_span()
-          return unless span
+        def self.finish_processing(_name, start, finish, _id, payload)
+          # retrieve the tracing context and the latest active span
+          tracing_context = payload.fetch(:tracing_context)
+          span = tracing_context[:dd_request_span]
+          return unless span && !span.finished?
 
           begin
             resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
@@ -69,8 +69,7 @@ module Datadog
               span.set_error(error) if status.starts_with?('5')
             end
           ensure
-            span.start_time = start
-            span.finish(finish)
+            span.finish()
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)

data/lib/ddtrace/contrib/rails/action_view.rb

@@ -10,99 +10,89 @@ module Datadog
           Datadog::RailsRendererPatcher.patch_renderer()
 
           # subscribe when the template rendering starts
-          ::ActiveSupport::Notifications.subscribe('start_render_template.action_view') do |*args|
+          ::ActiveSupport::Notifications.subscribe('!datadog.start_render_template.action_view') do |*args|
             start_render_template(*args)
           end
 
-          # subscribe when the partial rendering starts
-          ::ActiveSupport::Notifications.subscribe('start_render_partial.action_view') do |*args|
-            start_render_partial(*args)
+          # subscribe when the template rendering has been processed
+          ::ActiveSupport::Notifications.subscribe('!datadog.finish_render_template.action_view') do |*args|
+            finish_render_template(*args)
           end
 
-          # subscribe when the template rendering has been processed
-          ::ActiveSupport::Notifications.subscribe('render_template.action_view') do |*args|
-            render_template(*args)
+          # subscribe when the partial rendering starts
+          ::ActiveSupport::Notifications.subscribe('!datadog.start_render_partial.action_view') do |*args|
+            start_render_partial(*args)
           end
 
           # subscribe when the partial rendering has been processed
-          ::ActiveSupport::Notifications.subscribe('render_partial.action_view') do |*args|
-            render_partial(*args)
+          ::ActiveSupport::Notifications.subscribe('!datadog.finish_render_partial.action_view') do |*args|
+            finish_render_partial(*args)
           end
         end
 
-        def self.get_key(f)
-          'datadog_actionview_' + f
-        end
-
-        def self.start_render_template(*)
-          key = get_key('render_template')
-          return if Thread.current[key]
+        def self.start_render_template(_name, _start, _finish, _id, payload)
+          # retrieve the tracing context
+          tracing_context = payload.fetch(:tracing_context)
 
+          # create a new Span and add it to the tracing context
           tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          type = Datadog::Ext::HTTP::TEMPLATE
-          tracer.trace('rails.render_template', span_type: type)
-
-          Thread.current[key] = true
+          span = tracer.trace('rails.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE)
+          tracing_context[:dd_rails_template_span] = span
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.start_render_partial(*)
-          key = get_key('render_partial')
-          return if Thread.current[key]
+        def self.finish_render_template(_name, _start, _finish, _id, payload)
+          # retrieve the tracing context and the latest active span
+          tracing_context = payload.fetch(:tracing_context)
+          span = tracing_context[:dd_rails_template_span]
+          return if !span || span.finished?
 
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          type = Datadog::Ext::HTTP::TEMPLATE
-          tracer.trace('rails.render_partial', span_type: type)
+          # finish the tracing and update the execution time
+          begin
+            template_name = tracing_context[:template_name]
+            layout = tracing_context[:layout]
+            exception = tracing_context[:exception]
 
-          Thread.current[key] = true
+            span.set_tag('rails.template_name', template_name) if template_name
+            span.set_tag('rails.layout', layout) if layout
+            span.set_error(exception) if exception
+          ensure
+            span.finish()
+          end
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.render_template(_name, start, finish, _id, payload)
-          key = get_key('render_template')
-          return unless Thread.current[key]
-          Thread.current[key] = false
+        def self.start_render_partial(_name, _start, _finish, _id, payload)
+          # retrieve the tracing context
+          tracing_context = payload.fetch(:tracing_context)
 
-          # finish the tracing and update the execution time
           tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          span = tracer.active_span()
-          return unless span
-
-          begin
-            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(payload.fetch(:identifier))
-            span.set_tag('rails.template_name', template_name)
-            span.set_tag('rails.layout', payload.fetch(:layout))
-            span.set_error(payload[:exception]) if payload[:exception]
-          ensure
-            span.start_time = start
-            span.finish(finish)
-          end
+          span = tracer.trace('rails.render_partial', span_type: Datadog::Ext::HTTP::TEMPLATE)
+          tracing_context[:dd_rails_partial_span] = span
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.render_partial(_name, start, finish, _id, payload)
-          key = get_key('render_partial')
-          return unless Thread.current[key]
-          Thread.current[key] = false
+        def self.finish_render_partial(_name, start, finish, _id, payload)
+          # retrieve the tracing context and the latest active span
+          tracing_context = payload.fetch(:tracing_context)
+          span = tracing_context[:dd_rails_partial_span]
+          return if !span || span.finished?
 
           # finish the tracing and update the execution time
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          span = tracer.active_span()
-          return unless span
-
           begin
-            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(payload.fetch(:identifier))
-            span.set_tag('rails.template_name', template_name)
-            span.set_error(payload[:exception]) if payload[:exception]
+            template_name = tracing_context[:template_name]
+            exception = tracing_context[:exception]
+
+            span.set_tag('rails.template_name', template_name) if template_name
+            span.set_error(exception) if exception
           ensure
-            span.start_time = start
-            span.finish(finish)
+            span.finish()
           end
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
       end
     end

data/lib/ddtrace/contrib/rails/active_support.rb

@@ -11,102 +11,58 @@ module Datadog
           Datadog::RailsCachePatcher.patch_cache_store()
 
           # subscribe when a cache read starts being processed
-          ::ActiveSupport::Notifications.subscribe('start_cache_read.active_support') do |*args|
-            start_trace_cache('GET', *args)
-          end
-
-          # subscribe when a cache fetch starts being processed
-          ::ActiveSupport::Notifications.subscribe('start_cache_fetch.active_support') do |*args|
-            start_trace_cache('GET', *args)
-          end
-
-          # subscribe when a cache write starts being processed
-          ::ActiveSupport::Notifications.subscribe('start_cache_write.active_support') do |*args|
-            start_trace_cache('SET', *args)
-          end
-
-          # subscribe when a cache delete starts being processed
-          ::ActiveSupport::Notifications.subscribe('start_cache_delete.active_support') do |*args|
-            start_trace_cache('DELETE', *args)
+          ::ActiveSupport::Notifications.subscribe('!datadog.start_cache_tracing.active_support') do |*args|
+            start_trace_cache(*args)
           end
 
           # subscribe when a cache read has been processed
-          ::ActiveSupport::Notifications.subscribe('cache_read.active_support') do |*args|
-            trace_cache('GET', *args)
+          ::ActiveSupport::Notifications.subscribe('!datadog.finish_cache_tracing.active_support') do |*args|
+            finish_trace_cache(*args)
           end
+        end
 
-          # subscribe when a cache write has been processed
-          ::ActiveSupport::Notifications.subscribe('cache_write.active_support') do |*args|
-            trace_cache('SET', *args)
-          end
+        def self.start_trace_cache(_name, _start, _finish, _id, payload)
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          tracing_context = payload.fetch(:tracing_context)
 
-          # subscribe when a cache delete has been processed
-          ::ActiveSupport::Notifications.subscribe('cache_delete.active_support') do |*args|
-            trace_cache('DELETE', *args)
-          end
-        end
+          # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
+          # This check ensures that two reads are not nested since they don't provide
+          # interesting details.
+          # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
+          # to avoid any kind of issue.
+          current_span = tracer.active_span
+          return if current_span.try('name') == 'rails.cache' &&
+                    current_span.try('resource') == 'GET' &&
+                    payload[:action] == 'GET'
 
-        def self.create_span(tracer)
+          # create a new ``Span`` and add it to the tracing context
           service = ::Rails.configuration.datadog_trace.fetch(:default_cache_service)
           type = Datadog::Ext::CACHE::TYPE
-          tracer.trace('rails.cache', service: service, span_type: type)
-        end
-
-        def self.get_key(resource)
-          'datadog_activesupport_' + resource
-        end
-
-        def self.start_trace_cache(resource, *_args)
-          key = get_key(resource)
-          # This is mostly to trap the case of fetch/read. In some cases the framework
-          # will call fetch but fetch won't call read. In some cases read can be called
-          # alone. And in some cases they are nested. In all cases we want to have one
-          # and only one span.
-          return if Thread.current[key]
-          create_span(::Rails.configuration.datadog_trace.fetch(:tracer))
-          Thread.current[key] = true
+          span = tracer.trace('rails.cache', service: service, span_type: type)
+          span.resource = payload.fetch(:action)
+          tracing_context[:dd_cache_span] = span
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
 
-        def self.trace_cache(resource, _name, start, finish, _id, payload)
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          key = get_key(resource)
-          if Thread.current[key]
-            # span was created by start_trace_cache, plan to re-use this one
-            Thread.current[key] = false
-          else
-            # Create a span now, as start_trace_cache was not called.
-            #
-            # This could typically happen if, for some reason the monkey-patching
-            # of the cache class did not work as expected. Doing this, we might
-            # loose some interesting parentship between some spans, because this
-            # span is created too late, and children won't "find" their parent.
-            # But, it's better than no span at all, and it case there is no child
-            # at all, it will work just as expected. In practice, it's required to
-            # have standard file cache work together with redis cache.
-            create_span(tracer)
-          end
-          span = tracer.active_span()
-          return unless span
+        def self.finish_trace_cache(_name, _start, _finish, _id, payload)
+          # retrieve the tracing context and continue the trace
+          tracing_context = payload.fetch(:tracing_context)
+          span = tracing_context[:dd_cache_span]
+          return unless span && !span.finished?
 
           begin
-            # finish the tracing and update the execution time
-            span.resource = resource
             # discard parameters from the cache_store configuration
             store, = *Array.wrap(::Rails.configuration.cache_store).flatten
             span.set_tag('rails.cache.backend', store)
             span.set_tag('rails.cache.key', payload.fetch(:key))
             span.set_error(payload[:exception]) if payload[:exception]
           ensure
-            span.start_time = start
-            span.finish(finish)
+            span.finish()
           end
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
-
-        private_class_method :create_span, :get_key, :start_trace_cache, :trace_cache
       end
     end
   end