datadog 2.12.0 → 2.22.0

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

@@ -19,7 +19,7 @@ module Datadog
           register_as :rack, auto_patch: false
 
           def self.version
-            Gem.loaded_specs['rack'] && Gem.loaded_specs['rack'].version
+            Gem.loaded_specs['rack']&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -47,7 +47,7 @@ module Datadog
             end
 
             TraceProxyMiddleware.call(env, configuration) do
-              trace_options = { type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND }
+              trace_options = {type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND}
               trace_options[:service] = configuration[:service_name] if configuration[:service_name]
 
               # start a new request span and attach it to the current Rack environment;
@@ -80,7 +80,7 @@ module Datadog
               # catch exceptions that may be raised in the middleware chain
               # Note: if a middleware catches an Exception without re raising,
               # the Exception cannot be recorded here.
-              request_span.set_error(e) unless request_span.nil?
+              request_span&.set_error(e)
               raise e
             ensure
               env[Ext::RACK_ENV_REQUEST_SPAN] = previous_request_span if previous_request_span
@@ -123,7 +123,7 @@ module Datadog
             # 4. Fallback with verb + status, eq `GET 200`
             request_span.resource ||=
               if configuration[:middleware_names] && env['RESPONSE_MIDDLEWARE']
-                "#{env['RESPONSE_MIDDLEWARE']}##{original_request_method}"
+                "#{env["RESPONSE_MIDDLEWARE"]}##{original_request_method}"
               elsif trace.resource_override?
                 trace.resource
               else
@@ -240,16 +240,18 @@ module Datadog
             Datadog.configuration.tracing[:rack]
           end
 
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
           def parse_url(env, original_env)
             request_obj = ::Rack::Request.new(env)
 
             # scheme, host, and port
             base_url = if request_obj.respond_to?(:base_url)
-                         request_obj.base_url
-                       else
-                         # Compatibility for older Rack versions
-                         request_obj.url.chomp(request_obj.fullpath)
-                       end
+              request_obj.base_url
+            else
+              # Compatibility for older Rack versions
+              request_obj.url.chomp(request_obj.fullpath)
+            end
 
             # https://github.com/rack/rack/blob/main/SPEC.rdoc
             #
@@ -269,18 +271,20 @@ module Datadog
             # prepended to PATH_INFO to reflect the correct user visible path.
             request_uri = env['REQUEST_URI'].to_s
             fullpath = if request_uri.empty?
-                         query_string = original_env['QUERY_STRING'].to_s
-                         path = original_env['SCRIPT_NAME'].to_s + original_env['PATH_INFO'].to_s
-
-                         query_string.empty? ? path : "#{path}?#{query_string}"
-                       else
-                         # normally REQUEST_URI starts at the path, but it
-                         # might contain the full URL in some cases (e.g WEBrick)
-                         request_uri.delete_prefix(base_url)
-                       end
+              query_string = original_env['QUERY_STRING'].to_s
+              path = original_env['SCRIPT_NAME'].to_s + original_env['PATH_INFO'].to_s
+
+              query_string.empty? ? path : "#{path}?#{query_string}"
+            else
+              # normally REQUEST_URI starts at the path, but it
+              # might contain the full URL in some cases (e.g WEBrick)
+              request_uri.delete_prefix(base_url)
+            end
 
             base_url + fullpath
           end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
 
           def parse_user_agent_header(headers)
             headers.get(Tracing::Metadata::Ext::HTTP::HEADER_USER_AGENT)

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

@@ -45,7 +45,7 @@ module Datadog
           end
 
           def retain_middleware_name(middleware)
-            return unless middleware && middleware.respond_to?(:call)
+            return unless middleware&.respond_to?(:call)
 
             middleware.singleton_class.class_eval do
               alias_method :__call, :call

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -17,13 +17,14 @@ module Datadog
 
           module_function
 
-          def get_request_start(env, now = Time.now.utc)
+          def get_request_start(env, now = Core::Utils::Time.now.utc)
             header = env[REQUEST_START] || env[QUEUE_START]
             return unless header
 
             # nginx header is seconds in the format "t=1512379167.574"
             # apache header is microseconds in the format "t=1570633834463123"
             # heroku header is milliseconds in the format "1570634024294"
+            # @see https://github.com/heroku/vegur/blob/65d168f757e0ddb448f41cfb9e4b0281c747378d/README.md?plain=1#L383-L384
             time_string = header.to_s.delete('^0-9')
             return if time_string.nil?
 
@@ -34,8 +35,8 @@ module Datadog
             # return the request_start only if it's lesser than
             # current time, to avoid significant clock skew
             request_start = Time.at(time_value)
-            request_start.utc > now ? nil : request_start
-          rescue StandardError => e
+            (request_start.utc > now) ? nil : request_start
+          rescue => e
             # in case of an Exception we don't create a
             # `request.queuing` span
             Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")

data/lib/datadog/tracing/contrib/rack/trace_proxy_middleware.rb

@@ -43,7 +43,13 @@ module Datadog
             # excluding the time spent processing the request itself
             queue_span.finish
 
-            yield.tap { request_span.finish }
+            yield
+          ensure
+            # Ensure that the spans are finished even if an exception is raised.
+            # **This is very important** to prevent the trace from leaking between requests,
+            # especially because `queue_span` is normally a root span.
+            queue_span&.finish
+            request_span&.finish
           end
         end
       end

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

@@ -13,7 +13,7 @@ module Datadog
           # @public_api
           class Settings < Contrib::Configuration::Settings
             def initialize(options = {})
-              super(options)
+              super
 
               # NOTE: Eager load these
               #       Rails integration is responsible for orchestrating other integrations.

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

@@ -12,7 +12,8 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'
-          ENV_DISABLE = 'DISABLE_DATADOG_RAILS'
+          # Note: Alias (previous name DISABLE_DATADOG_RAILS) defined in supported-configurations.json
+          ENV_DISABLE = 'DD_DISABLE_DATADOG_RAILS'
 
           SPAN_RUNNER_FILE = 'rails.runner.file'
           SPAN_RUNNER_INLINE = 'rails.runner.inline'

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

@@ -23,7 +23,7 @@ module Datadog
           register_as :rails, auto_patch: false
 
           def self.version
-            Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
+            Gem.loaded_specs['railties']&.version
           end
 
           def self.loaded?
@@ -35,7 +35,7 @@ module Datadog
           end
 
           def self.patchable?
-            super && !ENV.key?(Ext::ENV_DISABLE)
+            super && !DATADOG_ENV.key?(Ext::ENV_DISABLE)
           end
 
           def new_configuration

data/lib/datadog/tracing/contrib/rails/log_injection.rb

@@ -16,7 +16,7 @@ module Datadog
 
             app_config.log_tags ||= [] # Can be nil, we initialized it if so
             app_config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
-          rescue StandardError => e
+          rescue => e
             Datadog.logger.warn(
               "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"
             )

data/lib/datadog/tracing/contrib/rails/middlewares.rb

@@ -34,7 +34,7 @@ module Datadog
               # 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[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN].set_error(e) if env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+              env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]&.set_error(e)
             end
             raise e
           end

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

@@ -86,7 +86,10 @@ module Datadog
 
           # Instruments the `bin/rails runner` command.
           def patch_rails_runner
-            ::Rails::Command.singleton_class.prepend(Command) if defined?(::Rails::Command)
+            # The `RunnerCommand` class is only available in Rails 5.1 and later.
+            if defined?(::Rails::Command::RunnerCommand) && Integration.version >= Gem::Version.new('5.1')
+              ::Rails::Command::RunnerCommand.prepend(Runner)
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -10,34 +10,48 @@ module Datadog
         # * `-`: for code provided through the STDIN.
         # * File path: for code provided through a local file.
         # * `inline code`: for code provided directly as a command line argument.
+        #
+        # The difficulty in instrumenting the Rails Runner is that
+        # the Rails application (and as a consequence the Datadog tracing library)
+        # is loaded very late in the runner execution.
+        # The Rails application is loaded inside the same method the method
+        # that directly executes the code the user wants the runner to execute:
+        #
+        # ```ruby
+        # def perform(code_or_file = nil, *command_argv)
+        #   boot_application! # Loads the Rails and Datadog
+        #
+        #   if code_or_file == "-"
+        #     eval($stdin.read, TOPLEVEL_BINDING, "stdin") # Calls the user code for this Runner
+        #   # ...
+        # ```
+        #
+        # This means that there's no time to instrument the calling method, `perform`, which
+        # would be ideal. Instead, we resort to instrumenting `eval` and `load`, but
+        # only for calls from the `Rails::Command::RunnerCommand` class.
+        #
         # @see https://guides.rubyonrails.org/v6.1/command_line.html#bin-rails-runner
         module Runner
           # Limit the maximum size of the source code captured in the source tag.
           MAX_TAG_VALUE_SIZE = 4096
           private_constant :MAX_TAG_VALUE_SIZE
 
-          def runner(code_or_file = nil, *_command_argv)
-            if code_or_file == '-'
+          # Instruments the `Kernel.eval` method, but only for the
+          # `Rails::Command::RunnerCommand` class.
+          def eval(*args)
+            source = args[0]
+
+            if args[2] == 'stdin'
               name = Ext::SPAN_RUNNER_STDIN
-              resource = nil
               operation = Ext::TAG_OPERATION_STDIN
-              # The source is not yet available for STDIN, but it will be captured in `eval`.
-            elsif File.exist?(code_or_file)
-              name = Ext::SPAN_RUNNER_FILE
-              resource = code_or_file
-              operation = Ext::TAG_OPERATION_FILE
-              source = File.read(code_or_file)
             else
               name = Ext::SPAN_RUNNER_INLINE
-              resource = nil
               operation = Ext::TAG_OPERATION_INLINE
-              source = code_or_file
             end
 
             Tracing.trace(
               name,
               service: Datadog.configuration.tracing[:rails][:service_name],
-              resource: resource,
               tags: {
                 Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
                 Tracing::Metadata::Ext::TAG_OPERATION => operation,
@@ -55,39 +69,47 @@ module Datadog
             end
           end
 
-          # Capture the executed source code when provided from STDIN.
-          def eval(*args)
-            span = Datadog::Tracing.active_span
-            if span&.name == Ext::SPAN_RUNNER_STDIN
-              source = args[0]
-              span.set_tag(
-                Ext::TAG_RUNNER_SOURCE,
-                Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
-              )
-            end
-
-            super
+          def self.prepended(base)
+            base.const_set(:Kernel, InstrumentedKernel)
           end
 
-          ruby2_keywords :eval if respond_to?(:ruby2_keywords, true)
-        end
+          # Instruments the `Kernel.load` method, but only for the
+          # `Rails::Command::RunnerCommand` class.
+          module InstrumentedKernel
+            def self.load(*args)
+              file = args[0]
+              name = Ext::SPAN_RUNNER_FILE
+              resource = file
+              operation = Ext::TAG_OPERATION_FILE
+
+              begin
+                # Reads one more byte than the limit to allow us to check if the source exceeds the limit.
+                source = File.read(file, MAX_TAG_VALUE_SIZE + 1)
+              rescue => e
+                Datadog.logger.debug("Failed to read file '#{file}' for Rails runner: #{e.message}")
+              end
 
-        # The instrumentation target, {Rails::Command::RunnerCommand} is only loaded
-        # right before `bin/rails runner` is executed. This means there's not much
-        # opportunity to patch it ahead of time.
-        # To ensure we can patch it successfully, we patch it's caller, {Rails::Command}
-        # and promptly patch {Rails::Command::RunnerCommand} when it is loaded.
-        module Command
-          def find_by_namespace(*args)
-            ret = super
-            # Patch RunnerCommand if it is loaded and not already patched.
-            if defined?(::Rails::Command::RunnerCommand) && !(::Rails::Command::RunnerCommand < Runner)
-              ::Rails::Command::RunnerCommand.prepend(Runner)
+              Tracing.trace(
+                name,
+                service: Datadog.configuration.tracing[:rails][:service_name],
+                resource: resource,
+                tags: {
+                  Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
+                  Tracing::Metadata::Ext::TAG_OPERATION => operation,
+                }
+              ) do |span|
+                if source
+                  span.set_tag(
+                    Ext::TAG_RUNNER_SOURCE,
+                    Core::Utils.truncate(source, MAX_TAG_VALUE_SIZE)
+                  )
+                end
+                Contrib::Analytics.set_rate!(span, Datadog.configuration.tracing[:rails])
+
+                super
+              end
             end
-            ret
           end
-
-          ruby2_keywords :find_by_namespace if respond_to?(:ruby2_keywords, true)
         end
       end
     end

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

@@ -65,7 +65,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_INVOKE)
               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
+            rescue => e
               Datadog.logger.debug("Error while tracing Rake invoke: #{e.class.name} #{e.message}")
             end
 
@@ -74,7 +74,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_EXECUTE)
               span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.debug("Error while tracing Rake execute: #{e.class.name} #{e.message}")
             end
 
@@ -84,12 +84,12 @@ module Datadog
             end
 
             def enabled?
-              Datadog.configuration.tracing.enabled && \
+              Datadog.configuration.tracing.enabled &&
                 configuration[:enabled] == true
             end
 
             def span_options
-              { service: configuration[:service_name] }
+              {service: configuration[:service_name]}
             end
 
             def configuration

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

@@ -18,7 +18,7 @@ module Datadog
           register_as :rake
 
           def self.version
-            Gem.loaded_specs['rake'] && Gem.loaded_specs['rake'].version
+            Gem.loaded_specs['rake']&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/redis/configuration/resolver.rb

@@ -19,13 +19,13 @@ module Datadog
             protected
 
             def parse_matcher(matcher)
-              matcher = { url: matcher } if matcher.is_a?(String)
+              matcher = {url: matcher} if matcher.is_a?(String)
 
               normalize(connection_resolver.resolve(matcher))
             end
 
             def normalize(hash)
-              return { url: hash[:url] } if hash[:scheme] == UNIX_SCHEME
+              return {url: hash[:url]} if hash[:scheme] == UNIX_SCHEME
 
               # Connexion strings are always converted to host, port, db and scheme
               # but the host, port, db and scheme will generate the :url only after

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

@@ -24,10 +24,11 @@ module Datadog
           TAG_OPERATION_COMMAND = 'command'
           TAG_SYSTEM = 'redis'
           TAG_DATABASE_INDEX = 'db.redis.database_index'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

@@ -31,11 +31,11 @@ module Datadog
           end
 
           def self.redis_version
-            Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
+            Gem.loaded_specs['redis']&.version
           end
 
           def self.redis_client_version
-            Gem.loaded_specs['redis-client'] && Gem.loaded_specs['redis-client'].version
+            Gem.loaded_specs['redis-client']&.version
           end
 
           def self.loaded?

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

@@ -30,7 +30,7 @@ module Datadog
                 # For `redis-rb` 3.x
                 return client if respond_to?(:client)
 
-                Datadog.logger.warn 'Fail to apply configuration on redis client instance with '  \
+                Datadog.logger.warn 'Fail to apply configuration on redis client instance with ' \
                                                         '`Datadog.configure_onto(redis)`.'
 
                 # Null object instead of raising error
@@ -49,8 +49,8 @@ module Datadog
             module InstanceMethods
               def datadog_pin=(_pin)
                 Datadog.logger.warn \
-                  '`Datadog.configure_onto(redis)` is not supported on Redis 5+. To instrument '\
-                  "a redis instance with custom configuration, please initialize it with:\n"\
+                  '`Datadog.configure_onto(redis)` is not supported on Redis 5+. To instrument ' \
+                  "a redis instance with custom configuration, please initialize it with:\n" \
                   "  `Redis.new(..., custom: { datadog: { service_name: 'my-service' } })`.\n\n" \
                   'See: https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md#redis'
               end
@@ -61,7 +61,7 @@ module Datadog
 
           def default_tags
             [].tap do |tags|
-              tags << "target_redis_version:#{Integration.redis_version}"               if Integration.redis_version
+              tags << "target_redis_version:#{Integration.redis_version}" if Integration.redis_version
               tags << "target_redis_client_version:#{Integration.redis_client_version}" if Integration.redis_client_version
             end
           end

data/lib/datadog/tracing/contrib/redis/quantize.rb

@@ -43,7 +43,7 @@ module Datadog
             return 'AUTH ?' if auth_command?(command_args)
 
             verb, *args = command_args.map { |x| format_arg(x) }
-            Core::Utils.truncate("#{verb.upcase} #{args.join(' ')}", CMD_MAX_LEN, TOO_LONG_MARK)
+            Core::Utils.truncate("#{verb.upcase} #{args.join(" ")}", CMD_MAX_LEN, TOO_LONG_MARK)
           end
 
           def get_verb(command_args)

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -46,7 +46,7 @@ module Datadog
               span.set_tag Ext::TAG_RAW_COMMAND, raw_command
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.error(e.message)
               Datadog::Core::Telemetry::Logger.report(e)
             end

data/lib/datadog/tracing/contrib/redis/trace_middleware.rb

@@ -62,10 +62,10 @@ module Datadog
             # Quantizes a multi-command Redis pipeline execution
             def get_pipeline_commands(commands, command_args)
               list = if command_args
-                       commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-                     else
-                       commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
-                     end
+                commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
+              else
+                commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+              end
 
               list.empty? ? '(none)' : list.join("\n")
             end

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

@@ -35,7 +35,7 @@ module Datadog
         def [](name)
           @mutex.synchronize do
             entry = @data[name]
-            entry.klass if entry
+            entry&.klass
           end
         end
 

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

@@ -18,7 +18,7 @@ module Datadog
           register_as :resque, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['resque'] && Gem.loaded_specs['resque'].version
+            Gem.loaded_specs['resque']&.version
           end
 
           def self.loaded?

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

@@ -76,7 +76,7 @@ module Datadog
           end
 
           def span_options
-            { service: datadog_configuration[:service_name], on_error: datadog_configuration[:on_error] }
+            {service: datadog_configuration[:service_name], on_error: datadog_configuration[:on_error]}
           end
 
           def datadog_configuration

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

@@ -17,10 +17,11 @@ module Datadog
           SPAN_REQUEST = 'rest_client.request'
           TAG_COMPONENT = 'rest_client'
           TAG_OPERATION_REQUEST = 'request'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

@@ -21,7 +21,7 @@ module Datadog
           end
 
           def self.version
-            Gem.loaded_specs['rest-client'] && Gem.loaded_specs['rest-client'].version
+            Gem.loaded_specs['rest-client']&.version
           end
 
           def self.loaded?

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

@@ -22,13 +22,15 @@ module Datadog
             def execute(&block)
               uri = URI.parse(url)
 
-              return super(&block) unless Tracing.enabled?
+              return super unless Tracing.enabled?
 
               datadog_trace_request(uri) do |_span, trace|
-                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                if Tracing::Distributed::PropagationPolicy.enabled?(
+                  global_config: datadog_configuration,
+                  trace: trace
+                )
+                  Contrib::HTTP.inject(trace, processed_headers)
                 end
-                Contrib::HTTP.inject(trace, processed_headers) if datadog_configuration[:distributed_tracing]
 
                 super(&block)
               end
@@ -104,11 +106,11 @@ module Datadog
               # rubocop:disable Lint/RescueException
             rescue Exception => e
               # rubocop:enable Lint/RescueException
-              span.set_error(e) if span
+              span&.set_error(e)
 
               raise e
             ensure
-              span.finish if span
+              span&.finish
             end
 
             private

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

@@ -46,7 +46,7 @@ module Datadog
               ensure
                 begin
                   response = yield
-                rescue StandardError
+                rescue
                   # The status code is unknown to Roda and decided by the upstream web runner.
                   # In this case, spans default to status code 500 rather than a blank status code.
                   default_error_status = '500'

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

@@ -20,7 +20,7 @@ module Datadog
           register_as :roda
 
           def self.version
-            Gem.loaded_specs['roda'] && Gem.loaded_specs['roda'].version
+            Gem.loaded_specs['roda']&.version
           end
 
           def self.loaded?

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

@@ -25,7 +25,7 @@ module Datadog
               # 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 = correlation.to_h.merge(original_named_tags)
-              super(log, message, progname, &block)
+              super
             end
           end
         end

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

@@ -21,7 +21,7 @@ module Datadog
           register_as :semantic_logger
 
           def self.version
-            Gem.loaded_specs['semantic_logger'] && Gem.loaded_specs['semantic_logger'].version
+            Gem.loaded_specs['semantic_logger']&.version
           end
 
           def self.loaded?