datadog 2.0.0.beta1

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../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],
+              type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: configuration[:on_error]
+            }
+
+            Tracing.trace(Ext::SPAN_JOB, **trace_options) do |request_span|
+              request_span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_MESSAGING_SYSTEM)
+
+              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_RABBITMQ_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]
+
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
+              @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/span_attribute_schema.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Contains methods for fetching values according to span attributes schema
+      module SpanAttributeSchema
+        REFLEXIVE_SOURCES = [Tracing::Metadata::Ext::TAG_PEER_SERVICE].freeze
+        NO_SOURCE = [].freeze
+
+        def self.fetch_service_name(env, default)
+          ENV.fetch(env) do
+            if Datadog.configuration.tracing.contrib.global_default_service_name.enabled
+              return Datadog.configuration.service
+            end
+
+            default
+          end
+        end
+
+        def self.set_peer_service!(span, sources)
+          # Acquire all peer.service values as well as any potential remapping
+          peer_service_val, peer_service_source = set_peer_service_from_source(span, sources)
+          remap_val = Datadog.configuration.tracing.contrib.peer_service_mapping[peer_service_val]
+
+          # Only continue to setting peer.service if actual source is found
+          return false unless peer_service_source
+
+          span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_PEER_SERVICE_SOURCE, peer_service_source)
+
+          # Set peer.service to remapped value if found otherwise normally set peer.service
+          if remap_val
+            span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, remap_val)
+            span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_PEER_SERVICE_REMAP, peer_service_val)
+          else
+            span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, peer_service_val)
+          end
+          true
+        end
+
+        # set_peer_service_from_source: Implements the extraction logic to determine the peer.service value
+        # based on the list of source tags passed as a parameter.
+        #
+        # If no values are found, it checks the default list for all spans before returning false for no result
+        # Sets the source of where the information for peer.service was extracted from
+        # Returns a peer.service value if successfully set or not
+        def self.set_peer_service_from_source(span, sources = [])
+          # Filter out sources based on existence of peer.service tag
+          sources = filter_peer_service_sources(span, sources)
+
+          # Find a possible peer.service source from the list of source tags passed in
+          sources.each do |source|
+            source_val = span.get_tag(source)
+            next unless not_empty_tag?(source_val)
+
+            return source_val, source
+          end
+          false
+        end
+
+        private_class_method :set_peer_service_from_source
+
+        # filter_peer_service_sources: returns filtered sources based on existence of peer.service tag
+        # If peer.service exists, we do not read from any other source rather use peer.service as source
+        # This is to prevent overwriting of pre-existing peer.service tags
+        def self.filter_peer_service_sources(span, sources)
+          ps = span.get_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE)
+          # Do not override existing peer.service tag if it exists based on schema version
+          return REFLEXIVE_SOURCES if not_empty_tag?(ps)
+
+          # Check that peer.service is only set on spankind client/producer spans
+          if (span.get_tag(Tracing::Metadata::Ext::TAG_KIND) == Tracing::Metadata::Ext::SpanKind::TAG_CLIENT) ||
+              (span.get_tag(Tracing::Metadata::Ext::TAG_KIND) == Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
+            return sources
+          end
+
+          NO_SOURCE
+        end
+
+        private_class_method :filter_peer_service_sources
+
+        def self.not_empty_tag?(tag)
+          tag && (tag != '')
+        end
+
+        private_class_method :not_empty_tag?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Parsing status range from environment variable
+      class StatusRangeEnvParser
+        class << self
+          def call(value)
+            [].tap do |array|
+              value.split(',').each do |e|
+                next unless e
+
+                v = e.split('-')
+
+                case v.length
+                when 0 then next
+                when 1 then array << Integer(v.first)
+                when 2 then array << (Integer(v.first)..Integer(v.last))
+                else
+                  Datadog.logger.debug(
+                    "Invalid error_status_codes configuration: Unable to parse #{value}, containing #{v}."
+                  )
+                  next
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Useful checking whether the defined range covers status code
+      class StatusRangeMatcher
+        def initialize(ranges)
+          @ranges = Array(ranges)
+        end
+
+        def include?(status)
+          @ranges.any? do |e|
+            case e
+            when Range
+              e.include? status
+            when Integer
+              e == status
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        module Configuration
+          # Custom settings for the Stripe 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Stripe integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_STRIPE_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_STRIPE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_STRIPE_ANALYTICS_SAMPLE_RATE'
+          SPAN_REQUEST = 'stripe.request'
+          SPAN_TYPE_REQUEST = 'custom'
+          TAG_COMPONENT = 'stripe'
+          TAG_OPERATION_REQUEST = 'request'
+          TAG_REQUEST_HTTP_STATUS = 'stripe.request.http_status'
+          TAG_REQUEST_ID = 'stripe.request.id'
+          TAG_REQUEST_METHOD = 'stripe.request.method'
+          TAG_REQUEST_NUM_RETRIES = 'stripe.request.num_retries'
+          TAG_REQUEST_PATH = 'stripe.request.path'
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'request'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Provides instrumentation for `stripe` through the Stripe instrumentation framework
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Stripe::Instrumentation.subscribe(:request_begin, :datadog_tracing) { |event| Request.start_span(event) }
+            ::Stripe::Instrumentation.subscribe(:request_end, :datadog_tracing) { |event| Request.finish_span(event) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../../analytics'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Stripe
+        # Defines instrumentation for Stripe requests
+        module Request
+          module_function
+
+          def start_span(event)
+            # Start a trace
+            Tracing.trace(Ext::SPAN_REQUEST).tap do |span|
+              event.user_data[:datadog_span] = span
+            end
+          end
+
+          def finish_span(event)
+            span = event.user_data[:datadog_span]
+            # If no active span, return.
+            return nil if span.nil?
+
+            begin
+              tag_span(span, event)
+            ensure
+              # Finish the span
+              span.finish
+            end
+          end
+
+          def tag_span(span, event)
+            # dependent upon stripe/stripe-ruby#1168
+            span.resource = "stripe.#{event.object_name}" if event.respond_to?(:object_name) && event.object_name
+
+            span.type = Ext::SPAN_TYPE_REQUEST
+            span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+            # 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.set_tag(Ext::TAG_REQUEST_ID, event.request_id)
+            span.set_tag(Ext::TAG_REQUEST_HTTP_STATUS, event.http_status.to_s)
+            span.set_tag(Ext::TAG_REQUEST_METHOD, event.method)
+            span.set_tag(Ext::TAG_REQUEST_PATH, event.path)
+            span.set_tag(Ext::TAG_REQUEST_NUM_RETRIES, event.num_retries.to_s)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:stripe]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../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.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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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,28 @@
+# frozen_string_literal: 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'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SUCKER_PUNCH_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'sucker_punch'
+          SPAN_PERFORM = 'sucker_punch.perform'
+          SPAN_PERFORM_ASYNC = 'sucker_punch.perform_async'
+          SPAN_PERFORM_IN = 'sucker_punch.perform_in'
+          TAG_PERFORM_IN = 'sucker_punch.perform_in'
+          TAG_QUEUE = 'sucker_punch.queue'
+          TAG_COMPONENT = 'sucker_punch'
+          TAG_OPERATION_PERFORM = 'perform'
+          TAG_OPERATION_PERFORM_ASYNC = 'perform_async'
+          TAG_OPERATION_PERFORM_IN = 'perform_in'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'sucker_punch'
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '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.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 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative '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