appsignal 4.10.0-java → 5.0.0.rc.1-java

data/lib/appsignal/event_formatter/active_job/perform_formatter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class EventFormatter
+    # @!visibility private
+    module ActiveJob
+      # Active Job reports the job it is running as a `perform.active_job`
+      # notification. The job's own transaction already carries its title, so
+      # this formatter only describes the event as the work of performing a
+      # job.
+      class PerformFormatter < Appsignal::EventFormatter
+        PERFORM_ATTRIBUTES =
+          Appsignal::OpenTelemetry::Messaging.perform_attributes("active_job").freeze
+
+        def opentelemetry_attributes(payload)
+          PERFORM_ATTRIBUTES.merge(
+            { "messaging.destination.name" => queue_name(payload) }.compact
+          )
+        end
+
+        # The queue the job being performed is on, which the notification
+        # carries as the job itself.
+        def queue_name(payload)
+          job = payload[:job]
+          job.queue_name if job.respond_to?(:queue_name)
+        end
+      end
+    end
+  end
+end
+
+Appsignal::EventFormatter.register(
+  "perform.active_job",
+  Appsignal::EventFormatter::ActiveJob::PerformFormatter
+)

data/lib/appsignal/event_formatter/active_record/sql_formatter.rb

@@ -5,6 +5,25 @@ module Appsignal
     # @!visibility private
     module ActiveRecord
       class SqlFormatter < Appsignal::EventFormatter
+        # A query is an outgoing call to a datastore.
+        def opentelemetry_kind
+          :client
+        end
+
+        # The payload carries the connection the query ran on (Rails 6.0+),
+        # whose `adapter_name` is each adapter's own name for itself, such as
+        # `"PostgreSQL"` or `"Mysql2"`. A name the mapping does not recognise
+        # is left to the SQL sentinel, same as an adapter this gem has never
+        # heard of.
+        def opentelemetry_attributes(payload)
+          name = Appsignal::OpenTelemetry::SqlDbSystem.name_for_active_record(
+            payload[:connection]&.adapter_name
+          )
+          return unless name
+
+          { "db.system.name" => name }
+        end
+
         def format(payload)
           [payload[:name], payload[:sql], SQL_BODY_FORMAT]
         end

data/lib/appsignal/event_formatter/elastic_search/search_formatter.rb

@@ -5,6 +5,21 @@ module Appsignal
     # @!visibility private
     module ElasticSearch
       class SearchFormatter < Appsignal::EventFormatter
+        # A search is an outgoing call to an Elasticsearch cluster.
+        def opentelemetry_kind
+          :client
+        end
+
+        def opentelemetry_attributes(payload)
+          {
+            "db.system.name" => "elasticsearch",
+            # This notification is only emitted for a search, so that is the
+            # operation every one of these spans describes.
+            "db.operation.name" => "search",
+            "db.collection.name" => search_index(payload)
+          }.compact
+        end
+
         def format(payload)
           [
             "#{payload[:name]}: #{payload[:klass]}",
@@ -12,6 +27,18 @@ module Appsignal
           ]
         end
 
+        # The index a search ran against, which the notification carries in the
+        # search it describes. A search that names more than one index, or none
+        # at all, is left without this attribute rather than described with a
+        # value that is not an index name.
+        def search_index(payload)
+          search = payload[:search]
+          return unless search.respond_to?(:[])
+
+          index = search[:index]
+          index if index.is_a?(String)
+        end
+
         def sanitized_search(search)
           return unless search.is_a?(Hash)
 

data/lib/appsignal/event_formatter/recorded_elsewhere.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Appsignal
+  class EventFormatter
+    # Registered for an event that a dedicated AppSignal integration already
+    # records with richer semantics. The generic instrumentation paths ask the
+    # registry whether to record an event, so registering this for an event
+    # name is how that integration claims it.
+    #
+    # @!visibility private
+    class RecordedElsewhere < Appsignal::EventFormatter
+      def record?
+        false
+      end
+    end
+  end
+end

data/lib/appsignal/event_formatter/rom/sql_formatter.rb

@@ -5,6 +5,18 @@ module Appsignal
     # @!visibility private
     module Rom
       class SqlFormatter < Appsignal::EventFormatter
+        # These events arrive over dry-monitor, which is a notification bus
+        # rather than a library that queries a database. ROM is what emits
+        # them, so that is what the scope names.
+        def opentelemetry_scope
+          ["appsignal-ruby/rom", Appsignal::VERSION]
+        end
+
+        # A query is an outgoing call to a datastore.
+        def opentelemetry_kind
+          :client
+        end
+
         # dry-monitor reports an event under an id rather than a name, so the
         # first value here names the event. Naming it after ROM keeps every ROM
         # query in one group.
@@ -17,6 +29,18 @@ module Appsignal
         def format(payload)
           ["query.rom", payload[:query], SQL_BODY_FORMAT]
         end
+
+        # The payload's `name` is Sequel's `database_type` symbol for the
+        # database ROM is talking to, so this uses Sequel's own lookup
+        # rather than a coincidentally similar one. A symbol the mapping does
+        # not recognise is left to the SQL sentinel, same as an engine this
+        # gem has never heard of.
+        def opentelemetry_attributes(payload)
+          name = Appsignal::OpenTelemetry::SqlDbSystem.name_for_sequel(payload[:name])
+          return unless name
+
+          { "db.system.name" => name }
+        end
       end
     end
   end

data/lib/appsignal/event_formatter/sequel/sql_formatter.rb

@@ -10,6 +10,11 @@ module Appsignal
       # formatter the sequel-rails events are recorded without the SQL query
       # that's being executed.
       class SqlFormatter < Appsignal::EventFormatter
+        # A query is an outgoing call to a datastore.
+        def opentelemetry_kind
+          :client
+        end
+
         def format(payload)
           [payload[:name].to_s, payload[:sql], SQL_BODY_FORMAT]
         end

data/lib/appsignal/event_formatter/view_component/render_formatter.rb

@@ -7,11 +7,28 @@ module Appsignal
       class RenderFormatter < Appsignal::EventFormatter
         BLANK = ""
 
+        def opentelemetry_attributes(_payload)
+          Appsignal::OpenTelemetry::Rendering.attributes
+        end
+
         def format(payload)
+          # The body is the component's path made relative to the application's
+          # root, so a component rendered outside an application gets no title
+          # and no body.
+          return unless root_path
+
           [payload[:name], payload[:identifier].sub(root_path, BLANK)]
         end
 
+        # The application's root, which a component's path is made relative to.
+        #
+        # Whether there is an application is decided here, when the event is
+        # formatted, rather than when this file is loaded. AppSignal can be
+        # required before Rails is, and deciding it at load time would leave
+        # every component render in the application without a title.
         def root_path
+          return unless defined?(Rails)
+
           @root_path ||= "#{Rails.root}/"
         end
       end
@@ -19,13 +36,7 @@ module Appsignal
   end
 end
 
-if defined?(Rails)
-  Appsignal::EventFormatter.register(
-    "render.view_component",
-    Appsignal::EventFormatter::ViewComponent::RenderFormatter
-  )
-  Appsignal::EventFormatter.register(
-    "!render.view_component",
-    Appsignal::EventFormatter::ViewComponent::RenderFormatter
-  )
-end
+Appsignal::EventFormatter.register(
+  "render.view_component",
+  Appsignal::EventFormatter::ViewComponent::RenderFormatter
+)

data/lib/appsignal/event_formatter.rb

@@ -102,8 +102,77 @@ module Appsignal
         formatter&.format(payload)
       end
 
+      # The OpenTelemetry span kind for an event, which its formatter can
+      # declare. An event with no formatter, or whose formatter declares
+      # nothing, has no kind of its own and falls back to the default.
+      #
+      # A formatter written against the documented interface only implements
+      # `format`, so ask whether this one answers to the method at all rather
+      # than assuming every formatter does.
+      #
+      # @!visibility private
+      def opentelemetry_kind(name)
+        formatter = formatter_for(name)
+        return unless formatter.respond_to?(:opentelemetry_kind)
+
+        formatter.opentelemetry_kind
+      end
+
+      # The OpenTelemetry attributes describing an event, which its formatter
+      # can build from the event's payload. An event with no formatter, or
+      # whose formatter describes nothing, gets no attributes of its own.
+      #
+      # @!visibility private
+      def opentelemetry_attributes(name, payload)
+        formatter = formatter_for(name)
+        return unless formatter.respond_to?(:opentelemetry_attributes)
+
+        formatter.opentelemetry_attributes(payload)
+      end
+
+      # The OpenTelemetry instrumentation scope for an event, which its
+      # formatter can declare. It names the library the instrumentation is for,
+      # which is not always the library the event arrived through.
+      #
+      # An event with no formatter, or whose formatter declares nothing, is
+      # left to the scope the recording path derives for it.
+      #
+      # @!visibility private
+      def opentelemetry_scope(name)
+        formatter = formatter_for(name)
+        return unless formatter.respond_to?(:opentelemetry_scope)
+
+        formatter.opentelemetry_scope
+      end
+
+      # Whether the generic instrumentation paths should record an event, which
+      # its formatter can answer. An event a dedicated integration already
+      # records says no, so that it is not recorded a second time. An event
+      # with no formatter, or whose formatter says nothing, is recorded.
+      #
+      # @!visibility private
+      def record?(name)
+        formatter = formatter_for(name)
+        return true unless formatter.respond_to?(:record?)
+
+        formatter.record?
+      end
+
       private
 
+      # The formatter registered for an event name.
+      #
+      # A formatter is registered under whatever key was given to `register`,
+      # which is a String for every formatter in this gem. An event can be
+      # instrumented under a Symbol name, so fall back to the String form of it.
+      #
+      # `format` does not do this, on purpose. It has always looked a name up
+      # exactly as given, so making it match a Symbol name would start giving a
+      # title to events that have never had one.
+      def formatter_for(name)
+        formatters[name] || formatters[name.to_s]
+      end
+
       def initialize_formatter(name, formatter)
         format_method = formatter.instance_method(:format)
         if !format_method || format_method.arity != 1
@@ -123,6 +192,15 @@ module Appsignal
       end
     end
 
+    # The title and the body to show for an event, as an array. A formatter
+    # that is registered to describe an event in some other way, rather than to
+    # name it, does not have to implement this.
+    #
+    # @!visibility private
+    def format(_payload)
+      nil
+    end
+
     # @return [Integer]
     # @api public
     DEFAULT = 0

data/lib/appsignal/extension.rb

@@ -46,6 +46,10 @@ module Appsignal
         def data_array_new
           Appsignal::Extension::MockData.new
         end
+
+        def allocation_count
+          0
+        end
       end
     end