ddtrace 0.34.1 → 1.23.1

data/lib/datadog/tracing/contrib/sequel/database.rb

@@ -0,0 +1,60 @@
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Adds instrumentation to Sequel::Database
+        module Database
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for instrumenting Sequel::Database
+          module InstanceMethods
+            def run(sql, options = ::Sequel::OPTS)
+              opts = parse_opts(sql, options)
+
+              response = nil
+
+              Tracing.trace(Ext::SPAN_QUERY) do |span|
+                span.service =  Datadog.configuration_for(self, :service_name) \
+                                || Datadog.configuration.tracing[:sequel][:service_name] \
+                                || Contrib::SpanAttributeSchema.fetch_service_name(
+                                  '',
+                                  adapter_name
+                                )
+                span.resource = opts[:query]
+                span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                Utils.set_common_tags(span, self)
+                span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
+                response = super(sql, options)
+              end
+              response
+            end
+
+            private
+
+            def adapter_name
+              Utils.adapter_name(self)
+            end
+
+            def parse_opts(sql, opts)
+              db_opts = if ::Sequel::VERSION < '3.41.0' && self.class.to_s !~ /Dataset$/
+                          @opts
+                        elsif instance_variable_defined?(:@pool) && @pool
+                          @pool.db.opts
+                        end
+              sql = sql.is_a?(::Sequel::SQL::Expression) ? literal(sql) : sql.to_s
+
+              Utils.parse_opts(sql, opts, db_opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/dataset.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Adds instrumentation to Sequel::Dataset
+        module Dataset
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for instrumenting Sequel::Dataset
+          module InstanceMethods
+            def execute(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            def execute_ddl(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            def execute_dui(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            def execute_insert(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            private
+
+            def trace_execute(super_method, sql, options, &block)
+              opts = Utils.parse_opts(sql, options, db.opts, self)
+              response = nil
+
+              Tracing.trace(Ext::SPAN_QUERY) do |span|
+                span.service =  Datadog.configuration_for(db, :service_name) \
+                                || Datadog.configuration.tracing[:sequel][:service_name] \
+                                || Contrib::SpanAttributeSchema.fetch_service_name(
+                                  '',
+                                  adapter_name
+                                )
+                span.resource = opts[:query]
+                span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                Utils.set_common_tags(span, db)
+                span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
+                span.set_tag(Ext::TAG_PREPARED_NAME, opts[:prepared_name]) if opts[:prepared_name]
+                response = super_method.call(sql, options, &block)
+              end
+              response
+            end
+
+            def adapter_name
+              Utils.adapter_name(db)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/ext.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Sequel integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SEQUEL_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SEQUEL_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SEQUEL_ANALYTICS_SAMPLE_RATE'
+          SPAN_QUERY = 'sequel.query'
+          TAG_DB_VENDOR = 'sequel.db.vendor'
+          TAG_PREPARED_NAME = 'sequel.prepared.name'
+          TAG_COMPONENT = 'sequel'
+          TAG_OPERATION_QUERY = 'query'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/integration.rb

@@ -0,0 +1,41 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Description of Sequel integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.41')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :sequel, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['sequel'] && Gem.loaded_specs['sequel'].version
+          end
+
+          def self.loaded?
+            !defined?(::Sequel).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/patcher.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'database'
+require_relative 'dataset'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Patcher enables patching of 'sequel' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            patch_sequel_database
+            patch_sequel_dataset
+          end
+
+          def patch_sequel_database
+            ::Sequel::Database.include(Database)
+          end
+
+          def patch_sequel_dataset
+            ::Sequel::Dataset.include(Dataset)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/utils.rb

@@ -0,0 +1,88 @@
+require_relative '../../metadata/ext'
+require_relative '../utils/database'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # General purpose functions for Sequel
+        module Utils
+          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
+
+              if scheme == 'jdbc'.freeze
+                # The subtype is more important in this case,
+                # otherwise all database adapters will be 'jdbc'.
+                database_type(database)
+              else
+                Contrib::Utils::Database.normalize_vendor(scheme)
+              end
+            end
+
+            # Database engine
+            #
+            # e.g. database:mysql (adapter:mysql2), database:postgres (adapter:jdbc)
+            def database_type(database)
+              Contrib::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
+
+              {
+                name: opts[:type],
+                query: sql,
+                prepared_name: prepared_name,
+                database: db_opts[:database],
+                host: db_opts[:host]
+              }
+            end
+
+            def set_common_tags(span, db)
+              # Tag original global service name if not used
+              if span.service != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
+
+              # TODO: Extract host for Sequel with JDBC. The easiest way seem to be through
+              # TODO: the database URI. Unfortunately, JDBC URIs do not work with `URI.parse`.
+              # host, _port = extract_host_port_from_uri(db.uri)
+              # span.set_tag(Tracing::Metadata::Ext::TAG_DESTINATION_NAME, host)
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME, db.opts[:host]) if db.opts[:host]
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.tracing[: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
+    end
+  end
+end

data/lib/datadog/tracing/contrib/shoryuken/configuration/settings.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../../span_operation'
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Shoryuken
+        module Configuration
+          # Default settings for the Shoryuken integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :service_name
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+            end
+            option :tag_body, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/shoryuken/ext.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Shoryuken
+        # Shoryuken integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SHORYUKEN_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SHORYUKEN_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SHORYUKEN_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'shoryuken'
+          SPAN_JOB = 'shoryuken.job'
+          TAG_JOB_ID = 'shoryuken.id'
+          TAG_JOB_QUEUE = 'shoryuken.queue'
+          TAG_JOB_ATTRIBUTES = 'shoryuken.attributes'
+          TAG_JOB_BODY = 'shoryuken.body'
+          TAG_COMPONENT = 'shoryuken'
+          TAG_OPERATION_JOB = 'job'
+          TAG_MESSAGING_SYSTEM = 'amazonsqs'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/shoryuken/integration.rb

@@ -0,0 +1,42 @@
+require_relative '../integration'
+require_relative 'ext'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Shoryuken
+        # Description of Shoryuken integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/shoryuken/patcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'tracer'
+
+module Datadog
+  module Tracing
+    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
+end

data/lib/datadog/tracing/contrib/shoryuken/tracer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../analytics'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Shoryuken
+        # Tracer is a Shoryuken server-side middleware which traces executed jobs
+        class Tracer
+          def initialize(options = {})
+            @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)
+            Tracing.trace(
+              Ext::SPAN_JOB,
+              service: @shoryuken_service,
+              span_type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: @error_handler
+            ) do |span|
+              span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_MESSAGING_SYSTEM)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
+
+              # 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) if configuration[:tag_body]
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
+              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.tracing[:shoryuken]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/client_tracer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'distributed/propagation'
+require_relative 'ext'
+require_relative 'utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Tracer is a Sidekiq client-side middleware which traces job enqueues/pushes
+        class ClientTracer
+          include Utils
+
+          def initialize(options = {})
+            @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)
+
+            Datadog::Tracing.trace(Ext::SPAN_PUSH, service: @sidekiq_service) do |span, trace_op|
+              propagation.inject!(trace_op, job) if configuration[:distributed_tracing]
+
+              span.resource = resource
+
+              span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PUSH)
+
+              span.set_tag(
+                Datadog::Tracing::Metadata::Ext::TAG_KIND,
+                Datadog::Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER
+              )
+
+              # 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.tracing[:sidekiq]
+          end
+
+          def propagation
+            @propagation ||= Contrib::Sidekiq::Distributed::Propagation.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/configuration/settings.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../../../span_operation'
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module Configuration
+          # Custom settings for the Sidekiq integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :tag_args do |o|
+              o.type :bool
+              o.env Ext::ENV_TAG_JOB_ARGS
+              o.default false
+            end
+
+            option :service_name
+            option :client_service_name
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+            end
+            option :quantize, default: {}, type: :hash
+            option :distributed_tracing, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/distributed/propagation.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../../distributed/fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3_multi'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/none'
+require_relative '../../../distributed/trace_context'
+require_relative '../../../configuration/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module Distributed
+          # Extracts and injects propagation through HTTP headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER =>
+                    Tracing::Distributed::B3Multi.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
+                    Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                })
+            end
+          end
+        end
+      end
+    end
+  end
+end