newrelic_rpm 6.8.0.360 → 8.13.1

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

@@ -1,22 +1,16 @@
-# 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/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
-      class HTTPClientResponse
-        attr_reader :response
-
-        def initialize(response)
-          @response = response
-        end
-
+      class HTTPClientResponse < AbstractResponse
         def [](key)
-          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
@@ -24,12 +18,12 @@ module NewRelic
         end
 
         def to_hash
-          response.headers
+          @wrapped_response.headers
         end
       end
 
       class HTTPClientRequest < AbstractRequest
-        attr_reader :request, :uri
+        attr_reader :request
 
         HTTP_CLIENT = "HTTPClient".freeze
         LHOST = 'host'.freeze
@@ -38,7 +32,6 @@ module NewRelic
 
         def initialize(request)
           @request = request
-          @uri = request.header.request_uri
         end
 
         def type
@@ -59,6 +52,10 @@ module NewRelic
           host_from_header || uri.host.to_s
         end
 
+        def uri
+          @uri ||= URIUtil.parse_and_normalize_url(request.header.request_uri)
+        end
+
         def [](key)
           request.headers[key]
         end

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

@@ -1,26 +1,37 @@
-# 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/http_clients/abstract_request'
+require_relative 'abstract'
+require 'resolv'
 
 module NewRelic
   module Agent
     module HTTPClients
+      class NetHTTPResponse < AbstractResponse
+        def [](key)
+          @wrapped_response[key]
+        end
+
+        def to_hash
+          @wrapped_response.to_hash
+        end
+      end
+
       class NetHTTPRequest < AbstractRequest
         def initialize(connection, request)
           @connection = connection
           @request = request
         end
 
-        NET_HTTP = 'Net::HTTP'.freeze
+        NET_HTTP = 'Net::HTTP'
 
         def type
           NET_HTTP
         end
 
-        HOST = 'host'.freeze
-        COLON = ':'.freeze
+        HOST = 'host'
+        COLON = ':'
 
         def host_from_header
           if hostname = self[HOST]
@@ -49,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,30 +1,26 @@
-# 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/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
-      class TyphoeusHTTPResponse
-        def initialize(response)
-          @response = response
-        end
-
+      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
@@ -33,7 +29,7 @@ module NewRelic
         private
 
         def headers
-          @response.headers
+          @wrapped_response.headers
         end
       end
 
@@ -43,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
@@ -71,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,7 +1,7 @@
 # -*- ruby -*-
-# 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
 
 # This module includes utilities for manipulating URIs, particularly from the
 # context of Net::HTTP requests. We don't always have direct access to the full
@@ -13,21 +13,20 @@ module NewRelic
   module Agent
     module HTTPClients
       module URIUtil
-
-        def self.filter_uri(original)
-          filtered = original.dup
-          filtered.user = nil
-          filtered.password = nil
-          filtered.query = nil
-          filtered.fragment = nil
-          filtered.to_s
+        def self.obfuscated_uri(url)
+          parse_and_normalize_url(url).tap do |obfuscated|
+            obfuscated.user = nil
+            obfuscated.password = nil
+            obfuscated.query = nil
+            obfuscated.fragment = nil
+          end
         end
 
         # There are valid URI strings that some HTTP client libraries will
         # accept that the stdlib URI module doesn't handle. If we find that
         # Addressable is around, use that to normalize out our URL's.
         def self.parse_and_normalize_url(url)
-          uri = url
+          uri = url.dup
           unless ::URI === uri
             if defined?(::Addressable::URI)
               address = ::Addressable::URI.parse(url)
@@ -41,10 +40,10 @@ module NewRelic
           uri
         end
 
-        QUESTION_MARK = "?".freeze
+        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,16 +1,16 @@
-# 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/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
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
 
           finishable = if name == PERFORM_ACTION
@@ -23,17 +23,20 @@ module NewRelic
           end
           push_segment(id, finishable)
         rescue => e
-          log_notification_error e, name, 'start'
+          log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) # THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
 
-          notice_error payload if payload.key? :exception
+          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'
+          log_notification_error(e, name, 'finish')
         end
 
         private
@@ -47,14 +50,9 @@ module NewRelic
         end
 
         DOT_ACTION_CABLE = '.action_cable'.freeze
-        EMPTY_STRING = ''.freeze
 
         def action_name(name)
-          name.gsub DOT_ACTION_CABLE, EMPTY_STRING
-        end
-
-        def notice_error(payload)
-          NewRelic::Agent.notice_error payload[:exception_object]
+          name.gsub(DOT_ACTION_CABLE, NewRelic::EMPTY_STR)
         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/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/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,12 +26,16 @@ 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? \
               && !should_ignore(payload, controller_class(payload))
 
+            if exception = exception_object(payload)
+              finishable.notice_error(exception)
+            end
+
             finishable.finish
           else
             Agent.instance.pop_trace_execution_flag
@@ -45,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
 
@@ -87,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_view_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/instrumentation/notifications_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActionView render
@@ -9,8 +10,7 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionViewSubscriber < NotificationsSubscriber
-
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           parent = segment_stack[id].last
           metric_name = format_metric_name(name, payload, parent)
 
@@ -18,14 +18,18 @@ module NewRelic
           if state.is_execution_traced? && recordable?(name, metric_name)
             event.finishable = Tracer.start_segment(name: metric_name)
           end
-          push_segment id, event
+          push_segment(id, event)
         rescue => e
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_segment(id)
-          event.finish if event
+        def finish(name, id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -54,15 +58,15 @@ module NewRelic
               || metric_name == "View/#{::NewRelic::Agent::UNKNOWN_METRIC}/Partial"
         end
 
-        RENDER_TEMPLATE_EVENT_NAME   = 'render_template.action_view'.freeze
-        RENDER_PARTIAL_EVENT_NAME    = 'render_partial.action_view'.freeze
+        RENDER_TEMPLATE_EVENT_NAME = 'render_template.action_view'.freeze
+        RENDER_PARTIAL_EVENT_NAME = 'render_partial.action_view'.freeze
         RENDER_COLLECTION_EVENT_NAME = 'render_collection.action_view'.freeze
 
         def metric_action(name)
           case name
-          when /#{RENDER_TEMPLATE_EVENT_NAME}$/ then 'Rendering'
-          when RENDER_PARTIAL_EVENT_NAME        then 'Partial'
-          when RENDER_COLLECTION_EVENT_NAME     then 'Partial'
+          when /#{RENDER_TEMPLATE_EVENT_NAME}$/o then 'Rendering'
+          when RENDER_PARTIAL_EVENT_NAME then 'Partial'
+          when RENDER_COLLECTION_EVENT_NAME then 'Partial'
           end
         end
 
@@ -97,8 +101,11 @@ module NewRelic
         def finish
           @finishable.finish if @finishable
         end
+
+        def notice_error(error)
+          @finishable.notice_error(error) if @finishable
+        end
       end
     end
-
   end
 end

data/lib/new_relic/agent/instrumentation/active_job.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
 
 require 'new_relic/agent/prepend_supportability'
 
@@ -12,7 +12,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveJob instrumentation'
+    ::NewRelic::Agent.logger.info('Installing ActiveJob instrumentation')
 
     ActiveSupport.on_load(:active_job) do
       ::ActiveJob::Base.around_enqueue do |job, block|
@@ -44,12 +44,13 @@ module NewRelic
 
           # Don't nest transactions if we're already in a web transaction.
           # Probably inline processing the job if that happens, so just trace.
-          if    txn &&  txn.recording_web_transaction?
+          if txn && txn.recording_web_transaction?
             run_in_trace(job, block, :Consume)
           elsif txn && !txn.recording_web_transaction?
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
               transaction_name_suffix_for_job(job),
-              transaction_category)
+              transaction_category
+            )
             block.call
           else
             run_in_transaction(job, block)
@@ -57,15 +58,21 @@ module NewRelic
         end
 
         def self.run_in_trace(job, block, event)
-          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}") do
+          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}",
+            code_information: code_information_for_job(job)) do
             block.call
           end
         end
 
         def self.run_in_transaction(job, block)
+          options = code_information_for_job(job)
+          options = {} if options.frozen? # the hash will be added to later
           ::NewRelic::Agent::Tracer.in_transaction(name: transaction_name_for_job(job),
-                                                   category: :other,
-                                                   &block)
+            category: :other, options: options, &block)
+        end
+
+        def self.code_information_for_job(job)
+          NewRelic::Agent::MethodTracerHelpers.code_information(job.class, :perform)
         end
 
         def self.transaction_category

data/lib/new_relic/agent/instrumentation/active_merchant.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
 
 DependencyDetection.defer do
   @name = :active_merchant
@@ -12,7 +12,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveMerchant instrumentation'
+    ::NewRelic::Agent.logger.info('Installing ActiveMerchant instrumentation')
   end
 
   executes do
@@ -24,14 +24,28 @@ DependencyDetection.defer do
       gateway.class_eval do
         implemented_methods = public_instance_methods(false).map(&:to_sym)
         gateway_name = self.name.split('::').last
-        [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
+        actions = [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update]
+        actions.each do |operation|
           if implemented_methods.include?(operation)
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}"
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
-            add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+            add_method_tracer operation, [-> (*) { "ActiveMerchant/gateway/#{gateway_name}/#{operation}" },
+              -> (*) { "ActiveMerchant/gateway/#{gateway_name}" },
+              -> (*) { "ActiveMerchant/operation/#{operation}" }]
           end
         end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(ActiveMerchant::VERSION) < Gem::Version.new('1.65.0')
+
+    deprecation_msg = 'The Ruby Agent is dropping support for ActiveMerchant versions below 1.65.0 ' \
+      'in version 9.0.0. Please upgrade your ActiveMerchant version to continue receiving full support. ' \
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_active_merchant_version,
+      deprecation_msg
+    )
+  end
 end