newrelic_rpm 9.5.0 → 9.8.0

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

@@ -0,0 +1,197 @@
+# 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'],
+        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/sidekiq.rb

@@ -33,7 +33,9 @@ DependencyDetection.defer do
       end
 
       if config.respond_to?(:error_handlers)
-        config.error_handlers << proc do |error, *_|
+        # 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

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

@@ -33,7 +33,7 @@ module NewRelic::Agent::Instrumentation
         set(:newrelic_ignores, Hash.new([])) if !respond_to?(:newrelic_ignores)
 
         # If we call an ignore without a route, it applies to the whole app
-        routes = ['*'] if routes.empty?
+        routes = [::NewRelic::ASTERISK] if routes.empty?
 
         settings.newrelic_ignores[type] += routes.map do |r|
           # Ugly sending to private Base#compile, but we want to mimic

data/lib/new_relic/agent/instrumentation/sinatra/transaction_namer.rb

@@ -25,14 +25,12 @@ module NewRelic
             transaction_name(::NewRelic::Agent::UNKNOWN_METRIC, request)
           end
 
-          ROOT = '/'.freeze
-
           def transaction_name(route_text, request)
             verb = http_verb(request)
 
             route_text = route_text.source if route_text.is_a?(Regexp)
             name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
-            name = ROOT if name.empty?
+            name = NewRelic::ROOT if name.empty?
             name = "#{verb} #{name}" unless verb.nil?
             name
           rescue => e

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

@@ -46,7 +46,7 @@ DependencyDetection.defer do
   executes do
     next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
 
-    deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
+    deprecation_msg = 'The Ruby agent is dropping support for Sinatra versions below 2.0.0 ' \
       'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
 
     NewRelic::Agent.logger.log_once(

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

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

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

@@ -0,0 +1,21 @@
+# 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 ViewComponent::Chain
+    def self.instrument!
+      ::ViewComponent::Base.class_eval do
+        include NewRelic::Agent::Instrumentation::ViewComponent
+
+        alias_method(:render_in_without_tracing, :render_in)
+
+        def render_in(*args)
+          render_in_with_tracing(*args) do
+            render_in_without_tracing(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/view_component/instrumentation.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 ViewComponent
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    def render_in_with_tracing(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      begin
+        segment = NewRelic::Agent::Tracer.start_segment(
+          name: metric_name(self.class.identifier, self.class.name)
+        )
+        yield
+      rescue => e
+        NewRelic::Agent.notice_error(e)
+        raise
+      ensure
+        segment&.finish
+      end
+    end
+
+    def metric_name(identifier, component)
+      "View/#{metric_path(identifier)}/#{component}"
+    end
+
+    def metric_path(identifier)
+      return 'component' unless identifier
+
+      if (parts = identifier.split('/')).size > 1
+        parts[-2..-1].join('/') # Get filepath by assuming the Rails' structure: app/components/home/example_component.rb
+      else
+        NewRelic::Agent::UNKNOWN_METRIC
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/view_component/prepend.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 ViewComponent::Prepend
+    include NewRelic::Agent::Instrumentation::ViewComponent
+
+    def render_in(*args)
+      render_in_with_tracing(*args) { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/view_component.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 'view_component/instrumentation'
+require_relative 'view_component/chain'
+require_relative 'view_component/prepend'
+
+DependencyDetection.defer do
+  named :view_component
+
+  depends_on do
+    defined?(ViewComponent) &&
+      ViewComponent::Base.method_defined?(:render_in)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ViewComponent instrumentation')
+
+    if use_prepend?
+      prepend_instrument ViewComponent::Base, NewRelic::Agent::Instrumentation::ViewComponent::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ViewComponent::Chain
+    end
+  end
+end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -2,7 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
 require 'json'
 require 'new_relic/agent/obfuscator'
 

data/lib/new_relic/agent/llm/chat_completion_message.rb

@@ -0,0 +1,25 @@
+# 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
+  module Agent
+    module Llm
+      class ChatCompletionMessage < LlmEvent
+        ATTRIBUTES = %i[content role sequence completion_id token_count
+          is_response]
+        EVENT_NAME = 'LlmChatCompletionMessage'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/chat_completion_summary.rb

@@ -0,0 +1,66 @@
+# 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 'response_headers'
+
+module NewRelic
+  module Agent
+    module Llm
+      class ChatCompletionSummary < LlmEvent
+        include ResponseHeaders
+
+        ATTRIBUTES = %i[request_max_tokens response_number_of_messages
+          request_model response_choices_finish_reason request_temperature
+          duration error]
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          response_number_of_messages: 'response.number_of_messages',
+          request_model: 'request.model',
+          response_choices_finish_reason: 'response.choices.finish_reason',
+          request_temperature: 'request.temperature'
+        }
+        ERROR_COMPLETION_ID = 'completion_id'
+        EVENT_NAME = 'LlmChatCompletionSummary'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ResponseHeaders::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def attribute_name_exceptions
+          # TODO: OLD RUBIES < 2.6
+          # Hash#merge accepts multiple arguments in 2.6
+          # Remove condition once support for Ruby <2.6 is dropped
+          if RUBY_VERSION >= '2.6.0'
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
+          else
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)
+          end
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+
+        def error_attributes(exception)
+          attrs = {ERROR_COMPLETION_ID => id}
+
+          error_attributes_from_response(exception, attrs)
+        end
+
+        private
+
+        def error_attributes_from_response(exception, attrs)
+          return attrs unless exception.respond_to?(:response)
+
+          attrs[ERROR_ATTRIBUTE_STATUS_CODE] = exception.response.dig(:status)
+          attrs[ERROR_ATTRIBUTE_CODE] = exception.response.dig(:body, ERROR_STRING, CODE_STRING)
+          attrs[ERROR_ATTRIBUTE_PARAM] = exception.response.dig(:body, ERROR_STRING, PARAM_STRING)
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/embedding.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
+  module Agent
+    module Llm
+      class Embedding < LlmEvent
+        include ResponseHeaders
+
+        ATTRIBUTES = %i[input request_model token_count duration error].freeze
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          request_model: 'request.model'
+        }.freeze
+        ERROR_EMBEDDING_ID = 'embedding_id'
+        EVENT_NAME = 'LlmEmbedding'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ResponseHeaders::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def attribute_name_exceptions
+          # TODO: OLD RUBIES < 2.6
+          # Hash#merge accepts multiple arguments in 2.6
+          # Remove condition once support for Ruby <2.6 is dropped
+          if RUBY_VERSION >= '2.6.0'
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
+          else
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)
+          end
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+
+        def error_attributes(exception)
+          attrs = {}
+          attrs[ERROR_EMBEDDING_ID] = id
+
+          error_attributes_from_response(exception, attrs)
+        end
+
+        private
+
+        def error_attributes_from_response(exception, attrs)
+          return attrs unless exception.respond_to?(:response)
+
+          attrs[ERROR_ATTRIBUTE_STATUS_CODE] = exception.response.dig(:status)
+          attrs[ERROR_ATTRIBUTE_CODE] = exception.response.dig(:body, ERROR_STRING, CODE_STRING)
+          attrs[ERROR_ATTRIBUTE_PARAM] = exception.response.dig(:body, ERROR_STRING, PARAM_STRING)
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/llm_event.rb

@@ -0,0 +1,95 @@
+# 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
+  module Agent
+    module Llm
+      class LlmEvent
+        # Every subclass must define its own ATTRIBUTES constant, an array of symbols representing
+        # that class's unique attributes
+        ATTRIBUTES = %i[id request_id span_id trace_id response_model vendor
+          ingest_source metadata]
+        # These attributes should not be passed as arguments to initialize and will be set by the agent
+        AGENT_DEFINED_ATTRIBUTES = %i[span_id trace_id ingest_source]
+        # Some attributes have names that can't be written as symbols used for metaprogramming.
+        # The ATTRIBUTE_NAME_EXCEPTIONS hash should use the symbolized version of the name as the key
+        # and the string version expected by the UI as the value.
+        ATTRIBUTE_NAME_EXCEPTIONS = {response_model: 'response.model'}
+        INGEST_SOURCE = 'Ruby'
+        ERROR_ATTRIBUTE_STATUS_CODE = 'http.statusCode'
+        ERROR_ATTRIBUTE_CODE = 'error.code'
+        ERROR_ATTRIBUTE_PARAM = 'error.param'
+        ERROR_STRING = 'error'
+        CODE_STRING = 'code'
+        PARAM_STRING = 'param'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def self.set_llm_agent_attribute_on_transaction
+          NewRelic::Agent::Transaction.add_agent_attribute(:llm, true, NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+        end
+
+        # This initialize method is used for all subclasses.
+        # It leverages the subclass's `attributes` method to iterate through
+        # all the attributes for that subclass.
+        # It assigns instance variables for all arguments passed to the method.
+        # It also assigns agent-defined attributes.
+        def initialize(opts = {})
+          (attributes - AGENT_DEFINED_ATTRIBUTES).each do |attr|
+            instance_variable_set(:"@#{attr}", opts[attr]) if opts.key?(attr)
+          end
+
+          @id = id || NewRelic::Agent::GuidGenerator.generate_guid
+          @span_id = NewRelic::Agent::Tracer.current_span_id
+          @trace_id = NewRelic::Agent::Tracer.current_trace_id
+          @ingest_source = INGEST_SOURCE
+        end
+
+        # All subclasses use event_attributes to get a full hash of all
+        # attributes and their values
+        def event_attributes
+          attributes_hash = attributes.each_with_object({}) do |attr, hash|
+            hash[replace_attr_with_string(attr)] = instance_variable_get(:"@#{attr}")
+          end
+          attributes_hash.merge!(metadata) && attributes_hash.delete(:metadata) if !metadata.nil?
+
+          attributes_hash
+        end
+
+        # Subclasses define an attributes method to concatenate attributes
+        # defined across their ancestors and other modules
+        def attributes
+          ATTRIBUTES
+        end
+
+        # Subclasses that record events will override this method
+        def event_name
+        end
+
+        # Some attribute names include periods, which aren't valid values for
+        # Ruby method names. This method returns a Hash with the key as the
+        # Ruby symbolized version of the attribute and the value as the
+        # period-delimited string expected upstream.
+        def attribute_name_exceptions
+          ATTRIBUTE_NAME_EXCEPTIONS
+        end
+
+        def record
+          NewRelic::Agent.record_custom_event(event_name, event_attributes)
+        end
+
+        # Subclasses that add attributes to noticed errors will override this method
+        def error_attributes(exception)
+          NewRelic::EMPTY_HASH
+        end
+
+        private
+
+        def replace_attr_with_string(attr)
+          attribute_name_exceptions.fetch(attr, attr)
+        end
+      end
+    end
+  end
+end