@dxos/tracing 0.5.5 → 0.5.6-main.04fedb4

package/src/remote/metrics.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export interface MetricData {
+  unit?: string;
+  tags?: Record<string, string>;
+  timestamp?: number;
+}
+
+interface MetricsMethods {
+  /**
+   * Adds a value to a counter metric
+   */
+  increment(name: string, value?: number, data?: MetricData): void;
+  /**
+   * Adds a value to a distribution metric
+   */
+  distribution(name: string, value: number, data?: MetricData): void;
+  /**
+   * Adds a value to a set metric. Value must be a string or integer.
+   */
+  set(name: string, value: number | string, data?: MetricData): void;
+  /**
+   * Adds a value to a gauge metric
+   */
+  gauge(name: string, value: number, data?: MetricData): void;
+}
+
+/**
+ * Allows metrics to be recorded within SDK code without requiring specific consumers.
+ */
+export class RemoteMetrics implements MetricsMethods {
+  private _metrics = new Set<MetricsMethods>();
+
+  async registerProcessor(processor: MetricsMethods) {
+    this._metrics.add(processor);
+  }
+
+  increment(name: string, value?: number, data?: MetricData) {
+    return Array.from(this._metrics.values()).map((processor) => processor.increment(name, value, data));
+  }
+
+  distribution(name: string, value: number, data?: MetricData) {
+    return Array.from(this._metrics.values()).map((processor) => processor.distribution(name, value, data));
+  }
+
+  set(name: string, value: number | string, data?: MetricData) {
+    return Array.from(this._metrics.values()).map((processor) => processor.set(name, value, data));
+  }
+
+  gauge(name: string, value: number, data?: MetricData) {
+    return Array.from(this._metrics.values()).map((processor) => processor.gauge(name, value, data));
+  }
+}

package/src/remote/tracing.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type TracingSpan } from '../trace-processor';
+
+type RemoteSpan = {
+  end: () => void;
+};
+
+type StartSpanOptions = {
+  name: string;
+  op?: string;
+  attributes?: Record<string, any>;
+};
+
+interface TracingMethods {
+  startSpan: (options: StartSpanOptions) => RemoteSpan;
+}
+
+/**
+ * Allows traces to be recorded within SDK code without requiring specific consumers.
+ */
+// TODO(wittjosiah): Should probably just use otel. Use `any` for now to not depend on Sentry directly.
+export class RemoteTracing {
+  private _tracing: TracingMethods | undefined;
+  private _spanMap = new Map<TracingSpan, RemoteSpan>();
+
+  async registerProcessor(processor: TracingMethods) {
+    this._tracing = processor;
+  }
+
+  flushSpan(span: TracingSpan) {
+    if (!this._tracing) {
+      return;
+    }
+
+    if (!span.endTs) {
+      const remoteSpan = this._tracing.startSpan({
+        name: span.methodName,
+        op: span.op ?? 'function',
+        attributes: span.attributes,
+      });
+      this._spanMap.set(span, remoteSpan);
+    } else {
+      const remoteSpan = this._spanMap.get(span);
+      if (remoteSpan) {
+        remoteSpan.end();
+        this._spanMap.delete(span);
+      }
+    }
+  }
+}

package/src/trace-processor.ts

@@ -14,6 +14,7 @@ import type { AddLinkOptions } from './api';
 import { DiagnosticsManager } from './diagnostic';
 import { DiagnosticsChannel } from './diagnostics-channel';
 import { type BaseCounter } from './metrics';
+import { RemoteMetrics, RemoteTracing } from './remote';
 import { TRACE_SPAN_ATTRIBUTE, getTracingContext } from './symbols';
 import { TraceSender } from './trace-sender';
 
@@ -31,9 +32,12 @@ export type TraceResourceConstructorParams = {
 
 export type TraceSpanParams = {
   instance: any;
+  // TODO(wittjosiah): Rename to `name`.
   methodName: string;
   parentCtx: Context | null;
   showInBrowserTimeline: boolean;
+  op?: string;
+  attributes?: Record<string, any>;
 };
 
 export class ResourceEntry {
@@ -76,6 +80,8 @@ const MAX_INFO_OBJECT_DEPTH = 8;
 export class TraceProcessor {
   public readonly diagnostics = new DiagnosticsManager();
   public readonly diagnosticsChannel = new DiagnosticsChannel();
+  public readonly remoteMetrics = new RemoteMetrics();
+  public readonly remoteTracing = new RemoteTracing();
 
   readonly subscriptions: Set<TraceSubscription> = new Set();
 
@@ -272,6 +278,7 @@ export class TraceProcessor {
       this._clearSpans();
     }
     this._markSpanDirty(span.id);
+    this.remoteTracing.flushSpan(runtimeSpan);
   }
 
   private _markResourceDirty(id: number) {
@@ -355,6 +362,8 @@ export class TracingSpan {
   readonly parentId: number | null = null;
   readonly methodName: string;
   readonly resourceId: number | null = null;
+  readonly op: string | undefined;
+  readonly attributes: Record<string, any>;
   startTs: number;
   endTs: number | null = null;
   error: SerializedError | null = null;
@@ -371,6 +380,8 @@ export class TracingSpan {
     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({