ddtrace 0.39.0 → 0.44.0

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

@@ -1,5 +1,6 @@
 require 'ddtrace/ext/net'
 require 'ddtrace/ext/distributed'
+require 'ddtrace/ext/integration'
 require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/rest_client/ext'
 
@@ -31,6 +32,9 @@ module Datadog
           def datadog_tag_request(uri, span)
             span.resource = method.to_s.upcase
 
+            # 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?
 

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/rspec/ext'
+
+module Datadog
+  module Contrib
+    module RSpec
+      module Configuration
+        # Custom settings for the RSpec 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, true) }
+            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 do |o|
+            o.default { Datadog.configuration.service || Ext::SERVICE_NAME }
+            o.lazy
+          end
+
+          option :operation_name do |o|
+            o.default { ENV.key?(Ext::ENV_OPERATION_NAME) ? ENV[Ext::ENV_OPERATION_NAME] : Ext::OPERATION_NAME }
+            o.lazy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/rspec/example.rb

@@ -0,0 +1,61 @@
+module Datadog
+  module Contrib
+    module RSpec
+      # Instrument RSpec::Core::Example
+      module Example
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # Instance methods for configuration
+        module InstanceMethods
+          def run(example_group_instance, reporter)
+            configuration = Datadog.configuration[:rspec]
+            return super unless configuration[:enabled]
+
+            test_name = "#{example_group.description}::#{description}"
+            trace_options = {
+              app: Ext::APP,
+              resource: test_name,
+              service: configuration[:service_name],
+              span_type: Datadog::Ext::AppTypes::TEST,
+              tags: example_group.instance_variable_get(:@tags).merge(Datadog.configuration.tags)
+            }
+
+            configuration[:tracer].trace(configuration[:operation_name], trace_options) do |span|
+              span.set_tag(Datadog::Ext::Test::TAG_FRAMEWORK, Ext::FRAMEWORK)
+              span.set_tag(Datadog::Ext::Test::TAG_NAME, test_name)
+              span.set_tag(Datadog::Ext::Test::TAG_SUITE, example_group.file_path)
+              span.set_tag(Datadog::Ext::Test::TAG_TYPE, Ext::TEST_TYPE)
+              span.set_tag(Datadog::Ext::Test::TAG_SPAN_KIND, Datadog::Ext::AppTypes::TEST)
+
+              # Set analytics sample rate
+              if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                Datadog::Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+              end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
+              result = super
+
+              case execution_result.status
+              when :passed
+                span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::PASS)
+              when :failed
+                span.status = 1
+                span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::FAIL)
+                span.set_error(execution_result.exception)
+              else
+                if execution_result.example_skipped?
+                  span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::SKIP)
+                end
+              end
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/rspec/example_group.rb

@@ -0,0 +1,61 @@
+module Datadog
+  module Contrib
+    module RSpec
+      # Instrument RSpec::Core::ExampleGroup
+      module ExampleGroup
+        def self.included(base)
+          base.singleton_class.send(:prepend, ClassMethods)
+        end
+
+        # Class methods for configuration
+        module ClassMethods
+          def run(reporter = ::RSpec::Core::NullReporter)
+            configuration = Datadog.configuration[:rspec]
+            return super unless configuration[:enabled]
+
+            trace_options = {
+              app: Ext::APP,
+              resource: description,
+              service: configuration[:service_name],
+              span_type: Datadog::Ext::AppTypes::TEST,
+              tags: tags.merge(Datadog.configuration.tags)
+            }
+
+            configuration[:tracer].trace(Ext::EXAMPLE_GROUP_OPERATION_NAME, trace_options) do |span|
+              span.set_tag(Datadog::Ext::Test::TAG_FRAMEWORK, Ext::FRAMEWORK)
+              span.set_tag(Datadog::Ext::Test::TAG_NAME, description)
+              span.set_tag(Datadog::Ext::Test::TAG_SUITE, file_path)
+              span.set_tag(Datadog::Ext::Test::TAG_TYPE, Ext::TEST_TYPE)
+              span.set_tag(Datadog::Ext::Test::TAG_SPAN_KIND, Datadog::Ext::AppTypes::TEST)
+
+              # Set analytics sample rate
+              if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                Datadog::Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+              end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
+              result = super
+
+              if ::RSpec.world.wants_to_quit
+                span.status = 1
+                span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::FAIL)
+              else
+                span.set_tag(Datadog::Ext::Test::TAG_STATUS, Datadog::Ext::Test::Status::PASS)
+              end
+
+              result
+            end
+          end
+
+          private
+
+          def tags
+            @tags ||= Datadog::Ext::CI.tags(ENV)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Datadog
+  module Contrib
+    module RSpec
+      # RSpec integration constants
+      module Ext
+        APP = 'rspec'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RSPEC_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RSPEC_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_RSPEC_ENABLED'.freeze
+        ENV_OPERATION_NAME = 'DD_TRACE_RSPEC_OPERATION_NAME'.freeze
+        FRAMEWORK = 'rspec'.freeze
+        OPERATION_NAME = 'rspec.example'.freeze
+        EXAMPLE_GROUP_OPERATION_NAME = 'rspec.example_group'.freeze
+        SERVICE_NAME = 'rspec'.freeze
+        TEST_TYPE = 'test'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/rspec/configuration/settings'
+require 'ddtrace/contrib/rspec/patcher'
+require 'ddtrace/contrib/integration'
+
+module Datadog
+  module Contrib
+    module RSpec
+      # Description of RSpec integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.0.0')
+
+        register_as :rspec, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['rspec'] \
+            && Gem.loaded_specs['rspec'].version
+        end
+
+        def self.loaded?
+          !defined?(::RSpec).nil? && !defined?(::RSpec::Core).nil? && \
+            !defined?(::RSpec::Core::Example).nil? && !defined?(::RSpec::Core::ExampleGroup).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/rspec/patcher.rb

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/rspec/example'
+require 'ddtrace/contrib/rspec/example_group'
+
+module Datadog
+  module Contrib
+    module RSpec
+      # Patcher enables patching of 'rspec' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ::RSpec::Core::Example.send(:include, Example)
+          ::RSpec::Core::ExampleGroup.send(:include, ExampleGroup)
+        end
+      end
+    end
+  end
+end

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

@@ -24,7 +24,7 @@ module Datadog
               span.service = datadog_pin.service
               span.resource = opts[:query]
               span.span_type = Datadog::Ext::SQL::TYPE
-              Utils.set_analytics_sample_rate(span)
+              Utils.set_common_tags(span)
               span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
               response = super(sql, options)
             end
@@ -52,6 +52,8 @@ module Datadog
                       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

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

@@ -38,15 +38,16 @@ module Datadog
           private
 
           def trace_execute(super_method, sql, options, &block)
-            opts = Utils.parse_opts(sql, options, db.opts)
+            opts = Utils.parse_opts(sql, options, db.opts, self)
             response = nil
 
             datadog_pin.tracer.trace(Ext::SPAN_QUERY) do |span|
               span.service = datadog_pin.service
               span.resource = opts[:query]
               span.span_type = Datadog::Ext::SQL::TYPE
-              Utils.set_analytics_sample_rate(span)
+              Utils.set_common_tags(span)
               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

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

@@ -12,6 +12,7 @@ module Datadog
         SERVICE_NAME = 'sequel'.freeze
         SPAN_QUERY = 'sequel.query'.freeze
         TAG_DB_VENDOR = 'sequel.db.vendor'.freeze
+        TAG_PREPARED_NAME = 'sequel.prepared.name'.freeze
       end
     end
   end

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

@@ -1,3 +1,5 @@
+require 'ddtrace/ext/integration'
+
 module Datadog
   module Contrib
     module Sequel
@@ -26,21 +28,30 @@ module Datadog
             Datadog::Utils::Database.normalize_vendor(database.database_type.to_s)
           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)
+          def parse_opts(sql, opts, db_opts, dataset = nil)
+            # Prepared statements don't provide their sql query in the +sql+ parameter.
+            unless sql.is_a?(String)
+              if 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
             end
 
             {
               name: opts[:type],
               query: sql,
+              prepared_name: prepared_name,
               database: db_opts[:database],
               host: db_opts[:host]
             }
           end
 
-          def set_analytics_sample_rate(span)
+          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
 

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

@@ -22,6 +22,7 @@ module Datadog
           end
 
           option :service_name, default: Ext::SERVICE_NAME
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
         end
       end
     end

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

@@ -8,10 +8,13 @@ module Datadog
         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) do |span|
+          @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])

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

@@ -29,6 +29,7 @@ module Datadog
 
           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

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

@@ -11,6 +11,7 @@ module Datadog
         def initialize(options = {})
           super
           @sidekiq_service = options[:service_name] || configuration[:service_name]
+          @error_handler = options[:error_handler] || configuration[:error_handler]
         end
 
         def call(worker, job, queue)
@@ -19,7 +20,9 @@ module Datadog
           service = worker_config(resource, :service_name) || @sidekiq_service
           tag_args = worker_config(resource, :tag_args) || configuration[:tag_args]
 
-          @tracer.trace(Ext::SPAN_JOB, service: service, span_type: Datadog::Ext::AppTypes::WORKER) do |span|
+          @tracer.trace(Ext::SPAN_JOB, service: service, span_type: Datadog::Ext::AppTypes::WORKER,
+                                       on_error: @error_handler) do |span|
+
             span.resource = resource
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])

data/lib/ddtrace/contrib/sinatra/env.rb

@@ -8,12 +8,13 @@ module Datadog
       module Env
         module_function
 
-        def datadog_span(env)
-          env[Ext::RACK_ENV_REQUEST_SPAN]
+        def datadog_span(env, app)
+          env[Ext::RACK_ENV_REQUEST_SPAN][app]
         end
 
-        def set_datadog_span(env, span)
-          env[Ext::RACK_ENV_REQUEST_SPAN] = span
+        def set_datadog_span(env, app, span)
+          hash = (env[Ext::RACK_ENV_REQUEST_SPAN] ||= {})
+          hash[app] = span
         end
 
         def request_header_tags(env, headers)

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

@@ -36,21 +36,32 @@ module Datadog
         end
 
         def self.registered(app)
-          app.use TracerMiddleware
+          app.use TracerMiddleware, app_instance: app
 
           app.after do
             configuration = Datadog.configuration[:sinatra]
             next unless configuration[:tracer].enabled
 
-            # Ensures we only create a span for the top-most Sinatra middleware.
-            #
-            # If we traced all Sinatra middleware apps, we would have a chain
-            # of nested spans that were not responsible for handling this request,
-            # adding little value to users.
-            next if Sinatra::Env.middleware_traced?(env)
-
-            span = Sinatra::Env.datadog_span(env) || Sinatra::Tracer.create_middleware_span(env, configuration)
-
+            span = Sinatra::Env.datadog_span(env, app)
+
+            # TODO: `route` should *only* be populated if @datadog_route is defined.
+            # TODO: If @datadog_route is not defined, then this Sinatra app is not responsible
+            # TODO: for handling this request.
+            # TODO:
+            # TODO: This change would be BREAKING for any Sinatra app (classic or modular),
+            # TODO: as it affects the `resource` value for requests not handled by the Sinatra app.
+            # TODO: Currently we use "#{method} #{path}" in such aces, but `path` is the raw,
+            # TODO: high-cardinality HTTP path, and can contain PII.
+            # TODO:
+            # TODO: The value we should use as the `resource` when the Sinatra app is not
+            # TODO: responsible for the request is a tricky subject.
+            # TODO: The best option is a value that clearly communicates that this app did not
+            # TODO: handle this request. It's important to keep in mind that an unhandled request
+            # TODO: by this Sinatra app might still be handled by another Rack middleware (which can
+            # TODO: be a Sinatra app itself) or it might just 404 if not handled at all.
+            # TODO:
+            # TODO: A possible value for `resource` could set a high level description, e.g.
+            # TODO: `request.request_method`, given we don't have the response object available yet.
             route = if defined?(@datadog_route)
                       @datadog_route
                     else
@@ -59,36 +70,10 @@ module Datadog
                     end
 
             span.resource = "#{request.request_method} #{route}"
-
-            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
-            span.set_tag(Ext::TAG_APP_NAME, app.settings.name)
             span.set_tag(Ext::TAG_ROUTE_PATH, route)
-            if request.script_name && !request.script_name.empty?
-              span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
-            end
-
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-            span.set_error(env['sinatra.error']) if response.server_error?
-
-            Sinatra::Env.set_middleware_traced(env, true)
           end
         end
 
-        # Initializes a span for the top-most Sinatra middleware.
-        def self.create_middleware_span(env, configuration)
-          tracer = configuration[:tracer]
-          span = tracer.trace(
-            Ext::SPAN_REQUEST,
-            service: configuration[:service_name],
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-            start_time: Sinatra::Env.middleware_start_time(env)
-          )
-
-          Sinatra::Env.set_datadog_span(env, span)
-          span
-        end
-
         # Method overrides for Sinatra::Base
         module Base
           def render(engine, data, *)
@@ -114,14 +99,8 @@ module Datadog
           def route_eval
             configuration = Datadog.configuration[:sinatra]
             tracer = configuration[:tracer]
-
             return super unless tracer.enabled
 
-            # For initialization of Sinatra middleware span in order
-            # guarantee that the Ext::SPAN_ROUTE span being created below
-            # has the middleware span as its parent.
-            Sinatra::Tracer.create_middleware_span(env, configuration) unless Sinatra::Env.datadog_span(env)
-
             tracer.trace(
               Ext::SPAN_ROUTE,
               service: configuration[:service_name],