ddtrace 0.29.1 → 0.30.0

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

@@ -11,20 +11,14 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:mongo)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:mongo) do
-            begin
-              ::Mongo::Address.send(:include, Instrumentation::Address)
-              ::Mongo::Client.send(:include, Instrumentation::Client)
-              add_mongo_monitoring
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply MongoDB integration: #{e}")
-            end
-          end
+          ::Mongo::Address.send(:include, Instrumentation::Address)
+          ::Mongo::Client.send(:include, Instrumentation::Client)
+          add_mongo_monitoring
         end
 
         def add_mongo_monitoring

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

@@ -10,18 +10,12 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:mysql2)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:mysql2) do
-            begin
-              patch_mysql2_client
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply mysql2 integration: #{e}")
-            end
-          end
+          patch_mysql2_client
         end
 
         def patch_mysql2_client

data/lib/ddtrace/contrib/patcher.rb

@@ -6,21 +6,49 @@ module Datadog
     module Patcher
       def self.included(base)
         base.send(:include, Datadog::Patcher)
-        base.send(:extend, InstanceMethods)
-        base.send(:include, InstanceMethods)
+
+        base.singleton_class.send(:prepend, CommonMethods)
+        base.send(:prepend, CommonMethods) if base.class == Class
       end
 
-      # Class methods for patchers
-      module ClassMethods
-        def patch
-          raise NotImplementedError, '#patch not implemented for Patcher!'
+      # 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
-      end
 
-      # Instance methods for patchers
-      module InstanceMethods
         def patch
-          raise NotImplementedError, '#patch not implemented for Patcher!'
+          return unless defined?(super)
+
+          do_once(:patch) do
+            begin
+              super.tap do
+                # Emit a metric
+                Diagnostics::Health.metrics.instrumentation_patched(1, tags: default_tags)
+              end
+            rescue StandardError => e
+              # Log the error
+              Datadog::Tracer.log.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{e.backtrace.first}")
+
+              # Emit a metric
+              tags = default_tags
+              tags << "error:#{e.class.name}"
+
+              Diagnostics::Health.metrics.error_instrumentation_patch(1, tags: tags)
+            end
+          end
+        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

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

@@ -12,19 +12,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:racecar)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:racecar) do
-            begin
-              # Subscribe to Racecar events
-              Events.subscribe!
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Racecar integration: #{e}")
-            end
-          end
+          # Subscribe to Racecar events
+          Events.subscribe!
         end
       end
     end

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

@@ -2,36 +2,33 @@ module Datadog
   module Contrib
     module Rack
       # Provides instrumentation for `rack`
-      module Patcher
+      module MiddlewarePatcher
         include Contrib::Patcher
 
         module_function
 
-        def patched?
-          done?(:rack)
+        def target_version
+          Integration.version
         end
 
         def patch
           # Patch middleware
-          do_once(:rack) do
-            require_relative 'middlewares'
-          end
+          require_relative 'middlewares'
+        end
+      end
 
-          # Patch middleware names
-          if !done?(:rack_middleware_names) && get_option(:middleware_names)
-            if get_option(:application)
-              do_once(:rack_middleware_names) do
-                patch_middleware_names
-              end
-            else
-              Datadog::Tracer.log.warn(%(
-              Rack :middleware_names requires you to also pass :application.
-              Middleware names have NOT been patched; please provide :application.
-              e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)
-            end
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.error("Unable to apply Rack integration: #{e}")
+      # Provides instrumentation for Rack middleware names
+      module MiddlewareNamePatcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          patch_middleware_names
         end
 
         def patch_middleware_names
@@ -67,6 +64,44 @@ module Datadog
           Datadog.configuration[:rack].get_option(option)
         end
       end
+
+      # Applies multiple patches
+      module Patcher
+        PATCHERS = [
+          MiddlewarePatcher,
+          MiddlewareNamePatcher
+        ].freeze
+
+        module_function
+
+        def patched?
+          PATCHERS.all?(&:patched?)
+        end
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          MiddlewarePatcher.patch unless MiddlewarePatcher.patched?
+
+          # Patch middleware names
+          if !MiddlewareNamePatcher.patched? && get_option(:middleware_names)
+            if get_option(:application)
+              MiddlewareNamePatcher.patch
+            else
+              Datadog::Tracer.log.warn(%(
+              Rack :middleware_names requires you to also pass :application.
+              Middleware names have NOT been patched; please provide :application.
+              e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)
+            end
+          end
+        end
+
+        def get_option(option)
+          Datadog.configuration[:rack].get_option(option)
+        end
+      end
     end
   end
 end

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

@@ -12,17 +12,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:rails)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:rails) do
-            patch_before_intialize
-            patch_after_intialize
-          end
-        rescue => e
-          Datadog::Tracer.log.error("Unable to apply Rails integration: #{e}")
+          patch_before_intialize
+          patch_after_intialize
         end
 
         def patch_before_intialize

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

@@ -12,19 +12,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:rake)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:rake) do
-            begin
-              # Add instrumentation patch to Rake task
-              ::Rake::Task.send(:include, Instrumentation)
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Rake integration: #{e}")
-            end
-          end
+          # Add instrumentation patch to Rake task
+          ::Rake::Task.send(:include, Instrumentation)
         end
 
         def get_option(option)

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

@@ -10,25 +10,19 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:redis)
+        def target_version
+          Integration.version
         end
 
         # patch applies our patch if needed
         def patch
-          do_once(:redis) do
-            begin
-              # do not require these by default, but only when actually patching
-              require 'redis'
-              require 'ddtrace/ext/app_types'
-              require 'ddtrace/contrib/redis/tags'
-              require 'ddtrace/contrib/redis/quantize'
+          # do not require these by default, but only when actually patching
+          require 'redis'
+          require 'ddtrace/ext/app_types'
+          require 'ddtrace/contrib/redis/tags'
+          require 'ddtrace/contrib/redis/quantize'
 
-              patch_redis_client
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
-            end
-          end
+          patch_redis_client
         end
 
         # rubocop:disable Metrics/MethodLength

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

@@ -11,19 +11,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:resque)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:resque) do
-            begin
-              require_relative 'resque_job'
-              get_option(:workers).each { |worker| worker.extend(ResqueJob) }
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Resque integration: #{e}")
-            end
-          end
+          require_relative 'resque_job'
+          get_option(:workers).each { |worker| worker.extend(ResqueJob) }
         end
 
         def get_option(option)

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

@@ -7,17 +7,15 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:rest_client)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:rest_client) do
-            require 'ddtrace/ext/app_types'
-            require 'ddtrace/contrib/rest_client/request_patch'
+          require 'ddtrace/ext/app_types'
+          require 'ddtrace/contrib/rest_client/request_patch'
 
-            ::RestClient::Request.send(:include, RequestPatch)
-          end
+          ::RestClient::Request.send(:include, RequestPatch)
         end
       end
     end

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

@@ -11,19 +11,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:sequel)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:sequel) do
-            begin
-              patch_sequel_database
-              patch_sequel_dataset
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Sequel integration: #{e}")
-            end
-          end
+          patch_sequel_database
+          patch_sequel_dataset
         end
 
         def patch_sequel_database

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

@@ -9,19 +9,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:shoryuken)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:shoryuken) do
-            begin
-              ::Shoryuken.server_middleware do |chain|
-                chain.add Shoryuken::Tracer
-              end
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Shoryuken integration: #{e}")
-            end
+          ::Shoryuken.server_middleware do |chain|
+            chain.add Shoryuken::Tracer
           end
         end
       end

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

@@ -9,28 +9,22 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:sidekiq)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:sidekiq) do
-            begin
-              require 'ddtrace/contrib/sidekiq/client_tracer'
-              ::Sidekiq.configure_client do |config|
-                config.client_middleware do |chain|
-                  chain.add(Sidekiq::ClientTracer)
-                end
-              end
+          require 'ddtrace/contrib/sidekiq/client_tracer'
+          ::Sidekiq.configure_client do |config|
+            config.client_middleware do |chain|
+              chain.add(Sidekiq::ClientTracer)
+            end
+          end
 
-              require 'ddtrace/contrib/sidekiq/server_tracer'
-              ::Sidekiq.configure_server do |config|
-                config.server_middleware do |chain|
-                  chain.add(Sidekiq::ServerTracer)
-                end
-              end
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Sidekiq integration: #{e}")
+          require 'ddtrace/contrib/sidekiq/server_tracer'
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add(Sidekiq::ServerTracer)
             end
           end
         end