datadog 2.18.0 → 2.20.0

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

@@ -27,7 +27,7 @@ module Datadog
                     span.resource = query
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, false)
-                  rescue StandardError => e
+                  rescue => e
                     Datadog.logger.debug("error preparing span for presto: #{e}")
                   end
 
@@ -45,7 +45,7 @@ module Datadog
                     span.resource = query
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
-                  rescue StandardError => e
+                  rescue => e
                     Datadog.logger.debug("error preparing span for presto: #{e}")
                   end
 
@@ -64,7 +64,7 @@ module Datadog
                     span.type = Tracing::Metadata::Ext::AppTypes::TYPE_DB
                     # ^ not an SQL type span, since there's no SQL query
                     span.set_tag(Ext::TAG_QUERY_ID, query_id)
-                  rescue StandardError => e
+                  rescue => e
                     Datadog.logger.debug("error preparing span for presto: #{e}")
                   end
 

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

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

data/lib/datadog/tracing/contrib/propagation/sql_comment/comment.rb

@@ -15,7 +15,7 @@ module Datadog
 
             def to_s
               @string ||= begin
-                ret = String.new
+                ret = +''
 
                 @hash.each do |key, value|
                   next if value.nil?

data/lib/datadog/tracing/contrib/propagation/sql_comment.rb

@@ -48,7 +48,7 @@ module Datadog
                   Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_traceparent, trace_op.to_digest)
               else
                 Datadog.logger.warn(
-                  'Sql comment propagation with `full` mode is aborted, because tracing is disabled. '\
+                  'Sql comment propagation with `full` mode is aborted, because tracing is disabled. ' \
                   'Please set `Datadog.configuration.tracing.enabled = true` to continue.'
                 )
               end

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

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

data/lib/datadog/tracing/contrib/racecar/event.rb

@@ -26,7 +26,7 @@ module Datadog
             end
 
             def span_options
-              { service: configuration[:service_name] }
+              {service: configuration[:service_name]}
             end
 
             def configuration

data/lib/datadog/tracing/contrib/racecar/events/batch.rb

@@ -26,8 +26,8 @@ module Datadog
 
             def span_options
               super.merge(
-                tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_BATCH,
-                        Tracing::Metadata::Ext::TAG_KIND => Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER }
+                tags: {Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_BATCH,
+                       Tracing::Metadata::Ext::TAG_KIND => Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER}
               )
             end
           end

data/lib/datadog/tracing/contrib/racecar/events/consume.rb

@@ -25,7 +25,7 @@ module Datadog
             end
 
             def span_options
-              super.merge(tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONSUME })
+              super.merge(tags: {Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONSUME})
             end
           end
         end

data/lib/datadog/tracing/contrib/racecar/events/message.rb

@@ -26,8 +26,8 @@ module Datadog
 
             def span_options
               super.merge(
-                tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_MESSAGE,
-                        Tracing::Metadata::Ext::TAG_KIND => Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER }
+                tags: {Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_MESSAGE,
+                       Tracing::Metadata::Ext::TAG_KIND => Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER}
               )
             end
           end

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

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

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

@@ -22,7 +22,7 @@ module Datadog
             end
 
             # Allows this class to have a similar API to a {Hash}.
-            alias [] get
+            alias_method :[], :get
 
             # Tests whether a header with the given name exists in the environment.
             def key?(header_name)

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

@@ -12,17 +12,17 @@ module Datadog
 
             # Use global DD_TRACE_HEADER_TAGS if integration-level configuration is not provided
             tags = if configuration.using_default?(:headers) && !Datadog.configuration.tracing.using_default?(:header_tags)
-                     Datadog.configuration.tracing.header_tags.request_tags(headers)
-                   else
-                     whitelist = configuration[:headers][:request] || []
-                     whitelist.each_with_object({}) do |header, result|
-                       header_value = headers.get(header)
-                       unless header_value.nil?
-                         header_tag = Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)
-                         result[header_tag] = header_value
-                       end
-                     end
-                   end
+              Datadog.configuration.tracing.header_tags.request_tags(headers)
+            else
+              whitelist = configuration[:headers][:request] || []
+              whitelist.each_with_object({}) do |header, result|
+                header_value = headers.get(header)
+                unless header_value.nil?
+                  header_tag = Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)
+                  result[header_tag] = header_value
+                end
+              end
+            end
 
             span.set_tags(tags)
           end
@@ -32,27 +32,27 @@ module Datadog
 
             # Use global DD_TRACE_HEADER_TAGS if integration-level configuration is not provided
             tags = if configuration.using_default?(:headers) && !Datadog.configuration.tracing.using_default?(:header_tags)
-                     Datadog.configuration.tracing.header_tags.response_tags(headers)
-                   else
-                     whitelist = configuration[:headers][:response] || []
-                     whitelist.each_with_object({}) do |header, result|
-                       header_value = headers[header]
-
-                       next if header_value.nil?
-
-                       header_tag = Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)
-
-                       # Maintain the value format between Rack 2 and 3
-                       #
-                       # Rack 2.x => { 'foo' => 'bar,baz' }
-                       # Rack 3.x => { 'foo' => ['bar', 'baz'] }
-                       result[header_tag] = if header_value.is_a? Array
-                                              header_value.join(',')
-                                            else
-                                              header_value
-                                            end
-                     end
-                   end
+              Datadog.configuration.tracing.header_tags.response_tags(headers)
+            else
+              whitelist = configuration[:headers][:response] || []
+              whitelist.each_with_object({}) do |header, result|
+                header_value = headers[header]
+
+                next if header_value.nil?
+
+                header_tag = Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)
+
+                # Maintain the value format between Rack 2 and 3
+                #
+                # Rack 2.x => { 'foo' => 'bar,baz' }
+                # Rack 3.x => { 'foo' => ['bar', 'baz'] }
+                result[header_tag] = if header_value.is_a? Array
+                  header_value.join(',')
+                else
+                  header_value
+                end
+              end
+            end
 
             span.set_tags(tags)
           end

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

@@ -34,8 +34,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/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/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?

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)