newrelic_rpm 3.12.0.288 → 9.10.2

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

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

@@ -0,0 +1,196 @@
+# 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
+    VENDOR = 'openAI' # AIM expects this capitalization style for the UI
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+    EMBEDDINGS_PATH = '/embeddings'
+    CHAT_COMPLETIONS_PATH = '/chat/completions'
+    EMBEDDINGS_SEGMENT_NAME = 'Llm/embedding/OpenAI/embeddings'
+    CHAT_COMPLETIONS_SEGMENT_NAME = 'Llm/completion/OpenAI/chat'
+
+    def json_post_with_new_relic(path:, parameters:)
+      return yield unless path == EMBEDDINGS_PATH || path == CHAT_COMPLETIONS_PATH
+
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+      NewRelic::Agent::Llm::LlmEvent.set_llm_agent_attribute_on_transaction
+      record_openai_metric
+
+      if path == EMBEDDINGS_PATH
+        embeddings_instrumentation(parameters) { yield }
+      elsif path == CHAT_COMPLETIONS_PATH
+        chat_completions_instrumentation(parameters) { yield }
+      end
+    end
+
+    private
+
+    def embeddings_instrumentation(parameters)
+      segment = NewRelic::Agent::Tracer.start_segment(name: EMBEDDINGS_SEGMENT_NAME)
+      event = create_embeddings_event(parameters)
+      segment.llm_event = event
+      begin
+        response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        # TODO: Remove !response.include?('error') when we drop support for versions below 4.0.0
+        add_embeddings_response_params(response, event) if response && !response.include?('error')
+
+        response
+      ensure
+        finish(segment, event)
+      end
+    end
+
+    def chat_completions_instrumentation(parameters)
+      segment = NewRelic::Agent::Tracer.start_segment(name: CHAT_COMPLETIONS_SEGMENT_NAME)
+      event = create_chat_completion_summary(parameters)
+      segment.llm_event = event
+      messages = create_chat_completion_messages(parameters, event.id)
+
+      begin
+        response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        # TODO: Remove !response.include?('error') when we drop support for versions below 4.0.0
+        if response && !response.include?('error')
+          add_chat_completion_response_params(parameters, response, event)
+          messages = update_chat_completion_messages(messages, response, event)
+        end
+
+        response
+      ensure
+        finish(segment, event)
+        messages&.each { |m| m.record }
+      end
+    end
+
+    def create_chat_completion_summary(parameters)
+      NewRelic::Agent::Llm::ChatCompletionSummary.new(
+        vendor: VENDOR,
+        request_max_tokens: (parameters[:max_tokens] || parameters['max_tokens'])&.to_i,
+        request_model: parameters[:model] || parameters['model'],
+        request_temperature: (parameters[:temperature] || parameters['temperature'])&.to_f,
+        metadata: llm_custom_attributes
+      )
+    end
+
+    def create_embeddings_event(parameters)
+      event = NewRelic::Agent::Llm::Embedding.new(
+        vendor: VENDOR,
+        request_model: parameters[:model] || parameters['model'],
+        metadata: llm_custom_attributes
+      )
+      add_input(event, (parameters[:input] || parameters['input']))
+
+      event
+    end
+
+    def add_chat_completion_response_params(parameters, response, event)
+      event.response_number_of_messages = (parameters[:messages] || parameters['messages']).size + response['choices'].size
+      # The response hash always returns keys as strings, so we don't need to run an || check here
+      event.response_model = response['model']
+      event.response_choices_finish_reason = response['choices'][0]['finish_reason']
+    end
+
+    def add_embeddings_response_params(response, event)
+      event.response_model = response['model']
+      event.token_count = calculate_token_count(event.request_model, event.input)
+    end
+
+    def create_chat_completion_messages(parameters, summary_id)
+      (parameters[:messages] || parameters['messages']).map.with_index do |message, index|
+        msg = NewRelic::Agent::Llm::ChatCompletionMessage.new(
+          role: message[:role] || message['role'],
+          sequence: index,
+          completion_id: summary_id,
+          vendor: VENDOR
+        )
+        add_content(msg, (message[:content] || message['content']))
+
+        msg
+      end
+    end
+
+    def create_chat_completion_response_messages(response, sequence_origin, summary_id)
+      response['choices'].map.with_index(sequence_origin) do |choice, index|
+        msg = NewRelic::Agent::Llm::ChatCompletionMessage.new(
+          role: choice['message']['role'],
+          sequence: index,
+          completion_id: summary_id,
+          vendor: VENDOR,
+          is_response: true
+        )
+        add_content(msg, choice['message']['content'])
+
+        msg
+      end
+    end
+
+    def update_chat_completion_messages(messages, response, summary)
+      messages += create_chat_completion_response_messages(response, messages.size, summary.id)
+      response_id = response['id'] || NewRelic::Agent::GuidGenerator.generate_guid
+      messages.each do |message|
+        message.id = "#{response_id}-#{message.sequence}"
+        message.request_id = summary.request_id
+        message.response_model = response['model']
+        message.metadata = llm_custom_attributes
+
+        model = message.is_response ? message.response_model : summary.request_model
+
+        message.token_count = calculate_token_count(model, message.content)
+      end
+    end
+
+    def calculate_token_count(model, content)
+      return unless NewRelic::Agent.llm_token_count_callback
+
+      begin
+        count = NewRelic::Agent.llm_token_count_callback.call({model: model, content: content})
+      rescue => e
+        NewRelic::Agent.logger.warn("Error calculating token count using the provided proc. Error: #{e}'")
+      end
+
+      count if count.is_a?(Integer) && count > 0
+    end
+
+    def record_content_enabled?
+      NewRelic::Agent.config[:'ai_monitoring.record_content.enabled']
+    end
+
+    def add_content(message, content)
+      message.content = content if record_content_enabled?
+    end
+
+    def add_input(event, input)
+      event.input = input if record_content_enabled?
+    end
+
+    def llm_custom_attributes
+      NewRelic::Agent::Tracer.current_transaction&.attributes&.custom_attributes&.select { |k| k.to_s.match(/llm.*/) }
+    end
+
+    def record_openai_metric
+      NewRelic::Agent.record_metric(nr_supportability_metric, 0.0)
+    end
+
+    def segment_noticed_error?(segment)
+      segment&.noticed_error
+    end
+
+    def nr_supportability_metric
+      @nr_supportability_metric ||= "Supportability/Ruby/ML/OpenAI/#{::OpenAI::VERSION}"
+    end
+
+    def finish(segment, event)
+      segment&.finish
+
+      return unless event
+
+      if segment
+        event.error = true if segment_noticed_error?(segment)
+        event.duration = segment.duration
+      end
+
+      event.record
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ruby_openai/prepend.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 OpenAI::Prepend
+    include NewRelic::Agent::Instrumentation::OpenAI
+
+    # In versions 4.0.0+ json_post is an instance method defined in the
+    # OpenAI::HTTP module, included by the OpenAI::Client class.
+    #
+    # In versions below 4.0.0 json_post is a class method on OpenAI::Client.
+    #
+    # Dependency detection will apply the instrumentation to the correct scope,
+    # so we don't need to change the code here.
+    def json_post(**kwargs)
+      json_post_with_new_relic(**kwargs) { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ruby_openai.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
+
+require_relative 'ruby_openai/instrumentation'
+require_relative 'ruby_openai/chain'
+require_relative 'ruby_openai/prepend'
+
+DependencyDetection.defer do
+  named :'ruby_openai'
+
+  depends_on do
+    NewRelic::Agent.config[:'ai_monitoring.enabled'] &&
+      defined?(OpenAI) && defined?(OpenAI::Client) &&
+      Gem::Version.new(OpenAI::VERSION) >= Gem::Version.new('3.4.0')
+  end
+
+  executes do
+    if use_prepend?
+      # TODO: Remove condition when we drop support for versions below 5.0.0
+      if Gem::Version.new(OpenAI::VERSION) >= Gem::Version.new('5.0.0')
+        prepend_instrument OpenAI::Client,
+          NewRelic::Agent::Instrumentation::OpenAI::Prepend,
+          NewRelic::Agent::Instrumentation::OpenAI::VENDOR
+      else
+        prepend_instrument OpenAI::Client.singleton_class,
+          NewRelic::Agent::Instrumentation::OpenAI::Prepend,
+          NewRelic::Agent::Instrumentation::OpenAI::VENDOR
+      end
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::OpenAI::Chain,
+        NewRelic::Agent::Instrumentation::OpenAI::VENDOR
+    end
+  end
+end

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

@@ -1,53 +1,47 @@
 # -*- 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.
-
-require 'newrelic_rpm'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 DependencyDetection.defer do
   @name = :sequel
 
   depends_on do
-    defined?(::Sequel)
+    defined?(Sequel)
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_sequel_instrumentation] &&
-    !NewRelic::Agent.config[:disable_database_instrumentation]
+    !NewRelic::Agent.config[:disable_sequel_instrumentation]
   end
 
   def supported_sequel_version?
-    Sequel.const_defined?( :MAJOR ) &&
-      ( Sequel::MAJOR > 3 ||
-        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
+    Sequel.const_defined?(:MAJOR) &&
+      (Sequel::MAJOR > 3 ||
+        Sequel::MAJOR == 3 && Sequel::MINOR >= 37)
   end
 
   executes do
     if supported_sequel_version?
 
-      ::NewRelic::Agent.logger.info 'Installing Sequel instrumentation'
+      NewRelic::Agent.logger.info('Installing Sequel instrumentation')
 
-      if Sequel::Database.respond_to?( :extension )
-        Sequel::Database.extension :newrelic_instrumentation
+      if Sequel::Database.respond_to?(:extension)
+        Sequel::Database.extension(:new_relic_instrumentation)
       else
-        NewRelic::Agent.logger.info "Detected Sequel version %s." % [ Sequel::VERSION ]
-        NewRelic::Agent.logger.info "Please see additional documentation: " +
-          "https://newrelic.com/docs/ruby/sequel-instrumentation"
+        NewRelic::Agent.logger.info('Detected Sequel version %s.' % [Sequel::VERSION])
+        NewRelic::Agent.logger.info('Please see additional documentation: ' +
+          'https://docs.newrelic.com/docs/apm/agents/ruby-agent/frameworks/sequel-instrumentation/')
       end
 
-      Sequel.synchronize{Sequel::DATABASES.dup}.each do |db|
-        db.extension :newrelic_instrumentation
+      Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|
+        db.extension(:new_relic_instrumentation)
       end
 
-      Sequel::Model.plugin :newrelic_instrumentation
-
+      Sequel::Model.plugin(:new_relic_instrumentation) if defined?(Sequel::Model)
     else
 
-      NewRelic::Agent.logger.info "Sequel instrumentation requires at least version 3.37.0."
+      NewRelic::Agent.logger.info('Sequel instrumentation requires at least version 3.37.0.')
 
     end
-
   end
-
 end

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

@@ -1,6 +1,6 @@
-# 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
 
 module NewRelic
   module Agent
@@ -9,22 +9,22 @@ module NewRelic
         extend self
 
         # Fallback if the product cannot be determined
-        DEFAULT_PRODUCT_NAME = "Sequel".freeze
+        DEFAULT_PRODUCT_NAME = 'Sequel'.freeze
 
         # A Sequel adapter is called an "adapter_scheme" and can be accessed from
         # the database:
         #
         #   DB.adapter_scheme
         PRODUCT_NAMES = {
-          :ibmdb => "IBMDB2",
-          :firebird => "Firebird",
-          :informix => "Informix",
-          :jdbc => "JDBC",
-          :mysql => "MySQL",
-          :mysql2 => "MySQL",
-          :oracle => "Oracle",
-          :postgres => "Postgres",
-          :sqlite => "SQLite"
+          :ibmdb => 'IBMDB2',
+          :firebird => 'Firebird',
+          :informix => 'Informix',
+          :jdbc => 'JDBC',
+          :mysql => 'MySQL',
+          :mysql2 => 'MySQL',
+          :oracle => 'Oracle',
+          :postgres => 'Postgres',
+          :sqlite => 'SQLite'
         }.freeze
 
         def product_name_from_adapter(adapter)
@@ -33,4 +33,4 @@ module NewRelic
       end
     end
   end
-end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/client.rb

@@ -0,0 +1,24 @@
+# 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::Sidekiq
+  class Client
+    include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+    INSTRUMENTATION_NAME = 'SidekiqClient'
+
+    def call(_worker_class, job, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+      yield
+    end
+
+    def distributed_tracing_headers
+      headers = {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+      headers
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/extensions/delayed_class.rb

@@ -0,0 +1,30 @@
+# 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
+
+# TODO: remove this class once Sidekiq v6 is no longer supported.
+#       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
+#       were removed entirely in Sidekiq 7.
+#
+#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       of the removal, which includes mentions of alternatives
+if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
+  class Sidekiq::Extensions::DelayedClass
+    def newrelic_trace_args(msg, queue)
+      (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
+        YAML.unsafe_load(msg['args'][0])
+      else
+        YAML.load(msg['args'][0])
+      end
+
+      {
+        :name => method_name,
+        :class_name => target.name,
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    rescue => e
+      NewRelic::Agent.logger.error('Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass', e)
+      NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/server.rb

@@ -0,0 +1,60 @@
+# 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::Sidekiq
+  class Server
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+    ATTRIBUTE_BASE_NAMESPACE = 'sidekiq.args'
+    ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+    ATTRIBUTE_JOB_NAMESPACE = :"job.#{ATTRIBUTE_BASE_NAMESPACE}"
+    INSTRUMENTATION_NAME = 'SidekiqServer'
+
+    # Client middleware has additional parameters, and our tests use the
+    # middleware client-side to work inline.
+    def call(worker, msg, queue, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      trace_args = if worker.respond_to?(:newrelic_trace_args)
+        worker.newrelic_trace_args(msg, queue)
+      else
+        self.class.default_trace_args(msg)
+      end
+      trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
+
+      perform_action_with_newrelic_trace(trace_args) do
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
+          NewRelic::Agent::AttributePreFiltering.pre_filter(msg['args'], self.class.nr_attribute_options),
+          ATTRIBUTE_JOB_NAMESPACE,
+          NewRelic::Agent::AttributeFilter::DST_NONE
+        )
+
+        if ::NewRelic::Agent.config[:'distributed_tracing.enabled'] && trace_headers&.any?
+          ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, 'Other')
+        end
+
+        yield
+      end
+    end
+
+    def self.default_trace_args(msg)
+      {
+        :name => 'perform',
+        :class_name => msg['class'],
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    end
+
+    def self.nr_attribute_options
+      @nr_attribute_options ||= begin
+        ATTRIBUTE_FILTER_TYPES.each_with_object({}) do |type, opts|
+          pattern =
+            NewRelic::Agent::AttributePreFiltering.formulate_regexp_union(:"#{ATTRIBUTE_BASE_NAMESPACE}.#{type}")
+          opts[type] = pattern if pattern
+        end.merge(attribute_namespace: ATTRIBUTE_JOB_NAMESPACE)
+      end
+    end
+  end
+end

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

@@ -1,66 +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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'sidekiq/client'
+require_relative 'sidekiq/server'
+require_relative 'sidekiq/extensions/delayed_class'
 
 DependencyDetection.defer do
   @name = :sidekiq
 
   depends_on do
-    defined?(::Sidekiq) && !NewRelic::Agent.config[:disable_sidekiq]
+    defined?(Sidekiq) && !NewRelic::Agent.config[:disable_sidekiq]
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Sidekiq instrumentation'
+    NewRelic::Agent.logger.info('Installing Sidekiq instrumentation')
   end
 
   executes do
-    class NewRelic::SidekiqInstrumentation
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-      # Client middleware has additional parameters, and our tests use the
-      # middleware client-side to work inline.
-      def call(worker, msg, queue, *_)
-        trace_args = if worker.respond_to?(:newrelic_trace_args)
-          worker.newrelic_trace_args(msg, queue)
-        else
-          self.class.default_trace_args(msg)
-        end
-
-        perform_action_with_newrelic_trace(trace_args) do
-          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-            NewRelic::Agent::AttributeFilter::DST_NONE)
-
-          yield
-        end
-      end
-
-      def self.default_trace_args(msg)
-        {
-          :name => 'perform',
-          :class_name => msg['class'],
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      end
-    end
-
-    class Sidekiq::Extensions::DelayedClass
-      def newrelic_trace_args(msg, queue)
-        (target, method_name, _args) = YAML.load(msg['args'][0])
-        {
-          :name => method_name,
-          :class_name => target.name,
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      rescue => e
-        NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
-        NewRelic::SidekiqInstrumentation.default_trace_args(msg)
+    Sidekiq.configure_client do |config|
+      config.client_middleware do |chain|
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
     end
 
     Sidekiq.configure_server do |config|
+      config.client_middleware do |chain|
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
+      end
       config.server_middleware do |chain|
-        chain.add NewRelic::SidekiqInstrumentation
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
+      end
+
+      if config.respond_to?(:error_handlers)
+        # Sidekiq 3.0.0 - 7.1.4 expect error_handlers to have 2 arguments
+        # Sidekiq 7.1.5+ expect error_handlers to have 3 arguments
+        config.error_handlers << proc do |error, _ctx, *_|
+          NewRelic::Agent.notice_error(error)
+        end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated ' \
+      'and will be dropped entirely in a future major New Relic Ruby agent release.' \
+      'Please upgrade your Sidekiq version to continue receiving full support. '
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sidekiq_version,
+      deprecation_msg
+    )
+  end
 end