ddtrace 0.38.0

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

@@ -0,0 +1,108 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/parsers'
+
+module Datadog
+  module Contrib
+    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(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 = MongoDB.query_builder(event.command_name, event.database_name, event.command)
+          serialized_query = query.to_s
+
+          # Set analytics sample rate
+          if analytics_enabled?
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+          end
+
+          # add operation tags; the full query is stored and used as a resource,
+          # since it has been quantized and reduced
+          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)
+
+          # set the resource with the quantized query
+          span.resource = serialized_query
+        end
+
+        def failed(event)
+          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.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?
+          clear_span(event)
+        end
+
+        def succeeded(event)
+          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(Ext::TAG_ROWS, rows) unless rows.nil?
+        rescue StandardError => 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?
+          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
+  end
+end

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

@@ -0,0 +1,25 @@
+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 :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 :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Datadog
+  module Contrib
+    module Mysql2
+      # Mysql2 integration constants
+      module Ext
+        APP = 'mysql2'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_MYSQL2_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_MYSQL2_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'mysql2'.freeze
+        SPAN_QUERY = 'mysql2.query'.freeze
+        TAG_DB_NAME = 'mysql2.db.name'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/sql'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/mysql2/ext'
+
+module Datadog
+  module Contrib
+    module Mysql2
+      # Mysql2::Client patch module
+      module Instrumentation
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # Mysql2::Client patch instance methods
+        module InstanceMethods
+          def query(sql, options = {})
+            datadog_pin.tracer.trace(Ext::SPAN_QUERY) do |span|
+              span.resource = sql
+              span.service = datadog_pin.service
+              span.span_type = Datadog::Ext::SQL::TYPE
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+              span.set_tag(Ext::TAG_DB_NAME, query_options[:database])
+              span.set_tag(Datadog::Ext::NET::TARGET_HOST, query_options[:host])
+              span.set_tag(Datadog::Ext::NET::TARGET_PORT, query_options[:port])
+              super(sql, options)
+            end
+          end
+
+          def datadog_pin
+            @datadog_pin ||= Datadog::Pin.new(
+              Datadog.configuration[:mysql2][:service_name],
+              app: Ext::APP,
+              app_type: Datadog::Ext::AppTypes::DB,
+              tracer: -> { Datadog.configuration[:mysql2][:tracer] }
+            )
+          end
+
+          private
+
+          def datadog_configuration
+            Datadog.configuration[:mysql2]
+          end
+
+          def analytics_enabled?
+            datadog_configuration[:analytics_enabled]
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/mysql2/instrumentation'
+
+module Datadog
+  module Contrib
+    module Mysql2
+      # Patcher enables patching of 'mysql2' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          patch_mysql2_client
+        end
+
+        def patch_mysql2_client
+          ::Mysql2::Client.send(:include, Instrumentation)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patchable.rb

@@ -0,0 +1,59 @@
+module Datadog
+  module Contrib
+    # Base provides features that are shared across all integrations
+    module Patchable
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for integrations
+      module ClassMethods
+        def version
+          nil
+        end
+
+        # Is the target available? (e.g. gem installed?)
+        def available?
+          !version.nil?
+        end
+
+        # Is the target loaded into the application? (e.g. constants defined?)
+        def loaded?
+          true
+        end
+
+        # Is the loaded code compatible with this integration? (e.g. minimum version met?)
+        def compatible?
+          available? && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new(VERSION::MINIMUM_RUBY_VERSION)
+        end
+
+        # Can the patch for this integration be applied?
+        def patchable?
+          available? && loaded? && compatible?
+        end
+      end
+
+      # Instance methods for integrations
+      module InstanceMethods
+        def patcher
+          nil
+        end
+
+        def patch
+          if !self.class.patchable? || patcher.nil?
+            desc = "Available?: #{self.class.available?}"
+            desc += ", Loaded? #{self.class.loaded?}"
+            desc += ", Compatible? #{self.class.compatible?}"
+            desc += ", Patchable? #{self.class.patchable?}"
+
+            Datadog.logger.warn("Unable to patch #{self.class.name} (#{desc})")
+            return
+          end
+
+          patcher.patch
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patcher.rb

@@ -0,0 +1,62 @@
+require 'ddtrace/patcher'
+
+module Datadog
+  module Contrib
+    # Common behavior for patcher modules
+    module Patcher
+      def self.included(base)
+        base.send(:include, Datadog::Patcher)
+
+        base.singleton_class.send(:prepend, CommonMethods)
+        base.send(:prepend, CommonMethods) if base.class == Class
+      end
+
+      # Prepended instance methods for all patchers
+      module CommonMethods
+        def patch_name
+          self.class != Class && self.class != Module ? self.class.name : name
+        end
+
+        def patched?
+          done?(:patch)
+        end
+
+        def patch
+          return unless defined?(super)
+
+          do_once(:patch) do
+            begin
+              super.tap do
+                # Emit a metric
+                Datadog.health_metrics.instrumentation_patched(1, tags: default_tags)
+              end
+            rescue StandardError => e
+              on_patch_error(e)
+            end
+          end
+        end
+
+        # Processes patching errors. This default implementation logs the error and reports relevant metrics.
+        # @param e [Exception]
+        def on_patch_error(e)
+          # Log the error
+          Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{e.backtrace.first}")
+
+          # Emit a metric
+          tags = default_tags
+          tags << "error:#{e.class.name}"
+
+          Datadog.health_metrics.error_instrumentation_patch(1, tags: tags)
+        end
+
+        private
+
+        def default_tags
+          ["patcher:#{patch_name}"].tap do |tags|
+            tags << "target_version:#{target_version}" if respond_to?(:target_version) && !target_version.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+module Datadog
+  module Contrib
+    module Presto
+      # Presto integration constants
+      module Ext
+        APP = 'presto'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_PRESTO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_PRESTO_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'presto'.freeze
+        SPAN_QUERY = 'presto.query'.freeze
+        SPAN_RESUME = 'presto.resume_query'.freeze
+        SPAN_KILL = 'presto.kill_query'.freeze
+        TAG_SCHEMA_NAME = 'presto.schema'.freeze
+        TAG_CATALOG_NAME = 'presto.catalog'.freeze
+        TAG_USER_NAME = 'presto.user'.freeze
+        TAG_TIME_ZONE = 'presto.time_zone'.freeze
+        TAG_LANGUAGE = 'presto.language'.freeze
+        TAG_PROXY = 'presto.http_proxy'.freeze
+        TAG_MODEL_VERSION = 'presto.model_version'.freeze
+        TAG_QUERY_ID = 'presto.query.id'.freeze
+        TAG_QUERY_ASYNC = 'presto.query.async'.freeze
+      end
+    end
+  end
+end