newrelic_rpm 6.2.0.354 → 6.15.0

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

@@ -1,20 +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.
+# 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 ExconHTTPResponse
-        def initialize(response)
-          @response = response
+      class ExconHTTPResponse < AbstractResponse
+        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.
           @normalized_headers = {}
-          headers = response.respond_to?(:headers) ? response.headers : response[:headers]
-          (headers || {}).each do |key, val|
+          (get_attribute(:headers) || {}).each do |key, val|
             @normalized_headers[key.upcase] = val
           end
         end
@@ -26,15 +27,30 @@ module NewRelic
         def to_hash
           @normalized_headers.dup
         end
+
+        private
+
+        def get_attribute name
+          if @wrapped_response.respond_to?(name) 
+            @wrapped_response.send(name) 
+          else
+            @wrapped_response[name]
+          end
+        end
+
+        def get_status_code
+          code = get_attribute(:status).to_i
+          code == 0 ? nil : code
+        end
       end
 
       class ExconHTTPRequest < AbstractRequest
         attr_reader :method
 
-        EXCON = "Excon".freeze
-        LHOST = 'host'.freeze
-        UHOST = 'Host'.freeze
-        COLON = ':'.freeze
+        EXCON = "Excon"
+        LHOST = 'host'
+        UHOST = 'Host'
+        COLON = ':'
 
         def initialize(datum)
           @datum = datum
@@ -70,9 +86,8 @@ module NewRelic
         end
 
         def uri
-          ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(
-            "#{@scheme}://#{host}:#{@port}#{@path}"
-            )
+          url = "#{@scheme}://#{host}:#{@port}#{@path}"
+          URIUtil.parse_and_normalize_url url
         end
       end
     end

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

@@ -1,39 +1,35 @@
 # 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 HTTPResponse
-        attr_reader :response
-
-        def initialize(response)
-          @response = response
-        end
-
+      class HTTPResponse < AbstractResponse
         def [](key)
-          _, value = response.headers.find { |k,_| key.downcase == k.downcase }
+          _, value = @wrapped_response.headers.find{ |k, _| key.downcase == k.downcase }
           value unless value.nil?
         end
 
         def to_hash
-          response.headers
+          @wrapped_response.headers
         end
       end
 
       class HTTPRequest < AbstractRequest
-        HTTP_RB = 'http.rb'.freeze
-        HOST    = 'host'.freeze
-        COLON   = ':'.freeze
+        HTTP_RB = 'http.rb'
+        HOST    = 'host'
+        COLON   = ':'
 
-        attr_reader :request, :uri
+        def initialize wrapped_request
+          @wrapped_request = wrapped_request
+        end
 
-        def initialize(request)
-          @request = request
-          @uri = request.uri
+        def uri
+          @uri ||= URIUtil.parse_and_normalize_url(@wrapped_request.uri)
         end
 
         def type
@@ -47,19 +43,19 @@ module NewRelic
         end
 
         def host
-          host_from_header || request.host
+          host_from_header || @wrapped_request.host
         end
 
         def method
-          request.verb.upcase
+          @wrapped_request.verb.upcase
         end
 
         def [](key)
-          request.headers[key]
+          @wrapped_request.headers[key]
         end
 
         def []=(key, value)
-          request.headers[key] = value
+          @wrapped_request.headers[key] = value
         end
       end
     end

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

@@ -1,21 +1,17 @@
 # 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|
+          @wrapped_response.headers.each do |k,v|
             if key.downcase == k.downcase
               return v
             end
@@ -24,12 +20,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 +34,6 @@ module NewRelic
 
         def initialize(request)
           @request = request
-          @uri = request.header.request_uri
         end
 
         def type
@@ -59,6 +54,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,38 @@
 # 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 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]

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

@@ -1,16 +1,14 @@
 # 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?
@@ -33,7 +31,7 @@ module NewRelic
         private
 
         def headers
-          @response.headers
+          @wrapped_response.headers
         end
       end
 

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

@@ -1,7 +1,8 @@
 # -*- 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
@@ -14,20 +15,20 @@ module NewRelic
     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 +42,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,78 +1,58 @@
 # 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.
+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
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
-          event = super
-          if event.name == PERFORM_ACTION
-            start_transaction event
+
+          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
+          push_segment(id, finishable)
         rescue => e
           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?
-          event = super
-          notice_error payload if payload.key? :exception
-          if event.name == PERFORM_ACTION
-            finish_transaction event
-          else
-            stop_recording_metrics event
+
+          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
 
-        def start_transaction event
-          event.payload[:finishable] = Tracer.start_transaction_or_segment(
-            name:     transaction_name_from_event(event),
-            category: :action_cable
-          )
-        end
-
-        def finish_transaction event
-          (finishable = event.payload[:finishable]) && finishable.finish
-        end
-
-        def start_recording_metrics event
-          event.payload[:segment] = Tracer.start_segment name: metric_name_from_event(event)
-        end
-
-        def stop_recording_metrics event
-          event.payload[:segment].finish if event.payload[:segment]
+        def transaction_name_from_payload(payload)
+          "Controller/ActionCable/#{payload[:channel_class]}/#{payload[:action]}"
         end
 
-        def transaction_name_from_event event
-          "Controller/ActionCable/#{event.payload[:channel_class]}/#{event.payload[:action]}"
+        def metric_name_from_payload(name, payload)
+          "Ruby/ActionCable/#{payload[:channel_class]}/#{action_name(name)}"
         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_subscriber.rb

@@ -1,24 +1,24 @@
 # 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.
+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
+      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)
 
-          event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
-          push_event(event)
+          controller_class = controller_class(payload)
 
-          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, controller_class)
+            push_segment(id, finishable)
           else
             # if this transaction is ignored, make sure child
             # transaction are also ignored
@@ -30,11 +30,16 @@ module NewRelic
         end
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_event(id)
-          event.payload.merge!(payload)
+          finishable = pop_segment(id)
 
-          if state.is_execution_traced? && !event.ignored?
-            stop_transaction(event)
+          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
           end
@@ -42,81 +47,52 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def start_transaction(event)
-          event.payload[:finishable] = Tracer.start_transaction_or_segment(
-            name:             event.metric_name,
-            category:         :controller,
-            options: {
-              request:          event.request,
-              filtered_params:  filter(event.payload[:params]),
-              apdex_start_time: event.queue_start,
-              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:   {
+              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]
+              )
             }
           )
         end
 
-        def stop_transaction(event)
-          (finishable = event.payload[:finishable]) && finishable.finish
+        def format_metric_name(metric_action, controller_name)
+          controller_class = ::NewRelic::LanguageSupport.constantize(controller_name)
+          "Controller/#{controller_class.controller_path}/#{metric_action}"
         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)
+        def controller_class(payload)
+          ::NewRelic::LanguageSupport.constantize(payload[:controller])
         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
-        end
-
-        def metric_name
-          @metric_name || "Controller/#{metric_path}/#{metric_action}"
-        end
-
-        def metric_path
-          @controller_class.controller_path
-        end
-
-        def metric_action
-          payload[:action]
-        end
-
-        def ignored?
-          _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
-        end
-
-        def apdex_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_APDEX_KEY)
-        end
-
-        def enduser_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY)
-        end
-
-        def _is_filtered?(key)
+        def should_ignore(payload, controller_class)
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-            key,
-            @controller_class,
-            metric_action)
+            ControllerInstrumentation::NR_DO_NOT_TRACE_KEY,
+            controller_class,
+            payload[:action]
+          )
         end
 
-        def to_s
-          "#<NewRelic::Agent::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+        def queue_start(request)
+          if request && request.respond_to?(:env)
+            QueueTime.parse_frontend_timestamp(request.env, Time.now)
+          end
         end
       end
     end