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

package/dist/types/src/observability.js

@@ -1,497 +1,209 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2025 DXOS.org
 //
-import { Event, scheduleTaskInterval } from '@dxos/async';
-import { PublicKey } from '@dxos/client';
-import { Context } from '@dxos/context';
+import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import { SubscriptionList } from '@dxos/async';
 import { invariant } from '@dxos/invariant';
-import { LogLevel, log } from '@dxos/log';
-import { ConnectionState } from '@dxos/network-manager';
-import { DeviceKind, Platform } from '@dxos/protocols/proto/dxos/client/services';
-import { isNode } from '@dxos/util';
-import buildSecrets from './cli-observability-secrets.json';
-import { getTelemetryIdentity, mapSpaces } from './helpers';
-import { TelemetryEvent } from './segment';
-const SPACE_METRICS_MIN_INTERVAL = 1000 * 60; // 1 minute
-const SPACE_TELEMETRY_MIN_INTERVAL = 1000 * 60 * 60; // 1 hour
-const NETWORK_METRICS_MIN_INTERVAL = 1000 * 60 * 5; // 5 minutes
-/*
- * Observability provides a common interface for error logging, metrics, and telemetry.
- * It currently provides these capabilities using Sentry, OpenTelemetry, and Segment.
- *
- * Segment:
- * https://app.segment.com/dxos/sources/composer-app/debugger
- * https://app.segment.com/dxos/sources/composer-app/settings/keys
- *
- * NOTE:
- * - Segment maintains a set of admin creates Source (e.g., "composer-app").
- * - Each source has at least one API_KEY, which is used by the client.
- *
- * Testing:
- * https://app.segment.com/dxos/sources/composer-app/settings/keys
- * - DX_TELEMETRY_API_KEY
- * - DX_SENTRY_DESTINATION
- *
- * Sentry:
- * https://sentry.io/organizations/dxos/issues
- *
- * OpenTelemetry:
- * https://dxosorg.grafana.net/explore
- */
-export class Observability {
-    _mode;
-    _namespace;
-    _config;
-    _group;
-    _secrets;
-    _tags = new Map();
-    // TODO(wittjosiah): Generic metrics interface.
-    _otelMetrics;
-    _otelTraces;
-    // TODO(wittjosiah): Generic telemetry interface.
-    _telemetryBatchSize;
-    _telemetry;
-    // TODO(wittjosiah): Generic error logging interface.
-    _sentryLogProcessor;
-    _otelLogs;
-    _errorReportingOptions;
-    _captureException;
-    _captureUserFeedback;
-    _lastNetworkStatus;
-    _ctx = new Context();
-    // TODO(nf): make platform a required extension?
-    constructor({ mode, namespace, environment, release, config, group, secrets, telemetry, errorLog, }) {
-        this._mode = mode;
-        this._namespace = namespace;
-        this._config = config;
-        this._group = group;
-        this._secrets = this._loadSecrets(config, secrets);
-        this._telemetryBatchSize = telemetry?.batchSize ?? 30;
-        this._errorReportingOptions = errorLog?.sentryInitOptions;
-        // Tags.
-        this.setTag('mode', this._mode);
-        this.setTag('namespace', this._namespace);
-        this.setTag('environment', environment);
-        this.setTag('release', release);
-        this.setTag('session', PublicKey.random().toHex());
-        this.setTag('group', this._group);
-    }
-    get mode() {
-        return this._mode;
-    }
-    get group() {
-        return this._group;
-    }
-    get enabled() {
-        return this._mode !== 'disabled';
-    }
-    _loadSecrets(config, secrets) {
-        if (isNode()) {
-            const mergedSecrets = {
-                ...buildSecrets,
-                ...secrets,
-            };
-            process.env.DX_ENVIRONMENT && (mergedSecrets.DX_ENVIRONMENT = process.env.DX_ENVIRONMENT);
-            process.env.DX_RELEASE && (mergedSecrets.DX_RELEASE = process.env.DX_RELEASE);
-            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.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 {
-            log('config', { rtc: this._secrets, config });
-            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'),
-                OTEL_ENDPOINT: config?.get('runtime.app.env.DX_OTEL_ENDPOINT'),
-                OTEL_AUTHORIZATION: config?.get('runtime.app.env.DX_OTEL_AUTHORIZATION'),
-                ...secrets,
-            };
-        }
-    }
-    async initialize() {
-        log('initializing...');
-        await this._initLogs();
-        await this._initMetrics();
-        await this._initTelemetry();
-        await this._initErrorLogs();
-        await this._initTraces();
-    }
-    async close() {
-        log('closing...');
-        const closes = [];
-        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();
-    }
-    setMode(mode) {
-        this._mode = mode;
-    }
-    //
-    // Tags
-    //
-    /** Callback (e.g., to share tags with Sentry.) */
-    _setTag;
-    /**
-     * camelCase keys are converted to snake_case in Segment.
-     */
-    setTag(key, value, scope) {
-        if (value === undefined) {
-            return;
-        }
-        if (this.enabled && (scope === undefined || scope === 'all' || scope === 'errors')) {
-            this._setTag?.(key, value);
-        }
-        if (!scope) {
-            scope = 'all';
-        }
-        this._tags.set(key, { value, scope });
-    }
-    getTag(key) {
-        return this._tags.get(key);
-    }
-    // TODO(wittjosiah): Improve privacy of telemetry identifiers. See `getTelemetryIdentifier`.
-    async setIdentityTags(clientServices) {
-        if (clientServices.IdentityService) {
-            clientServices.IdentityService.queryIdentity().subscribe((idqr) => {
-                if (!idqr?.identity?.did) {
-                    log('empty response from identity service', { idqr });
-                    return;
-                }
-                this.setTag('did', idqr.identity.did);
-                this._telemetry?.identify({ userId: idqr.identity.did });
-            });
-        }
-        if (clientServices.DevicesService) {
-            clientServices.DevicesService.queryDevices().subscribe((dqr) => {
-                if (!dqr || !dqr.devices || dqr.devices.length === 0) {
-                    log('empty response from device service', { device: dqr });
-                    return;
-                }
-                invariant(dqr, 'empty response from device service');
-                const thisDevice = dqr.devices.find((device) => device.kind === DeviceKind.CURRENT);
-                if (!thisDevice) {
-                    log('no current device', { device: dqr });
-                    return;
-                }
-                this.setTag('deviceKey', thisDevice.deviceKey.truncate());
-                if (thisDevice.profile?.label) {
-                    this.setTag('deviceProfile', thisDevice.profile.label);
+import { log } from '@dxos/log';
+export * from './storage';
+class ObservabilityImpl {
+    _initialized = false;
+    _extensions = [];
+    _dataProviders = [];
+    _subscriptions = new SubscriptionList();
+    initialize() {
+        if (this._initialized) {
+            return Effect.succeed(undefined);
+        }
+        const initializedExtensions = [];
+        return Effect.gen(this, function* () {
+            for (const extension of this._extensions) {
+                if (extension.initialize) {
+                    yield* extension.initialize();
                 }
-            });
-        }
-    }
-    setIPDataTelemetryTags = (ipData) => {
-        this.setTag('city', ipData.city, 'telemetry');
-        this.setTag('region', ipData.region, 'telemetry');
-        this.setTag('country', ipData.country, 'telemetry');
-        ipData.latitude && this.setTag('latitude', ipData.latitude.toString(), 'telemetry');
-        ipData.longitude && this.setTag('longitude', ipData.longitude.toString(), 'telemetry');
-    };
-    //
-    // Logs
-    //
-    async _initLogs() {
-        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])),
-                logLevel: LogLevel.VERBOSE,
-                includeSharedWorkerLogs: false,
-            });
-            this._otelLogs && log.runtimeConfig.processors.push(this._otelLogs.logProcessor);
-            log('otel logs enabled', { namespace: this._namespace });
-        }
-        else {
-            log('otel logs disabled');
-        }
-    }
-    //
-    // Metrics
-    //
-    async _initMetrics() {
-        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');
-        }
-    }
-    /**
-     * Gauge metric.
-     *
-     * The default implementation uses OpenTelemetry
-     */
-    gauge(name, value, extraTags) {
-        this._otelMetrics?.gauge(name, value, extraTags);
-    }
-    // TODO(nf): Refactor into ObservabilityExtensions.
-    startNetworkMetrics(clientServices) {
-        if (!clientServices.NetworkService) {
-            return;
-        }
-        // TODO(nf): support type in debounce()
-        const updateSignalMetrics = new Event().debounce(NETWORK_METRICS_MIN_INTERVAL);
-        updateSignalMetrics.on(this._ctx, async () => {
-            log('send signal metrics');
-            this._lastNetworkStatus?.signaling?.forEach(({ server, state }) => {
-                this.gauge('dxos.client.network.signal.connectionState', state, { server });
-            });
-            let swarmCount = 0;
-            const connectionStates = new Map();
-            for (const state in ConnectionState) {
-                connectionStates.set(state, 0);
+                initializedExtensions.push(extension);
             }
-            let totalReadBufferSize = 0;
-            let totalWriteBufferSize = 0;
-            let totalChannelBufferSize = 0;
-            this._lastNetworkStatus?.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;
-                    }
+            const cleanups = yield* Effect.all(this._dataProviders.map((provider) => provider(this)));
+            this._subscriptions.add(...cleanups.filter((cleanup) => cleanup !== undefined));
+            this._initialized = true;
+        }).pipe(Effect.catchAll((error) => Effect.gen(this, function* () {
+            log.catch(error);
+            // Roll back already-initialized extensions.
+            for (const extension of initializedExtensions) {
+                if (extension.close) {
+                    yield* extension.close().pipe(Effect.catchAll(() => Effect.succeed(undefined)));
                 }
-                this.gauge('dxos.client.network.swarm.count', swarmCount);
-                for (const state in ConnectionState) {
-                    this.gauge('dxos.client.network.connection.count', connectionStates.get(state) ?? 0, { state });
+            }
+            this._subscriptions.clear();
+        })));
+    }
+    close() {
+        return Effect.gen(this, function* () {
+            this._subscriptions.clear();
+            this._dataProviders.length = 0;
+            for (const extension of this._extensions) {
+                if (extension.close) {
+                    yield* extension.close();
                 }
-                this.gauge('dxos.client.network.totalReadBufferSize', totalReadBufferSize);
-                this.gauge('dxos.client.network.totalWriteBufferSize', totalWriteBufferSize);
-                this.gauge('dxos.client.network.totalChannelBufferSize', totalChannelBufferSize);
-            });
-        });
-        clientServices.NetworkService.queryStatus().subscribe((networkStatus) => {
-            this._lastNetworkStatus = networkStatus;
-            updateSignalMetrics.emit();
+            }
+            this._initialized = false;
         });
-        scheduleTaskInterval(this._ctx, async () => updateSignalMetrics.emit(), NETWORK_METRICS_MIN_INTERVAL);
     }
-    startSpacesMetrics(client, namespace) {
-        // TODO(nf): update subscription on new spaces
-        const spaces = client.spaces.get();
-        const subscriptions = new Map();
-        this._ctx.onDispose(() => subscriptions.forEach((subscription) => subscription.unsubscribe()));
-        const updateSpaceMetrics = new Event().debounce(SPACE_METRICS_MIN_INTERVAL);
-        updateSpaceMetrics.on(this._ctx, async () => {
-            log('send space metrics');
-            for (const data of mapSpaces(spaces, { truncateKeys: true })) {
-                this.gauge('dxos.client.space.members', data.members, { key: data.key });
-                this.gauge('dxos.client.space.objects', data.objects, { key: data.key });
-                this.gauge('dxos.client.space.epoch', data.epoch, { key: data.key });
-                this.gauge('dxos.client.space.currentDataMutations', data.currentDataMutations, { key: data.key });
+    enable() {
+        return Effect.gen(this, function* () {
+            for (const extension of this._extensions) {
+                if (extension.enable) {
+                    yield* extension.enable();
+                }
             }
         });
-        const updateSpaceTelemetry = new Event().debounce(SPACE_TELEMETRY_MIN_INTERVAL);
-        updateSpaceTelemetry.on(this._ctx, async () => {
-            log('send space telemetry');
-            for (const data of mapSpaces(spaces, { truncateKeys: true })) {
-                this.track({
-                    ...getTelemetryIdentity(client),
-                    event: TelemetryEvent.METRICS,
-                    action: 'space.update',
-                    properties: data,
-                });
+    }
+    disable() {
+        return Effect.gen(this, function* () {
+            for (const extension of this._extensions) {
+                if (extension.disable) {
+                    yield* extension.disable();
+                }
             }
         });
-        const subscribeToSpaceUpdate = (space) => space.pipeline.subscribe({
-            next: () => {
-                updateSpaceMetrics.emit();
-                updateSpaceTelemetry.emit();
-            },
-        });
-        spaces.forEach((space) => {
-            subscriptions.set(space.id, subscribeToSpaceUpdate(space));
-        });
-        client.spaces.subscribe({
-            next: async (spaces) => {
-                spaces
-                    .filter((space) => !subscriptions.has(space.id))
-                    .forEach((space) => {
-                    subscriptions.set(space.id, subscribeToSpaceUpdate(space));
-                });
-            },
-        });
-        scheduleTaskInterval(this._ctx, async () => updateSpaceMetrics.emit(), NETWORK_METRICS_MIN_INTERVAL);
     }
-    async startRuntimeMetrics(client, frequency = NETWORK_METRICS_MIN_INTERVAL) {
-        const platform = await client.services.services.SystemService?.getPlatform();
-        invariant(platform, 'platform is required');
-        this.setTag('platformType', 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);
-            }
-        }
-        scheduleTaskInterval(this._ctx, async () => {
-            if (client.services.constructor.name === 'WorkerClientServices') {
-                const memory = window.performance.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);
+    flush() {
+        return Effect.gen(this, function* () {
+            for (const extension of this._extensions) {
+                if (extension.flush) {
+                    yield* extension.flush();
                 }
             }
-            client.services.services.SystemService?.getPlatform()
-                .then((platform) => {
-                if (platform.memory) {
-                    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 }));
-        }, frequency);
+        });
     }
-    //
-    // Telemetry
-    //
-    async _initTelemetry() {
-        if (this._secrets.TELEMETRY_API_KEY && this._mode !== 'disabled' && typeof document !== 'undefined') {
-            const { SegmentTelemetry } = await import('./segment');
-            this._telemetry = new SegmentTelemetry({
-                apiKey: this._secrets.TELEMETRY_API_KEY,
-                batchSize: this._telemetryBatchSize,
-                getTags: () => Object.fromEntries(Array.from(this._tags)
-                    .filter(([key, value]) => {
-                    return value.scope === 'all' || value.scope === 'telemetry';
-                })
-                    .map(([key, value]) => [key, value.value])),
-            });
-        }
-        else {
-            log('segment disabled');
-        }
+    _addExtension(extension) {
+        invariant(!this._initialized, 'Observability is already initialized');
+        this._extensions.push(extension);
     }
-    /**
-     * Submit telemetry page view.
-     * The default implementation uses Segment.
-     */
-    page(options) {
-        this._telemetry?.page(options);
+    _addDataProvider(dataProvider) {
+        invariant(!this._initialized, 'Observability is already initialized');
+        this._dataProviders.push(dataProvider);
     }
     /**
-     * Submit telemetry user action.
-     * The default implementation uses Segment.
+     * Adds a data provider and initializes it.
      */
-    track(options) {
-        this._telemetry?.track(options);
+    addDataProvider(dataProvider) {
+        return Effect.gen(this, function* () {
+            this._dataProviders.push(dataProvider);
+            const cleanup = yield* dataProvider(this);
+            if (cleanup) {
+                this._subscriptions.add(cleanup);
+            }
+        });
     }
-    //
-    // Error Logs
-    //
-    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;
-            this._setTag = setTag;
-            // TODO(nf): Refactor package into this one?
-            log.info('Initializing Sentry', {
-                dest: this._secrets.SENTRY_DESTINATION,
-                options: this._errorReportingOptions,
-            });
-            this._sentryLogProcessor = new SentryLogProcessor();
-            init({
-                ...this._errorReportingOptions,
-                destination: this._secrets.SENTRY_DESTINATION,
-                scrubFilenames: this._mode !== 'full',
-                onError: (event) => this._sentryLogProcessor.addLogBreadcrumbsTo(event),
-            });
-            // TODO(nf): Set platform at instantiation? needed for node.
-            // TODO(nf): Is this different than passing as properties in options?
-            this._tags.forEach((v, k) => {
-                if (v.scope === 'all' || v.scope === 'errors') {
-                    setTag(k, v.value);
-                }
-            });
+    identify(distinctId, attributes, setOnceAttributes) {
+        for (const extension of this._extensions) {
+            extension.identify?.(distinctId, attributes, setOnceAttributes);
         }
-        else {
-            log('sentry disabled');
+    }
+    alias(distinctId, previousId) {
+        for (const extension of this._extensions) {
+            extension.alias?.(distinctId, previousId);
         }
     }
-    startErrorLogs() {
-        this._sentryLogProcessor && log.runtimeConfig.processors.push(this._sentryLogProcessor.logProcessor);
+    setTags(tags, kind) {
+        for (const extension of this._extensions) {
+            if (kind && !extension.apis.some((api) => api.kind === kind)) {
+                continue;
+            }
+            const processedTags = Object.fromEntries(Object.entries(tags)
+                .filter((entry) => entry[1] !== undefined)
+                .map(([key, value]) => [key, value.toString()]));
+            extension.setTags?.(processedTags);
+        }
     }
-    startTraces() {
-        this._otelTraces && this._otelTraces.start();
+    get enabled() {
+        return this._extensions.every((extension) => extension.enabled);
     }
-    // TODO(nf): Refactor init based on providers and their capabilities.
-    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])),
-            });
-        }
+    get errors() {
+        return {
+            captureException: (error, attributes) => {
+                for (const extension of this._getExtensions('errors')) {
+                    extension.captureException(error, attributes);
+                }
+            },
+        };
     }
-    /**
-     * Manually capture an exception.
-     * The default implementation uses Sentry.
-     */
-    captureException(err) {
-        if (this.enabled) {
-            this._captureException?.(err);
-        }
+    get events() {
+        return {
+            captureEvent: (event, attributes) => {
+                for (const extension of this._getExtensions('events')) {
+                    extension.captureEvent(event, attributes);
+                }
+            },
+        };
     }
-    /**
-     * Manually capture user feedback.
-     * The default implementation uses Sentry.
-     */
-    captureUserFeedback(message) {
-        if (!this._secrets.SENTRY_DESTINATION) {
-            log.info('Feedback submitted without Sentry destination', { message });
-            return;
-        }
-        // TODO(Zan): Should this respect telemetry mode? Sending feedback is explicitly user-initiated.
-        // - Maybe if telemetry is disable we shouldn't enable replay.
-        // - (Check the browser.ts implementation for reference).
-        void this._captureUserFeedback?.(message);
+    get feedback() {
+        return {
+            captureUserFeedback: (form) => {
+                for (const extension of this._getExtensions('feedback')) {
+                    extension.captureUserFeedback(form);
+                }
+            },
+        };
+    }
+    isAvailable(kind) {
+        const apis = this._getExtensions(kind);
+        if (apis.length === 0) {
+            return Effect.succeed(false);
+        }
+        return Effect.gen(this, function* () {
+            for (const api of apis) {
+                const available = yield* api.isAvailable();
+                if (available) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    get metrics() {
+        return {
+            gauge: (name, value, attributes) => {
+                for (const extension of this._getExtensions('metrics')) {
+                    extension.gauge(name, value, attributes);
+                }
+            },
+            increment: (name, value, attributes) => {
+                for (const extension of this._getExtensions('metrics')) {
+                    extension.increment(name, value, attributes);
+                }
+            },
+            distribution: (name, value, attributes) => {
+                for (const extension of this._getExtensions('metrics')) {
+                    extension.distribution(name, value, attributes);
+                }
+            },
+        };
+    }
+    _getExtensions(kind) {
+        return Function.pipe(this._extensions, Array.flatMap((extension) => extension.apis), Array.filter((api) => api.kind === kind));
     }
 }
+export const make = () => Effect.succeed(new ObservabilityImpl());
+export const addExtension = (_extension) => Effect.fn(function* (_observability) {
+    const observability = yield* _observability;
+    const extension = yield* _extension;
+    invariant('_addExtension' in observability && typeof observability._addExtension === 'function');
+    observability._addExtension(extension);
+    return observability;
+});
+export const addDataProvider = (dataProvider) => Effect.fn(function* (_observability) {
+    const observability = yield* _observability;
+    invariant('_addDataProvider' in observability && typeof observability._addDataProvider === 'function');
+    observability._addDataProvider(dataProvider);
+    return observability;
+});
+export const initialize = Effect.fn(function* (_observability) {
+    const observability = yield* _observability;
+    yield* observability.initialize();
+    return observability;
+});
 //# sourceMappingURL=observability.js.map