@dxos/observability 0.3.11-main.0252f93

package/dist/lib/node/index.cjs

@@ -0,0 +1,630 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  Observability: () => Observability
+});
+module.exports = __toCommonJS(node_exports);
+var import_chunk_VDBBIYH6 = require("./chunk-VDBBIYH6.cjs");
+var import_chunk_FSAOBKO2 = require("./chunk-FSAOBKO2.cjs");
+var import_async = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_invariant = require("@dxos/invariant");
+var import_log = require("@dxos/log");
+var import_network_manager = require("@dxos/network-manager");
+var import_services = require("@dxos/protocols/proto/dxos/client/services");
+var import_util = require("@dxos/util");
+var import_analytics_node = __toESM(require("analytics-node"));
+var import_invariant2 = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var cli_observability_secrets_default = {
+  SENTRY_DESTINATION: "https://2647916221e643869965e78469479aa4@o4504012000067584.ingest.sentry.io/4504012027265029",
+  TELEMETRY_API_KEY: "B00QG6PtJJrJ0VVFe0H5a6bcUUShKyZM",
+  IPDATA_API_KEY: "73dfdecdf979c18f07d50cf841bbdd9e589f237256326ac8cca23786",
+  DATADOG_API_KEY: null,
+  DATADOG_APP_KEY: null
+};
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/segment/node.ts";
+var SegmentTelemetry = class {
+  constructor({ apiKey, batchSize, getTags }) {
+    this._getTags = getTags;
+    try {
+      (0, import_invariant2.invariant)(apiKey, "Key required to send telemetry", {
+        F: __dxlog_file,
+        L: 20,
+        S: this,
+        A: [
+          "apiKey",
+          "'Key required to send telemetry'"
+        ]
+      });
+      this._analytics = new import_analytics_node.default(apiKey, {
+        flushAt: batchSize,
+        enable: true
+      });
+    } catch (err) {
+      import_log2.log.catch("Failed to initialize telemetry", err, {
+        F: __dxlog_file,
+        L: 27,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Track a page view.
+  */
+  page({ installationId: anonymousId, identityId: userId, ...options } = {}) {
+    if (!this._analytics) {
+      (0, import_log2.log)("Analytics not initialized", {
+        action: "page"
+      }, {
+        F: __dxlog_file,
+        L: 36,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    try {
+      this._analytics.page({
+        ...options,
+        userId,
+        anonymousId
+      });
+    } catch (err) {
+      import_log2.log.catch("Failed to track page", err, {
+        F: __dxlog_file,
+        L: 47,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Track an event.
+  */
+  event({ installationId: anonymousId, identityId: userId, name: event, ...options }) {
+    (0, import_log2.log)("sending event to telemetry", {
+      event,
+      options,
+      tags: Object.fromEntries(this._getTags().entries())
+    }, {
+      F: __dxlog_file,
+      L: 55,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (!this._analytics) {
+      (0, import_log2.log)("Analytics not initialized", {
+        action: "event"
+      }, {
+        F: __dxlog_file,
+        L: 57,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    try {
+      this._analytics.track({
+        ...options,
+        context: Object.fromEntries(this._getTags().entries()),
+        userId,
+        anonymousId,
+        event
+      });
+    } catch (err) {
+      import_log2.log.catch("Failed to track event", err, {
+        F: __dxlog_file,
+        L: 70,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Flush the event queue.
+  */
+  async flush() {
+    if (!this._analytics) {
+      (0, import_log2.log)("Analytics not initialized", {
+        action: "flush"
+      }, {
+        F: __dxlog_file,
+        L: 79,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    try {
+      await this._analytics.flush((err) => {
+        (0, import_chunk_FSAOBKO2.captureException)(err);
+      });
+    } catch (err) {
+      import_log2.log.catch("Failed to flush", err, {
+        F: __dxlog_file,
+        L: 88,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+};
+var mapSpaces = (spaces, options = {
+  verbose: false,
+  truncateKeys: false
+}) => {
+  return spaces.map((space) => {
+    const { open, ready } = space.internal.data.metrics ?? {};
+    const startup = open && ready && ready.getTime() - open.getTime();
+    const pipeline = space.internal.data.pipeline;
+    const startDataMutations = pipeline?.currentEpoch?.subject.assertion.timeframe.totalMessages() ?? 0;
+    const epoch = pipeline?.currentEpoch?.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,
+      name: space.properties.name,
+      members: space.members.get().length,
+      objects: space.db.query().objects.length,
+      startup,
+      epoch,
+      // appliedEpoch,
+      startDataMutations,
+      currentDataMutations,
+      totalDataMutations,
+      // TODO(burdon): Negative?
+      progress: (Math.min(Math.abs((currentDataMutations - startDataMutations) / (totalDataMutations - startDataMutations)), 1) * 100).toFixed(0)
+    };
+  });
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/observability/src/observability.ts";
+var SPACE_METRICS_MIN_INTERVAL = 1e3 * 60;
+var DATADOG_IDLE_INTERVAL = 1e3 * 60 * 1;
+var ERROR_TAGS = [
+  "identityKey",
+  "username",
+  "deviceKey",
+  "group"
+];
+var Observability = class {
+  // TODO(nf): make platform a required extension?
+  constructor({ namespace, config, secrets, group, mode, telemetry, errorLog, logProcessor }) {
+    this._mode = "disabled";
+    this._ctx = new import_context.Context();
+    this._tags = /* @__PURE__ */ new Map();
+    this._namespace = namespace;
+    this._config = config;
+    this._mode = mode ?? "disabled";
+    this._group = group;
+    this._secrets = this._loadSecrets(config, secrets);
+    this._telemetryBatchSize = telemetry?.batchSize ?? 30;
+    this._errorReportingOptions = errorLog?.sentryInitOptions;
+    this._errorLogProcessor = logProcessor ?? false;
+    if (this._group) {
+      this.setTag("group", this._group);
+    }
+    this.setTag("namespace", this._namespace);
+    if (this._mode === "full") {
+    }
+  }
+  _loadSecrets(config, secrets) {
+    if ((0, import_util.isNode)()) {
+      return cli_observability_secrets_default;
+    } else {
+      (0, import_invariant.invariant)(config, "runtime config is required", {
+        F: __dxlog_file2,
+        L: 117,
+        S: this,
+        A: [
+          "config",
+          "'runtime config is required'"
+        ]
+      });
+      (0, import_log.log)("config", {
+        rtc: this._secrets,
+        config
+      }, {
+        F: __dxlog_file2,
+        L: 118,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return {
+        DX_ENVIRONMENT: config.get("runtime.app.env.DX_ENVIRONMENT"),
+        DX_RELEASE: config.get("runtime.app.env.DX_RELEASE"),
+        SENTRY_DESTINATION: config.get("runtime.app.env.DX_SENTRY_DESTINATION"),
+        TELEMETRY_API_KEY: config.get("runtime.app.env.DX_TELEMETRY_API_KEY"),
+        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"),
+        ...secrets
+      };
+    }
+  }
+  initialize() {
+    this._initMetrics();
+    this._initTelemetry();
+    this._initErrorLogs();
+  }
+  async close() {
+    await this._ctx.dispose();
+  }
+  setMode(mode) {
+    this._mode = mode;
+  }
+  get mode() {
+    return this._mode;
+  }
+  get enabled() {
+    return this._mode !== "disabled";
+  }
+  //
+  // Tags
+  //
+  /**
+  * Set a tag for all observability services.
+  */
+  setTag(key, value) {
+    if (this.enabled && ERROR_TAGS.includes(key)) {
+      (0, import_chunk_FSAOBKO2.setTag)(key, value);
+    }
+    this._tags.set(key, value);
+  }
+  // TODO(nf): Combine with setDeviceTags.
+  async setIdentityTags(client) {
+    client.services.services.IdentityService.queryIdentity().subscribe((idqr) => {
+      if (!idqr?.identity?.identityKey) {
+        (0, import_log.log)("empty response from identity service", {
+          idqr
+        }, {
+          F: __dxlog_file2,
+          L: 175,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this.setTag("identityKey", idqr?.identity?.identityKey.truncate());
+      if (idqr?.identity?.profile?.displayName) {
+        this.setTag("username", idqr?.identity?.profile?.displayName);
+      }
+    });
+  }
+  async setDeviceTags(client) {
+    client.services.services.DevicesService.queryDevices().subscribe((dqr) => {
+      if (!dqr || !dqr.devices || dqr.devices.length === 0) {
+        (0, import_log.log)("empty response from device service", {
+          device: dqr
+        }, {
+          F: __dxlog_file2,
+          L: 191,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      (0, import_invariant.invariant)(dqr, "empty response from device service", {
+        F: __dxlog_file2,
+        L: 194,
+        S: this,
+        A: [
+          "dqr",
+          "'empty response from device service'"
+        ]
+      });
+      const thisDevice = dqr.devices.find((device) => device.kind === import_services.DeviceKind.CURRENT);
+      if (!thisDevice) {
+        (0, import_log.log)("no current device", {
+          device: dqr
+        }, {
+          F: __dxlog_file2,
+          L: 198,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this.setTag("deviceKey", thisDevice.deviceKey.truncate());
+      if (thisDevice.profile?.label) {
+        this.setTag("deviceProfile", thisDevice.profile.label);
+      }
+    });
+  }
+  //
+  // Metrics
+  //
+  _initMetrics() {
+    if (this.enabled && this._secrets.DATADOG_API_KEY) {
+      this._metrics = new import_chunk_VDBBIYH6.DatadogMetrics({
+        apiKey: this._secrets.DATADOG_API_KEY,
+        getTags: () => this._tags,
+        // TODO(nf): move/refactor from telementryContext, needed to read CORS proxy
+        config: this._config
+      });
+    } else {
+      (0, import_log.log)("datadog disabled", void 0, {
+        F: __dxlog_file2,
+        L: 221,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Gauge metric.
+  *
+  * The default implementation uses Datadog.
+  */
+  gauge(name, value, extraTags) {
+    this._metrics?.gauge(name, value, extraTags);
+  }
+  // TODO(nf): Refactor into ObservabilityExtensions.
+  startNetworkMetrics(client) {
+    const updateSignalMetrics = new import_async.Event();
+    updateSignalMetrics.on(this._ctx, async (networkStatus) => {
+      (0, import_log.log)("send signal metrics", void 0, {
+        F: __dxlog_file2,
+        L: 241,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      networkStatus.signaling.forEach(({ server, state }) => {
+        this.gauge("dxos.client.network.signal.connectionState", state, {
+          server
+        });
+      });
+      let swarmCount = 0;
+      const connectionStates = /* @__PURE__ */ new Map();
+      for (const state in import_network_manager.ConnectionState) {
+        connectionStates.set(state, 0);
+      }
+      let totalReadBufferSize = 0;
+      let totalWriteBufferSize = 0;
+      let totalChannelBufferSize = 0;
+      networkStatus.connectionInfo?.forEach((connectionInfo) => {
+        swarmCount++;
+        for (const conn of connectionInfo.connections ?? []) {
+          connectionStates.set(conn.state, (connectionStates.get(conn.state) ?? 0) + 1);
+          totalReadBufferSize += conn.readBufferSize ?? 0;
+          totalWriteBufferSize += conn.writeBufferSize ?? 0;
+          for (const stream of conn.streams ?? []) {
+            totalChannelBufferSize += stream.writeBufferSize ?? 0;
+          }
+        }
+        this.gauge("dxos.client.network.swarm.count", swarmCount);
+        for (const state in import_network_manager.ConnectionState) {
+          this.gauge("dxos.client.network.connection.count", connectionStates.get(state) ?? 0, {
+            state
+          });
+        }
+        this.gauge("dxox.client.network.totalReadBufferSize", totalReadBufferSize);
+        this.gauge("dxos.client.network.totalWriteBufferSize", totalWriteBufferSize);
+        this.gauge("dxos.client.network.totalChannelBufferSize", totalChannelBufferSize);
+      });
+    });
+    client.services.services.NetworkService?.queryStatus().subscribe((networkStatus) => {
+      updateSignalMetrics.emit(networkStatus);
+    });
+  }
+  startSpacesMetrics(client) {
+    let spaces = client.spaces.get();
+    const subscriptions = /* @__PURE__ */ new Map();
+    this._ctx.onDispose(() => subscriptions.forEach((subscription) => subscription.unsubscribe()));
+    const updateSpaceMetrics = new import_async.Event().debounce(SPACE_METRICS_MIN_INTERVAL);
+    updateSpaceMetrics.on(this._ctx, async (space) => {
+      (0, import_log.log)("send space update", void 0, {
+        F: __dxlog_file2,
+        L: 293,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      for (const sp of mapSpaces(spaces, {
+        truncateKeys: true
+      })) {
+        this.gauge("dxos.client.space.members", sp.members, {
+          key: sp.key
+        });
+        this.gauge("dxos.client.space.objects", sp.objects, {
+          key: sp.key
+        });
+        this.gauge("dxos.client.space.epoch", sp.epoch, {
+          key: sp.key
+        });
+        this.gauge("dxos.client.space.currentDataMutations", sp.currentDataMutations, {
+          key: sp.key
+        });
+      }
+    });
+    const subscribeToSpaceUpdate = (space) => space.pipeline.subscribe({
+      next: () => {
+        updateSpaceMetrics.emit();
+      }
+    });
+    spaces.forEach((space) => {
+      subscriptions.set(space.key.toHex(), subscribeToSpaceUpdate(space));
+    });
+    client.spaces.subscribe({
+      next: async () => {
+        spaces = client.spaces.get();
+        spaces.filter((space) => !subscriptions.has(space.key.toHex())).forEach((space) => {
+          subscriptions.set(space.key.toHex(), subscribeToSpaceUpdate(space));
+        });
+      }
+    });
+    (0, import_async.scheduleTaskInterval)(this._ctx, async () => updateSpaceMetrics.emit(), DATADOG_IDLE_INTERVAL);
+  }
+  async startRuntimeMetrics(client, frequency = DATADOG_IDLE_INTERVAL) {
+    const platform = await client.services.services.SystemService?.getPlatform();
+    (0, import_invariant.invariant)(platform, "platform is required", {
+      F: __dxlog_file2,
+      L: 330,
+      S: this,
+      A: [
+        "platform",
+        "'platform is required'"
+      ]
+    });
+    this.setTag("platform_type", import_services.Platform.PLATFORM_TYPE[platform.type].toLowerCase());
+    if (this._mode === "full") {
+      if (platform.platform) {
+        this.setTag("platform", platform.platform);
+      }
+      if (platform.arch) {
+        this.setTag("arch", platform.arch);
+      }
+      if (platform.runtime) {
+        this.setTag("runtime", platform.runtime);
+      }
+    }
+    (0, import_async.scheduleTaskInterval)(this._ctx, async () => {
+      (0, import_log.log)("platform", void 0, {
+        F: __dxlog_file2,
+        L: 348,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      client.services.services.SystemService?.getPlatform().then((platform2) => {
+        (0, import_log.log)("platform", {
+          platform: platform2
+        }, {
+          F: __dxlog_file2,
+          L: 351,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (platform2.memory) {
+          this.gauge("dxos.client.runtime.rss", platform2.memory.rss);
+          this.gauge("dxos.client.runtime.heapTotal", platform2.memory.heapTotal);
+          this.gauge("dxos.client.runtime.heapUsed", platform2.memory.heapUsed);
+        }
+      }).catch((error) => (0, import_log.log)("platform error", {
+        error
+      }, {
+        F: __dxlog_file2,
+        L: 358,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    }, frequency);
+  }
+  //
+  // Telemetry
+  //
+  _initTelemetry() {
+    if (this._secrets.TELEMETRY_API_KEY && this._mode !== "disabled") {
+      this._telemetry = new SegmentTelemetry({
+        apiKey: this._secrets.TELEMETRY_API_KEY,
+        batchSize: this._telemetryBatchSize,
+        getTags: () => this._tags
+      });
+    } else {
+      (0, import_log.log)("segment disabled", void 0, {
+        F: __dxlog_file2,
+        L: 376,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * A telemetry event.
+  *
+  * The default implementation uses Segment.
+  */
+  event(options) {
+    this._telemetry?.event(options);
+  }
+  /**
+  * A telemetry page view.
+  *
+  * The default implementation uses Segment.
+  */
+  page(options) {
+    this._telemetry?.page(options);
+  }
+  //
+  // Error Logs
+  //
+  _initErrorLogs() {
+    if (this._secrets.SENTRY_DESTINATION && this._mode !== "disabled") {
+      import_log.log.info("Initializing Sentry", {
+        dest: this._secrets.SENTRY_DESTINATION,
+        options: this._errorReportingOptions
+      }, {
+        F: __dxlog_file2,
+        L: 405,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      (0, import_chunk_FSAOBKO2.init)({
+        ...this._errorReportingOptions,
+        destination: this._secrets.SENTRY_DESTINATION,
+        scrubFilenames: this._mode !== "full"
+      });
+      if (this._errorReportingOptions?.tracing) {
+        (0, import_chunk_FSAOBKO2.configureTracing)();
+      }
+      if (this._errorLogProcessor) {
+        (0, import_chunk_FSAOBKO2.enableSentryLogProcessor)();
+      }
+      this._tags.forEach((v, k) => {
+        if (ERROR_TAGS.includes(k)) {
+          (0, import_chunk_FSAOBKO2.setTag)(k, v);
+        }
+      });
+    } else {
+      (0, import_log.log)("sentry disabled", void 0, {
+        F: __dxlog_file2,
+        L: 428,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  /**
+  * Manually capture an exception.
+  *
+  * The default implementation uses Sentry.
+  */
+  captureException(err) {
+    if (this.enabled) {
+      (0, import_chunk_FSAOBKO2.captureException)(err);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Observability
+});
+//# sourceMappingURL=index.cjs.map