@powersync/service-core 0.0.0-dev-20260602073133 → 0.0.0-dev-20260909133214

package/src/storage/implementation/ReplicationStreamStorageIds.ts

@@ -0,0 +1,21 @@
+import { BucketDefinitionId, ParameterIndexId } from '@powersync/service-sync-rules';
+import { SingleSyncConfigBucketDefinitionMapping } from './BucketDefinitionMapping.js';
+
+/**
+ * Persisted storage ids for a replication stream, derived from the rule_mapping documents
+ * of all its sync configs.
+ *
+ * This requires no parsed sync configs, and deliberately does not resolve individual
+ * sources - use the parsed-set-bound {@link BucketDefinitionMapping} for that.
+ */
+export class ReplicationStreamStorageIds {
+  constructor(private readonly mappings: SingleSyncConfigBucketDefinitionMapping[]) {}
+
+  get bucketDefinitionIds(): BucketDefinitionId[] {
+    return [...new Set(this.mappings.flatMap((mapping) => mapping.allBucketDefinitionIds()))];
+  }
+
+  get parameterIndexIds(): ParameterIndexId[] {
+    return [...new Set(this.mappings.flatMap((mapping) => mapping.allParameterIndexIds()))];
+  }
+}

package/src/storage/storage-index.ts

@@ -2,16 +2,26 @@ export * from './bson.js';
 export * from './BucketStorage.js';
 export * from './BucketStorageBatch.js';
 export * from './BucketStorageFactory.js';
+export * from './CheckpointChecksumInvalidatedError.js';
 export * from './ChecksumCache.js';
-export * from './PersistedSyncRulesContent.js';
+export * from './ParsedSyncConfigSet.js';
+export * from './PersistedReplicationStream.js';
+export * from './PersistedSyncConfigContent.js';
+export * from './PersistedSyncConfigStatus.js';
 export * from './ReplicationEventPayload.js';
 export * from './ReplicationLock.js';
 export * from './ReportStorage.js';
 export * from './SourceEntity.js';
 export * from './SourceTable.js';
+export * from './SourceTableReconciler.js';
 export * from './storage-metrics.js';
 export * from './StorageEngine.js';
 export * from './StorageProvider.js';
 export * from './StorageVersionConfig.js';
 export * from './SyncRulesBucketStorage.js';
 export * from './WriteCheckpointAPI.js';
+
+export * from './implementation/BucketDefinitionMapping.js';
+export * from './implementation/IncrementalReprocessingCompatibility.js';
+export * from './implementation/IncrementalReprocessingSyncConfigLog.js';
+export * from './implementation/ReplicationStreamStorageIds.js';

package/src/storage/storage-metrics.ts

@@ -1,7 +1,7 @@
 import { logger } from '@powersync/lib-services-framework';
 import { StorageMetric } from '@powersync/service-types';
 import { MetricsEngine } from '../metrics/MetricsEngine.js';
-import { BucketStorageFactory, StorageMetrics } from './BucketStorageFactory.js';
+import { BucketStorageFactory, StorageMetrics, StorageSyncConfigMetrics } from './BucketStorageFactory.js';
 
 export function createCoreStorageMetrics(engine: MetricsEngine): void {
   engine.createObservableGauge({
@@ -9,59 +9,205 @@ export function createCoreStorageMetrics(engine: MetricsEngine): void {
     description: 'Size of current data stored in PowerSync',
     unit: 'bytes'
   });
+  engine.createObservableGauge({
+    name: StorageMetric.ATTRIBUTED_SOURCE_RECORDS_BYTES,
+    description: 'Size of current data stored in PowerSync by sync config',
+    unit: 'bytes'
+  });
 
   engine.createObservableGauge({
     name: StorageMetric.OPERATION_SIZE_BYTES,
     description: 'Size of operations stored in PowerSync',
     unit: 'bytes'
   });
+  engine.createObservableGauge({
+    name: StorageMetric.ATTRIBUTED_BUCKET_DATA_BYTES,
+    description: 'Size of operations stored in PowerSync by sync config',
+    unit: 'bytes'
+  });
 
   engine.createObservableGauge({
     name: StorageMetric.PARAMETER_SIZE_BYTES,
     description: 'Size of parameter data stored in PowerSync',
     unit: 'bytes'
   });
+  engine.createObservableGauge({
+    name: StorageMetric.ATTRIBUTED_PARAMETER_INDEXES_BYTES,
+    description: 'Size of parameter data stored in PowerSync by sync config',
+    unit: 'bytes'
+  });
+
+  engine.createObservableGauge({
+    name: StorageMetric.OBJECT_STORAGE_SIZE_BYTES,
+    description: 'Size of active object-storage references stored in PowerSync',
+    unit: 'bytes'
+  });
+  engine.createObservableGauge({
+    name: StorageMetric.ATTRIBUTED_OBJECT_STORAGE_BYTES,
+    description: 'Size of active object-storage references by sync config',
+    unit: 'bytes'
+  });
 }
 
 export function initializeCoreStorageMetrics(engine: MetricsEngine, storage: BucketStorageFactory): void {
   const replication_storage_size_bytes = engine.getObservableGauge(StorageMetric.REPLICATION_SIZE_BYTES);
+  const attributed_source_records_bytes = engine.getObservableGauge(StorageMetric.ATTRIBUTED_SOURCE_RECORDS_BYTES);
   const operation_storage_size_bytes = engine.getObservableGauge(StorageMetric.OPERATION_SIZE_BYTES);
+  const attributed_bucket_data_bytes = engine.getObservableGauge(StorageMetric.ATTRIBUTED_BUCKET_DATA_BYTES);
   const parameter_storage_size_bytes = engine.getObservableGauge(StorageMetric.PARAMETER_SIZE_BYTES);
+  const attributed_parameter_indexes_bytes = engine.getObservableGauge(
+    StorageMetric.ATTRIBUTED_PARAMETER_INDEXES_BYTES
+  );
+  const object_storage_size_bytes = engine.getObservableGauge(StorageMetric.OBJECT_STORAGE_SIZE_BYTES);
+  const attributed_object_storage_bytes = engine.getObservableGauge(StorageMetric.ATTRIBUTED_OBJECT_STORAGE_BYTES);
 
   const MINIMUM_INTERVAL = 60_000;
 
+  /**
+   * How long a sync config that is no longer present keeps being reported as zero.
+   *
+   * This must comfortably exceed the longest metric export interval, so that every configured
+   * reader observes the zero at least once. The OTLP reader exports every 5 minutes.
+   */
+  const RETIRED_SYNC_CONFIG_INTERVAL = 15 * 60_000;
+
+  type SyncConfigAttributes = {
+    sync_config_id: string;
+    sync_config_state: string;
+    version_label?: string;
+  };
+
+  /**
+   * Attribute sets reported at least once, along with the last time each was present in the
+   * storage metrics.
+   *
+   * These gauges are exported with cumulative temporality, which means the metrics SDK keeps
+   * re-exporting the last reported value for every attribute set it has seen, also after we stop
+   * reporting that set. Without this, a sync config that has since been pruned would keep
+   * reporting its last non-zero size indefinitely, so sums over these gauges would drift upwards
+   * permanently. Reporting zero for a while instead leaves the SDK carrying a zero forward.
+   */
+  const reportedSyncConfigs = new Map<string, { attributes: SyncConfigAttributes; lastSeen: number }>();
+
+  const syncConfigKey = (attributes: SyncConfigAttributes) =>
+    JSON.stringify([attributes.sync_config_id, attributes.sync_config_state, attributes.version_label]);
+
+  const syncConfigAttributes = (syncConfig: StorageSyncConfigMetrics): SyncConfigAttributes => ({
+    sync_config_id: syncConfig.sync_config_id,
+    sync_config_state: syncConfig.sync_config_state,
+    ...(syncConfig.version_label == null ? {} : { version_label: syncConfig.version_label })
+  });
+
+  const trackSyncConfigs = (metrics: StorageMetrics | null) => {
+    if (metrics == null) {
+      // Failed to read the metrics - this says nothing about which sync configs still exist.
+      return;
+    }
+    const now = Date.now();
+    for (const syncConfig of metrics.sync_config_metrics ?? []) {
+      const attributes = syncConfigAttributes(syncConfig);
+      reportedSyncConfigs.set(syncConfigKey(attributes), { attributes, lastSeen: now });
+    }
+    for (const [key, entry] of reportedSyncConfigs) {
+      if (now - entry.lastSeen > RETIRED_SYNC_CONFIG_INTERVAL) {
+        reportedSyncConfigs.delete(key);
+      }
+    }
+  };
+
   let cachedRequest: Promise<StorageMetrics | null> | undefined = undefined;
   let cacheTimestamp = 0;
 
   const getMetrics = () => {
     if (!cachedRequest || Date.now() - cacheTimestamp > MINIMUM_INTERVAL) {
-      cachedRequest = storage.getStorageMetrics().catch((e) => {
-        logger.error(`Failed to get storage metrics`, e);
-        return null;
-      });
+      cachedRequest = storage
+        .getStorageMetrics()
+        .catch((e) => {
+          logger.error(`Failed to get storage metrics`, e);
+          return null;
+        })
+        .then((metrics) => {
+          trackSyncConfigs(metrics);
+          return metrics;
+        });
       cacheTimestamp = Date.now();
     }
     return cachedRequest;
   };
 
+  type StorageSizeMetricKey =
+    | 'attributed_bucket_data_bytes'
+    | 'attributed_parameter_indexes_bytes'
+    | 'attributed_source_records_bytes'
+    | 'attributed_object_storage_bytes';
+
+  function nonNegative(value: number): number;
+  function nonNegative(value: number | undefined): number | undefined;
+  function nonNegative(value: number | undefined) {
+    return value == null ? value : Math.max(0, value);
+  }
+
+  const observationsForSyncConfigs = (metrics: StorageMetrics, key: StorageSizeMetricKey) => {
+    const observations: { value: number; attributes?: Record<string, string> }[] = [];
+    const present = new Set<string>();
+    for (const syncConfig of metrics.sync_config_metrics ?? []) {
+      const attributes = syncConfigAttributes(syncConfig);
+      present.add(syncConfigKey(attributes));
+      observations.push({ value: nonNegative(syncConfig[key]), attributes });
+    }
+    for (const entry of reportedSyncConfigs.values()) {
+      if (!present.has(syncConfigKey(entry.attributes))) {
+        observations.push({ value: 0, attributes: entry.attributes });
+      }
+    }
+    return observations;
+  };
+
   replication_storage_size_bytes.setValueProvider(async () => {
+    const metrics = await getMetrics();
+    return nonNegative(metrics?.replication_size_bytes);
+  });
+
+  attributed_source_records_bytes.setValueProvider(async () => {
     const metrics = await getMetrics();
     if (metrics) {
-      return metrics.replication_size_bytes;
+      return observationsForSyncConfigs(metrics, 'attributed_source_records_bytes');
     }
   });
 
   operation_storage_size_bytes.setValueProvider(async () => {
+    const metrics = await getMetrics();
+    return nonNegative(metrics?.operations_size_bytes);
+  });
+
+  attributed_bucket_data_bytes.setValueProvider(async () => {
     const metrics = await getMetrics();
     if (metrics) {
-      return metrics.operations_size_bytes;
+      return observationsForSyncConfigs(metrics, 'attributed_bucket_data_bytes');
     }
   });
 
   parameter_storage_size_bytes.setValueProvider(async () => {
+    const metrics = await getMetrics();
+    return nonNegative(metrics?.parameters_size_bytes);
+  });
+
+  attributed_parameter_indexes_bytes.setValueProvider(async () => {
+    const metrics = await getMetrics();
+    if (metrics) {
+      return observationsForSyncConfigs(metrics, 'attributed_parameter_indexes_bytes');
+    }
+  });
+
+  object_storage_size_bytes.setValueProvider(async () => {
+    const metrics = await getMetrics();
+    return nonNegative(metrics?.object_storage_size_bytes);
+  });
+
+  attributed_object_storage_bytes.setValueProvider(async () => {
     const metrics = await getMetrics();
     if (metrics) {
-      return metrics.parameters_size_bytes;
+      return observationsForSyncConfigs(metrics, 'attributed_object_storage_bytes');
     }
   });
 }

package/src/sync/BucketChecksumState.ts

@@ -2,6 +2,7 @@ import {
   BucketParameterQuerier,
   BucketPriority,
   BucketSource,
+  BucketSourceType,
   HydratedSyncConfig,
   mergeBuckets,
   QuerierError,
@@ -22,9 +23,26 @@ import {
 } from '@powersync/lib-services-framework';
 import { JwtPayload } from '../auth/JwtPayload.js';
 import { ParameterSetLimitExceededError } from '../storage/storage-index.js';
+import { PerformanceTracer } from '../tracing/PerformanceTracer.js';
 import { SyncContext } from './SyncContext.js';
 import { getIntersection, hasIntersection } from './util.js';
 
+export type SyncCheckpointTraceCategory =
+  // buildNextCheckpointLine, excluding parameter computation and checksum lookups
+  | 'checkpoint'
+  // Parameter lookups
+  | 'parameters'
+  // Checksum calculations
+  | 'checksum'
+  // Waiting for a data lock to become available
+  | 'acquiring_lock'
+  // Data fetches. Holds one data lock for this period.
+  | 'bucket_data'
+  // Sending data to client, may include serialization overhead. Holds one data lock for this period in most cases.
+  | 'sending'
+  // Time spent reading concurrent S3 requests, counted once per batch.
+  | 's3';
+
 export interface BucketChecksumStateOptions {
   syncContext: SyncContext;
   bucketStorage: BucketChecksumStateStorage;
@@ -60,6 +78,12 @@ export class BucketChecksumState {
    */
   private lastChecksums: util.ChecksumMap | null = null;
   private lastWriteCheckpoint: bigint | null = null;
+  /**
+   * The next storage checkpoint diff may be relative to a checksum-invalidated
+   * checkpoint that was never sent to the client. Re-check every bucket once
+   * instead of applying that diff to the last client-visible checksums.
+   */
+  private forceFullChecksumForNextCheckpoint = false;
   /**
    * Once we've sent the first full checkpoint line including all {@link util.Checkpoint.streams} that the user is
    * subscribed to, we keep an index of the stream names to their index in that array.
@@ -101,6 +125,10 @@ export class BucketChecksumState {
     }
   }
 
+  invalidateChecksumBaseline() {
+    this.forceFullChecksumForNextCheckpoint = true;
+  }
+
   /**
    * Build a new checkpoint line for an underlying storage checkpoint update if any buckets have changed.
    *
@@ -112,14 +140,20 @@ export class BucketChecksumState {
    * @param next The updated checkpoint
    * @returns A {@link CheckpointLine} if any of the buckets watched by this connected was updated, or otherwise `null`.
    */
-  async buildNextCheckpointLine(next: storage.StorageCheckpointUpdate): Promise<CheckpointLine | null> {
+  async buildNextCheckpointLine(
+    next: storage.StorageCheckpointUpdate,
+    tracer?: PerformanceTracer<SyncCheckpointTraceCategory>
+  ): Promise<CheckpointLine | null> {
+    tracer ??= new PerformanceTracer<SyncCheckpointTraceCategory>(`sync checkpoint ${next.base.checkpoint}`);
+
     const { writeCheckpoint, base } = next;
     const userIdForLogs = this.parameterState.syncParams.userId;
 
     const storage = this.bucketStorage;
 
-    const update = await this.parameterState.getCheckpointUpdate(next);
+    const update = await this.parameterState.getCheckpointUpdate(next, tracer);
     const { buckets: allBuckets, updatedBuckets, usedParameterResults } = update;
+    const forceFullChecksum = this.forceFullChecksumForNextCheckpoint;
 
     /** Set of all buckets in this checkpoint. */
     const bucketDescriptionMap = new Map(allBuckets.map((b) => [b.bucket, b]));
@@ -144,8 +178,9 @@ export class BucketChecksumState {
         const count = bucketsByDefinition.get(definition) ?? 0;
         bucketsByDefinition.set(definition, count + 1);
       }
-
-      const breakdown = formatBucketDefinitionBreakdown(bucketsByDefinition);
+      // Only 1 type is allowed per sync config
+      const bucketSourceType = this.parameterState.syncRules.bucketSourceDefinitions[0].type;
+      const breakdown = formatBucketDefinitionBreakdown(bucketsByDefinition, bucketSourceType);
       errorMessage += breakdown.message;
       logData.buckets_by_definition = breakdown.countsByDefinition;
 
@@ -154,13 +189,14 @@ export class BucketChecksumState {
     }
 
     let checksumMap: util.ChecksumMap;
-    if (updatedBuckets != INVALIDATE_ALL_BUCKETS) {
+    if (!forceFullChecksum && updatedBuckets != INVALIDATE_ALL_BUCKETS) {
       if (this.lastChecksums == null) {
         throw new ServiceAssertionError(`Bucket diff received without existing checksums`);
       }
 
       // Re-check updated buckets only
       let checksumLookups: storage.BucketChecksumRequest[] = [];
+      let hasNewBucket = false;
 
       let newChecksums = new Map<string, util.BucketChecksum>();
       for (let desc of bucketDescriptionMap.values()) {
@@ -174,11 +210,17 @@ export class BucketChecksumState {
           newChecksums.set(desc.bucket, existing);
         } else {
           checksumLookups.push({ bucket: desc.bucket, source: desc.source });
+          hasNewBucket ||= !this.lastChecksums.has(desc.bucket);
         }
       }
 
       if (checksumLookups.length > 0) {
-        let updatedChecksums = await storage.getChecksums(base.checkpoint, checksumLookups);
+        const requestHint: storage.BucketRequestHint = hasNewBucket ? 'bulk' : 'incremental';
+        let updatedChecksums: util.ChecksumMap;
+
+        using _ = tracer.span('checksum');
+        updatedChecksums = await storage.getChecksums(base, checksumLookups, { requestHint });
+
         for (let [bucket, value] of updatedChecksums.entries()) {
           newChecksums.set(bucket, value);
         }
@@ -186,12 +228,23 @@ export class BucketChecksumState {
       checksumMap = newChecksums;
     } else {
       // Re-check all buckets
-      const bucketList = [...bucketDescriptionMap.values()].map((b) => ({ bucket: b.bucket, source: b.source }));
-      checksumMap = await storage.getChecksums(base.checkpoint, bucketList);
+      const hasNewBucket =
+        this.lastChecksums == null ||
+        [...bucketDescriptionMap.values()].some((b) => !this.lastChecksums!.has(b.bucket));
+      const requestHint: storage.BucketRequestHint = hasNewBucket ? 'bulk' : 'incremental';
+      const bucketList = [...bucketDescriptionMap.values()].map((b) => ({
+        bucket: b.bucket,
+        source: b.source
+      }));
+
+      using _ = tracer.span('checksum');
+      checksumMap = await storage.getChecksums(base, bucketList, { requestHint });
     }
 
     // Subset of buckets for which there may be new data in this batch.
     let bucketsToFetch: ResolvedBucket[];
+    let bucketDataRequestHint: storage.BucketRequestHint;
+    const newBucketDownloads = new Set<string>();
 
     let checkpointLine: util.StreamingSyncCheckpointDiff | util.StreamingSyncCheckpoint;
 
@@ -210,6 +263,9 @@ export class BucketChecksumState {
         diff.updatedBuckets.length == 0
       ) {
         // No changes - don't send anything to the client
+        if (forceFullChecksum) {
+          this.forceFullChecksumForNextCheckpoint = false;
+        }
         return null;
       }
 
@@ -232,6 +288,12 @@ export class BucketChecksumState {
       bucketsToFetch = [...generateBucketsToFetch].map((b) => {
         return bucketDescriptionMap.get(b)!;
       });
+      for (const bucket of diff.updatedBuckets) {
+        if (!this.lastChecksums!.has(bucket.bucket)) {
+          newBucketDownloads.add(bucket.bucket);
+        }
+      }
+      bucketDataRequestHint = newBucketDownloads.size > 0 ? 'bulk' : 'incremental';
 
       deferredLog = () => {
         let message = `Updated checkpoint: ${base.checkpoint} | `;
@@ -280,6 +342,10 @@ export class BucketChecksumState {
         );
       };
       bucketsToFetch = allBuckets;
+      for (const bucket of bucketsToFetch) {
+        newBucketDownloads.add(bucket.bucket);
+      }
+      bucketDataRequestHint = 'bulk';
 
       const subscriptions: util.StreamDescription[] = [];
       const streamNameToIndex = new Map<string, number>();
@@ -321,6 +387,7 @@ export class BucketChecksumState {
     return {
       checkpointLine,
       bucketsToFetch,
+      bucketDataRequestHint,
       advance: () => {
         hasAdvanced = true;
         // bucketDataPositions must be updated in-place - it represents the current state of
@@ -353,6 +420,9 @@ export class BucketChecksumState {
         this.lastChecksums = checksumMap;
         this.lastWriteCheckpoint = writeCheckpoint;
         this.pendingBucketDownloads = pendingBucketDownloads;
+        if (forceFullChecksum) {
+          this.forceFullChecksumForNextCheckpoint = false;
+        }
         deferredLog();
       },
 
@@ -512,12 +582,15 @@ export class BucketParameterState {
     return (desc.subscribedToByDefault && this.includeDefaultStreams) || this.subscribedStreamNames.has(desc.name);
   }
 
-  async getCheckpointUpdate(checkpoint: storage.StorageCheckpointUpdate): Promise<CheckpointUpdate> {
+  async getCheckpointUpdate(
+    checkpoint: storage.StorageCheckpointUpdate,
+    tracer: PerformanceTracer<SyncCheckpointTraceCategory>
+  ): Promise<CheckpointUpdate> {
     const querier = this.querier;
     let update: CheckpointUpdate;
     if (querier.hasDynamicBuckets) {
       try {
-        update = await this.getCheckpointUpdateDynamic(checkpoint);
+        update = await this.getCheckpointUpdateDynamic(checkpoint, tracer);
       } catch (e: unknown) {
         if (e instanceof ParameterSetLimitExceededError) {
           // Too many parameter results, create a breakdown of which streams are responsible for the most queries and
@@ -580,7 +653,10 @@ export class BucketParameterState {
   /**
    * For dynamic buckets, we need to re-query the list of buckets every time.
    */
-  private async getCheckpointUpdateDynamic(checkpoint: storage.StorageCheckpointUpdate): Promise<CheckpointUpdate> {
+  private async getCheckpointUpdateDynamic(
+    checkpoint: storage.StorageCheckpointUpdate,
+    tracer: PerformanceTracer<SyncCheckpointTraceCategory>
+  ): Promise<CheckpointUpdate> {
     const querier = this.querier;
     const staticBuckets = this.staticBuckets.values();
     const update = checkpoint.update;
@@ -636,6 +712,7 @@ export class BucketParameterState {
           }
 
           try {
+            using _ = tracer.span('parameters', definition);
             const results = await checkpoint.base.getParameterSets(lookups, remainingBudget);
             const numRows = results.reduce((a, b) => a + b.rows.length, 0);
 
@@ -692,6 +769,7 @@ export class BucketParameterState {
 export interface CheckpointLine {
   checkpointLine: util.StreamingSyncCheckpointDiff | util.StreamingSyncCheckpoint;
   bucketsToFetch: ResolvedBucket[];
+  bucketDataRequestHint: storage.BucketRequestHint;
 
   /**
    * Call when a checkpoint line is being sent to a client, to update the internal state.
@@ -738,30 +816,36 @@ function logCheckpoint(
 }
 
 /**
- * Format a breakdown of dynamic bucket by sync stream definition.
+ * Format a breakdown of dynamic buckets by sync stream or legacy bucket definition.
  *
- * Sorts definitions by count (descending), includes the top 10, and returns both the
+ * Sorts definitions by count (descending), includes the top 100, and returns both the
  * formatted message string and the counts record suitable for structured log data.
  */
-function formatBucketDefinitionBreakdown(bucketsByDefinition: Map<string, number>): {
+function formatBucketDefinitionBreakdown(
+  bucketsByDefinition: Map<string, number>,
+  bucketSourceType: BucketSourceType
+): {
   message: string;
   countsByDefinition: Record<string, number>;
 } {
-  // Sort definitions by count (descending) and take top 10
+  const maxLoggedDefinitions = 100;
+
+  // Sort definitions by count (descending) and take the largest entries.
   const allSorted = Array.from(bucketsByDefinition.entries()).sort((a, b) => b[1] - a[1]);
-  const sortedDefinitions = allSorted.slice(0, 10);
+  const sortedDefinitions = allSorted.slice(0, maxLoggedDefinitions);
 
-  let message = '\Buckets by definition:';
+  const sourceLabel = bucketSourceType == BucketSourceType.SYNC_STREAM ? 'sync stream' : 'bucket definition';
+  let message = `\nBuckets by ${sourceLabel}:`;
   const countsByDefinition: Record<string, number> = {};
   for (const [definition, count] of sortedDefinitions) {
     message += `\n  ${definition}: ${count}`;
     countsByDefinition[definition] = count;
   }
 
-  if (allSorted.length > 10) {
-    const remainingResults = allSorted.slice(10).reduce((sum, [, count]) => sum + count, 0);
-    const remainingDefinitions = allSorted.length - 10;
-    message += `\n  ... and ${remainingResults} more results from ${remainingDefinitions} definitions`;
+  if (allSorted.length > maxLoggedDefinitions) {
+    const remainingResults = allSorted.slice(maxLoggedDefinitions).reduce((sum, [, count]) => sum + count, 0);
+    const remainingDefinitions = allSorted.length - maxLoggedDefinitions;
+    message += `\n  ... and ${remainingResults} more buckets from ${remainingDefinitions} ${sourceLabel}s`;
   }
 
   return { message, countsByDefinition };

package/src/sync/RequestTracker.ts

@@ -15,6 +15,8 @@ export class RequestTracker {
   largeBuckets: Record<string, number> = {};
 
   private encoding: string | undefined = undefined;
+  private lastCheckpointLogOperationsSynced = 0;
+  private lastCheckpointLogDataSyncedBytes = 0;
 
   constructor(private metrics: MetricsEngine) {
     this.metrics = metrics;
@@ -68,6 +70,19 @@ export class RequestTracker {
       encoding: this.encoding
     };
   }
+
+  getIncrementalCheckpointStats(): CheckpointLogStats {
+    const operationsSynced = this.operationsSynced - this.lastCheckpointLogOperationsSynced;
+    const dataSyncedBytes = this.dataSyncedBytes - this.lastCheckpointLogDataSyncedBytes;
+
+    this.lastCheckpointLogOperationsSynced = this.operationsSynced;
+    this.lastCheckpointLogDataSyncedBytes = this.dataSyncedBytes;
+
+    return {
+      operations_synced: operationsSynced,
+      data_synced_bytes: dataSyncedBytes
+    };
+  }
 }
 
 export interface OperationCounts {
@@ -83,6 +98,11 @@ export interface OperationsSentStats {
   total: number;
 }
 
+export interface CheckpointLogStats {
+  operations_synced: number;
+  data_synced_bytes: number;
+}
+
 export function statsForBatch(batch: SyncBucketData): OperationsSentStats {
   let put = 0;
   let remove = 0;