@powersync/service-core 1.25.0 → 1.26.0

package/src/storage/implementation/BucketDefinitionMapping.ts

@@ -2,11 +2,14 @@ import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import {
   BucketDataSource,
   BucketDefinitionId,
+  EventDefinitionId,
   HashMap,
   ParameterIndexId,
   ParameterIndexLookupCreator,
   ParameterLookupDefinitionId,
   SerializedBucketDataSourceWithDataSources,
+  serializedEventDefinitionEquality,
+  SerializedEventDescriptor,
   SerializedParameterIndexLookupCreator,
   serializedStreamBucketDataSourceEquality,
   serializedStreamParameterIndexLookupCreatorEquality,
@@ -15,17 +18,22 @@ import {
   SyncConfigWithErrors
 } from '@powersync/service-sync-rules';
 
+/** Minimal shape required to resolve an event's assigned id: its name is the per-config key. */
+export interface NamedEventDefinition {
+  readonly name: string;
+}
+
 export interface SerializedSyncConfigWithMapping {
   plan: SerializedSyncPlan;
   mapping: SingleSyncConfigBucketDefinitionMapping;
 }
 
-export type IncrementalMappingDefinitionType = 'bucket_data' | 'parameter_lookup';
+export type IncrementalMappingDefinitionType = 'bucket_data' | 'parameter_lookup' | 'event';
 
 export interface IncrementalMappingDefinitionChange {
   type: IncrementalMappingDefinitionType;
   name: string;
-  id: BucketDefinitionId | ParameterIndexId;
+  id: BucketDefinitionId | ParameterIndexId | EventDefinitionId;
 }
 
 export interface IncrementalMappingChanges {
@@ -58,6 +66,10 @@ export interface PersistedDefinitionMapping {
    * Map of (lookupName, queryId) -> id, unique per replication stream.
    */
   parameter_indexes: Record<string, string>;
+  /**
+   * Map of event name -> id, unique per replication stream. Absent for mappings persisted before events were tracked.
+   */
+  events?: Record<string, string>;
 }
 
 /**
@@ -80,11 +92,14 @@ export interface BucketDefinitionMapping {
 
   allParameterIndexIds(): ParameterIndexId[];
 
+  allEventDefinitionIds(): EventDefinitionId[];
+
   syncConfigIdsForSourceTable(
     selectedSyncConfigIds: string[],
     table: SourceTableRef,
     bucketDataSourceIds: BucketDefinitionId[],
-    parameterLookupSourceIds: ParameterIndexId[]
+    parameterLookupSourceIds: ParameterIndexId[],
+    eventDefinitionIds: EventDefinitionId[]
   ): string[];
 
   snapshotBlockingSourceTablesFilter(syncConfigId: string): Record<string, unknown>;
@@ -100,7 +115,11 @@ export interface BucketDefinitionMapping {
  */
 export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinitionMapping {
   static fromPersistedMapping(mapping: PersistedDefinitionMapping): SingleSyncConfigBucketDefinitionMapping {
-    return new SingleSyncConfigBucketDefinitionMapping(mapping.definitions ?? {}, mapping.parameter_indexes ?? {});
+    return new SingleSyncConfigBucketDefinitionMapping(
+      mapping.definitions ?? {},
+      mapping.parameter_indexes ?? {},
+      mapping.events ?? {}
+    );
   }
 
   static fromParsedSyncConfig(syncConfig: SyncConfigWithErrors): SingleSyncConfigBucketDefinitionMapping {
@@ -108,9 +127,11 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     const parameterKeys = syncConfig.config.bucketParameterLookupSources
       .map((source) => `${source.sourceId.lookupName}#${source.sourceId.queryId}`)
       .sort();
+    const eventNames = syncConfig.config.eventDefinitions.map((event) => event.name).sort();
 
     const definitions: Record<string, BucketDefinitionId> = {};
     const parameterLookups: Record<string, ParameterIndexId> = {};
+    const events: Record<string, EventDefinitionId> = {};
 
     for (const [index, uniqueName] of definitionNames.entries()) {
       definitions[uniqueName] = (index + 1).toString(16);
@@ -118,8 +139,11 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     for (const [index, key] of parameterKeys.entries()) {
       parameterLookups[key] = (index + 1).toString(16);
     }
+    for (const [index, name] of eventNames.entries()) {
+      events[name] = (index + 1).toString(16);
+    }
 
-    return new SingleSyncConfigBucketDefinitionMapping(definitions, parameterLookups);
+    return new SingleSyncConfigBucketDefinitionMapping(definitions, parameterLookups, events);
   }
 
   /**
@@ -162,9 +186,25 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
       nextParameterIndexId++;
       return id;
     }
+    // Event ids are deliberately allocated per replication stream instead of being hashes or UUIDs derived from a
+    // compiled plan. Compatibility decides whether to reuse an existing id, keeping the storage identifier separate
+    // from event content and allowing the comparison to evolve independently. That comparison must remain
+    // conservative: a false negative only causes a new id and resnapshot, while a false positive could incorrectly
+    // reuse existing event state.
+    let nextEventDefinitionId =
+      reservedMappings
+        .map((mapping) => mapping.allEventDefinitionIds())
+        .flat()
+        .reduce((maxId, id) => Math.max(maxId, parseInt(id, 16)), 0) + 1;
+    function generateNewEventDefinitionId(): EventDefinitionId {
+      const id = nextEventDefinitionId.toString(16);
+      nextEventDefinitionId++;
+      return id;
+    }
 
     const definitions: Record<string, BucketDefinitionId> = {};
     const parameterLookups: Record<string, ParameterIndexId> = {};
+    const events: Record<string, EventDefinitionId> = {};
     const changes: IncrementalMappingChanges = {
       reusedDefinitions: [],
       addedDefinitions: []
@@ -175,6 +215,9 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     const compatibleParameterLookups = new HashMap<SerializedParameterIndexLookupCreator, ParameterIndexId>(
       serializedStreamParameterIndexLookupCreatorEquality
     );
+    const compatibleEvents = new HashMap<SerializedEventDescriptor, EventDefinitionId>(
+      serializedEventDefinitionEquality
+    );
 
     for (const config of compatibleConfigs) {
       for (const bucket of config.plan.buckets) {
@@ -188,6 +231,10 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
           config.mapping.parameterLookupIdByKey(parameterLookupKey(parameterLookup.lookupScope))
         );
       }
+
+      for (const event of config.plan.events ?? []) {
+        compatibleEvents.putIfAbsent(event, () => config.mapping.eventDefinitionIdByName(event.name));
+      }
     }
 
     for (const bucket of newPlan.buckets) {
@@ -223,15 +270,32 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
       }
     }
 
+    for (const event of newPlan.events ?? []) {
+      const compatibleId = compatibleEvents.get(event);
+      const id = compatibleId ?? generateNewEventDefinitionId();
+      events[event.name] = id;
+      const change: IncrementalMappingDefinitionChange = {
+        type: 'event',
+        name: event.name,
+        id
+      };
+      if (compatibleId == null) {
+        changes.addedDefinitions.push(change);
+      } else {
+        changes.reusedDefinitions.push(change);
+      }
+    }
+
     return {
-      mapping: new SingleSyncConfigBucketDefinitionMapping(definitions, parameterLookups),
+      mapping: new SingleSyncConfigBucketDefinitionMapping(definitions, parameterLookups, events),
       changes
     };
   }
 
   constructor(
     private definitions: Record<string, BucketDefinitionId> = {},
-    private parameterLookupMapping: Record<string, ParameterIndexId> = {}
+    private parameterLookupMapping: Record<string, ParameterIndexId> = {},
+    private events: Record<string, EventDefinitionId> = {}
   ) {}
 
   bucketSourceId(source: BucketDataSource): BucketDefinitionId {
@@ -270,8 +334,20 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     }));
   }
 
+  allEventDefinitionIds(): EventDefinitionId[] {
+    return Object.values(this.events);
+  }
+
+  eventDefinitionEntries(): IncrementalMappingDefinitionChange[] {
+    return Object.entries(this.events).map(([name, id]) => ({
+      type: 'event',
+      name,
+      id
+    }));
+  }
+
   allDefinitionEntries(): IncrementalMappingDefinitionChange[] {
-    return [...this.bucketDefinitionEntries(), ...this.parameterIndexEntries()];
+    return [...this.bucketDefinitionEntries(), ...this.parameterIndexEntries(), ...this.eventDefinitionEntries()];
   }
 
   parameterLookupId(source: ParameterIndexLookupCreator): ParameterIndexId {
@@ -286,10 +362,23 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     return defId;
   }
 
+  eventId(event: NamedEventDefinition): EventDefinitionId {
+    return this.eventDefinitionIdByName(event.name);
+  }
+
+  eventDefinitionIdByName(name: string): EventDefinitionId {
+    const id = this.events[name];
+    if (id == null) {
+      throw new ServiceAssertionError(`No mapping found for event definition ${name}`);
+    }
+    return id;
+  }
+
   serialize(): PersistedDefinitionMapping {
     return {
       definitions: { ...this.definitions },
-      parameter_indexes: { ...this.parameterLookupMapping }
+      parameter_indexes: { ...this.parameterLookupMapping },
+      events: { ...this.events }
     };
   }
 
@@ -297,9 +386,12 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     selectedSyncConfigIds: string[],
     _table: SourceTableRef,
     bucketDataSourceIds: BucketDefinitionId[],
-    parameterLookupSourceIds: ParameterIndexId[]
+    parameterLookupSourceIds: ParameterIndexId[],
+    eventDefinitionIds: EventDefinitionId[]
   ): string[] {
-    return bucketDataSourceIds.length > 0 || parameterLookupSourceIds.length > 0 ? selectedSyncConfigIds : [];
+    return bucketDataSourceIds.length > 0 || parameterLookupSourceIds.length > 0 || eventDefinitionIds.length > 0
+      ? selectedSyncConfigIds
+      : [];
   }
 
   snapshotBlockingSourceTablesFilter(_syncConfigId: string): Record<string, unknown> {
@@ -312,6 +404,10 @@ export class SingleSyncConfigBucketDefinitionMapping implements BucketDefinition
     if (parameterLookupSourceIds.length > 0) {
       clauses.push({ parameter_lookup_source_ids: { $in: parameterLookupSourceIds } });
     }
+    const eventDefinitionIds = this.allEventDefinitionIds();
+    if (eventDefinitionIds.length > 0) {
+      clauses.push({ event_definition_ids: { $in: eventDefinitionIds } });
+    }
     if (clauses.length == 0) {
       return {
         snapshot_done: false,
@@ -337,6 +433,7 @@ export class MultiSyncConfigBucketDefinitionMapping implements BucketDefinitionM
   private bucketDataSourceSyncConfigIdsById = new Map<BucketDefinitionId, Set<string>>();
   private parameterLookupMappings = new WeakMap<ParameterIndexLookupCreator, SingleSyncConfigBucketDefinitionMapping>();
   private parameterLookupSyncConfigIdsById = new Map<ParameterIndexId, Set<string>>();
+  private eventDefinitionSyncConfigIdsById = new Map<EventDefinitionId, Set<string>>();
   private syncConfigsById = new Map<string, SyncConfigWithRequiredMapping>();
   private mappings: SingleSyncConfigBucketDefinitionMapping[];
 
@@ -357,6 +454,9 @@ export class MultiSyncConfigBucketDefinitionMapping implements BucketDefinitionM
           config.syncConfigId
         );
       }
+      for (const event of config.syncConfig.config.eventDefinitions) {
+        addSetEntry(this.eventDefinitionSyncConfigIdsById, config.mapping.eventId(event), config.syncConfigId);
+      }
     }
   }
 
@@ -388,11 +488,16 @@ export class MultiSyncConfigBucketDefinitionMapping implements BucketDefinitionM
     return [...new Set(this.mappings.flatMap((mapping) => mapping.allParameterIndexIds()))];
   }
 
+  allEventDefinitionIds(): EventDefinitionId[] {
+    return [...new Set(this.mappings.flatMap((mapping) => mapping.allEventDefinitionIds()))];
+  }
+
   syncConfigIdsForSourceTable(
     _selectedSyncConfigIds: string[],
-    table: SourceTableRef,
+    _table: SourceTableRef,
     bucketDataSourceIds: BucketDefinitionId[],
-    parameterLookupSourceIds: ParameterIndexId[]
+    parameterLookupSourceIds: ParameterIndexId[],
+    eventDefinitionIds: EventDefinitionId[]
   ): string[] {
     const ids = new Set<string>();
     for (const sourceId of bucketDataSourceIds) {
@@ -401,10 +506,8 @@ export class MultiSyncConfigBucketDefinitionMapping implements BucketDefinitionM
     for (const sourceId of parameterLookupSourceIds) {
       addAll(ids, this.parameterLookupSyncConfigIdsById.get(sourceId));
     }
-    for (const [syncConfigId, config] of this.syncConfigsById) {
-      if (config.syncConfig.config.tableTriggersEvent(table)) {
-        ids.add(syncConfigId);
-      }
+    for (const eventDefinitionId of eventDefinitionIds) {
+      addAll(ids, this.eventDefinitionSyncConfigIdsById.get(eventDefinitionId));
     }
     return [...ids];
   }

package/src/storage/implementation/IncrementalReprocessingSyncConfigLog.ts

@@ -1,4 +1,9 @@
-import { BucketDataSource, ParameterIndexLookupCreator, SyncConfigWithErrors } from '@powersync/service-sync-rules';
+import {
+  BucketDataSource,
+  EventDefinition,
+  ParameterIndexLookupCreator,
+  SyncConfigWithErrors
+} from '@powersync/service-sync-rules';
 import {
   IncrementalMappingChanges,
   IncrementalMappingDefinitionChange,
@@ -30,6 +35,8 @@ export function describeIncrementalSyncConfigUpdate(options: {
   mappingChanges: IncrementalMappingChanges;
 }): IncrementalSyncConfigUpdateLog {
   const { activeMappings, newMapping, newSyncConfig, mappingChanges } = options;
+  // Buckets, parameter lookups and events all flow through the mapping's assigned ids, so their changes are
+  // already present in mappingChanges and allDefinitionEntries().
   const newDefinitionKeys = new Set(newMapping.allDefinitionEntries().map(definitionKey));
   const activeDefinitions = uniqueDefinitions(activeMappings.flatMap((mapping) => mapping.allDefinitionEntries()));
 
@@ -57,10 +64,16 @@ function sourceTablesForDefinition(
     );
   }
 
-  return sourceTablesForSources(
-    syncConfig.config.bucketParameterLookupSources.filter(
-      (source) => mapping.parameterLookupId(source) == definition.id
-    )
+  if (definition.type == 'parameter_lookup') {
+    return sourceTablesForSources(
+      syncConfig.config.bucketParameterLookupSources.filter(
+        (source) => mapping.parameterLookupId(source) == definition.id
+      )
+    );
+  }
+
+  return sourceTablesForEvents(
+    syncConfig.config.eventDefinitions.filter((event) => mapping.eventId(event) == definition.id)
   );
 }
 
@@ -68,6 +81,10 @@ function sourceTablesForSources(sources: Array<BucketDataSource | ParameterIndex
   return uniqueSorted(sources.flatMap((source) => [...source.getSourceTables()].map((table) => table.tablePattern)));
 }
 
+function sourceTablesForEvents(events: EventDefinition[]) {
+  return uniqueSorted(events.flatMap((event) => [...event.getSourceTables()].map((table) => table.tablePattern)));
+}
+
 function definitionKey(definition: IncrementalMappingDefinitionChange) {
   return `${definition.type}:${definition.id}`;
 }

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

@@ -39,7 +39,9 @@ export type SyncCheckpointTraceCategory =
   // 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';
+  | 'sending'
+  // Time spent reading concurrent S3 requests, counted once per batch.
+  | 's3';
 
 export interface BucketChecksumStateOptions {
   syncContext: SyncContext;