@powersync/service-core 0.0.0-dev-20250304151813 → 0.0.0-dev-20250306152715

package/src/metrics/metrics-interfaces.ts

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,74 @@
+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/AbstractReplicationJob.ts

@@ -2,10 +2,12 @@ import { container, logger } from '@powersync/lib-services-framework';
 import winston from 'winston';
 import * as storage from '../storage/storage-index.js';
 import { ErrorRateLimiter } from './ErrorRateLimiter.js';
+import { MetricsEngine } from '../metrics/MetricsEngine.js';
 
 export interface AbstractReplicationJobOptions {
   id: string;
   storage: storage.SyncRulesBucketStorage;
+  metrics: MetricsEngine;
   lock: storage.ReplicationLock;
   rateLimiter: ErrorRateLimiter;
 }

package/src/replication/AbstractReplicator.ts

@@ -7,6 +7,7 @@ import { SyncRulesProvider } from '../util/config/sync-rules/sync-rules-provider
 import { AbstractReplicationJob } from './AbstractReplicationJob.js';
 import { ErrorRateLimiter } from './ErrorRateLimiter.js';
 import { ConnectionTestResult } from './ReplicationModule.js';
+import { MetricsEngine } from '../metrics/MetricsEngine.js';
 
 // 5 minutes
 const PING_INTERVAL = 1_000_000_000n * 300n;
@@ -19,6 +20,7 @@ export interface CreateJobOptions {
 export interface AbstractReplicatorOptions {
   id: string;
   storageEngine: StorageEngine;
+  metricsEngine: MetricsEngine;
   syncRuleProvider: SyncRulesProvider;
   /**
    * This limits the effect of retries when there is a persistent issue.
@@ -33,6 +35,7 @@ export interface AbstractReplicatorOptions {
  */
 export abstract class AbstractReplicator<T extends AbstractReplicationJob = AbstractReplicationJob> {
   protected logger: winston.Logger;
+
   /**
    *  Map of replication jobs by sync rule id. Usually there is only one running job, but there could be two when
    *  transitioning to a new set of sync rules.
@@ -72,6 +75,10 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
     return this.options.rateLimiter;
   }
 
+  protected get metrics() {
+    return this.options.metricsEngine;
+  }
+
   public async start(): Promise<void> {
     this.runLoop().catch((e) => {
       this.logger.error('Data source fatal replication error', e);

package/src/replication/ReplicationModule.ts

@@ -64,6 +64,14 @@ export abstract class ReplicationModule<TConfig extends DataSourceConfig>
    */
   protected abstract createReplicator(context: system.ServiceContext): AbstractReplicator;
 
+  /**
+   *  Any additional initialization specific to the module should be added here. Will be called if necessary after the
+   *  main initialization has been completed
+   *  @param context
+   *  @protected
+   */
+  protected abstract onInitialized(context: system.ServiceContext): Promise<void>;
+
   public abstract testConnection(config: TConfig): Promise<ConnectionTestResult>;
 
   /**
@@ -93,6 +101,8 @@ export abstract class ReplicationModule<TConfig extends DataSourceConfig>
 
     context.replicationEngine?.register(this.createReplicator(context));
     context.routerEngine?.registerAPI(this.createRouteAPIAdapter());
+
+    await this.onInitialized(context);
   }
 
   protected decodeConfig(config: TConfig): void {

package/src/replication/replication-index.ts

@@ -3,3 +3,4 @@ export * from './AbstractReplicator.js';
 export * from './ErrorRateLimiter.js';
 export * from './ReplicationEngine.js';
 export * from './ReplicationModule.js';
+export * from './replication-metrics.js';

package/src/replication/replication-metrics.ts

@@ -0,0 +1,45 @@
+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_TOTAL,
+    description: 'Total number of replicated rows'
+  });
+
+  engine.createCounter({
+    name: ReplicationMetric.TRANSACTIONS_REPLICATED_TOTAL,
+    description: 'Total number of replicated transactions'
+  });
+
+  engine.createCounter({
+    name: ReplicationMetric.CHUNKS_REPLICATED_TOTAL,
+    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_TOTAL);
+  const transactions_replicated_total = engine.getCounter(ReplicationMetric.TRANSACTIONS_REPLICATED_TOTAL);
+  const chunks_replicated_total = engine.getCounter(ReplicationMetric.CHUNKS_REPLICATED_TOTAL);
+
+  data_replicated_bytes.add(0);
+  rows_replicated_total.add(0);
+  transactions_replicated_total.add(0);
+  chunks_replicated_total.add(0);
+}

package/src/routes/endpoints/socket-route.ts

@@ -2,18 +2,19 @@ import { ErrorCode, errors, logger, schema } from '@powersync/lib-services-frame
 import { RequestParameters } from '@powersync/service-sync-rules';
 import { serialize } from 'bson';
 
-import { Metrics } from '../../metrics/Metrics.js';
 import * as sync from '../../sync/sync-index.js';
 import * as util from '../../util/util-index.js';
 import { SocketRouteGenerator } from '../router-socket.js';
 import { SyncRoutes } from './sync-stream.js';
 
+import { APIMetric } from '@powersync/service-types';
+
 export const syncStreamReactive: SocketRouteGenerator = (router) =>
   router.reactiveStream<util.StreamingSyncRequest, any>(SyncRoutes.STREAM, {
     validator: schema.createTsCodecValidator(util.StreamingSyncRequest, { allowAdditional: true }),
     handler: async ({ context, params, responder, observer, initialN, signal: upstreamSignal }) => {
       const { service_context } = context;
-      const { routerEngine, syncContext } = service_context;
+      const { routerEngine, metricsEngine, syncContext } = service_context;
 
       // Create our own controller that we can abort directly
       const controller = new AbortController();
@@ -69,8 +70,8 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
         controller.abort();
       });
 
-      Metrics.getInstance().concurrent_connections.add(1);
-      const tracker = new sync.RequestTracker();
+      metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(1);
+      const tracker = new sync.RequestTracker(metricsEngine);
       try {
         for await (const data of sync.streamResponse({
           syncContext: syncContext,
@@ -147,7 +148,7 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
           operations_synced: tracker.operationsSynced,
           data_synced_bytes: tracker.dataSyncedBytes
         });
-        Metrics.getInstance().concurrent_connections.add(-1);
+        metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(-1);
       }
     }
   });

package/src/routes/endpoints/sync-stream.ts

@@ -5,10 +5,11 @@ import { Readable } from 'stream';
 import * as sync from '../../sync/sync-index.js';
 import * as util from '../../util/util-index.js';
 
-import { Metrics } from '../../metrics/Metrics.js';
 import { authUser } from '../auth.js';
 import { routeDefinition } from '../router.js';
 
+import { APIMetric } from '@powersync/service-types';
+
 export enum SyncRoutes {
   STREAM = '/sync/stream'
 }
@@ -20,7 +21,7 @@ export const syncStreamed = routeDefinition({
   validator: schema.createTsCodecValidator(util.StreamingSyncRequest, { allowAdditional: true }),
   handler: async (payload) => {
     const { service_context } = payload.context;
-    const { routerEngine, storageEngine, syncContext } = service_context;
+    const { routerEngine, storageEngine, metricsEngine, syncContext } = service_context;
     const headers = payload.request.headers;
     const userAgent = headers['x-user-agent'] ?? headers['user-agent'];
     const clientId = payload.params.client_id;
@@ -49,9 +50,9 @@ export const syncStreamed = routeDefinition({
     const syncRules = bucketStorage.getParsedSyncRules(routerEngine!.getAPI().getParseSyncRulesOptions());
 
     const controller = new AbortController();
-    const tracker = new sync.RequestTracker();
+    const tracker = new sync.RequestTracker(metricsEngine);
     try {
-      Metrics.getInstance().concurrent_connections.add(1);
+      metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(1);
       const stream = Readable.from(
         sync.transformToBytesTracked(
           sync.ndjson(
@@ -96,7 +97,7 @@ export const syncStreamed = routeDefinition({
         data: stream,
         afterSend: async () => {
           controller.abort();
-          Metrics.getInstance().concurrent_connections.add(-1);
+          metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(-1);
           logger.info(`Sync stream complete`, {
             user_id: syncParams.user_id,
             client_id: clientId,
@@ -108,7 +109,7 @@ export const syncStreamed = routeDefinition({
       });
     } catch (ex) {
       controller.abort();
-      Metrics.getInstance().concurrent_connections.add(-1);
+      metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(-1);
     }
   }
 });

package/src/storage/BucketStorageBatch.ts

@@ -4,6 +4,7 @@ import { BSON } from 'bson';
 import { ReplicationEventPayload } from './ReplicationEventPayload.js';
 import { SourceTable } from './SourceTable.js';
 import { BatchedCustomWriteCheckpointOptions } from './storage-index.js';
+import { InternalOpId } from '../util/utils.js';
 
 export const DEFAULT_BUCKET_BATCH_COMMIT_OPTIONS: ResolvedBucketBatchCommitOptions = {
   createEmptyCheckpoints: true
@@ -144,7 +145,7 @@ export interface BucketBatchStorageListener {
 }
 
 export interface FlushedResult {
-  flushed_op: string;
+  flushed_op: InternalOpId;
 }
 
 export interface BucketBatchCommitOptions {

package/src/storage/ChecksumCache.ts

@@ -1,12 +1,11 @@
-import { BucketChecksum, OpId } from '../util/protocol-types.js';
-import { ChecksumMap, addBucketChecksums } from '../util/utils.js';
-import { LRUCache } from 'lru-cache/min';
 import { OrderedSet } from '@js-sdsl/ordered-set';
-import { BucketPriority } from '@powersync/service-sync-rules';
+import { LRUCache } from 'lru-cache/min';
+import { BucketChecksum } from '../util/protocol-types.js';
+import { addBucketChecksums, ChecksumMap, InternalOpId } from '../util/utils.js';
 
 interface ChecksumFetchContext {
   fetch(bucket: string): Promise<BucketChecksum>;
-  checkpoint: bigint;
+  checkpoint: InternalOpId;
 }
 
 export interface PartialChecksum {
@@ -28,10 +27,11 @@ export interface PartialChecksum {
    */
   isFullChecksum: boolean;
 }
+
 export interface FetchPartialBucketChecksum {
   bucket: string;
-  start?: OpId;
-  end: OpId;
+  start?: InternalOpId;
+  end: InternalOpId;
 }
 
 export type PartialChecksumMap = Map<string, PartialChecksum>;
@@ -101,8 +101,7 @@ export class ChecksumCache {
 
       dispose: (value, key) => {
         // Remove from the set of cached checkpoints for the bucket
-        const { checkpointString } = parseCacheKey(key);
-        const checkpoint = BigInt(checkpointString);
+        const { checkpoint } = parseCacheKey(key);
         const checkpointSet = this.bucketCheckpoints.get(value.bucket);
         if (checkpointSet == null) {
           return;
@@ -128,7 +127,7 @@ export class ChecksumCache {
     });
   }
 
-  async getChecksums(checkpoint: OpId, buckets: string[]): Promise<BucketChecksum[]> {
+  async getChecksums(checkpoint: InternalOpId, buckets: string[]): Promise<BucketChecksum[]> {
     const checksums = await this.getChecksumMap(checkpoint, buckets);
     // Return results in the same order as the request
     return buckets.map((bucket) => checksums.get(bucket)!);
@@ -141,7 +140,7 @@ export class ChecksumCache {
    *
    * @returns a Map with exactly one entry for each bucket requested
    */
-  async getChecksumMap(checkpoint: OpId, buckets: string[]): Promise<ChecksumMap> {
+  async getChecksumMap(checkpoint: InternalOpId, buckets: string[]): Promise<ChecksumMap> {
     // Buckets that don't have a cached checksum for this checkpoint yet
     let toFetch = new Set<string>();
 
@@ -235,7 +234,7 @@ export class ChecksumCache {
                 // Partial checksum found - make a partial checksum request
                 bucketRequest = {
                   bucket,
-                  start: cp.toString(),
+                  start: cp,
                   end: checkpoint
                 };
                 add.set(bucket, cached);
@@ -315,11 +314,11 @@ export class ChecksumCache {
   }
 }
 
-function makeCacheKey(checkpoint: bigint | string, bucket: string) {
+function makeCacheKey(checkpoint: InternalOpId | string, bucket: string) {
   return `${checkpoint}/${bucket}`;
 }
 
 function parseCacheKey(key: string) {
   const index = key.indexOf('/');
-  return { checkpointString: key.substring(0, index), bucket: key.substring(index + 1) };
+  return { checkpoint: BigInt(key.substring(0, index)), bucket: key.substring(index + 1) };
 }

package/src/storage/SyncRulesBucketStorage.ts

@@ -71,7 +71,7 @@ export interface SyncRulesBucketStorage
   /**
    * Used to resolve "dynamic" parameter queries.
    */
-  getParameterSets(checkpoint: util.OpId, lookups: SqliteJsonValue[][]): Promise<SqliteJsonRow[]>;
+  getParameterSets(checkpoint: util.InternalOpId, lookups: SqliteJsonValue[][]): Promise<SqliteJsonRow[]>;
 
   getCheckpointChanges(options: GetCheckpointChangesOptions): Promise<CheckpointChanges>;
 
@@ -94,8 +94,8 @@ export interface SyncRulesBucketStorage
    * @param options batch size options
    */
   getBucketDataBatch(
-    checkpoint: util.OpId,
-    dataBuckets: Map<string, string>,
+    checkpoint: util.InternalOpId,
+    dataBuckets: Map<string, util.InternalOpId>,
     options?: BucketDataBatchOptions
   ): AsyncIterable<SyncBucketDataBatch>;
 
@@ -104,7 +104,7 @@ export interface SyncRulesBucketStorage
    *
    * Returns zero checksums for any buckets not found.
    */
-  getChecksums(checkpoint: util.OpId, buckets: string[]): Promise<util.ChecksumMap>;
+  getChecksums(checkpoint: util.InternalOpId, buckets: string[]): Promise<util.ChecksumMap>;
 }
 
 export interface SyncRulesBucketStorageListener {
@@ -169,7 +169,7 @@ export interface CompactOptions {
    * This can also be used to create a "safe buffer" of recent operations that should
    * not be compacted, to avoid invalidating checkpoints in use.
    */
-  maxOpId?: bigint;
+  maxOpId?: util.InternalOpId;
 
   /**
    * If specified, compact only the specific buckets.
@@ -215,11 +215,11 @@ export interface BucketDataBatchOptions {
 
 export interface SyncBucketDataBatch {
   batch: util.SyncBucketData;
-  targetOp: bigint | null;
+  targetOp: util.InternalOpId | null;
 }
 
 export interface ReplicationCheckpoint {
-  readonly checkpoint: util.OpId;
+  readonly checkpoint: util.InternalOpId;
   readonly lsn: string | null;
 }
 
@@ -238,7 +238,7 @@ export interface WatchFilterEvent {
 
 export interface WriteCheckpoint {
   base: ReplicationCheckpoint;
-  writeCheckpoint: bigint | null;
+  writeCheckpoint: util.InternalOpId | null;
 }
 
 export interface StorageCheckpointUpdate extends WriteCheckpoint {
@@ -246,8 +246,8 @@ export interface StorageCheckpointUpdate extends WriteCheckpoint {
 }
 
 export interface GetCheckpointChangesOptions {
-  lastCheckpoint: util.OpId;
-  nextCheckpoint: util.OpId;
+  lastCheckpoint: util.InternalOpId;
+  nextCheckpoint: util.InternalOpId;
 }
 
 export interface CheckpointChanges {

package/src/storage/storage-index.ts

@@ -6,6 +6,7 @@ export * from './SourceEntity.js';
 export * from './SourceTable.js';
 export * from './StorageEngine.js';
 export * from './StorageProvider.js';
+export * from './storage-metrics.js';
 export * from './WriteCheckpointAPI.js';
 export * from './BucketStorageFactory.js';
 export * from './BucketStorageBatch.js';

package/src/storage/storage-metrics.ts

@@ -0,0 +1,67 @@
+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;
+    }
+  });
+}