@dxos/observability 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/src/helpers/common.ts

@@ -1,38 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import type { Client } from '@dxos/client';
-
-import { type IdentityOptions } from '../segment';
-
-export type IPData = {
-  city: string;
-  region: string;
-  country: string;
-  latitude: number;
-  longitude: number;
-};
-
-// TODO(wittjosiah): Improve privacy of telemetry identifiers.
-//  - Identifier should be generated client-side with no attachment to identity.
-//  - Identifier can then be reset by user.
-//  - Identifier can be synced via HALO to allow for correlation of events bewteen devices.
-//  - Identifier should also be stored outside of HALO such that it is available immediately on startup.
-export const getTelemetryIdentifier = (client: Client): string | undefined => {
-  if (!client?.initialized) {
-    return undefined;
-  }
-
-  const identity = client.halo.identity.get();
-  if (identity) {
-    return identity.did;
-  }
-
-  return undefined;
-};
-
-export const getTelemetryIdentity = (client: Client): IdentityOptions => {
-  const did = getTelemetryIdentifier(client);
-  return { did };
-};

package/src/helpers/index.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-export * from './browser-observability';
-export * from './common';
-export * from './node-observability';
-export * from './map-spaces';
-export * from './setup-telemetry-listeners';

package/src/helpers/map-spaces.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import type { Space } from '@dxos/client-protocol';
-
-export type MapSpacesOptions = {
-  verbose?: boolean;
-  truncateKeys?: boolean;
-};
-
-export const mapSpaces = (spaces: Space[], options: MapSpacesOptions = { verbose: false, truncateKeys: false }) => {
-  return spaces.map((space) => {
-    // TODO(burdon): Factor out.
-    // TODO(burdon): Agent needs to restart before `ready` is available.
-    const { open, ready } = space.internal.data.metrics ?? {};
-    const startup = open && ready && ready.getTime() - open.getTime();
-
-    // TODO(burdon): Get feeds from client-services if verbose (factor out from devtools/diagnostics).
-    // const host = client.services.services.DevtoolsHost!;
-    const pipeline = space.internal.data.pipeline;
-    const startDataMutations = pipeline?.currentEpoch?.subject.assertion.timeframe.totalMessages() ?? 0;
-    const epoch = pipeline?.currentEpoch?.subject.assertion.number;
-    // const appliedEpoch = pipeline?.appliedEpoch?.subject.assertion.number;
-    const currentDataMutations = pipeline?.currentDataTimeframe?.totalMessages() ?? 0;
-    const totalDataMutations = pipeline?.targetDataTimeframe?.totalMessages() ?? 0;
-
-    return {
-      // TODO(nf): truncate keys for DD?
-      key: space.key.truncate(),
-      open: space.isOpen,
-      members: space.members.get().length,
-      objects: space.db.coreDatabase.getAllObjectIds().length,
-      startup,
-      epoch,
-      // appliedEpoch,
-      startDataMutations,
-      currentDataMutations,
-      totalDataMutations,
-
-      // TODO(burdon): Negative?
-      progress: (
-        Math.min(Math.abs((currentDataMutations - startDataMutations) / (totalDataMutations - startDataMutations)), 1) *
-        100
-      ).toFixed(0),
-    };
-  });
-};

package/src/helpers/setup-telemetry-listeners.ts

@@ -1,109 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import type { Client } from '@dxos/client';
-
-import { type Observability } from '../observability';
-
-import { getTelemetryIdentity } from './common';
-
-let lastFocusEvent = new Date();
-let totalTime = 0;
-
-export const setupTelemetryListeners = (namespace: string, client: Client, observability: Observability) => {
-  const clickCallback = (event: Event) => {
-    const id = (event.target as HTMLElement)?.id;
-    if (!id) {
-      return;
-    }
-
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: 'window.click',
-        properties: {
-          id: (event.target as HTMLElement)?.id,
-          path: (event.composedPath() as HTMLElement[])
-            .filter((el) => Boolean(el.tagName))
-            .map((el) => `${el.tagName.toLowerCase()}${el.id ? `#${el.id}` : ''}`)
-            .reverse()
-            .join('>'),
-        },
-      });
-    });
-  };
-
-  const focusCallback = () => {
-    const now = new Date();
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: 'window.focus',
-        properties: {
-          timeAway: now.getTime() - lastFocusEvent.getTime(),
-        },
-      });
-    });
-
-    lastFocusEvent = now;
-  };
-
-  const blurCallback = () => {
-    const now = new Date();
-    const duration = now.getTime() - lastFocusEvent.getTime();
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: 'window.blur',
-        properties: {
-          duration,
-        },
-      });
-    });
-
-    lastFocusEvent = now;
-    totalTime = totalTime + duration;
-  };
-
-  const unloadCallback = () => {
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: 'page.unload',
-        properties: {
-          duration: totalTime,
-        },
-      });
-    });
-  };
-
-  const errorCallback = (event: ErrorEvent) => {
-    setTimeout(() => {
-      observability.track({
-        ...getTelemetryIdentity(client),
-        action: 'window.error',
-        properties: {
-          message: event.message,
-          filename: event.filename,
-          stack: (event.error as Error)?.stack,
-          cause: (event.error as Error)?.cause,
-        },
-      });
-    });
-  };
-
-  window.addEventListener('click', clickCallback, true);
-  window.addEventListener('focus', focusCallback);
-  window.addEventListener('blur', blurCallback);
-  window.addEventListener('beforeunload', unloadCallback);
-  window.addEventListener('error', errorCallback);
-
-  return () => {
-    window.removeEventListener('click', clickCallback, true);
-    window.removeEventListener('focus', focusCallback);
-    window.removeEventListener('blur', blurCallback);
-    window.removeEventListener('beforeunload', unloadCallback);
-    window.removeEventListener('error', errorCallback);
-  };
-};

package/src/otel/index.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './otel';
-export * from './logs';
-export * from './metrics';
-export * from './traces';

package/src/otel/logs.ts

@@ -1,102 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { SeverityNumber } from '@opentelemetry/api-logs';
-import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
-import { defaultResource, resourceFromAttributes } from '@opentelemetry/resources';
-import { BatchLogRecordProcessor, LoggerProvider } from '@opentelemetry/sdk-logs';
-import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-
-import {
-  type LogConfig,
-  type LogEntry,
-  LogLevel,
-  type LogProcessor,
-  getContextFromEntry,
-  getRelativeFilename,
-} from '@dxos/log';
-import { jsonlogify } from '@dxos/util';
-
-import { type OtelOptions, setDiagLogger } from './otel';
-
-export type OtelLogOptions = OtelOptions & {
-  logLevel: LogLevel;
-  /**
-   * Set `true` to capture logs sent through LoggingService from shared worker.
-   * Better to set to `false` because shared worker is initializing its own logger.
-   */
-  includeSharedWorkerLogs: boolean;
-};
-
-export class OtelLogs {
-  private _loggerProvider: LoggerProvider;
-  constructor(private readonly options: OtelLogOptions) {
-    setDiagLogger(options.consoleDiagLogLevel);
-    const resource = defaultResource().merge(
-      resourceFromAttributes({
-        [SEMRESATTRS_SERVICE_NAME]: this.options.serviceName,
-        [SEMRESATTRS_SERVICE_VERSION]: this.options.serviceVersion,
-      }),
-    );
-    const logExporter = new OTLPLogExporter({
-      url: this.options.endpoint + '/v1/logs',
-      headers: {
-        Authorization: this.options.authorizationHeader,
-      },
-      concurrencyLimit: 10, // an optional limit on pending requests
-    });
-    this._loggerProvider = new LoggerProvider({
-      resource,
-      processors: [new BatchLogRecordProcessor(logExporter)],
-    });
-  }
-
-  public readonly logProcessor: LogProcessor = (config: LogConfig, entry: LogEntry) => {
-    const logger = this._loggerProvider.getLogger('dxos-observability', this.options.serviceVersion);
-
-    if (
-      entry.level < this.options.logLevel ||
-      (!this.options.includeSharedWorkerLogs && entry.meta?.S?.remoteSessionId)
-    ) {
-      return;
-    }
-
-    const record = {
-      ...entry,
-      ...(entry.meta ? { meta: { file: getRelativeFilename(entry.meta.F), line: entry.meta.L } } : {}),
-      context: jsonlogify(getContextFromEntry(entry)),
-    };
-
-    logger.emit({
-      severityNumber: convertLevel(entry.level),
-      body: JSON.stringify(record),
-      attributes: this.options.getTags(),
-    });
-  };
-
-  flush(): Promise<void> {
-    return this._loggerProvider.forceFlush();
-  }
-
-  close(): Promise<void> {
-    return this._loggerProvider.shutdown();
-  }
-}
-
-const convertLevel = (level: LogLevel): SeverityNumber => {
-  switch (level) {
-    case LogLevel.DEBUG:
-      return SeverityNumber.DEBUG;
-    case LogLevel.VERBOSE:
-      return SeverityNumber.INFO;
-    case LogLevel.INFO:
-      return SeverityNumber.INFO;
-    case LogLevel.WARN:
-      return SeverityNumber.WARN;
-    case LogLevel.ERROR:
-      return SeverityNumber.ERROR;
-    default:
-      return SeverityNumber.ERROR;
-  }
-};

package/src/otel/traces-browser.ts

@@ -1,62 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type Tracer, trace } from '@opentelemetry/api';
-import { getWebAutoInstrumentations } from '@opentelemetry/auto-instrumentations-web';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { registerInstrumentations } from '@opentelemetry/instrumentation';
-import { defaultResource, resourceFromAttributes } from '@opentelemetry/resources';
-import { BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
-import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-
-import { log } from '@dxos/log';
-import { type StartSpanOptions, TRACE_PROCESSOR } from '@dxos/tracing';
-
-import { type OtelOptions } from './otel';
-
-export class OtelTraces {
-  private _tracer: Tracer;
-  constructor(private readonly options: OtelOptions) {
-    const resource = defaultResource().merge(
-      resourceFromAttributes({
-        [SEMRESATTRS_SERVICE_NAME]: this.options.serviceName,
-        [SEMRESATTRS_SERVICE_VERSION]: this.options.serviceVersion,
-      }),
-    );
-
-    const tracerProvider = new WebTracerProvider({
-      resource,
-      spanProcessors: [
-        new SimpleSpanProcessor(new ConsoleSpanExporter()),
-        new BatchSpanProcessor(
-          new OTLPTraceExporter({
-            url: this.options.endpoint + '/v1/traces',
-            headers: {
-              Authorization: this.options.authorizationHeader,
-            },
-            concurrencyLimit: 10, // an optional limit on pending requests
-          }),
-        ),
-      ],
-    });
-
-    // TODO(nf): ContextManager? Propogator?
-    trace.setGlobalTracerProvider(tracerProvider);
-    this._tracer = trace.getTracer('dxos-observability', this.options.serviceVersion);
-  }
-
-  public start(): void {
-    registerInstrumentations({
-      instrumentations: [getWebAutoInstrumentations()],
-    });
-    log('trace processor registered');
-    TRACE_PROCESSOR.remoteTracing.registerProcessor({
-      startSpan: (options: StartSpanOptions) => {
-        log('begin otel trace', { options });
-        return this._tracer.startSpan(options.name, options);
-      },
-    });
-  }
-}

package/src/otel/traces.ts

@@ -1,60 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type Tracer, trace } from '@opentelemetry/api';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { defaultResource, resourceFromAttributes } from '@opentelemetry/resources';
-import {
-  BasicTracerProvider,
-  BatchSpanProcessor,
-  ConsoleSpanExporter,
-  SimpleSpanProcessor,
-} from '@opentelemetry/sdk-trace-base';
-import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-import { log } from 'debug';
-
-import { type StartSpanOptions, TRACE_PROCESSOR } from '@dxos/tracing';
-
-import { type OtelOptions } from './otel';
-
-export class OtelTraces {
-  private _tracer: Tracer;
-  constructor(private readonly options: OtelOptions) {
-    const resource = defaultResource().merge(
-      resourceFromAttributes({
-        [SEMRESATTRS_SERVICE_NAME]: this.options.serviceName,
-        [SEMRESATTRS_SERVICE_VERSION]: this.options.serviceVersion,
-      }),
-    );
-
-    const tracerProvider = new BasicTracerProvider({
-      resource,
-      spanProcessors: [
-        new SimpleSpanProcessor(new ConsoleSpanExporter()),
-        new BatchSpanProcessor(
-          new OTLPTraceExporter({
-            url: this.options.endpoint + '/v1/traces',
-            headers: {
-              Authorization: this.options.authorizationHeader,
-            },
-            concurrencyLimit: 10, // an optional limit on pending requests
-          }),
-        ),
-      ],
-    });
-
-    trace.setGlobalTracerProvider(tracerProvider);
-    this._tracer = trace.getTracer('dxos-observability', this.options.serviceVersion);
-  }
-
-  public start(): void {
-    log('trace processor registered');
-    TRACE_PROCESSOR.remoteTracing.registerProcessor({
-      startSpan: (options: StartSpanOptions) => {
-        log('begin otel trace', { options });
-        return this._tracer.startSpan(options.name, options);
-      },
-    });
-  }
-}

package/src/segment/base.ts

@@ -1,69 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type IdentifyParams, type PageParams, type TrackParams } from '@segment/analytics-node';
-
-import { log } from '@dxos/log';
-
-import {
-  type IdentityOptions,
-  type PageOptions,
-  type SegmentIdentityOptions,
-  type Tags,
-  TelemetryEvent,
-  type TrackOptions,
-} from './types';
-
-/**
- * NOTE: Segment provides a default ID if we don't provide one.
- */
-const getIdentityOptions = ({ did, installationId }: IdentityOptions): SegmentIdentityOptions => {
-  if (!did && !installationId) {
-    log.warn('No telemetry identifier provided.');
-  }
-
-  return {
-    userId: did,
-    anonymousId: installationId,
-  } as SegmentIdentityOptions;
-};
-
-/**
- * Base class for Node and BrowserSegment telemetry.
- */
-export abstract class AbstractSegmentTelemetry {
-  constructor(private readonly _getTags: () => Tags) {}
-
-  abstract identify(options: IdentifyParams): void;
-
-  abstract page(options: PageOptions): void;
-
-  abstract track(options: TrackOptions): void;
-
-  protected createPageProps(options: PageOptions): PageParams {
-    const { properties, ...rest } = options;
-    return {
-      ...getIdentityOptions(options),
-      ...rest,
-      properties: {
-        common: this._getTags(),
-        custom: properties,
-      },
-    };
-  }
-
-  protected createTrackProps(options: TrackOptions): TrackParams {
-    const { event, action, properties, ...rest } = options;
-    return {
-      ...getIdentityOptions(options),
-      ...rest,
-      event: event ?? TelemetryEvent.ACTION,
-      properties: {
-        action,
-        common: this._getTags(),
-        custom: properties,
-      },
-    };
-  }
-}

package/src/segment/browser.ts

@@ -1,69 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { type IdentifyParams } from '@segment/analytics-node';
-import snippet from '@segment/snippet';
-
-import { log } from '@dxos/log';
-
-import { captureException } from '../sentry';
-
-import { AbstractSegmentTelemetry } from './base';
-import type { PageOptions, SegmentTelemetryOptions, TrackOptions } from './types';
-
-/**
- * Browser telemetry.
- */
-// https://segment.com/docs/connections/sources/catalog/libraries/website/javascript/#basic-tracking-methods
-export class SegmentTelemetry extends AbstractSegmentTelemetry {
-  constructor({ apiKey, batchSize, getTags }: SegmentTelemetryOptions) {
-    super(getTags);
-    try {
-      const contents = snippet.min({ apiKey, page: false });
-      const script = document.createElement('script');
-      script.innerHTML = contents;
-      document.body.append(script);
-    } catch (err) {
-      log.catch('failed to initialize telemetry', err);
-    }
-  }
-
-  identify(options: IdentifyParams): void {
-    try {
-      (window as any).analytics?.identify(options.userId, options.traits);
-    } catch (err) {
-      log.catch('failed to identify', err);
-    }
-  }
-
-  page(options: PageOptions): void {
-    try {
-      const props = this.createPageProps(options);
-      (window as any).analytics?.page(props.category, props.name, props.properties);
-    } catch (err) {
-      log.catch('failed to track page', err);
-    }
-  }
-
-  track(options: TrackOptions): void {
-    try {
-      const props = this.createTrackProps(options);
-      (window as any).analytics?.track(props.event, props.properties);
-    } catch (err) {
-      log.catch('failed to track event', err);
-    }
-  }
-
-  async flush(): Promise<void> {
-    try {
-      await (window as any).analytics?.flush((err: any) => {
-        captureException(err);
-      });
-    } catch (err) {
-      log.catch('failed to flush telemetry', err);
-    }
-  }
-
-  async close(): Promise<void> {}
-}

package/src/segment/node.ts

@@ -1,95 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { Analytics, type IdentifyParams } from '@segment/analytics-node';
-
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-
-import { captureException } from '../sentry';
-
-import { AbstractSegmentTelemetry } from './base';
-import type { PageOptions, SegmentTelemetryOptions, TrackOptions } from './types';
-
-/**
- * Node telemetry.
- */
-export class SegmentTelemetry extends AbstractSegmentTelemetry {
-  private _analytics?: Analytics;
-
-  constructor({ apiKey, batchSize, getTags }: SegmentTelemetryOptions) {
-    super(getTags);
-    try {
-      invariant(apiKey, 'Missing API key.');
-      this._analytics = new Analytics({
-        writeKey: apiKey,
-        flushAt: batchSize,
-      });
-    } catch (err) {
-      log.catch('Failed to initialize telemetry', err);
-    }
-  }
-
-  identify(options: IdentifyParams): void {
-    if (!this._analytics) {
-      log('Analytics not initialized', { action: 'identify' });
-      return;
-    }
-
-    try {
-      this._analytics.identify(options);
-    } catch (err) {
-      log.catch('Failed to identify', err);
-    }
-  }
-
-  page(options: PageOptions): void {
-    if (!this._analytics) {
-      log('Analytics not initialized', { action: 'page' });
-      return;
-    }
-
-    try {
-      this._analytics.page(this.createPageProps(options));
-    } catch (err) {
-      log.catch('Failed to track page', err);
-    }
-  }
-
-  track(options: TrackOptions): void {
-    if (!this._analytics) {
-      log('Analytics not initialized', { action: 'track' });
-      return;
-    }
-
-    log.info('sending event to telemetry', { options });
-    try {
-      this._analytics.track(this.createTrackProps(options));
-    } catch (err) {
-      log.catch('Failed to track action', err);
-    }
-  }
-
-  async flush(): Promise<void> {
-    if (!this._analytics) {
-      log('Analytics not initialized', { action: 'flush' });
-      return;
-    }
-
-    try {
-      await this._analytics.flush();
-    } catch (err) {
-      // are these errors worth capturing?
-      captureException(err);
-    }
-  }
-
-  async close(): Promise<void> {
-    if (!this._analytics) {
-      return;
-    }
-
-    await this._analytics.closeAndFlush();
-  }
-}