ddtrace 0.35.2 → 1.1.0

data/lib/datadog/tracing/contrib/sinatra/tracer_middleware.rb

@@ -0,0 +1,123 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/rack/ext'
+require 'datadog/tracing/contrib/sinatra/env'
+require 'datadog/tracing/contrib/sinatra/ext'
+require 'datadog/tracing/contrib/sinatra/headers'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Middleware used for automatically tagging configured headers and handle request span
+        class TracerMiddleware
+          def initialize(app, opt = {})
+            @app = app
+            @app_instance = opt[:app_instance]
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          def call(env)
+            # Set the trace context (e.g. distributed tracing)
+            if configuration[:distributed_tracing] && Tracing.active_trace.nil?
+              original_trace = Propagation::HTTP.extract(env)
+              Tracing.continue_trace!(original_trace)
+            end
+
+            Tracing.trace(
+              Ext::SPAN_REQUEST,
+              service: configuration[:service_name],
+              span_type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
+            ) do |span|
+              begin
+                # this is kept nil until we set a correct one (either in the route or with a fallback in the ensure below)
+                # the nil signals that there's no good one yet and is also seen by profiler, when sampling the resource
+                span.resource = nil
+
+                Sinatra::Env.set_datadog_span(env, @app_instance, span)
+
+                response = @app.call(env)
+              ensure
+                Sinatra::Env.request_header_tags(env, configuration[:headers][:request]).each do |name, value|
+                  span.set_tag(name, value) if span.get_tag(name).nil?
+                end
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+                request = ::Sinatra::Request.new(env)
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, request.path)
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request.request_method)
+                if request.script_name && !request.script_name.empty?
+                  span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+                end
+
+                span.set_tag(Ext::TAG_APP_NAME, @app_instance.settings.name)
+
+                # If this app handled the request, then Contrib::Sinatra::Tracer OR Contrib::Sinatra::Base set the
+                # resource; if no resource was set, let's use a fallback
+                span.resource = env['REQUEST_METHOD'] if span.resource.nil?
+
+                rack_request_span = env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+
+                # This propagates the Sinatra resource to the Rack span,
+                # since the latter is unaware of what the resource might be
+                # and would fallback to a generic resource name when unset
+                rack_request_span.resource ||= span.resource if rack_request_span
+
+                if response
+                  if (status = response[0])
+                    sinatra_response = ::Sinatra::Response.new([], status) # Build object to use status code helpers
+
+                    span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, sinatra_response.status)
+                    span.set_error(env['sinatra.error']) if sinatra_response.server_error?
+                  end
+
+                  if (headers = response[1])
+                    Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
+                      span.set_tag(name, value) if span.get_tag(name).nil?
+                    end
+                  end
+                end
+
+                # Set analytics sample rate
+                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+              end
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          private
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            configuration[:analytics_sample_rate]
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:sinatra]
+          end
+
+          def header_to_rack_header(name)
+            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/tracing/span_operation'
+require 'datadog/tracing/contrib/configuration/settings'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        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, false) }
+              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
+            option :error_handler, default: Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+            option :tag_body, default: false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Sneakers integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SNEAKERS_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SNEAKERS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SNEAKERS_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'sneakers'
+          SPAN_JOB = 'sneakers.job'
+          TAG_JOB_ROUTING_KEY = 'sneakers.routing_key'
+          TAG_JOB_QUEUE = 'sneakers.queue'
+          TAG_JOB_BODY = 'sneakers.body'
+          TAG_COMPONENT = 'sneakers'
+          TAG_OPERATION_JOB = 'job'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/sneakers/ext'
+require 'datadog/tracing/contrib/sneakers/configuration/settings'
+require 'datadog/tracing/contrib/sneakers/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Description of Sneakers integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.12.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :sneakers, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['sneakers'] && Gem.loaded_specs['sneakers'].version
+          end
+
+          def self.loaded?
+            !defined?(::Sneakers).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/sneakers/patcher.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/sneakers/tracer'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Patcher enables patching of 'sneakers' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Sneakers.middleware.use(Sneakers::Tracer, nil)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Tracer is a Sneakers server-side middleware which traces executed jobs
+        class Tracer
+          def initialize(app, *args)
+            @app = app
+            @args = args
+          end
+
+          def call(deserialized_msg, delivery_info, metadata, handler)
+            trace_options = {
+              service: configuration[:service_name],
+              span_type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: configuration[:error_handler]
+            }
+
+            Tracing.trace(Ext::SPAN_JOB, **trace_options) do |request_span|
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              request_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(request_span, configuration[:analytics_sample_rate])
+              end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(request_span)
+
+              request_span.resource = @app.to_proc.binding.eval('self.class').to_s
+              request_span.set_tag(Ext::TAG_JOB_ROUTING_KEY, delivery_info.routing_key)
+              request_span.set_tag(Ext::TAG_JOB_QUEUE, delivery_info.consumer.queue.name)
+
+              request_span.set_tag(Ext::TAG_JOB_BODY, deserialized_msg) if configuration[:tag_body]
+
+              @app.call(deserialized_msg, delivery_info, metadata, handler)
+            end
+          end
+
+          private
+
+          def configuration
+            Datadog.configuration.tracing[:sneakers]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/status_code_matcher.rb

@@ -0,0 +1,75 @@
+# typed: true
+
+require 'set'
+
+require 'datadog/core'
+require 'datadog/tracing/metadata/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Contains methods helpful for tracing/annotating HTTP request libraries
+      class StatusCodeMatcher
+        REGEX_PARSER = /^\d{3}(?:-\d{3})?(?:,\d{3}(?:-\d{3})?)*$/.freeze
+
+        def initialize(range)
+          @error_response_range = range
+          set_range
+        end
+
+        def include?(exception_status)
+          set_range.include?(exception_status)
+        end
+
+        def to_s
+          @error_response_range.to_s
+        end
+
+        private
+
+        def set_range
+          @datadog_set ||= begin
+            set = Set.new
+            handle_statuses.each do |statuses|
+              status = statuses.to_s.split('-')
+              case status.length
+              when 1
+                set.add(Integer(status[0]))
+              when 2
+                min, max = status.minmax
+                Array(min..max).each do |i|
+                  set.add(Integer(i))
+                end
+              end
+            end
+            set
+          end
+          @datadog_set
+        end
+
+        def error_responses
+          return @error_response_range if @error_response_range.is_a?(String) && !@error_response_range.nil?
+
+          @error_response_range.join(',') if @error_response_range.is_a?(Array) && !@error_response_range.empty?
+        end
+
+        def handle_statuses
+          if error_responses
+            filter_error_responses = error_responses.gsub(/\s+/, '').split(',').select do |code|
+              if !code.to_s.match(REGEX_PARSER)
+                Datadog.logger.debug("Invalid config provided: #{code}. Must be formatted like '400-403,405,410-499'.")
+                next
+              else
+                true
+              end
+            end
+            filter_error_responses.empty? ? Tracing::Metadata::Ext::HTTP::ERROR_RANGE.to_a : filter_error_responses
+          else
+            Datadog.logger.debug('No valid config was provided for :error_statuses - falling back to default.')
+            Tracing::Metadata::Ext::HTTP::ERROR_RANGE.to_a
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/sucker_punch/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        module Configuration
+          # Custom settings for the SuckerPunch integration
+          # @public_api
+          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, false) }
+              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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sucker_punch/exception_handler.rb

@@ -0,0 +1,28 @@
+# typed: false
+
+require 'sucker_punch'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Patches `sucker_punch` exception handling
+        module ExceptionHandler
+          METHOD = ->(e, *) { raise(e) }
+
+          module_function
+
+          def patch!
+            ::SuckerPunch.singleton_class.class_eval do
+              alias_method :__exception_handler, :exception_handler
+
+              def exception_handler
+                ::Datadog::Tracing::Contrib::SuckerPunch::ExceptionHandler::METHOD
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # SuckerPunch integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SUCKER_PUNCH_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SUCKER_PUNCH_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'.freeze
+          SERVICE_NAME = 'sucker_punch'.freeze
+          SPAN_PERFORM = 'sucker_punch.perform'.freeze
+          SPAN_PERFORM_ASYNC = 'sucker_punch.perform_async'.freeze
+          SPAN_PERFORM_IN = 'sucker_punch.perform_in'.freeze
+          TAG_PERFORM_IN = 'sucker_punch.perform_in'.freeze
+          TAG_QUEUE = 'sucker_punch.queue'.freeze
+          TAG_COMPONENT = 'sucker_punch'.freeze
+          TAG_OPERATION_PERFORM = 'perform'.freeze
+          TAG_OPERATION_PERFORM_ASYNC = 'perform_async'.freeze
+          TAG_OPERATION_PERFORM_IN = 'perform_in'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sucker_punch/instrumentation.rb

@@ -0,0 +1,105 @@
+# typed: false
+
+require 'sucker_punch'
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/sucker_punch/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Defines instrumentation patches for the `sucker_punch` gem
+        module Instrumentation
+          module_function
+
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/AbcSize
+          def patch!
+            # rubocop:disable Metrics/BlockLength
+            ::SuckerPunch::Job::ClassMethods.class_eval do
+              alias_method :__run_perform_without_datadog, :__run_perform
+              def __run_perform(*args)
+                Datadog::Tracing.send(:tracer).provider.context = Datadog::Tracing::Context.new
+
+                __with_instrumentation(Ext::SPAN_PERFORM) do |span|
+                  span.resource = "PROCESS #{self}"
+
+                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PERFORM)
+
+                  # Set analytics sample rate
+                  if Datadog::Tracing::Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+                    Datadog::Tracing::Contrib::Analytics.set_sample_rate(
+                      span,
+                      datadog_configuration[:analytics_sample_rate]
+                    )
+                  end
+
+                  # Measure service stats
+                  Datadog::Tracing::Contrib::Analytics.set_measured(span)
+
+                  __run_perform_without_datadog(*args)
+                end
+              rescue => e
+                ::SuckerPunch.__exception_handler.call(e, self, args)
+              end
+              ruby2_keywords :__run_perform if respond_to?(:ruby2_keywords, true)
+
+              alias_method :__perform_async, :perform_async
+              def perform_async(*args)
+                __with_instrumentation(Ext::SPAN_PERFORM_ASYNC) do |span|
+                  span.resource = "ENQUEUE #{self}"
+
+                  span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PERFORM_ASYNC)
+
+                  # Measure service stats
+                  Datadog::Tracing::Contrib::Analytics.set_measured(span)
+
+                  __perform_async(*args)
+                end
+              end
+              ruby2_keywords :perform_async if respond_to?(:ruby2_keywords, true)
+
+              alias_method :__perform_in, :perform_in
+              def perform_in(interval, *args)
+                __with_instrumentation(Ext::SPAN_PERFORM_IN) do |span|
+                  span.resource = "ENQUEUE #{self}"
+
+                  span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_PERFORM_IN)
+
+                  span.set_tag(Ext::TAG_PERFORM_IN, interval)
+
+                  # Measure service stats
+                  Datadog::Tracing::Contrib::Analytics.set_measured(span)
+
+                  __perform_in(interval, *args)
+                end
+              end
+              ruby2_keywords :perform_in if respond_to?(:ruby2_keywords, true)
+
+              private
+
+              def datadog_configuration
+                Datadog.configuration.tracing[:sucker_punch]
+              end
+
+              def __with_instrumentation(name)
+                Datadog::Tracing.trace(name, service: datadog_configuration[:service_name]) do |span|
+                  span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+                  span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                  span.set_tag(Ext::TAG_QUEUE, to_s)
+                  yield span
+                end
+              end
+            end
+            # rubocop:enable Metrics/BlockLength
+          end
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/sucker_punch/configuration/settings'
+require 'datadog/tracing/contrib/sucker_punch/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Description of SuckerPunch integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.0.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :sucker_punch, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['sucker_punch'] && Gem.loaded_specs['sucker_punch'].version
+          end
+
+          def self.loaded?
+            !defined?(::SuckerPunch).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/sucker_punch/patcher.rb

@@ -0,0 +1,37 @@
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/sucker_punch/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        # Patcher enables patching of 'sucker_punch' module.
+        module Patcher
+          include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require 'datadog/tracing/contrib/sucker_punch/exception_handler'
+            require 'datadog/tracing/contrib/sucker_punch/instrumentation'
+
+            ExceptionHandler.patch!
+            Instrumentation.patch!
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:sucker_punch].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end