@dxos/observability 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/observability",
-  "version": "0.8.4-main.9be5663bfe",
+  "version": "0.8.4-main.abd8ff62ef",
   "description": "Provides a common interface for app and platform observability",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -49,25 +49,28 @@
     "posthog-js": "^1.353.0",
     "uuid": "^9.0.0",
     "zone.js": "^0.15.0",
-    "@dxos/async": "0.8.4-main.9be5663bfe",
-    "@dxos/client": "0.8.4-main.9be5663bfe",
-    "@dxos/client-protocol": "0.8.4-main.9be5663bfe",
-    "@dxos/client-services": "0.8.4-main.9be5663bfe",
-    "@dxos/debug": "0.8.4-main.9be5663bfe",
-    "@dxos/context": "0.8.4-main.9be5663bfe",
-    "@dxos/log": "0.8.4-main.9be5663bfe",
-    "@dxos/config": "0.8.4-main.9be5663bfe",
-    "@dxos/invariant": "0.8.4-main.9be5663bfe",
-    "@dxos/network-manager": "0.8.4-main.9be5663bfe",
-    "@dxos/protocols": "0.8.4-main.9be5663bfe",
-    "@dxos/node-std": "0.8.4-main.9be5663bfe",
-    "@dxos/tracing": "0.8.4-main.9be5663bfe",
-    "@dxos/util": "0.8.4-main.9be5663bfe"
+    "@dxos/async": "0.8.4-main.abd8ff62ef",
+    "@dxos/client": "0.8.4-main.abd8ff62ef",
+    "@dxos/client-protocol": "0.8.4-main.abd8ff62ef",
+    "@dxos/client-services": "0.8.4-main.abd8ff62ef",
+    "@dxos/config": "0.8.4-main.abd8ff62ef",
+    "@dxos/context": "0.8.4-main.abd8ff62ef",
+    "@dxos/debug": "0.8.4-main.abd8ff62ef",
+    "@dxos/invariant": "0.8.4-main.abd8ff62ef",
+    "@dxos/log-store-idb": "0.8.4-main.abd8ff62ef",
+    "@dxos/log": "0.8.4-main.abd8ff62ef",
+    "@dxos/node-std": "0.8.4-main.abd8ff62ef",
+    "@dxos/network-manager": "0.8.4-main.abd8ff62ef",
+    "@dxos/protocols": "0.8.4-main.abd8ff62ef",
+    "@dxos/tracing": "0.8.4-main.abd8ff62ef",
+    "@dxos/util": "0.8.4-main.abd8ff62ef"
   },
   "devDependencies": {
     "@effect/platform": "0.94.4",
     "@types/debug": "^4.1.10",
-    "@types/js-yaml": "^4.0.5"
+    "@types/js-yaml": "^4.0.5",
+    "@dxos/effect": "0.8.4-main.abd8ff62ef",
+    "@dxos/messaging": "0.8.4-main.abd8ff62ef"
   },
   "peerDependencies": {
     "@effect/platform": "0.94.4",

package/src/cli-observability-secrets.json

@@ -1,6 +1,6 @@
 {
   "POSTHOG_API_KEY": null,
   "IPDATA_API_KEY": "73dfdecdf979c18f07d50cf841bbdd9e589f237256326ac8cca23786",
-  "OTEL_ENDPOINT": "https://ingest.eu.signoz.cloud:443",
-  "OTEL_HEADERS": "signoz-ingestion-key: 5300e0c9-a5e8-4a10-9c61-f473e539c0b7"
+  "OTEL_ENDPOINT": "/api/otel",
+  "OTEL_HEADERS": null
 }

package/src/extensions/otel/extension.ts

@@ -9,7 +9,7 @@ import * as Match from 'effect/Match';
 import * as Option from 'effect/Option';
 import * as Ref from 'effect/Ref';
 
-import { type Config } from '@dxos/config';
+import { type Config, resolveTelemetryTag } from '@dxos/config';
 import { LogLevel, log } from '@dxos/log';
 import { isNode, isNonNullable } from '@dxos/util';
 
@@ -57,7 +57,8 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
   const { OtelTraces } = yield* Effect.promise(() => import('./traces'));
 
   const cachedDisabled = yield* Effect.promise(() => isObservabilityDisabled(serviceName));
-  const enabledRef = yield* Ref.make(!cachedDisabled);
+  const disabled = cachedDisabled || isObservabilityDisabledSync(serviceName);
+  const enabledRef = yield* Ref.make(!disabled);
   const tags = new Map<string, string>();
 
   const endpoint = isNode()
@@ -78,11 +79,31 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
     return stubExtension;
   }
 
+  // Matches edge's `ctx.tag` span attribute (stamped by the edge log middleware
+  // when it reads the `X-DXOS-Client-Tag` header, see
+  // /edge/packages/services/edge/src/log-middleware.ts).
+  //
+  // Stamped in TWO places:
+  //   1. Resource attribute — so logs and metrics emitted from this extension
+  //      also carry it, and for zero per-span cost.
+  //   2. Span attribute via `tags` — because edge puts `ctx.tag` in the span-
+  //      attribute context (not resource), and SigNoz indexes the two contexts
+  //      separately. Stamping it on span attributes here keeps a single
+  //      `ctx.tag = <value>` filter matching spans from both tiers in SigNoz
+  //      without requiring qualified `attribute.ctx.tag`/`resource.ctx.tag` syntax.
+  const clientTag = resolveTelemetryTag(config);
+  if (clientTag) {
+    tags.set('ctx.tag', clientTag);
+  }
+
   const resource = defaultResource().merge(
     resourceFromAttributes({
       [ATTR_SERVICE_NAME]: serviceName,
       [ATTR_SERVICE_VERSION]: serviceVersion,
+      'session.id': crypto.randomUUID(),
       'deployment.environment': environment,
+      'dxos.process.type': detectProcessType(),
+      ...(clientTag ? { 'ctx.tag': clientTag } : {}),
     }),
   );
 
@@ -114,9 +135,13 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
       })
     : undefined;
 
-  return {
+  const extension: Extension = {
     initialize: () =>
       Effect.sync(() => {
+        if (disabled) {
+          return;
+        }
+
         if (logs) {
           log.runtimeConfig.processors.push(logs.logProcessor);
         }
@@ -134,13 +159,31 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
     }),
     close: () =>
       Effect.promise(async () => {
-        await logs?.close();
-        await metrics?.close();
+        // Run logs/metrics close concurrently and swallow their failures so the
+        // tracer provider shutdown below ALWAYS runs. Without this, a rejection
+        // from logs or metrics would drop the tracer provider's BatchSpanProcessor
+        // queue on process exit, manifesting as "Missing Span" in SigNoz for any
+        // already-exported children.
+        const results = await Promise.allSettled([logs?.close(), metrics?.close()]);
+        for (const result of results) {
+          if (result.status === 'rejected') {
+            log.catch(result.reason);
+          }
+        }
+        // Critical: shut down the tracer provider so BatchSpanProcessor drains its
+        // queue. Otherwise spans enqueued in the last 5s (close/teardown spans)
+        // are dropped on process exit.
+        await traces?.close();
       }),
     flush: () =>
       Effect.promise(async () => {
-        await logs?.flush();
-        await metrics?.flush();
+        const results = await Promise.allSettled([logs?.flush(), metrics?.flush()]);
+        for (const result of results) {
+          if (result.status === 'rejected') {
+            log.catch(result.reason);
+          }
+        }
+        await traces?.flush();
       }),
     setTags: (incomingTags) => {
       for (const [key, value] of Object.entries(incomingTags)) {
@@ -164,8 +207,45 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
       traces ? ({ kind: 'traces', isAvailable: () => Effect.succeed(true) } satisfies ExtensionApi) : undefined,
     ].filter(isNonNullable),
   };
+
+  return extension;
 });
 
+/**
+ * Synchronous best-effort check for observability opt-out.
+ * Prevents telemetry from being emitted before the async storage check completes.
+ */
+const isObservabilityDisabledSync = (serviceName: string): boolean => {
+  if (isNode()) {
+    return process.env.DX_DISABLE_OBSERVABILITY === 'true';
+  }
+  try {
+    if (typeof localStorage !== 'undefined') {
+      return localStorage.getItem(`${serviceName}/observability-disabled`) === 'true';
+    }
+  } catch {
+    // localStorage not available (e.g., in workers).
+  }
+  return false;
+};
+
+/** Best-effort detection of the JavaScript execution context type. */
+const detectProcessType = (): string => {
+  if (isNode()) {
+    return 'node';
+  }
+  if (typeof window !== 'undefined') {
+    return 'browser';
+  }
+  if (typeof (globalThis as any).ServiceWorkerGlobalScope !== 'undefined') {
+    return 'service-worker';
+  }
+  if (typeof (globalThis as any).SharedWorkerGlobalScope !== 'undefined') {
+    return 'shared-worker';
+  }
+  return 'dedicated-worker';
+};
+
 const parseHeaders = (unparsedHeaders: string): Record<string, string> => {
   return unparsedHeaders.split(';').reduce((acc: Record<string, string>, header) => {
     const [key, ...rest] = header.split(':');

package/src/extensions/otel/logs.ts

@@ -81,8 +81,11 @@ export class OtelLogs {
   }
 }
 
+/** Maps {@link LogLevel} to OpenTelemetry {@link SeverityNumber}. */
 const convertLevel = (level: LogLevel): SeverityNumber => {
   switch (level) {
+    case LogLevel.TRACE:
+      return SeverityNumber.TRACE;
     case LogLevel.DEBUG:
       return SeverityNumber.DEBUG;
     case LogLevel.VERBOSE:
@@ -94,7 +97,7 @@ const convertLevel = (level: LogLevel): SeverityNumber => {
     case LogLevel.ERROR:
       return SeverityNumber.ERROR;
     default:
-      return SeverityNumber.ERROR;
+      return SeverityNumber.UNSPECIFIED;
   }
 };
 

package/src/extensions/otel/span-processors.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Context } from '@opentelemetry/api';
+import { type ReadableSpan, type Span, type SpanProcessor } from '@opentelemetry/sdk-trace-base';
+
+import { log } from '@dxos/log';
+
+/**
+ * Injects dynamic tags as attributes on every span.
+ *
+ * This is an `onStart`-only processor; `onEnd`/`shutdown`/`forceFlush` are no-ops
+ * because this processor never holds pending work (delegates export to downstream
+ * processors like BatchSpanProcessor).
+ *
+ * Use for tags that are not known at provider construction (e.g. identity
+ * resolved asynchronously after login). For values known at startup, prefer
+ * putting them on the `Resource` — see `extension.ts`.
+ *
+ * Failures in the tag provider are swallowed so they can never break span
+ * recording (the processor is best-effort and runs on the startSpan hot path).
+ */
+export class TagInjectorSpanProcessor implements SpanProcessor {
+  constructor(private readonly _getTags: () => Record<string, string>) {}
+
+  onStart(span: Span, _parentContext: Context): void {
+    let tags: Record<string, string>;
+    try {
+      tags = this._getTags();
+    } catch (err) {
+      log.catch(err);
+      return;
+    }
+    for (const [key, value] of Object.entries(tags)) {
+      span.setAttribute(key, value);
+    }
+  }
+
+  onEnd(_span: ReadableSpan): void {}
+
+  async shutdown(): Promise<void> {}
+
+  async forceFlush(): Promise<void> {}
+}

package/src/extensions/otel/traces-browser.ts

@@ -2,7 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Context, type Tracer, context as otelContext, propagation, trace } from '@opentelemetry/api';
+import {
+  ROOT_CONTEXT,
+  SpanStatusCode,
+  type Tracer,
+  context as otelContext,
+  propagation,
+  trace,
+} from '@opentelemetry/api';
 import { getWebAutoInstrumentations } from '@opentelemetry/auto-instrumentations-web';
 import { W3CTraceContextPropagator } from '@opentelemetry/core';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
@@ -11,47 +18,27 @@ import {
   AlwaysOnSampler,
   BatchSpanProcessor,
   ParentBasedSampler,
-  type ReadableSpan,
-  type SpanProcessor,
   TraceIdRatioBasedSampler,
 } from '@opentelemetry/sdk-trace-base';
 import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
 import { ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
 
 import { log } from '@dxos/log';
-import { type StartSpanOptions, TRACE_PROCESSOR } from '@dxos/tracing';
+import { TRACE_ALL_KEY, type RemoteSpan, type StartSpanOptions, TRACE_PROCESSOR } from '@dxos/tracing';
 
 import { type OtelOptions } from './otel';
-
-/**
- * Injects dynamic tags (e.g. userId) as attributes on every span.
- */
-class TagInjectorSpanProcessor implements SpanProcessor {
-  constructor(private readonly _getTags: () => Record<string, string>) {}
-
-  onStart(span: { setAttribute: (key: string, value: string) => void }): void {
-    const tags = this._getTags();
-    for (const [key, value] of Object.entries(tags)) {
-      span.setAttribute(key, value);
-    }
-  }
-
-  onEnd(_span: ReadableSpan): void {}
-
-  async shutdown(): Promise<void> {}
-
-  async forceFlush(): Promise<void> {}
-}
+import { TagInjectorSpanProcessor } from './span-processors';
 
 export class OtelTraces {
   private _tracer: Tracer;
+  private readonly _tracerProvider: WebTracerProvider;
 
   constructor(private readonly options: OtelOptions) {
     propagation.setGlobalPropagator(new W3CTraceContextPropagator());
 
-    const forceTraceAll = typeof localStorage !== 'undefined' && localStorage.getItem('dxos.debug.traceAll') === 'true';
+    const forceTraceAll = typeof localStorage !== 'undefined' && localStorage.getItem(TRACE_ALL_KEY) === 'true';
 
-    const tracerProvider = new WebTracerProvider({
+    this._tracerProvider = new WebTracerProvider({
       resource: this.options.resource,
       sampler: new ParentBasedSampler({
         root: forceTraceAll ? new AlwaysOnSampler() : new TraceIdRatioBasedSampler(0.3),
@@ -69,7 +56,7 @@ export class OtelTraces {
       ],
     });
 
-    trace.setGlobalTracerProvider(tracerProvider);
+    trace.setGlobalTracerProvider(this._tracerProvider);
 
     this._tracer = trace.getTracer(
       'dxos-observability',
@@ -77,34 +64,76 @@ export class OtelTraces {
     );
   }
 
+  /**
+   * Forcibly flush the BatchSpanProcessor. Call before process exit / page unload
+   * to avoid losing queued spans (which manifests as "Missing Span" in SigNoz —
+   * their already-exported children reference a parent that never made it to OTLP).
+   */
+  public async flush(): Promise<void> {
+    await this._tracerProvider.forceFlush();
+  }
+
+  /**
+   * Flush + shut down the tracer provider via `WebTracerProvider.shutdown()`,
+   * which forces a final export then terminates all span processors.
+   *
+   * Terminal and effectively one-shot: safe to call after `flush()`, but
+   * `flush()` MUST NOT be called after `close()` — shutdown stops further
+   * exporting, so subsequent `close()`/`flush()` calls resolve without
+   * emitting new spans.
+   */
+  public async close(): Promise<void> {
+    await this._tracerProvider.shutdown();
+  }
+
   public start(): void {
     log('trace processor registered');
 
     registerInstrumentations({
       instrumentations: [
         getWebAutoInstrumentations({
-          // Fetch is disabled in favor of explicit ctx on our call sites; if re-enabled, keep noisy
-          // third-party URLs out of traces (matches prior browser tracing setup).
           '@opentelemetry/instrumentation-fetch': { enabled: false, ignoreUrls: [/api\.ipdata\.co/] },
           '@opentelemetry/instrumentation-document-load': { enabled: false },
           '@opentelemetry/instrumentation-xml-http-request': { enabled: false },
+          '@opentelemetry/instrumentation-user-interaction': { enabled: false },
         }),
       ],
     });
 
-    TRACE_PROCESSOR.remoteTracing.registerProcessor({
-      startSpan: (options: StartSpanOptions) => {
+    const tracer = this._tracer;
+
+    TRACE_PROCESSOR.tracingBackend = {
+      startSpan: (options: StartSpanOptions): RemoteSpan => {
         log('begin otel trace', { options });
-        const explicitParent = options.parentContext as Context | undefined;
-        const parentCtx = explicitParent ?? otelContext.active();
-        const span = this._tracer.startSpan(options.name, options, parentCtx);
-        const spanCtx = trace.setSpan(parentCtx, span);
+        const parentCtx = options.parentContext
+          ? propagation.extract(ROOT_CONTEXT, {
+              traceparent: options.parentContext.traceparent,
+              tracestate: options.parentContext.tracestate ?? '',
+            })
+          : otelContext.active();
+
+        const span = tracer.startSpan(options.name, options, parentCtx);
+
+        const sc = span.spanContext();
+        const spanContext =
+          sc && sc.traceId && sc.spanId
+            ? {
+                traceparent: `00-${sc.traceId}-${sc.spanId}-${(sc.traceFlags ?? 0).toString(16).padStart(2, '0')}`,
+                tracestate: sc.traceState?.serialize(),
+              }
+            : undefined;
+
         return {
-          end: () => span.end(),
-          wrapExecution: <T>(fn: () => T): T => otelContext.with(spanCtx, fn),
-          spanContext: spanCtx,
+          end: (endTime?: number) => span.end(endTime),
+          setError: (err: unknown) => {
+            if (err instanceof Error) {
+              span.recordException(err);
+            }
+            span.setStatus({ code: SpanStatusCode.ERROR, message: err instanceof Error ? err.message : String(err) });
+          },
+          spanContext,
         };
       },
-    });
+    };
   }
 }

package/src/extensions/otel/traces.ts

@@ -2,48 +2,112 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Tracer, trace } from '@opentelemetry/api';
+import {
+  ROOT_CONTEXT,
+  SpanStatusCode,
+  type Tracer,
+  context as otelContext,
+  propagation,
+  trace,
+} from '@opentelemetry/api';
+import { W3CTraceContextPropagator } from '@opentelemetry/core';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { BasicTracerProvider, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-import { log } from 'debug';
 
-import { type StartSpanOptions, TRACE_PROCESSOR } from '@dxos/tracing';
+import { log } from '@dxos/log';
+import { type RemoteSpan, type StartSpanOptions, TRACE_PROCESSOR } from '@dxos/tracing';
 
 import { type OtelOptions } from './otel';
+import { TagInjectorSpanProcessor } from './span-processors';
 
 export class OtelTraces {
   private _tracer: Tracer;
+  private readonly _tracerProvider: BasicTracerProvider;
 
   constructor(private readonly options: OtelOptions) {
-    const tracerProvider = new BasicTracerProvider({
+    propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+
+    this._tracerProvider = new BasicTracerProvider({
       resource: this.options.resource,
       spanProcessors: [
+        new TagInjectorSpanProcessor(this.options.getTags),
         new BatchSpanProcessor(
           new OTLPTraceExporter({
             url: this.options.endpoint + '/v1/traces',
             headers: this.options.headers,
-            concurrencyLimit: 10, // an optional limit on pending requests
+            concurrencyLimit: 10,
           }),
         ),
       ],
     });
 
-    trace.setGlobalTracerProvider(tracerProvider);
+    trace.setGlobalTracerProvider(this._tracerProvider);
     this._tracer = trace.getTracer(
       'dxos-observability',
       this.options.resource.attributes[ATTR_SERVICE_VERSION]?.toString(),
     );
   }
 
+  /**
+   * Forcibly flush the BatchSpanProcessor. Call before process exit to avoid
+   * losing queued spans (which manifests as "Missing Span" in SigNoz — their
+   * already-exported children reference a parent that never made it to OTLP).
+   */
+  public async flush(): Promise<void> {
+    await this._tracerProvider.forceFlush();
+  }
+
+  /**
+   * Flush + shut down the tracer provider via `BasicTracerProvider.shutdown()`,
+   * which forces a final export then terminates all span processors.
+   *
+   * Terminal and effectively one-shot: safe to call after `flush()`, but
+   * `flush()` MUST NOT be called after `close()` — shutdown stops further
+   * exporting, so subsequent `close()`/`flush()` calls resolve without
+   * emitting new spans.
+   */
+  public async close(): Promise<void> {
+    await this._tracerProvider.shutdown();
+  }
+
   public start(): void {
     log('trace processor registered');
 
-    TRACE_PROCESSOR.remoteTracing.registerProcessor({
-      startSpan: (options: StartSpanOptions) => {
+    const tracer = this._tracer;
+
+    TRACE_PROCESSOR.tracingBackend = {
+      startSpan: (options: StartSpanOptions): RemoteSpan => {
         log('begin otel trace', { options });
-        return this._tracer.startSpan(options.name, options);
+        const parentCtx = options.parentContext
+          ? propagation.extract(ROOT_CONTEXT, {
+              traceparent: options.parentContext.traceparent,
+              tracestate: options.parentContext.tracestate ?? '',
+            })
+          : otelContext.active();
+
+        const span = tracer.startSpan(options.name, options, parentCtx);
+
+        const sc = span.spanContext();
+        const spanContext =
+          sc && sc.traceId && sc.spanId
+            ? {
+                traceparent: `00-${sc.traceId}-${sc.spanId}-${(sc.traceFlags ?? 0).toString(16).padStart(2, '0')}`,
+                tracestate: sc.traceState?.serialize(),
+              }
+            : undefined;
+
+        return {
+          end: (endTime?: number) => span.end(endTime),
+          setError: (err: unknown) => {
+            if (err instanceof Error) {
+              span.recordException(err);
+            }
+            span.setStatus({ code: SpanStatusCode.ERROR, message: err instanceof Error ? err.message : String(err) });
+          },
+          spanContext,
+        };
       },
-    });
+    };
   }
 }

package/src/extensions/posthog/extension.ts

@@ -6,7 +6,8 @@ import * as Effect from 'effect/Effect';
 import { type PostHogConfig } from 'posthog-js';
 
 import { type Config } from '@dxos/config';
-import { LogBuffer, log } from '@dxos/log';
+import { log } from '@dxos/log';
+import { type IdbLogStore } from '@dxos/log-store-idb';
 
 import { type Extension } from '../../observability-extension';
 import { stubExtension } from '../stub';
@@ -18,8 +19,12 @@ export type ExtensionsOptions = {
   /** Deployment environment, e.g. `production` or `staging`. */
   environment?: string;
   posthog?: Partial<PostHogConfig>;
-  /** Shared log buffer for debug log dumps. Creates a local one if not provided. */
-  logBuffer?: LogBuffer;
+  /**
+   * Shared persistent log store for debug log dumps.
+   * The owning app is expected to register `logStore.processor` with `log` itself —
+   * this extension only consumes the buffered logs (via `export()`).
+   */
+  logStore?: IdbLogStore;
 };
 
 /** Upload serialized logs to the feedback-logs endpoint. Returns the R2 key on success. */
@@ -48,7 +53,7 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
   release,
   environment,
   posthog: posthogConfig,
-  logBuffer: externalLogBuffer,
+  logStore,
 }) {
   if (typeof window === 'undefined') {
     log('PostHog is being stubbed because it is running in a worker.');
@@ -65,7 +70,6 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
 
   const { default: posthog } = yield* Effect.promise(() => import('posthog-js'));
   const { logProcessor } = yield* Effect.promise(() => import('./log-processor'));
-  const logBuffer = externalLogBuffer ?? new LogBuffer();
   let feedbackSurveyAvailable: boolean | null = null;
   let unregisterPosthogProcessors: (() => void) | undefined;
 
@@ -103,10 +107,8 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
         }
         unregisterPosthogProcessors?.();
         const removePosthogLog = log.addProcessor(logProcessor);
-        const removeLogBuffer = log.addProcessor(logBuffer.logProcessor);
         unregisterPosthogProcessors = () => {
           removePosthogLog();
-          removeLogBuffer();
         };
       }),
     close: () =>
@@ -155,8 +157,11 @@ export const extensions: (options: ExtensionsOptions) => Effect.Effect<Extension
             }
 
             let debugLogDumpKey: string | null = null;
-            if (form.includeLogs !== false && logBuffer.size > 0) {
-              debugLogDumpKey = (await uploadLogs(logBuffer.serialize())) ?? 'failed';
+            if (form.includeLogs !== false && logStore !== undefined) {
+              const ndjson = await logStore.export();
+              if (ndjson.length > 0) {
+                debugLogDumpKey = (await uploadLogs(ndjson)) ?? 'failed';
+              }
             }
 
             // https://posthog.com/docs/surveys/implementing-custom-surveys

package/src/extensions/posthog/log-processor.test.ts

@@ -5,7 +5,7 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 
 import { InvariantViolation } from '@dxos/invariant';
-import { type LogConfig, type LogEntry, LogLevel } from '@dxos/log';
+import { type LogConfig, LogEntry, type LogEntryInit, LogLevel } from '@dxos/log';
 
 // Replace the posthog-js module with a stub so log-processor's top-level import resolves to our mock.
 // Dynamic imports are used so that both the mock and log-processor are loaded after vi.mock is hoisted.
@@ -23,11 +23,12 @@ const baseConfig: LogConfig = {
   processors: [],
 };
 
-const createEntry = (overrides: Partial<LogEntry> = {}): LogEntry => ({
-  level: LogLevel.ERROR,
-  message: 'test error',
-  ...overrides,
-});
+const createEntry = (overrides: Partial<LogEntryInit> = {}): LogEntry =>
+  new LogEntry({
+    level: LogLevel.ERROR,
+    message: 'test error',
+    ...overrides,
+  });
 
 describe('logProcessor', () => {
   beforeEach(() => {