railwatch 0.1.4 → 0.2.0

data/app/models/railwatch/telemetry/bounded_gzip.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Railwatch
+  require "stringio"
+  require "zlib"
+
+  module Telemetry
+    # Reads untrusted gzip streams without ever asking zlib for more than the
+    # configured output ceiling. Ingest uses verify! without retaining the
+    # expanded bytes; read paths either return a bounded body or a bounded
+    # prefix for displays that can be truncated.
+    module BoundedGzip
+      READ_SIZE = 64.kilobytes
+
+      class Error < ArgumentError; end
+      class Malformed < Error; end
+      class TooLarge < Error; end
+      class SizeMismatch < Error; end
+
+      module_function
+
+      def decompress(compressed, max_bytes:)
+        output = String.new(encoding: Encoding::BINARY)
+        each_chunk(compressed, max_bytes: max_bytes) { |chunk| output << chunk }
+        output
+      end
+
+      # Returns [prefix, truncated?]. Once one byte beyond the display limit is
+      # observed, decompression stops instead of expanding the rest of a legacy
+      # gzip bomb merely to prove that it was truncated.
+      def decompress_capped(compressed, limit:)
+        output = String.new(encoding: Encoding::BINARY)
+        each_chunk(compressed, max_bytes: limit) { |chunk| output << chunk }
+        [ output, false ]
+      rescue TooLarge
+        [ output, true ]
+      end
+
+      def verify!(compressed, max_bytes:, expected_bytes:, utf8: false)
+        unless expected_bytes.is_a?(Integer) && expected_bytes.between?(0, max_bytes)
+          raise SizeMismatch, "declared size #{expected_bytes} exceeds the #{max_bytes} byte ceiling"
+        end
+
+        validator = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_16LE) if utf8
+        actual_bytes = each_chunk(compressed, max_bytes: max_bytes) do |chunk|
+          validator&.convert(chunk)
+        end
+        validator&.finish
+        return actual_bytes if actual_bytes == expected_bytes
+
+        raise SizeMismatch, "declared size #{expected_bytes} does not match decompressed size #{actual_bytes}"
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        raise Malformed, "decompressed content is not valid UTF-8"
+      end
+
+      def utf8!(text)
+        text.force_encoding(Encoding::UTF_8)
+        return text if text.valid_encoding?
+
+        raise Malformed, "decompressed content is not valid UTF-8"
+      end
+
+      def each_chunk(compressed, max_bytes:)
+        raise ArgumentError, "max_bytes must be non-negative" unless max_bytes.is_a?(Integer) && max_bytes >= 0
+
+        # StringIO and zlib operate on bytes regardless of the String's
+        # encoding. Avoid String#b here: it duplicates even an already-binary
+        # database BLOB, adding another full compressed-body allocation.
+        source = StringIO.new(compressed.to_s)
+        reader = Zlib::GzipReader.new(source)
+        total = 0
+        loop do
+          # The extra byte proves that a stream at the boundary has ended. Only
+          # the portion up to the ceiling is ever yielded or retained.
+          chunk = reader.readpartial([ READ_SIZE, max_bytes - total + 1 ].min)
+          if total + chunk.bytesize > max_bytes
+            remaining = max_bytes - total
+            yield chunk.byteslice(0, remaining) if remaining.positive?
+            raise TooLarge, "decompressed content exceeds #{max_bytes} bytes"
+          end
+
+          total += chunk.bytesize
+          yield chunk
+        end
+      rescue EOFError
+        # GzipReader reads ahead in fixed-size blocks. `unused` catches bytes
+        # already buffered past the gzip member; checking the underlying IO is
+        # also required when the member ends exactly on a read boundary and
+        # the trailing bytes have not been pulled into zlib's buffer yet.
+        raise Malformed, "gzip stream has trailing data" if reader.unused.present? || !source.eof?
+
+        total
+      rescue Zlib::Error => e
+        raise Malformed, "invalid gzip stream: #{e.message}"
+      ensure
+        reader&.close
+      end
+      private_class_method :each_chunk
+    end
+  end
+end

data/app/models/railwatch/telemetry/broadcast.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class Broadcast < TelemetryRecord
+      include Child
+
+      def timeline_label
+        stream.to_s.first(120)
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/cache_event.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class CacheEvent < TelemetryRecord
+      include Child
+
+      # `type` is the cache operation (hit, miss, write...), not STI.
+      self.inheritance_column = nil
+
+      def timeline_label
+        "#{type} #{key}".first(120)
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/child.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    # Shared behaviour for every record that belongs to an execution.
+    module Child
+      extend ActiveSupport::Concern
+
+      included do
+        scope :recent, -> { order(occurred_at: :desc) }
+        scope :between, ->(from, to) { where(occurred_at: from..to) }
+        scope :in_execution, ->(id) { where(execution_id: id) }
+      end
+
+      class_methods do
+        # One execution's rows for the waterfall; a child that resolves a
+        # column from elsewhere (Query) overrides this.
+        def timeline_scope(execution_id)
+          in_execution(execution_id)
+        end
+      end
+
+      def execution
+        Execution.find_by(execution_id: execution_id)
+      end
+
+      def duration_ms
+        respond_to?(:duration) && duration ? duration / 1000.0 : nil
+      end
+
+      # parent_start is passed in by Execution#timeline, which already holds
+      # the parent. Resolving it here instead cost one query per child row,
+      # so a waterfall of a few hundred logs and queries was a few hundred
+      # lookups of the same execution.
+      def timeline_entry(type, parent_start = nil)
+        parent_start ||= execution&.occurred_at
+        {
+          type: type.to_s.singularize,
+          id: id,
+          offset: parent_start ? ((occurred_at - parent_start) * 1000.0).round(3) : 0,
+          duration: duration_ms,
+          label: timeline_label,
+          stage: execution_stage,
+          source: (self[:source] if has_attribute?(:source))
+        }
+      end
+
+      def timeline_label
+        try(:name) || try(:key) || try(:message)&.first(120) || self.class.name.demodulize
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/cursor_page.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    # Stable keyset pagination for high-volume telemetry tables. Cursors are
+    # signed and bind their sort shape, so clients cannot inject columns or use
+    # a cursor from one resource/order against another.
+    class CursorPage
+      class InvalidCursor < ArgumentError; end
+
+      DEFAULT_LIMIT = 50
+      MAX_LIMIT = 200
+      ORDERS = {
+        recent: { column: :occurred_at, direction: :desc, type: :time },
+        slowest: { column: :duration, direction: :desc, type: :integer }
+      }.freeze
+
+      def self.call(scope, cursor: nil, limit: nil, order: :recent, context: nil)
+        new(scope, cursor: cursor, limit: limit, order: order, context: context).call
+      end
+
+      def initialize(scope, cursor:, limit:, order:, context:)
+        @scope = scope
+        @cursor = cursor
+        parsed_limit = limit.to_i
+        parsed_limit = DEFAULT_LIMIT unless parsed_limit.positive?
+        @limit = [ parsed_limit, MAX_LIMIT ].min
+        @order_name = order.to_sym
+        @order = ORDERS.fetch(@order_name)
+        @context = context.to_s
+      end
+
+      def call
+        relation = apply_cursor(scope)
+        relation = relation.from("#{relation.klass.quoted_table_name} INDEXED BY idx_queries_slowest") if force_slowest_index?
+        rows = relation.reorder(order[:column] => order[:direction], id: order[:direction]).limit(limit + 1).to_a
+        has_more = rows.length > limit
+        rows = rows.first(limit)
+        next_cursor = encode(rows.last) if has_more
+        [ rows, { limit: limit, next_cursor: next_cursor, has_more: has_more } ]
+      end
+
+      private
+
+      attr_reader :scope, :cursor, :limit, :order, :order_name, :context
+
+      # SQLite's planner costs the duration-led covering index higher than
+      # scanning the whole occurred_at window and sorting it, even with fresh
+      # statistics, so it never picks it on its own. Forced only for the one
+      # (model, order) pair the index exists for.
+      # INDEXED BY is SQLite's own syntax, and telemetry is a SQLite database
+      # in both the platform and an embedded install. Ask anyway, so pointing
+      # this at anything else degrades to the planner's own choice rather
+      # than a syntax error on every page load.
+      def force_slowest_index?
+        order_name == :slowest && scope.klass == Telemetry::Query &&
+          scope.klass.connection.adapter_name.match?(/sqlite/i)
+      end
+
+      def apply_cursor(relation)
+        values = decode
+        return relation unless values
+
+        column = relation.klass.arel_table[order[:column]]
+        id = relation.klass.arel_table[:id]
+        comparator = order[:direction] == :desc ? :lt : :gt
+        relation.where(column.public_send(comparator, values[:value])
+          .or(column.eq(values[:value]).and(id.public_send(comparator, values[:id]))))
+      end
+
+      def encode(row)
+        return unless row
+        value = row.public_send(order[:column])
+        value = value.iso8601(6) if order[:type] == :time
+        # The page size is deliberately not bound: changing it mid-scroll must
+        # not hard-fail. The cursor is a stable position, not a security
+        # boundary -- the scope it is applied to is already tenant-scoped here.
+        verifier.generate({ v: 1, model: scope.klass.name, order: order_name,
+                           context: context, value: value, id: row.id })
+      end
+
+      def decode
+        return if cursor.blank?
+        payload = verifier.verify(cursor.to_s).symbolize_keys
+        valid_shape = payload[:v] == 1 && payload[:model] == scope.klass.name &&
+          payload[:order].to_s == order_name.to_s && payload[:context] == context
+        raise InvalidCursor, "invalid telemetry cursor" unless valid_shape
+        value = order[:type] == :time ? Time.iso8601(payload[:value].to_s) : Integer(payload[:value].to_s, 10)
+        { value: value, id: Integer(payload[:id].to_s, 10) }
+      rescue ActiveSupport::MessageVerifier::InvalidSignature, ArgumentError, TypeError
+        raise InvalidCursor, "invalid telemetry cursor"
+      end
+
+      def verifier
+        Rails.application.message_verifier("telemetry_cursor")
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/deprecation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class Deprecation < TelemetryRecord
+      include Child
+
+      def timeline_label
+        message.to_s.first(120)
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/enqueued_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class EnqueuedJob < TelemetryRecord
+      include Child
+
+      def timeline_label
+        name.to_s.first(120)
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/exception.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class Exception < TelemetryRecord
+      include Child
+
+      self.table_name = "exceptions"
+
+      scope :unhandled, -> { where(handled: false) }
+
+      def timeline_label
+        "#{class_name}: #{message.to_s.first(100)}"
+      end
+
+      def app_frames
+        frames.select { |f| f["in_app"] }
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/execution.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    # A request, job attempt, scheduled task, command, or channel action. The parent of
+    # every other telemetry row via execution_id.
+    class Execution < TelemetryRecord
+      KINDS = %w[request job_attempt scheduled_task command channel_action].freeze
+
+      scope :of_kind, ->(kind) { where(kind: kind) }
+      scope :requests, -> { where(kind: "request") }
+      scope :jobs, -> { where(kind: "job_attempt") }
+      scope :scheduled, -> { where(kind: "scheduled_task") }
+      scope :commands, -> { where(kind: "command") }
+      scope :channels, -> { where(kind: "channel_action") }
+      scope :recent, -> { order(occurred_at: :desc) }
+      scope :between, ->(from, to) { where(occurred_at: from..to) }
+      scope :failed, -> { where("status >= 500 OR outcome = 'failed'") }
+
+      # Servers that reported an execution since `time`. Asked once per kind:
+      # there is no index led by occurred_at alone, so the obvious
+      # `where(occurred_at: time..).distinct.pluck(:server)` scans the whole
+      # table -- 15 to 26 seconds every five minutes on the platform's own
+      # 500k-row tenant, from SilentHostCheckJob -- while (kind, occurred_at)
+      # seeks straight to the window for each of the five kinds.
+      def self.servers_since(time)
+        KINDS.flat_map { |kind| where(kind: kind, occurred_at: time..).distinct.pluck(:server) }.uniq
+      end
+
+      # The schedule string each task key last ran with, in one query: the
+      # newest scheduled_task row per key carries it in detail. The scheduled
+      # tasks page and CheckScheduledTasksJob both used to look it up per key.
+      def self.latest_schedules(keys)
+        return {} if keys.empty?
+        latest = scheduled.where(task_key: keys).group(:task_key).select(:task_key, Arel.sql("MAX(id) AS id"))
+        scheduled.where(id: latest.map(&:id))
+          .pluck(:task_key, Arel.sql("json_extract(detail, '$.schedule')")).to_h
+      end
+
+      CHILDREN = {
+        queries: Query, exceptions: Exception, cache_events: CacheEvent, mails: Mail,
+        broadcasts: Broadcast, outgoing_requests: OutgoingRequest, storage_ops: StorageOp,
+        view_renders: ViewRender, logs: Log, enqueued_jobs: EnqueuedJob, transactions: Transaction,
+        notifications: Notification, spans: Span, profiles: Profile, attachments: Attachment,
+        llm_calls: LlmCall
+      }.freeze
+
+      CHILDREN.each do |name, klass|
+        define_method(name) { klass.where(execution_id: execution_id) }
+      end
+
+      # All children merged and ordered for the waterfall timeline.
+      def timeline
+        CHILDREN.flat_map { |name, klass| klass.timeline_scope(execution_id).map { |r| r.timeline_entry(name, occurred_at) } }
+                .sort_by { |e| e[:offset] }
+      end
+
+      def failed?
+        (status && status >= 500) || outcome == "failed"
+      end
+
+      def duration_ms
+        duration / 1000.0
+      end
+
+      def children_count
+        counters.values.sum
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/health_sample.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    # Periodic Puma / Solid Queue health sample from one process: thread pool
+    # utilisation, socket backlog, connection pool pressure, queue depth and
+    # the age of the oldest ready job.
+    class HealthSample < TelemetryRecord
+      # The gem reports every 15s, so a process that has not sampled in ten
+      # minutes is gone rather than idle.
+      LIVE_WINDOW = 10.minutes
+      BUCKET = 5.minutes
+
+      scope :recent, -> { order(sampled_at: :desc) }
+      scope :between, ->(from, to) { where(sampled_at: from..to) }
+
+      # The newest sample from each (server, pid) pair seen since `time`: one
+      # row per process still reporting.
+      def self.live(time = LIVE_WINDOW.ago)
+        where(id: where(sampled_at: time..).group(:server, :pid).select(Arel.sql("MAX(id)"))).order(:server, :pid)
+      end
+
+      # Health over the window, one point per BUCKET: thread utilisation is a
+      # percentage averaged across the processes that sampled into the bucket,
+      # backlog is summed across them, and the queue figures are the worst
+      # seen (any process's reading covers the whole queue).
+      def self.series(from, to, bucket: BUCKET)
+        slice = bucket_expression(bucket)
+        between(from, to).group(slice).order(slice)
+          .pluck(slice,
+                 Arel.sql("AVG(CASE WHEN threads_max > 0 THEN threads_busy * 100.0 / threads_max END)"),
+                 Arel.sql("SUM(backlog)"), Arel.sql("MAX(queue_depth)"), Arel.sql("MAX(queue_latency)"))
+          .map do |t, utilisation, backlog, depth, latency|
+            { t: t, utilisation: utilisation.to_f.round(1), backlog: backlog.to_i,
+             queue_depth: depth.to_i, queue_latency: (latency.to_i / 1000.0).round(1) }
+          end
+      end
+
+      # Deepest depth reported for each queue across `samples`, most backed up
+      # first. Every worker reports the same shared queue, so the readings are
+      # merged with max, not summed.
+      def self.queue_depths(samples)
+        depths = samples.each_with_object({}) do |sample, out|
+          # A process without a job backend reports queues: nil, not {}.
+          (sample.detail["queues"] || {}).each { |queue, depth| out[queue] = [ out[queue].to_i, depth.to_i ].max }
+        end
+        depths.sort_by { |_queue, depth| -depth }.map { |queue, depth| { queue: queue, depth: depth } }
+      end
+
+      # The recurring task keys Solid Queue is running, from the newest live
+      # sample that carries a manifest (the gem sends one on every health
+      # sample). nil when no live process has reported one: an older gem, or
+      # nothing alive to ask.
+      def self.recurring_task_keys(since: LIVE_WINDOW.ago)
+        manifest = where(sampled_at: since..).where("json_extract(detail, '$.recurring_tasks') IS NOT NULL")
+          .recent.pick(Arel.sql("json_extract(detail, '$.recurring_tasks')"))
+        manifest && JSON.parse(manifest).keys
+      end
+
+      def self.bucket_expression(bucket)
+        seconds = bucket.to_i
+        Arel.sql("strftime('%Y-%m-%dT%H:%M:00Z', (strftime('%s', sampled_at) / #{seconds}) * #{seconds}, 'unixepoch')")
+      end
+      private_class_method :bucket_expression
+
+      def thread_utilisation
+        return nil if threads_max.to_i.zero?
+        threads_busy.to_f / threads_max
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/ingest_batch.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    # One row per batch written into the telemetry database. In embedded mode
+    # it is also the delivery ledger: `batch_id` is the reporter's stable id
+    # for the batch (unique, so a replay is a no-op) and `followups` is the
+    # work the batch still owes outside its own transaction, nil once done.
+    class IngestBatch < TelemetryRecord
+      scope :recent, -> { order(received_at: :desc) }
+      scope :with_pending_followups, -> { where.not(followups: nil).order(:received_at) }
+
+      def self.committed(batch_id)
+        batch_id.present? ? find_by(batch_id: batch_id) : nil
+      end
+
+      # Runs the follow-ups a batch left behind and clears them. Safe to run
+      # more than once: the grouping commits a FollowupReceipt per (batch,
+      # group) in the railwatch database together with the occurrence count,
+      # so a second run finds the receipts and counts nothing. Clearing the
+      # outbox here is only what stops the maintenance drain from picking the
+      # row up again; it is not what makes the replay safe.
+      def drain_followups!(environment)
+        work = followups || {}
+        ids = Array(work["group_exception_ids"])
+        GroupExceptionsJob.new.perform(environment, ids, batch_id: batch_id) if ids.any?
+        update_columns(followups: nil)
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/llm_call.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class LlmCall < TelemetryRecord
+      include Child
+
+      # A tool invocation is a call in the same pipeline, so it shares this
+      # table; it just has a name where a model call has a model.
+      TOOL = "tool"
+
+      scope :models, -> { where.not(operation: TOOL) }
+      scope :tools, -> { where(operation: TOOL) }
+
+      NANOS_PER_DOLLAR = 1_000_000_000.0
+
+      # Dollars, or nil when the call is unpriced. Callers must render the
+      # difference: an unpriced call is not a free one.
+      def cost
+        cost_nanos && cost_nanos / NANOS_PER_DOLLAR
+      end
+
+      # What the app paid for, which is the count a bill is drawn from.
+      def total_tokens
+        [ input_tokens, output_tokens, cache_read_tokens, cache_write_tokens ].compact.sum
+      end
+
+      def timeline_label
+        tool? ? tool_name.to_s : "#{provider}/#{model}"
+      end
+
+      def tool?
+        operation == TOOL
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/log.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class Log < TelemetryRecord
+      include Child
+
+      # Wraps each hit inside a snippet. One character for both ends so the
+      # frontend can split on it and mark the odd-numbered pieces; U+001F is
+      # not something a log line can realistically contain.
+      SNIPPET_MARK = "\u001F"
+
+      # "quoted phrase" | -excluded | bare, in the order they were typed.
+      TERM = /-?"[^"]*"|\S+/
+
+      scope :fts, ->(text) {
+        next none if text.to_s.strip.empty?
+        next where("message LIKE ?", "%#{sanitize_sql_like(text)}%") unless fts_available?
+        match = match_expression(text)
+        match ? where("logs.id IN (SELECT rowid FROM logs_fts WHERE logs_fts MATCH ?)", match) : none
+      }
+
+      class << self
+        # Free text -> an FTS5 MATCH expression. Quoted phrases stay whole,
+        # every other word becomes a prefix token so "widg" finds "widgets",
+        # and a leading "-" excludes -- but only when something positive is
+        # left to exclude from, since FTS5's NOT needs a left operand. Every
+        # term is emitted as a quoted string, which is what keeps FTS5 syntax
+        # (NEAR, *, :, parens) inert instead of raising a "syntax error".
+        # Returns nil when the text has nothing searchable in it.
+        def match_expression(text)
+          terms = text.to_s.scan(TERM).filter_map { |term| parse_term(term) }
+          positive = terms.reject(&:first).map(&:last)
+          negative = terms.select(&:first).map(&:last)
+          if positive.empty?
+            positive = negative
+            negative = []
+          end
+          return nil if positive.empty?
+          [ positive.join(" "), *negative.map { |term| "NOT #{term}" } ].join(" ")
+        end
+
+        # id => message with SNIPPET_MARK around each hit, for the rows the
+        # page is about to render. Empty unless we actually ran an FTS query.
+        def fts_snippets(ids, text)
+          return {} if ids.empty? || !fts_available?
+          match = match_expression(text)
+          return {} if match.nil?
+          sql = sanitize_sql_array([ "SELECT rowid, snippet(logs_fts, 0, ?, ?, ?, 24) FROM logs_fts WHERE logs_fts MATCH ? AND rowid IN (?)",
+            SNIPPET_MARK, SNIPPET_MARK, "…", match, ids ])
+          connection.select_rows(sql).to_h
+        end
+
+        # Postgres telemetry databases (SCOPE.md keeps them supported) have no
+        # logs_fts, and neither does a database created before the index was
+        # added. Every telemetry database is built from the same schema, so
+        # this is a process-wide fact rather than a per-environment one.
+        def fts_available?
+          return @fts_available if defined?(@fts_available)
+          @fts_available = connection.adapter_name.match?(/sqlite/i) &&
+            connection.select_value("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'logs_fts'").present?
+        end
+
+        private
+
+        # "term" -> [negated?, fts5 term], or nil if there is nothing left of
+        # it once the quotes and the minus sign come off.
+        def parse_term(term)
+          negated = term.start_with?("-") && term.length > 1
+          body = negated ? term[1..] : term
+          phrase = body.start_with?('"') && body.end_with?('"') && body.length > 1
+          body = body[1..-2].to_s if phrase
+          return nil unless body.match?(/[[:alnum:]]/)
+          [ negated, phrase ? quote(body) : "#{quote(body)}*" ]
+        end
+
+        def quote(term) = %("#{term.gsub('"', '""')}")
+      end
+
+      def timeline_label
+        message.to_s.first(120)
+      end
+    end
+  end
+end

data/app/models/railwatch/telemetry/mail.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Railwatch
+  module Telemetry
+    class Mail < TelemetryRecord
+      include Child
+
+      def timeline_label
+        mailer.to_s.first(120)
+      end
+    end
+  end
+end