@dxos/tracing 0.8.4-main.dedc0f3 → 0.8.4-main.e00bdcdb52

package/dist/lib/browser/index.mjs

@@ -1,22 +1,105 @@
 // src/api.ts
-import { Context as Context2 } from "@dxos/context";
+import { Context as Context2, LifecycleState, Resource, TRACE_SPAN_ATTRIBUTE } from "@dxos/context";
 
 // src/symbols.ts
-var symbolTracingContext = Symbol("dxos.tracing.context");
+var symbolTracingContext = /* @__PURE__ */ Symbol("dxos.tracing.context");
 var getTracingContext = (target) => {
-  var _target, _symbolTracingContext;
-  return (_target = target)[_symbolTracingContext = symbolTracingContext] ?? (_target[_symbolTracingContext] = {
+  return target[symbolTracingContext] ??= {
     infoProperties: {},
     metricsProperties: {}
-  });
+  };
 };
-var TRACE_SPAN_ATTRIBUTE = "dxos.trace-span";
 
 // src/trace-processor.ts
-import { unrefTimeout } from "@dxos/async";
-import { LogLevel, getContextFromEntry, log } from "@dxos/log";
+import { LogLevel, log } from "@dxos/log";
 import { getPrototypeSpecificInstanceId } from "@dxos/util";
 
+// src/buffering-backend.ts
+var BUFFERED_PREFIX = "buffered-";
+var BufferedSpan = class {
+  options;
+  spanContext;
+  startTime;
+  delegate;
+  #ended = false;
+  #endTime;
+  #error;
+  #hasError = false;
+  constructor(options, id) {
+    this.options = options;
+    this.spanContext = {
+      traceparent: `${BUFFERED_PREFIX}${id}`
+    };
+    this.startTime = Date.now();
+  }
+  end(endTime) {
+    if (this.delegate) {
+      this.delegate.end(endTime);
+      return;
+    }
+    this.#endTime = endTime ?? Date.now();
+    this.#ended = true;
+  }
+  setError(err) {
+    if (this.delegate) {
+      this.delegate.setError?.(err);
+      return;
+    }
+    this.#error = err;
+    this.#hasError = true;
+  }
+  replay(real) {
+    if (this.#hasError) {
+      real.setError?.(this.#error);
+    }
+    if (this.#ended) {
+      real.end(this.#endTime);
+    } else {
+      this.delegate = real;
+    }
+  }
+};
+var BufferingTracingBackend = class {
+  #pending = [];
+  #counter = 0;
+  startSpan(options) {
+    const span2 = new BufferedSpan(options, ++this.#counter);
+    this.#pending.push(span2);
+    return span2;
+  }
+  /** Discard all buffered spans without replaying them. */
+  clear() {
+    this.#pending.length = 0;
+  }
+  /**
+  * Replay all buffered spans into {@link backend}.
+  *
+  * @returns Map from synthetic buffered traceparent to real {@link TraceContextData},
+  *   used by the post-drain translating wrapper to resolve stale buffered IDs
+  *   still present on in-flight {@link Context} objects.
+  */
+  drain(backend) {
+    const idMap = /* @__PURE__ */ new Map();
+    for (const buffered of this.#pending) {
+      let parentContext = buffered.options.parentContext;
+      if (parentContext && parentContext.traceparent.startsWith(BUFFERED_PREFIX)) {
+        parentContext = idMap.get(parentContext.traceparent) ?? parentContext;
+      }
+      const real = backend.startSpan({
+        ...buffered.options,
+        parentContext,
+        startTime: buffered.startTime
+      });
+      if (real.spanContext) {
+        idMap.set(buffered.spanContext.traceparent, real.spanContext);
+      }
+      buffered.replay(real);
+    }
+    this.#pending.length = 0;
+    return idMap;
+  }
+};
+
 // src/diagnostic.ts
 import { asyncTimeout } from "@dxos/async";
 import { invariant } from "@dxos/invariant";
@@ -25,37 +108,27 @@ import { invariant } from "@dxos/invariant";
 var createId = () => Math.random().toString(36).slice(2);
 
 // src/diagnostic.ts
-function _define_property(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var __dxlog_file = "/__w/dxos/dxos/packages/common/tracing/src/diagnostic.ts";
 var DIAGNOSTICS_TIMEOUT = 1e4;
 var TraceDiagnosticImpl = class {
-  unregister() {
-    this._onUnregister();
-  }
+  id;
+  fetch;
+  name;
+  _onUnregister;
   constructor(id, fetch, name, _onUnregister) {
-    _define_property(this, "id", void 0);
-    _define_property(this, "fetch", void 0);
-    _define_property(this, "name", void 0);
-    _define_property(this, "_onUnregister", void 0);
     this.id = id;
     this.fetch = fetch;
     this.name = name;
     this._onUnregister = _onUnregister;
   }
+  unregister() {
+    this._onUnregister();
+  }
 };
 var DiagnosticsManager = class {
+  instanceId = createId();
+  registry = /* @__PURE__ */ new Map();
+  _instanceTag = null;
   get instanceTag() {
     return this._instanceTag;
   }
@@ -81,27 +154,11 @@ var DiagnosticsManager = class {
   }
   async fetch(request) {
     if (request.instanceId != null) {
-      invariant(request.instanceId === this.instanceId, "Invalid instance id", {
-        F: __dxlog_file,
-        L: 82,
-        S: this,
-        A: [
-          "request.instanceId === this.instanceId",
-          "'Invalid instance id'"
-        ]
-      });
+      invariant(request.instanceId === this.instanceId, "Invalid instance id", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 52, S: this, A: ["request.instanceId === this.instanceId", "'Invalid instance id'"] });
     }
     const { id } = request;
     const diagnostic2 = this.registry.get(id);
-    invariant(diagnostic2, "Diagnostic not found", {
-      F: __dxlog_file,
-      L: 86,
-      S: this,
-      A: [
-        "diagnostic",
-        "'Diagnostic not found'"
-      ]
-    });
+    invariant(diagnostic2, "Diagnostic not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 56, S: this, A: ["diagnostic", "'Diagnostic not found'"] });
     try {
       const data = await asyncTimeout(diagnostic2.fetch(), DIAGNOSTICS_TIMEOUT);
       return {
@@ -118,37 +175,31 @@ var DiagnosticsManager = class {
       };
     }
   }
-  constructor() {
-    _define_property(this, "instanceId", createId());
-    _define_property(this, "registry", /* @__PURE__ */ new Map());
-    _define_property(this, "_instanceTag", null);
-  }
 };
 
 // src/diagnostics-channel.ts
 import { Trigger, sleep } from "@dxos/async";
 import { Context } from "@dxos/context";
 import { invariant as invariant2 } from "@dxos/invariant";
-function _define_property2(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var __dxlog_file2 = "/__w/dxos/dxos/packages/common/tracing/src/diagnostics-channel.ts";
 var DEFAULT_CHANNEL_NAME = "dxos-diagnostics";
 var DISCOVER_TIME = 500;
 var DiagnosticsChannel = class _DiagnosticsChannel {
+  _channelName;
   static get supported() {
     return globalThis.BroadcastChannel != null;
   }
+  _ctx = new Context(void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 16 });
+  // Separate channels becauase the client and server may be in the same process.
+  _serveChannel = void 0;
+  _clientChannel = void 0;
+  constructor(_channelName = DEFAULT_CHANNEL_NAME) {
+    this._channelName = _channelName;
+    if (_DiagnosticsChannel.supported) {
+      this._serveChannel = new BroadcastChannel(_channelName);
+      this._clientChannel = new BroadcastChannel(_channelName);
+    }
+  }
   destroy() {
     void this._ctx.dispose();
     this._serveChannel?.close();
@@ -166,15 +217,7 @@ var DiagnosticsChannel = class _DiagnosticsChannel {
     }
   }
   serve(manager) {
-    invariant2(this._serveChannel, void 0, {
-      F: __dxlog_file2,
-      L: 78,
-      S: this,
-      A: [
-        "this._serveChannel",
-        ""
-      ]
-    });
+    invariant2(this._serveChannel, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 43, S: this, A: ["this._serveChannel", ""] });
     const listener = async (event) => {
       switch (event.data.type) {
         case "DIAGNOSTICS_DISCOVER": {
@@ -206,15 +249,7 @@ var DiagnosticsChannel = class _DiagnosticsChannel {
     this._ctx.onDispose(() => this._serveChannel.removeEventListener("message", listener));
   }
   async discover() {
-    invariant2(this._clientChannel, void 0, {
-      F: __dxlog_file2,
-      L: 114,
-      S: this,
-      A: [
-        "this._clientChannel",
-        ""
-      ]
-    });
+    invariant2(this._clientChannel, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 77, S: this, A: ["this._clientChannel", ""] });
     const diagnostics = [];
     const collector = (event) => {
       const data = event.data;
@@ -242,15 +277,7 @@ var DiagnosticsChannel = class _DiagnosticsChannel {
     }
   }
   async fetch(request) {
-    invariant2(this._clientChannel, void 0, {
-      F: __dxlog_file2,
-      L: 147,
-      S: this,
-      A: [
-        "this._clientChannel",
-        ""
-      ]
-    });
+    invariant2(this._clientChannel, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 106, S: this, A: ["this._clientChannel", ""] });
     const requestId = createId();
     const trigger = new Trigger();
     const listener = (event) => {
@@ -274,40 +301,11 @@ var DiagnosticsChannel = class _DiagnosticsChannel {
       this._clientChannel.removeEventListener("message", listener);
     }
   }
-  constructor(_channelName = DEFAULT_CHANNEL_NAME) {
-    _define_property2(this, "_channelName", void 0);
-    _define_property2(this, "_ctx", void 0);
-    _define_property2(this, "_serveChannel", void 0);
-    _define_property2(this, "_clientChannel", void 0);
-    this._channelName = _channelName;
-    this._ctx = new Context(void 0, {
-      F: __dxlog_file2,
-      L: 46
-    });
-    this._serveChannel = void 0;
-    this._clientChannel = void 0;
-    if (_DiagnosticsChannel.supported) {
-      this._serveChannel = new BroadcastChannel(_channelName);
-      this._clientChannel = new BroadcastChannel(_channelName);
-    }
-  }
 };
 
 // src/remote/metrics.ts
-function _define_property3(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var RemoteMetrics = class {
+  _metrics = /* @__PURE__ */ new Set();
   registerProcessor(processor) {
     this._metrics.add(processor);
   }
@@ -323,214 +321,102 @@ var RemoteMetrics = class {
   gauge(name, value, data) {
     return Array.from(this._metrics.values()).map((processor) => processor.gauge(name, value, data));
   }
-  constructor() {
-    _define_property3(this, "_metrics", /* @__PURE__ */ new Set());
-  }
-};
-
-// src/remote/tracing.ts
-function _define_property4(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var RemoteTracing = class {
-  registerProcessor(processor) {
-    this._tracing = processor;
-  }
-  flushSpan(span2) {
-    if (!this._tracing) {
-      return;
-    }
-    if (!span2.endTs) {
-      const remoteSpan = this._tracing.startSpan({
-        name: span2.methodName,
-        op: span2.op ?? "function",
-        attributes: span2.attributes
-      });
-      this._spanMap.set(span2, remoteSpan);
-    } else {
-      const remoteSpan = this._spanMap.get(span2);
-      if (remoteSpan) {
-        remoteSpan.end();
-        this._spanMap.delete(span2);
-      }
-    }
-  }
-  constructor() {
-    _define_property4(this, "_tracing", void 0);
-    _define_property4(this, "_spanMap", /* @__PURE__ */ new Map());
-  }
-};
-
-// src/trace-sender.ts
-import { Stream } from "@dxos/codec-protobuf/stream";
-function _define_property5(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var TraceSender = class {
-  streamTrace(request) {
-    return new Stream(({ ctx, next }) => {
-      const flushEvents = (resources, spans2, logs) => {
-        const event = {
-          resourceAdded: [],
-          resourceRemoved: [],
-          spanAdded: [],
-          logAdded: []
-        };
-        if (resources) {
-          for (const id of resources) {
-            const entry = this._traceProcessor.resources.get(id);
-            if (entry) {
-              event.resourceAdded.push({
-                resource: entry.data
-              });
-            } else {
-              event.resourceRemoved.push({
-                id
-              });
-            }
-          }
-        } else {
-          for (const entry of this._traceProcessor.resources.values()) {
-            event.resourceAdded.push({
-              resource: entry.data
-            });
-          }
-        }
-        if (spans2) {
-          for (const id of spans2) {
-            const span2 = this._traceProcessor.spans.get(id);
-            if (span2) {
-              event.spanAdded.push({
-                span: span2
-              });
-            }
-          }
-        } else {
-          for (const span2 of this._traceProcessor.spans.values()) {
-            event.spanAdded.push({
-              span: span2
-            });
-          }
-        }
-        if (logs) {
-          for (const log2 of logs) {
-            event.logAdded.push({
-              log: log2
-            });
-          }
-        } else {
-          for (const log2 of this._traceProcessor.logs) {
-            event.logAdded.push({
-              log: log2
-            });
-          }
-        }
-        if (event.resourceAdded.length > 0 || event.resourceRemoved.length > 0 || event.spanAdded.length > 0) {
-          next(event);
-        }
-      };
-      const flush = () => {
-        flushEvents(subscription.dirtyResources, subscription.dirtySpans, subscription.newLogs);
-        subscription.dirtyResources.clear();
-        subscription.dirtySpans.clear();
-        subscription.newLogs.length = 0;
-      };
-      const subscription = {
-        flush,
-        dirtyResources: /* @__PURE__ */ new Set(),
-        dirtySpans: /* @__PURE__ */ new Set(),
-        newLogs: []
-      };
-      this._traceProcessor.subscriptions.add(subscription);
-      ctx.onDispose(() => {
-        this._traceProcessor.subscriptions.delete(subscription);
-      });
-      flushEvents(null, null, null);
-    });
-  }
-  constructor(_traceProcessor) {
-    _define_property5(this, "_traceProcessor", void 0);
-    this._traceProcessor = _traceProcessor;
-  }
 };
 
 // src/weak-ref.ts
 var WeakRefMock = class {
-  deref() {
-    return void 0;
-  }
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor
   constructor(target) {
   }
+  deref() {
+    return void 0;
+  }
 };
 var WeakRef = globalThis.WeakRef ?? WeakRefMock;
 
 // src/trace-processor.ts
-function _define_property6(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-var _globalThis;
 var __dxlog_file3 = "/__w/dxos/dxos/packages/common/tracing/src/trace-processor.ts";
 var ResourceEntry = class {
-  getMetric(name) {
-    return this.data.metrics?.find((metric) => metric.name === name);
-  }
+  data;
+  instance;
+  annotation;
+  /**
+  * Sometimes bundlers mangle class names: WebFile -> WebFile2.
+  *
+  * We use a heuristic to remove the suffix.
+  */
+  sanitizedClassName;
   constructor(data, instance, annotation) {
-    _define_property6(this, "data", void 0);
-    _define_property6(this, "instance", void 0);
-    _define_property6(this, "annotation", void 0);
-    _define_property6(this, "sanitizedClassName", void 0);
     this.data = data;
     this.instance = instance;
     this.annotation = annotation;
     this.sanitizedClassName = sanitizeClassName(data.className);
   }
+  getMetric(name) {
+    return this.data.metrics?.find((metric) => metric.name === name);
+  }
 };
 var MAX_RESOURCE_RECORDS = 2e3;
-var MAX_SPAN_RECORDS = 1e3;
 var MAX_LOG_RECORDS = 1e3;
-var REFRESH_INTERVAL = 1e3;
 var MAX_INFO_OBJECT_DEPTH = 8;
-var IS_CLOUDFLARE_WORKERS = !!globalThis?.navigator?.userAgent?.includes("Cloudflare-Workers");
 var TraceProcessor = class {
+  diagnostics = new DiagnosticsManager();
+  diagnosticsChannel = new DiagnosticsChannel();
+  remoteMetrics = new RemoteMetrics();
+  #bufferingBackend = new BufferingTracingBackend();
+  #activeBackend = this.#bufferingBackend;
+  /**
+  * Tracing backend. Initially a buffering backend that records spans;
+  * once the observability package sets a real backend, the buffer is drained
+  * and a thin translating wrapper is installed that resolves stale buffered
+  * parent IDs still held by in-flight {@link Context} objects.
+  *
+  * The wrapper only allocates when a `buffered-*` parent is actually encountered;
+  * the common path is a single `startsWith` check and direct passthrough.
+  */
+  get tracingBackend() {
+    return this.#activeBackend;
+  }
+  set tracingBackend(backend) {
+    if (!backend || backend === this.#bufferingBackend) {
+      this.#bufferingBackend.clear();
+      this.#activeBackend = this.#bufferingBackend;
+      return;
+    }
+    const idMap = this.#bufferingBackend.drain(backend);
+    this.#activeBackend = {
+      startSpan: (options) => {
+        const parent = options.parentContext;
+        if (parent?.traceparent.startsWith(BUFFERED_PREFIX)) {
+          const translated = idMap.get(parent.traceparent);
+          if (translated) {
+            return backend.startSpan({
+              ...options,
+              parentContext: translated
+            });
+          }
+        }
+        return backend.startSpan(options);
+      }
+    };
+  }
+  resources = /* @__PURE__ */ new Map();
+  resourceInstanceIndex = /* @__PURE__ */ new WeakMap();
+  resourceIdList = [];
+  logs = [];
+  _instanceTag = null;
+  constructor() {
+    log.addProcessor(this._logProcessor.bind(this), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 80, S: this });
+    if (DiagnosticsChannel.supported) {
+      this.diagnosticsChannel.serve(this.diagnostics);
+    }
+    this.diagnosticsChannel.unref();
+  }
   setInstanceTag(tag) {
     this._instanceTag = tag;
     this.diagnostics.setInstanceTag(tag);
   }
-  /**
-  * @internal
-  */
-  // TODO(burdon): Comment.
+  /** @internal */
   createTraceResource(params) {
     const id = this.resources.size;
     const tracingContext = getTracingContext(Object.getPrototypeOf(params.instance));
@@ -551,24 +437,10 @@ var TraceProcessor = class {
     if (this.resourceIdList.length > MAX_RESOURCE_RECORDS) {
       this._clearResources();
     }
-    this._markResourceDirty(id);
-  }
-  createTraceSender() {
-    return new TraceSender(this);
-  }
-  traceSpan(params) {
-    const span2 = new TracingSpan(this, params);
-    this._flushSpan(span2);
-    return span2;
   }
   // TODO(burdon): Not implemented.
   addLink(parent, child, opts) {
   }
-  //
-  // Getters
-  //
-  // TODO(burdon): Define type.
-  // TODO(burdon): Reconcile with system service.
   getDiagnostics() {
     this.refresh();
     return {
@@ -576,7 +448,6 @@ var TraceProcessor = class {
         `${entry.sanitizedClassName}#${entry.data.instanceId}`,
         entry.data
       ])),
-      spans: Array.from(this.spans.values()),
       logs: this.logs.filter((log2) => log2.level >= LogLevel.INFO)
     };
   }
@@ -631,43 +502,8 @@ var TraceProcessor = class {
       for (const key of Object.keys(tracingContext.metricsProperties)) {
         instance[key]._tick?.(time);
       }
-      let _changed = false;
-      const oldInfo = resource2.data.info;
       resource2.data.info = this.getResourceInfo(instance);
-      _changed || (_changed = !areEqualShallow(oldInfo, resource2.data.info));
-      const oldMetrics = resource2.data.metrics;
       resource2.data.metrics = this.getResourceMetrics(instance);
-      _changed || (_changed = !areEqualShallow(oldMetrics, resource2.data.metrics));
-      this._markResourceDirty(resource2.data.id);
-    }
-    for (const subscription of this.subscriptions) {
-      subscription.flush();
-    }
-  }
-  //
-  // Implementation
-  //
-  /**
-  * @internal
-  */
-  _flushSpan(runtimeSpan) {
-    const span2 = runtimeSpan.serialize();
-    this.spans.set(span2.id, span2);
-    this.spanIdList.push(span2.id);
-    if (this.spanIdList.length > MAX_SPAN_RECORDS) {
-      this._clearSpans();
-    }
-    this._markSpanDirty(span2.id);
-    this.remoteTracing.flushSpan(runtimeSpan);
-  }
-  _markResourceDirty(id) {
-    for (const subscription of this.subscriptions) {
-      subscription.dirtyResources.add(id);
-    }
-  }
-  _markSpanDirty(id) {
-    for (const subscription of this.subscriptions) {
-      subscription.dirtySpans.add(id);
     }
   }
   _clearResources() {
@@ -676,175 +512,48 @@ var TraceProcessor = class {
       this.resources.delete(id);
     }
   }
-  _clearSpans() {
-    while (this.spanIdList.length > MAX_SPAN_RECORDS) {
-      const id = this.spanIdList.shift();
-      this.spans.delete(id);
-    }
-  }
   _pushLog(log2) {
     this.logs.push(log2);
     if (this.logs.length > MAX_LOG_RECORDS) {
       this.logs.shift();
     }
-    for (const subscription of this.subscriptions) {
-      subscription.newLogs.push(log2);
-    }
   }
-  constructor() {
-    _define_property6(this, "diagnostics", new DiagnosticsManager());
-    _define_property6(this, "diagnosticsChannel", new DiagnosticsChannel());
-    _define_property6(this, "remoteMetrics", new RemoteMetrics());
-    _define_property6(this, "remoteTracing", new RemoteTracing());
-    _define_property6(this, "subscriptions", /* @__PURE__ */ new Set());
-    _define_property6(this, "resources", /* @__PURE__ */ new Map());
-    _define_property6(this, "resourceInstanceIndex", /* @__PURE__ */ new WeakMap());
-    _define_property6(this, "resourceIdList", []);
-    _define_property6(this, "spans", /* @__PURE__ */ new Map());
-    _define_property6(this, "spanIdList", []);
-    _define_property6(this, "logs", []);
-    _define_property6(this, "_instanceTag", null);
-    _define_property6(this, "_logProcessor", (config, entry) => {
-      switch (entry.level) {
-        case LogLevel.ERROR:
-        case LogLevel.WARN:
-        case LogLevel.TRACE: {
-          const scope = entry.meta?.S;
-          const resource2 = this.resourceInstanceIndex.get(scope);
-          if (!resource2) {
-            return;
-          }
-          const context = getContextFromEntry(entry) ?? {};
-          for (const key of Object.keys(context)) {
-            context[key] = sanitizeValue(context[key], 0, this);
-          }
-          const entryToPush = {
-            level: entry.level,
-            message: entry.message ?? (entry.error ? entry.error.message ?? String(entry.error) : ""),
-            context,
-            timestamp: /* @__PURE__ */ new Date(),
-            meta: {
-              file: entry.meta?.F ?? "",
-              line: entry.meta?.L ?? 0,
-              resourceId: resource2.data.id
-            }
-          };
-          this._pushLog(entryToPush);
-          break;
+  _logProcessor = (config, entry) => {
+    switch (entry.level) {
+      case LogLevel.ERROR:
+      case LogLevel.WARN:
+      case LogLevel.TRACE: {
+        const scope = entry.meta?.S;
+        const resource2 = this.resourceInstanceIndex.get(scope);
+        if (!resource2) {
+          return;
         }
-        default:
-      }
-    });
-    log.addProcessor(this._logProcessor.bind(this), void 0, {
-      F: __dxlog_file3,
-      L: 103,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!IS_CLOUDFLARE_WORKERS) {
-      const refreshInterval = setInterval(this.refresh.bind(this), REFRESH_INTERVAL);
-      unrefTimeout(refreshInterval);
-    }
-    if (DiagnosticsChannel.supported) {
-      this.diagnosticsChannel.serve(this.diagnostics);
-    }
-    this.diagnosticsChannel.unref();
-  }
-};
-var TracingSpan = class _TracingSpan {
-  get name() {
-    const resource2 = this._traceProcessor.resources.get(this.resourceId);
-    return resource2 ? `${resource2.sanitizedClassName}#${resource2.data.instanceId}.${this.methodName}` : this.methodName;
-  }
-  get ctx() {
-    return this._ctx;
-  }
-  markSuccess() {
-    this.endTs = performance.now();
-    this._traceProcessor._flushSpan(this);
-    if (this._showInBrowserTimeline) {
-      this._markInBrowserTimeline();
-    }
-  }
-  markError(err) {
-    this.endTs = performance.now();
-    this.error = serializeError(err);
-    this._traceProcessor._flushSpan(this);
-    if (this._showInBrowserTimeline) {
-      this._markInBrowserTimeline();
-    }
-  }
-  serialize() {
-    return {
-      id: this.id,
-      resourceId: this.resourceId ?? void 0,
-      methodName: this.methodName,
-      parentId: this.parentId ?? void 0,
-      startTs: this.startTs.toFixed(3),
-      endTs: this.endTs?.toFixed(3) ?? void 0,
-      error: this.error ?? void 0
-    };
-  }
-  _markInBrowserTimeline() {
-    if (typeof globalThis?.performance?.measure === "function") {
-      performance.measure(this.name, {
-        start: this.startTs,
-        end: this.endTs
-      });
-    }
-  }
-  constructor(_traceProcessor, params) {
-    _define_property6(this, "_traceProcessor", void 0);
-    _define_property6(this, "id", void 0);
-    _define_property6(this, "parentId", void 0);
-    _define_property6(this, "methodName", void 0);
-    _define_property6(this, "resourceId", void 0);
-    _define_property6(this, "op", void 0);
-    _define_property6(this, "attributes", void 0);
-    _define_property6(this, "startTs", void 0);
-    _define_property6(this, "endTs", void 0);
-    _define_property6(this, "error", void 0);
-    _define_property6(this, "_showInBrowserTimeline", void 0);
-    _define_property6(this, "_ctx", void 0);
-    this._traceProcessor = _traceProcessor;
-    this.parentId = null;
-    this.resourceId = null;
-    this.endTs = null;
-    this.error = null;
-    this._ctx = null;
-    this.id = _TracingSpan.nextId++;
-    this.methodName = params.methodName;
-    this.resourceId = _traceProcessor.getResourceId(params.instance);
-    this.startTs = performance.now();
-    this._showInBrowserTimeline = params.showInBrowserTimeline;
-    this.op = params.op;
-    this.attributes = params.attributes ?? {};
-    if (params.parentCtx) {
-      this._ctx = params.parentCtx.derive({
-        attributes: {
-          [TRACE_SPAN_ATTRIBUTE]: this.id
+        const context = {
+          ...entry.computedContext
+        };
+        if (entry.computedError !== void 0) {
+          context.error = entry.computedError;
         }
-      });
-      const parentId = params.parentCtx.getAttribute(TRACE_SPAN_ATTRIBUTE);
-      if (typeof parentId === "number") {
-        this.parentId = parentId;
+        const { filename, line } = entry.computedMeta;
+        const entryToPush = {
+          level: entry.level,
+          message: entry.message ?? entry.computedError ?? "",
+          context,
+          timestamp: new Date(entry.timestamp),
+          meta: {
+            file: filename ?? "",
+            line: line ?? 0,
+            resourceId: resource2.data.id
+          }
+        };
+        this._pushLog(entryToPush);
+        break;
       }
+      default:
     }
-  }
-};
-_define_property6(TracingSpan, "nextId", 0);
-var serializeError = (err) => {
-  if (err instanceof Error) {
-    return {
-      name: err.name,
-      message: err.message
-    };
-  }
-  return {
-    message: String(err)
   };
 };
-var TRACE_PROCESSOR = (_globalThis = globalThis).TRACE_PROCESSOR ?? (_globalThis.TRACE_PROCESSOR = new TraceProcessor());
+var TRACE_PROCESSOR = globalThis.TRACE_PROCESSOR ??= new TraceProcessor();
 var sanitizeValue = (value, depth, traceProcessor) => {
   switch (typeof value) {
     case "string":
@@ -890,46 +599,115 @@ var sanitizeValue = (value, depth, traceProcessor) => {
       return value.toString();
   }
 };
-var areEqualShallow = (a, b) => {
-  for (const key in a) {
-    if (!(key in b) || a[key] !== b[key]) {
-      return false;
-    }
-  }
-  for (const key in b) {
-    if (!(key in a) || a[key] !== b[key]) {
-      return false;
-    }
-  }
-  return true;
-};
 var sanitizeClassName = (className) => {
+  let name = className.replace(/^_+/, "");
   const SANITIZE_REGEX = /[^_](\d+)$/;
-  const m = className.match(SANITIZE_REGEX);
-  if (!m) {
-    return className;
-  } else {
-    return className.slice(0, -m[1].length);
+  const m = name.match(SANITIZE_REGEX);
+  if (m) {
+    name = name.slice(0, -m[1].length);
   }
+  return name;
 };
 var isSetLike = (value) => value instanceof Set || typeof value === "object" && value !== null && Object.getPrototypeOf(value).constructor.name === "ComplexSet";
 var isMapLike = (value) => value instanceof Map || typeof value === "object" && value !== null && Object.getPrototypeOf(value).constructor.name === "ComplexMap";
 
 // src/api.ts
-var resource = (options) => (constructor) => {
-  const klass = /* @__PURE__ */ (() => {
-    class _class extends constructor {
-      constructor(...rest) {
-        super(...rest);
-        TRACE_PROCESSOR.createTraceResource({
-          constructor,
-          annotation: options?.annotation,
-          instance: this
-        });
+var __dxlog_file4 = "/__w/dxos/dxos/packages/common/tracing/src/api.ts";
+var LIFECYCLE_SPAN = /* @__PURE__ */ Symbol("dxos.tracing.lifecycle-span");
+var TRACE_ALL_KEY = "dxos.debug.traceAll";
+var collectSpanAttributes = (instance, spanAttributes) => {
+  const proto = Object.getPrototypeOf(instance);
+  if (!proto) {
+    return;
+  }
+  const tracingContext = getTracingContext(proto);
+  for (const [key, { options }] of Object.entries(tracingContext.infoProperties)) {
+    if (!options.spanAttribute) {
+      continue;
+    }
+    try {
+      const value = typeof instance[key] === "function" ? instance[key]() : instance[key];
+      if (value != null) {
+        const resolved = options.enum ? options.enum[value] : String(value);
+        spanAttributes[`ctx.${key}`] = resolved;
       }
+    } catch {
+    }
+  }
+};
+var resource = (options) => (constructor) => {
+  if (options?.lifecycle && !(constructor.prototype instanceof Resource)) {
+    throw new Error(`@trace.resource({ lifecycle: true }) requires ${constructor.name} to extend Resource`);
+  }
+  const klass = /* @__PURE__ */ (() => class extends constructor {
+    constructor(...rest) {
+      super(...rest);
+      TRACE_PROCESSOR.createTraceResource({
+        constructor,
+        annotation: options?.annotation,
+        instance: this
+      });
     }
-    return _class;
   })();
+  if (options?.lifecycle) {
+    const sanitizedName = sanitizeClassName(constructor.name);
+    const proto = klass.prototype;
+    const originalOpen = proto.open;
+    const originalClose = proto.close;
+    proto.open = async function(ctx) {
+      const self = this;
+      if (self._lifecycleState !== LifecycleState.CLOSED) {
+        return originalOpen.call(this, ctx);
+      }
+      const parentSpanContext = ctx?.getAttribute(TRACE_SPAN_ATTRIBUTE);
+      const resourceEntry = TRACE_PROCESSOR.resourceInstanceIndex.get(this);
+      const spanAttributes = {};
+      if (resourceEntry) {
+        spanAttributes.entryPoint = resourceEntry.sanitizedClassName;
+      }
+      const remoteSpan = TRACE_PROCESSOR.tracingBackend?.startSpan({
+        name: `${sanitizedName}.lifecycle`,
+        op: "lifecycle",
+        attributes: spanAttributes,
+        parentContext: parentSpanContext
+      });
+      self[LIFECYCLE_SPAN] = remoteSpan;
+      let openCtx = ctx;
+      if (remoteSpan?.spanContext != null) {
+        const traceAttrs = {
+          [TRACE_SPAN_ATTRIBUTE]: remoteSpan.spanContext
+        };
+        openCtx = ctx ? ctx.derive({
+          attributes: traceAttrs
+        }) : new Context2({
+          attributes: traceAttrs
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 79 });
+      }
+      try {
+        return await originalOpen.call(this, openCtx);
+      } catch (err) {
+        remoteSpan?.setError?.(err);
+        remoteSpan?.end();
+        self[LIFECYCLE_SPAN] = void 0;
+        throw err;
+      }
+    };
+    proto.close = async function(ctx) {
+      const self = this;
+      const remoteSpan = self[LIFECYCLE_SPAN];
+      try {
+        return await originalClose.call(this, ctx);
+      } catch (err) {
+        remoteSpan?.setError?.(err);
+        throw err;
+      } finally {
+        if (remoteSpan) {
+          remoteSpan.end();
+          self[LIFECYCLE_SPAN] = void 0;
+        }
+      }
+    };
+  }
   Object.defineProperty(klass, "name", {
     value: constructor.name
   });
@@ -943,45 +721,117 @@ var info = (opts = {}) => (target, propertyKey, descriptor) => {
 var mark = (name) => {
   performance.mark(name);
 };
-var span = ({ showInBrowserTimeline = false, op, attributes } = {}) => (target, propertyKey, descriptor) => {
+var span = ({ showInBrowserTimeline = false, showInRemoteTracing = true, op, attributes } = {}) => (target, propertyKey, descriptor) => {
   const method = descriptor.value;
   descriptor.value = async function(...args) {
     const parentCtx = args[0] instanceof Context2 ? args[0] : null;
-    const span2 = TRACE_PROCESSOR.traceSpan({
-      parentCtx,
-      methodName: propertyKey,
-      instance: this,
-      showInBrowserTimeline,
-      op,
-      attributes
-    });
-    const callArgs = span2.ctx ? [
-      span2.ctx,
-      ...args.slice(1)
-    ] : args;
+    const startTs = performance.now();
+    const parentSpanContext = parentCtx?.getAttribute(TRACE_SPAN_ATTRIBUTE);
+    const resourceEntry = TRACE_PROCESSOR.resourceInstanceIndex.get(this);
+    const className = resourceEntry?.sanitizedClassName ?? sanitizeClassName(target.constructor?.name ?? "unknown");
+    const spanName = `${className}.${propertyKey}`;
+    const spanAttributes = {};
+    if (resourceEntry) {
+      spanAttributes.entryPoint = resourceEntry.sanitizedClassName;
+    }
+    collectSpanAttributes(this, spanAttributes);
+    if (attributes) {
+      for (const [key, value] of Object.entries(attributes)) {
+        spanAttributes[key.startsWith("ctx.") ? key : `ctx.${key}`] = value;
+      }
+    }
+    const remoteSpan = showInRemoteTracing ? TRACE_PROCESSOR.tracingBackend?.startSpan({
+      name: spanName,
+      op: op ?? "function",
+      attributes: spanAttributes,
+      parentContext: parentSpanContext
+    }) : void 0;
+    let callArgs = args;
+    if (parentCtx) {
+      const childCtx = remoteSpan?.spanContext != null ? parentCtx.derive({
+        attributes: {
+          [TRACE_SPAN_ATTRIBUTE]: remoteSpan.spanContext
+        }
+      }) : parentCtx.derive();
+      callArgs = [
+        childCtx,
+        ...args.slice(1)
+      ];
+    }
     try {
       return await method.apply(this, callArgs);
     } catch (err) {
-      span2.markError(err);
+      remoteSpan?.setError?.(err);
       throw err;
     } finally {
-      span2.markSuccess();
+      remoteSpan?.end();
+      if (showInBrowserTimeline && typeof globalThis?.performance?.measure === "function") {
+        performance.measure(spanName, {
+          start: startTs,
+          end: performance.now()
+        });
+      }
     }
   };
 };
-var spans = /* @__PURE__ */ new Map();
+var manualSpans = /* @__PURE__ */ new Map();
+var manualSpanTimestamps = /* @__PURE__ */ new Map();
 var spanStart = (params) => {
-  if (spans.has(params.id)) {
-    return;
+  if (manualSpans.has(params.id) || manualSpanTimestamps.has(params.id)) {
+    return params.parentCtx;
+  }
+  const resourceEntry = TRACE_PROCESSOR.resourceInstanceIndex.get(params.instance);
+  const className = resourceEntry?.sanitizedClassName ?? "unknown";
+  const spanName = `${className}.${params.methodName}`;
+  if (params.showInBrowserTimeline) {
+    manualSpanTimestamps.set(params.id, {
+      name: spanName,
+      startTs: performance.now()
+    });
+  }
+  if (params.showInRemoteTracing === false || !TRACE_PROCESSOR.tracingBackend) {
+    return params.parentCtx;
+  }
+  const parentSpanContext = params.parentCtx?.getAttribute(TRACE_SPAN_ATTRIBUTE);
+  const spanAttributes = {};
+  if (resourceEntry) {
+    spanAttributes.entryPoint = resourceEntry.sanitizedClassName;
+  }
+  collectSpanAttributes(params.instance, spanAttributes);
+  if (params.attributes) {
+    for (const [key, value] of Object.entries(params.attributes)) {
+      spanAttributes[key.startsWith("ctx.") ? key : `ctx.${key}`] = value;
+    }
+  }
+  const remoteSpan = TRACE_PROCESSOR.tracingBackend.startSpan({
+    name: spanName,
+    op: params.op ?? "function",
+    attributes: spanAttributes,
+    parentContext: parentSpanContext
+  });
+  manualSpans.set(params.id, remoteSpan);
+  if (params.parentCtx && remoteSpan.spanContext != null) {
+    return params.parentCtx.derive({
+      attributes: {
+        [TRACE_SPAN_ATTRIBUTE]: remoteSpan.spanContext
+      }
+    });
   }
-  const span2 = TRACE_PROCESSOR.traceSpan(params);
-  spans.set(params.id, span2);
+  return params.parentCtx;
 };
 var spanEnd = (id) => {
-  const span2 = spans.get(id);
-  if (span2) {
-    span2.markSuccess();
-    spans.delete(id);
+  const remoteSpan = manualSpans.get(id);
+  if (remoteSpan) {
+    remoteSpan.end();
+    manualSpans.delete(id);
+  }
+  const timestamps = manualSpanTimestamps.get(id);
+  if (timestamps && typeof globalThis?.performance?.measure === "function") {
+    performance.measure(timestamps.name, {
+      start: timestamps.startTs,
+      end: performance.now()
+    });
+    manualSpanTimestamps.delete(id);
   }
 };
 var metricsCounter = () => (target, propertyKey, descriptor) => {
@@ -1007,20 +857,12 @@ var trace = {
 };
 
 // src/metrics/base.ts
-function _define_property7(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var BaseCounter = class {
+  /**
+  * @internal
+  */
+  _instance;
+  name;
   /**
   * @internal
   */
@@ -1030,27 +872,16 @@ var BaseCounter = class {
   }
   _tick(time) {
   }
-  constructor() {
-    _define_property7(this, "_instance", void 0);
-    _define_property7(this, "name", void 0);
-  }
 };
 
 // src/metrics/unary-counter.ts
-function _define_property8(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var UnaryCounter = class extends BaseCounter {
+  value = 0;
+  units;
+  constructor({ units } = {}) {
+    super();
+    this.units = units;
+  }
   inc(by = 1) {
     this.value += by;
   }
@@ -1063,28 +894,19 @@ var UnaryCounter = class extends BaseCounter {
       }
     };
   }
-  constructor({ units } = {}) {
-    super(), _define_property8(this, "value", 0), _define_property8(this, "units", void 0);
-    this.units = units;
-  }
 };
 
 // src/metrics/time-series-counter.ts
-function _define_property9(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var MAX_BUCKETS = 60;
 var TimeSeriesCounter = class extends BaseCounter {
+  _currentValue = 0;
+  _totalValue = 0;
+  _buckets = [];
+  units;
+  constructor({ units } = {}) {
+    super();
+    this.units = units;
+  }
   inc(by = 1) {
     this._currentValue += by;
     this._totalValue += by;
@@ -1113,28 +935,15 @@ var TimeSeriesCounter = class extends BaseCounter {
       }
     };
   }
-  constructor({ units } = {}) {
-    super(), _define_property9(this, "_currentValue", 0), _define_property9(this, "_totalValue", 0), _define_property9(this, "_buckets", []), _define_property9(this, "units", void 0);
-    this.units = units;
-  }
 };
 
 // src/metrics/time-usage-counter.ts
-function _define_property10(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var MAX_BUCKETS2 = 60;
 var TimeUsageCounter = class extends BaseCounter {
+  _currentValue = 0;
+  _totalValue = 0;
+  _buckets = [];
+  _lastTickTime = performance.now();
   record(time) {
     this._currentValue += time;
     this._totalValue += time;
@@ -1175,26 +984,16 @@ var TimeUsageCounter = class extends BaseCounter {
       }
     };
   }
-  constructor(...args) {
-    super(...args), _define_property10(this, "_currentValue", 0), _define_property10(this, "_totalValue", 0), _define_property10(this, "_buckets", []), _define_property10(this, "_lastTickTime", performance.now());
-  }
 };
 
 // src/metrics/map-counter.ts
-function _define_property11(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var MapCounter = class extends BaseCounter {
+  values = /* @__PURE__ */ new Map();
+  units;
+  constructor({ units } = {}) {
+    super();
+    this.units = units;
+  }
   inc(key, by = 1) {
     const prev = this.values.get(key) ?? 0;
     this.values.set(key, prev + by);
@@ -1211,27 +1010,14 @@ var MapCounter = class extends BaseCounter {
       }
     };
   }
-  constructor({ units } = {}) {
-    super(), _define_property11(this, "values", /* @__PURE__ */ new Map()), _define_property11(this, "units", void 0);
-    this.units = units;
-  }
 };
 
 // src/metrics/custom-counter.ts
-function _define_property12(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
 var CustomCounter = class extends BaseCounter {
+  _getData;
+  constructor(_getData) {
+    super(), this._getData = _getData;
+  }
   getData() {
     return {
       name: this.name,
@@ -1240,9 +1026,6 @@ var CustomCounter = class extends BaseCounter {
       }
     };
   }
-  constructor(_getData) {
-    super(), _define_property12(this, "_getData", void 0), this._getData = _getData;
-  }
 };
 
 // src/index.ts
@@ -1266,16 +1049,13 @@ export {
   DiagnosticsManager,
   MapCounter,
   RemoteMetrics,
-  RemoteTracing,
   ResourceEntry,
+  TRACE_ALL_KEY,
   TRACE_PROCESSOR,
-  TRACE_SPAN_ATTRIBUTE,
   TimeSeriesCounter,
   TimeUsageCounter,
   TraceDiagnosticImpl,
   TraceProcessor,
-  TraceSender,
-  TracingSpan,
   UnaryCounter,
   getTracingContext,
   sanitizeClassName,