ddtrace 0.13.0 → 0.47.0

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Mysql2
+      # Mysql2 integration constants
+      module Ext
+        APP = 'mysql2'.freeze
+        ENV_ENABLED = 'DD_TRACE_MYSQL2_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_MYSQL2_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_MYSQL2_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MYSQL2_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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,64 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/integration'
+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
+
+              # 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?
+
+              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

@@ -1,41 +1,25 @@
-require 'ddtrace/contrib/mysql2/client'
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/mysql2/instrumentation'
 
 module Datadog
   module Contrib
     module Mysql2
-      # Mysql2 patcher
+      # Patcher enables patching of 'mysql2' module.
       module Patcher
-        include Base
-
-        register_as :mysql2
-        option :service_name, default: 'mysql2'
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        def patch
-          return @patched if patched? || !compatible?
-
-          patch_mysql2_client
-
-          @patched = true
-        rescue StandardError => e
-          Tracer.log.error("Unable to apply mysql2 integration: #{e}")
-          @patched
-        end
-
-        def patched?
-          @patched
+        def target_version
+          Integration.version
         end
 
-        def compatible?
-          defined?(::Mysql2)
+        def patch
+          patch_mysql2_client
         end
 
         def patch_mysql2_client
-          ::Mysql2::Client.send(:include, Client)
+          ::Mysql2::Client.send(:include, Instrumentation)
         end
       end
     end

data/lib/ddtrace/contrib/patchable.rb

@@ -0,0 +1,70 @@
+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?
+            return {
+              name: self.class.name,
+              available: self.class.available?,
+              loaded: self.class.loaded?,
+              compatible: self.class.compatible?,
+              patchable: self.class.patchable?
+            }
+          end
+
+          patcher.patch
+          true
+        end
+
+        # Can the patch for this integration be applied automatically?
+        # For example: test integrations should only be applied
+        # by the user explicitly setting `c.use :rspec`
+        # and rails sub-modules are auto-instrumented by enabling rails
+        # so auto-instrumenting them on their own will cause changes in
+        # service naming behavior
+        def auto_instrument?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patcher.rb

@@ -0,0 +1,65 @@
+require 'ddtrace/utils/only_once'
+
+module Datadog
+  module Contrib
+    # Common behavior for patcher modules
+    module Patcher
+      def self.included(base)
+        base.singleton_class.send(:prepend, CommonMethods)
+        base.send(:prepend, CommonMethods) if base.instance_of?(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?
+          patch_only_once.ran?
+        end
+
+        def patch
+          return unless defined?(super)
+
+          patch_only_once.run 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
+
+        def patch_only_once
+          # NOTE: This is not thread-safe
+          @patch_only_once ||= Datadog::Utils::OnlyOnce.new
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,28 @@
+module Datadog
+  module Contrib
+    module Presto
+      # Presto integration constants
+      module Ext
+        APP = 'presto'.freeze
+        ENV_ENABLED = 'DD_TRACE_PRESTO_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_PRESTO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_PRESTO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_PRESTO_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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

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

@@ -0,0 +1,110 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/presto/ext'
+
+module Datadog
+  module Contrib
+    module Presto
+      # Instrumentation for Presto integration
+      module Instrumentation
+        # Instrumentation for Presto::Client::Client
+        module Client
+          def self.included(base)
+            base.send(:prepend, InstanceMethods)
+          end
+
+          # Instance methods for Presto::Client
+          module InstanceMethods
+            def run(query)
+              tracer.trace(Ext::SPAN_QUERY, span_options) do |span|
+                begin
+                  decorate!(span)
+                  span.resource = query
+                  span.span_type = Datadog::Ext::SQL::TYPE
+                  span.set_tag(Ext::TAG_QUERY_ASYNC, false)
+                rescue StandardError => e
+                  Datadog.logger.debug("error preparing span for presto: #{e}")
+                end
+
+                super(query)
+              end
+            end
+
+            def query(query, &blk)
+              tracer.trace(Ext::SPAN_QUERY, span_options) do |span|
+                begin
+                  decorate!(span)
+                  span.resource = query
+                  span.span_type = Datadog::Ext::SQL::TYPE
+                  span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
+                rescue StandardError => e
+                  Datadog.logger.debug("error preparing span for presto: #{e}")
+                end
+
+                super(query, &blk)
+              end
+            end
+
+            def kill(query_id)
+              tracer.trace(Ext::SPAN_KILL, span_options) do |span|
+                begin
+                  decorate!(span)
+                  span.resource = Ext::SPAN_KILL
+                  span.span_type = Datadog::Ext::AppTypes::DB
+                  # ^ not an SQL type span, since there's no SQL query
+                  span.set_tag(Ext::TAG_QUERY_ID, query_id)
+                rescue StandardError => e
+                  Datadog.logger.debug("error preparing span for presto: #{e}")
+                end
+
+                super(query_id)
+              end
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration[:presto]
+            end
+
+            def span_options
+              {
+                service: datadog_configuration[:service_name],
+                app: Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB
+              }
+            end
+
+            def tracer
+              datadog_configuration.tracer
+            end
+
+            def decorate!(span)
+              set_nilable_tag!(span, :server, Datadog::Ext::NET::TARGET_HOST)
+              set_nilable_tag!(span, :user, Ext::TAG_USER_NAME)
+              set_nilable_tag!(span, :schema, Ext::TAG_SCHEMA_NAME)
+              set_nilable_tag!(span, :catalog, Ext::TAG_CATALOG_NAME)
+              set_nilable_tag!(span, :time_zone, Ext::TAG_TIME_ZONE)
+              set_nilable_tag!(span, :language, Ext::TAG_LANGUAGE)
+              set_nilable_tag!(span, :http_proxy, Ext::TAG_PROXY)
+              set_nilable_tag!(span, :model_version, Ext::TAG_MODEL_VERSION)
+
+              # Tag as an external peer service
+              span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
+
+              # Set analytics sample rate
+              if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+              end
+            end
+
+            def set_nilable_tag!(span, key, tag_name)
+              @options[key].tap { |val| span.set_tag(tag_name, val) if val }
+            end
+          end
+        end
+      end
+    end
+  end
+end