@zerotal/flow 1.6.3 → 1.7.2

package/src/observability.ts

@@ -44,8 +44,15 @@ interface DevtoolsSink {
     meta?: string[];
     warn?: string;
     order?: number;
+    hidden?: boolean;
   }): void;
   record(ctx: object, channel: string, entry: Record<string, unknown>): void;
+  /**
+   * Optional because it postdates the sink: a project can pin a devtools older
+   * than this Flow, and an action that goes untraced is a worse panel, not a
+   * crashed one.
+   */
+  finalise?(ctx: object, meta: { startMs: number; durationMs: number; method?: string }): void;
 }
 
 // Framework/asset noise the panel shouldn't chart as realtime traffic.
@@ -134,6 +141,12 @@ export function installFlowObservability(app: Application): () => void {
 
   const trace = _observer<DevtoolsSink>(app, "devtools.trace");
   if (trace) {
+    // Recorded on the trace, but with no tab of its own: Flow's client panel is
+    // the better home for it. A time-travel frame already names the component,
+    // the action and the fields it changed, so a separate tab could only repeat
+    // that beside a duration the trace header already shows — and the frames and
+    // the actions are the same clicks seen from the two ends. The panel reads
+    // these entries off the trace and prints them on the frame they belong to.
     trace.channel({
       id: "flow",
       label: "Flow",
@@ -142,12 +155,18 @@ export function installFlowObservability(app: Application): () => void {
       meta: ["durationMs", "ip"],
       warn: "failed",
       order: 20,
+      hidden: true,
     });
 
     unsubs.push(
       FrameworkEvents.on(FlowActionHandled, (e) => {
         // An action round-trips over the WebSocket against its own HttpContext,
-        // so it buffers against that context and lands on that action's trace.
+        // so it buffers against that context — and then has to finalise that
+        // context itself. Devtools builds traces from core's request lifecycle,
+        // and a WebSocket action fires none of it, so for as long as this call
+        // was missing every action buffered its evidence and dropped it: the Flow
+        // tab reported "no flow activity" for apps whose every interaction is a
+        // Flow action, and the queries those actions ran showed up nowhere.
         if (!e.ctx) return;
         if (IGNORE_PREFIXES.some((p) => _rawPath(e.ctx as object).startsWith(p))) return;
         trace.record(e.ctx as object, "flow", {
@@ -157,6 +176,14 @@ export function installFlowObservability(app: Application): () => void {
           ip: e.ip,
           ...(e.ok ? {} : { failed: true }),
         });
+        // The synthetic request behind an action is a GET of the page the action
+        // ran on, so labelling it `FLOW` is what keeps it from reading as a second
+        // page load in the request list.
+        trace.finalise?.(e.ctx as object, {
+          startMs: Date.now() - e.durationMs,
+          durationMs: e.durationMs,
+          method: "FLOW",
+        });
       }),
     );
   }