ddtrace 0.13.0 → 0.47.0

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

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/sequel/database'
 require 'ddtrace/contrib/sequel/dataset'
 
@@ -5,42 +6,18 @@ module Datadog
   module Contrib
     module Sequel
       # Patcher enables patching of 'sequel' module.
-      # This is used in monkey.rb to manually apply patches
       module Patcher
-        include Base
-
-        APP = 'sequel'.freeze
-
-        register_as :sequel, auto_patch: false
-        option :service_name
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        # patched? tells whether patch has been successfully applied
-        def patched?
-          @patched
+        def target_version
+          Integration.version
         end
 
         def patch
-          if !@patched && compatible?
-            begin
-              patch_sequel_database
-              patch_sequel_dataset
-
-              @patched = true
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Sequel integration: #{e}")
-            end
-          end
-
-          @patched
-        end
-
-        def compatible?
-          RUBY_VERSION >= '2.0.0' && defined?(::Sequel)
+          patch_sequel_database
+          patch_sequel_dataset
         end
 
         def patch_sequel_database

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

@@ -1,26 +1,72 @@
+require 'ddtrace/ext/integration'
+
 module Datadog
   module Contrib
     module Sequel
       # General purpose functions for Sequel
       module Utils
-        module_function
+        class << self
+          # Ruby database connector library
+          #
+          # e.g. adapter:mysql2 (database:mysql), adapter:jdbc (database:postgres)
+          def adapter_name(database)
+            scheme = database.adapter_scheme.to_s
 
-        def adapter_name(database)
-          Datadog::Utils::Database.normalize_vendor(database.adapter_scheme.to_s)
-        end
+            if scheme == 'jdbc'.freeze
+              # The subtype is more important in this case,
+              # otherwise all database adapters will be 'jdbc'.
+              database_type(database)
+            else
+              Datadog::Utils::Database.normalize_vendor(scheme)
+            end
+          end
+
+          # Database engine
+          #
+          # e.g. database:mysql (adapter:mysql2), database:postgres (adapter:jdbc)
+          def database_type(database)
+            Datadog::Utils::Database.normalize_vendor(database.database_type.to_s)
+          end
+
+          def parse_opts(sql, opts, db_opts, dataset = nil)
+            # Prepared statements don't provide their sql query in the +sql+ parameter.
+            if !sql.is_a?(String) && (dataset && dataset.respond_to?(:prepared_sql) &&
+              (resolved_sql = dataset.prepared_sql))
+              # The dataset contains the resolved SQL query and prepared statement name.
+              prepared_name = dataset.prepared_statement_name
+              sql = resolved_sql
+            end
 
-        def parse_opts(sql, opts, db_opts)
-          if ::Sequel::VERSION >= '4.37.0' && !sql.is_a?(String)
-            # In 4.37.0, sql was converted to a prepared statement object
-            sql = sql.prepared_sql unless sql.is_a?(Symbol)
+            {
+              name: opts[:type],
+              query: sql,
+              prepared_name: prepared_name,
+              database: db_opts[:database],
+              host: db_opts[:host]
+            }
           end
 
-          {
-            name: opts[:type],
-            query: sql,
-            database: db_opts[:database],
-            host: db_opts[:host]
-          }
+          def set_common_tags(span)
+            # 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?
+          end
+
+          private
+
+          def datadog_configuration
+            Datadog.configuration[:sequel]
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
         end
       end
     end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module Shoryuken
+      module Configuration
+        # Default settings for the Shoryuken 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
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Datadog
+  module Contrib
+    module Shoryuken
+      # Shoryuken integration constants
+      module Ext
+        APP = 'shoryuken'.freeze
+        ENV_ENABLED = 'DD_TRACE_SHORYUKEN_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SHORYUKEN_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_SHORYUKEN_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SHORYUKEN_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_SHORYUKEN_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'shoryuken'.freeze
+        SPAN_JOB = 'shoryuken.job'.freeze
+        TAG_JOB_ID = 'shoryuken.id'.freeze
+        TAG_JOB_QUEUE = 'shoryuken.queue'.freeze
+        TAG_JOB_ATTRIBUTES = 'shoryuken.attributes'.freeze
+        TAG_JOB_BODY = 'shoryuken.body'.freeze
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,24 @@
+require 'ddtrace/contrib/shoryuken/tracer'
+
+module Datadog
+  module Contrib
+    module Shoryuken
+      # Patcher enables patching of 'shoryuken' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ::Shoryuken.server_middleware do |chain|
+            chain.add Shoryuken::Tracer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Shoryuken
+      # Tracer is a Shoryuken server-side middleware which traces executed jobs
+      class Tracer
+        def initialize(options = {})
+          @tracer = options[:tracer] || configuration[:tracer]
+          @shoryuken_service = options[:service_name] || configuration[:service_name]
+          @error_handler = options[:error_handler] || configuration[:error_handler]
+        end
+
+        def call(worker_instance, queue, sqs_msg, body)
+          @tracer.trace(Ext::SPAN_JOB, service: @shoryuken_service, span_type: Datadog::Ext::AppTypes::WORKER,
+                                       on_error: @error_handler) do |span|
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.resource = resource(worker_instance, body)
+            span.set_tag(Ext::TAG_JOB_ID, sqs_msg.message_id)
+            span.set_tag(Ext::TAG_JOB_QUEUE, queue)
+            span.set_tag(Ext::TAG_JOB_ATTRIBUTES, sqs_msg.attributes) if sqs_msg.respond_to?(:attributes)
+            span.set_tag(Ext::TAG_JOB_BODY, body)
+
+            yield
+          end
+        end
+
+        private
+
+        def resource(worker_instance, body)
+          # If it's a Hash, try to get the job class from it.
+          # This is for ActiveJob compatibility.
+          job_class = body['job_class'] if body.is_a?(Hash)
+          # If nothing is available, use the worker class name.
+          job_class || worker_instance.class.name
+        end
+
+        def configuration
+          Datadog.configuration[:shoryuken]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'ddtrace/contrib/sidekiq/tracing'
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      # Tracer is a Sidekiq client-side middleware which traces job enqueues/pushes
+      class ClientTracer
+        include Tracing
+
+        def initialize(options = {})
+          super
+          @sidekiq_service = options[:client_service_name] || configuration[:client_service_name]
+        end
+
+        # Client middleware arguments are documented here:
+        #   https://github.com/mperham/sidekiq/wiki/Middleware#client-middleware
+        def call(worker_class, job, queue, redis_pool)
+          resource = job_resource(job)
+
+          @tracer.trace(Ext::SPAN_PUSH, service: @sidekiq_service) do |span|
+            span.resource = resource
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+            span.set_tag(Ext::TAG_JOB_ID, job['jid'])
+            span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
+            span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
+
+            yield
+          end
+        end
+
+        private
+
+        def configuration
+          Datadog.configuration[:sidekiq]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/sidekiq/ext'
+
+module Datadog
+  module Contrib
+    module Sidekiq
+      module Configuration
+        # Custom settings for the Sidekiq 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 :tag_args do |o|
+            o.default { env_to_bool(Ext::ENV_TAG_JOB_ARGS, false) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+          option :client_service_name, default: Ext::CLIENT_SERVICE_NAME
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Datadog
+  module Contrib
+    module Sidekiq
+      # Sidekiq integration constants
+      module Ext
+        APP = 'sidekiq'.freeze
+        CLIENT_SERVICE_NAME = 'sidekiq-client'.freeze
+        ENV_ENABLED = 'DD_TRACE_SIDEKIQ_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SIDEKIQ_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_SIDEKIQ_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SIDEKIQ_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_SIDEKIQ_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_TAG_JOB_ARGS = 'DD_SIDEKIQ_TAG_JOB_ARGS'.freeze
+        SERVICE_NAME = 'sidekiq'.freeze
+        SPAN_PUSH = 'sidekiq.push'.freeze
+        SPAN_JOB = 'sidekiq.job'.freeze
+        TAG_JOB_DELAY = 'sidekiq.job.delay'.freeze
+        TAG_JOB_ID = 'sidekiq.job.id'.freeze
+        TAG_JOB_QUEUE = 'sidekiq.job.queue'.freeze
+        TAG_JOB_RETRY = 'sidekiq.job.retry'.freeze
+        TAG_JOB_RETRY_COUNT = 'sidekiq.job.retry_count'.freeze
+        TAG_JOB_WRAPPER = 'sidekiq.job.wrapper'.freeze
+        TAG_JOB_ARGS = 'sidekiq.job.args'.freeze
+      end
+    end
+  end
+end

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

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