newrelic_rpm 8.11.0 → 8.13.0

data/lib/new_relic/agent/instrumentation/elasticsearch.rb

@@ -0,0 +1,31 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'elasticsearch/instrumentation'
+require_relative 'elasticsearch/chain'
+require_relative 'elasticsearch/prepend'
+
+DependencyDetection.defer do
+  named :elasticsearch
+
+  depends_on do
+    defined?(::Elasticsearch)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info('Installing Elasticsearch instrumentation')
+
+    to_instrument = if ::Gem::Version.create(::Elasticsearch::VERSION) < ::Gem::Version.create("8.0.0")
+      ::Elasticsearch::Transport::Client
+    else
+      ::Elastic::Transport::Client
+    end
+
+    if use_prepend?
+      prepend_instrument to_instrument, NewRelic::Agent::Instrumentation::Elasticsearch::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Elasticsearch
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/excon.rb

@@ -17,6 +17,7 @@ DependencyDetection.defer do
   # so we could safely subscribe and not be clobbered by future subscribers,
   # but alas, it does not yet.
 
+  # TODO: MAJOR VERSION - update min version to 0.56.0
   EXCON_MIN_VERSION = Gem::Version.new("0.19.0")
 
   depends_on do
@@ -32,6 +33,22 @@ DependencyDetection.defer do
     end
   end
 
+  executes do
+    next unless Gem::Version.new(::Excon::VERSION) < Gem::Version.new('0.56.0')
+
+    deprecation_msg = 'Instrumentation for Excon versions below 0.56.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Excon version to continue receiving full support. '
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_excon_version,
+      deprecation_msg
+    )
+
+    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Excon", 1)
+  end
+
   def install_excon_instrumentation(excon_version)
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'

data/lib/new_relic/agent/instrumentation/grape/instrumentation.rb

@@ -45,6 +45,7 @@ module NewRelic::Agent::Instrumentation
 
       def handle_transaction(endpoint, class_name, version)
         return unless endpoint && route = endpoint.route
+
         name_transaction(route, class_name, version)
         capture_params(endpoint)
       end

data/lib/new_relic/agent/instrumentation/logger/instrumentation.rb

@@ -15,21 +15,25 @@ module NewRelic
         # and AuditLogger without them having to know the inner details.
         def self.mark_skip_instrumenting(logger)
           return if logger.frozen?
+
           logger.instance_variable_set(:@skip_instrumenting, true)
         end
 
         def self.clear_skip_instrumenting(logger)
           return if logger.frozen?
+
           logger.instance_variable_set(:@skip_instrumenting, false)
         end
 
         def mark_skip_instrumenting
           return if frozen?
+
           @skip_instrumenting = true
         end
 
         def clear_skip_instrumenting
           return if frozen?
+
           @skip_instrumenting = false
         end
 

data/lib/new_relic/agent/instrumentation/mongodb_command_subscriber.rb

@@ -14,6 +14,7 @@ module NewRelic
         def started(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
+
             segments[event.operation_id] = start_segment(event)
           rescue Exception => e
             log_notification_error('started', e)
@@ -33,6 +34,7 @@ module NewRelic
         def completed(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
+
             segment = segments.delete(event.operation_id)
             return unless segment
 

data/lib/new_relic/agent/instrumentation/notifications_subscriber.rb

@@ -76,6 +76,7 @@ module NewRelic
           # defensive.
           return if defined?(exception_object)
           return unless defined?(::ActiveSupport::VERSION)
+
           if ::ActiveSupport::VERSION::STRING < "5.0.0"
             # Earlier versions of Rails did not add the exception itself to the
             # payload accessible via :exception_object, so we create a stand-in
@@ -85,6 +86,7 @@ module NewRelic
             def exception_object(payload)
               exception_class, message = payload[:exception]
               return nil unless exception_class
+
               NewRelic::Agent::NoticeableError.new(exception_class, message)
             end
           else

data/lib/new_relic/agent/instrumentation/rack/chain.rb

@@ -21,8 +21,16 @@ module NewRelic::Agent::Instrumentation
           if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
             ::NewRelic::Agent.logger.info("Installing #{builder_class} middleware instrumentation")
 
-            def run_with_newrelic(app, *args)
-              run_with_tracing(app) { |wrapped_app| run_without_newrelic(wrapped_app, *args) }
+            def run_with_newrelic(app = nil, *args, &block)
+              app_or_block = app || block
+              run_with_tracing(app_or_block) do |wrapped|
+                # Rack::Builder#run for Rack v3+ supports a block, and does not
+                # support args. Whether a block or an app is provided, that
+                # callable object will be wrapped into a MiddlewareProxy
+                # instance. That proxy instance must then be passed to
+                # run_without_newrelic as the app argument.
+                block ? run_without_newrelic(wrapped, &nil) : run_without_newrelic(wrapped, *args)
+              end
             end
 
             alias_method(:run_without_newrelic, :run)

data/lib/new_relic/agent/instrumentation/rack/instrumentation.rb

@@ -23,6 +23,7 @@ module NewRelic
 
         def check_for_late_instrumentation(app)
           return if defined?(@checked_for_late_instrumentation) && @checked_for_late_instrumentation
+
           @checked_for_late_instrumentation = true
           if middleware_instrumentation_enabled?
             if ::NewRelic::Agent::Instrumentation::MiddlewareProxy.needs_wrapping?(app)
@@ -49,12 +50,14 @@ module NewRelic
 
         def run_with_tracing(app)
           return yield(app) unless middleware_instrumentation_enabled?
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true))
         end
 
         def use_with_tracing(middleware_class)
           return if middleware_class.nil?
           return yield(middleware_class) unless middleware_instrumentation_enabled?
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class))
         end
       end

data/lib/new_relic/agent/instrumentation/rack/prepend.rb

@@ -23,8 +23,15 @@ module NewRelic::Agent::Instrumentation
         with_deferred_dependency_detection { super }
       end
 
-      def run(app, *args)
-        run_with_tracing(app) { |wrapped_app| super(wrapped_app, *args) }
+      def run(app = nil, *args, &block)
+        app_or_block = app || block
+        run_with_tracing(app_or_block) do |wrapped|
+          # Rack::Builder#run for Rack v3+ supports a block, and does not
+          # support args. Whether a block or an app is provided, that callable
+          # object will be wrapped into a MiddlewareProxy instance. That
+          # proxy instance must then be passed to super as the app argument.
+          block ? super(wrapped, &nil) : super(wrapped, *args)
+        end
       end
 
       def use(middleware_class, *args, &blk)

data/lib/new_relic/agent/instrumentation/rainbows_instrumentation.rb

@@ -22,7 +22,6 @@ DependencyDetection.defer do
       :deprecated_rainbows_dispatcher,
       deprecation_msg
     )
-    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Rainbows", 1)
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rake/instrumentation.rb

@@ -37,6 +37,7 @@ module NewRelic
 
         def safe_from_third_party_gem?
           return true unless NewRelic::LanguageSupport.bundled_gem?("newrelic-rake")
+
           ::NewRelic::Agent.logger.info("Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present")
           false
         end

data/lib/new_relic/agent/instrumentation/redis/chain.rb

@@ -9,16 +9,28 @@ module NewRelic::Agent::Instrumentation
         ::Redis::Client.class_eval do
           include NewRelic::Agent::Instrumentation::Redis
 
-          alias_method(:call_without_new_relic, :call)
+          if method_defined?(:call_v)
+            alias_method(:call_v_without_new_relic, :call_v)
 
-          def call(*args, &block)
-            call_with_tracing(args[0]) { call_without_new_relic(*args, &block) }
+            def call_v(*args, &block)
+              call_with_tracing(args[0]) { call_v_without_new_relic(*args, &block) }
+            end
           end
 
-          alias_method(:call_pipeline_without_new_relic, :call_pipeline)
+          if method_defined?(:call)
+            alias_method(:call_without_new_relic, :call)
 
-          def call_pipeline(*args, &block)
-            call_pipeline_with_tracing(args[0]) { call_pipeline_without_new_relic(*args, &block) }
+            def call(*args, &block)
+              call_with_tracing(args[0]) { call_without_new_relic(*args, &block) }
+            end
+          end
+
+          if method_defined?(:call_pipeline)
+            alias_method(:call_pipeline_without_new_relic, :call_pipeline)
+
+            def call_pipeline(*args, &block)
+              call_pipeline_with_tracing(args[0]) { call_pipeline_without_new_relic(*args, &block) }
+            end
           end
 
           alias_method(:connect_without_new_relic, :connect)

data/lib/new_relic/agent/instrumentation/redis/constants.rb

@@ -0,0 +1,17 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Redis
+  class Constants
+    PRODUCT_NAME = 'Redis'
+    CONNECT = 'connect'
+    UNKNOWN = 'unknown'
+    LOCALHOST = 'localhost'
+    MULTI_OPERATION = 'multi'
+    PIPELINE_OPERATION = 'pipeline'
+    HAS_REDIS_CLIENT = defined?(::Redis) &&
+      Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('5.0.0') &&
+      !!defined?(::RedisClient)
+  end
+end

data/lib/new_relic/agent/instrumentation/redis/instrumentation.rb

@@ -2,42 +2,48 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
+require_relative 'constants'
+
 module NewRelic::Agent::Instrumentation
   module Redis
-    PRODUCT_NAME = 'Redis'
-    CONNECT = 'connect'
-    UNKNOWN = "unknown"
-    LOCALHOST = "localhost"
-    MULTI_OPERATION = 'multi'
-    PIPELINE_OPERATION = 'pipeline'
+    def connect_with_tracing
+      with_tracing(Constants::CONNECT, database: db) { yield }
+    end
 
     def call_with_tracing(command, &block)
       operation = command[0]
       statement = ::NewRelic::Agent::Datastores::Redis.format_command(command)
 
-      with_tracing(operation, statement) { yield }
+      with_tracing(operation, statement: statement, database: db) { yield }
     end
 
+    # Used for Redis 4.x and 3.x
     def call_pipeline_with_tracing(pipeline)
-      operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? MULTI_OPERATION : PIPELINE_OPERATION
+      operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? Constants::MULTI_OPERATION : Constants::PIPELINE_OPERATION
       statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
 
-      with_tracing(operation, statement) { yield }
+      with_tracing(operation, statement: statement, database: db) { yield }
     end
 
-    def connect_with_tracing
-      with_tracing(CONNECT) { yield }
+    # Used for Redis 5.x+
+    def call_pipelined_with_tracing(pipeline)
+      operation = pipeline.flatten.include?('MULTI') ? Constants::MULTI_OPERATION : Constants::PIPELINE_OPERATION
+      statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline)
+
+      # call_pipelined isn't invoked on the client object, so use client.db to
+      # access the client instance var on self
+      with_tracing(operation, statement: statement, database: client.db) { yield }
     end
 
     private
 
-    def with_tracing(operation, statement = nil)
+    def with_tracing(operation, statement: nil, database: nil)
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
-        product: PRODUCT_NAME,
+        product: Constants::PRODUCT_NAME,
         operation: operation,
         host: _nr_hostname,
         port_path_or_id: _nr_port_path_or_id,
-        database_name: db
+        database_name: database
       )
       begin
         segment.notice_nosql_statement(statement) if statement
@@ -48,17 +54,21 @@ module NewRelic::Agent::Instrumentation
     end
 
     def _nr_hostname
-      self.path ? LOCALHOST : self.host
+      _nr_client.path ? Constants::LOCALHOST : _nr_client.host
     rescue => e
       NewRelic::Agent.logger.debug("Failed to retrieve Redis host: #{e}")
-      UNKNOWN
+      Constants::UNKNOWN
     end
 
     def _nr_port_path_or_id
-      self.path || self.port
+      _nr_client.path || _nr_client.port
     rescue => e
       NewRelic::Agent.logger.debug("Failed to retrieve Redis port_path_or_id: #{e}")
-      UNKNOWN
+      Constants::UNKNOWN
+    end
+
+    def _nr_client
+      @nr_client ||= self.is_a?(::Redis::Client) ? self : client
     end
   end
 end

data/lib/new_relic/agent/instrumentation/redis/middleware.rb

@@ -0,0 +1,16 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module RedisClient
+    module Middleware
+      # This module is used to instrument Redis 5.x+
+      include NewRelic::Agent::Instrumentation::Redis
+
+      def call_pipelined(*args, &block)
+        call_pipelined_with_tracing(args[0]) { super }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/redis/prepend.rb

@@ -7,6 +7,12 @@ module NewRelic::Agent::Instrumentation
     module Prepend
       include NewRelic::Agent::Instrumentation::Redis
 
+      # Defined in version 5.x+
+      def call_v(*args, &block)
+        call_with_tracing(args[0]) { super }
+      end
+
+      # Defined in version 4.x, 3.x
       def call(*args, &block)
         call_with_tracing(args[0]) { super }
       end

data/lib/new_relic/agent/instrumentation/redis.rb

@@ -7,7 +7,9 @@ require 'new_relic/agent/datastores/redis'
 
 require_relative 'redis/instrumentation'
 require_relative 'redis/chain'
+require_relative 'redis/constants'
 require_relative 'redis/prepend'
+require_relative 'redis/middleware'
 
 DependencyDetection.defer do
   # Why not :redis? newrelic-redis used that name, so avoid conflicting
@@ -29,6 +31,10 @@ DependencyDetection.defer do
 
   executes do
     NewRelic::Agent.logger.info('Installing Redis Instrumentation')
+    if NewRelic::Agent::Instrumentation::Redis::Constants::HAS_REDIS_CLIENT
+      ::RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::Middleware)
+    end
+
     if use_prepend?
       prepend_instrument ::Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
     else

data/lib/new_relic/agent/instrumentation/sidekiq/client.rb

@@ -0,0 +1,20 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Sidekiq
+  class Client
+    include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+    def call(_worker_class, job, *_)
+      job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+      yield
+    end
+
+    def distributed_tracing_headers
+      headers = {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+      headers
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/extensions/delayed_class.rb

@@ -0,0 +1,30 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# TODO: remove this class once Sidekiq v6 is no longer supported.
+#       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
+#       were removed entirely in Sidekiq 7.
+#
+#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       of the removal, which includes mentions of alternatives
+if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
+  class Sidekiq::Extensions::DelayedClass
+    def newrelic_trace_args(msg, queue)
+      (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
+        YAML.unsafe_load(msg['args'][0])
+      else
+        YAML.load(msg['args'][0])
+      end
+
+      {
+        :name => method_name,
+        :class_name => target.name,
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    rescue => e
+      NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+      NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/server.rb

@@ -0,0 +1,37 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation::Sidekiq
+  class Server
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+    # Client middleware has additional parameters, and our tests use the
+    # middleware client-side to work inline.
+    def call(worker, msg, queue, *_)
+      trace_args = if worker.respond_to?(:newrelic_trace_args)
+        worker.newrelic_trace_args(msg, queue)
+      else
+        self.class.default_trace_args(msg)
+      end
+      trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
+
+      perform_action_with_newrelic_trace(trace_args) do
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
+          NewRelic::Agent::AttributeFilter::DST_NONE)
+
+        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+        yield
+      end
+    end
+
+    def self.default_trace_args(msg)
+      {
+        :name => 'perform',
+        :class_name => msg['class'],
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq.rb

@@ -1,6 +1,9 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
+require_relative 'sidekiq/client'
+require_relative 'sidekiq/server'
+require_relative 'sidekiq/extensions/delayed_class'
 
 DependencyDetection.defer do
   @name = :sidekiq
@@ -14,83 +17,18 @@ DependencyDetection.defer do
   end
 
   executes do
-    module NewRelic::SidekiqInstrumentation
-      class Server
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-        # Client middleware has additional parameters, and our tests use the
-        # middleware client-side to work inline.
-        def call(worker, msg, queue, *_)
-          trace_args = if worker.respond_to?(:newrelic_trace_args)
-            worker.newrelic_trace_args(msg, queue)
-          else
-            self.class.default_trace_args(msg)
-          end
-          trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
-
-          perform_action_with_newrelic_trace(trace_args) do
-            NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-              NewRelic::Agent::AttributeFilter::DST_NONE)
-
-            ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
-            yield
-          end
-        end
-
-        def self.default_trace_args(msg)
-          {
-            :name => 'perform',
-            :class_name => msg['class'],
-            :category => 'OtherTransaction/SidekiqJob'
-          }
-        end
-      end
-
-      class Client
-        def call(_worker_class, job, *_)
-          job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
-          yield
-        end
-
-        def distributed_tracing_headers
-          headers = {}
-          ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
-          headers
-        end
-      end
-    end
-
-    class Sidekiq::Extensions::DelayedClass
-      def newrelic_trace_args(msg, queue)
-        (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
-          YAML.unsafe_load(msg['args'][0])
-        else
-          YAML.load(msg['args'][0])
-        end
-
-        {
-          :name => method_name,
-          :class_name => target.name,
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      rescue => e
-        NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
-        NewRelic::SidekiqInstrumentation::Server.default_trace_args(msg)
-      end
-    end
-
     Sidekiq.configure_client do |config|
       config.client_middleware do |chain|
-        chain.add(NewRelic::SidekiqInstrumentation::Client)
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
     end
 
     Sidekiq.configure_server do |config|
       config.client_middleware do |chain|
-        chain.add(NewRelic::SidekiqInstrumentation::Client)
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
       config.server_middleware do |chain|
-        chain.add(NewRelic::SidekiqInstrumentation::Server)
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
       end
 
       if config.respond_to?(:error_handlers)
@@ -103,6 +41,7 @@ DependencyDetection.defer do
 
   executes do
     next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+
     deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
       'They will stop being monitored in version 9.0.0. ' \
       'Please upgrade your Sidekiq version to continue receiving full support. '
@@ -112,7 +51,5 @@ DependencyDetection.defer do
       :deprecated_sidekiq_version,
       deprecation_msg
     )
-
-    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Sidekiq", 1)
   end
 end

data/lib/new_relic/agent/instrumentation/sinatra.rb

@@ -45,6 +45,7 @@ DependencyDetection.defer do
 
   executes do
     next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
+
     deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
       'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
 
@@ -53,7 +54,5 @@ DependencyDetection.defer do
       :deprecated_sinatra_version,
       deprecation_msg
     )
-
-    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Sinatra", 1)
   end
 end

data/lib/new_relic/agent/instrumentation/sunspot.rb

@@ -19,8 +19,6 @@ DependencyDetection.defer do
       :deprecated_sunspot,
       deprecation_msg
     )
-
-    ::NewRelic::Agent.record_metric("Supportability/Deprecated/Sunspot", 1)
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/thread/instrumentation.rb

@@ -15,6 +15,7 @@ module NewRelic
 
         def add_thread_tracing(*args, &block)
           return block if skip_tracing?
+
           NewRelic::Agent::Tracer.thread_block_with_current_transaction(*args, &block)
         end
 

data/lib/new_relic/agent/instrumentation/tilt/instrumentation.rb

@@ -14,6 +14,7 @@ module NewRelic
         # So here we are only grabbing the file name and name of directory it is in
         def create_filename_for_metric(file)
           return file unless defined?(::Sinatra) && defined?(::Sinatra::Base)
+
           file.split('/')[-2..-1].join('/')
         rescue NoMethodError
           file

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -118,6 +118,7 @@ module NewRelic
 
       def create_nonce(nonce = nil)
         return '' unless nonce
+
         " nonce=\"#{nonce.to_s}\""
       end