newrelic_rpm 7.0.0 → 9.0.0

data/lib/new_relic/agent/http_clients/abstract.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,7 +14,6 @@ module NewRelic
       #
       # @api public
       class AbstractRequest
-
         def []
           raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
         end
@@ -41,15 +39,15 @@ module NewRelic
         end
       end
 
-      # This class implements the adaptor pattern and is used internally provide 
+      # This class implements the adaptor pattern and is used internally provide
       # uniform access to the underlying HTTP Client's response object
       # NOTE: response_object should be non-nil!
       class AbstractResponse # :nodoc:
-
-        def initialize wrapped_response
-          if wrapped_response.nil? 
+        def initialize(wrapped_response)
+          if wrapped_response.nil?
             raise ArgumentError, WHINY_NIL_ERROR % self.class
           end
+
           @wrapped_response = wrapped_response
         end
 
@@ -57,24 +55,25 @@ module NewRelic
           !!status_code
         end
 
-        # most HTTP client libraries report the HTTP status code as an integer, so 
+        # most HTTP client libraries report the HTTP status code as an integer, so
         # we expect status_code to be set only if a non-zero value is present
         def status_code
           @status_code ||= get_status_code
         end
 
-        private 
+        private
 
-        def get_status_code_using method_name
+        def get_status_code_using(method_name)
           return unless @wrapped_response.respond_to?(method_name)
+
           code = @wrapped_response.send(method_name).to_i
           code == 0 ? nil : code
         end
 
-        # Override this method to memoize a non-zero Integer representation 
+        # Override this method to memoize a non-zero Integer representation
         # of HTTP status code from the response object
         def get_status_code
-          get_status_code_using :code
+          get_status_code_using(:code)
         end
       end
     end

data/lib/new_relic/agent/http_clients/curb_wrappers.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
@@ -8,13 +7,12 @@ require_relative 'abstract'
 module NewRelic
   module Agent
     module HTTPClients
-
       class CurbRequest
         CURB = 'Curb'
         LHOST = 'host'
         UHOST = 'Host'
 
-        def initialize curlobj
+        def initialize(curlobj)
           @curlobj = curlobj
         end
 
@@ -34,7 +32,7 @@ module NewRelic
           @curlobj._nr_http_verb
         end
 
-        def []( key )
+        def [](key)
           @curlobj.headers[key]
         end
 
@@ -48,9 +46,8 @@ module NewRelic
       end
 
       class CurbResponse < AbstractResponse
-
-        def initialize wrapped_response
-          super wrapped_response
+        def initialize(wrapped_response)
+          super(wrapped_response)
           @headers = {}
         end
 
@@ -62,7 +59,7 @@ module NewRelic
           @headers.dup
         end
 
-        def append_header_data data
+        def append_header_data(data)
           key, value = data.split(/:\s*/, 2)
           @headers[key.downcase] = value
           @wrapped_response._nr_header_str ||= String.new
@@ -72,11 +69,9 @@ module NewRelic
         private
 
         def get_status_code
-          get_status_code_using :response_code
+          get_status_code_using(:response_code)
         end
       end
-
     end
-
   end
 end

data/lib/new_relic/agent/http_clients/excon_wrappers.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,8 +8,8 @@ module NewRelic
   module Agent
     module HTTPClients
       class ExconHTTPResponse < AbstractResponse
-        def initialize wrapped_response
-          super wrapped_response
+        def initialize(wrapped_response)
+          super(wrapped_response)
 
           # Since HTTP headers are case-insensitive, we normalize all of them to
           # upper case here, and then also in our [](key) implementation.
@@ -30,9 +29,9 @@ module NewRelic
 
         private
 
-        def get_attribute name
-          if @wrapped_response.respond_to?(name) 
-            @wrapped_response.send(name) 
+        def get_attribute(name)
+          if @wrapped_response.respond_to?(name)
+            @wrapped_response.send(name)
           else
             @wrapped_response[name]
           end
@@ -57,8 +56,8 @@ module NewRelic
 
           @method = @datum[:method].to_s.upcase
           @scheme = @datum[:scheme]
-          @port   = @datum[:port]
-          @path   = @datum[:path]
+          @port = @datum[:port]
+          @path = @datum[:path]
         end
 
         def type
@@ -87,7 +86,7 @@ module NewRelic
 
         def uri
           url = "#{@scheme}://#{host}:#{@port}#{@path}"
-          URIUtil.parse_and_normalize_url url
+          URIUtil.parse_and_normalize_url(url)
         end
       end
     end

data/lib/new_relic/agent/http_clients/http_rb_wrappers.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
@@ -10,7 +9,7 @@ module NewRelic
     module HTTPClients
       class HTTPResponse < AbstractResponse
         def [](key)
-          _, value = @wrapped_response.headers.find{ |k, _| key.downcase == k.downcase }
+          _, value = @wrapped_response.headers.find { |k, _| key.casecmp(k) == 0 }
           value unless value.nil?
         end
 
@@ -21,10 +20,10 @@ module NewRelic
 
       class HTTPRequest < AbstractRequest
         HTTP_RB = 'http.rb'
-        HOST    = 'host'
-        COLON   = ':'
+        HOST = 'host'
+        COLON = ':'
 
-        def initialize wrapped_request
+        def initialize(wrapped_request)
           @wrapped_request = wrapped_request
         end
 

data/lib/new_relic/agent/http_clients/httpclient_wrappers.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,10 +8,9 @@ module NewRelic
   module Agent
     module HTTPClients
       class HTTPClientResponse < AbstractResponse
-
         def [](key)
-          @wrapped_response.headers.each do |k,v|
-            if key.downcase == k.downcase
+          @wrapped_response.headers.each do |k, v|
+            if key.casecmp(k) == 0
               return v
             end
           end

data/lib/new_relic/agent/http_clients/net_http_wrappers.rb

@@ -1,15 +1,14 @@
-# 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 'abstract'
+require 'resolv'
 
 module NewRelic
   module Agent
     module HTTPClients
       class NetHTTPResponse < AbstractResponse
-
         def [](key)
           @wrapped_response[key]
         end
@@ -61,10 +60,15 @@ module NewRelic
           when /^https?:\/\//
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(@request.path)
           else
+            connection_address = @connection.address
+            if connection_address =~ Resolv::IPv6::Regex
+              connection_address = "[#{connection_address}]"
+            end
+
             scheme = @connection.use_ssl? ? 'https' : 'http'
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(
-              "#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}"
-              )
+              "#{scheme}://#{connection_address}:#{@connection.port}#{@request.path}"
+            )
           end
         end
       end

data/lib/new_relic/agent/http_clients/typhoeus_wrappers.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,20 +8,19 @@ module NewRelic
   module Agent
     module HTTPClients
       class TyphoeusHTTPResponse < AbstractResponse
-
         def [](key)
           unless headers.nil?
             result = headers[key]
 
             # Typhoeus 0.5.3 has a bug where asking the headers hash for a
-            # non-existent header will return the hash itself, not what we want.
+            # nonexistent header will return the hash itself, not what we want.
             result == headers ? nil : result
           end
         end
 
         def to_hash
           hash = {}
-          headers.each do |(k,v)|
+          headers.each do |(k, v)|
             hash[k] = v
           end
           hash
@@ -41,7 +39,7 @@ module NewRelic
           @uri = case request.url
             when ::URI then request.url
             else NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(request.url)
-            end
+          end
         end
 
         TYPHOEUS = "Typhoeus".freeze
@@ -69,6 +67,7 @@ module NewRelic
 
         def [](key)
           return nil unless @request.options && @request.options[:headers]
+
           @request.options[:headers][key]
         end
 

data/lib/new_relic/agent/http_clients/uri_util.rb

@@ -1,5 +1,4 @@
 # -*- ruby -*-
-# 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,7 +13,6 @@ module NewRelic
   module Agent
     module HTTPClients
       module URIUtil
-
         def self.obfuscated_uri(url)
           parse_and_normalize_url(url).tap do |obfuscated|
             obfuscated.user = nil
@@ -45,7 +43,7 @@ module NewRelic
         QUESTION_MARK = "?"
 
         def self.strip_query_string(fragment)
-          if fragment.include? QUESTION_MARK
+          if fragment.include?(QUESTION_MARK)
             fragment.split(QUESTION_MARK).first
           else
             fragment

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

@@ -1,18 +1,16 @@
-# 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/notifications_subscriber'
 
 module NewRelic
   module Agent
     module Instrumentation
       class ActionCableSubscriber < NotificationsSubscriber
-
         PERFORM_ACTION = 'perform_action.action_cable'.freeze
 
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          return unless state.is_execution_traced?
-
+        def start_segment(name, id, payload) # THREAD_LOCAL_ACCESS
           finishable = if name == PERFORM_ACTION
             Tracer.start_transaction_or_segment(
               name: transaction_name_from_payload(payload),
@@ -22,21 +20,6 @@ module NewRelic
             Tracer.start_segment(name: metric_name_from_payload(name, payload))
           end
           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?
-
-          if exception = exception_object(payload)
-            NewRelic::Agent.notice_error exception
-          end
-
-          finishable = pop_segment(id)
-          finishable.finish if finishable
-        rescue => e
-          log_notification_error e, name, 'finish'
         end
 
         private
@@ -46,13 +29,17 @@ module NewRelic
         end
 
         def metric_name_from_payload(name, payload)
-          "Ruby/ActionCable/#{payload[:channel_class]}/#{action_name(name)}"
+          "Ruby/ActionCable/#{metric_name(payload)}/#{action_name(name)}"
+        end
+
+        def metric_name(payload)
+          payload[:broadcasting] || payload[:channel_class]
         end
 
         DOT_ACTION_CABLE = '.action_cable'.freeze
 
         def action_name(name)
-          name.gsub DOT_ACTION_CABLE, NewRelic::EMPTY_STR
+          name.gsub(DOT_ACTION_CABLE, NewRelic::EMPTY_STR)
         end
       end
     end

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

@@ -0,0 +1,39 @@
+# 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'
+require 'new_relic/agent/instrumentation/ignore_actions'
+require 'new_relic/agent/parameter_filtering'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionControllerOtherSubscriber < NotificationsSubscriber
+        def add_segment_params(segment, payload)
+          segment.params[:filter] = payload[:filter] if payload[:filter]
+          segment.params[:keys] = payload[:keys] if payload[:keys]
+          segment.params[:original_path] = payload[:request].original_fullpath if payload[:request]
+
+          if payload[:context]
+            segment.params[:action] = payload[:context][:action]
+            segment.params[:controller] = payload[:context][:controller]
+          end
+        end
+
+        def metric_name(name, payload)
+          controller_name = controller_name_for_metric(payload)
+          "Ruby/ActionController#{"/#{controller_name}" if controller_name}/#{name.gsub(/\.action_controller/, '')}"
+        end
+
+        def controller_name_for_metric(payload)
+          # redirect_to
+          return payload[:request].controller_class.controller_path if payload[:request] && payload[:request].controller_class
+
+          # unpermitted_parameters
+          ::NewRelic::LanguageSupport.constantize(payload[:context][:controller]).controller_path if payload[:context] && payload[:context][:controller]
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
-# 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/notifications_subscriber'
 require 'new_relic/agent/instrumentation/ignore_actions'
 require 'new_relic/agent/parameter_filtering'
@@ -9,15 +10,11 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionControllerSubscriber < NotificationsSubscriber
-
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          # @req is a historically stable but not guaranteed Rails header property
-          request = payload[:headers].instance_variable_get(:@req)
-
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           controller_class = controller_class(payload)
 
           if state.is_execution_traced? && !should_ignore(payload, controller_class)
-            finishable = start_transaction_or_segment(payload, request, controller_class)
+            finishable = start_transaction_or_segment(payload, request_for_payload(payload), controller_class)
             push_segment(id, finishable)
           else
             # if this transaction is ignored, make sure child
@@ -29,7 +26,7 @@ module NewRelic
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) # THREAD_LOCAL_ACCESS
           finishable = pop_segment(id)
 
           if state.is_execution_traced? \
@@ -49,31 +46,34 @@ module NewRelic
 
         def start_transaction_or_segment(payload, request, controller_class)
           Tracer.start_transaction_or_segment(
-            name:      format_metric_name(payload[:action], controller_class),
-            category:  :controller,
-            options:   {
-              request:          request,
-              filtered_params:  NewRelic::Agent::ParameterFiltering.filter_using_rails(
-                payload[:params],
-                Rails.application.config.filter_parameters
-              ),
-              apdex_start_time: queue_start(request),
-              ignore_apdex:     NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-                ControllerInstrumentation::NR_IGNORE_APDEX_KEY,
-                controller_class,
-                payload[:action]
-              ),
-              ignore_enduser:   NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-                ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
-                controller_class,
-                payload[:action]
-              )
-            }
+            name: format_metric_name(payload[:action], controller_class),
+            category: :controller,
+            options: tracer_options(payload, request, controller_class)
           )
         end
 
-        def format_metric_name(metric_action, controller_name)
-          controller_class = ::NewRelic::LanguageSupport.constantize(controller_name)
+        def tracer_options(payload, request, controller_class)
+          {
+            request: request,
+            filtered_params: filtered_params(payload[:params]),
+            apdex_start_time: queue_start(request),
+            ignore_apdex: ignore?(payload[:action], ControllerInstrumentation::NR_IGNORE_APDEX_KEY, controller_class),
+            ignore_enduser: ignore?(payload[:action],
+              ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
+              controller_class)
+          }.merge(NewRelic::Agent::MethodTracerHelpers.code_information(controller_class, payload[:action]))
+        end
+
+        def filtered_params(params)
+          NewRelic::Agent::ParameterFiltering.filter_using_rails(params, Rails.application.config.filter_parameters)
+        end
+
+        def ignore?(action, key, controller_class)
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(key, controller_class, action)
+        end
+
+        def format_metric_name(metric_action, controller)
+          controller_class = controller.is_a?(Class) ? controller : Object.const_get(controller)
           "Controller/#{controller_class.controller_path}/#{metric_action}"
         end
 
@@ -91,9 +91,16 @@ module NewRelic
 
         def queue_start(request)
           if request && request.respond_to?(:env)
-            QueueTime.parse_frontend_timestamp(request.env, Time.now)
+            QueueTime.parse_frontend_timestamp(request.env, Process.clock_gettime(Process::CLOCK_REALTIME))
           end
         end
+
+        def request_for_payload(payload)
+          # @req is a historically stable but not guaranteed Rails header property
+          return unless payload[:headers].instance_variables.include?(:@req)
+
+          payload[:headers].instance_variable_get(:@req)
+        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+# 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/action_dispatch_subscriber'
+
+DependencyDetection.defer do
+  named :action_dispatch
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_dispatch]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionDispatch) &&
+      defined?(ActionPack) &&
+      ActionPack.respond_to?(:gem_version) &&
+      ActionPack.gem_version >= Gem::Version.new('6.0.0') && # notifications for dispatch added in Rails 6
+      !NewRelic::Agent::Instrumentation::ActionDispatchSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionDispatch instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A[^\.]+\.action_dispatch\z/,
+      NewRelic::Agent::Instrumentation::ActionDispatchSubscriber.new)
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionDispatchSubscriber < NotificationsSubscriber
+        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))
+          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
+
+        def metric_name(name, payload)
+          middleware = payload[:middleware]
+          method = method_from_name(name)
+          "Ruby/ActionDispatch/#{middleware}/#{method}"
+        end
+
+        PATTERN = /\A([^\.]+)\.action_dispatch\z/
+        UNKNOWN = 'unknown'.freeze
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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/action_mailbox_subscriber'
+
+DependencyDetection.defer do
+  named :action_mailbox
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_mailbox]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionMailbox) &&
+      ActionMailbox.respond_to?(:gem_version) && # 'require "action_mailbox"' doesn't require version...
+      ActionMailbox.gem_version >= Gem::Version.new('7.1.0.alpha') && # notifications added in Rails 7.1
+      !NewRelic::Agent::Instrumentation::ActionMailboxSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionMailbox instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A[^\.]+\.action_mailbox\z/,
+      NewRelic::Agent::Instrumentation::ActionMailboxSubscriber.new)
+  end
+end