@dxos/observability 0.6.3-main.daaea86 → 0.6.3-main.e6314a6

package/dist/types/src/otel/traces-browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traces-browser.js","sourceRoot":"","sources":["../../../../src/otel/traces-browser.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,0BAA0B;AAC1B,EAAE;;;AAEF,4CAAwD;AACxD,wFAAsF;AACtF,sFAA4E;AAC5E,oEAA0E;AAC1E,wDAAoD;AACpD,kEAA6G;AAC7G,gEAAiE;AACjE,8EAA4G;AAE5G,mCAAgC;AAChC,2CAAuE;AAIvE,MAAa,UAAU;IAErB,YAA6B,OAAoB;QAApB,YAAO,GAAP,OAAO,CAAa;QAC/C,MAAM,QAAQ,GAAG,oBAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,CACvC,IAAI,oBAAQ,CAAC;YACX,CAAC,+CAAwB,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;YACpD,CAAC,kDAA2B,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;SAC3D,CAAC,CACH,CAAC;QAEF,MAAM,cAAc,GAAG,IAAI,iCAAiB,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC3D,cAAc,CAAC,gBAAgB,CAAC,IAAI,oCAAmB,CAAC,IAAI,oCAAmB,EAAE,CAAC,CAAC,CAAC;QACpF,cAAc,CAAC,gBAAgB,CAC7B,IAAI,mCAAkB,CACpB,IAAI,4CAAiB,CAAC;YACpB,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,YAAY;YACzC,OAAO,EAAE;gBACP,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,mBAAmB;aAChD;YACD,gBAAgB,EAAE,EAAE,EAAE,wCAAwC;SAC/D,CAAC,CACH,CACF,CAAC;QACF,wCAAwC;QACxC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,WAAK,CAAC,SAAS,CAAC,oBAAoB,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IACpF,CAAC;IAEM,KAAK;QACV,IAAA,0CAAwB,EAAC;YACvB,gBAAgB,EAAE,CAAC,IAAA,sDAA0B,GAAE,CAAC;SACjD,CAAC,CAAC;QACH,IAAA,SAAG,EAAC,4BAA4B,CAAC,CAAC;QAClC,yBAAe,CAAC,aAAa,CAAC,iBAAiB,CAAC;YAC9C,SAAS,EAAE,CAAC,OAAyB,EAAE,EAAE;gBACvC,IAAA,SAAG,EAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;gBACrC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACvD,CAAC;SACF,CAAC,CAAC;IACL,CAAC;CACF;AAxCD,gCAwCC"}

package/dist/types/src/otel/traces.d.ts

@@ -0,0 +1,8 @@
+import { type OtelOptions } from './otel';
+export declare class OtelTraces {
+    private readonly options;
+    private _tracer;
+    constructor(options: OtelOptions);
+    start(): void;
+}
+//# sourceMappingURL=traces.d.ts.map

package/dist/types/src/otel/traces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traces.d.ts","sourceRoot":"","sources":["../../../../src/otel/traces.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE1C,qBAAa,UAAU;IAET,OAAO,CAAC,QAAQ,CAAC,OAAO;IADpC,OAAO,CAAC,OAAO,CAAS;gBACK,OAAO,EAAE,WAAW;IAyB1C,KAAK;CASb"}

package/dist/types/src/otel/traces.js

@@ -0,0 +1,44 @@
+"use strict";
+//
+// Copyright 2024 DXOS.org
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelTraces = void 0;
+const api_1 = require("@opentelemetry/api");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const debug_1 = require("debug");
+const tracing_1 = require("@dxos/tracing");
+class OtelTraces {
+    constructor(options) {
+        this.options = options;
+        const resource = resources_1.Resource.default().merge(new resources_1.Resource({
+            [semantic_conventions_1.SEMRESATTRS_SERVICE_NAME]: this.options.serviceName,
+            [semantic_conventions_1.SEMRESATTRS_SERVICE_VERSION]: this.options.serviceVersion,
+        }));
+        const tracerProvider = new sdk_trace_base_1.BasicTracerProvider({ resource });
+        tracerProvider.addSpanProcessor(new sdk_trace_base_1.SimpleSpanProcessor(new sdk_trace_base_1.ConsoleSpanExporter()));
+        tracerProvider.addSpanProcessor(new sdk_trace_base_1.BatchSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            url: this.options.endpoint + '/v1/traces',
+            headers: {
+                Authorization: this.options.authorizationHeader,
+            },
+            concurrencyLimit: 10, // an optional limit on pending requests
+        })));
+        tracerProvider.register();
+        this._tracer = api_1.trace.getTracer('dxos-observability', this.options.serviceVersion);
+    }
+    start() {
+        (0, debug_1.log)('trace processor registered');
+        tracing_1.TRACE_PROCESSOR.remoteTracing.registerProcessor({
+            startSpan: (options) => {
+                (0, debug_1.log)('begin otel trace', { options });
+                return this._tracer.startSpan(options.name, options);
+            },
+        });
+    }
+}
+exports.OtelTraces = OtelTraces;
+//# sourceMappingURL=traces.js.map

package/dist/types/src/otel/traces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traces.js","sourceRoot":"","sources":["../../../../src/otel/traces.ts"],"names":[],"mappings":";AAAA,EAAE;AACF,0BAA0B;AAC1B,EAAE;;;AAEF,4CAAwD;AACxD,sFAA4E;AAC5E,wDAAoD;AACpD,kEAKuC;AACvC,8EAA4G;AAC5G,iCAA4B;AAE5B,2CAAuE;AAIvE,MAAa,UAAU;IAErB,YAA6B,OAAoB;QAApB,YAAO,GAAP,OAAO,CAAa;QAC/C,MAAM,QAAQ,GAAG,oBAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,CACvC,IAAI,oBAAQ,CAAC;YACX,CAAC,+CAAwB,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;YACpD,CAAC,kDAA2B,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;SAC3D,CAAC,CACH,CAAC;QAEF,MAAM,cAAc,GAAG,IAAI,oCAAmB,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC7D,cAAc,CAAC,gBAAgB,CAAC,IAAI,oCAAmB,CAAC,IAAI,oCAAmB,EAAE,CAAC,CAAC,CAAC;QACpF,cAAc,CAAC,gBAAgB,CAC7B,IAAI,mCAAkB,CACpB,IAAI,4CAAiB,CAAC;YACpB,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,YAAY;YACzC,OAAO,EAAE;gBACP,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,mBAAmB;aAChD;YACD,gBAAgB,EAAE,EAAE,EAAE,wCAAwC;SAC/D,CAAC,CACH,CACF,CAAC;QACF,cAAc,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,WAAK,CAAC,SAAS,CAAC,oBAAoB,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;IACpF,CAAC;IAEM,KAAK;QACV,IAAA,WAAG,EAAC,4BAA4B,CAAC,CAAC;QAClC,yBAAe,CAAC,aAAa,CAAC,iBAAiB,CAAC;YAC9C,SAAS,EAAE,CAAC,OAAyB,EAAE,EAAE;gBACvC,IAAA,WAAG,EAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;gBACrC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACvD,CAAC;SACF,CAAC,CAAC;IACL,CAAC;CACF;AApCD,gCAoCC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/observability",
-  "version": "0.6.3-main.daaea86",
+  "version": "0.6.3-main.e6314a6",
   "description": "Provides a common interface for app and platform observability",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -37,7 +37,8 @@
     "./src/datadog/node.ts": "./src/datadog/browser.ts",
     "./src/segment/node.ts": "./src/segment/browser.ts",
     "./src/sentry/node.ts": "./src/sentry/browser.ts",
-    "./testing/testkit/index.ts": "./testing/testkit/browser.ts"
+    "./testing/testkit/index.ts": "./testing/testkit/browser.ts",
+    "./src/otel/traces.ts": "./src/otel/traces-browser.ts"
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
@@ -58,35 +59,49 @@
     "src"
   ],
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.52.1",
+    "@opentelemetry/auto-instrumentations-web": "^0.40.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.52.1",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.52.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.52.1",
+    "@opentelemetry/instrumentation": "^0.52.1",
+    "@opentelemetry/resources": "^1.25.1",
+    "@opentelemetry/sdk-logs": "^0.52.1",
+    "@opentelemetry/sdk-metrics": "^1.25.1",
+    "@opentelemetry/sdk-trace-base": "^1.25.1",
+    "@opentelemetry/sdk-trace-web": "^1.25.1",
+    "@opentelemetry/semantic-conventions": "^1.25.0",
     "@segment/analytics-node": "^2.1.0",
     "@segment/snippet": "^4.15.3",
-    "@sentry/browser": "^8.7.0",
-    "@sentry/node": "^8.7.0",
+    "@sentry/browser": "^8.8.0",
+    "@sentry/node": "^8.8.0",
     "datadog-metrics": "^0.11.1",
     "debug": "^4.3.4",
     "js-yaml": "^4.1.0",
     "localforage": "^1.10.0",
     "uuid": "^9.0.0",
-    "@dxos/async": "0.6.3-main.daaea86",
-    "@dxos/client": "0.6.3-main.daaea86",
-    "@dxos/client-protocol": "0.6.3-main.daaea86",
-    "@dxos/client-services": "0.6.3-main.daaea86",
-    "@dxos/config": "0.6.3-main.daaea86",
-    "@dxos/context": "0.6.3-main.daaea86",
-    "@dxos/debug": "0.6.3-main.daaea86",
-    "@dxos/invariant": "0.6.3-main.daaea86",
-    "@dxos/log": "0.6.3-main.daaea86",
-    "@dxos/network-manager": "0.6.3-main.daaea86",
-    "@dxos/protocols": "0.6.3-main.daaea86",
-    "@dxos/node-std": "0.6.3-main.daaea86",
-    "@dxos/tracing": "0.6.3-main.daaea86",
-    "@dxos/util": "0.6.3-main.daaea86"
+    "@dxos/async": "0.6.3-main.e6314a6",
+    "@dxos/client": "0.6.3-main.e6314a6",
+    "@dxos/client-protocol": "0.6.3-main.e6314a6",
+    "@dxos/client-services": "0.6.3-main.e6314a6",
+    "@dxos/context": "0.6.3-main.e6314a6",
+    "@dxos/config": "0.6.3-main.e6314a6",
+    "@dxos/debug": "0.6.3-main.e6314a6",
+    "@dxos/log": "0.6.3-main.e6314a6",
+    "@dxos/invariant": "0.6.3-main.e6314a6",
+    "@dxos/network-manager": "0.6.3-main.e6314a6",
+    "@dxos/protocols": "0.6.3-main.e6314a6",
+    "@dxos/node-std": "0.6.3-main.e6314a6",
+    "@dxos/util": "0.6.3-main.e6314a6",
+    "@dxos/tracing": "0.6.3-main.e6314a6"
   },
   "devDependencies": {
-    "@sentry/types": "^8.7.0",
+    "@sentry/types": "^8.8.0",
     "@types/debug": "^4.1.10",
     "@types/js-yaml": "^4.0.5",
-    "sentry-testkit": "^5.0.5"
+    "sentry-testkit": "^5.0.5",
+    "zone.js": ">=0.11.4 <0.12.0-0 || >=0.13.0 <0.14.0-0 || >=0.14.0 <0.15.0-0"
   },
   "publishConfig": {
     "access": "public"

package/src/cli-observability-secrets.json

@@ -3,5 +3,7 @@
   "TELEMETRY_API_KEY": "B00QG6PtJJrJ0VVFe0H5a6bcUUShKyZM",
   "IPDATA_API_KEY": "73dfdecdf979c18f07d50cf841bbdd9e589f237256326ac8cca23786",
   "DATADOG_API_KEY": null,
-  "DATADOG_APP_KEY": null
+  "DATADOG_APP_KEY": null,
+  "OTEL_ENDPOINT": null,
+  "OTEL_AUTHORIZATION": null
 }

package/src/helpers/browser-observability.ts

@@ -155,6 +155,7 @@ export const initializeAppObservability = async ({
     // TODO(nf): should provide capability to init Sentry earlier in booting process to capture errors during initialization.
 
     await observability.initialize();
+    observability.startErrorLogs();
 
     const ipData = await getIPData(config);
 

package/src/observability.ts

@@ -15,9 +15,10 @@ import { isNode } from '@dxos/util';
 import buildSecrets from './cli-observability-secrets.json';
 import { type DatadogMetrics } from './datadog';
 import { type IPData, getTelemetryIdentifier, mapSpaces } from './helpers';
+import { type OtelLogs, type OtelMetrics, type OtelTraces } from './otel';
 import { type SegmentTelemetry, type EventOptions, type PageOptions } from './segment';
 import { type InitOptions, type captureException as SentryCaptureException } from './sentry';
-import { SentryLogProcessor } from './sentry/sentry-log-processor';
+import { type SentryLogProcessor } from './sentry/sentry-log-processor';
 
 const SPACE_METRICS_MIN_INTERVAL = 1000 * 60; // 1 minute
 const SPACE_TELEMETRY_MIN_INTERVAL = 1000 * 60 * 60; // 1 hour
@@ -33,6 +34,8 @@ export type ObservabilitySecrets = {
   IPDATA_API_KEY: string | null;
   DATADOG_API_KEY: string | null;
   DATADOG_APP_KEY: string | null;
+  OTEL_ENDPOINT: string | null;
+  OTEL_AUTHORIZATION: string | null;
 };
 
 export type Mode = 'basic' | 'full' | 'disabled';
@@ -66,10 +69,14 @@ export type ObservabilityOptions = {
 export class Observability {
   // TODO(wittjosiah): Generic metrics interface.
   private _metrics?: DatadogMetrics;
+  private _otelMetrics?: OtelMetrics;
+  private _otelTraces?: OtelTraces;
   // TODO(wittjosiah): Generic telemetry interface.
   private _telemetryBatchSize: number;
   private _telemetry?: SegmentTelemetry;
   // TODO(wittjosiah): Generic error logging interface.
+  private _sentryLogProcessor?: SentryLogProcessor;
+  private _otelLogs?: OtelLogs;
   private _errorReportingOptions?: InitOptions;
   private _captureException?: typeof SentryCaptureException;
   private _captureUserFeedback?: (name: string, email: string, message: string) => Promise<void>;
@@ -135,11 +142,14 @@ export class Observability {
 
       process.env.DX_ENVIRONMENT && (mergedSecrets.DX_ENVIRONMENT = process.env.DX_ENVIRONMENT);
       process.env.DX_RELEASE && (mergedSecrets.DX_RELEASE = process.env.DX_RELEASE);
+      // TODO: prefix these with DX_?
       process.env.SENTRY_DESTINATION && (mergedSecrets.SENTRY_DESTINATION = process.env.SENTRY_DESTINATION);
       process.env.TELEMETRY_API_KEY && (mergedSecrets.TELEMETRY_API_KEY = process.env.TELEMETRY_API_KEY);
       process.env.IPDATA_API_KEY && (mergedSecrets.IPDATA_API_KEY = process.env.IPDATA_API_KEY);
       process.env.DATADOG_API_KEY && (mergedSecrets.DATADOG_API_KEY = process.env.DATADOG_API_KEY);
       process.env.DATADOG_APP_KEY && (mergedSecrets.DATADOG_APP_KEY = process.env.DATADOG_APP_KEY);
+      process.env.DX_OTEL_ENDPOINT && (mergedSecrets.OTEL_ENDPOINT = process.env.DX_OTEL_ENDPOINT);
+      process.env.DX_OTEL_AUTHORIZATION && (mergedSecrets.OTEL_AUTHORIZATION = process.env.DX_OTEL_AUTHORIZATION);
 
       return mergedSecrets;
     } else {
@@ -152,6 +162,8 @@ export class Observability {
         IPDATA_API_KEY: config?.get('runtime.app.env.DX_IPDATA_API_KEY'),
         DATADOG_API_KEY: config?.get('runtime.app.env.DX_DATADOG_API_KEY'),
         DATADOG_APP_KEY: config?.get('runtime.app.env.DX_DATADOG_APP_KEY'),
+        OTEL_ENDPOINT: config?.get('runtime.app.env.DX_OTEL_ENDPOINT'),
+        OTEL_AUTHORIZATION: config?.get('runtime.app.env.DX_OTEL_AUTHORIZATION'),
         ...secrets,
       };
     }
@@ -161,12 +173,16 @@ export class Observability {
     await this._initMetrics();
     await this._initTelemetry();
     await this._initErrorLogs();
+    await this._initTraces();
   }
 
   async close() {
-    if (this._telemetry) {
-      await this._telemetry.close();
-    }
+    const closes: Promise<void>[] = [];
+    this._telemetry && closes.push(this._telemetry.close());
+    this._otelMetrics && closes.push(this._otelMetrics.close());
+    this._otelLogs && closes.push(this._otelLogs.close());
+
+    await Promise.all(closes);
     await this._ctx.dispose();
 
     // TODO(wittjosiah): Remove telemetry, etc. scripts.
@@ -258,6 +274,27 @@ export class Observability {
     } else {
       log('datadog disabled');
     }
+
+    if (this.enabled && this._secrets.OTEL_ENDPOINT && this._secrets.OTEL_AUTHORIZATION) {
+      const { OtelMetrics } = await import('./otel');
+      this._otelMetrics = new OtelMetrics({
+        endpoint: this._secrets.OTEL_ENDPOINT,
+        authorizationHeader: this._secrets.OTEL_AUTHORIZATION,
+        serviceName: this._namespace,
+        serviceVersion: this.getTag('release')?.value ?? '0.0.0',
+        getTags: () =>
+          Object.fromEntries(
+            Array.from(this._tags)
+              .filter(([key, value]) => {
+                return value.scope === 'all' || value.scope === 'metrics';
+              })
+              .map(([key, value]) => [key, value.value]),
+          ),
+      });
+      log('otel metrics enabled');
+    } else {
+      log('otel metrics disabled');
+    }
   }
 
   /**
@@ -267,6 +304,7 @@ export class Observability {
    */
   gauge(name: string, value: number | any, extraTags?: any) {
     this._metrics?.gauge(name, value, extraTags);
+    this._otelMetrics?.gauge(name, value, extraTags);
   }
 
   // TODO(nf): Refactor into ObservabilityExtensions.
@@ -399,14 +437,20 @@ export class Observability {
     scheduleTaskInterval(
       this._ctx,
       async () => {
-        log('platform');
+        if (client.services.constructor.name === 'WorkerClientServices') {
+          const memory = (window.performance as any).memory;
+          if (memory) {
+            this.gauge('dxos.client.runtime.heapTotal', memory.totalJSHeapSize);
+            this.gauge('dxos.client.runtime.heapUsed', memory.usedJSHeapSize);
+            this.gauge('dxos.client.runtime.heapSizeLimit', memory.jsHeapSizeLimit);
+          }
+        }
         client.services.services.SystemService?.getPlatform()
           .then((platform) => {
-            log('platform', { platform });
             if (platform.memory) {
-              this.gauge('dxos.client.runtime.rss', platform.memory.rss);
-              this.gauge('dxos.client.runtime.heapTotal', platform.memory.heapTotal);
-              this.gauge('dxos.client.runtime.heapUsed', platform.memory.heapUsed);
+              this.gauge('dxos.client.services.runtime.rss', platform.memory.rss);
+              this.gauge('dxos.client.services.runtime.heapTotal', platform.memory.heapTotal);
+              this.gauge('dxos.client.services.runtime.heapUsed', platform.memory.heapUsed);
             }
           })
           .catch((error) => log('platform error', { error }));
@@ -464,6 +508,7 @@ export class Observability {
   private async _initErrorLogs() {
     if (this._secrets.SENTRY_DESTINATION && this._mode !== 'disabled') {
       const { captureException, captureUserFeedback, init, setTag } = await import('./sentry');
+      const { SentryLogProcessor } = await import('./sentry/sentry-log-processor');
       this._captureException = captureException;
       this._captureUserFeedback = captureUserFeedback;
 
@@ -474,17 +519,14 @@ export class Observability {
         dest: this._secrets.SENTRY_DESTINATION,
         options: this._errorReportingOptions,
       });
-
-      const logProcessor = new SentryLogProcessor();
+      this._sentryLogProcessor = new SentryLogProcessor();
       init({
         ...this._errorReportingOptions,
         destination: this._secrets.SENTRY_DESTINATION,
         scrubFilenames: this._mode !== 'full',
-        onError: (event) => logProcessor.addLogBreadcrumbsTo(event),
+        onError: (event) => this._sentryLogProcessor!.addLogBreadcrumbsTo(event),
       });
-
       // TODO(nf): set platform at instantiation? needed for node.
-      log.runtimeConfig.processors.push(logProcessor.logProcessor);
 
       // TODO(nf): is this different than passing as properties in options?
       this._tags.forEach((v, k) => {
@@ -495,6 +537,57 @@ export class Observability {
     } else {
       log('sentry disabled');
     }
+
+    if (this._secrets.OTEL_ENDPOINT && this._secrets.OTEL_AUTHORIZATION && this._mode !== 'disabled') {
+      const { OtelLogs } = await import('./otel');
+      this._otelLogs = new OtelLogs({
+        endpoint: this._secrets.OTEL_ENDPOINT,
+        authorizationHeader: this._secrets.OTEL_AUTHORIZATION,
+        serviceName: this._namespace,
+        serviceVersion: this.getTag('release')?.value ?? '0.0.0',
+        getTags: () =>
+          Object.fromEntries(
+            Array.from(this._tags)
+              .filter(([key, value]) => {
+                return value.scope === 'all' || value.scope === 'errors';
+              })
+              .map(([key, value]) => [key, value.value]),
+          ),
+      });
+      log('otel logs enabled', { namespace: this._namespace });
+    } else {
+      log('otel logs disabled');
+    }
+  }
+
+  startErrorLogs() {
+    this._sentryLogProcessor && log.runtimeConfig.processors.push(this._sentryLogProcessor.logProcessor);
+    this._otelLogs && log.runtimeConfig.processors.push(this._otelLogs.logProcessor);
+  }
+
+  startTraces() {
+    this._otelTraces && this._otelTraces.start();
+  }
+
+  // TODO(nf): refactor init based on providers and their capabilities
+  private async _initTraces() {
+    if (this._secrets.OTEL_ENDPOINT && this._secrets.OTEL_AUTHORIZATION && this._mode !== 'disabled') {
+      const { OtelTraces } = await import('./otel');
+      this._otelTraces = new OtelTraces({
+        endpoint: this._secrets.OTEL_ENDPOINT,
+        authorizationHeader: this._secrets.OTEL_AUTHORIZATION,
+        serviceName: this._namespace,
+        serviceVersion: this.getTag('release')?.value ?? '0.0.0',
+        getTags: () =>
+          Object.fromEntries(
+            Array.from(this._tags)
+              .filter(([key, value]) => {
+                return value.scope === 'all' || value.scope === 'metrics';
+              })
+              .map(([key, value]) => [key, value.value]),
+          ),
+      });
+    }
   }
 
   /**

package/src/otel/index.ts

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

package/src/otel/logs.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { Resource } from '@opentelemetry/resources';
+import { BatchLogRecordProcessor, LoggerProvider } from '@opentelemetry/sdk-logs';
+import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+
+import {
+  getContextFromEntry,
+  getRelativeFilename,
+  type LogConfig,
+  type LogEntry,
+  LogLevel,
+  type LogProcessor,
+  shouldLog,
+} from '@dxos/log';
+import { jsonlogify } from '@dxos/util';
+
+import { type OtelOptions, setDiagLogger } from './otel';
+
+export class OtelLogs {
+  private _loggerProvider: LoggerProvider;
+  constructor(private readonly options: OtelOptions) {
+    setDiagLogger(options.consoleDiagLogLevel);
+    const resource = Resource.default().merge(
+      new Resource({
+        [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 });
+    this._loggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(logExporter));
+  }
+
+  public readonly logProcessor: LogProcessor = (config: LogConfig, entry: LogEntry) => {
+    const logger = this._loggerProvider.getLogger('dxos-observability', this.options.serviceVersion);
+
+    if (!shouldLog(entry, config.captureFilters) || 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() {
+    return this._loggerProvider.forceFlush();
+  }
+
+  close() {
+    return this._loggerProvider.shutdown();
+  }
+}
+
+const convertLevel = (level: LogLevel): SeverityNumber => {
+  switch (level) {
+    case LogLevel.DEBUG:
+      return SeverityNumber.DEBUG;
+    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/metrics.ts

@@ -0,0 +1,111 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type Attributes, type Meter, type ObservableGauge } from '@opentelemetry/api';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { Resource } from '@opentelemetry/resources';
+import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+
+import { log } from '@dxos/log';
+import { TRACE_PROCESSOR, type MetricData } from '@dxos/tracing';
+
+import { type OtelOptions, setDiagLogger } from './otel';
+
+const EXPORT_INTERVAL = 60 * 1000;
+
+type SynchronousGauge = {
+  gauge: ObservableGauge<Attributes>;
+  nextValue: number;
+  nextTags?: any;
+};
+
+export class OtelMetrics {
+  private _meterProvider: MeterProvider;
+  private _meter: Meter;
+  private _gauges = new Map<string, SynchronousGauge>();
+
+  constructor(private readonly options: OtelOptions) {
+    // TODO: improve error handling/logging
+    //  https://github.com/open-telemetry/opentelemetry-js/issues/4823
+    setDiagLogger(options.consoleDiagLogLevel);
+    const resource = Resource.default().merge(
+      new Resource({
+        [SEMRESATTRS_SERVICE_NAME]: this.options.serviceName,
+        [SEMRESATTRS_SERVICE_VERSION]: this.options.serviceVersion,
+      }),
+    );
+
+    const grafanaMetricReader = new PeriodicExportingMetricReader({
+      exporter: new OTLPMetricExporter({
+        url: this.options.endpoint + '/v1/metrics',
+        headers: {
+          Authorization: this.options.authorizationHeader,
+        },
+      }),
+      exportIntervalMillis: EXPORT_INTERVAL,
+    });
+
+    this._meterProvider = new MeterProvider({
+      resource,
+      readers: [grafanaMetricReader],
+    });
+    this._meter = this._meterProvider.getMeter('dxos-observability');
+
+    const metrics = {
+      // TODO: update metrics names and remove prefix?
+      increment: (name: string, value?: number, data?: MetricData) => {
+        this.increment(name, value, convertTags(data));
+      },
+      distribution: (name: string, value: number, data?: MetricData) => {
+        this.distribution(name, value, convertTags(data));
+      },
+      set: (name: string, value: number | string, data?: MetricData) => {
+        // Not implemented, not part of Otel spec.
+      },
+      gauge: (name: string, value: number, data?: MetricData) => {
+        this.gauge(name, value, convertTags(data));
+      },
+    };
+
+    TRACE_PROCESSOR.remoteMetrics.registerProcessor(metrics);
+  }
+
+  gauge(name: string, value: number, tags?: any) {
+    const gauge = this._meter.createGauge(name);
+    log('otel gauge', { name, value, tags: { ...this.options.getTags(), ...tags } });
+    gauge.record(value, { ...this.options.getTags(), ...tags });
+  }
+
+  increment(name: string, value?: number, tags?: any) {
+    const counter = this._meter.createCounter(name);
+    log('otel counter', { name, value, tags: { ...this.options.getTags(), ...tags } });
+    counter.add(value ?? 1, { ...this.options.getTags(), ...tags });
+  }
+
+  distribution(name: string, value: number, tags?: any) {
+    const distribution = this._meter.createHistogram(name);
+    log('otel distribution', { name, value, tags: { ...this.options.getTags(), ...tags } });
+    distribution.record(value, { ...this.options.getTags(), ...tags });
+  }
+
+  flush() {
+    return this._meterProvider.forceFlush();
+  }
+
+  close() {
+    return this._meterProvider.shutdown();
+  }
+}
+
+const convertTags = (data?: MetricData) => {
+  if (data && data.tags) {
+    return Object.entries(data.tags).reduce<{ [key: string]: any }>((obj, [key, value]) => {
+      obj[key] = value;
+      return obj;
+    }, {});
+  } else {
+    return {};
+  }
+};

package/src/otel/otel.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { diag, DiagConsoleLogger, DiagLogLevel } from '@opentelemetry/api';
+
+export type OtelOptions = {
+  endpoint: string;
+  authorizationHeader: string;
+  serviceName: string; // For the Otel API, the name of the entity for which signals (metrics or trace) are collected.
+  serviceVersion: string; // For the Otel API, The name of the entity for which signals (metrics or trace) are collected.
+  getTags: () => { [key: string]: string };
+  consoleDiagLogLevel?: string;
+};
+
+export const setDiagLogger = (level?: string) => {
+  const logLevel = DiagLogLevel[level as keyof typeof DiagLogLevel];
+  if (logLevel) {
+    diag.setLogger(new DiagConsoleLogger(), logLevel);
+  }
+};