@dxos/tracing 0.1.56-main.d9d1c3e

package/src/trace-processor.ts

@@ -0,0 +1,215 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Context } from '@dxos/context';
+import { Error as SerializedError } from '@dxos/protocols/proto/dxos/error';
+import { Resource, Span } from '@dxos/protocols/proto/dxos/tracing';
+import { getPrototypeSpecificInstanceId } from '@dxos/util';
+
+import type { AddLinkOptions } from './api';
+import { TRACE_SPAN_ATTRIBUTE, getTracingContext } from './symbols';
+import { TraceSender } from './trace-sender';
+
+export type TraceResourceConstructorParams = {
+  constructor: { new (...args: any[]): {} };
+  instance: any;
+};
+
+export type TraceSpanParams = {
+  instance: any;
+  methodName: string;
+  parentCtx: Context | null;
+};
+
+export type ResourceEntry = {
+  data: Resource;
+  instance: WeakRef<any>;
+};
+
+export type TraceSubscription = {
+  dirtyResources: Set<number>;
+  dirtySpans: Set<number>;
+};
+
+const MAX_RESOURCE_RECORDS = 500;
+const MAX_SPAN_RECORDS = 1_000;
+
+export class TraceProcessor {
+  resources = new Map<number, ResourceEntry>();
+  resourceInstanceIndex = new WeakMap<any, ResourceEntry>();
+  resourceIdList: number[] = [];
+
+  spans = new Map<number, Span>();
+  spanIdList: number[] = [];
+
+  subscriptions: Set<TraceSubscription> = new Set();
+
+  traceResourceConstructor(params: TraceResourceConstructorParams) {
+    const id = this.resources.size;
+    const entry: ResourceEntry = {
+      data: {
+        id,
+        className: params.constructor.name,
+        instanceId: getPrototypeSpecificInstanceId(params.instance),
+        info: this.getResourceInfo(params.instance),
+        links: [],
+      },
+      instance: new WeakRef(params.instance),
+    };
+    this.resources.set(id, entry);
+    this.resourceInstanceIndex.set(params.instance, entry);
+    this.resourceIdList.push(id);
+    if (this.resourceIdList.length > MAX_RESOURCE_RECORDS) {
+      this._clearResources();
+    }
+    this._markResourceDirty(id);
+  }
+
+  getResourceInfo(instance: any): Record<string, any> {
+    const res: Record<string, any> = {};
+    const tracingContext = getTracingContext(Object.getPrototypeOf(instance));
+
+    for (const [key, _opts] of Object.entries(tracingContext.infoProperties)) {
+      try {
+        res[key] = typeof instance[key] === 'function' ? instance[key]() : instance[key];
+      } catch (err: any) {
+        res[key] = err.message;
+      }
+    }
+
+    return res;
+  }
+
+  traceSpan(params: TraceSpanParams): TracingSpan {
+    const span = new TracingSpan(this, params);
+    this._flushSpan(span);
+    return span;
+  }
+
+  addLink(parent: any, child: any, opts: AddLinkOptions) {}
+
+  getResourceId(instance: any): number | null {
+    const entry = this.resourceInstanceIndex.get(instance);
+    return entry ? entry.data.id : null;
+  }
+
+  createTraceSender() {
+    return new TraceSender(this);
+  }
+
+  /**
+   * @internal
+   */
+  _flushSpan(runtimeSpan: TracingSpan) {
+    const span = runtimeSpan.serialize();
+    this.spans.set(span.id, span);
+    this.spanIdList.push(span.id);
+    if (this.spanIdList.length > MAX_SPAN_RECORDS) {
+      this._clearSpans();
+    }
+    this._markSpanDirty(span.id);
+  }
+
+  private _markResourceDirty(id: number) {
+    for (const subscription of this.subscriptions) {
+      subscription.dirtyResources.add(id);
+    }
+  }
+
+  private _markSpanDirty(id: number) {
+    for (const subscription of this.subscriptions) {
+      subscription.dirtySpans.add(id);
+    }
+  }
+
+  private _clearResources() {
+    // TODO(dmaretskyi): Use FinalizationRegistry to delete finalized resources first.
+    while (this.resourceIdList.length > MAX_RESOURCE_RECORDS) {
+      const id = this.resourceIdList.shift()!;
+      this.resources.delete(id);
+    }
+  }
+
+  private _clearSpans() {
+    while (this.spanIdList.length > MAX_SPAN_RECORDS) {
+      const id = this.spanIdList.shift()!;
+      this.spans.delete(id);
+    }
+  }
+}
+
+export class TracingSpan {
+  static nextId = 0;
+
+  readonly id: number;
+  readonly parentId: number | null = null;
+  readonly methodName: string;
+  readonly resourceId: number | null = null;
+  startTs: number;
+  endTs: number | null = null;
+  error: SerializedError | null = null;
+
+  private readonly _ctx: Context | null = null;
+
+  constructor(private _traceProcessor: TraceProcessor, params: TraceSpanParams) {
+    this.id = TracingSpan.nextId++;
+    this.methodName = params.methodName;
+    this.resourceId = _traceProcessor.getResourceId(params.instance);
+    this.startTs = performance.now();
+
+    if (params.parentCtx) {
+      this._ctx = params.parentCtx.derive({
+        attributes: {
+          [TRACE_SPAN_ATTRIBUTE]: this.id,
+        },
+      });
+      const parentId = params.parentCtx.getAttribute(TRACE_SPAN_ATTRIBUTE);
+      if (typeof parentId === 'number') {
+        this.parentId = parentId;
+      }
+    }
+  }
+
+  get ctx(): Context | null {
+    return this._ctx;
+  }
+
+  markSuccess() {
+    this.endTs = performance.now();
+    this._traceProcessor._flushSpan(this);
+  }
+
+  markError(err: unknown) {
+    this.endTs = performance.now();
+    this.error = serializeError(err);
+    this._traceProcessor._flushSpan(this);
+  }
+
+  serialize(): Span {
+    return {
+      id: this.id,
+      resourceId: this.resourceId ?? undefined,
+      methodName: this.methodName,
+      parentId: this.parentId ?? undefined,
+      startTs: this.startTs.toFixed(3),
+      endTs: this.endTs?.toFixed(3) ?? undefined,
+      error: this.error ?? undefined,
+    };
+  }
+}
+
+const serializeError = (err: unknown): SerializedError => {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+    };
+  }
+
+  return {
+    message: String(err),
+  };
+};
+
+export const TRACE_PROCESSOR: TraceProcessor = ((globalThis as any).TRACE_PROCESSOR ??= new TraceProcessor());

package/src/trace-sender.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Stream } from '@dxos/codec-protobuf';
+import { StreamTraceEvent, TracingService } from '@dxos/protocols/proto/dxos/tracing';
+
+import { TraceProcessor, TraceSubscription } from './trace-processor';
+
+const FLUSH_INTERVAL = 1_000;
+
+export class TraceSender implements TracingService {
+  constructor(private _traceProcessor: TraceProcessor) {}
+
+  streamTrace(request: void): Stream<StreamTraceEvent> {
+    return new Stream(({ ctx, next }) => {
+      const subscription: TraceSubscription = {
+        dirtyResources: new Set(),
+        dirtySpans: new Set(),
+      };
+      this._traceProcessor.subscriptions.add(subscription);
+      ctx.onDispose(() => {
+        this._traceProcessor.subscriptions.delete(subscription);
+      });
+
+      const flushEvents = (resources: Set<number> | null, spans: Set<number> | null) => {
+        const event: StreamTraceEvent = {
+          resourceAdded: [],
+          resourceRemoved: [],
+          spanAdded: [],
+        };
+
+        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 (spans) {
+          for (const id of spans) {
+            const span = this._traceProcessor.spans.get(id);
+            if (span) {
+              event.spanAdded!.push({ span });
+            }
+          }
+        } else {
+          for (const span of this._traceProcessor.spans.values()) {
+            event.spanAdded!.push({ span });
+          }
+        }
+
+        if (event.resourceAdded!.length > 0 || event.resourceRemoved!.length > 0 || event.spanAdded!.length > 0) {
+          next(event);
+        }
+      };
+
+      flushEvents(null, null);
+
+      const timer = setInterval(() => {
+        flushEvents(subscription.dirtyResources, subscription.dirtySpans);
+        subscription.dirtyResources.clear();
+        subscription.dirtySpans.clear();
+      }, FLUSH_INTERVAL);
+      ctx.onDispose(() => {
+        clearInterval(timer);
+      });
+    });
+  }
+}

package/src/tracing.test.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { Context } from '@dxos/context';
+import { log } from '@dxos/log';
+import { test } from '@dxos/test';
+
+import { trace } from './api';
+import { TRACE_PROCESSOR } from './trace-processor';
+
+@trace.resource()
+class FeedStore {
+  private readonly _storage: any;
+
+  private readonly _feeds = new Map<string, Feed>();
+
+  @trace.info()
+  get storageType() {
+    return this._storage.type;
+  }
+
+  @trace.span()
+  async openFeed(ctx: Context) {
+    const feed = new Feed();
+    feed.key = Math.random().toString(36).substring(2, 15);
+    this._feeds.set(feed.key, feed);
+    trace.addLink(this, feed, {});
+
+    await feed.open(ctx);
+    return feed;
+  }
+}
+
+@trace.resource()
+class Feed {
+  @trace.info()
+  key!: string;
+
+  @trace.span()
+  async open(ctx: Context) {}
+
+  @trace.span()
+  async close() {
+    throw new Error('Not implemented');
+  }
+}
+
+test('feed store tracing', async () => {
+  const store = new FeedStore();
+  await store.openFeed(new Context());
+  const feed = await store.openFeed(new Context());
+
+  await feed.close().catch(() => {});
+
+  log.info('resources', TRACE_PROCESSOR.resources);
+  log.info('spans', TRACE_PROCESSOR.spans);
+});