complete performance and reliability follow-ups

packages/observability/src/client.ts

@@ -22,7 +22,7 @@ export function webVitalsClient(options: WebVitalsClientOptions = {}): string {
   function send(name, value) {
     var body = JSON.stringify({ name: name, value: value, rating: rating(name, value), route: location.pathname, navigationType: performance.getEntriesByType("navigation")[0]?.type });
     if (navigator.sendBeacon) navigator.sendBeacon(endpoint, new Blob([body], { type: "application/json" }));
-    else fetch(endpoint, { method: "POST", headers: { "content-type": "application/json" }, body: body, keepalive: true }).catch(function(){});
+    else fetch(endpoint, { method: "POST", headers: { "content-type": "application/json" }, body: body, keepalive: true }).catch(function(error){ console.warn("[wrnexus:observability] web-vitals delivery failed", error); });
   }
   function flush() {
     if (flushed) return;
@@ -31,9 +31,13 @@ export function webVitalsClient(options: WebVitalsClientOptions = {}): string {
     if (inp) send("INP", inp);
     if (cls) send("CLS", cls);
   }
-  try { new PerformanceObserver(function(list){ var entries=list.getEntries(); var last=entries[entries.length-1]; if(last) lcp = Math.max(lcp, last.startTime); }).observe({type:"largest-contentful-paint",buffered:true}); } catch(_) {}
-  try { new PerformanceObserver(function(list){ list.getEntries().forEach(function(e){ if(!e.hadRecentInput) cls += e.value; }); }).observe({type:"layout-shift",buffered:true}); } catch(_) {}
-  try { new PerformanceObserver(function(list){ list.getEntries().forEach(function(e){ inp=Math.max(inp,e.duration||0); }); }).observe({type:"event",durationThreshold:40,buffered:true}); } catch(_) {}
+  function observe(type, callback, options) {
+    try { new PerformanceObserver(callback).observe(options); }
+    catch(error) { console.warn("[wrnexus:observability] PerformanceObserver unavailable for " + type, error); }
+  }
+  observe("largest-contentful-paint", function(list){ var entries=list.getEntries(); var last=entries[entries.length-1]; if(last) lcp = Math.max(lcp, last.startTime); }, {type:"largest-contentful-paint",buffered:true});
+  observe("layout-shift", function(list){ list.getEntries().forEach(function(e){ if(!e.hadRecentInput) cls += e.value; }); }, {type:"layout-shift",buffered:true});
+  observe("event", function(list){ list.getEntries().forEach(function(e){ inp=Math.max(inp,e.duration||0); }); }, {type:"event",durationThreshold:40,buffered:true});
   addEventListener("visibilitychange", function(){ if(document.visibilityState === "hidden") flush(); });
   addEventListener("pagehide", flush, { once: true });
 })();`;

packages/observability/src/diagnostics.ts

@@ -0,0 +1,14 @@
+export type ObservabilityDiagnostic = (message: string, error: unknown) => void;
+
+/** Report exporter failures without feeding them back through the exporter. */
+export function reportObservabilityFailure(
+  message: string,
+  error: unknown,
+  diagnostic?: ObservabilityDiagnostic,
+): void {
+  if (diagnostic) {
+    diagnostic(message, error);
+    return;
+  }
+  console.warn(`[wrnexus:observability] ${message}`, error);
+}

packages/observability/src/integrations.ts

@@ -2,6 +2,7 @@ import type { MetricPoint } from "./metrics.ts";
 import type { LogRecord } from "./logging.ts";
 import type { MetricExporter } from "./server.ts";
 import type { SpanExporter, SpanRecord, TraceContext } from "./trace.ts";
+import { reportObservabilityFailure, type ObservabilityDiagnostic } from "./diagnostics.ts";
 
 export type FrameworkSpanKind =
   "database" | "cache" | "queue" | "realtime" | "server-action" | "application";
@@ -26,6 +27,7 @@ export function createOperationTracer(
     context?: () => Partial<TraceContext>;
     now?: () => number;
     onExportError?: (error: unknown) => void;
+    diagnostic?: ObservabilityDiagnostic;
   } = {},
 ): OperationTracer {
   const now = options.now ?? Date.now;
@@ -66,7 +68,9 @@ export function createOperationTracer(
         try {
           await options.exporter?.export([record]);
         } catch (error) {
-          options.onExportError?.(error);
+          if (options.onExportError) options.onExportError(error);
+          else
+            reportObservabilityFailure("operation span export failed", error, options.diagnostic);
         }
       }
     },

packages/observability/src/trace.ts

@@ -1,4 +1,5 @@
 import { createTracer, type Context, type Middleware } from "@wrnexus/core";
+import { reportObservabilityFailure, type ObservabilityDiagnostic } from "./diagnostics.ts";
 
 export interface TraceContext {
   version: "00";
@@ -63,6 +64,7 @@ export interface TraceMiddlewareOptions {
   routeName?: (ctx: Context) => string;
   serverTiming?: boolean;
   onExportError?: (error: unknown, span: SpanRecord) => void | Promise<void>;
+  diagnostic?: ObservabilityDiagnostic;
 }
 
 export function traceMiddleware(options: TraceMiddlewareOptions = {}): Middleware {
@@ -131,7 +133,8 @@ export function traceMiddleware(options: TraceMiddlewareOptions = {}): Middlewar
           await options.onSpan?.(span);
           await options.exporter?.export([span]);
         } catch (error) {
-          await options.onExportError?.(error, span);
+          if (options.onExportError) await options.onExportError(error, span);
+          else reportObservabilityFailure("trace export failed", error, options.diagnostic);
         }
       }
     }

packages/observability/test/integrations.test.ts

@@ -93,4 +93,14 @@ describe("observability integrations", () => {
     expect(await profile("render", () => "ok")).toBe("ok");
     expect(profiles[0]).toMatchObject({ name: "render", durationMs: 4 });
   });
+
+  test("operation exporter failures reach diagnostics without recursive telemetry", async () => {
+    const diagnostics: string[] = [];
+    const tracer = createOperationTracer({
+      exporter: { export: () => Promise.reject(new Error("offline")) },
+      diagnostic: (message) => diagnostics.push(message),
+    });
+    await expect(tracer.span("database", "query", async () => 1)).resolves.toBe(1);
+    expect(diagnostics).toEqual(["operation span export failed"]);
+  });
 });

packages/observability/test/observability.test.ts

@@ -8,6 +8,8 @@ describe("@wrnexus/observability", () => {
     expect(client).toContain('addEventListener("pagehide", flush');
     expect(client).not.toContain('send("INP",max)');
     expect(client).not.toContain('send("LCP", last.startTime)');
+    expect(client).toContain("web-vitals delivery failed");
+    expect(client).toContain("PerformanceObserver unavailable for");
   });
 
   test("records deterministic counters and histograms", () => {

packages/observability/test/operations.test.ts

@@ -81,6 +81,22 @@ describe("production observability operations", () => {
     expect(failures).toHaveLength(1);
   });
 
+  test("reports exporter failures through the non-recursive diagnostic hook", async () => {
+    const diagnostics: Array<{ message: string; error: unknown }> = [];
+    const ctx = createContext(
+      new Request("https://example.test/"),
+      new URL("https://example.test/"),
+    );
+    const middleware = traceMiddleware({
+      random: (target) => target.fill(8),
+      exporter: { export: () => Promise.reject(new Error("offline")) },
+      diagnostic: (message, error) => diagnostics.push({ message, error }),
+    });
+    expect((await middleware(ctx, () => new Response("ok"))).status).toBe(200);
+    expect(diagnostics).toHaveLength(1);
+    expect(diagnostics[0]?.message).toBe("trace export failed");
+  });
+
   test("exports OTLP JSON traces and metrics", async () => {
     const requests: unknown[] = [];
     const send = (async (_url: URL | RequestInfo, init?: RequestInit) => {