@gloom-sh/terminal 0.19.1 → 0.19.2

package/src/utils/main-thread-stall.ts

@@ -9,15 +9,31 @@ const SAMPLE_INTERVAL_MS = 250;
  */
 const STALL_THRESHOLD_MS = 400;
 
+/** The facts a `sqlite.blocked` step was measured with (data/sqlite/retry.ts). */
+interface StallSqliteDetail {
+  /** The statement's fixed name, such as "touch cached resource". */
+  operation: string;
+  attempts: number;
+  /** Whether it waited on another connection's lock, rather than being slow on its own. */
+  lockWait: boolean;
+}
+
 export interface StallEvent {
   blockedMs: number;
   /** The last measured section before the stall (perf-marks), if any. */
   lastMeasured?: string;
   /** How long before the stall was noticed that section ended. */
   lastMeasuredEndedMsAgo?: number;
+  /** When that section was a SQLite statement that held the thread. */
+  sqlite?: StallSqliteDetail;
+  /** How long the process had been running when the stall was noticed. */
+  uptimeMs?: number;
+  /** Whether the process had finished starting (`markStartupComplete`). */
+  phase?: "startup" | "steady";
 }
 
 let stallSink: ((event: StallEvent) => void) | null = null;
+let startupComplete = false;
 
 /**
  * Where this process's stalls go besides the Debug Log: the stall log and its
@@ -31,6 +47,20 @@ export function setStallSink(next: ((event: StallEvent) => void) | null): () =>
   };
 }
 
+/**
+ * The process is up: its first screen has its data, or (the desktop app's
+ * Bun process) the main window has what it asked for. Stalls before this are
+ * reported as startup ones.
+ */
+export function markStartupComplete(): void {
+  startupComplete = true;
+}
+
+/** Test seam. */
+export function resetStartupCompleteForTests(): void {
+  startupComplete = false;
+}
+
 function noteStall(event: StallEvent): void {
   try {
     stallSink?.(event);
@@ -39,6 +69,14 @@ function noteStall(event: StallEvent): void {
   }
 }
 
+/** The facts of a `sqlite.blocked` sample, when they have the shape retry.ts gives them. */
+function sqliteDetail(metadata: Record<string, unknown> | undefined): StallSqliteDetail | undefined {
+  if (!metadata) return undefined;
+  const { operation, attempts, lockWait } = metadata;
+  if (typeof operation !== "string" || typeof attempts !== "number") return undefined;
+  return { operation, attempts, lockWait: lockWait === true };
+}
+
 export interface MainThreadStallMonitorOptions {
   intervalMs?: number;
   thresholdMs?: number;
@@ -60,7 +98,9 @@ function defaultNow(): number {
  * comes back late, the app was unresponsive for exactly that long. The report
  * carries the last measured section and how long before the stall it ended,
  * which is usually enough to tell "the cache read did it" from "the render
- * did it" in a report that only says the app hung for a few seconds.
+ * did it" in a report that only says the app hung for a few seconds, and how
+ * long the process had been up, so a slow start reads apart from a hang
+ * hours in.
  */
 export function startMainThreadStallMonitor(
   options: MainThreadStallMonitorOptions = {},
@@ -72,7 +112,8 @@ export function startMainThreadStallMonitor(
   const cancel = options.cancel ?? ((handle) => clearInterval(handle as ReturnType<typeof setInterval>));
   const report = options.report
     ?? ((blockedMs, context) => {
-      recordPerfSample("runtime.stall", blockedMs, context);
+      // Logged, but not a step: the next stall still names the work before it.
+      recordPerfSample("runtime.stall", blockedMs, context, { lastStep: false });
       noteStall({ blockedMs, ...context });
     });
 
@@ -83,10 +124,14 @@ export function startMainThreadStallMonitor(
     previous = current;
     if (blockedMs < thresholdMs) return;
     const sample = lastPerfSample();
+    const sqlite = sample?.name === "sqlite.blocked" ? sqliteDetail(sample.metadata) : undefined;
     report(blockedMs, {
       ...(sample
         ? { lastMeasured: sample.name, lastMeasuredEndedMsAgo: Math.round(current - sample.endedAt) }
         : {}),
+      ...(sqlite ? { sqlite } : {}),
+      uptimeMs: Math.round(current),
+      phase: startupComplete ? "steady" : "startup",
     });
   }, intervalMs);
   if (handle && typeof (handle as { unref?: () => void }).unref === "function") {

package/src/utils/perf-marks.ts

@@ -20,27 +20,34 @@ function now(): number {
     : Date.now();
 }
 
-// Two scalars rather than an object: every measured section writes them, and
-// only the stall monitor ever reads them.
+// Scalars rather than an object: every measured section writes them, and
+// only the stall monitor ever reads them. The metadata is the caller's own
+// object, kept by reference.
 let lastSampleName: string | null = null;
 let lastSampleEndedAt = 0;
+let lastSampleMetadata: Record<string, unknown> | undefined;
 
 /**
- * The most recent measured section and when it ended. The stall monitor reads
- * it so a report of "the app froze" carries the last thing the app is known to
- * have been doing.
+ * The most recent measured section, when it ended and what it was measured
+ * with. The stall monitor reads it so a report of "the app froze" carries the
+ * last thing the app is known to have been doing.
  */
-export function lastPerfSample(): { name: string; endedAt: number } | null {
-  return lastSampleName == null ? null : { name: lastSampleName, endedAt: lastSampleEndedAt };
+export function lastPerfSample(): { name: string; endedAt: number; metadata?: Record<string, unknown> } | null {
+  if (lastSampleName == null) return null;
+  return { name: lastSampleName, endedAt: lastSampleEndedAt, ...(lastSampleMetadata ? { metadata: lastSampleMetadata } : {}) };
 }
 
 function logSlowPerfSample(
   name: string,
   durationMs: number,
   metadata?: Record<string, unknown>,
+  lastStep = true,
 ): void {
-  lastSampleName = name;
-  lastSampleEndedAt = now();
+  if (lastStep) {
+    lastSampleName = name;
+    lastSampleEndedAt = now();
+    lastSampleMetadata = metadata;
+  }
   const payload = {
     durationMs: Math.round(durationMs * 10) / 10,
     ...(metadata ?? {}),
@@ -60,13 +67,18 @@ export function isPerfTraceEnabled(): boolean {
   return traceToStderr;
 }
 
-/** A sample measured elsewhere (a React Profiler callback, for instance). */
+/**
+ * A sample measured elsewhere (a React Profiler callback, for instance).
+ * `lastStep: false` logs it without making it the step a later stall names:
+ * the stall monitor's own samples, which measure no work.
+ */
 export function recordPerfSample(
   name: string,
   durationMs: number,
   metadata?: Record<string, unknown>,
+  options?: { lastStep?: boolean },
 ): void {
-  logSlowPerfSample(name, durationMs, metadata);
+  logSlowPerfSample(name, durationMs, metadata, options?.lastStep !== false);
 }
 
 export function measurePerf<T>(

package/src/utils/price-history-integrity.ts

@@ -46,6 +46,50 @@ export function pricePointIntegrityFlags(point: PricePoint): string[] {
   return flags;
 }
 
+/**
+ * A wick too far from its bar's body to have traded: a low under half the lower
+ * of open and close, or a high over twice the higher, as `low<close/2` or
+ * `high>2*open` (IAG on LSE, 2021-11-29: a low of 0.0155 under a close of
+ * 1.316). Only that wick is withheld: the open and close stand, so closes,
+ * returns and drawdowns read the bar while lows, highs and ranges do not.
+ * Empty when the wicks are plausible, or when the bar's prices contradict
+ * each other, which blanks it whole (pricePointIntegrityFlags).
+ */
+export function pricePointWickFlags(point: PricePoint): string[] {
+  const { open, high, low, close } = point;
+  if (pricePointIntegrityFlags(point).length > 0) return [];
+  const body = [["open", open], ["close", close]].filter((entry): entry is [string, number] => isFiniteNumber(entry[1]));
+  if (body.length === 0) return [];
+  // On a tie the close names the side, as the price the bar is read by.
+  const [bottomName, bottom] = body.reduce((least, entry) => entry[1] <= least[1] ? entry : least);
+  const [topName, top] = body.reduce((most, entry) => entry[1] >= most[1] ? entry : most);
+  const flags: string[] = [];
+  if (isFiniteNumber(low) && bottom > 0 && low < bottom / 2) flags.push(`low<${bottomName}/2`);
+  if (isFiniteNumber(high) && top > 0 && high > top * 2) flags.push(`high>2*${topName}`);
+  return flags;
+}
+
+/** Whether a flag code is a withheld wick (pricePointWickFlags), whose bar keeps its open and close. */
+export function isWickFlag(code: string): boolean {
+  return /^(low<(open|close)\/2|high>2\*(open|close))$/.test(code);
+}
+
+/** A bar's high and low with a wick too far from its body to have traded (pricePointWickFlags) left out. */
+export function pricePointWicks(point: PricePoint): { high: number | undefined; low: number | undefined } {
+  const flags = pricePointWickFlags(point);
+  return {
+    high: flags.some((flag) => flag.startsWith("high")) ? undefined : point.high,
+    low: flags.some((flag) => flag.startsWith("low")) ? undefined : point.low,
+  };
+}
+
+/** "1 bar has a low or high too far from its open and close to have traded; left out of ranges.", or undefined for none. */
+export function priceHistoryWickNotice(count: number): string | undefined {
+  return count > 0
+    ? `${count === 1 ? "1 bar has a low or high" : `${count} bars have lows or highs`} too far from ${count === 1 ? "its" : "their"} open and close to have traded; left out of ranges.`
+    : undefined;
+}
+
 export function pricePointIntegrity(point: PricePoint): PriceHistoryIntegrity | undefined {
   if (pricePointIntegrityFlags(point).length === 0) return undefined;
   const date = new Date(point.date);
@@ -58,8 +102,10 @@ export function pricePointIntegrity(point: PricePoint): PriceHistoryIntegrity |
 /** Calculation/display fields deliberately exclude the contradictory source row. */
 export function pricePointValues(point: PricePoint, integrity = pricePointIntegrity(point)) {
   const value = (number: number | undefined) => !integrity && isFiniteNumber(number) ? number : null;
+  // A wick too far from the body to have traded is left out; the rest of the bar stands.
+  const wicks = pricePointWicks(point);
   return {
-    open: value(point.open), high: value(point.high), low: value(point.low),
+    open: value(point.open), high: value(wicks.high), low: value(wicks.low),
     close: value(point.close), volume: value(point.volume),
     ...(integrity ? { integrity } : {}),
   };