ddtrace 0.13.0 → 0.47.0

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

@@ -0,0 +1,26 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/kafka/ext'
+require 'ddtrace/contrib/kafka/events'
+
+module Datadog
+  module Contrib
+    module Kafka
+      # Patcher enables patching of 'kafka' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          # Subscribe to Kafka events
+          Events.subscribe!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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 :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 :quantize, default: DEFAULT_QUANTIZE
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Datadog
+  module Contrib
+    module MongoDB
+      # MongoDB integration constants
+      module Ext
+        APP = 'mongodb'.freeze
+        ENV_ENABLED = 'DD_TRACE_MONGO_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_MONGO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_MONGO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MONGO_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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

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

@@ -0,0 +1,69 @@
+require 'ddtrace/pin'
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/parsers'
+require 'ddtrace/contrib/mongodb/subscribers'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      # Instrumentation for Mongo integration
+      module Instrumentation
+        # Instrumentation for Mongo::Client
+        module Client
+          def self.included(base)
+            base.send(:include, InstanceMethods)
+          end
+
+          # Instance methods for Mongo::Client
+          module InstanceMethods
+            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
+
+        # Instrumentation for Mongo::Address
+        module Address
+          def self.included(base)
+            base.send(:include, InstanceMethods)
+          end
+
+          # Instance methods for Mongo::Address
+          module InstanceMethods
+            def datadog_pin
+              @datadog_pin ||= begin
+                service = Datadog.configuration[:mongo][:service_name]
+
+                Datadog::Pin.new(
+                  service,
+                  app: Datadog::Contrib::MongoDB::Ext::APP,
+                  app_type: Datadog::Ext::AppTypes::DB,
+                  tracer: -> { Datadog.configuration[:mongo][:tracer] }
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/mongodb/configuration/settings'
+require 'ddtrace/contrib/mongodb/patcher'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      # Description of MongoDB integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('2.1.0')
+
+        register_as :mongo, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version
+        end
+
+        def self.loaded?
+          !defined?(::Mongo::Monitoring::Global).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/mongodb/patcher.rb

@@ -1,92 +1,29 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/instrumentation'
 
 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.
+      # Patcher enables patching of 'mongo' module.
       module Patcher
-        include Base
-        register_as :mongo, auto_patch: true
-        option :service_name, default: SERVICE
-        option :quantize, default: { show: [:collection, :database, :operation] }
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        def patched?
-          @patched
+        def target_version
+          Integration.version
         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
+          ::Mongo::Address.send(:include, Instrumentation::Address)
+          ::Mongo::Client.send(:include, Instrumentation::Client)
+          add_mongo_monitoring
         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::Patcher.without_warnings do
-              remove_method :initialize
-            end
-
-            def initialize(*args, &blk)
-              # attach the Pin instance
-              initialize_without_datadog(*args, &blk)
-              service = Datadog.configuration[:mongo][:service_name]
-              pin = Datadog::Pin.new(service, app: APP, app_type: Datadog::Ext::AppTypes::DB)
-              pin.onto(self)
-            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
+          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, MongoCommandSubscriber.new)
         end
       end
     end

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

@@ -1,6 +1,10 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/parsers'
+require 'ddtrace/ext/integration'
+
 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.
@@ -14,20 +18,25 @@ module Datadog
           # 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
+          span = pin.tracer.trace(Ext::SPAN_COMMAND, service: pin.service, span_type: Ext::SPAN_TYPE_COMMAND)
+          set_span(event, span)
 
           # build a quantized Query using the Parser module
-          query = Datadog::Contrib::MongoDB
-                  .query_builder(event.command_name, event.database_name, event.command)
+          query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
           serialized_query = query.to_s
 
+          # 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?
+
           # 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(Ext::TAG_DB, query['database'])
+          span.set_tag(Ext::TAG_COLLECTION, query['collection'])
+          span.set_tag(Ext::TAG_OPERATION, query['operation'])
+          span.set_tag(Ext::TAG_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)
 
@@ -36,35 +45,65 @@ module Datadog
         end
 
         def failed(event)
-          span = Thread.current[:datadog_mongo_span]
+          span = get_span(event)
           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}")
+          Datadog.logger.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
+          span.finish unless span.nil?
+          clear_span(event)
         end
 
         def succeeded(event)
-          span = Thread.current[:datadog_mongo_span]
+          span = get_span(event)
           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?
+          span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
         rescue StandardError => e
-          Datadog::Tracer.log.debug("error when handling MongoDB 'succeeded' event: #{e}")
+          Datadog.logger.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
+          span.finish unless span.nil?
+          clear_span(event)
+        end
+
+        private
+
+        def get_span(event)
+          Thread.current[:datadog_mongo_span] \
+            && Thread.current[:datadog_mongo_span][event.request_id]
+        end
+
+        def set_span(event, span)
+          Thread.current[:datadog_mongo_span] ||= {}
+          Thread.current[:datadog_mongo_span][event.request_id] = span
+        end
+
+        def clear_span(event)
+          return if Thread.current[:datadog_mongo_span].nil?
+
+          Thread.current[:datadog_mongo_span].delete(event.request_id)
+        end
+
+        def analytics_enabled?
+          Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+        end
+
+        def analytics_sample_rate
+          datadog_configuration[:analytics_sample_rate]
+        end
+
+        def datadog_configuration
+          Datadog.configuration[:mongo]
         end
       end
     end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/mysql2/ext'
+
+module Datadog
+  module Contrib
+    module Mysql2
+      module Configuration
+        # Custom settings for the Mysql2 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 :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end