ddtrace 0.54.2 → 1.0.0

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,38 @@
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/sucker_punch/ext'
+require 'datadog/tracing/contrib/sucker_punch/integration'
+
+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

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

@@ -0,0 +1,31 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        # Common database-related utility functions.
+        module Database
+          VENDOR_DEFAULT = 'defaultdb'.freeze
+          VENDOR_POSTGRES = 'postgres'.freeze
+          VENDOR_SQLITE = 'sqlite'.freeze
+
+          module_function
+
+          def normalize_vendor(vendor)
+            case vendor
+            when nil
+              VENDOR_DEFAULT
+            when 'postgresql'
+              VENDOR_POSTGRES
+            when 'sqlite3'
+              VENDOR_SQLITE
+            else
+              vendor
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/utils/quantization/hash.rb

@@ -0,0 +1,111 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        module Quantization
+          # Quantization for Hash
+          module Hash
+            PLACEHOLDER = '?'.freeze
+            EXCLUDE_KEYS = [].freeze
+            SHOW_KEYS = [].freeze
+            DEFAULT_OPTIONS = {
+              exclude: EXCLUDE_KEYS,
+              show: SHOW_KEYS,
+              placeholder: PLACEHOLDER
+            }.freeze
+
+            module_function
+
+            def format(hash_obj, options = {})
+              options ||= {}
+              format!(hash_obj, options)
+            rescue StandardError
+              options[:placeholder] || PLACEHOLDER
+            end
+
+            def format!(hash_obj, options = {})
+              options ||= {}
+              options = merge_options(DEFAULT_OPTIONS, options)
+              format_hash(hash_obj, options)
+            end
+
+            def format_hash(hash_obj, options = {})
+              case hash_obj
+              when ::Hash
+                return {} if options[:exclude] == :all
+                return hash_obj if options[:show] == :all
+
+                hash_obj.each_with_object({}) do |(key, value), quantized|
+                  if options[:show].any?(&indifferent_equals(key))
+                    quantized[key] = value
+                  elsif options[:exclude].none?(&indifferent_equals(key))
+                    quantized[key] = format_value(value, options)
+                  end
+                end
+              else
+                format_value(hash_obj, options)
+              end
+            end
+
+            def format_value(value, options = {})
+              return value if options[:show] == :all
+
+              case value
+              when ::Hash
+                format_hash(value, options)
+              when Array
+                # If any are objects, format them.
+                format_array(value, options)
+              else
+                options[:placeholder]
+              end
+            end
+
+            def format_array(value, options)
+              if value.any? { |v| v.class <= ::Hash || v.class <= Array }
+                first_entry = format_value(value.first, options)
+                value.size > 1 ? [first_entry, options[:placeholder]] : [first_entry]
+                # Otherwise short-circuit and return single placeholder
+              else
+                [options[:placeholder]]
+              end
+            end
+
+            def merge_options(original, additional)
+              {}.tap do |options|
+                # Show
+                # If either is :all, value becomes :all
+                options[:show] =  if original[:show] == :all || additional[:show] == :all
+                                    :all
+                                  else
+                                    (original[:show] || []).dup.concat(additional[:show] || []).uniq
+                                  end
+
+                # Exclude
+                # If either is :all, value becomes :all
+                options[:exclude] = if original[:exclude] == :all || additional[:exclude] == :all
+                                      :all
+                                    else
+                                      (original[:exclude] || []).dup.concat(additional[:exclude] || []).uniq
+                                    end
+
+                options[:placeholder] = additional[:placeholder] || original[:placeholder]
+              end
+            end
+
+            def indifferent_equals(value)
+              value = convert_value(value)
+              ->(compared_value) { value == convert_value(compared_value) }
+            end
+
+            def convert_value(value)
+              value.is_a?(Symbol) ? value.to_s : value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/utils/quantization/http.rb

@@ -0,0 +1,99 @@
+# typed: true
+
+require 'uri'
+require 'set'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Utils
+        module Quantization
+          # Quantization for HTTP resources
+          module HTTP
+            include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
+            PLACEHOLDER = '?'.freeze
+
+            module_function
+
+            def url(url, options = {})
+              url!(url, options)
+            rescue StandardError
+              options[:placeholder] || PLACEHOLDER
+            end
+
+            def url!(url, options = {})
+              options ||= {}
+
+              URI.parse(url).tap do |uri|
+                # Format the query string
+                if uri.query
+                  query = query(uri.query, options[:query])
+                  uri.query = (!query.nil? && query.empty? ? nil : query)
+                end
+
+                # Remove any URI framents
+                uri.fragment = nil unless options[:fragment] == :show
+              end.to_s
+            end
+
+            def query(query, options = {})
+              query!(query, options)
+            rescue StandardError
+              options[:placeholder] || PLACEHOLDER
+            end
+
+            def query!(query, options = {})
+              options ||= {}
+              options[:show] = options[:show] || []
+              options[:exclude] = options[:exclude] || []
+
+              # Short circuit if query string is meant to exclude everything
+              # or if the query string is meant to include everything
+              return '' if options[:exclude] == :all
+              return query if options[:show] == :all
+
+              collect_query(query, uniq: true) do |key, value|
+                if options[:exclude].include?(key)
+                  [nil, nil]
+                else
+                  value = options[:show].include?(key) ? value : nil
+                  [key, value]
+                end
+              end
+            end
+
+            # Iterate over each key value pair, yielding to the block given.
+            # Accepts :uniq option, which keeps uniq copies of keys without values.
+            # e.g. Reduces "foo&bar=bar&bar=bar&foo" to "foo&bar=bar&bar=bar"
+            def collect_query(query, options = {})
+              return query unless block_given?
+
+              uniq = options[:uniq].nil? ? false : options[:uniq]
+              keys = Set.new
+
+              delims = query.scan(/(^|&|;)/).flatten
+              query.split(/[&;]/).collect.with_index do |pairs, i|
+                key, value = pairs.split('=', 2)
+                key, value = yield(key, value, delims[i])
+                if uniq && keys.include?(key)
+                  ''
+                elsif key && value
+                  "#{delims[i]}#{key}=#{value}"
+                elsif key
+                  "#{delims[i]}#{key}".tap { keys << key }
+                # rubocop:disable Lint/DuplicateBranch
+                else
+                  ''
+                end
+                # rubocop:enable Lint/DuplicateBranch
+              end.join.sub(/^[&;]/, '')
+            end
+
+            private_class_method :collect_query
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -0,0 +1,76 @@
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/registry'
+require 'datadog/tracing/contrib/extensions'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Registry is a global, declarative repository of all available integrations.
+      #
+      # Integrations should register themselves with the registry as early as
+      # possible as the initial tracer configuration can only activate integrations
+      # if they have already been registered.
+      #
+      # Despite that, integrations *can* be appended to the registry at any point
+      # of the program execution. Newly appended integrations can then be
+      # activated during tracer reconfiguration.
+      #
+      # The registry does not depend on runtime configuration and registered integrations
+      # must execute correctly after successive configuration changes.
+      # The registered integrations themselves can depend on the stateful configuration
+      # of the tracer.
+      #
+      # `Datadog.registry` is a helper accessor to this constant, but it's only available
+      # after the tracer has complete initialization. Use `Datadog::Tracing::Contrib::REGISTRY` instead
+      # of `Datadog.registry` when you code might be called during tracer initialization.
+      REGISTRY = Registry.new
+    end
+  end
+end
+
+require 'datadog/tracing/contrib/action_cable/integration'
+require 'datadog/tracing/contrib/action_mailer/integration'
+require 'datadog/tracing/contrib/action_pack/integration'
+require 'datadog/tracing/contrib/action_view/integration'
+require 'datadog/tracing/contrib/active_model_serializers/integration'
+require 'datadog/tracing/contrib/active_job/integration'
+require 'datadog/tracing/contrib/active_record/integration'
+require 'datadog/tracing/contrib/active_support/integration'
+require 'datadog/tracing/contrib/aws/integration'
+require 'datadog/tracing/contrib/concurrent_ruby/integration'
+require 'datadog/tracing/contrib/dalli/integration'
+require 'datadog/tracing/contrib/delayed_job/integration'
+require 'datadog/tracing/contrib/elasticsearch/integration'
+require 'datadog/tracing/contrib/ethon/integration'
+require 'datadog/tracing/contrib/excon/integration'
+require 'datadog/tracing/contrib/faraday/integration'
+require 'datadog/tracing/contrib/grape/integration'
+require 'datadog/tracing/contrib/graphql/integration'
+require 'datadog/tracing/contrib/grpc/integration'
+require 'datadog/tracing/contrib/http/integration'
+require 'datadog/tracing/contrib/httpclient/integration'
+require 'datadog/tracing/contrib/httprb/integration'
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/kafka/integration'
+require 'datadog/tracing/contrib/lograge/integration'
+require 'datadog/tracing/contrib/mongodb/integration'
+require 'datadog/tracing/contrib/mysql2/integration'
+require 'datadog/tracing/contrib/presto/integration'
+require 'datadog/tracing/contrib/qless/integration'
+require 'datadog/tracing/contrib/que/integration'
+require 'datadog/tracing/contrib/racecar/integration'
+require 'datadog/tracing/contrib/rack/integration'
+require 'datadog/tracing/contrib/rails/integration'
+require 'datadog/tracing/contrib/rake/integration'
+require 'datadog/tracing/contrib/redis/integration'
+require 'datadog/tracing/contrib/resque/integration'
+require 'datadog/tracing/contrib/rest_client/integration'
+require 'datadog/tracing/contrib/semantic_logger/integration'
+require 'datadog/tracing/contrib/sequel/integration'
+require 'datadog/tracing/contrib/shoryuken/integration'
+require 'datadog/tracing/contrib/sidekiq/integration'
+require 'datadog/tracing/contrib/sinatra/integration'
+require 'datadog/tracing/contrib/sneakers/integration'
+require 'datadog/tracing/contrib/sucker_punch/integration'

data/lib/datadog/tracing/correlation.rb

@@ -0,0 +1,100 @@
+# typed: true
+
+require 'datadog/core'
+
+module Datadog
+  module Tracing
+    # Contains behavior for managing correlations with tracing
+    # e.g. Retrieve a correlation to the current trace for logging, etc.
+    module Correlation
+      # Represents current trace state with key identifiers
+      # @public_api
+      class Identifier
+        LOG_ATTR_ENV = 'dd.env'.freeze
+        LOG_ATTR_SERVICE = 'dd.service'.freeze
+        LOG_ATTR_SPAN_ID = 'dd.span_id'.freeze
+        LOG_ATTR_TRACE_ID = 'dd.trace_id'.freeze
+        LOG_ATTR_VERSION = 'dd.version'.freeze
+
+        attr_reader \
+          :env,
+          :service,
+          :span_id,
+          :span_name,
+          :span_resource,
+          :span_service,
+          :span_type,
+          :trace_id,
+          :trace_name,
+          :trace_resource,
+          :trace_service,
+          :version
+
+        # @!visibility private
+        def initialize(
+          env: nil,
+          service: nil,
+          span_id: nil,
+          span_name: nil,
+          span_resource: nil,
+          span_service: nil,
+          span_type: nil,
+          trace_id: nil,
+          trace_name: nil,
+          trace_resource: nil,
+          trace_service: nil,
+          version: nil
+        )
+          # Dup and freeze strings so they aren't modified by reference.
+          @env = Core::Utils::SafeDup.frozen_or_dup(env || Datadog.configuration.env).freeze
+          @service = Core::Utils::SafeDup.frozen_or_dup(service || Datadog.configuration.service).freeze
+          @span_id = span_id || 0
+          @span_name = Core::Utils::SafeDup.frozen_or_dup(span_name).freeze
+          @span_resource = Core::Utils::SafeDup.frozen_or_dup(span_resource).freeze
+          @span_service = Core::Utils::SafeDup.frozen_or_dup(span_service).freeze
+          @span_type = Core::Utils::SafeDup.frozen_or_dup(span_type).freeze
+          @trace_id = trace_id || 0
+          @trace_name = Core::Utils::SafeDup.frozen_or_dup(trace_name).freeze
+          @trace_resource = Core::Utils::SafeDup.frozen_or_dup(trace_resource).freeze
+          @trace_service = Core::Utils::SafeDup.frozen_or_dup(trace_service).freeze
+          @version = Core::Utils::SafeDup.frozen_or_dup(version || Datadog.configuration.version).freeze
+        end
+
+        def to_log_format
+          @log_format ||= begin
+            attributes = []
+            attributes << "#{LOG_ATTR_ENV}=#{env}" unless env.nil?
+            attributes << "#{LOG_ATTR_SERVICE}=#{service}"
+            attributes << "#{LOG_ATTR_VERSION}=#{version}" unless version.nil?
+            attributes << "#{LOG_ATTR_TRACE_ID}=#{trace_id}"
+            attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
+            attributes.join(' ')
+          end
+        end
+      end
+
+      module_function
+
+      # Produces a CorrelationIdentifier from the TraceDigest provided
+      #
+      # DEV: can we memoize this object, give it can be common to
+      # use a correlation multiple times, specially in the context of logging?
+      # @!visibility private
+      def identifier_from_digest(digest)
+        return Identifier.new unless digest
+
+        Identifier.new(
+          span_id: digest.span_id,
+          span_name: digest.span_name,
+          span_resource: digest.span_resource,
+          span_service: digest.span_service,
+          span_type: digest.span_type,
+          trace_id: digest.trace_id,
+          trace_name: digest.trace_name,
+          trace_resource: digest.trace_resource,
+          trace_service: digest.trace_service
+        )
+      end
+    end
+  end
+end