@powersync/service-core 0.0.0-dev-20250310210938 → 0.0.0-dev-20250312090341

package/src/metrics/metrics-interfaces.ts

@@ -1,41 +0,0 @@
-export interface Counter {
-  /**
-   *  Increment the counter by the given value. Only positive numbers are valid.
-   *  @param value
-   */
-  add(value: number): void;
-}
-
-export interface UpDownCounter {
-  /**
-   *  Increment or decrement(if negative) the counter by the given value.
-   *  @param value
-   */
-  add(value: number): void;
-}
-
-export interface ObservableGauge {
-  /**
-   *  Set a value provider that provides the value for the gauge at the time of observation.
-   *  @param valueProvider
-   */
-  setValueProvider(valueProvider: () => Promise<number | undefined>): void;
-}
-
-export enum Precision {
-  INT = 'int',
-  DOUBLE = 'double'
-}
-
-export interface MetricMetadata {
-  name: string;
-  description?: string;
-  unit?: string;
-  precision?: Precision;
-}
-
-export interface MetricsFactory {
-  createCounter(metadata: MetricMetadata): Counter;
-  createUpDownCounter(metadata: MetricMetadata): UpDownCounter;
-  createObservableGauge(metadata: MetricMetadata): ObservableGauge;
-}

package/src/metrics/open-telemetry/OpenTelemetryMetricsFactory.ts

@@ -1,66 +0,0 @@
-import { Meter, ValueType } from '@opentelemetry/api';
-import {
-  Counter,
-  ObservableGauge,
-  UpDownCounter,
-  MetricMetadata,
-  MetricsFactory,
-  Precision
-} from '../metrics-interfaces.js';
-
-export class OpenTelemetryMetricsFactory implements MetricsFactory {
-  private meter: Meter;
-
-  constructor(meter: Meter) {
-    this.meter = meter;
-  }
-
-  createCounter(metadata: MetricMetadata): Counter {
-    return this.meter.createCounter(metadata.name, {
-      description: metadata.description,
-      unit: metadata.unit,
-      valueType: this.toValueType(metadata.precision)
-    });
-  }
-
-  createObservableGauge(metadata: MetricMetadata): ObservableGauge {
-    const gauge = this.meter.createObservableGauge(metadata.name, {
-      description: metadata.description,
-      unit: metadata.unit,
-      valueType: this.toValueType(metadata.precision)
-    });
-
-    return {
-      setValueProvider(valueProvider: () => Promise<number | undefined>) {
-        gauge.addCallback(async (result) => {
-          const value = await valueProvider();
-
-          if (value) {
-            result.observe(value);
-          }
-        });
-      }
-    };
-  }
-
-  createUpDownCounter(metadata: MetricMetadata): UpDownCounter {
-    return this.meter.createUpDownCounter(metadata.name, {
-      description: metadata.description,
-      unit: metadata.unit,
-      valueType: this.toValueType(metadata.precision)
-    });
-  }
-
-  private toValueType(precision?: Precision): ValueType {
-    if (!precision) {
-      return ValueType.INT;
-    }
-
-    switch (precision) {
-      case Precision.INT:
-        return ValueType.INT;
-      case Precision.DOUBLE:
-        return ValueType.DOUBLE;
-    }
-  }
-}

package/src/metrics/open-telemetry/util.ts

@@ -1,74 +0,0 @@
-import { MeterProvider, MetricReader, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
-import { env } from '../../util/env.js';
-import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
-import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
-import { Resource } from '@opentelemetry/resources';
-import { ServiceContext } from '../../system/ServiceContext.js';
-import { OpenTelemetryMetricsFactory } from './OpenTelemetryMetricsFactory.js';
-import { MetricsFactory } from '../metrics-interfaces.js';
-
-export interface RuntimeMetadata {
-  [key: string]: string | number | undefined;
-}
-
-export function createOpenTelemetryMetricsFactory(context: ServiceContext): MetricsFactory {
-  const { configuration, lifeCycleEngine, storageEngine } = context;
-  const configuredExporters: MetricReader[] = [];
-
-  if (env.METRICS_PORT) {
-    const prometheusExporter = new PrometheusExporter({ port: env.METRICS_PORT, preventServerStart: true });
-    configuredExporters.push(prometheusExporter);
-
-    lifeCycleEngine.withLifecycle(prometheusExporter, {
-      start: () => prometheusExporter.startServer()
-    });
-  }
-
-  if (!configuration.telemetry.disable_telemetry_sharing) {
-    const periodicExporter = new PeriodicExportingMetricReader({
-      exporter: new OTLPMetricExporter({
-        url: configuration.telemetry.internal_service_endpoint
-      }),
-      exportIntervalMillis: 1000 * 60 * 5 // 5 minutes
-    });
-
-    configuredExporters.push(periodicExporter);
-  }
-
-  let resolvedMetadata: (metadata: RuntimeMetadata) => void;
-  const runtimeMetadata: Promise<RuntimeMetadata> = new Promise((resolve) => {
-    resolvedMetadata = resolve;
-  });
-
-  lifeCycleEngine.withLifecycle(null, {
-    start: async () => {
-      const bucketStorage = storageEngine.activeBucketStorage;
-      try {
-        const instanceId = await bucketStorage.getPowerSyncInstanceId();
-        resolvedMetadata({ ['instance_id']: instanceId });
-      } catch (err) {
-        resolvedMetadata({ ['instance_id']: 'Unknown' });
-      }
-    }
-  });
-
-  const meterProvider = new MeterProvider({
-    resource: new Resource(
-      {
-        ['service']: 'PowerSync'
-      },
-      runtimeMetadata
-    ),
-    readers: configuredExporters
-  });
-
-  lifeCycleEngine.withLifecycle(meterProvider, {
-    stop: async () => {
-      await meterProvider.shutdown();
-    }
-  });
-
-  const meter = meterProvider.getMeter('powersync');
-
-  return new OpenTelemetryMetricsFactory(meter);
-}

package/src/replication/replication-metrics.ts

@@ -1,45 +0,0 @@
-import { MetricsEngine } from '../metrics/metrics-index.js';
-import { ReplicationMetric } from '@powersync/service-types';
-
-/**
- *  Create and register the core replication metrics.
- *  @param engine
- */
-export function createCoreReplicationMetrics(engine: MetricsEngine): void {
-  engine.createCounter({
-    name: ReplicationMetric.DATA_REPLICATED_BYTES,
-    description: 'Uncompressed size of replicated data',
-    unit: 'bytes'
-  });
-
-  engine.createCounter({
-    name: ReplicationMetric.ROWS_REPLICATED,
-    description: 'Total number of replicated rows'
-  });
-
-  engine.createCounter({
-    name: ReplicationMetric.TRANSACTIONS_REPLICATED,
-    description: 'Total number of replicated transactions'
-  });
-
-  engine.createCounter({
-    name: ReplicationMetric.CHUNKS_REPLICATED,
-    description: 'Total number of replication chunks'
-  });
-}
-
-/**
- *  Initialise the core replication metrics. This should be called after the metrics have been created.
- *  @param engine
- */
-export function initializeCoreReplicationMetrics(engine: MetricsEngine): void {
-  const data_replicated_bytes = engine.getCounter(ReplicationMetric.DATA_REPLICATED_BYTES);
-  const rows_replicated_total = engine.getCounter(ReplicationMetric.ROWS_REPLICATED);
-  const transactions_replicated_total = engine.getCounter(ReplicationMetric.TRANSACTIONS_REPLICATED);
-  const chunks_replicated_total = engine.getCounter(ReplicationMetric.CHUNKS_REPLICATED);
-
-  data_replicated_bytes.add(0);
-  rows_replicated_total.add(0);
-  transactions_replicated_total.add(0);
-  chunks_replicated_total.add(0);
-}

package/src/storage/storage-metrics.ts

@@ -1,67 +0,0 @@
-import { MetricsEngine } from '../metrics/MetricsEngine.js';
-import { logger } from '@powersync/lib-services-framework';
-import { BucketStorageFactory, StorageMetrics } from './BucketStorageFactory.js';
-import { StorageMetric } from '@powersync/service-types';
-
-export function createCoreStorageMetrics(engine: MetricsEngine): void {
-  engine.createObservableGauge({
-    name: StorageMetric.REPLICATION_SIZE_BYTES,
-    description: 'Size of current data stored in PowerSync',
-    unit: 'bytes'
-  });
-
-  engine.createObservableGauge({
-    name: StorageMetric.OPERATION_SIZE_BYTES,
-    description: 'Size of operations stored in PowerSync',
-    unit: 'bytes'
-  });
-
-  engine.createObservableGauge({
-    name: StorageMetric.PARAMETER_SIZE_BYTES,
-    description: 'Size of parameter data stored in PowerSync',
-    unit: 'bytes'
-  });
-}
-
-export function initializeCoreStorageMetrics(engine: MetricsEngine, storage: BucketStorageFactory): void {
-  const replication_storage_size_bytes = engine.getObservableGauge(StorageMetric.REPLICATION_SIZE_BYTES);
-  const operation_storage_size_bytes = engine.getObservableGauge(StorageMetric.OPERATION_SIZE_BYTES);
-  const parameter_storage_size_bytes = engine.getObservableGauge(StorageMetric.PARAMETER_SIZE_BYTES);
-
-  const MINIMUM_INTERVAL = 60_000;
-
-  let cachedRequest: Promise<StorageMetrics | null> | undefined = undefined;
-  let cacheTimestamp = 0;
-
-  const getMetrics = () => {
-    if (cachedRequest == null || Date.now() - cacheTimestamp > MINIMUM_INTERVAL) {
-      cachedRequest = storage.getStorageMetrics().catch((e) => {
-        logger.error(`Failed to get storage metrics`, e);
-        return null;
-      });
-      cacheTimestamp = Date.now();
-    }
-    return cachedRequest;
-  };
-
-  replication_storage_size_bytes.setValueProvider(async () => {
-    const metrics = await getMetrics();
-    if (metrics) {
-      return metrics.replication_size_bytes;
-    }
-  });
-
-  operation_storage_size_bytes.setValueProvider(async () => {
-    const metrics = await getMetrics();
-    if (metrics) {
-      return metrics.operations_size_bytes;
-    }
-  });
-
-  parameter_storage_size_bytes.setValueProvider(async () => {
-    const metrics = await getMetrics();
-    if (metrics) {
-      return metrics.parameters_size_bytes;
-    }
-  });
-}