@dxos/tracing 0.10.0 → 0.11.1

package/dist/lib/node-esm/index.mjs

@@ -1,1067 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-
-// src/api.ts
-import { Context as Context2, LifecycleState, Resource, TRACE_SPAN_ATTRIBUTE } from "@dxos/context";
-
-// src/symbols.ts
-var symbolTracingContext = /* @__PURE__ */ Symbol("dxos.tracing.context");
-var getTracingContext = (target) => {
-  return target[symbolTracingContext] ??= {
-    infoProperties: {},
-    metricsProperties: {}
-  };
-};
-
-// src/trace-processor.ts
-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";
-
-// src/util.ts
-var createId = () => Math.random().toString(36).slice(2);
-
-// src/diagnostic.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/common/tracing/src/diagnostic.ts";
-var DIAGNOSTICS_TIMEOUT = 1e4;
-var TraceDiagnosticImpl = class {
-  id;
-  fetch;
-  name;
-  _onUnregister;
-  constructor(id, fetch, name, _onUnregister) {
-    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;
-  }
-  setInstanceTag(tag) {
-    this._instanceTag = tag;
-  }
-  registerDiagnostic(params) {
-    const impl = new TraceDiagnosticImpl(params.id, params.fetch, params.name ?? params.id, () => {
-      if (this.registry.get(params.id) === impl) {
-        this.registry.delete(params.id);
-      }
-    });
-    this.registry.set(params.id, impl);
-    return impl;
-  }
-  list() {
-    return Array.from(this.registry.values()).map((diagnostic2) => ({
-      id: diagnostic2.id,
-      instanceId: this.instanceId,
-      instanceTag: this._instanceTag,
-      name: diagnostic2.name
-    }));
-  }
-  async fetch(request) {
-    if (request.instanceId != null) {
-      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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 56, S: this, A: ["diagnostic", "'Diagnostic not found'"] });
-    try {
-      const data = await asyncTimeout(diagnostic2.fetch(), DIAGNOSTICS_TIMEOUT);
-      return {
-        id,
-        instanceId: this.instanceId,
-        data
-      };
-    } catch (err) {
-      return {
-        id,
-        instanceId: this.instanceId,
-        data: null,
-        error: err.stack
-      };
-    }
-  }
-};
-
-// src/diagnostics-channel.ts
-import { Trigger, sleep } from "@dxos/async";
-import { Context } from "@dxos/context";
-import { invariant as invariant2 } from "@dxos/invariant";
-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();
-    this._clientChannel?.close();
-  }
-  /**
-  * In node.js, the channel will keep the process alive.
-  * This method allows the process to exit.
-  * Noop in the browser.
-  */
-  unref() {
-    if (this._serveChannel && typeof this._serveChannel.unref === "function") {
-      this._serveChannel.unref();
-      this._clientChannel.unref();
-    }
-  }
-  serve(manager) {
-    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": {
-          const diagnostics = manager.list();
-          this._serveChannel.postMessage({
-            type: "DIAGNOSTICS_ANNOUNCE",
-            diagnostics
-          });
-          break;
-        }
-        case "DIAGNOSTICS_FETCH": {
-          const { requestId, request } = event.data;
-          if (request.instanceId != null && request.instanceId !== manager.instanceId) {
-            break;
-          } else if (request.instanceTag != null && request.instanceTag !== manager.instanceTag) {
-            break;
-          }
-          const data = await manager.fetch(request);
-          this._serveChannel.postMessage({
-            type: "DIAGNOSTICS_RESPONSE",
-            requestId,
-            data
-          });
-          break;
-        }
-      }
-    };
-    this._serveChannel.addEventListener("message", listener);
-    this._ctx.onDispose(() => this._serveChannel.removeEventListener("message", listener));
-  }
-  async discover() {
-    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;
-      switch (data.type) {
-        case "DIAGNOSTICS_ANNOUNCE":
-          diagnostics.push(...data.diagnostics);
-          break;
-      }
-    };
-    try {
-      this._clientChannel.addEventListener("message", collector);
-      this._clientChannel.postMessage({
-        type: "DIAGNOSTICS_DISCOVER"
-      });
-      await sleep(DISCOVER_TIME);
-      const result = [];
-      for (const diagnostic2 of diagnostics) {
-        if (!result.some((d) => d.id === diagnostic2.id && d.instanceId === diagnostic2.instanceId)) {
-          result.push(diagnostic2);
-        }
-      }
-      return diagnostics;
-    } finally {
-      this._clientChannel.removeEventListener("message", collector);
-    }
-  }
-  async fetch(request) {
-    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) => {
-      const data = event.data;
-      if (data.type === "DIAGNOSTICS_RESPONSE" && data.requestId === requestId) {
-        trigger.wake(data.data);
-      }
-    };
-    try {
-      this._clientChannel.addEventListener("message", listener);
-      this._clientChannel.postMessage({
-        type: "DIAGNOSTICS_FETCH",
-        requestId,
-        request
-      });
-      const result = await trigger.wait({
-        timeout: DIAGNOSTICS_TIMEOUT
-      });
-      return result;
-    } finally {
-      this._clientChannel.removeEventListener("message", listener);
-    }
-  }
-};
-
-// src/remote/metrics.ts
-var RemoteMetrics = class {
-  _metrics = /* @__PURE__ */ new Set();
-  registerProcessor(processor) {
-    this._metrics.add(processor);
-  }
-  increment(name, value, data) {
-    return Array.from(this._metrics.values()).map((processor) => processor.increment(name, value, data));
-  }
-  distribution(name, value, data) {
-    return Array.from(this._metrics.values()).map((processor) => processor.distribution(name, value, data));
-  }
-  set(name, value, data) {
-    return Array.from(this._metrics.values()).map((processor) => processor.set(name, value, data));
-  }
-  gauge(name, value, data) {
-    return Array.from(this._metrics.values()).map((processor) => processor.gauge(name, value, data));
-  }
-};
-
-// src/weak-ref.ts
-var WeakRefMock = class {
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  constructor(target) {
-  }
-  deref() {
-    return void 0;
-  }
-};
-var WeakRef = globalThis.WeakRef ?? WeakRefMock;
-
-// src/trace-processor.ts
-var __dxlog_file3 = "/__w/dxos/dxos/packages/common/tracing/src/trace-processor.ts";
-var ResourceEntry = class {
-  data;
-  instance;
-  annotation;
-  /**
-  * Sometimes bundlers mangle class names: WebFile -> WebFile2.
-  *
-  * We use a heuristic to remove the suffix.
-  */
-  sanitizedClassName;
-  constructor(data, instance, annotation) {
-    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_LOG_RECORDS = 1e3;
-var MAX_INFO_OBJECT_DEPTH = 8;
-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 */
-  createTraceResource(params) {
-    const id = this.resources.size;
-    const tracingContext = getTracingContext(Object.getPrototypeOf(params.instance));
-    for (const key of Object.keys(tracingContext.metricsProperties)) {
-      params.instance[key]._assign(params.instance, key);
-    }
-    const entry = new ResourceEntry({
-      id,
-      className: params.constructor.name,
-      instanceId: getPrototypeSpecificInstanceId(params.instance),
-      info: this.getResourceInfo(params.instance),
-      links: [],
-      metrics: this.getResourceMetrics(params.instance)
-    }, new WeakRef(params.instance), params.annotation);
-    this.resources.set(id, entry);
-    this.resourceInstanceIndex.set(params.instance, entry);
-    this.resourceIdList.push(id);
-    if (this.resourceIdList.length > MAX_RESOURCE_RECORDS) {
-      this._clearResources();
-    }
-  }
-  // TODO(burdon): Not implemented.
-  addLink(parent, child, opts) {
-  }
-  getDiagnostics() {
-    this.refresh();
-    return {
-      resources: Object.fromEntries(Array.from(this.resources.entries()).map(([id, entry]) => [
-        `${entry.sanitizedClassName}#${entry.data.instanceId}`,
-        entry.data
-      ])),
-      logs: this.logs.filter((log2) => log2.level >= LogLevel.INFO)
-    };
-  }
-  getResourceInfo(instance) {
-    const res = {};
-    const tracingContext = getTracingContext(Object.getPrototypeOf(instance));
-    for (const [key, { options }] of Object.entries(tracingContext.infoProperties)) {
-      try {
-        const value = typeof instance[key] === "function" ? instance[key]() : instance[key];
-        if (options.enum) {
-          res[key] = options.enum[value];
-        } else {
-          res[key] = sanitizeValue(value, options.depth === void 0 ? 1 : options.depth ?? MAX_INFO_OBJECT_DEPTH, this);
-        }
-      } catch (err) {
-        res[key] = err.message;
-      }
-    }
-    return res;
-  }
-  getResourceMetrics(instance) {
-    const res = [];
-    const tracingContext = getTracingContext(Object.getPrototypeOf(instance));
-    for (const [key, _opts] of Object.entries(tracingContext.metricsProperties)) {
-      res.push(instance[key].getData());
-    }
-    return res;
-  }
-  getResourceId(instance) {
-    const entry = this.resourceInstanceIndex.get(instance);
-    return entry ? entry.data.id : null;
-  }
-  findResourcesByClassName(className) {
-    return [
-      ...this.resources.values()
-    ].filter((res) => res.data.className === className || res.sanitizedClassName === className);
-  }
-  findResourcesByAnnotation(annotation) {
-    return [
-      ...this.resources.values()
-    ].filter((res) => res.annotation === annotation);
-  }
-  refresh() {
-    for (const resource2 of this.resources.values()) {
-      const instance = resource2.instance.deref();
-      if (!instance) {
-        continue;
-      }
-      const tracingContext = getTracingContext(Object.getPrototypeOf(instance));
-      const time = performance.now();
-      instance.tick?.(time);
-      for (const key of Object.keys(tracingContext.metricsProperties)) {
-        instance[key]._tick?.(time);
-      }
-      resource2.data.info = this.getResourceInfo(instance);
-      resource2.data.metrics = this.getResourceMetrics(instance);
-    }
-  }
-  _clearResources() {
-    while (this.resourceIdList.length > MAX_RESOURCE_RECORDS) {
-      const id = this.resourceIdList.shift();
-      this.resources.delete(id);
-    }
-  }
-  _pushLog(log2) {
-    this.logs.push(log2);
-    if (this.logs.length > MAX_LOG_RECORDS) {
-      this.logs.shift();
-    }
-  }
-  _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 = {
-          ...entry.computedContext
-        };
-        if (entry.computedError !== void 0) {
-          context.error = entry.computedError;
-        }
-        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:
-    }
-  };
-};
-var TRACE_PROCESSOR = globalThis.TRACE_PROCESSOR ??= new TraceProcessor();
-var sanitizeValue = (value, depth, traceProcessor) => {
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "undefined":
-      return value;
-    case "object":
-    case "function":
-      if (value === null) {
-        return value;
-      }
-      {
-        const resourceEntry = traceProcessor.resourceInstanceIndex.get(value);
-        if (resourceEntry) {
-          return `${resourceEntry.sanitizedClassName}#${resourceEntry.data.instanceId}`;
-        }
-      }
-      if (typeof value.toJSON === "function") {
-        return sanitizeValue(value.toJSON(), depth, traceProcessor);
-      }
-      if (depth > 0) {
-        if (isSetLike(value)) {
-          return Object.fromEntries(Array.from(value.entries()).map((value2) => sanitizeValue(value2, depth - 1, traceProcessor)));
-        } else if (isMapLike(value)) {
-          return Object.fromEntries(Array.from(value.entries()).map(([key, value2]) => [
-            key,
-            sanitizeValue(value2, depth - 1, traceProcessor)
-          ]));
-        } else if (Array.isArray(value)) {
-          return value.map((item) => sanitizeValue(item, depth - 1, traceProcessor));
-        } else if (typeof value === "object") {
-          const res = {};
-          for (const key of Object.keys(value)) {
-            res[key] = sanitizeValue(value[key], depth - 1, traceProcessor);
-          }
-          return res;
-        }
-      }
-      if (typeof value.truncate === "function") {
-        return value.truncate();
-      }
-      return value.toString();
-  }
-};
-var sanitizeClassName = (className) => {
-  let name = className.replace(/^_+/, "");
-  const SANITIZE_REGEX = /[^_](\d+)$/;
-  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 __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
-      });
-    }
-  })();
-  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
-  });
-  return klass;
-};
-var info = (opts = {}) => (target, propertyKey, descriptor) => {
-  getTracingContext(target).infoProperties[propertyKey] = {
-    options: opts
-  };
-};
-var mark = (name) => {
-  performance.mark(name);
-};
-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 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) {
-      remoteSpan?.setError?.(err);
-      throw err;
-    } finally {
-      remoteSpan?.end();
-      if (showInBrowserTimeline && typeof globalThis?.performance?.measure === "function") {
-        performance.measure(spanName, {
-          start: startTs,
-          end: performance.now()
-        });
-      }
-    }
-  };
-};
-var manualSpans = /* @__PURE__ */ new Map();
-var manualSpanTimestamps = /* @__PURE__ */ new Map();
-var spanStart = (params) => {
-  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
-      }
-    });
-  }
-  return params.parentCtx;
-};
-var spanEnd = (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) => {
-  getTracingContext(target).metricsProperties[propertyKey] = {};
-};
-var addLink = (parent, child, opts = {}) => {
-  TRACE_PROCESSOR.addLink(parent, child, opts);
-};
-var diagnostic = (params) => {
-  return TRACE_PROCESSOR.diagnostics.registerDiagnostic(params);
-};
-var trace = {
-  addLink,
-  diagnostic,
-  info,
-  mark,
-  metricsCounter,
-  resource,
-  span,
-  spanStart,
-  spanEnd,
-  metrics: TRACE_PROCESSOR.remoteMetrics
-};
-
-// src/metrics/base.ts
-var BaseCounter = class {
-  /**
-  * @internal
-  */
-  _instance;
-  name;
-  /**
-  * @internal
-  */
-  _assign(instance, name) {
-    this._instance = instance;
-    this.name = name;
-  }
-  _tick(time) {
-  }
-};
-
-// src/metrics/unary-counter.ts
-var UnaryCounter = class extends BaseCounter {
-  value = 0;
-  units;
-  constructor({ units } = {}) {
-    super();
-    this.units = units;
-  }
-  inc(by = 1) {
-    this.value += by;
-  }
-  getData() {
-    return {
-      name: this.name,
-      counter: {
-        value: this.value,
-        units: this.units
-      }
-    };
-  }
-};
-
-// src/metrics/time-series-counter.ts
-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;
-  }
-  _tick(time) {
-    this._buckets.push(this._currentValue);
-    if (this._buckets.length > MAX_BUCKETS) {
-      this._buckets.shift();
-    }
-    this._currentValue = 0;
-  }
-  getData() {
-    return {
-      name: this.name,
-      timeSeries: {
-        tracks: [
-          {
-            name: this.name,
-            units: this.units,
-            points: this._buckets.map((value, index) => ({
-              value
-            })),
-            total: this._totalValue
-          }
-        ]
-      }
-    };
-  }
-};
-
-// src/metrics/time-usage-counter.ts
-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;
-  }
-  beginRecording() {
-    const start = performance.now();
-    return {
-      end: () => {
-        const end = performance.now();
-        this.record(end - start);
-      }
-    };
-  }
-  _tick(time) {
-    const delta = time - this._lastTickTime;
-    this._lastTickTime = time;
-    const percentage = this._currentValue / delta * 100;
-    this._buckets.push(percentage);
-    if (this._buckets.length > MAX_BUCKETS2) {
-      this._buckets.shift();
-    }
-    this._currentValue = 0;
-  }
-  getData() {
-    return {
-      name: this.name,
-      timeSeries: {
-        tracks: [
-          {
-            name: this.name,
-            units: "%",
-            points: this._buckets.map((value, index) => ({
-              value
-            })),
-            total: this._totalValue
-          }
-        ]
-      }
-    };
-  }
-};
-
-// src/metrics/map-counter.ts
-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);
-  }
-  getData() {
-    return {
-      name: this.name,
-      multiCounter: {
-        records: Array.from(this.values.entries()).map(([key, value]) => ({
-          key,
-          value
-        })),
-        units: this.units
-      }
-    };
-  }
-};
-
-// src/metrics/custom-counter.ts
-var CustomCounter = class extends BaseCounter {
-  _getData;
-  constructor(_getData) {
-    super(), this._getData = _getData;
-  }
-  getData() {
-    return {
-      name: this.name,
-      custom: {
-        payload: this._getData()
-      }
-    };
-  }
-};
-
-// src/index.ts
-trace.diagnostic({
-  id: "process-info",
-  name: "Process Info",
-  fetch: async () => {
-    return {
-      platform: globalThis.process?.platform,
-      arch: globalThis.process?.arch,
-      versions: globalThis.process?.versions,
-      href: globalThis.location?.href
-    };
-  }
-});
-export {
-  BaseCounter,
-  CustomCounter,
-  DIAGNOSTICS_TIMEOUT,
-  DiagnosticsChannel,
-  DiagnosticsManager,
-  MapCounter,
-  RemoteMetrics,
-  ResourceEntry,
-  TRACE_ALL_KEY,
-  TRACE_PROCESSOR,
-  TimeSeriesCounter,
-  TimeUsageCounter,
-  TraceDiagnosticImpl,
-  TraceProcessor,
-  UnaryCounter,
-  getTracingContext,
-  sanitizeClassName,
-  symbolTracingContext,
-  trace
-};
-//# sourceMappingURL=index.mjs.map