ddtrace 0.54.2 → 1.0.0.beta1

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

@@ -0,0 +1,51 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      # Registry is a collection of tracing integrations.
+      # @public_api
+      class Registry
+        include Enumerable
+
+        Entry = Struct.new(:name, :klass, :auto_patch)
+
+        # @!visibility private
+        def initialize
+          @data = {}
+          @mutex = Mutex.new
+        end
+
+        # @param name [Symbol] instrumentation name, to be used when activating this integration
+        # @param klass [Object] instrumentation implementation
+        # @param auto_patch [Boolean] is the tracer allowed to automatically patch
+        #   the host application with this instrumentation?
+        def add(name, klass, auto_patch = false)
+          @mutex.synchronize do
+            @data[name] = Entry.new(name, klass, auto_patch).freeze
+          end
+        end
+
+        def each(&block)
+          @mutex.synchronize do
+            @data.each_value(&block)
+          end
+        end
+
+        def [](name)
+          @mutex.synchronize do
+            entry = @data[name]
+            entry.klass if entry
+          end
+        end
+
+        def to_h
+          @mutex.synchronize do
+            @data.each_with_object({}) do |(_, entry), hash|
+              hash[entry.name] = entry.auto_patch
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: false
+require 'datadog/tracing/span_operation'
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/resque/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        module Configuration
+          # Custom settings for the Resque 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
+            option :error_handler, default: Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Resque integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
+          SERVICE_NAME = 'resque'.freeze
+          SPAN_JOB = 'resque.job'.freeze
+          TAG_COMPONENT = 'resque'.freeze
+          TAG_OPERATION_JOB = 'job'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# typed: false
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/resque/configuration/settings'
+require 'datadog/tracing/contrib/resque/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Description of Resque integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :resque, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['resque'] && Gem.loaded_specs['resque'].version
+          end
+
+          def self.loaded?
+            !defined?(::Resque).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+
+          class << self
+            # Globally-acccesible reference for pre-forking optimization
+            attr_accessor :sync_writer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# typed: false
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/resque/integration'
+require 'datadog/tracing/contrib/sidekiq/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Patcher enables patching of 'resque' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'resque_job'
+
+            ::Resque::Job.prepend(Resque::Job)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/resque_job.rb

@@ -0,0 +1,102 @@
+# typed: false
+require 'resque'
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/sidekiq/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Automatically configures jobs with {ResqueJob} plugin.
+        module Job
+          def perform
+            job = payload_class
+            job.extend(Contrib::Resque::ResqueJob) unless job.is_a?(Contrib::Resque::ResqueJob)
+          ensure
+            super
+          end
+        end
+
+        # Uses Resque job hooks to create traces
+        module ResqueJob
+          # `around_perform` hooks are executed in alphabetical order.
+          # we use the lowest printable character that allows for an inline
+          # method definition ('0'), alongside our naming prefix for identification.
+          #
+          # We could, in theory, use any character (e.g "\x00"), but this will lead
+          # to unreadable stack traces that contain this method call.
+          #
+          # We could also just use `around_perform` but this might override the user's
+          # own method.
+          def around_perform0_ddtrace(*args)
+            return yield unless datadog_configuration && Tracing.enabled?
+
+            Tracing.trace(Ext::SPAN_JOB, **span_options) do |span|
+              span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
+              span.span_type = Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+              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?(datadog_configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+              end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
+              yield
+            end
+          end
+
+          def after_perform_shutdown_tracer(*_)
+            shutdown_tracer_when_forked!
+          end
+
+          def on_failure_shutdown_tracer(*_)
+            shutdown_tracer_when_forked!
+          end
+
+          def shutdown_tracer_when_forked!
+            Tracing.shutdown! if forked?
+          end
+
+          private
+
+          def forked?
+            Datadog.configuration_for(::Resque, :forked) == true
+          end
+
+          def span_options
+            { service: datadog_configuration[:service_name], on_error: datadog_configuration[:error_handler] }
+          end
+
+          def datadog_configuration
+            Datadog.configuration[:resque]
+          end
+        end
+      end
+    end
+  end
+end
+
+Resque.after_fork do
+  configuration = Datadog.configuration[:resque]
+  next if configuration.nil?
+
+  # Add a pin, marking the job as forked.
+  # Used to trigger shutdown in forks for performance reasons.
+  Datadog.configure_onto(::Resque, forked: true)
+
+  # Clean the state so no CoW happens
+  # TODO: Remove this. Should be obsolete with new context management.
+  #       But leave this in the interim... should be safe.
+  tracer = Datadog::Tracing.send(:tracer)
+  next if tracer.nil?
+
+  tracer.provider.context = nil
+end

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

@@ -0,0 +1,35 @@
+# typed: false
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/rest_client/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module RestClient
+        module Configuration
+          # Custom settings for the RestClient 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 :distributed_tracing, default: true
+            option :service_name, default: Ext::DEFAULT_PEER_SERVICE_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module RestClient
+        # RestClient integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REST_CLIENT_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REST_CLIENT_ANALYTICS_SAMPLE_RATE'.freeze
+          DEFAULT_PEER_SERVICE_NAME = 'rest_client'.freeze
+          SPAN_REQUEST = 'rest_client.request'.freeze
+          TAG_COMPONENT = 'rest_client'.freeze
+          TAG_OPERATION_REQUEST = 'request'.freeze
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,29 @@
+# typed: true
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/rest_client/integration'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module RestClient
+        # Patcher enables patching of 'rest_client' 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/rest_client/request_patch'
+
+            ::RestClient::Request.include(RequestPatch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -0,0 +1,104 @@
+# typed: false
+require 'uri'
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/propagation/http'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/rest_client/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module RestClient
+        # RestClient RequestPatch
+        module RequestPatch
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # InstanceMethods - implementing instrumentation
+          module InstanceMethods
+            def execute(&block)
+              uri = URI.parse(url)
+
+              return super(&block) unless Tracing.enabled?
+
+              datadog_trace_request(uri) do |_span, trace|
+                Tracing::Propagation::HTTP.inject!(trace, processed_headers) if datadog_configuration[:distributed_tracing]
+
+                super(&block)
+              end
+            end
+
+            def datadog_tag_request(uri, span)
+              span.resource = method.to_s.upcase
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+              # Tag as an external peer service
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, uri.host)
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, method.to_s.upcase)
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
+            end
+
+            def datadog_trace_request(uri)
+              span = Tracing.trace(
+                Ext::SPAN_REQUEST,
+                service: datadog_configuration[:service_name],
+                span_type: Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+              )
+
+              trace = Tracing.active_trace
+
+              datadog_tag_request(uri, span)
+
+              yield(span, trace).tap do |response|
+                # Verify return value is a response
+                # If so, add additional tags.
+                if response.is_a?(::RestClient::Response)
+                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.code)
+                end
+              end
+            rescue ::RestClient::ExceptionWithResponse => e
+              span.set_error(e) if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(e.http_code)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, e.http_code)
+
+              raise e
+              # rubocop:disable Lint/RescueException
+            rescue Exception => e
+              # rubocop:enable Lint/RescueException
+              span.set_error(e) if span
+
+              raise e
+            ensure
+              span.finish if span
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration[:rest_client]
+            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/semantic_logger/configuration/settings.rb

@@ -0,0 +1,22 @@
+# typed: false
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/semantic_logger/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SemanticLogger
+        module Configuration
+          # Custom settings for the SemanticLogger integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module SemanticLogger
+        # SemanticLogger integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SEMANTIC_LOGGER_ENABLED'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# typed: true
+require 'datadog/tracing'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SemanticLogger
+        # Instrumentation for SemanticLogger
+        module Instrumentation
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for configuration
+          module InstanceMethods
+            def log(log, message = nil, progname = nil, &block)
+              return super unless Datadog.configuration[:semantic_logger].enabled
+
+              original_named_tags = log.named_tags || {}
+
+              # Retrieves trace information for current thread
+              correlation = Tracing.correlation
+              # merge original lambda with datadog context
+
+              datadog_trace_log_hash = {
+                # Adds IDs as tags to log output
+                dd: {
+                  # To preserve precision during JSON serialization, use strings for large numbers
+                  trace_id: correlation.trace_id.to_s,
+                  span_id: correlation.span_id.to_s,
+                  env: correlation.env.to_s,
+                  service: correlation.service.to_s,
+                  version: correlation.version.to_s
+                },
+                ddsource: ['ruby']
+              }
+
+              # # if the user already has conflicting log_tags
+              # # we want them to clobber ours, because we should allow them to override
+              # # if needed.
+              log.named_tags = datadog_trace_log_hash.merge(original_named_tags)
+              super(log, message, progname, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# typed: false
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/semantic_logger/configuration/settings'
+require 'datadog/tracing/contrib/semantic_logger/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SemanticLogger
+        # Description of SemanticLogger integration
+        class Integration
+          include Contrib::Integration
+
+          # v4 had a migration to `named_tags` instead of `payload`
+          # and has been out for almost 5 years at this point
+          # it's probably reasonable to nudge users to using modern ruby libs
+          MINIMUM_VERSION = Gem::Version.new('4.0.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :semantic_logger
+
+          def self.version
+            Gem.loaded_specs['semantic_logger'] && Gem.loaded_specs['semantic_logger'].version
+          end
+
+          def self.loaded?
+            !defined?(::SemanticLogger::Logger).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          # TODO: abstract out the log injection related instrumentation into it's own module so we dont
+          # keep having to do these workarounds
+          def auto_instrument?
+            false
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# typed: true
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/semantic_logger/instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Datadog SemanticLogger integration.
+      module SemanticLogger
+        # Patcher enables patching of 'semantic_logger' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          # patch applies our patch
+          def patch
+            ::SemanticLogger::Logger.include(Instrumentation)
+          end
+        end
+      end
+    end
+  end
+end