newrelic_rpm 8.2.0 → 8.3.0

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

@@ -15,77 +15,76 @@ module NewRelic::Agent::Instrumentation
           def http_head_with_newrelic(*args, &blk)
             http_head_with_tracing { http_head_without_newrelic(*args, &blk) }
           end
-    
+
           alias_method :http_head_without_newrelic, :http_head
           alias_method :http_head, :http_head_with_newrelic
-    
+
           def http_post_with_newrelic(*args, &blk)
             http_post_with_tracing { http_post_without_newrelic(*args, &blk) }
           end
-    
+
           alias_method :http_post_without_newrelic, :http_post
           alias_method :http_post, :http_post_with_newrelic
-    
+
           def http_put_with_newrelic(*args, &blk)
             http_put_with_tracing { http_put_without_newrelic(*args, &blk) }
           end
-    
+
           alias_method :http_put_without_newrelic, :http_put
           alias_method :http_put, :http_put_with_newrelic
-    
+
           # Hook the #http method to set the verb.
           def http_with_newrelic verb
-            http_with_tracing(verb) {  http_without_newrelic( verb ) }
+            http_with_tracing(verb) { http_without_newrelic(verb) }
           end
-    
+
           alias_method :http_without_newrelic, :http
           alias_method :http, :http_with_newrelic
-    
+
           # Hook the #perform method to mark the request as non-parallel.
           def perform_with_newrelic
             perform_with_tracing { perform_without_newrelic }
           end
-    
+
           alias_method :perform_without_newrelic, :perform
           alias_method :perform, :perform_with_newrelic
-    
+
           # Record the HTTP verb for future #perform calls
           def method_with_newrelic verb
             method_with_tracing { method_without_newrelic(verb) }
           end
-    
+
           alias_method :method_without_newrelic, :method
           alias_method :method, :method_with_newrelic
-    
+
           # We override this method in order to ensure access to header_str even
           # though we use an on_header callback
           def header_str_with_newrelic
             header_str_with_tracing { header_str_without_newrelic }
           end
-    
+
           alias_method :header_str_without_newrelic, :header_str
           alias_method :header_str, :header_str_with_newrelic
         end
 
-        Curl::Multi.class_eval do 
+        Curl::Multi.class_eval do
           include NewRelic::Agent::Instrumentation::Curb::Multi
-    
+
           # Add CAT with callbacks if the request is serial
           def add_with_newrelic(curl)
             add_with_tracing(curl) { add_without_newrelic curl }
           end
-    
+
           alias_method :add_without_newrelic, :add
           alias_method :add, :add_with_newrelic
-    
+
           # Trace as an External/Multiple call if the first request isn't serial.
           def perform_with_newrelic(&blk)
             perform_with_tracing { perform_without_newrelic(&blk) }
           end
-    
+
           alias_method :perform_without_newrelic, :perform
           alias_method :perform, :perform_with_newrelic
-    
         end
       end
     end

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

@@ -9,51 +9,50 @@ module NewRelic
       module Curb
         module Easy
           attr_accessor :_nr_instrumented,
-                        :_nr_failure_instrumented,
-                        :_nr_http_verb,
-                        :_nr_header_str,
-                        :_nr_original_on_header,
-                        :_nr_original_on_complete,
-                        :_nr_original_on_failure,
-                        :_nr_serial
-    
+            :_nr_failure_instrumented,
+            :_nr_http_verb,
+            :_nr_header_str,
+            :_nr_original_on_header,
+            :_nr_original_on_complete,
+            :_nr_original_on_failure,
+            :_nr_serial
+
           # We have to hook these three methods separately, as they don't use
           # Curl::Easy#http
           def http_head_with_tracing
             self._nr_http_verb = :HEAD
             yield
           end
-    
+
           def http_post_with_tracing
             self._nr_http_verb = :POST
             yield
           end
-    
-    
+
           def http_put_with_tracing
             self._nr_http_verb = :PUT
             yield
           end
-    
+
           # Hook the #http method to set the verb.
           def http_with_tracing verb
             self._nr_http_verb = verb.to_s.upcase
             yield
           end
-    
+
           # Hook the #perform method to mark the request as non-parallel.
           def perform_with_tracing
             self._nr_http_verb ||= :GET
             self._nr_serial = true
             yield
           end
-    
+
           # Record the HTTP verb for future #perform calls
           def method_with_tracing verb
             self._nr_http_verb = verb.upcase
             yield
           end
-    
+
           # We override this method in order to ensure access to header_str even
           # though we use an on_header callback
           def header_str_with_tracing
@@ -65,9 +64,8 @@ module NewRelic
               yield
             end
           end
-
         end
-####################################################
+        ####################################################
 
         module Multi
           include NewRelic::Agent::MethodTracer
@@ -77,14 +75,14 @@ module NewRelic
             if curl.respond_to?(:_nr_serial) && curl._nr_serial
               hook_pending_request(curl) if NewRelic::Agent::Tracer.tracing_enabled?
             end
-    
+
             return yield
           end
 
           # Trace as an External/Multiple call if the first request isn't serial.
           def perform_with_tracing
             return yield if first_request_is_serial?
-    
+
             trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
               yield
             end
@@ -94,15 +92,15 @@ module NewRelic
           # and set up cross-application tracing if it's enabled.
           def hook_pending_request(request)
             wrapped_request, wrapped_response = wrap_request(request)
-    
+
             segment = NewRelic::Agent::Tracer.start_external_request_segment(
               library: wrapped_request.type,
               uri: wrapped_request.uri,
               procedure: wrapped_request.method
             )
-    
+
             segment.add_request_headers wrapped_request
-    
+
             # install all callbacks
             unless request._nr_instrumented
               install_header_callback(request, wrapped_response)
@@ -113,8 +111,7 @@ module NewRelic
           rescue => err
             NewRelic::Agent.logger.error("Untrapped exception", err)
           end
-    
-    
+
           # Create request and response adapter objects for the specified +request+
           # NOTE: Although strange to wrap request and response at once, it works
           # because curb's callback mechanism updates the instantiated wrappers
@@ -123,7 +120,7 @@ module NewRelic
             return NewRelic::Agent::HTTPClients::CurbRequest.new(request),
                     NewRelic::Agent::HTTPClients::CurbResponse.new(request)
           end
-    
+
           # Install a callback that will record the response headers
           # to enable CAT linking
           def install_header_callback(request, wrapped_response)
@@ -139,7 +136,7 @@ module NewRelic
               end
             end
           end
-    
+
           # Install a callback that will finish the trace.
           def install_completion_callback(request, wrapped_response, segment)
             original_callback = request.on_complete
@@ -156,7 +153,7 @@ module NewRelic
               end
             end
           end
-    
+
           # Install a callback that will fire on failures
           # NOTE:  on_failure is not always called, so we're not always
           # unhooking the callback.  No harm/no foul in production, but
@@ -177,10 +174,10 @@ module NewRelic
                 original_callback.call(failed_request, error) if original_callback
                 remove_failure_callback(failed_request)
               end
-              request._nr_failure_instrumented = true 
+              request._nr_failure_instrumented = true
             end
           end
-    
+
           # on_failure callbacks cannot be removed in the on_complete
           # callback where this method is invoked because on_complete
           # fires before the on_failure!
@@ -189,20 +186,20 @@ module NewRelic
             request.on_header(&request._nr_original_on_header)
             request._nr_instrumented = false
           end
-    
-          # We execute customer's on_failure callback (if any) and 
-          # uninstall our hook here since the on_complete callback 
+
+          # We execute customer's on_failure callback (if any) and
+          # uninstall our hook here since the on_complete callback
           # fires before the on_failure callback.
           def remove_failure_callback(request)
             request.on_failure(&request._nr_original_on_failure)
             request._nr_failure_instrumented = false
           end
-    
+
           private
-    
+
           def first_request_is_serial?
             return false unless (first = self.requests.first)
-    
+
             # Before curb 0.9.8, requests was an array of Curl::Easy
             # instances.  Starting with 0.9.8, it's a Hash where the
             # values are Curl::Easy instances.
@@ -211,12 +208,11 @@ module NewRelic
             # We need to handle either case.
             #
             first = first[-1] if first.is_a?(Array)
-    
+
             first.respond_to?(:_nr_serial) && first._nr_serial
           end
-
         end
       end
     end
   end
-end
+end

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

@@ -5,8 +5,8 @@
 
 require_relative 'instrumentation'
 
-module NewRelic 
-  module Agent 
+module NewRelic
+  module Agent
     module Instrumentation
       module Curb
         module Easy
@@ -16,27 +16,27 @@ module NewRelic
             def http_head(*args, &blk)
               http_head_with_tracing { super }
             end
-      
+
             def http_post(*args, &blk)
               http_post_with_tracing { super }
             end
-      
+
             def http_put(*args, &blk)
               http_put_with_tracing { super }
             end
-      
+
             def http verb
               http_with_tracing(verb) { super }
             end
-      
+
             def perform
               perform_with_tracing { super }
             end
-      
+
             def method verb
               method_with_tracing { super }
             end
-      
+
             def header_str
               header_str_with_tracing { super }
             end
@@ -46,7 +46,7 @@ module NewRelic
         module Multi
           module Prepend
             include NewRelic::Agent::Instrumentation::Curb::Multi
-      
+
             def add(curl)
               add_with_tracing(curl) { super }
             end
@@ -54,7 +54,6 @@ module NewRelic
             def perform(&blk)
               perform_with_tracing { super }
             end
-      
           end
         end
       end

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

@@ -100,7 +100,7 @@ module NewRelic
         clazz.class_eval do
           if method_defined?(method_name) || private_method_defined?(method_name)
             define_method("#{method_name}_with_newrelic",
-                          NewRelic::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
+              NewRelic::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
 
             alias_method "#{method_name}_without_newrelic", method_name
             alias_method method_name, "#{method_name}_with_newrelic"
@@ -114,7 +114,7 @@ module NewRelic
       PASSWORD_PARAM = '&password='.freeze
 
       def self.method_body(clazz, method_name, operation_only)
-        use_model_name   = NewRelic::Helper.instance_methods_include?(clazz, :model)
+        use_model_name = NewRelic::Helper.instance_methods_include?(clazz, :model)
         metric_operation = method_name.to_s.gsub(/[!?]/, "")
 
         Proc.new do |*args, &blk|
@@ -152,15 +152,15 @@ module NewRelic
               case strategy
               when :obfuscated
                 adapter_name = if self.respond_to?(:options)
-                    self.options[:adapter]
+                  self.options[:adapter]
+                else
+                  if self.repository.adapter.respond_to?(:options)
+                    self.repository.adapter.options[:adapter]
                   else
-                    if self.repository.adapter.respond_to?(:options)
-                      self.repository.adapter.options[:adapter]
-                    else
-                      # DataMapper < 0.10.0
-                      self.repository.adapter.uri.scheme
-                    end
+                    # DataMapper < 0.10.0
+                    self.repository.adapter.uri.scheme
                   end
+                end
                 statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => adapter_name)
                 obfuscated_sql = NewRelic::Agent::Database.obfuscate_sql(statement)
                 e.instance_variable_set(:@query, obfuscated_sql)
@@ -186,7 +186,7 @@ module NewRelic
         # We rely on the assumption that all possible entry points have been
         # hooked with tracers, ensuring that notice_sql attaches this SQL to
         # the proper call scope.
-        def log(msg) #THREAD_LOCAL_ACCESS
+        def log(msg) # THREAD_LOCAL_ACCESS
           state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 

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

@@ -14,25 +14,23 @@ module NewRelic::Agent::Instrumentation
           def initialize_with_new_relic(*args)
             initialize_with_tracing { initialize_without_new_relic(*args) }
           end
-    
+
           alias initialize_without_new_relic initialize
           alias initialize initialize_with_new_relic
-    
-    
+
           def install_newrelic_job_tracer
             Delayed::Job.class_eval do
               include NewRelic::Agent::Instrumentation::DelayedJobTracer
-    
+
               alias_method :invoke_job_without_new_relic, :invoke_job
-    
+
               def invoke_job(*args, &block)
                 invoke_job_with_tracing { invoke_job_without_new_relic(*args, &block) }
               end
-    
             end
           end
         end
       end
     end
   end
-end
+end

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

@@ -3,23 +3,21 @@
 # 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 DelayedJob
-
         def initialize_with_tracing
           yield
           worker_name = case
                         when self.respond_to?(:name) then self.name
                         when self.class.respond_to?(:default_name) then self.class.default_name
-                        end
+          end
           NewRelic::DelayedJobInjection.worker_name = worker_name
 
           # TODO: Refactor the last line of this condition so that it can be evaluated in both prepend and chain instrumentation
           if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
-            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic))
+              !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic))
 
             ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
             install_newrelic_job_tracer
@@ -45,9 +43,7 @@ module NewRelic
             yield
           end
         end
-
       end
     end
   end
 end
-

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

@@ -14,11 +14,11 @@ module NewRelic
         module Naming
           module_function
 
-          CLASS_METHOD_DELIMITER     = '.'.freeze
-          INSTANCE_METHOD_DELIMITER  = '#'.freeze
+          CLASS_METHOD_DELIMITER = '.'.freeze
+          INSTANCE_METHOD_DELIMITER = '#'.freeze
           LEGACY_DJ_FORMAT_DELIMITER = ';'.freeze
-          LEGACY_DJ_FORMAT_PREFIX    = 'LOAD'.freeze
-          LEGACY_DJ_DEFAULT_CLASS    = '(unknown class)'.freeze
+          LEGACY_DJ_FORMAT_PREFIX = 'LOAD'.freeze
+          LEGACY_DJ_DEFAULT_CLASS = '(unknown class)'.freeze
 
           def name_from_payload(payload_object)
             if payload_object.is_a? ::Delayed::PerformableMethod

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

@@ -11,7 +11,7 @@ module ::Excon
         @stack = stack
       end
 
-      def request_call(datum) #THREAD_LOCAL_ACCESS
+      def request_call(datum) # THREAD_LOCAL_ACCESS
         begin
           # Only instrument this request if we haven't already done so, because
           # we can get request_call multiple times for requests marked as
@@ -45,7 +45,7 @@ module ::Excon
         @stack.error_call(datum)
       end
 
-      def finish_trace(datum) #THREAD_LOCAL_ACCESS
+      def finish_trace(datum) # THREAD_LOCAL_ACCESS
         segment = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
         if segment
           begin

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

@@ -51,4 +51,3 @@ DependencyDetection.defer do
     end
   end
 end
-

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

@@ -14,7 +14,7 @@ module NewRelic::Agent::Instrumentation
               Grape::Instrumentation.capture_transaction env, self
             end
           end
-    
+
           alias_method :call_without_new_relic, :call
           alias_method :call, :call_with_new_relic
         end
@@ -22,4 +22,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -7,7 +7,6 @@ require 'new_relic/agent/parameter_filtering'
 module NewRelic::Agent::Instrumentation
   module Grape
     module Instrumentation
-
       extend self
 
       # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
@@ -37,12 +36,12 @@ module NewRelic::Agent::Instrumentation
         end
       end
 
-      API_ENDPOINT   = 'api.endpoint'.freeze
-      API_VERSION    = 'api.version'.freeze
-      FORMAT_REGEX   = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
-      VERSION_REGEX  = /:version(\/|$)/.freeze
-      MIN_VERSION    = Gem::Version.new("0.2.0")
-      PIPE_STRING    = '|'.freeze
+      API_ENDPOINT = 'api.endpoint'.freeze
+      API_VERSION = 'api.version'.freeze
+      FORMAT_REGEX = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
+      VERSION_REGEX = /:version(\/|$)/.freeze
+      MIN_VERSION = Gem::Version.new("0.2.0")
+      PIPE_STRING = '|'.freeze
 
       def handle_transaction(endpoint, class_name, version)
         return unless endpoint && route = endpoint.route

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

@@ -11,7 +11,7 @@ DependencyDetection.defer do
   # not shipping yet, overloading the name interferes with the plugin.
   named :grape_instrumentation
   configure_with :grape
-  
+
   depends_on do
     defined?(::Grape::VERSION) &&
       Gem::Version.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::Grape::Instrumentation::MIN_VERSION
@@ -37,9 +37,8 @@ DependencyDetection.defer do
     if use_prepend?
       instrumented_class = ::NewRelic::Agent::Instrumentation::Grape::Instrumentation.instrumented_class
       prepend_instrument instrumented_class, ::NewRelic::Agent::Instrumentation::Grape::Prepend
-    else 
+    else
       chain_instrument ::NewRelic::Agent::Instrumentation::Grape::Chain
     end
   end
-
 end

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

@@ -4,7 +4,7 @@
 
 module NewRelic::Agent::Instrumentation
   module HTTPClient
-    module Chain 
+    module Chain
       def self.instrument!
         ::HTTPClient.class_eval do
           include NewRelic::Agent::Instrumentation::HTTPClient::Instrumentation
@@ -14,7 +14,7 @@ module NewRelic::Agent::Instrumentation
               do_get_block_without_newrelic(req, proxy, conn, &block)
             end
           end
-    
+
           alias :do_get_block_without_newrelic :do_get_block
           alias :do_get_block :do_get_block_with_newrelic
         end
@@ -22,4 +22,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -35,4 +35,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -2,7 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
-
 module NewRelic::Agent::Instrumentation
   module HTTPClient
     module Prepend
@@ -14,4 +13,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -12,11 +12,11 @@ module NewRelic::Agent::Instrumentation
           def perform_with_newrelic_trace(request, options)
             with_tracing(request) { perform_without_newrelic_trace(request, options) }
           end
-       
+
           alias perform_without_newrelic_trace perform
           alias perform perform_with_newrelic_trace
         end
       end
     end
   end
-end
+end

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

@@ -6,25 +6,25 @@ module NewRelic::Agent::Instrumentation
   module HTTPrb
     def with_tracing(request)
       wrapped_request = ::NewRelic::Agent::HTTPClients::HTTPRequest.new(request)
-  
+
       begin
         segment = NewRelic::Agent::Tracer.start_external_request_segment(
           library: wrapped_request.type,
           uri: wrapped_request.uri,
           procedure: wrapped_request.method
         )
-  
+
         segment.add_request_headers wrapped_request
-  
+
         response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
-  
+
         wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new response
         segment.process_response_headers wrapped_response
-  
+
         response
       ensure
         segment.finish if segment
       end
     end
   end
-end
+end