newrelic_rpm 5.7.0.350 → 9.0.0

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,75 +1,45 @@
-# 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/evented_subscriber'
+# 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 < EventedSubscriber
-
+      class ActionCableSubscriber < NotificationsSubscriber
         PERFORM_ACTION = 'perform_action.action_cable'.freeze
 
-        def start name, id, payload #THREAD_LOCAL_ACCESS
-          return unless state.is_execution_traced?
-          event = super
-          if event.name == PERFORM_ACTION
-            start_transaction event
+        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),
+              category: :action_cable
+            )
           else
-            start_recording_metrics event
+            Tracer.start_segment(name: metric_name_from_payload(name, payload))
           end
-        rescue => e
-          log_notification_error e, name, 'start'
-        end
-
-        def finish name, id, payload #THREAD_LOCAL_ACCESS
-          return unless state.is_execution_traced?
-          event = super
-          notice_error payload if payload.key? :exception
-          if event.name == PERFORM_ACTION
-            finish_transaction
-          else
-            stop_recording_metrics event
-          end
-        rescue => e
-          log_notification_error e, name, 'finish'
+          push_segment(id, finishable)
         end
 
         private
 
-        def start_transaction event
-          Transaction.start(state, :action_cable, :transaction_name => transaction_name_from_event(event))
-        end
-
-        def finish_transaction
-          Transaction.stop(state)
-        end
-
-        def start_recording_metrics event
-          event.payload[:segment] = Transaction.start_segment name: metric_name_from_event(event)
+        def transaction_name_from_payload(payload)
+          "Controller/ActionCable/#{payload[:channel_class]}/#{payload[:action]}"
         end
 
-        def stop_recording_metrics event
-          event.payload[:segment].finish if event.payload[:segment]
+        def metric_name_from_payload(name, payload)
+          "Ruby/ActionCable/#{metric_name(payload)}/#{action_name(name)}"
         end
 
-        def transaction_name_from_event event
-          "Controller/ActionCable/#{event.payload[:channel_class]}/#{event.payload[:action]}"
+        def metric_name(payload)
+          payload[:broadcasting] || payload[:channel_class]
         end
 
-        def metric_name_from_event event
-          "Ruby/ActionCable/#{event.payload[:channel_class]}/#{action_name_from_event(event)}"
-        end
-
-        DOT_ACTION_CABLE = ".action_cable".freeze
-        EMPTY_STRING = "".freeze
-
-        def action_name_from_event event
-          event.name.gsub DOT_ACTION_CABLE, EMPTY_STRING
-        end
+        DOT_ACTION_CABLE = '.action_cable'.freeze
 
-        def notice_error payload
-          NewRelic::Agent.notice_error payload[:exception_object]
+        def action_name(name)
+          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,24 +1,21 @@
-# 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/evented_subscriber'
+# 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 ActionControllerSubscriber < EventedSubscriber
-
-        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)
+      class ActionControllerSubscriber < NotificationsSubscriber
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
+          controller_class = controller_class(payload)
 
-          event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
-          push_event(event)
-
-          if state.is_execution_traced? && !event.ignored?
-            start_transaction(event)
+          if state.is_execution_traced? && !should_ignore(payload, 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
             # transaction are also ignored
@@ -29,12 +26,17 @@ module NewRelic
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_event(id)
-          event.payload.merge!(payload)
+        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
 
-          if state.is_execution_traced? && !event.ignored?
-            stop_transaction(event)
+            finishable.finish
           else
             Agent.instance.pop_trace_execution_flag
           end
@@ -42,77 +44,62 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def start_transaction(event)
-          Transaction.start(state, :controller,
-                            :request          => event.request,
-                            :filtered_params  => filter(event.payload[:params]),
-                            :apdex_start_time => event.queue_start,
-                            :transaction_name => event.metric_name,
-                            :ignore_apdex     => event.apdex_ignored?,
-                            :ignore_enduser   => event.enduser_ignored?)
+        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: tracer_options(payload, request, controller_class)
+          )
         end
 
-        def stop_transaction(event)
-          Transaction.stop(state)
-        end
-
-        def filter(params)
-          munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(params)
-          filters = Rails.application.config.filter_parameters
-          ActionDispatch::Http::ParameterFilter.new(filters).filter(munged_params)
-        end
-      end
-
-      class ControllerEvent < Event
-        attr_accessor :parent
-        attr_reader :queue_start, :request
-
-        def initialize(name, start, ending, transaction_id, payload, request)
-          # We have a different initialize parameter list, so be explicit
-          super(name, start, ending, transaction_id, payload)
-
-          @request = request
-          @controller_class = payload[:controller].split('::') \
-            .inject(Object){|m,o| m.const_get(o)}
-
-          if request && request.respond_to?(:env)
-            @queue_start = QueueTime.parse_frontend_timestamp(request.env, self.time)
-          end
+        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 metric_name
-          @metric_name || "Controller/#{metric_path}/#{metric_action}"
+        def filtered_params(params)
+          NewRelic::Agent::ParameterFiltering.filter_using_rails(params, Rails.application.config.filter_parameters)
         end
 
-        def metric_path
-          @controller_class.controller_path
+        def ignore?(action, key, controller_class)
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(key, controller_class, action)
         end
 
-        def metric_action
-          payload[:action]
+        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
 
-        def ignored?
-          _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
+        def controller_class(payload)
+          ::NewRelic::LanguageSupport.constantize(payload[:controller])
         end
 
-        def apdex_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_APDEX_KEY)
+        def should_ignore(payload, controller_class)
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+            ControllerInstrumentation::NR_DO_NOT_TRACE_KEY,
+            controller_class,
+            payload[:action]
+          )
         end
 
-        def enduser_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY)
+        def queue_start(request)
+          if request && request.respond_to?(:env)
+            QueueTime.parse_frontend_timestamp(request.env, Process.clock_gettime(Process::CLOCK_REALTIME))
+          end
         end
 
-        def _is_filtered?(key)
-          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-            key,
-            @controller_class,
-            metric_action)
-        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)
 
-        def to_s
-          "#<NewRelic::Agent::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+          payload[:headers].instance_variable_get(:@req)
         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