newrelic_rpm 9.5.0 → 9.7.0

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

@@ -0,0 +1,109 @@
+# 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 'uri'
+require_relative 'abstract'
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      class EthonHTTPResponse < AbstractResponse
+        def initialize(easy)
+          @easy = easy
+        end
+
+        def status_code
+          @easy.response_code
+        end
+
+        def [](key)
+          headers[format_key(key)]
+        end
+
+        def headers
+          # Ethon::Easy#response_headers will return '' if headers are unset
+          @easy.response_headers.scan(/\n([^:]+?): ([^:\n]+?)\r/).each_with_object({}) do |pair, hash|
+            hash[format_key(pair[0])] = pair[1]
+          end
+        end
+        alias to_hash headers
+
+        private
+
+        def format_key(key)
+          key.tr('-', '_').downcase
+        end
+      end
+
+      class EthonHTTPRequest < AbstractRequest
+        attr_reader :uri
+
+        DEFAULT_ACTION = 'GET'
+        DEFAULT_HOST = 'UNKNOWN_HOST'
+        ETHON = 'Ethon'
+
+        def initialize(easy)
+          @easy = easy
+          @uri = uri_from_easy
+        end
+
+        def type
+          ETHON
+        end
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
+        end
+
+        def uri_from_easy
+          # anticipate `Ethon::Easy#url` being `example.com` without a protocol
+          # defined and use an 'http' protocol prefix for `URI.parse` to work
+          # with the URL as desired
+          url_str = @easy.url.match?(':') ? @easy.url : "http://#{@easy.url}"
+          begin
+            URI.parse(url_str)
+          rescue URI::InvalidURIError => e
+            NewRelic::Agent.logger.debug("Failed to parse URI '#{url_str}': #{e.class} - #{e.message}")
+            URI.parse(NewRelic::EMPTY_STR)
+          end
+        end
+
+        def host
+          host_from_header || uri.host&.downcase || DEFAULT_HOST
+        end
+
+        def method
+          return DEFAULT_ACTION unless @easy.instance_variable_defined?(action_instance_var)
+
+          @easy.instance_variable_get(action_instance_var)
+        end
+
+        def action_instance_var
+          NewRelic::Agent::Instrumentation::Ethon::Easy::ACTION_INSTANCE_VAR
+        end
+
+        def []=(key, value)
+          headers[key] = value
+          @easy.headers = headers
+        end
+
+        def headers
+          @headers ||= if @easy.instance_variable_defined?(headers_instance_var)
+            @easy.instance_variable_get(headers_instance_var)
+          else
+            {}
+          end
+        end
+
+        def headers_instance_var
+          NewRelic::Agent::Instrumentation::Ethon::Easy::HEADERS_INSTANCE_VAR
+        end
+
+        def [](key)
+          headers[key]
+        end
+      end
+    end
+  end
+end

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

@@ -47,9 +47,6 @@ module NewRelic
         attr_reader :method
 
         EXCON = 'Excon'
-        LHOST = 'host'
-        UHOST = 'Host'
-        COLON = ':'
 
         def initialize(datum)
           @datum = datum

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

@@ -20,8 +20,6 @@ module NewRelic
 
       class HTTPRequest < AbstractRequest
         HTTP_RB = 'http.rb'
-        HOST = 'host'
-        COLON = ':'
 
         def initialize(wrapped_request)
           @wrapped_request = wrapped_request
@@ -36,7 +34,7 @@ module NewRelic
         end
 
         def host_from_header
-          if hostname = self[HOST]
+          if hostname = self[LHOST]
             hostname.split(COLON).first
           end
         end

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

@@ -26,9 +26,6 @@ module NewRelic
         attr_reader :request
 
         HTTP_CLIENT = 'HTTPClient'.freeze
-        LHOST = 'host'.freeze
-        UHOST = 'Host'.freeze
-        COLON = ':'.freeze
 
         def initialize(request)
           @request = request

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

@@ -0,0 +1,91 @@
+# 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'
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      # HTTPX returns an instance of HTTPX::ErrorResponse on error,
+      # and that instance itself yields the underlying HTTP response
+      # object via #response, but depending on the error that HTTP
+      # response object could be unset.
+      class HTTPXErrorResponse
+        def status; end
+        def headers; {}; end
+      end
+
+      class HTTPXHTTPResponse < AbstractResponse
+        def initialize(response)
+          if response.is_a?(::HTTPX::ErrorResponse)
+            @response = response.response || HTTPXErrorResponse.new
+          else
+            @response = response
+          end
+        end
+
+        def status_code
+          @response.status
+        end
+
+        def [](key)
+          headers[format_key(key)]
+        end
+
+        def headers
+          headers ||= @response.headers.to_hash.each_with_object({}) do |(k, v), h|
+            h[format_key(k)] = v
+          end
+        end
+        alias to_hash headers
+
+        private
+
+        def format_key(key)
+          key.tr('-', '_').downcase
+        end
+      end
+
+      class HTTPXHTTPRequest < AbstractRequest
+        attr_reader :uri
+
+        DEFAULT_HOST = 'UNKNOWN_HOST'
+        TYPE = 'HTTPX'
+
+        def initialize(request)
+          @request = request
+          @uri = request.uri
+        end
+
+        def type
+          TYPE
+        end
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
+        end
+
+        def host
+          host_from_header || uri.host&.downcase || DEFAULT_HOST
+        end
+
+        def method
+          @request.verb
+        end
+
+        def []=(key, value)
+          @request.headers[key] = value
+        end
+
+        def headers
+          @request.headers
+        end
+
+        def [](key)
+          @request.headers[key]
+        end
+      end
+    end
+  end
+end

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

@@ -30,11 +30,8 @@ module NewRelic
           NET_HTTP
         end
 
-        HOST = 'host'
-        COLON = ':'
-
         def host_from_header
-          if hostname = self[HOST]
+          if hostname = self[LHOST]
             hostname.split(COLON).first
           end
         end

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

@@ -48,9 +48,6 @@ module NewRelic
           TYPHOEUS
         end
 
-        LHOST = 'host'.freeze
-        UHOST = 'Host'.freeze
-
         def host_from_header
           self[LHOST] || self[UHOST]
         end

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

@@ -39,7 +39,7 @@ DependencyDetection.defer do
   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 ' \
+    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(

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

@@ -232,7 +232,6 @@ module NewRelic
 
           DEFAULT = 'default'.freeze
           UNKNOWN = 'unknown'.freeze
-          SLASH = '/'.freeze
           LOCALHOST = 'localhost'.freeze
 
           def adapter_from_config(config)
@@ -288,7 +287,7 @@ module NewRelic
           private
 
           def postgres_unix_domain_socket_case?(host, adapter)
-            adapter == :postgres && host && host.start_with?(SLASH)
+            adapter == :postgres && host && host.start_with?(NewRelic::SLASH)
           end
 
           def mysql_default_case?(config, adapter)

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

@@ -0,0 +1,69 @@
+# 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 ActiveSupportBroadcastLogger::Chain
+    def self.instrument!
+      ::ActiveSupportBroadcastLogger.class_eval do
+        include NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger
+
+        alias_method(:add_without_new_relic, :add)
+
+        def add(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            add_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:debug_without_new_relic, :debug)
+
+        def debug(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            debug_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:info_without_new_relic, :info)
+
+        def info(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            info_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:warn_without_new_relic, :warn)
+
+        def warn(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            warn_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:error_without_new_relic, :error)
+
+        def error(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            error_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:fatal_without_new_relic, :fatal)
+
+        def fatal(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            fatal_without_new_relic(*args, &traced_task)
+          end
+        end
+      end
+
+      alias_method(:unknown_without_new_relic, :unknown)
+
+      def unknown(*args, &task)
+        record_one_broadcast_with_new_relic(*args) do
+          unknown_without_new_relic(*args, &traced_task)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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 ActiveSupportBroadcastLogger
+    def record_one_broadcast_with_new_relic(*args)
+      broadcasts[1..-1].each { |broadcasted_logger| broadcasted_logger.instance_variable_set(:@skip_instrumenting, true) }
+      yield
+      broadcasts.each { |broadcasted_logger| broadcasted_logger.instance_variable_set(:@skip_instrumenting, false) }
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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 ActiveSupportBroadcastLogger::Prepend
+    include NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger
+
+    def add(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def debug(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def info(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def warn(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def error(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def fatal(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def unknown(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# 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 'active_support_broadcast_logger/instrumentation'
+require_relative 'active_support_broadcast_logger/chain'
+require_relative 'active_support_broadcast_logger/prepend'
+
+DependencyDetection.defer do
+  named :'active_support_broadcast_logger'
+
+  depends_on { defined?(ActiveSupport::BroadcastLogger) }
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActiveSupport::BroadcastLogger instrumentation')
+
+    if use_prepend?
+      prepend_instrument ActiveSupport::BroadcastLogger, NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Chain
+    end
+  end
+end

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

@@ -9,7 +9,9 @@ require_relative 'active_support_logger/prepend'
 DependencyDetection.defer do
   named :active_support_logger
 
-  depends_on { defined?(ActiveSupport::Logger) }
+  depends_on do
+    defined?(ActiveSupport::Logger) && defined?(ActiveSupport::Logger.broadcast)
+  end
 
   executes do
     NewRelic::Agent.logger.info('Installing ActiveSupport::Logger instrumentation')

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

@@ -0,0 +1,23 @@
+# 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 AsyncHttp::Chain
+    def self.instrument!
+      ::Async::HTTP::Internet.class_eval do
+        include NewRelic::Agent::Instrumentation::AsyncHttp
+
+        alias_method(:call_without_new_relic, :call)
+
+        def call(method, url, headers = nil, body = nil)
+          call_with_new_relic(method, url, headers, body) do |hdr|
+            call_without_new_relic(method, url, hdr, body)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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/http_clients/async_http_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module AsyncHttp
+    def call_with_new_relic(method, url, headers = nil, body = nil)
+      headers ||= {} # if it is nil, we need to make it a hash so we can insert headers
+      wrapped_request = NewRelic::Agent::HTTPClients::AsyncHTTPRequest.new(self, method, url, headers)
+
+      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)
+
+        NewRelic::Agent.disable_all_tracing do
+          response = NewRelic::Agent::Tracer.capture_segment_error(segment) do
+            yield(headers)
+          end
+        end
+
+        wrapped_response = NewRelic::Agent::HTTPClients::AsyncHTTPResponse.new(response)
+        segment.process_response_headers(wrapped_response)
+        response
+      ensure
+        segment&.finish
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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 AsyncHttp::Prepend
+    include NewRelic::Agent::Instrumentation::AsyncHttp
+
+    def call(method, url, headers = nil, body = nil)
+      call_with_new_relic(method, url, headers, body) { |hdr| super(method, url, hdr, body) }
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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 'async_http/instrumentation'
+require_relative 'async_http/chain'
+require_relative 'async_http/prepend'
+
+DependencyDetection.defer do
+  named :async_http
+
+  depends_on do
+    defined?(Async::HTTP) && Gem::Version.new(Async::HTTP::VERSION) >= Gem::Version.new('0.59.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing async_http instrumentation')
+
+    require 'async/http/internet'
+    if use_prepend?
+      prepend_instrument Async::HTTP::Internet, NewRelic::Agent::Instrumentation::AsyncHttp::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::AsyncHttp::Chain
+    end
+  end
+end

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

@@ -56,7 +56,7 @@ module NewRelic::Agent::Instrumentation
       return if nr_hosts.empty?
 
       NewRelic::Agent.disable_all_tracing do
-        @nr_cluster_name ||= perform_request('GET', '_cluster/health').body['cluster_name']
+        @nr_cluster_name ||= perform_request('GET', '/').body['cluster_name']
       end
     rescue StandardError => e
       NewRelic::Agent.logger.error('Failed to get cluster name for elasticsearch', e)

data/lib/new_relic/agent/instrumentation/ethon/chain.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
+
+module NewRelic::Agent::Instrumentation
+  module Ethon
+    module Chain
+      def self.instrument!
+        ::Ethon::Easy.class_eval do
+          include NewRelic::Agent::Instrumentation::Ethon::Easy
+
+          alias_method(:fabricate_without_tracing, :fabricate)
+          def fabricate(url, action_name, options)
+            fabricate_with_tracing(url, action_name, options) { fabricate_without_tracing(url, action_name, options) }
+          end
+
+          alias_method(:headers_equals_without_tracing, :headers=)
+          def headers=(headers)
+            headers_equals_with_tracing(headers) { headers_equals_without_tracing(headers) }
+          end
+
+          alias_method(:perform_without_tracing, :perform)
+          def perform(*args)
+            perform_with_tracing(*args) { perform_without_tracing(*args) }
+          end
+        end
+
+        ::Ethon::Multi.class_eval do
+          include NewRelic::Agent::Instrumentation::Ethon::Multi
+
+          alias_method(:perform_without_tracing, :perform)
+          def perform(*args)
+            perform_with_tracing(*args) { perform_without_tracing(*args) }
+          end
+        end
+      end
+    end
+  end
+end