newrelic_rpm 5.7.0.350 → 9.0.0

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

@@ -1,6 +1,7 @@
-# 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.
+# frozen_string_literal: true
+
 require 'new_relic/agent/datastores/mongo/event_formatter'
 
 module NewRelic
@@ -13,17 +14,43 @@ module NewRelic
         def started(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
-            segments[event.operation_id] = start_segment event
+
+            segments[event.operation_id] = start_segment(event)
           rescue Exception => e
             log_notification_error('started', e)
           end
         end
 
+        ERROR_KEYS = %w[ writeErrors writeConcernError writeConcernErrors ].freeze
+
+        def error_key_present?(event)
+          if reply = event.reply
+            ERROR_KEYS.detect { |key| reply[key] }
+          end
+        rescue
+          false
+        end
+
         def completed(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
+
             segment = segments.delete(event.operation_id)
-            segment.finish if segment
+            return unless segment
+
+            # operations that succeed but have errors return CommandSucceeded
+            # with an error_key that is populated with error specifics
+            if error_key = error_key_present?(event)
+              # taking the last error as there can potentially be many
+              attributes = event.reply[error_key][-1]
+              segment.notice_error(Mongo::Error.new("%s (%s)" % [attributes["errmsg"], attributes["code"]]))
+
+            # failing commands return a CommandFailed event with an error message
+            # in the form of "% (%s)" for the message and code
+            elsif event.is_a?(Mongo::Monitoring::Event::CommandFailed)
+              segment.notice_error(Mongo::Error.new(event.message))
+            end
+            segment.finish
           rescue Exception => e
             log_notification_error('completed', e)
           end
@@ -34,12 +61,12 @@ module NewRelic
 
         private
 
-        def start_segment event
-          host = host_from_address event.address
-          port_path_or_id = port_path_or_id_from_address event.address
+        def start_segment(event)
+          host = host_from_address(event.address)
+          port_path_or_id = port_path_or_id_from_address(event.address)
           segment = NewRelic::Agent::Tracer.start_datastore_segment(
             product: MONGODB,
-            operation: event.command_name,
+            operation: operation(event.command_name),
             collection: collection(event),
             host: host,
             port_path_or_id: port_path_or_id,
@@ -49,6 +76,15 @@ module NewRelic
           segment
         end
 
+        def operation(command_name)
+          # from 2.0 to 2.5, :findandmodify was the command_name
+          if command_name == :findandmodify
+            :findAndModify
+          else
+            command_name
+          end
+        end
+
         def collection(event)
           event.command[COLLECTION] || event.command[:collection] || event.command.values.first
         end
@@ -74,31 +110,31 @@ module NewRelic
         LOCALHOST = "localhost".freeze
 
         def host_from_address(address)
-          if unix_domain_socket? address.host
+          if unix_domain_socket?(address.host)
             LOCALHOST
           else
             address.host
           end
         rescue => e
-          NewRelic::Agent.logger.debug "Failed to retrieve Mongo host: #{e}"
+          NewRelic::Agent.logger.debug("Failed to retrieve Mongo host: #{e}")
           UNKNOWN
         end
 
         def port_path_or_id_from_address(address)
-          if unix_domain_socket? address.host
+          if unix_domain_socket?(address.host)
             address.host
           else
             address.port
           end
         rescue => e
-          NewRelic::Agent.logger.debug "Failed to retrieve Mongo port_path_or_id: #{e}"
+          NewRelic::Agent.logger.debug("Failed to retrieve Mongo port_path_or_id: #{e}")
           UNKNOWN
         end
 
         SLASH = "/".freeze
 
         def unix_domain_socket?(host)
-          host.start_with? SLASH
+          host.start_with?(SLASH)
         end
       end
     end

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

@@ -0,0 +1,24 @@
+# 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 NetHTTP
+    module Chain
+      def self.instrument!
+        Net::HTTP.class_eval do
+          include NewRelic::Agent::Instrumentation::NetHTTP
+
+          def request_with_newrelic_trace(request, *args, &block)
+            request_with_tracing(request) { request_without_newrelic_trace(request, *args, &block) }
+          end
+
+          alias request_without_newrelic_trace request
+          alias request request_with_newrelic_trace
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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 NetHTTP
+        def request_with_tracing(request)
+          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+
+          segment = NewRelic::Agent::Tracer.start_external_request_segment(
+            library: wrapped_request.type,
+            uri: wrapped_request.uri,
+            procedure: wrapped_request.method
+          )
+
+          begin
+            response = nil
+            segment.add_request_headers(wrapped_request)
+
+            # RUBY-1244 Disable further tracing in request to avoid double
+            # counting if connection wasn't started (which calls request again).
+            NewRelic::Agent.disable_all_tracing do
+              response = NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield
+              end
+            end
+
+            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new(response)
+            segment.process_response_headers(wrapped_response)
+            response
+          ensure
+            segment.finish
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# 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 NetHTTP
+        module Prepend
+          include NewRelic::Agent::Instrumentation::NetHTTP
+
+          def request(request, *args, &block)
+            request_with_tracing(request) { super }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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 'net_http/chain'
+require_relative 'net_http/prepend'
+
+DependencyDetection.defer do
+  named :net_http
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Net:HTTP Wrappers')
+    require 'new_relic/agent/http_clients/net_http_wrappers'
+  end
+
+  # Airbrake uses method chaining on Net::HTTP in versions < 10.0.2 (10.0.2 updated to prepend for Net:HTTP)
+  conflicts_with_prepend do
+    defined?(Airbrake) && defined?(Airbrake::AIRBRAKE_VERSION) && Gem::Version.create(Airbrake::AIRBRAKE_VERSION) < Gem::Version.create('10.0.2')
+  end
+
+  conflicts_with_prepend do
+    defined?(ScoutApm)
+  end
+
+  conflicts_with_prepend do
+    defined?(Rack::MiniProfiler) && !defined?(Rack::MINI_PROFILER_PREPEND_NET_HTTP_PATCH)
+  end
+
+  conflicts_with_prepend do
+    source_location_for(Net::HTTP, "request") =~ /airbrake|profiler/i
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument Net::HTTP, NewRelic::Agent::Instrumentation::NetHTTP::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::NetHTTP::Chain
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# 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
+      class NotificationsSubscriber
+        def initialize
+          @queue_key = ['NewRelic', self.class.name, object_id].join('-')
+          define_exception_method
+        end
+
+        def self.subscribed?
+          find_all_subscribers.find { |s| s.instance_variable_get(:@delegate).class == self }
+        end
+
+        def self.find_all_subscribers
+          # TODO: need to talk to Rails core about an API for this,
+          # rather than digging through Listener ivars
+          instance_variable_names = [:@subscribers, :@string_subscribers, :@other_subscribers]
+          all_subscribers = []
+
+          notifier = ActiveSupport::Notifications.notifier
+
+          instance_variable_names.each do |name|
+            if notifier.instance_variable_defined?(name)
+              subscribers = notifier.instance_variable_get(name)
+              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)
+                # 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 }
+              end
+            end
+          end
+
+          all_subscribers
+        end
+
+        def self.subscribe(pattern)
+          if !subscribed?
+            ActiveSupport::Notifications.subscribe(pattern, new)
+          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.
+          NewRelic::Agent.logger.error("Error during #{event_type} callback for event '#{name}':")
+          NewRelic::Agent.logger.log_exception(:error, error)
+        end
+
+        def push_segment(id, segment)
+          segment_stack[id].push(segment)
+        end
+
+        def pop_segment(id)
+          segment = segment_stack[id].pop
+          segment
+        end
+
+        def segment_stack
+          Thread.current[@queue_key] ||= Hash.new { |h, id| h[id] = [] }
+        end
+
+        def state
+          NewRelic::Agent::Tracer.state
+        end
+
+        def define_exception_method
+          # we don't expect this to be called more than once, but we're being
+          # 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
+            # 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::NoticeableError.new(exception_class, message)
+            end
+          else
+            def exception_object(payload)
+              payload[:exception_object]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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 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
+
+              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
+
+                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
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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
+    def invoke_route_with_tracing(*args)
+      begin
+        env["newrelic.last_route"] = args[0].original_path
+      rescue => e
+        ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
+      end
+
+      begin
+        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
+          )
+        end
+      rescue => e
+        ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
+      end
+
+      yield
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/padrino/prepend.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
+  module PadrinoTracer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Sinatra
+      include NewRelic::Agent::Instrumentation::Padrino
+
+      def dispatch
+        dispatch_with_tracing { super }
+      end
+
+      def invoke_route(*args, &block)
+        invoke_route_with_tracing(*args) { super }
+      end
+    end
+  end
+end

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

@@ -1,68 +1,32 @@
-# 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.
-
-require 'new_relic/agent/instrumentation/sinatra'
+# 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,
+# we only need to patch into Padrino's dispatch to get things started.
+#
+# Parts of the Sinatra instrumentation (such as the TransactionNamer) are
+# aware of Padrino as a potential target in areas where both Sinatra and
+# Padrino run through the same code.
+
+require_relative 'sinatra'
+require_relative 'padrino/chain'
+require_relative 'padrino/instrumentation'
+require_relative 'padrino/prepend'
 
 DependencyDetection.defer do
   @name = :padrino
+  configure_with :sinatra
 
-  depends_on do
-    !NewRelic::Agent.config[:disable_sinatra] &&
-      defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods)
-  end
+  depends_on { defined?(Padrino) && defined?(Padrino::Routing::InstanceMethods) }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
-
-    # 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,
-    # we only need to patch into Padrino's dispatch to get things started.
-    #
-    # Parts of the Sinatra instrumentation (such as the TransactionNamer) are
-    # aware of Padrino as a potential target in areas where both Sinatra and
-    # Padrino run through the same code.
-    module ::Padrino::Routing::InstanceMethods
-      include NewRelic::Agent::Instrumentation::Sinatra
-
-      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
-
-        alias invoke_route_without_newrelic invoke_route
-        alias invoke_route invoke_route_with_newrelic
-      end
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Padrino
-        def invoke_route_with_newrelic(*args, &block)
-          begin
-            env["newrelic.last_route"] = args[0].original_path
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
-          end
-
-          begin
-            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)
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
-          end
-
-          invoke_route_without_newrelic(*args, &block)
-        end
-      end
+    NewRelic::Agent.logger.info('Installing Padrino instrumentation')
+    if use_prepend?
+      prepend_instrument Padrino::Application, NewRelic::Agent::Instrumentation::PadrinoTracer::Prepend
+    else
+      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/rpm/blob/master/LICENSE for complete details.
+# 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/rpm/blob/master/LICENSE for complete details.
+# 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