newrelic_rpm 9.5.0 → 9.6.0

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

@@ -0,0 +1,111 @@
+# 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'
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
+        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/httpx_wrappers.rb

@@ -0,0 +1,93 @@
+# 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'
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
+        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/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/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

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

@@ -0,0 +1,105 @@
+# 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/ethon_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module Ethon
+    module NRShared
+      INSTRUMENTATION_NAME = 'Ethon'
+      NOTICEABLE_ERROR_CLASS = 'Ethon::Errors::EthonError'
+
+      def prep_easy(easy, parent = nil)
+        wrapped_request = NewRelic::Agent::HTTPClients::EthonHTTPRequest.new(easy)
+        segment = NewRelic::Agent::Tracer.start_external_request_segment(
+          library: wrapped_request.type,
+          uri: wrapped_request.uri,
+          procedure: wrapped_request.method,
+          parent: parent
+        )
+        segment.add_request_headers(wrapped_request)
+
+        callback = proc do
+          wrapped_response = NewRelic::Agent::HTTPClients::EthonHTTPResponse.new(easy)
+          segment.process_response_headers(wrapped_response)
+
+          if easy.return_code != :ok
+            e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS,
+              "return_code: >>#{easy.return_code}<<, response_code: >>#{easy.response_code}<<")
+            segment.notice_error(e)
+          end
+
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+
+        easy.on_complete { callback.call }
+
+        segment
+      end
+
+      def wrap_with_tracing(segment, &block)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        NewRelic::Agent::Tracer.capture_segment_error(segment) do
+          yield
+        end
+      ensure
+        NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+    end
+
+    module Easy
+      include NRShared
+
+      ACTION_INSTANCE_VAR = :@nr_action
+      HEADERS_INSTANCE_VAR = :@nr_headers
+
+      # `Ethon::Easy` doesn't expose the "action name" ('GET', 'POST', etc.)
+      # and Ethon's fabrication of HTTP classes uses
+      # `Ethon::Easy::Http::Custom` for non-standard actions. To be able to
+      # know the action name at `#perform` time, we set a new instance variable
+      # on the `Ethon::Easy` instance with the base name of the fabricated
+      # class, respecting the 'Custom' name where appropriate.
+      def fabricate_with_tracing(_url, action_name, _options)
+        fabbed = yield
+        instance_variable_set(ACTION_INSTANCE_VAR, NewRelic::Agent.base_name(fabbed.class.name).upcase)
+        fabbed
+      end
+
+      # `Ethon::Easy` uses `Ethon::Easy::Header` to set request headers on
+      # libcurl with `#headers=`. After they are set, they aren't easy to get
+      # at again except via FFI so set a new instance variable on the
+      # `Ethon::Easy` instance to store them in Ruby hash format.
+      def headers_equals_with_tracing(headers)
+        instance_variable_set(HEADERS_INSTANCE_VAR, headers)
+        yield
+      end
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = prep_easy(self)
+        wrap_with_tracing(segment) { yield }
+      end
+    end
+
+    module Multi
+      include NRShared
+
+      MULTI_SEGMENT_NAME = 'External/Multiple/Ethon::Multi/perform'
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = NewRelic::Agent::Tracer.start_segment(name: MULTI_SEGMENT_NAME)
+
+        wrap_with_tracing(segment) do
+          easy_handles.each { |easy| prep_easy(easy, segment) }
+
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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 Easy
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Easy
+
+        def fabricate(url, action_name, options)
+          fabricate_with_tracing(url, action_name, options) { super }
+        end
+
+        def headers=(headers)
+          headers_equals_with_tracing(headers) { super }
+        end
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+
+    module Multi
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Multi
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+  end
+end