newrelic_rpm 7.0.0 → 9.0.0

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
   module Agent
@@ -12,7 +12,7 @@ module NewRelic
         end
 
         def self.subscribed?
-          find_all_subscribers.find{|s| s.instance_variable_get(:@delegate).class == self }
+          find_all_subscribers.find { |s| s.instance_variable_get(:@delegate).class == self }
         end
 
         def self.find_all_subscribers
@@ -26,11 +26,11 @@ module NewRelic
           instance_variable_names.each do |name|
             if notifier.instance_variable_defined?(name)
               subscribers = notifier.instance_variable_get(name)
-              if subscribers.is_a? Array
+              if subscribers.is_a?(Array)
                 # Rails 5 @subscribers, and Rails 6 @other_subscribers is a
                 # plain array of subscriber objects
                 all_subscribers += subscribers
-              elsif subscribers.is_a? Hash
+              elsif subscribers.is_a?(Hash)
                 # Rails 6 @string_subscribers is a Hash mapping the pattern
                 # string of a subscriber to an array of subscriber objects
                 subscribers.values.each { |array| all_subscribers += array }
@@ -47,6 +47,47 @@ module NewRelic
           end
         end
 
+        def start(name, id, payload)
+          return unless state.is_execution_traced?
+
+          start_segment(name, id, payload)
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload)
+          return unless state.is_execution_traced?
+
+          finish_segment(id, payload)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_segment(name, id, payload)
+          segment = Tracer.start_segment(name: metric_name(name, payload))
+          add_segment_params(segment, payload)
+          push_segment(id, segment)
+        end
+
+        def finish_segment(id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+        end
+
+        # for subclasses
+        def add_segment_params(segment, payload)
+          # no op
+        end
+
+        # for subclasses
+        def metric_name(name, payload)
+          "Ruby/#{name}"
+        end
+
         def log_notification_error(error, name, event_type)
           # These are important enough failures that we want the backtraces
           # logged at error level, hence the explicit log_exception call.
@@ -55,7 +96,7 @@ module NewRelic
         end
 
         def push_segment(id, segment)
-          segment_stack[id].push segment
+          segment_stack[id].push(segment)
         end
 
         def pop_segment(id)
@@ -64,7 +105,7 @@ module NewRelic
         end
 
         def segment_stack
-          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+          Thread.current[@queue_key] ||= Hash.new { |h, id| h[id] = [] }
         end
 
         def state
@@ -76,16 +117,18 @@ 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 asssessible via :exception_object, so we create a stand-in
+            # payload accessible via :exception_object, so we create a stand-in
             # error object from the given class name and message.
             # NOTE: no backtrace available this way, but we can notice the error
             # well enough to send the necessary info the UI requires to present it.
             def exception_object(payload)
               exception_class, message = payload[:exception]
               return nil unless exception_class
-              NewRelic::Agent::NoticibleError.new exception_class, message
+
+              NewRelic::Agent::NoticeableError.new(exception_class, message)
             end
           else
             def exception_object(payload)
@@ -94,7 +137,6 @@ module NewRelic
           end
         end
       end
-
     end
   end
 end

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

@@ -1,31 +1,35 @@
-# encoding: utf-8
 # 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 Padrino
-    module Chain
-      def self.instrument!
-        ::Padrino::Routing::InstanceMethods.module_eval do
-          include NewRelic::Agent::Instrumentation::Sinatra
+module NewRelic
+  module Agent
+    module Instrumentation
+      module PadrinoTracer
+        module Chain
+          def self.instrument!
+            ::Padrino::Routing::InstanceMethods.module_eval do
+              include NewRelic::Agent::Instrumentation::Sinatra
 
-          def dispatch_with_newrelic
-            dispatch_with_tracing { dispatch_without_newrelic }
-          end
+              def dispatch_with_newrelic
+                dispatch_with_tracing { dispatch_without_newrelic }
+              end
 
-          alias dispatch_without_newrelic dispatch!
-          alias dispatch! dispatch_with_newrelic
+              alias dispatch_without_newrelic dispatch!
+              alias dispatch! dispatch_with_newrelic
 
-          # Padrino 0.13 mustermann routing
-          if private_method_defined?(:invoke_route)
-            include NewRelic::Agent::Instrumentation::Padrino
+              # Padrino 0.13 mustermann routing
+              if private_method_defined?(:invoke_route)
+                include NewRelic::Agent::Instrumentation::Padrino
 
-            def invoke_route_with_newrelic(*args, &block)
-              invoke_route_with_tracing(*args) { invoke_route_without_newrelic(*args, &block) }
-            end
+                def invoke_route_with_newrelic(*args, &block)
+                  invoke_route_with_tracing(*args) { invoke_route_without_newrelic(*args, &block) }
+                end
 
-            alias invoke_route_without_newrelic invoke_route
-            alias invoke_route invoke_route_with_newrelic
+                alias invoke_route_without_newrelic invoke_route
+                alias invoke_route invoke_route_with_newrelic
+              end
+            end
           end
         end
       end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 Padrino
@@ -15,7 +15,8 @@ module NewRelic::Agent::Instrumentation
         txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
         unless txn_name.nil?
           ::NewRelic::Agent::Transaction.set_default_transaction_name(
-            "#{self.class.name}/#{txn_name}", :sinatra)
+            "#{self.class.name}/#{txn_name}", :sinatra
+          )
         end
       rescue => e
         ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
@@ -24,4 +25,4 @@ module NewRelic::Agent::Instrumentation
       yield
     end
   end
-end
+end

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

@@ -1,9 +1,9 @@
-# encoding: utf-8
 # 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 Padrino
+  module PadrinoTracer
     module Prepend
       include NewRelic::Agent::Instrumentation::Sinatra
       include NewRelic::Agent::Instrumentation::Padrino
@@ -17,4 +17,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
 
 # Our Padrino instrumentation relies heavily on the fact that Padrino is
 # built on Sinatra. Although it wires up a lot of its own routing logic,
@@ -19,17 +19,14 @@ DependencyDetection.defer do
   @name = :padrino
   configure_with :sinatra
 
-  depends_on { defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods) }
+  depends_on { defined?(Padrino) && defined?(Padrino::Routing::InstanceMethods) }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
+    NewRelic::Agent.logger.info('Installing Padrino instrumentation')
     if use_prepend?
-      prepend_instrument ::Padrino::Routing::InstanceMethods, NewRelic::Agent::Instrumentation::Padrino::Prepend
+      prepend_instrument Padrino::Application, NewRelic::Agent::Instrumentation::PadrinoTracer::Prepend
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Padrino::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::PadrinoTracer::Chain
     end
   end
 end
-
-
-

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

@@ -1,23 +1,23 @@
-# encoding: utf-8
 # 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
 
 DependencyDetection.defer do
   @name = :passenger
 
   depends_on do
-    defined?(::PhusionPassenger)
+    defined?(PhusionPassenger)
   end
 
   executes do
-    ::NewRelic::Agent.logger.debug "Installing Passenger event hooks."
+    NewRelic::Agent.logger.debug("Installing Passenger event hooks.")
 
-    ::PhusionPassenger.on_event(:stopping_worker_process) do
-      ::NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
+    PhusionPassenger.on_event(:stopping_worker_process) do
+      NewRelic::Agent.logger.debug("Passenger stopping this process, shutdown the agent.")
       NewRelic::Agent.instance.shutdown
     end
 
-    ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
       # We want to reset the stats from the stats engine in case any carried
       # over into the spawned process.  Don't clear them in case any were
       # cached.  We do this even in conservative spawning.

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
   module Agent
@@ -9,13 +9,12 @@ module NewRelic
       # Record queue time metrics based on any of three headers
       # which can be set on the request.
       module QueueTime
-        REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'.freeze
-        QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'.freeze
+        REQUEST_START_HEADER = 'HTTP_X_REQUEST_START'.freeze
+        QUEUE_START_HEADER = 'HTTP_X_QUEUE_START'.freeze
         MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'.freeze
-        ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
         # any timestamps before this are thrown out and the parser
         # will try again with a larger unit (2000/1/1 UTC)
-        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800)
+        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800).to_f
 
         CANDIDATE_HEADERS = [
           REQUEST_START_HEADER,
@@ -27,7 +26,7 @@ module NewRelic
 
         module_function
 
-        def parse_frontend_timestamp(headers, now=Time.now)
+        def parse_frontend_timestamp(headers, now = Process.clock_gettime(Process::CLOCK_REALTIME))
           earliest = nil
 
           CANDIDATE_HEADERS.each do |header|
@@ -40,7 +39,7 @@ module NewRelic
           end
 
           if earliest && earliest > now
-            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
+            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now}")
             earliest = now
           end
 
@@ -52,14 +51,14 @@ module NewRelic
           when /^\s*([\d+\.]+)\s*$/ then $1
           # following regexp intentionally unanchored to handle
           # (ie ignore) leading server names
-          when /t=([\d+\.]+)/       then $1
+          when /t=([\d+\.]+)/ then $1
           end
         end
 
         def parse_timestamp(string)
           DIVISORS.each do |divisor|
             begin
-              t = Time.at(string.to_f / divisor)
+              t = (string.to_f / divisor)
               return t if t > EARLIEST_ACCEPTABLE_TIME
             rescue RangeError
               # On Ruby versions built with a 32-bit time_t, attempting to

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

@@ -1,39 +1,48 @@
-# encoding: utf-8
 # 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 Rack
     module Chain
-      def self.instrument! builder_class
-        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection builder_class
+      def self.instrument!(builder_class)
+        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection(builder_class)
 
         builder_class.class_eval do
           include ::NewRelic::Agent::Instrumentation::RackBuilder
-  
+
           def to_app_with_newrelic_deferred_dependency_detection
             with_deferred_dependency_detection { to_app_without_newrelic }
           end
 
-          alias_method :to_app_without_newrelic, :to_app
-          alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
-  
+          alias_method(:to_app_without_newrelic, :to_app)
+          alias_method(:to_app, :to_app_with_newrelic_deferred_dependency_detection)
+
           if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-            ::NewRelic::Agent.logger.info "Installing #{builder_class} middleware instrumentation"
+            ::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
-            alias_method :run, :run_with_newrelic
-  
+
+            alias_method(:run_without_newrelic, :run)
+            alias_method(:run, :run_with_newrelic)
+
             def use_with_newrelic(middleware_class, *args, &block)
               use_with_tracing(middleware_class) { |wrapped_class| use_without_newrelic(wrapped_class, *args, &block) }
             end
-    
-            alias_method :use_without_newrelic, :use
-            alias_method :use, :use_with_newrelic
+            ruby2_keywords(:use_with_newrelic) if respond_to?(:ruby2_keywords, true)
+
+            alias_method(:use_without_newrelic, :use)
+            alias_method(:use, :use_with_newrelic)
           end
         end
       end
@@ -41,10 +50,10 @@ module NewRelic::Agent::Instrumentation
 
     module URLMap
       module Chain
-        def self.instrument! url_map_class
+        def self.instrument!(url_map_class)
           url_map_class.class_eval do
-            alias_method :initialize_without_newrelic, :initialize
-    
+            alias_method(:initialize_without_newrelic, :initialize)
+
             def initialize(map = {})
               traced_map = ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
               initialize_without_newrelic(traced_map)
@@ -54,4 +63,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 RackHelpers
@@ -20,6 +20,8 @@ module NewRelic::Agent::Instrumentation
       return false unless defined? ::Puma::Const::PUMA_VERSION
 
       version = Gem::Version.new(::Puma::Const::PUMA_VERSION)
+      # TODO: MAJOR VERSION - update min_version to 3.9.0
+      # min_version = Gem::Version.new('3.9.0')
       min_version = Gem::Version.new('2.12.0')
       version >= min_version
     end
@@ -29,4 +31,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -1,13 +1,12 @@
-# encoding: utf-8
 # 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
   module Agent
     module Instrumentation
       module RackBuilder
-
-        def self.track_deferred_detection builder_class
+        def self.track_deferred_detection(builder_class)
           class << builder_class
             attr_accessor :_nr_deferred_detection_ran
           end
@@ -16,19 +15,20 @@ module NewRelic
 
         def deferred_dependency_check
           return if self.class._nr_deferred_detection_ran
-  
-          NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
+
+          NewRelic::Agent.logger.info("Doing deferred dependency-detection before Rack startup")
           DependencyDetection.detect!
           self.class._nr_deferred_detection_ran = true
         end
 
         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)
               ::NewRelic::Agent.logger.info("We weren't able to instrument all of your Rack middlewares.",
-                                            "To correct this, ensure you 'require \"newrelic_rpm\"' before setting up your middleware stack.")
+                "To correct this, ensure you 'require \"newrelic_rpm\"' before setting up your middleware stack.")
             end
           end
         end
@@ -41,22 +41,24 @@ module NewRelic
         # this point.
         def with_deferred_dependency_detection
           deferred_dependency_check
-          yield.tap{ |result| check_for_late_instrumentation(result) }
+          yield.tap { |result| check_for_late_instrumentation(result) }
         end
 
         def middleware_instrumentation_enabled?
           ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
         end
 
-        def run_with_tracing app
+        def run_with_tracing(app)
           return yield(app) unless middleware_instrumentation_enabled?
-          yield ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+
+          yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true))
         end
 
-        def use_with_tracing middleware_class
+        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)
+
+          yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class))
         end
       end
 
@@ -70,4 +72,4 @@ module NewRelic
       end
     end
   end
-end
+end

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

@@ -1,14 +1,13 @@
-# encoding: utf-8
 # 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 Rack
-    
     module URLMap
       module Prepend
         def initialize(map = {})
-          super ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
+          super(::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map))
         end
       end
     end
@@ -16,21 +15,29 @@ module NewRelic::Agent::Instrumentation
     module Prepend
       include ::NewRelic::Agent::Instrumentation::RackBuilder
 
-      def self.prepended builder_class
-        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection builder_class
+      def self.prepended(builder_class)
+        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection(builder_class)
       end
 
       def to_app
         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)
         use_with_tracing(middleware_class) { |wrapped_class| super(wrapped_class, *args, &blk) }
       end
+      ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -13,14 +13,14 @@ DependencyDetection.defer do
   named :rack
 
   depends_on do
-    defined?(::Rack) && defined?(::Rack::Builder)
+    defined?(Rack) && defined?(Rack::Builder)
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
+      prepend_instrument Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
     else
-      chain_instrument_target ::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
+      chain_instrument_target Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
     end
   end
 end
@@ -29,14 +29,14 @@ DependencyDetection.defer do
   named :puma_rack
 
   depends_on do
-    defined?(::Puma::Rack::Builder)
+    defined?(Puma::Rack::Builder)
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
+      prepend_instrument Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
     else
-      chain_instrument_target ::Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
+      chain_instrument_target Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
     end
   end
 end
@@ -45,19 +45,19 @@ DependencyDetection.defer do
   named :rack_urlmap
 
   depends_on do
-    defined?(::Rack) && defined?(::Rack::URLMap)
+    defined?(Rack) && defined?(Rack::URLMap)
   end
 
   depends_on do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+    NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
+      prepend_instrument Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
     else
-      chain_instrument_target ::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
-      ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map 
+      chain_instrument_target Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
+      NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map
     end
   end
 end
@@ -70,14 +70,14 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+    NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
+      prepend_instrument Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
     else
-      chain_instrument_target ::Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
+      chain_instrument_target Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
     end
   end
 end