newrelic_rpm 9.5.0 → 9.8.0

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

data/lib/new_relic/agent/instrumentation/ethon.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_relative 'ethon/instrumentation'
+require_relative 'ethon/chain'
+require_relative 'ethon/prepend'
+
+DependencyDetection.defer do
+  named :ethon
+
+  # If Ethon is being used as a dependency of Typhoeus, allow the Typhoeus
+  # instrumentation to handle everything. Otherwise each external network call
+  # will confusingly result in "Ethon" segments duplicating the information
+  # already provided by "Typhoeus" segments.
+  depends_on do
+    !defined?(Typhoeus)
+  end
+
+  depends_on do
+    defined?(Ethon) && Gem::Version.new(Ethon::VERSION) >= Gem::Version.new('0.12.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ethon instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      # NOTE: by default prepend_instrument will go with the module name that
+      #       precedes 'Prepend' (so 'Easy' and 'Multi'), but we want to use
+      #       'Ethon::Easy' and 'Ethon::Multi' so 3rd argument is supplied
+      prepend_instrument Ethon::Easy, NewRelic::Agent::Instrumentation::Ethon::Easy::Prepend, Ethon::Easy.name
+      prepend_instrument Ethon::Multi, NewRelic::Agent::Instrumentation::Ethon::Multi::Prepend, Ethon::Multi.name
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Ethon::Chain
+    end
+  end
+end

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

@@ -14,10 +14,7 @@ module NewRelic::Agent::Instrumentation
     def add_thread_tracing(&block)
       return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
-      NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-        segment_name: 'Ruby/Fiber',
-        &block
-      )
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(&block)
     end
   end
 end

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

@@ -14,7 +14,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Client::INSTRUMENTATION_NAME
+    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Server::INSTRUMENTATION_NAME
     if use_prepend?
       prepend_instrument GRPC::RpcServer, NewRelic::Agent::Instrumentation::GRPC::Server::RpcServerPrepend, supportability_name
       prepend_instrument GRPC::RpcDesc, NewRelic::Agent::Instrumentation::GRPC::Server::RpcDescPrepend, supportability_name

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

@@ -0,0 +1,20 @@
+# 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 HTTPX
+    module Chain
+      def self.instrument!
+        ::HTTPX::Session.class_eval do
+          include NewRelic::Agent::Instrumentation::HTTPX
+
+          alias_method(:send_requests_without_tracing, :send_requests)
+          def send_requests(*requests)
+            send_requests_with_tracing(*requests) { send_requests_without_tracing(*requests) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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/httpx_wrappers'
+
+module NewRelic::Agent::Instrumentation::HTTPX
+  INSTRUMENTATION_NAME = 'HTTPX'
+  NOTICEABLE_ERROR_CLASS = 'HTTPX::Error'
+
+  def send_requests_with_tracing(*requests)
+    NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+    requests.each { |r| nr_start_segment(r) }
+    yield
+  end
+
+  def nr_start_segment(request)
+    return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+    wrapped_request = NewRelic::Agent::HTTPClients::HTTPXHTTPRequest.new(request)
+    segment = NewRelic::Agent::Tracer.start_external_request_segment(
+      library: wrapped_request.type,
+      uri: wrapped_request.uri,
+      procedure: wrapped_request.method
+    )
+    segment.add_request_headers(wrapped_request)
+
+    request.on(:response) { nr_finish_segment.call(request, segment) }
+  end
+
+  def nr_finish_segment
+    proc do |request, segment|
+      response = @responses[request]
+
+      unless response
+        NewRelic::Agent.logger.debug('Processed an on-response callback for HTTPX but could not find the response!')
+        next
+      end
+
+      wrapped_response = NewRelic::Agent::HTTPClients::HTTPXHTTPResponse.new(response)
+      segment.process_response_headers(wrapped_response)
+
+      if response.is_a?(::HTTPX::ErrorResponse)
+        e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS, "Couldn't connect: #{response}")
+        segment.notice_error(e)
+      end
+
+      ::NewRelic::Agent::Transaction::Segment.finish(segment)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httpx/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
+
+module NewRelic::Agent::Instrumentation
+  module HTTPX
+    module Prepend
+      include NewRelic::Agent::Instrumentation::HTTPX
+
+      def send_requests(*requests)
+        send_requests_with_tracing(*requests) { super }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# 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 'httpx/chain'
+require_relative 'httpx/instrumentation'
+require_relative 'httpx/prepend'
+
+DependencyDetection.defer do
+  named :httpx
+
+  depends_on do
+    defined?(HTTPX) && Gem::Version.new(HTTPX::VERSION) >= Gem::Version.new('1.0.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing httpx instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument HTTPX::Session, NewRelic::Agent::Instrumentation::HTTPX::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::HTTPX::Chain
+    end
+  end
+end

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

@@ -131,10 +131,8 @@ module NewRelic
           UNKNOWN
         end
 
-        SLASH = '/'.freeze
-
         def unix_domain_socket?(host)
-          host.start_with?(SLASH)
+          host.start_with?(NewRelic::SLASH)
         end
       end
     end

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

@@ -32,10 +32,16 @@ module NewRelic
             end
 
             wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new(response)
+
+            if NewRelic::Agent::LLM.openai_parent?(segment)
+              NewRelic::Agent::LLM.populate_openai_response_headers(wrapped_response, segment.parent)
+            end
+
             segment.process_response_headers(wrapped_response)
+
             response
           ensure
-            segment.finish
+            segment&.finish
           end
         end
       end

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -34,6 +34,7 @@ DependencyDetection.defer do
 
     subs = %w[send_file
       send_data
+      send_stream
       redirect_to
       halted_callback
       unpermitted_parameters]

data/lib/new_relic/agent/instrumentation/roda/ignorer.rb

@@ -0,0 +1,45 @@
+# 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 Roda
+    module Ignorer
+      def self.should_ignore?(app, type)
+        return false unless app.opts.include?(:newrelic_ignores)
+
+        app.opts[:newrelic_ignores][type].any? do |pattern|
+          pattern === app.request.path_info
+        end
+      end
+
+      def newrelic_ignore(*routes)
+        set_newrelic_ignore(:routes, *routes)
+      end
+
+      def newrelic_ignore_apdex(*routes)
+        set_newrelic_ignore(:apdex, *routes)
+      end
+
+      def newrelic_ignore_enduser(*routes)
+        set_newrelic_ignore(:enduser, *routes)
+      end
+
+      private
+
+      def set_newrelic_ignore(type, *routes)
+        # Create a newrelic_ignores hash if one doesn't exist
+        opts[:newrelic_ignores] = Hash.new([]) if !opts.include?(:newrelic_ignores)
+
+        if routes.empty?
+          opts[:newrelic_ignores][type] += [Regexp.new('.*')]
+        else
+          opts[:newrelic_ignores][type] += routes.map do |r|
+            # Roda adds leading slashes to routes, so we need to do the same
+            "#{'/' unless r.start_with?('/')}#{r}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,18 @@ module NewRelic::Agent::Instrumentation
           yield
         end
       end
+
+      def do_not_trace?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :routes)
+      end
+
+      def ignore_apdex?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :apdex)
+      end
+
+      def ignore_enduser?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :enduser)
+      end
     end
   end
 end

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -9,13 +9,12 @@ module NewRelic
         module TransactionNamer
           extend self
 
-          ROOT = '/'.freeze
           REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
 
           def transaction_name(request)
             path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC
             name = path.gsub(REGEX_MULTIPLE_SLASHES, '\1') # remove any rogue slashes
-            name = ROOT if name.empty?
+            name = NewRelic::ROOT if name.empty?
             name = "#{request.request_method} #{name}" if request.respond_to?(:request_method)
 
             name

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

@@ -4,6 +4,7 @@
 
 require_relative 'roda/instrumentation'
 require_relative 'roda/roda_transaction_namer'
+require_relative 'roda/ignorer'
 
 DependencyDetection.defer do
   named :roda
@@ -30,5 +31,6 @@ DependencyDetection.defer do
       chain_instrument NewRelic::Agent::Instrumentation::Roda::Build::Chain
       chain_instrument NewRelic::Agent::Instrumentation::Roda::Chain
     end
+    Roda.class_eval { extend NewRelic::Agent::Instrumentation::Roda::Ignorer }
   end
 end

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

@@ -0,0 +1,36 @@
+# 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 OpenAI::Chain
+    def self.instrument!
+      ::OpenAI::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::OpenAI
+
+        alias_method(:json_post_without_new_relic, :json_post)
+
+        # In versions 4.0.0+ json_post is an instance method
+        # defined in the OpenAI::HTTP module, included by the
+        # OpenAI::Client class
+        def json_post(**kwargs)
+          json_post_with_new_relic(**kwargs) do
+            json_post_without_new_relic(**kwargs)
+          end
+        end
+
+        # In versions below 4.0.0 json_post is a class method
+        # on OpenAI::Client
+        class << self
+          alias_method(:json_post_without_new_relic, :json_post)
+
+          def json_post(**kwargs)
+            json_post_with_new_relic(**kwargs) do
+              json_post_without_new_relic(**kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end