railwatch 0.3.7 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56eb44eab9d0988d36c517995ad2ec8d42971ed9af60e3cf4c419c5df926007f
-  data.tar.gz: 20f9bfed5d8044797a1e43b523668846b2b888756ff9fef59a1f54dc136d64c1
+  metadata.gz: 538efe4f9ba268dd88e694a7052542638a86d64f34978bffd45e5edb9e71dd18
+  data.tar.gz: 3f5d5b22228381e4f9d6657544c44fb3e337c754c9b7a9d683dada967d1592af
 SHA512:
-  metadata.gz: 8bbd22e4636c6c3ba58dfff0242d3553db415af9b90041b524634ae7b95e65a0ff52f6584c7d6c4c61aee12274e177b308d06040508db41ee8db0af81ff1ab0d
-  data.tar.gz: 398eea6fd06b824600b834f5da026f68b70fba6a5bcc1ec97c73995933ca9a8e569cca0d5135f27ee413563281bd91a941eb19ccb954f0b731cd25b2446ba86c
+  metadata.gz: 923dc66f9d7e94815affc41d5d0df65db1891a6e46b9462ab6dd2931989f60786149fe70142de5f451a1b1d3ff13a8c551fb8b2487b8bd93aade6e95d0ce3600
+  data.tar.gz: 5f1fc6b7a9e2afade92562883b6467b1ace633c1dcd85ef2d6cde7c6b72f53328922f6e4c7e8c47eb596af2662dcb5b4d09103d061dd4a718484d512ff766913

data/CHANGELOG.md

@@ -1,5 +1,63 @@
 # Changelog
 
+## 0.5.0 (2026-09-21)
+
+The telemetry layer the hosted platform runs is this gem's, not a copy. Everything
+Railwatch Cloud had improved in its fork comes home, and the two seams the platform
+needs are named.
+
+- **Chart bucket widths.** `Telemetry::Aggregations` offers `STEPS` (1m to 1d),
+  `default_step`, and `steps_for` a window; `series` takes a `step:` and reads raw
+  rows with exact per-bucket percentiles under an hour, rollups at an hour and up;
+  `fill` zero-fills quiet buckets. The dashboard shows a step picker beside the
+  window picker, and every series page, release health, tenants, processes, and
+  exceptions draw at the chosen step. Latency lines break over an empty bucket
+  instead of dropping to zero.
+- **One `Window`.** `Railwatch::Window` resolves `?window=` presets and custom
+  `?from=&to=` ranges, with the previous period for deltas; the controller concern
+  reads it instead of carrying the table.
+- **Rollup extras.** `Telemetry::Rollup.summarize` merges each type's `extra`
+  (LLM spend and tokens, cache hits and misses) the way `absorb!` does.
+- **LLM thresholds and anomaly rules.** `spend`, `tokens`, and `truncation_rate`
+  metrics on `llm_calls` and `llm_tools`; the form narrows metrics by kind and
+  shows the unit; `Threshold#format_value` prints dollars and percentages.
+- **`as_row`** on Execution, Log, Exception, and Query: the one row shape every
+  list surface shows. The commands page reads the exit code from `status`.
+- `Railwatch::TelemetryRecord` documents that the hosted platform tenants it, and
+  `docs/embedded.md` says what the platform is in terms of this engine.
+
+## 0.4.0 (2026-09-21)
+
+The gem is the one author of what goes over the wire and what runs in the
+browser. Anything that receives from it, Railwatch Cloud first, reads these
+from the gem instead of keeping a copy.
+
+- **One browser client.** The gem carried two: the install template wrote
+  the `railwatch_session` cookie that `Railwatch::Sessions` reads, while the
+  dashboard's own copy still wrote `lantern_session`, so every embedded
+  dashboard shipped a beacon whose sessions never stitched to their server
+  requests. There is one file now, `app/frontend/lib/railwatch.ts`, shipped
+  in the gem (`Railwatch.browser_client_path`): the dashboard bundle is built
+  from it, `railwatch:install` copies it, and a host with its own frontend
+  build imports it. A spec holds the cookie name to the regex.
+- **Shipped wire fixtures.** `lib/railwatch/wire_fixtures.json` holds one
+  record per type in `Railwatch::Record::VERSIONS`, produced by the gem's own
+  subscribers and middleware, stabilized, and checked in.
+  `Railwatch.wire_fixtures` loads it. A receiver tests its mapper against
+  these rather than hand-writing what it remembers the gem sending. The spec
+  that generates them fails when the file is stale; `rake
+  railwatch:wire_fixtures` regenerates it, and that diff is the review
+  surface for a wire change.
+- **Record versions are enforced.** Every record has carried a `v` since the
+  first release and no receiver read it. `Railwatch::Ingest::Mapper` now
+  refuses a record whose version is not the one this gem emits for its type,
+  by name (`log v2 is not v1`), on both the trusted embedded path and the
+  untrusted one. A shape change without a version bump is caught by the
+  fixture spec; a version bump the receiver has not shipped is refused
+  instead of misread.
+- `Railwatch::Transport::Http::HEADERS` names the delivery headers in one
+  place for the receiver to read.
+
 ## 0.3.7 (2026-09-20)
 
 - Stop a rake task or `rails runner` waiting on the network as it finishes.

data/app/controllers/railwatch/commands_controller.rb

@@ -5,7 +5,7 @@ module Railwatch
     def index
       rows = telemetry { Telemetry::Execution.commands.between(*window_range).recent.limit(200).to_a }
       render inertia: { commands: grouped("command", limit: 100),
-                        runs: rows.map { |r| { execution_id: r.execution_id, name: r.name, exit_code: r.status, duration: r.duration_ms.round(1), occurred_at: r.occurred_at, server: r.server, exception_preview: r.exception_preview } } }
+                        runs: rows.map(&:as_row) }
     end
 
     def show

data/app/controllers/railwatch/environment_scoped.rb

@@ -6,14 +6,13 @@ module Railwatch
   module EnvironmentScoped
     extend ActiveSupport::Concern
 
-    WINDOWS = { "1h" => 1.hour, "6h" => 6.hours, "24h" => 24.hours, "7d" => 7.days, "30d" => 30.days }.freeze
-    MAX_CUSTOM_RANGE = 90.days
-
     included do
       before_action :set_environment
       inertia_share environment: -> { environment_props }
-      inertia_share window: -> { window_key }
-      inertia_share range: -> { from, to = window_range; { from: from.iso8601(6), to: to.iso8601(6) } }
+      inertia_share window: -> { window.key }
+      inertia_share range: -> { window.to_h }
+      inertia_share step: -> { step_key }
+      inertia_share steps: -> { Telemetry::Aggregations.steps_for(*window_range) }
       inertia_share saved_views: -> { SavedView.props_for(environment, Viewer.user) }
     end
 
@@ -25,38 +24,19 @@ module Railwatch
       @environment = Environment.find(params[:environment_id] || Environment::ID)
     end
 
-    def window_key
-      custom_range ? "custom" : (WINDOWS.key?(params[:window].to_s) ? params[:window].to_s : "24h")
-    end
-
-    def window_range
-      return @window_range if defined?(@window_range)
-      @window_range = custom_range || begin
-        key = WINDOWS.key?(params[:window].to_s) ? params[:window].to_s : "24h"
-        to = Time.current
-        [ to - WINDOWS[key], to ]
-      end
+    def window
+      @window ||= Window.parse(window: params[:window], from: params[:from], to: params[:to])
     end
 
-    def custom_range
-      return @custom_range if defined?(@custom_range)
-      from = parse_time(params[:from])
-      to = from && (parse_time(params[:to]) || Time.current)
-      valid = from && to && to > from && (to - from) <= MAX_CUSTOM_RANGE
-      @custom_range = valid ? [ from, to ] : nil
-    end
-
-    def parse_time(value)
-      return nil if value.blank?
-      Time.zone.parse(value.to_s)
-    rescue ArgumentError, TypeError
-      nil
-    end
+    def window_range = window.range
 
-    def previous_window_range
+    # The chart bucket width: ?step= when it is one the window offers, else the
+    # window's default (a minute for an hour, an hour for a day, and so on).
+    def step_key
+      return @step_key if defined?(@step_key)
       from, to = window_range
-      span = to - from
-      [ from - span, from ]
+      offered = Telemetry::Aggregations.steps_for(from, to)
+      @step_key = offered.include?(params[:step].to_s) ? params[:step].to_s : Telemetry::Aggregations.default_step(from, to)
     end
 
     def telemetry(&block) = environment.with_telemetry(&block)
@@ -79,9 +59,11 @@ module Railwatch
       environment.deploys.between(*window_range).recent.limit(50).map { |d| { deploy: d.deploy, ref: d.short_ref, at: d.deployed_at } }
     end
 
-    def series(record_type, group_hash: nil, name: nil)
+    # Time-bucketed series for charts, one point per step_key across the
+    # window: [{t, count, errors, client_errors, avg, p50, p95, p99}]
+    def series(record_type, group_hash: nil)
       from, to = window_range
-      Telemetry::Aggregations.series(environment, record_type, from: from, to: to, group_hash: group_hash, name: name)
+      Telemetry::Aggregations.series(environment, record_type, from: from, to: to, group_hash: group_hash, step: step_key)
     end
 
     def grouped(record_type, limit: 100, order: nil, dir: nil)
@@ -91,7 +73,7 @@ module Railwatch
 
     def summary_with_delta(record_type, group_hash: nil)
       from, to = window_range
-      previous_from, previous_to = previous_window_range
+      previous_from, previous_to = window.previous.range
       Telemetry::Aggregations.summary_with_delta(environment, record_type, from: from, to: to,
                                                   previous_from: previous_from, previous_to: previous_to, group_hash: group_hash)
     end

data/app/controllers/railwatch/exceptions_controller.rb

@@ -38,16 +38,15 @@ module Railwatch
     # `errors` carries the unhandled count so the chart legend (handled /
     # unhandled) agrees with the Unhandled card above the table.
     def exception_series(from, to)
+      step = Telemetry::Aggregations::STEPS.fetch(step_key)
+      bucket = Telemetry::Aggregations.bucket_sql("occurred_at", step)
       buckets = Hash.new { |h, k| h[k] = { count: 0, errors: 0 } }
-      Telemetry::Exception.between(from, to)
-        .group(Arel.sql("strftime('%Y-%m-%dT%H:00:00Z', occurred_at)"), :handled)
-        .count
-        .each do |(bucket, handled), c|
-          buckets[bucket][:count] += c
-          buckets[bucket][:errors] += c unless handled
-        end
-      buckets.map { |bucket, b| { t: bucket, count: b[:count], errors: b[:errors], client_errors: 0, avg: 0, p50: 0, p95: 0, p99: 0 } }
-        .sort_by { |r| r[:t] }
+      Telemetry::Exception.between(from, to).group(bucket, :handled).count.each do |(b, handled), c|
+        buckets[b][:count] += c
+        buckets[b][:errors] += c unless handled
+      end
+      points = buckets.map { |b, c| { t: Time.at(b).utc, count: c[:count], errors: c[:errors], client_errors: 0, avg: nil, p50: nil, p95: nil, p99: nil } }
+      Telemetry::Aggregations.fill(points, from, to, step)
     end
     end
 end

data/app/controllers/railwatch/processes_controller.rb

@@ -6,7 +6,7 @@ module Railwatch
       live_since = Telemetry::HealthSample::LIVE_WINDOW.ago
       samples, series, queues, live_servers, processes = telemetry do
         live = Telemetry::HealthSample.live(live_since).to_a
-        [ live, Telemetry::HealthSample.series(*window_range), Telemetry::HealthSample.queue_depths(live),
+        [ live, Telemetry::HealthSample.series(*window_range, bucket: Telemetry::Aggregations::STEPS.fetch(step_key)), Telemetry::HealthSample.queue_depths(live),
           live.map(&:server) | Telemetry::Execution.servers_since(live_since),
           Telemetry::Process.recent.limit(200).to_a ]
       end

data/app/controllers/railwatch/releases_controller.rb

@@ -17,7 +17,7 @@ module Railwatch
       new_issues = new_issue_counts(deploys, to)
       summary, series, adoption, health = telemetry do
         [ Telemetry::ReleaseHealth.for_deploy(nil, from, to),
-          Telemetry::ReleaseHealth.series(nil, from, to),
+          Telemetry::ReleaseHealth.series(nil, from, to, step: step_key),
           Telemetry::ReleaseHealth.adoption(from, to),
           deploys.to_h { |d| [ d.deploy, Telemetry::ReleaseHealth.for_deploy(d.deploy, from, to) ] } ]
       end
@@ -37,7 +37,7 @@ module Railwatch
       data = telemetry do
         { summary: Telemetry::ReleaseHealth.for_deploy(release, from, to),
           previous_summary: previous && Telemetry::ReleaseHealth.for_deploy(previous.deploy, *previous.window),
-          series: Telemetry::ReleaseHealth.series(release, from, to),
+          series: Telemetry::ReleaseHealth.series(release, from, to, step: step_key),
           sessions: Telemetry::Session.where(deploy: release).recent.limit(SESSIONS_SHOWN).map { |s| session_row(s) } }
       end
       render inertia: data.merge(

data/app/controllers/railwatch/tenants_controller.rb

@@ -20,8 +20,8 @@ module Railwatch
       from, to = window_range
       data = telemetry do
         { tenant: tenant, summary: { current: Telemetry::Tenant.summary(tenant, from, to),
-                                    previous: Telemetry::Tenant.summary(tenant, *previous_window_range) },
-          series: Telemetry::Tenant.series(tenant, from, to), routes: Telemetry::Tenant.routes(tenant, from, to),
+                                    previous: Telemetry::Tenant.summary(tenant, *window.previous.range) },
+          series: Telemetry::Tenant.series(tenant, from, to, step: step_key), routes: Telemetry::Tenant.routes(tenant, from, to),
           jobs: Telemetry::Tenant.job_classes(tenant, from, to), exceptions: Telemetry::Tenant.exceptions(tenant, from, to),
           people: Telemetry::Tenant.people(tenant), recent_requests: Telemetry::Tenant.recent_requests(tenant, from, to) }
       end

data/app/controllers/railwatch/thresholds_controller.rb

@@ -8,7 +8,14 @@ module Railwatch
                         jobs: telemetry { Telemetry::Rollup.for_type("job_attempt").where("bucket > ?", 7.days.ago).distinct.pluck(:name).sort },
                         kinds: Threshold::TARGET_KINDS, metrics: Threshold::METRICS,
                         anomaly_rules: environment.anomaly_rules.order(:target_kind, :target).map { |r| r.slice(:id, :target_kind, :target, :metric, :deviation, :window_minutes, :baseline_days, :enabled, :last_fired_at).merge(description: r.description) },
-                        anomaly_target_kinds: AnomalyRule::TARGET_KINDS, anomaly_metrics: AnomalyRule::METRICS }
+                        # Spend and tokens only exist on llm_calls, so the form
+                        # narrows with the kind rather than offering a rule that
+                        # could never fire.
+                        metrics_for_kind: Threshold::TARGET_KINDS.index_with { |k| Threshold.metrics_for(k) },
+                        units: Threshold::UNITS,
+                        llm_models: telemetry { Telemetry::Rollup.for_type("llm_call").where("bucket > ?", 7.days.ago).distinct.pluck(:name).compact.sort },
+                        anomaly_target_kinds: AnomalyRule::TARGET_KINDS, anomaly_metrics: AnomalyRule::METRICS,
+                        anomaly_metrics_for_kind: AnomalyRule::TARGET_KINDS.index_with { |k| AnomalyRule.metrics_for(k) } }
     end
 
     def create

data/{lib/generators/railwatch/install/templates → app/frontend/lib}/railwatch.ts

@@ -77,7 +77,11 @@ const DEFAULT_IGNORE_ERRORS = [
   "ResizeObserver loop limit exceeded",
   "ResizeObserver loop completed with undelivered notifications",
 ]
-const DEFAULT_DENY_URLS = [/extensions\//i, /^chrome:\/\//i, /^moz-extension:\/\//i]
+const DEFAULT_DENY_URLS = [
+  /extensions\//i,
+  /^chrome:\/\//i,
+  /^moz-extension:\/\//i,
+]
 
 const SESSION_ID_KEY = "railwatch.session"
 const SESSION_STARTED_KEY = "railwatch.session.at"
@@ -128,10 +132,18 @@ function endpoint() {
 }
 
 function csrf() {
-  return document.querySelector<HTMLMetaElement>('meta[name="csrf-token"]')?.content ?? ""
+  return (
+    document.querySelector<HTMLMetaElement>('meta[name="csrf-token"]')
+      ?.content ?? ""
+  )
 }
 
-function post(payload: { visits: Visit[]; errors: JsError[]; session?: Session; tenant?: string }) {
+function post(payload: {
+  visits: Visit[]
+  errors: JsError[]
+  session?: Session
+  tenant?: string
+}) {
   const body = JSON.stringify(payload)
   const blob = new Blob([body], { type: "application/json" })
   if (navigator.sendBeacon?.(endpoint(), blob)) return
@@ -145,7 +157,12 @@ function post(payload: { visits: Visit[]; errors: JsError[]; session?: Session;
 
 function flush(ended = false) {
   if (queue.length === 0 && errors.length === 0 && !ended) return
-  post({ visits: queue.splice(0, queue.length), errors: errors.splice(0, errors.length), session: beat(ended), tenant: tenant() })
+  post({
+    visits: queue.splice(0, queue.length),
+    errors: errors.splice(0, errors.length),
+    session: beat(ended),
+    tenant: tenant(),
+  })
 }
 
 // The app's tenant resolver runs on the flush path, where a throw would cost
@@ -175,15 +192,23 @@ function startSession() {
   try {
     const existing = sessionStorage.getItem(SESSION_ID_KEY)
     const id = existing ?? randomId()
-    const startedAt = Number(sessionStorage.getItem(SESSION_STARTED_KEY)) || Date.now()
+    const startedAt =
+      Number(sessionStorage.getItem(SESSION_STARTED_KEY)) || Date.now()
     if (!existing) {
       sessionStorage.setItem(SESSION_ID_KEY, id)
       sessionStorage.setItem(SESSION_STARTED_KEY, String(startedAt))
     }
+    // Railwatch::Sessions::COOKIE reads this name to stitch server requests to the browser session.
     document.cookie = `railwatch_session=${id}; path=/; SameSite=Lax`
     session = { id, started_at: startedAt }
     // No duration on the first beat: that is what opens the session.
-    if (!existing) post({ visits: [], errors: [], session: { ...session }, tenant: tenant() })
+    if (!existing)
+      post({
+        visits: [],
+        errors: [],
+        session: { ...session },
+        tenant: tenant(),
+      })
   } catch {
     // sessionStorage is unavailable (private mode, storage disabled).
     // Everything else still reports; this tab just has no session.
@@ -213,7 +238,8 @@ function crumb(kind: Crumb["kind"], text: string) {
 // oldest entries until it fits the byte budget.
 function trail(): Crumb[] {
   const taken = crumbs.slice()
-  while (taken.length > 0 && JSON.stringify(taken).length > MAX_CRUMB_BYTES) taken.shift()
+  while (taken.length > 0 && JSON.stringify(taken).length > MAX_CRUMB_BYTES)
+    taken.shift()
   return taken
 }
 
@@ -223,16 +249,26 @@ function trail(): Crumb[] {
 function describeTarget(target: EventTarget | null): string {
   if (!(target instanceof Element)) return ""
   const id = target.id ? `#${target.id}` : ""
-  const className = typeof target.className === "string" ? target.className.trim() : ""
+  const className =
+    typeof target.className === "string" ? target.className.trim() : ""
   const classes = className ? `.${className.split(/\s+/).join(".")}` : ""
-  const text = target instanceof HTMLInputElement ? "" : (target.textContent ?? "").trim().replace(/\s+/g, " ").slice(0, 80)
+  const text =
+    target instanceof HTMLInputElement
+      ? ""
+      : (target.textContent ?? "").trim().replace(/\s+/g, " ").slice(0, 80)
   return `${target.tagName.toLowerCase()}${id}${classes}${text ? ` "${text}"` : ""}`
 }
 
 function startBreadcrumbs() {
-  document.addEventListener("click", (event) => crumb("click", describeTarget(event.target)), true)
+  document.addEventListener(
+    "click",
+    (event) => crumb("click", describeTarget(event.target)),
+    true,
+  )
   for (const level of ["error", "warn"] as const) {
-    const original = console[level].bind(console) as (...args: unknown[]) => void
+    const original = console[level].bind(console) as (
+      ...args: unknown[]
+    ) => void
     console[level] = (...args: unknown[]) => {
       crumb("console", `${level}: ${args.map(stringify).join(" ")}`)
       original(...args)
@@ -267,14 +303,26 @@ function topFrameUrl(stack: string): string | undefined {
 // the app's own code at all -- an extension, an injected widget, a tag
 // manager. None of those are anything this app can fix.
 function ignored(message: string, stack?: string): boolean {
-  if (ignoreErrors.some((pattern) => (typeof pattern === "string" ? message.includes(pattern) : pattern.test(message)))) return true
+  if (
+    ignoreErrors.some((pattern) =>
+      typeof pattern === "string"
+        ? message.includes(pattern)
+        : pattern.test(message),
+    )
+  )
+    return true
   const url = stack ? topFrameUrl(stack) : undefined
   if (!url) return false
   if (denyUrls.some((pattern) => pattern.test(url))) return true
   return !url.startsWith("/") && !url.startsWith(`${location.origin}/`)
 }
 
-function capture(name: string, message: string, stack?: string, context?: Record<string, unknown>) {
+function capture(
+  name: string,
+  message: string,
+  stack?: string,
+  context?: Record<string, unknown>,
+) {
   if (errors.length >= MAX_ERRORS) return
   if (ignored(message, stack)) return
   const breadcrumbs = trail()
@@ -292,15 +340,28 @@ function capture(name: string, message: string, stack?: string, context?: Record
   // Deduped within the flush, not across the page's life: a render loop
   // throws the same error every retry. (Inertia's re-rejection of a failed
   // request is dropped by identity in the rejection handler instead.)
-  if (errors.some((e) => e.name === error.name && e.message === error.message && e.stack === error.stack)) return
+  if (
+    errors.some(
+      (e) =>
+        e.name === error.name &&
+        e.message === error.message &&
+        e.stack === error.stack,
+    )
+  )
+    return
   errors.push(error)
 }
 
 // Anything at all can be thrown or rejected in JavaScript, not just an
 // Error. A non-Error value is reported under `fallback` with whatever it
 // stringifies to as the message.
-function captureValue(value: unknown, fallback: string, context?: Record<string, unknown>) {
-  if (value instanceof Error) capture(value.name, value.message, value.stack, context)
+function captureValue(
+  value: unknown,
+  fallback: string,
+  context?: Record<string, unknown>,
+) {
+  if (value instanceof Error)
+    capture(value.name, value.message, value.stack, context)
   else capture(fallback, stringify(value), undefined, context)
 }
 
@@ -336,7 +397,11 @@ export function railwatchRootOptions(): {
   onUncaughtError: (error: unknown, info: ReactErrorInfo) => void
 } {
   const report = (error: unknown, info: ReactErrorInfo) =>
-    captureValue(error, "Error", info.componentStack ? { componentStack: info.componentStack } : undefined)
+    captureValue(
+      error,
+      "Error",
+      info.componentStack ? { componentStack: info.componentStack } : undefined,
+    )
   return { onCaughtError: report, onUncaughtError: report }
 }
 
@@ -346,7 +411,12 @@ export function railwatchRootOptions(): {
 function stringify(value: unknown) {
   try {
     if (value instanceof Error) return `${value.name}: ${value.message}`
-    if (Array.isArray(value) || (typeof value === "object" && value !== null && value.toString === Object.prototype.toString)) {
+    if (
+      Array.isArray(value) ||
+      (typeof value === "object" &&
+        value !== null &&
+        value.toString === Object.prototype.toString)
+    ) {
       return JSON.stringify(value).slice(0, MAX_CRUMB_TEXT)
     }
     return String(value)
@@ -376,13 +446,20 @@ function startErrorCapture() {
   })
   window.addEventListener("unhandledrejection", (event) => {
     const reason = event.reason as unknown
-    if (typeof reason === "object" && reason !== null && requestFailures.has(reason)) return
+    if (
+      typeof reason === "object" &&
+      reason !== null &&
+      requestFailures.has(reason)
+    )
+      return
     captureValue(reason, "UnhandledRejection")
   })
   onInertia("exception", (detail) => captureRequestFailure(detail.exception))
   onInertia("networkError", (detail) => captureRequestFailure(detail.error))
   onInertia("invalid", (detail) => captureInvalidResponse(detail.response))
-  onInertia("httpException", (detail) => captureInvalidResponse(detail.response))
+  onInertia("httpException", (detail) =>
+    captureInvalidResponse(detail.response),
+  )
 }
 
 // A visit the user is waiting on: one that shows the progress bar, or the
@@ -402,12 +479,16 @@ function waiting(visit: object): boolean {
 // the next waiting `before`, a waiting `start`, or a reported failure,
 // which can only over-report.
 function idOf(record: object, key: string): string | undefined {
-  const value = key in record ? (record as Record<string, unknown>)[key] : undefined
+  const value =
+    key in record ? (record as Record<string, unknown>)[key] : undefined
   return typeof value === "string" ? value : undefined
 }
 
 function landed(detail: object) {
-  if (foregroundRequest?.id !== undefined && idOf(detail, "visitId") === foregroundRequest.id) {
+  if (
+    foregroundRequest?.id !== undefined &&
+    idOf(detail, "visitId") === foregroundRequest.id
+  ) {
     foregroundRequest = null
   }
 }
@@ -424,10 +505,17 @@ function captureRequestFailure(error: unknown) {
   captureValue(error, "InertiaException")
 }
 
-function onInertia(name: string, handler: (detail: Record<string, unknown>) => void) {
+function onInertia(
+  name: string,
+  handler: (detail: Record<string, unknown>) => void,
+) {
   document.addEventListener(`inertia:${name}`, (event) => {
     const detail = (event as CustomEvent<unknown>).detail
-    handler(typeof detail === "object" && detail !== null ? (detail as Record<string, unknown>) : {})
+    handler(
+      typeof detail === "object" && detail !== null
+        ? (detail as Record<string, unknown>)
+        : {},
+    )
   })
 }
 
@@ -439,19 +527,31 @@ function onInertia(name: string, handler: (detail: Record<string, unknown>) => v
 // predicate for the two cases is the x-inertia response header, so that is
 // the gate here; Inertia 2's `invalid` only ever fired for the first kind.
 function captureInvalidResponse(response: unknown) {
-  const res = (response ?? {}) as { status?: unknown; headers?: Record<string, unknown> }
+  const res = (response ?? {}) as {
+    status?: unknown
+    headers?: Record<string, unknown>
+  }
   if (inertiaResponse(res.headers)) return
   const status = typeof res.status === "number" ? res.status : "unknown status"
   const contentType = res.headers?.["content-type"]
-  capture("InertiaInvalidResponse", `Inertia invalid response (${status})`, undefined, {
-    status,
-    ...(typeof contentType === "string" ? { content_type: contentType } : {}),
-  })
+  capture(
+    "InertiaInvalidResponse",
+    `Inertia invalid response (${status})`,
+    undefined,
+    {
+      status,
+      ...(typeof contentType === "string" ? { content_type: contentType } : {}),
+    },
+  )
 }
 
-function inertiaResponse(headers: Record<string, unknown> | undefined): boolean {
+function inertiaResponse(
+  headers: Record<string, unknown> | undefined,
+): boolean {
   if (!headers || typeof headers !== "object") return false
-  return Object.keys(headers).some((key) => key.toLowerCase() === "x-inertia" && headers[key])
+  return Object.keys(headers).some(
+    (key) => key.toLowerCase() === "x-inertia" && headers[key],
+  )
 }
 
 // --- Core Web Vitals ---------------------------------------------------
@@ -472,10 +572,16 @@ interface ObserveOptions {
   durationThreshold?: number
 }
 
-function observe(type: string, callback: (entries: VitalEntry[]) => void, options: ObserveOptions = {}) {
+function observe(
+  type: string,
+  callback: (entries: VitalEntry[]) => void,
+  options: ObserveOptions = {},
+) {
   if (typeof PerformanceObserver === "undefined") return
   try {
-    const observer = new PerformanceObserver((list) => callback(list.getEntries()))
+    const observer = new PerformanceObserver((list) =>
+      callback(list.getEntries()),
+    )
     observer.observe({ type, buffered: true, ...options })
   } catch {
     // This browser does not support this entry type. Skip that metric only.
@@ -487,9 +593,12 @@ function observe(type: string, callback: (entries: VitalEntry[]) => void, option
 // this file is imported into) does not define, and a ReferenceError here
 // would take the whole client down with it.
 function navigationEntry(): PerformanceNavigationTiming | undefined {
-  const entries: PerformanceEntry[] = performance.getEntriesByType?.("navigation") ?? []
+  const entries: PerformanceEntry[] =
+    performance.getEntriesByType?.("navigation") ?? []
   const nav = entries[0]
-  return nav?.entryType === "navigation" ? (nav as PerformanceNavigationTiming) : undefined
+  return nav?.entryType === "navigation"
+    ? (nav as PerformanceNavigationTiming)
+    : undefined
 }
 
 function startVitals() {
@@ -511,7 +620,11 @@ function startVitals() {
     for (const entry of entries) {
       if (entry.hadRecentInput) continue
       const value = entry.value ?? 0
-      if (sessionValue && entry.startTime - sessionLast < 1000 && entry.startTime - sessionFirst < 5000) {
+      if (
+        sessionValue &&
+        entry.startTime - sessionLast < 1000 &&
+        entry.startTime - sessionFirst < 5000
+      ) {
         sessionValue += value
         sessionLast = entry.startTime
       } else {
@@ -541,7 +654,9 @@ function startVitals() {
 // serialized page object. Inertia's own events take over from here.
 function pageComponent(): string | undefined {
   try {
-    const page = JSON.parse(document.getElementById("app")?.dataset.page ?? "{}") as { component?: string }
+    const page = JSON.parse(
+      document.getElementById("app")?.dataset.page ?? "{}",
+    ) as { component?: string }
     return page.component
   } catch {
     // Not an Inertia-rendered page, or the payload moved. Report it anyway.
@@ -557,7 +672,10 @@ function initialVisit(): Visit | null {
 
   const duration = (nav.loadEventEnd || nav.responseEnd) - nav.startTime
   return {
-    started_at: Math.round((performance.timeOrigin ?? Date.now() - performance.now()) + nav.startTime),
+    started_at: Math.round(
+      (performance.timeOrigin ?? Date.now() - performance.now()) +
+        nav.startTime,
+    ),
     url: location.pathname + location.search,
     method: "GET",
     component,
@@ -587,8 +705,8 @@ function finalize() {
 }
 
 export function startRailwatch(options: RailwatchOptions = {}) {
-  ignoreErrors = [ ...DEFAULT_IGNORE_ERRORS, ...(options.ignoreErrors ?? []) ]
-  denyUrls = [ ...DEFAULT_DENY_URLS, ...(options.denyUrls ?? []) ]
+  ignoreErrors = [...DEFAULT_IGNORE_ERRORS, ...(options.ignoreErrors ?? [])]
+  denyUrls = [...DEFAULT_DENY_URLS, ...(options.denyUrls ?? [])]
   tenantOf = options.tenant
   startVitals()
   startSession()
@@ -609,7 +727,8 @@ export function startRailwatch(options: RailwatchOptions = {}) {
     if (!waiting(v) || event.defaultPrevented) return
     const request = (foregroundRequest = { id: idOf(v, "id") })
     queueMicrotask(() => {
-      if (event.defaultPrevented && foregroundRequest === request) foregroundRequest = null
+      if (event.defaultPrevented && foregroundRequest === request)
+        foregroundRequest = null
     })
   })
   router.on("start", (event) => {
@@ -642,7 +761,8 @@ export function startRailwatch(options: RailwatchOptions = {}) {
   router.on("finish", (event) => {
     // Fires once whether the visit completed, failed, or was cancelled.
     // Clamped so a missed start can only over-report, never silence.
-    if (waiting(event.detail.visit)) foregroundVisits = Math.max(0, foregroundVisits - 1)
+    if (waiting(event.detail.visit))
+      foregroundVisits = Math.max(0, foregroundVisits - 1)
     if (!current) return
     current.duration_ms = Date.now() - current.started_at
     current.status ??= "cancelled"