ddtrace 0.52.0 → 1.8.0

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

@@ -0,0 +1,104 @@
+# typed: false
+
+require 'resque'
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../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)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER)
+
+              # 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.tracing[:resque]
+          end
+        end
+      end
+    end
+  end
+end
+
+Resque.after_fork do
+  configuration = Datadog.configuration.tracing[: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,42 @@
+# typed: false
+
+require_relative '../../configuration/settings'
+require_relative '../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 do |o|
+              o.default { ENV.fetch(Ext::ENV_SERVICE_NAME, Ext::DEFAULT_PEER_SERVICE_NAME) }
+              o.lazy
+            end
+
+            option :split_by_domain, default: false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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_SERVICE_NAME = 'DD_TRACE_REST_CLIENT_SERVICE_NAME'.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,43 @@
+# typed: false
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative '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_relative '../patcher'
+
+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_relative '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,106 @@
+# typed: false
+
+require 'uri'
+
+require_relative '../../metadata/ext'
+require_relative '../../propagation/http'
+require_relative '../analytics'
+require_relative '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_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+              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[:split_by_domain] ? uri.host : 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.tracing[: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,23 @@
+# typed: false
+
+require_relative '../../configuration/settings'
+require_relative '../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,15 @@
+# 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,50 @@
+# typed: true
+
+require_relative '../../../core/logging/ext'
+
+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.tracing[: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: Core::Logging::Ext::DD_SOURCE
+              }
+
+              # # 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,52 @@
+# typed: false
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative '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,29 @@
+# typed: true
+
+require_relative '../patcher'
+require_relative '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

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

@@ -0,0 +1,33 @@
+# typed: false
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        module Configuration
+          # Custom settings for the Sequel 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# typed: false
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Adds instrumentation to Sequel::Database
+        module Database
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for instrumenting Sequel::Database
+          module InstanceMethods
+            def run(sql, options = ::Sequel::OPTS)
+              opts = parse_opts(sql, options)
+
+              response = nil
+
+              Tracing.trace(Ext::SPAN_QUERY) do |span|
+                span.service =  Datadog.configuration_for(self, :service_name) \
+                                || Datadog.configuration.tracing[:sequel][:service_name] \
+                                || adapter_name
+                span.resource = opts[:query]
+                span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                Utils.set_common_tags(span, self)
+                span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
+                response = super(sql, options)
+              end
+              response
+            end
+
+            private
+
+            def adapter_name
+              Utils.adapter_name(self)
+            end
+
+            def parse_opts(sql, opts)
+              db_opts = if ::Sequel::VERSION < '3.41.0' && self.class.to_s !~ /Dataset$/
+                          @opts
+                        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
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sequel/dataset.rb

@@ -0,0 +1,64 @@
+# typed: false
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sequel
+        # Adds instrumentation to Sequel::Dataset
+        module Dataset
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for instrumenting Sequel::Dataset
+          module InstanceMethods
+            def execute(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            def execute_ddl(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            def execute_dui(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            def execute_insert(sql, options = ::Sequel::OPTS, &block)
+              trace_execute(proc { super(sql, options, &block) }, sql, options, &block)
+            end
+
+            private
+
+            def trace_execute(super_method, sql, options, &block)
+              opts = Utils.parse_opts(sql, options, db.opts, self)
+              response = nil
+
+              Tracing.trace(Ext::SPAN_QUERY) do |span|
+                span.service =  Datadog.configuration_for(db, :service_name) \
+                                || Datadog.configuration.tracing[:sequel][:service_name] \
+                                || adapter_name
+                span.resource = opts[:query]
+                span.span_type = Tracing::Metadata::Ext::SQL::TYPE
+                Utils.set_common_tags(span, db)
+                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
+            end
+
+            def adapter_name
+              Utils.adapter_name(db)
+            end
+          end
+        end
+      end
+    end
+  end
+end