ddtrace 0.54.2 → 1.10.1

data/lib/ddtrace/contrib/rails/framework.rb

@@ -1,172 +0,0 @@
-# typed: false
-require 'ddtrace/pin'
-require 'ddtrace/ext/app_types'
-
-require 'ddtrace/contrib/active_record/integration'
-require 'ddtrace/contrib/active_support/integration'
-require 'ddtrace/contrib/action_cable/integration'
-require 'ddtrace/contrib/action_mailer/integration'
-require 'ddtrace/contrib/action_pack/integration'
-require 'ddtrace/contrib/action_view/integration'
-require 'ddtrace/contrib/grape/endpoint'
-require 'ddtrace/contrib/lograge/integration'
-require 'ddtrace/contrib/semantic_logger/integration'
-
-require 'ddtrace/contrib/rails/ext'
-require 'ddtrace/contrib/rails/utils'
-
-module Datadog
-  module Contrib
-    # Instrument Rails.
-    module Rails
-      # Rails framework code, used to essentially:
-      # - handle configuration entries which are specific to Datadog tracing
-      # - instrument parts of the framework when needed
-      module Framework # rubocop:disable Metrics/ModuleLength
-        # After the Rails application finishes initializing, we configure the Rails
-        # integration and all its sub-components with the application information
-        # available.
-        # We do this after the initialization because not all the information we
-        # require is available before then.
-        def self.setup
-          # NOTE: #configure has the side effect of rebuilding trace components.
-          #       During a typical Rails application lifecycle, we will see trace
-          #       components initialized twice because of this. This is necessary
-          #       because key configuration is not available until after the Rails
-          #       application has fully loaded, and some of this configuration is
-          #       used to reconfigure tracer components with Rails-sourced defaults.
-          #       This is a trade-off we take to get nice defaults.
-          Datadog.configure do |datadog_config|
-            rails_config = config_with_defaults(datadog_config)
-
-            # By default, default service would be guessed from the script
-            # being executed, but here we know better, get it from Rails config.
-            # Don't set this if service has been explicitly provided by the user.
-            datadog_config.service ||= rails_config[:service_name]
-
-            activate_rack!(datadog_config, rails_config)
-            activate_action_cable!(datadog_config, rails_config)
-            activate_action_mailer!(datadog_config, rails_config)
-            activate_active_support!(datadog_config, rails_config)
-            activate_action_pack!(datadog_config, rails_config)
-            activate_action_view!(datadog_config, rails_config)
-            activate_active_job!(datadog_config, rails_config)
-            activate_active_record!(datadog_config, rails_config)
-            activate_lograge!(datadog_config, rails_config)
-            activate_semantic_logger!(datadog_config, rails_config)
-          end
-        end
-
-        def self.config_with_defaults(datadog_config)
-          # We set defaults here instead of in the patcher because we need to wait
-          # for the Rails application to be fully initialized.
-          datadog_config[:rails].tap do |config|
-            config[:service_name] ||= (Datadog.configure.service_without_fallback || Utils.app_name)
-            config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
-            config[:controller_service] ||= config[:service_name]
-            config[:cache_service] ||= "#{config[:service_name]}-cache"
-            config[:job_service] ||= "#{config[:service_name]}-#{Contrib::ActiveJob::Ext::SERVICE_NAME}"
-          end
-        end
-
-        def self.activate_rack!(datadog_config, rails_config)
-          datadog_config.use(
-            :rack,
-            application: ::Rails.application,
-            service_name: rails_config[:service_name],
-            middleware_names: rails_config[:middleware_names],
-            distributed_tracing: rails_config[:distributed_tracing]
-          )
-        end
-
-        def self.activate_active_support!(datadog_config, rails_config)
-          return unless defined?(::ActiveSupport)
-
-          datadog_config.use(
-            :active_support,
-            cache_service: rails_config[:cache_service]
-          )
-        end
-
-        def self.activate_action_cable!(datadog_config, rails_config)
-          return unless defined?(::ActionCable)
-
-          datadog_config.use(
-            :action_cable,
-            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}"
-          )
-        end
-
-        def self.activate_action_mailer!(datadog_config, rails_config)
-          return unless defined?(::ActionMailer)
-
-          datadog_config.use(
-            :action_mailer,
-            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionMailer::Ext::SERVICE_NAME}"
-          )
-        end
-
-        def self.activate_action_pack!(datadog_config, rails_config)
-          return unless defined?(::ActionPack)
-
-          # TODO: This is configuring ActionPack but not patching. It will queue ActionPack
-          #       for patching, but patching won't take place until Datadog.configure completes.
-          #       Should we manually patch here?
-
-          datadog_config.use(
-            :action_pack,
-            service_name: rails_config[:service_name]
-          )
-        end
-
-        def self.activate_action_view!(datadog_config, rails_config)
-          return unless defined?(::ActionView)
-
-          datadog_config.use(
-            :action_view,
-            service_name: rails_config[:service_name]
-          )
-        end
-
-        def self.activate_active_job!(datadog_config, rails_config)
-          return unless defined?(::ActiveJob)
-
-          datadog_config.use(
-            :active_job,
-            service_name: rails_config[:job_service],
-            log_injection: rails_config[:log_injection]
-          )
-        end
-
-        def self.activate_active_record!(datadog_config, rails_config)
-          return unless defined?(::ActiveRecord)
-
-          datadog_config.use(
-            :active_record,
-            service_name: rails_config[:database_service]
-          )
-        end
-
-        def self.activate_lograge!(datadog_config, rails_config)
-          return unless defined?(::Lograge)
-
-          if rails_config[:log_injection]
-            datadog_config.use(
-              :lograge
-            )
-          end
-        end
-
-        def self.activate_semantic_logger!(datadog_config, rails_config)
-          return unless defined?(::SemanticLogger)
-
-          if rails_config[:log_injection]
-            datadog_config.use(
-              :semantic_logger
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-
-require 'ddtrace/contrib/rails/ext'
-require 'ddtrace/contrib/rails/configuration/settings'
-require 'ddtrace/contrib/rails/patcher'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Description of Rails integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('3.0')
-
-        register_as :rails, auto_patch: false
-
-        def self.version
-          Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
-        end
-
-        def self.loaded?
-          !defined?(::Rails).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def self.patchable?
-          super && !ENV.key?(Ext::ENV_DISABLE)
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rails/log_injection.rb

@@ -1,42 +0,0 @@
-# typed: false
-module Datadog
-  module Contrib
-    # Instrument Rails.
-    module Rails
-      # Rails log injection helper methods
-      module LogInjection
-        module_function
-
-        def add_as_tagged_logging_logger(app)
-          # we want to check if the current logger is a tagger logger instance
-          # log_tags defaults to nil so we have to set as an array if nothing exists yet
-          if (log_tags = app.config.log_tags).nil?
-            app.config.log_tags = [proc { Datadog.tracer.active_correlation.to_s }]
-          # if existing log_tags configuration exists, append to the end of the array
-          elsif log_tags.is_a?(Array)
-            app.config.log_tags << proc { Datadog.tracer.active_correlation.to_s }
-          end
-        rescue StandardError => e
-          # TODO: can we use Datadog.logger at this point?
-          Datadog.logger.warn("Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.message}")
-          false
-        end
-
-        def datadog_trace_log_hash(correlation)
-          {
-            # 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']
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rails/middlewares.rb

@@ -1,44 +0,0 @@
-# typed: true
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/action_pack/utils'
-
-module Datadog
-  module Contrib
-    # Rails module includes middlewares that are required for Rails to be properly instrumented.
-    module Rails
-      # This is only here to catch errors, the Rack module does something very similar, however,
-      # since it's not in the same place in the stack, when the Rack middleware is called,
-      # error is already swallowed and handled by Rails so we miss the call stack, for instance.
-      class ExceptionMiddleware
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          @app.call(env)
-        # rubocop:disable Lint/RescueException
-        # Here we really want to catch *any* exception, not only StandardError,
-        # as we really have no clue of what is in the block,
-        # and it is user code which should be executed no matter what.
-        # It's not a problem since we re-raise it afterwards so for example a
-        # SignalException::Interrupt would still bubble up.
-        rescue Exception => e
-          tracer = Datadog.configuration[:rails][:tracer]
-          span = tracer.active_span
-          if !span.nil? && ActionPack::Utils.exception_is_error?(e)
-            # Only set error if it's supposed to be flagged as such
-            # e.g. we don't want to flag 404s.
-            # You can add custom errors via `config.action_dispatch.rescue_responses`
-            span.set_error(e)
-
-            # Some exception gets handled by Rails middleware before it can be set on Rack middleware
-            # The rack span is the root span of the request and should make sure it has the full exception
-            # set on it.
-            env[:datadog_rack_request_span].set_error(e) if env[:datadog_rack_request_span]
-          end
-          raise e
-        end
-      end
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-# typed: ignore
-require 'ddtrace/contrib/rails/utils'
-require 'ddtrace/contrib/rails/framework'
-require 'ddtrace/contrib/rails/middlewares'
-require 'ddtrace/contrib/rails/log_injection'
-require 'ddtrace/contrib/rack/middlewares'
-require 'ddtrace/contrib/semantic_logger/patcher'
-require 'ddtrace/utils/only_once'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Patcher enables patching of 'rails' module.
-      module Patcher
-        include Contrib::Patcher
-
-        BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
-        AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          patch_before_intialize
-          patch_after_intialize
-        end
-
-        def patch_before_intialize
-          ::ActiveSupport.on_load(:before_initialize) do
-            Datadog::Contrib::Rails::Patcher.before_intialize(self)
-          end
-        end
-
-        def before_intialize(app)
-          BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
-            # Middleware must be added before the application is initialized.
-            # Otherwise the middleware stack will be frozen.
-            # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
-            add_middleware(app) if Datadog.configuration[:rails][:middleware]
-            add_logger(app) if Datadog.configuration[:rails][:log_injection]
-          end
-        end
-
-        def add_middleware(app)
-          # Add trace middleware at the top of the middleware stack,
-          # to ensure we capture the complete execution time.
-          app.middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
-
-          # Some Rails middleware can swallow an application error, preventing
-          # the error propagation to the encompassing Rack span.
-          #
-          # We insert our own middleware right before these Rails middleware
-          # have a chance to swallow the error.
-          #
-          # Note: because the middleware stack is push/pop, "before" and "after" are reversed
-          # for our use case: we insert ourselves with "after" a middleware to ensure we are
-          # able to pop the request "before" it.
-          if defined?(::ActionDispatch::DebugExceptions)
-            # Rails >= 3.2
-            app.middleware.insert_after(::ActionDispatch::DebugExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
-          else
-            # Rails < 3.2
-            app.middleware.insert_after(::ActionDispatch::ShowExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
-          end
-        end
-
-        def add_logger(app)
-          should_warn = true
-          # check if lograge key exists
-          # Note: Rails executes initializers sequentially based on alphabetical order,
-          # and lograge config could occur after datadog config.
-          # So checking for `app.config.lograge.enabled` may yield a false negative,
-          # and adding custom options naively if `config.lograge` exists from the lograge Railtie,
-          # is inconsistent since a lograge initializer would override it.
-          # Instead, we patch Lograge `custom_options` internals directly
-          # as part of Rails framework patching
-          # and just flag off the warning log here.
-          # SemanticLogger we similarly patch in the after_initiaize block, and should flag
-          # off the warning log here if we know we'll patch this gem later.
-          should_warn = false if app.config.respond_to?(:lograge) || defined?(::SemanticLogger)
-
-          # if lograge isn't set, check if tagged logged is enabled.
-          # if so, add proc that injects trace identifiers for tagged logging.
-          if (logger = app.config.logger) &&
-             defined?(::ActiveSupport::TaggedLogging) &&
-             logger.is_a?(::ActiveSupport::TaggedLogging)
-
-            Datadog::Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
-            should_warn = false
-          end
-
-          Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger} is not supported") if should_warn
-        end
-
-        def patch_after_intialize
-          ::ActiveSupport.on_load(:after_initialize) do
-            Datadog::Contrib::Rails::Patcher.after_intialize(self)
-          end
-        end
-
-        def after_intialize(app)
-          AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
-            # Finish configuring the tracer after the application is initialized.
-            # We need to wait for some things, like application name, middleware stack, etc.
-            setup_tracer
-          end
-        end
-
-        # Configure Rails tracing with settings
-        def setup_tracer
-          Datadog::Contrib::Rails::Framework.setup
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/rails/railtie.rb

@@ -1,18 +0,0 @@
-# typed: ignore
-require 'ddtrace/contrib/rails/framework'
-require 'ddtrace/contrib/rails/middlewares'
-require 'ddtrace/contrib/rack/middlewares'
-
-module Datadog
-  # Railtie class initializes
-  class Railtie < Rails::Railtie
-    # Add the trace middleware to the application stack
-    initializer 'datadog.before_intialize' do |app|
-      Datadog::Contrib::Rails::Patcher.before_intialize(app)
-    end
-
-    config.after_initialize do
-      Datadog::Contrib::Rails::Patcher.after_intialize(self)
-    end
-  end
-end

data/lib/ddtrace/contrib/rails/utils.rb

@@ -1,25 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/analytics'
-
-module Datadog
-  module Contrib
-    module Rails
-      # common utilities for Rails
-      module Utils
-        def self.app_name
-          if ::Rails::VERSION::MAJOR >= 6
-            ::Rails.application.class.module_parent_name.underscore
-          elsif ::Rails::VERSION::MAJOR >= 4
-            ::Rails.application.class.parent_name.underscore
-          else
-            ::Rails.application.class.to_s.underscore
-          end
-        end
-
-        def self.railtie_supported?
-          !(defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR >= 3 && defined?(::Rails::Railtie)).nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/rake/ext'
-
-module Datadog
-  module Contrib
-    module Rake
-      module Configuration
-        # Custom settings for the Rake 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 :quantize, default: {}
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Rake
-      # Rake integration constants
-      module Ext
-        APP = 'rake'.freeze
-        ENV_ENABLED = 'DD_TRACE_RAKE_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_RAKE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'rake'.freeze
-        SPAN_INVOKE = 'rake.invoke'.freeze
-        SPAN_EXECUTE = 'rake.execute'.freeze
-        TAG_EXECUTE_ARGS = 'rake.execute.args'.freeze
-        TAG_INVOKE_ARGS = 'rake.invoke.args'.freeze
-        TAG_TASK_ARG_NAMES = 'rake.task.arg_names'.freeze
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/rake/ext'
-
-module Datadog
-  module Contrib
-    module Rake
-      # Instrumentation for Rake tasks
-      module Instrumentation
-        def self.included(base)
-          base.prepend(InstanceMethods)
-        end
-
-        # Instance methods for Rake instrumentation
-        module InstanceMethods
-          def invoke(*args)
-            return super unless enabled?
-
-            tracer.trace(Ext::SPAN_INVOKE, span_options) do |span|
-              annotate_invoke!(span, args)
-              super
-            end
-          ensure
-            shutdown_tracer!
-          end
-
-          def execute(args = nil)
-            return super unless enabled?
-
-            tracer.trace(Ext::SPAN_EXECUTE, span_options) do |span|
-              annotate_execute!(span, args)
-              super
-            end
-          ensure
-            shutdown_tracer!
-          end
-
-          private
-
-          def shutdown_tracer!
-            tracer.shutdown! if tracer.active_span.nil? && ::Rake.application.top_level_tasks.include?(name)
-          end
-
-          def annotate_invoke!(span, args)
-            span.resource = name
-            # 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_TASK_ARG_NAMES, arg_names)
-            span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
-          rescue StandardError => e
-            Datadog.logger.debug("Error while tracing Rake invoke: #{e.message}")
-          end
-
-          def annotate_execute!(span, args)
-            span.resource = name
-            span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
-          rescue StandardError => e
-            Datadog.logger.debug("Error while tracing Rake execute: #{e.message}")
-          end
-
-          def quantize_args(args)
-            quantize_options = configuration[:quantize][:args]
-            Datadog::Quantization::Hash.format(args, quantize_options)
-          end
-
-          def enabled?
-            configuration[:enabled] == true
-          end
-
-          def tracer
-            configuration[:tracer]
-          end
-
-          def span_options
-            { service: configuration[:service_name] }
-          end
-
-          def configuration
-            Datadog.configuration[:rake]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/rake/configuration/settings'
-require 'ddtrace/contrib/rake/patcher'
-
-module Datadog
-  module Contrib
-    module Rake
-      # Description of Rake integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('12.0')
-
-        register_as :rake
-
-        def self.version
-          Gem.loaded_specs['rake'] && Gem.loaded_specs['rake'].version
-        end
-
-        def self.loaded?
-          !defined?(::Rake::Task).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/rake/patcher.rb

@@ -1,31 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/rake/ext'
-require 'ddtrace/contrib/rake/instrumentation'
-
-module Datadog
-  module Contrib
-    module Rake
-      # Patcher enables patching of 'rake' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          # Add instrumentation patch to Rake task
-          ::Rake::Task.include(Instrumentation)
-        end
-
-        def get_option(option)
-          Datadog.configuration[:rake].get_option(option)
-        end
-      end
-    end
-  end
-end