newrelic_rpm 5.5.0.348 → 7.2.0

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

@@ -0,0 +1,93 @@
+# 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::Agent::Instrumentation
+  module Curb
+    module Chain
+      def self.instrument!
+        Curl::Easy.class_eval do
+          include NewRelic::Agent::Instrumentation::Curb::Easy
+
+          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 ) }
+          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 
+          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
+  end
+end

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

@@ -0,0 +1,222 @@
+# 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 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
+    
+          # 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
+            if self._nr_serial
+              self._nr_header_str
+            else
+              # Since we didn't install a header callback for a non-serial request,
+              # just fall back to the original implementation.
+              yield
+            end
+          end
+
+        end
+####################################################
+
+        module Multi
+          include NewRelic::Agent::MethodTracer
+
+          # Add CAT with callbacks if the request is serial
+          def add_with_tracing(curl)
+            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
+          end
+
+          # Instrument the specified +request+ (a Curl::Easy object)
+          # 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)
+              install_completion_callback(request, wrapped_response, segment)
+              install_failure_callback(request, wrapped_response, segment)
+              request._nr_instrumented = true
+            end
+          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
+          # during the life-cycle of external request
+          def wrap_request(request)
+            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)
+            original_callback = request.on_header
+            request._nr_original_on_header = original_callback
+            request._nr_header_str = nil
+            request.on_header do |header_data|
+              if original_callback
+                original_callback.call header_data
+              else
+                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
+              ensure
+                segment.finish if 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
+                remove_instrumentation_callbacks(request)
+              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
+          # our on_failure callback hook.
+          def install_failure_callback(request, wrapped_response, segment)
+            return if request._nr_failure_instrumented
+            original_callback = request.on_failure
+            request._nr_original_on_failure = original_callback
+            request.on_failure do |failed_request, error|
+              begin
+                if segment
+                  noticible_error = NewRelic::Agent::NoticibleError.new error[0].name, error[-1]
+                  segment.notice_error noticible_error
+                end
+              ensure
+                original_callback.call(failed_request, error) if original_callback
+                remove_failure_callback(failed_request)
+              end
+              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!
+          def remove_instrumentation_callbacks(request)
+            request.on_complete(&request._nr_original_on_complete)
+            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 
+          # 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.
+            #
+            # So, requests.first will either be an_obj or [a_key, an_obj].
+            # 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

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

@@ -0,0 +1,63 @@
+# 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 Instrumentation
+      module Curb
+        module Easy
+          module Prepend
+            include NewRelic::Agent::Instrumentation::Curb::Easy
+
+            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
+          end
+        end
+
+        module Multi
+          module Prepend
+            include NewRelic::Agent::Instrumentation::Curb::Multi
+      
+            def add(curl)
+              add_with_tracing(curl) { super }
+            end
+
+            def perform(&blk)
+              perform_with_tracing { super }
+            end
+      
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 DependencyDetection.defer do
   named :data_mapper
@@ -140,7 +140,9 @@ module NewRelic
             )
 
             begin
-              self.send("#{method_name}_without_newrelic", *args, &blk)
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                self.send("#{method_name}_without_newrelic", *args, &blk)
+              end
             rescue ::DataObjects::ConnectionError => e
               raise
             rescue ::DataObjects::SQLError => e
@@ -185,7 +187,7 @@ module NewRelic
         # hooked with tracers, ensuring that notice_sql attaches this SQL to
         # the proper call scope.
         def log(msg) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
+          state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 
           txn = state.current_transaction

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

@@ -0,0 +1,38 @@
+# 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::Agent::Instrumentation
+  module DelayedJob
+    module Chain
+      def self.instrument!
+        Delayed::Worker.class_eval do
+          include NewRelic::Agent::Instrumentation::DelayedJob
+
+          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

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

@@ -0,0 +1,53 @@
+# 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
+          NewRelic::DelayedJobInjection.worker_name = worker_name
+  
+          if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
+            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
+  
+            ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+            install_newrelic_job_tracer
+            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
+        end
+
+      end
+
+      module DelayedJobTracer
+        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+        NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
+
+        def invoke_job_with_tracing
+          options = {
+            :category => NR_TRANSACTION_CATEGORY,
+            :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
+          }
+
+          perform_action_with_newrelic_trace(options) do
+            yield
+          end
+        end
+
+      end
+    end
+  end
+end
+