ddtrace 0.54.2 → 1.0.0.beta1

data/lib/ddtrace/contrib/resque/ext.rb

@@ -1,18 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Resque
-      # Resque integration constants
-      module Ext
-        APP = 'resque'.freeze
-        ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_RESQUE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'resque'.freeze
-        SPAN_JOB = 'resque.job'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/resque/integration.rb

@@ -1,44 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/resque/configuration/settings'
-require 'ddtrace/contrib/resque/patcher'
-
-module Datadog
-  module Contrib
-    module Resque
-      # Description of Resque integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('1.0')
-
-        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 default_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

data/lib/ddtrace/contrib/resque/patcher.rb

@@ -1,30 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/sidekiq/ext'
-
-module Datadog
-  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)
-
-          workers = Datadog.configuration[:resque][:workers] || []
-          workers.each { |worker| worker.extend(ResqueJob) }
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/resque/resque_job.rb

@@ -1,104 +0,0 @@
-# typed: false
-require 'ddtrace/ext/app_types'
-require 'ddtrace/sync_writer'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/sidekiq/ext'
-require 'resque'
-
-module Datadog
-  module Contrib
-    module Resque
-      # Automatically configures jobs with {ResqueJob} plugin.
-      module Job
-        def perform
-          if Datadog.configuration[:resque][:workers].nil?
-            job = payload_class
-            job.extend(Datadog::Contrib::Resque::ResqueJob) unless job.is_a? Datadog::Contrib::Resque::ResqueJob
-          end
-        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 && tracer
-
-          tracer.trace(Ext::SPAN_JOB, span_options) do |span|
-            span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
-            span.span_type = Datadog::Ext::AppTypes::WORKER
-            # 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!
-          tracer.shutdown! if forked?
-        end
-
-        private
-
-        def forked?
-          pin = Datadog::Pin.get_from(::Resque)
-          return false unless pin
-
-          pin.config[:forked] == true
-        end
-
-        def span_options
-          { service: datadog_configuration[:service_name], on_error: datadog_configuration[:error_handler] }
-        end
-
-        def tracer
-          datadog_configuration.tracer
-        end
-
-        def datadog_configuration
-          Datadog.configuration[:resque]
-        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::Pin.new(
-    configuration[:service_name],
-    config: { forked: true }
-  ).onto(::Resque)
-
-  # Clean the state so no CoW happens
-  next if configuration[:tracer].nil?
-
-  configuration[:tracer].provider.context = nil
-end

data/lib/ddtrace/contrib/rest_client/configuration/settings.rb

@@ -1,32 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/rest_client/ext'
-
-module Datadog
-  module Contrib
-    module RestClient
-      module Configuration
-        # Custom settings for the RestClient 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, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :distributed_tracing, default: true
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rest_client/ext.rb

@@ -1,18 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module RestClient
-      # RestClient integration constants
-      module Ext
-        APP = 'rest_client'.freeze
-        ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_REST_CLIENT_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_REST_CLIENT_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REST_CLIENT_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_REST_CLIENT_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'rest_client'.freeze
-        SPAN_REQUEST = 'rest_client.request'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rest_client/integration.rb

@@ -1,39 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/rest_client/configuration/settings'
-require 'ddtrace/contrib/rest_client/patcher'
-
-module Datadog
-  module Contrib
-    module RestClient
-      # Description of RestClient integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('1.8')
-
-        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 default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rest_client/patcher.rb

@@ -1,25 +0,0 @@
-# typed: true
-module Datadog
-  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 'ddtrace/ext/app_types'
-          require 'ddtrace/contrib/rest_client/request_patch'
-
-          ::RestClient::Request.include(RequestPatch)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rest_client/request_patch.rb

@@ -1,92 +0,0 @@
-# typed: false
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/integration'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/contrib/rest_client/ext'
-
-module Datadog
-  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 datadog_configuration[:tracer].enabled
-
-            datadog_trace_request(uri) do |span|
-              if datadog_configuration[:distributed_tracing]
-                Datadog::HTTPPropagator.inject!(span.context, processed_headers)
-              end
-
-              super(&block)
-            end
-          end
-
-          def datadog_tag_request(uri, span)
-            span.resource = method.to_s.upcase
-
-            # Tag as an external peer service
-            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-            span.set_tag(Datadog::Ext::HTTP::URL, uri.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, method.to_s.upcase)
-            span.set_tag(Datadog::Ext::NET::TARGET_HOST, uri.host)
-            span.set_tag(Datadog::Ext::NET::TARGET_PORT, uri.port)
-          end
-
-          def datadog_trace_request(uri)
-            span = datadog_configuration[:tracer].trace(Ext::SPAN_REQUEST,
-                                                        service: datadog_configuration[:service_name],
-                                                        span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND)
-
-            datadog_tag_request(uri, span)
-
-            yield(span).tap do |response|
-              # Verify return value is a response
-              # If so, add additional tags.
-              span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.code) if response.is_a?(::RestClient::Response)
-            end
-          rescue ::RestClient::ExceptionWithResponse => e
-            span.set_error(e) if Datadog::Ext::HTTP::ERROR_RANGE.cover?(e.http_code)
-            span.set_tag(Datadog::Ext::HTTP::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

data/lib/ddtrace/contrib/semantic_logger/configuration/settings.rb

@@ -1,19 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/semantic_logger/ext'
-
-module Datadog
-  module Contrib
-    module SemanticLogger
-      module Configuration
-        # Custom settings for the SemanticLogger integration
-        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

data/lib/ddtrace/contrib/semantic_logger/ext.rb

@@ -1,11 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module SemanticLogger
-      # SemanticLogger integration constants
-      module Ext
-        ENV_ENABLED = 'DD_TRACE_SEMANTIC_LOGGER_ENABLED'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/semantic_logger/instrumentation.rb

@@ -1,43 +0,0 @@
-# typed: true
-module Datadog
-  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)
-            original_named_tags = log.named_tags || {}
-
-            # Retrieves trace information for current thread
-            correlation = Datadog.tracer.active_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

data/lib/ddtrace/contrib/semantic_logger/integration.rb

@@ -1,48 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/semantic_logger/configuration/settings'
-require 'ddtrace/contrib/semantic_logger/patcher'
-
-module Datadog
-  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')
-
-        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 default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/semantic_logger/patcher.rb

@@ -1,26 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/semantic_logger/instrumentation'
-
-module Datadog
-  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

data/lib/ddtrace/contrib/sequel/configuration/settings.rb

@@ -1,29 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/sequel/ext'
-
-module Datadog
-  module Contrib
-    module Sequel
-      module Configuration
-        # Custom settings for the Sequel 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, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/sequel/database.rb

@@ -1,64 +0,0 @@
-# typed: false
-require 'ddtrace/ext/sql'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/sequel/ext'
-require 'ddtrace/contrib/sequel/utils'
-
-module Datadog
-  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
-
-            datadog_pin.tracer.trace(Ext::SPAN_QUERY) do |span|
-              span.service = datadog_pin.service
-              span.resource = opts[:query]
-              span.span_type = Datadog::Ext::SQL::TYPE
-              Utils.set_common_tags(span)
-              span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
-              response = super(sql, options)
-            end
-            response
-          end
-
-          def datadog_pin
-            @pin ||= Datadog::Pin.new(
-              Datadog.configuration[:sequel][:service_name] || adapter_name,
-              app: Ext::APP,
-              app_type: Datadog::Ext::AppTypes::DB,
-              tracer: -> { Datadog.configuration[:sequel][:tracer] }
-            )
-          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