newrelic_rpm 8.2.0 → 9.0.0

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

@@ -1,4 +1,3 @@
-# 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
@@ -15,77 +14,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
-    
+
+          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
-    
+
+          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
-    
+
+          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 ) }
+          def http_with_newrelic(verb)
+            http_with_tracing(verb) { http_without_newrelic(verb) }
           end
-    
-          alias_method :http_without_newrelic, :http
-          alias_method :http, :http_with_newrelic
-    
+
+          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
-    
+
+          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) }
+          def method_with_newrelic(verb)
+            method_with_tracing(verb) { method_without_newrelic(verb) }
           end
-    
-          alias_method :method_without_newrelic, :method
-          alias_method :method, :method_with_newrelic
-    
+
+          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
+
+          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 }
+            add_with_tracing(curl) { add_without_newrelic(curl) }
           end
-    
-          alias_method :add_without_newrelic, :add
-          alias_method :add, :add_with_newrelic
-    
+
+          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
-    
+
+          alias_method(:perform_without_newrelic, :perform)
+          alias_method(:perform, :perform_with_newrelic)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# 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
@@ -9,51 +8,49 @@ 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_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
+          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
+          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 +62,8 @@ module NewRelic
               yield
             end
           end
-
         end
-####################################################
+        ####################################################
 
         module Multi
           include NewRelic::Agent::MethodTracer
@@ -77,14 +73,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 +90,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
-    
+
+            segment.add_request_headers(wrapped_request)
+
             # install all callbacks
             unless request._nr_instrumented
               install_header_callback(request, wrapped_response)
@@ -113,8 +109,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 +118,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)
@@ -132,23 +127,23 @@ module NewRelic
             request._nr_header_str = nil
             request.on_header do |header_data|
               if original_callback
-                original_callback.call header_data
+                original_callback.call(header_data)
               else
-                wrapped_response.append_header_data header_data
+                wrapped_response.append_header_data(header_data)
                 header_data.length
               end
             end
           end
-    
+
           # Install a callback that will finish the trace.
           def install_completion_callback(request, wrapped_response, segment)
             original_callback = request.on_complete
             request._nr_original_on_complete = original_callback
             request.on_complete do |finished_request|
               begin
-                segment.process_response_headers wrapped_response
+                segment.process_response_headers(wrapped_response) if segment
               ensure
-                segment.finish if segment
+                ::NewRelic::Agent::Transaction::Segment.finish(segment)
                 # Make sure the existing completion callback is run, and restore the
                 # on_complete callback to how it was before.
                 original_callback.call(finished_request) if original_callback
@@ -156,31 +151,37 @@ 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
           # definitely something to beware of if debugging callback issues
-          # _nr_failure_instrumented exists to prevent infinitely chaining
+          # @__newrelic_original_callback exists to prevent infinitely chaining
           # our on_failure callback hook.
-          def install_failure_callback(request, wrapped_response, segment)
-            return if request._nr_failure_instrumented
+          def install_failure_callback(request, _wrapped_response, segment)
             original_callback = request.on_failure
+
+            nr_original_callback = original_callback.instance_variable_get(:@__newrelic_original_callback)
+            original_callback = nr_original_callback || original_callback
+
             request._nr_original_on_failure = original_callback
-            request.on_failure do |failed_request, error|
+
+            newrelic_callback = proc do |failed_request, error|
               begin
                 if segment
-                  noticible_error = NewRelic::Agent::NoticibleError.new error[0].name, error[-1]
-                  segment.notice_error noticible_error
+                  noticeable_error = NewRelic::Agent::NoticeableError.new(error[0].name, error[-1])
+                  segment.notice_error(noticeable_error)
                 end
               ensure
                 original_callback.call(failed_request, error) if original_callback
                 remove_failure_callback(failed_request)
               end
-              request._nr_failure_instrumented = true 
             end
+            newrelic_callback.instance_variable_set(:@__newrelic_original_callback, original_callback)
+
+            request.on_failure(&newrelic_callback)
           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 +190,19 @@ 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 +211,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

@@ -1,12 +1,11 @@
-# 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_relative 'instrumentation'
 
-module NewRelic 
-  module Agent 
+module NewRelic
+  module Agent
     module Instrumentation
       module Curb
         module Easy
@@ -16,27 +15,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
+
+            def http(verb)
               http_with_tracing(verb) { super }
             end
-      
+
             def perform
               perform_with_tracing { super }
             end
-      
-            def method verb
-              method_with_tracing { super }
+
+            def method(verb)
+              method_with_tracing(verb) { super }
             end
-      
+
             def header_str
               header_str_with_tracing { super }
             end
@@ -46,7 +45,7 @@ module NewRelic
         module Multi
           module Prepend
             include NewRelic::Agent::Instrumentation::Curb::Multi
-      
+
             def add(curl)
               add_with_tracing(curl) { super }
             end
@@ -54,7 +53,6 @@ module NewRelic
             def perform(&blk)
               perform_with_tracing { super }
             end
-      
           end
         end
       end

data/lib/new_relic/agent/instrumentation/curb.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_relative 'curb/chain'
 require_relative 'curb/prepend'
@@ -11,22 +11,22 @@ DependencyDetection.defer do
   CURB_MIN_VERSION = Gem::Version.new("0.8.1")
 
   depends_on do
-    defined?(::Curl) && defined?(::Curl::CURB_VERSION) &&
-      Gem::Version.new(::Curl::CURB_VERSION) >= CURB_MIN_VERSION
+    defined?(Curl) && defined?(Curl::CURB_VERSION) &&
+      Gem::Version.new(Curl::CURB_VERSION) >= CURB_MIN_VERSION
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Curb instrumentation'
+    NewRelic::Agent.logger.info('Installing Curb instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/curb_wrappers'
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Curl::Easy, NewRelic::Agent::Instrumentation::Curb::Easy::Prepend
-      prepend_instrument ::Curl::Multi, NewRelic::Agent::Instrumentation::Curb::Multi::Prepend
+      prepend_instrument Curl::Easy, NewRelic::Agent::Instrumentation::Curb::Easy::Prepend
+      prepend_instrument Curl::Multi, NewRelic::Agent::Instrumentation::Curb::Multi::Prepend
     else
-      chain_instrument ::NewRelic::Agent::Instrumentation::Curb::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::Curb::Chain
     end
   end
 end

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

@@ -0,0 +1,12 @@
+# 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
+
+# This is a helper file that will allow apps using ActiveSupport without Rails
+# to still leverage all ActiveSupport based instrumentation functionality
+# offered by the agent that would otherwise be gated by the detection of Rails.
+
+# ActiveSupport notifications custom events
+if !defined?(Rails) && defined?(ActiveSupport::Notifications) && defined?(ActiveSupport::IsolatedExecutionState)
+  require_relative 'rails_notifications/custom_events'
+end

data/lib/new_relic/agent/instrumentation/custom_events_subscriber.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
+
+require 'new_relic/agent/instrumentation/notifications_subscriber'
+
+# Listen for ActiveSupport::Notifications events for custom events
+module NewRelic::Agent::Instrumentation
+  class CustomEventsSubscriber < NotificationsSubscriber
+    def start(name, id, _payload) # THREAD_LOCAL_ACCESS
+      return unless state.is_execution_traced?
+
+      finishable = NewRelic::Agent::Tracer.start_transaction_or_segment(name: transaction_name(name),
+        category: :custom_events)
+      push_segment(id, finishable)
+    rescue => e
+      log_notification_error(e, name, 'start')
+    end
+
+    def finish(name, id, payload) # THREAD_LOCAL_ACCESS
+      return unless state.is_execution_traced?
+
+      NewRelic::Agent.notice_error(payload[:exception_object]) if payload.key?(:exception_object)
+
+      finishable = pop_segment(id)
+      finishable.finish if finishable
+    rescue => e
+      log_notification_error(e, name, 'finish')
+    end
+
+    private
+
+    def transaction_name(name)
+      "ActiveSupport/CustomEvents/#{name}"
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# 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
@@ -14,25 +13,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
-    
+
+              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

@@ -1,29 +1,26 @@
-# 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 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]'
+            ::NewRelic::Agent.logger.info('Installing DelayedJob instrumentation [part 2/2]')
             install_newrelic_job_tracer
-            NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
+            NewRelic::Control.instance.init_plugin(:dispatcher => :delayed_job)
           else
             NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
           end
@@ -45,9 +42,7 @@ module NewRelic
             yield
           end
         end
-
       end
     end
   end
 end
-

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

@@ -1,4 +1,3 @@
-# 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
@@ -17,7 +16,7 @@ module NewRelic
           end
 
           def install_newrelic_job_tracer
-            Delayed::Job.send :prepend, ::NewRelic::Agent::Instrumentation::DelayedJobTracerPrepend
+            Delayed::Job.send(:prepend, ::NewRelic::Agent::Instrumentation::DelayedJobTracerPrepend)
           end
         end
       end