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

package/src/metrics/Metrics.ts

@@ -0,0 +1,255 @@
+import { Attributes, Counter, ObservableGauge, UpDownCounter, ValueType } from '@opentelemetry/api';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
+import { Resource } from '@opentelemetry/resources';
+import { MeterProvider, MetricReader, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import { logger, ServiceAssertionError } from '@powersync/lib-services-framework';
+import * as storage from '../storage/storage-index.js';
+import * as util from '../util/util-index.js';
+
+export interface MetricsOptions {
+  disable_telemetry_sharing: boolean;
+  powersync_instance_id: string;
+  internal_metrics_endpoint: string;
+}
+
+export class Metrics {
+  private static instance: Metrics;
+
+  private prometheusExporter: PrometheusExporter;
+  private meterProvider: MeterProvider;
+
+  // Metrics
+  // 1. Data processing / month
+
+  // 1a. Postgres -> PowerSync
+  // Record on replication pod
+  public data_replicated_bytes: Counter<Attributes>;
+  // 1b. PowerSync -> clients
+  // Record on API pod
+  public data_synced_bytes: Counter<Attributes>;
+  // Unused for pricing
+  // Record on replication pod
+  public rows_replicated_total: Counter<Attributes>;
+  // Unused for pricing
+  // Record on replication pod
+  public transactions_replicated_total: Counter<Attributes>;
+  // Unused for pricing
+  // Record on replication pod
+  public chunks_replicated_total: Counter<Attributes>;
+
+  // 2. Sync operations / month
+
+  // Record on API pod
+  public operations_synced_total: Counter<Attributes>;
+
+  // 3. Data hosted on PowerSync sync service
+
+  // Record on replication pod
+  // 3a. Replication storage -> raw data as received from Postgres.
+  public replication_storage_size_bytes: ObservableGauge<Attributes>;
+  // 3b. Operations storage -> transformed history, as will be synced to clients
+  public operation_storage_size_bytes: ObservableGauge<Attributes>;
+  // 3c. Parameter storage -> used for parameter queries
+  public parameter_storage_size_bytes: ObservableGauge<Attributes>;
+
+  // 4. Peak concurrent connections
+
+  // Record on API pod
+  public concurrent_connections: UpDownCounter<Attributes>;
+
+  private constructor(meterProvider: MeterProvider, prometheusExporter: PrometheusExporter) {
+    this.meterProvider = meterProvider;
+    this.prometheusExporter = prometheusExporter;
+    const meter = meterProvider.getMeter('powersync');
+
+    this.data_replicated_bytes = meter.createCounter('powersync_data_replicated_bytes_total', {
+      description: 'Uncompressed size of replicated data',
+      unit: 'bytes',
+      valueType: ValueType.INT
+    });
+
+    this.data_synced_bytes = meter.createCounter('powersync_data_synced_bytes_total', {
+      description: 'Uncompressed size of synced data',
+      unit: 'bytes',
+      valueType: ValueType.INT
+    });
+
+    this.rows_replicated_total = meter.createCounter('powersync_rows_replicated_total', {
+      description: 'Total number of replicated rows',
+      valueType: ValueType.INT
+    });
+
+    this.transactions_replicated_total = meter.createCounter('powersync_transactions_replicated_total', {
+      description: 'Total number of replicated transactions',
+      valueType: ValueType.INT
+    });
+
+    this.chunks_replicated_total = meter.createCounter('powersync_chunks_replicated_total', {
+      description: 'Total number of replication chunks',
+      valueType: ValueType.INT
+    });
+
+    this.operations_synced_total = meter.createCounter('powersync_operations_synced_total', {
+      description: 'Number of operations synced',
+      valueType: ValueType.INT
+    });
+
+    this.replication_storage_size_bytes = meter.createObservableGauge('powersync_replication_storage_size_bytes', {
+      description: 'Size of current data stored in PowerSync',
+      unit: 'bytes',
+      valueType: ValueType.INT
+    });
+
+    this.operation_storage_size_bytes = meter.createObservableGauge('powersync_operation_storage_size_bytes', {
+      description: 'Size of operations stored in PowerSync',
+      unit: 'bytes',
+      valueType: ValueType.INT
+    });
+
+    this.parameter_storage_size_bytes = meter.createObservableGauge('powersync_parameter_storage_size_bytes', {
+      description: 'Size of parameter data stored in PowerSync',
+      unit: 'bytes',
+      valueType: ValueType.INT
+    });
+
+    this.concurrent_connections = meter.createUpDownCounter('powersync_concurrent_connections', {
+      description: 'Number of concurrent sync connections',
+      valueType: ValueType.INT
+    });
+  }
+
+  // Generally only useful for tests. Note: gauges are ignored here.
+  resetCounters() {
+    this.data_replicated_bytes.add(0);
+    this.data_synced_bytes.add(0);
+    this.rows_replicated_total.add(0);
+    this.transactions_replicated_total.add(0);
+    this.chunks_replicated_total.add(0);
+    this.operations_synced_total.add(0);
+    this.concurrent_connections.add(0);
+  }
+
+  public static getInstance(): Metrics {
+    if (!Metrics.instance) {
+      throw new ServiceAssertionError('Metrics have not been initialized');
+    }
+
+    return Metrics.instance;
+  }
+
+  public static async initialise(options: MetricsOptions): Promise<void> {
+    if (Metrics.instance) {
+      return;
+    }
+    logger.info('Configuring telemetry.');
+
+    logger.info(
+      `
+Attention:
+PowerSync collects completely anonymous telemetry regarding usage.
+This information is used to shape our roadmap to better serve our customers.
+You can learn more, including how to opt-out if you'd not like to participate in this anonymous program, by visiting the following URL:
+https://docs.powersync.com/self-hosting/telemetry
+Anonymous telemetry is currently: ${options.disable_telemetry_sharing ? 'disabled' : 'enabled'}
+    `.trim()
+    );
+
+    const configuredExporters: MetricReader[] = [];
+
+    const port: number = util.env.METRICS_PORT ?? 0;
+    const prometheusExporter = new PrometheusExporter({ port: port, preventServerStart: true });
+    configuredExporters.push(prometheusExporter);
+
+    if (!options.disable_telemetry_sharing) {
+      logger.info('Sharing anonymous telemetry');
+      const periodicExporter = new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter({
+          url: options.internal_metrics_endpoint
+        }),
+        exportIntervalMillis: 1000 * 60 * 5 // 5 minutes
+      });
+
+      configuredExporters.push(periodicExporter);
+    }
+
+    const meterProvider = new MeterProvider({
+      resource: new Resource({
+        ['service']: 'PowerSync',
+        ['instance_id']: options.powersync_instance_id
+      }),
+      readers: configuredExporters
+    });
+
+    if (port > 0) {
+      await prometheusExporter.startServer();
+    }
+
+    Metrics.instance = new Metrics(meterProvider, prometheusExporter);
+
+    logger.info('Telemetry configuration complete.');
+  }
+
+  public async shutdown(): Promise<void> {
+    await this.meterProvider.shutdown();
+  }
+
+  public configureApiMetrics() {
+    // Initialize the metric, so that it reports a value before connections
+    // have been opened.
+    this.concurrent_connections.add(0);
+  }
+
+  public configureReplicationMetrics(bucketStorage: storage.BucketStorageFactory) {
+    // Rate limit collection of these stats, since it may be an expensive query
+    const MINIMUM_INTERVAL = 60_000;
+
+    let cachedRequest: Promise<storage.StorageMetrics | null> | undefined = undefined;
+    let cacheTimestamp = 0;
+
+    function getMetrics() {
+      if (cachedRequest == null || Date.now() - cacheTimestamp > MINIMUM_INTERVAL) {
+        cachedRequest = bucketStorage.getStorageMetrics().catch((e) => {
+          logger.error(`Failed to get storage metrics`, e);
+          return null;
+        });
+        cacheTimestamp = Date.now();
+      }
+      return cachedRequest;
+    }
+
+    this.operation_storage_size_bytes.addCallback(async (result) => {
+      const metrics = await getMetrics();
+      if (metrics) {
+        result.observe(metrics.operations_size_bytes);
+      }
+    });
+
+    this.parameter_storage_size_bytes.addCallback(async (result) => {
+      const metrics = await getMetrics();
+      if (metrics) {
+        result.observe(metrics.parameters_size_bytes);
+      }
+    });
+
+    this.replication_storage_size_bytes.addCallback(async (result) => {
+      const metrics = await getMetrics();
+      if (metrics) {
+        result.observe(metrics.replication_size_bytes);
+      }
+    });
+  }
+
+  public async getMetricValueForTests(name: string): Promise<number | undefined> {
+    const metrics = await this.prometheusExporter.collect();
+    const scoped = metrics.resourceMetrics.scopeMetrics[0].metrics;
+    const metric = scoped.find((metric) => metric.descriptor.name == name);
+    if (metric == null) {
+      throw new Error(
+        `Cannot find metric ${name}. Options: ${scoped.map((metric) => metric.descriptor.name).join(',')}`
+      );
+    }
+    const point = metric.dataPoints[metric.dataPoints.length - 1];
+    return point?.value as number;
+  }
+}

package/src/replication/AbstractReplicationJob.ts

@@ -2,12 +2,10 @@ 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,7 +7,6 @@ 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;
@@ -20,7 +19,6 @@ 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.
@@ -35,7 +33,6 @@ 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.
@@ -75,10 +72,6 @@ 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,14 +64,6 @@ 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>;
 
   /**
@@ -101,8 +93,6 @@ 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,4 +3,3 @@ export * from './AbstractReplicator.js';
 export * from './ErrorRateLimiter.js';
 export * from './ReplicationEngine.js';
 export * from './ReplicationModule.js';
-export * from './replication-metrics.js';

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

@@ -2,19 +2,18 @@ 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, metricsEngine, syncContext } = service_context;
+      const { routerEngine, syncContext } = service_context;
 
       // Create our own controller that we can abort directly
       const controller = new AbortController();
@@ -70,8 +69,8 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
         controller.abort();
       });
 
-      metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(1);
-      const tracker = new sync.RequestTracker(metricsEngine);
+      Metrics.getInstance().concurrent_connections.add(1);
+      const tracker = new sync.RequestTracker();
       try {
         for await (const data of sync.streamResponse({
           syncContext: syncContext,
@@ -148,7 +147,7 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
           operations_synced: tracker.operationsSynced,
           data_synced_bytes: tracker.dataSyncedBytes
         });
-        metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(-1);
+        Metrics.getInstance().concurrent_connections.add(-1);
       }
     }
   });

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

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

package/src/storage/SyncRulesBucketStorage.ts

@@ -253,13 +253,14 @@ export interface GetCheckpointChangesOptions {
 export interface CheckpointChanges {
   updatedDataBuckets: string[];
   invalidateDataBuckets: boolean;
-  updatedParameterBucketDefinitions: string[];
+  /** Serialized using JSONBig */
+  updatedParameterLookups: Set<string>;
   invalidateParameterBuckets: boolean;
 }
 
 export const CHECKPOINT_INVALIDATE_ALL: CheckpointChanges = {
   updatedDataBuckets: [],
   invalidateDataBuckets: true,
-  updatedParameterBucketDefinitions: [],
+  updatedParameterLookups: new Set<string>(),
   invalidateParameterBuckets: true
 };

package/src/storage/bson.ts

@@ -25,22 +25,20 @@ export const BSON_DESERIALIZE_DATA_OPTIONS: bson.DeserializeOptions = {
  * @param lookup
  */
 export const serializeLookupBuffer = (lookup: SqliteJsonValue[]): NodeBuffer => {
-  const normalized = lookup.map((value) => {
-    if (typeof value == 'number' && Number.isInteger(value)) {
-      return BigInt(value);
-    } else {
-      return value;
-    }
-  });
-  return bson.serialize({ l: normalized }) as NodeBuffer;
+  return bson.serialize({ l: lookup }) as NodeBuffer;
 };
 
 export const serializeLookup = (lookup: SqliteJsonValue[]) => {
   return new bson.Binary(serializeLookupBuffer(lookup));
 };
 
-export const getLookupBucketDefinitionName = (lookup: bson.Binary) => {
+export const deserializeParameterLookup = (lookup: bson.Binary) => {
   const parsed = bson.deserialize(lookup.buffer, BSON_DESERIALIZE_INTERNAL_OPTIONS).l as SqliteJsonValue[];
+  return parsed;
+};
+
+export const getLookupBucketDefinitionName = (lookup: bson.Binary) => {
+  const parsed = deserializeParameterLookup(lookup);
   return parsed[0] as string;
 };
 

package/src/storage/storage-index.ts

@@ -6,7 +6,6 @@ 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/sync/BucketChecksumState.ts

@@ -7,6 +7,8 @@ import { ErrorCode, logger, ServiceAssertionError, ServiceError } from '@powersy
 import { BucketParameterQuerier } from '@powersync/service-sync-rules/src/BucketParameterQuerier.js';
 import { BucketSyncState } from './sync.js';
 import { SyncContext } from './SyncContext.js';
+import { JSONBig } from '@powersync/service-jsonbig';
+import { hasIntersection } from './util.js';
 
 export interface BucketChecksumStateOptions {
   syncContext: SyncContext;
@@ -268,6 +270,10 @@ export class BucketParameterState {
   public readonly syncParams: RequestParameters;
   private readonly querier: BucketParameterQuerier;
   private readonly staticBuckets: Map<string, BucketDescription>;
+  private cachedDynamicBuckets: BucketDescription[] | null = null;
+  private cachedDynamicBucketSet: Set<string> | null = null;
+
+  private readonly lookups: Set<string>;
 
   constructor(
     context: SyncContext,
@@ -282,6 +288,7 @@ export class BucketParameterState {
 
     this.querier = syncRules.getBucketParameterQuerier(this.syncParams);
     this.staticBuckets = new Map<string, BucketDescription>(this.querier.staticBuckets.map((b) => [b.bucket, b]));
+    this.lookups = new Set<string>(this.querier.parameterQueryLookups.map((l) => JSONBig.stringify(l)));
   }
 
   async getCheckpointUpdate(checkpoint: storage.StorageCheckpointUpdate): Promise<CheckpointUpdate | null> {
@@ -361,36 +368,61 @@ export class BucketParameterState {
     const staticBuckets = querier.staticBuckets;
     const update = checkpoint.update;
 
-    let hasChange = false;
-    if (update.invalidateDataBuckets || update.updatedDataBuckets?.length > 0) {
-      hasChange = true;
-    } else if (update.invalidateParameterBuckets) {
-      hasChange = true;
+    let hasParameterChange = false;
+    let invalidateDataBuckets = false;
+    // If hasParameterChange == true, then invalidateDataBuckets = true
+    // If invalidateDataBuckets == true, we ignore updatedBuckets
+    let updatedBuckets = new Set<string>();
+
+    if (update.invalidateDataBuckets) {
+      invalidateDataBuckets = true;
+    }
+
+    if (update.invalidateParameterBuckets) {
+      hasParameterChange = true;
     } else {
-      for (let bucket of update.updatedParameterBucketDefinitions ?? []) {
-        if (querier.dynamicBucketDefinitions.has(bucket)) {
-          hasChange = true;
-          break;
-        }
+      if (hasIntersection(this.lookups, update.updatedParameterLookups)) {
+        // This is a very coarse re-check of all queries
+        hasParameterChange = true;
       }
     }
 
-    if (!hasChange) {
-      return null;
-    }
+    let dynamicBuckets: BucketDescription[];
+    if (hasParameterChange || this.cachedDynamicBuckets == null || this.cachedDynamicBucketSet == null) {
+      dynamicBuckets = await querier.queryDynamicBucketDescriptions({
+        getParameterSets(lookups) {
+          return storage.getParameterSets(checkpoint.base.checkpoint, lookups);
+        }
+      });
+      this.cachedDynamicBuckets = dynamicBuckets;
+      this.cachedDynamicBucketSet = new Set<string>(dynamicBuckets.map((b) => b.bucket));
+      invalidateDataBuckets = true;
+    } else {
+      dynamicBuckets = this.cachedDynamicBuckets;
 
-    const dynamicBuckets = await querier.queryDynamicBucketDescriptions({
-      getParameterSets(lookups) {
-        return storage.getParameterSets(checkpoint.base.checkpoint, lookups);
+      if (!invalidateDataBuckets) {
+        // TODO: Do set intersection instead
+        for (let bucket of update.updatedDataBuckets ?? []) {
+          if (this.staticBuckets.has(bucket) || this.cachedDynamicBucketSet.has(bucket)) {
+            updatedBuckets.add(bucket);
+          }
+        }
       }
-    });
+    }
     const allBuckets = [...staticBuckets, ...dynamicBuckets];
 
-    return {
-      buckets: allBuckets,
-      // We cannot track individual bucket updates for dynamic lookups yet
-      updatedBuckets: null
-    };
+    if (invalidateDataBuckets) {
+      return {
+        buckets: allBuckets,
+        // We cannot track individual bucket updates for dynamic lookups yet
+        updatedBuckets: null
+      };
+    } else {
+      return {
+        buckets: allBuckets,
+        updatedBuckets: updatedBuckets
+      };
+    }
   }
 }
 

package/src/sync/RequestTracker.ts

@@ -1,6 +1,4 @@
-import { MetricsEngine } from '../metrics/MetricsEngine.js';
-
-import { APIMetric } from '@powersync/service-types';
+import { Metrics } from '../metrics/Metrics.js';
 
 /**
  * Record sync stats per request stream.
@@ -9,19 +7,15 @@ export class RequestTracker {
   operationsSynced = 0;
   dataSyncedBytes = 0;
 
-  constructor(private metrics: MetricsEngine) {
-    this.metrics = metrics;
-  }
-
   addOperationsSynced(operations: number) {
     this.operationsSynced += operations;
 
-    this.metrics.getCounter(APIMetric.OPERATIONS_SYNCED).add(operations);
+    Metrics.getInstance().operations_synced_total.add(operations);
   }
 
   addDataSynced(bytes: number) {
     this.dataSyncedBytes += bytes;
 
-    this.metrics.getCounter(APIMetric.DATA_SYNCED_BYTES).add(bytes);
+    Metrics.getInstance().data_synced_bytes.add(bytes);
   }
 }

package/src/sync/util.ts

@@ -153,3 +153,15 @@ export function settledPromise<T>(promise: Promise<T>): Promise<PromiseSettledRe
     }
   );
 }
+
+export function hasIntersection<T>(a: Set<T>, b: Set<T>) {
+  if (a.size > b.size) {
+    [a, b] = [b, a];
+  }
+  // Now, a is always smaller than b, so iterate over a
+  for (let value of a) {
+    if (b.has(value)) {
+      return true;
+    }
+  }
+}