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

package/src/util/config/compound-config-collector.ts

@@ -1,4 +1,5 @@
 import { logger, LookupOptions } from '@powersync/lib-services-framework';
+import { validateStorageVersion } from '@powersync/service-sync-rules';
 import { configFile } from '@powersync/service-types';
 import * as auth from '../../auth/auth-index.js';
 import { ConfigCollector } from './collectors/config-collector.js';
@@ -6,6 +7,8 @@ import { Base64ConfigCollector } from './collectors/impl/base64-config-collector
 import { FallbackConfigCollector } from './collectors/impl/fallback-config-collector.js';
 import { FileSystemConfigCollector } from './collectors/impl/filesystem-config-collector.js';
 import {
+  DEFAULT_CHECKPOINT_REQUEST_RETENTION_MINUTES,
+  DEFAULT_CHECKSUM_CACHE_TTL_MINUTES,
   DEFAULT_MAX_BUCKETS_PER_CONNECTION,
   DEFAULT_MAX_CONCURRENT_CONNECTIONS,
   DEFAULT_MAX_DATA_FETCH_CONCURRENCY,
@@ -60,6 +63,11 @@ export class CompoundConfigCollector {
   async collectConfig(runnerConfig: RunnerConfig = {}): Promise<ResolvedPowerSyncConfig> {
     const baseConfig = await this.collectBaseConfig(runnerConfig);
 
+    const defaultStorageVersion = baseConfig.storage?.default_storage_version;
+    if (defaultStorageVersion != null && validateStorageVersion(defaultStorageVersion) == null) {
+      throw new Error(`Storage version ${defaultStorageVersion} is not supported`);
+    }
+
     const dataSources = baseConfig.replication?.connections ?? [];
     if (dataSources.length > 1) {
       throw new Error('Only a single replication data source is supported currently');
@@ -193,7 +201,13 @@ export class CompoundConfigCollector {
         max_concurrent_connections:
           baseConfig.api?.parameters?.max_concurrent_connections ?? DEFAULT_MAX_CONCURRENT_CONNECTIONS,
         max_data_fetch_concurrency:
-          baseConfig.api?.parameters?.max_data_fetch_concurrency ?? DEFAULT_MAX_DATA_FETCH_CONCURRENCY
+          baseConfig.api?.parameters?.max_data_fetch_concurrency ?? DEFAULT_MAX_DATA_FETCH_CONCURRENCY,
+        checkpoint_request_retention_minutes: normalizeCheckpointRequestRetentionMinutes(
+          baseConfig.api?.parameters?.checkpoint_request_retention_minutes
+        ),
+        bucket_count_cache_ttl_minutes: normalizeChecksumCacheTtlMinutes(
+          baseConfig.api?.parameters?.bucket_count_cache_ttl_minutes
+        )
       },
       // TODO maybe move this out of the connection or something
       slot_name_prefix: baseConfig.replication?.connections?.[0]?.slot_name_prefix ?? 'powersync_',
@@ -249,3 +263,19 @@ export class CompoundConfigCollector {
     };
   }
 }
+
+function normalizeChecksumCacheTtlMinutes(ttlMinutes: number | undefined): number {
+  const normalized = ttlMinutes ?? DEFAULT_CHECKSUM_CACHE_TTL_MINUTES;
+  if (!Number.isFinite(normalized) || !Number.isInteger(normalized) || normalized < 1) {
+    throw new Error('api.parameters.bucket_count_cache_ttl_minutes must be a positive integer');
+  }
+  return normalized;
+}
+
+function normalizeCheckpointRequestRetentionMinutes(retentionMinutes: number | undefined): number {
+  const normalized = retentionMinutes ?? DEFAULT_CHECKPOINT_REQUEST_RETENTION_MINUTES;
+  if (!Number.isFinite(normalized) || !Number.isInteger(normalized) || normalized < 1) {
+    throw new Error('api.parameters.checkpoint_request_retention_minutes must be a positive integer');
+  }
+  return normalized;
+}

package/src/util/config/defaults.ts

@@ -3,3 +3,5 @@ export const DEFAULT_MAX_CONCURRENT_CONNECTIONS = 200;
 export const DEFAULT_MAX_DATA_FETCH_CONCURRENCY = 10;
 export const DEFAULT_MAX_BUCKETS_PER_CONNECTION = 1000;
 export const DEFAULT_MAX_PARAMETER_QUERY_RESULTS = 1000;
+export const DEFAULT_CHECKPOINT_REQUEST_RETENTION_MINUTES = 60;
+export const DEFAULT_CHECKSUM_CACHE_TTL_MINUTES = 1 * 60;

package/src/util/config/sync-rules/impl/base64-sync-rules-collector.ts

@@ -15,6 +15,7 @@ export class Base64SyncRulesCollector extends SyncRulesCollector {
 
     return {
       present: true,
+      version_label: baseConfig.sync_config?.version_label,
       exit_on_error: baseConfig.sync_config?.exit_on_error ?? true,
       content: Buffer.from(sync_config_base64, 'base64').toString()
     };

package/src/util/config/sync-rules/impl/filesystem-sync-rules-collector.ts

@@ -20,6 +20,7 @@ export class FileSystemSyncRulesCollector extends SyncRulesCollector {
     // Only persist the path here, and load on demand using `loadSyncRules()`.
     return {
       present: true,
+      version_label: baseConfig.sync_config?.version_label,
       exit_on_error: baseConfig.sync_config?.exit_on_error ?? true,
       path: config_path ? path.resolve(path.dirname(config_path), sync_path) : sync_path
     };

package/src/util/config/sync-rules/sync-rules-provider.ts

@@ -5,6 +5,7 @@ export interface SyncRulesProvider {
   get(): Promise<string | undefined>;
 
   readonly exitOnError: boolean;
+  readonly versionLabel: string | undefined;
 }
 
 export class ConfigurationFileSyncRulesProvider implements SyncRulesProvider {
@@ -21,4 +22,8 @@ export class ConfigurationFileSyncRulesProvider implements SyncRulesProvider {
   get exitOnError() {
     return this.config.exit_on_error;
   }
+
+  get versionLabel() {
+    return this.config.version_label;
+  }
 }

package/src/util/config/types.ts

@@ -22,6 +22,7 @@ export type Runner = (config: RunnerConfig) => Promise<void>;
 
 export type SyncRulesConfig = {
   present: boolean;
+  version_label?: string;
   content?: string;
   path?: string;
   exit_on_error: boolean;
@@ -53,9 +54,11 @@ export type ResolvedPowerSyncConfig = {
     max_data_fetch_concurrency: number;
     max_buckets_per_connection: number;
     max_parameter_query_results: number;
+    checkpoint_request_retention_minutes: number;
+    bucket_count_cache_ttl_minutes: number;
   };
 
-  /** Prefix for postgres replication slot names. May eventually be connection-specific. */
+  /** Prefix for postgres replication slot names, as well as replication stream names. */
   slot_name_prefix: string;
 
   healthcheck: {

package/src/util/lsn.ts

@@ -6,3 +6,12 @@ export function maxLsn(a: string | null | undefined, b: string | null | undefine
   if (b == null) return a;
   return a > b ? a : b;
 }
+
+/**
+ * Return the smaller of two LSNs, ignoring nulls.
+ */
+export function minLsn(a: string | null | undefined, b: string | null | undefined): string | null {
+  if (a == null) return b ?? null;
+  if (b == null) return a;
+  return a < b ? a : b;
+}

package/src/util/protocol-types.ts

@@ -1,5 +1,6 @@
 import { JsonContainer } from '@powersync/service-jsonbig';
 import { BucketPriority, SqliteJsonRow } from '@powersync/service-sync-rules';
+import { orNull } from '@powersync/service-types';
 import * as t from 'ts-codec';
 
 export const BucketRequest = t.object({
@@ -24,14 +25,14 @@ export const RequestedStreamSubscription = t.object({
   /**
    * An optional dictionary of parameters to pass to this specific stream.
    */
-  parameters: t.union(t.record(t.any), t.Null),
+  parameters: orNull(t.record(t.any)),
   /**
    * Set when the client wishes to re-assign a different priority to this stream.
    *
    * Streams and sync rules can also assign a default priority, but clients are allowed to override those. This can be
    * useful when the priority for partial syncs depends on e.g. the current page opened in a client.
    */
-  override_priority: t.union(t.number, t.Null)
+  override_priority: orNull(t.number)
 });
 
 export type RequestedStreamSubscription = t.Decoded<typeof RequestedStreamSubscription>;

package/src/util/util-index.ts

@@ -8,6 +8,7 @@ export * from './protocol-types.js';
 export * from './secs.js';
 export * from './utils.js';
 export * from './version.js';
+export * from './write-checkpoint-batcher.js';
 
 export * from './config.js';
 export * from './config/compound-config-collector.js';

package/src/util/utils.ts

@@ -33,7 +33,7 @@ export interface PartialChecksum {
  */
 export type InternalOpId = bigint;
 
-export const ID_NAMESPACE = 'a396dd91-09fc-4017-a28d-3df722f651e9';
+export const ID_NAMESPACE = uuid.parse('a396dd91-09fc-4017-a28d-3df722f651e9');
 
 export function escapeIdentifier(identifier: string) {
   return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
@@ -223,7 +223,7 @@ export function isCompleteRow<V>(
  * All other operations are replaced with a single CLEAR operation,
  * summing their checksums, and using a 0 as an op_id.
  *
- * This is the function $r(B)$, as described in /docs/bucket-properties.md.
+ * This is the function $r(B)$, as described in /docs/storage/bucket-properties.md.
  *
  * Used for tests.
  */
@@ -309,3 +309,17 @@ export function estimateRowSize(record: sync_rules.ToastableSqliteRow | undefine
   }
   return size;
 }
+
+export function formatBytes(bytes: number | bigint): string {
+  if (typeof bytes == 'bigint') {
+    bytes = Number(bytes); // We round either way
+  }
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+  } else if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  } else if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  }
+  return `${bytes}B`;
+}

package/src/util/write-checkpoint-batcher.ts

@@ -0,0 +1,142 @@
+import { ErrorCode, ServiceAssertionError, ServiceError } from '@powersync/lib-services-framework';
+import { RouteAPI } from '../api/RouteAPI.js';
+import {
+  BucketStorageFactory,
+  CreateManagedWriteCheckpointsResult,
+  ManagedWriteCheckpointOptions,
+  SyncRulesBucketStorage
+} from '../storage/storage-index.js';
+
+// Keep up to three source-head/storage batches executing concurrently under load.
+// There is intentionally no explicit batch-size cap here: the HTTP request queue
+// already bounds how many requests can be waiting in this process.
+// Smaller values here have better efficiency, while larger numbers here may give slight improvements in latency.
+// We want to limit the number of database connections in use for write checkpoints, so we keep the numbers low here.
+const MAX_IN_FLIGHT_WRITE_CHECKPOINT_BATCHES = 3;
+
+export interface CreateWriteCheckpointResult {
+  writeCheckpoint: string;
+  replicationHead: string;
+}
+
+interface QueuedWriteCheckpoint {
+  userId: string;
+  checkpointRequestId: bigint | undefined;
+  resolvers: PromiseWithResolvers<CreateWriteCheckpointResult>;
+}
+
+export class WriteCheckpointBatcher {
+  private pending: QueuedWriteCheckpoint[] = [];
+  private inFlight = 0;
+  private scheduledPump: NodeJS.Timeout | undefined;
+
+  constructor(
+    private readonly getAPI: () => RouteAPI,
+    private readonly getStorage: () => BucketStorageFactory
+  ) {}
+
+  enqueue(userId: string, checkpointRequestId?: bigint): Promise<CreateWriteCheckpointResult> {
+    const resolvers = Promise.withResolvers<CreateWriteCheckpointResult>();
+    this.pending.push({ userId, checkpointRequestId, resolvers });
+    this.schedulePump();
+    return resolvers.promise;
+  }
+
+  private schedulePump() {
+    if (this.scheduledPump != null) {
+      return;
+    }
+
+    // Delay dispatch by one timer turn so requests arriving together can share
+    // one source head and one storage write batch.
+    // While normally we wouldn't have http requests arriving at the exact same time, this is relevant when
+    // requests are queued by fastify: All current requests are typically batched together, and finish at the
+    // same time. Then we get many requests from the queue arriving at the same time. Without this delayed dispatch,
+    // the first request would form its own batch, and the rest will then wait for a new batch to become available.
+    // The delayed dispatch allow all those requests to be batched together.
+    this.scheduledPump = setTimeout(() => {
+      this.scheduledPump = undefined;
+      this.pump();
+    }, 0);
+  }
+
+  private pump() {
+    while (this.inFlight < MAX_IN_FLIGHT_WRITE_CHECKPOINT_BATCHES && this.pending.length > 0) {
+      const batch = this.pending;
+      this.pending = [];
+      this.inFlight++;
+
+      void this.executeBatch(batch).finally(() => {
+        this.inFlight--;
+        this.schedulePump();
+      });
+    }
+  }
+
+  private async executeBatch(batch: QueuedWriteCheckpoint[]) {
+    try {
+      const syncBucketStorage = (await this.getStorage().getActiveSyncConfig())?.storage;
+      if (!syncBucketStorage) {
+        throw new ServiceError(ErrorCode.PSYNC_S2302, `Cannot create Write Checkpoint since no sync config is active.`);
+      }
+
+      // The source adapter reads the head, hands it to this callback to persist the
+      // write-checkpoint mapping, then forces a source marker only when storage
+      // reports an advance. Keeping the marker inside the callback means it is
+      // causally ordered after the head within a single source session.
+      const { writeCheckpoints, currentCheckpoint } = await this.getAPI().createReplicationHead(
+        async (currentCheckpoint) => {
+          const { writeCheckpoints, shouldAdvance } = await this.createBatchWriteCheckpoints(
+            syncBucketStorage,
+            batch,
+            currentCheckpoint
+          );
+          return { response: { writeCheckpoints, currentCheckpoint }, shouldAdvance };
+        }
+      );
+
+      const results = batch.map((request) => {
+        const writeCheckpoint = writeCheckpoints.get(request.userId);
+        if (writeCheckpoint == null) {
+          throw new ServiceAssertionError(
+            `Write checkpoint storage did not return a checkpoint for user ${request.userId}`
+          );
+        }
+
+        return { request, writeCheckpoint };
+      });
+
+      for (const { request, writeCheckpoint } of results) {
+        request.resolvers.resolve({
+          writeCheckpoint: String(writeCheckpoint),
+          replicationHead: currentCheckpoint
+        });
+      }
+    } catch (error) {
+      // Do not retry here. The route should pass failures through so clients can
+      // apply their normal write-checkpoint retry policy.
+      for (const request of batch) {
+        request.resolvers.reject(error);
+      }
+    }
+  }
+
+  private async createBatchWriteCheckpoints(
+    syncBucketStorage: SyncRulesBucketStorage,
+    batch: QueuedWriteCheckpoint[],
+    currentCheckpoint: string
+  ): Promise<CreateManagedWriteCheckpointsResult> {
+    return syncBucketStorage.createManagedWriteCheckpoints(
+      batch.map((request) => {
+        const checkpoint: ManagedWriteCheckpointOptions = {
+          user_id: request.userId,
+          heads: { '1': currentCheckpoint }
+        };
+        if (request.checkpointRequestId != null) {
+          checkpoint.checkpoint_request_id = request.checkpointRequestId;
+        }
+        return checkpoint;
+      })
+    );
+  }
+}

package/test/src/AbstractReplicator.test.ts

@@ -0,0 +1,177 @@
+import { AbstractReplicationJob } from '@/replication/AbstractReplicationJob.js';
+import { AbstractReplicator, AbstractReplicatorOptions, CreateJobOptions } from '@/replication/AbstractReplicator.js';
+import { PersistedReplicationStream } from '@/storage/PersistedReplicationStream.js';
+import { SyncRulesBucketStorage } from '@/storage/SyncRulesBucketStorage.js';
+import { describe, expect, it, vi } from 'vitest';
+
+class TestReplicator extends AbstractReplicator {
+  constructor(
+    private readonly cleanup: (storage: SyncRulesBucketStorage) => Promise<void>,
+    options: AbstractReplicatorOptions = {
+      id: 'test',
+      storageEngine: {} as AbstractReplicatorOptions['storageEngine'],
+      metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+      syncRuleProvider: {} as AbstractReplicatorOptions['syncRuleProvider'],
+      rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+    }
+  ) {
+    super(options);
+  }
+
+  createJob(_options: CreateJobOptions): AbstractReplicationJob {
+    throw new Error('Not implemented');
+  }
+
+  cleanUp(storage: SyncRulesBucketStorage): Promise<void> {
+    return this.cleanup(storage);
+  }
+
+  async testConnection() {
+    return { connectionDescription: 'test' };
+  }
+
+  terminateStoppedStream(
+    replicationStream: PersistedReplicationStream,
+    syncRuleStorage: SyncRulesBucketStorage
+  ): Promise<void> {
+    return this.terminateStoppedReplicationStream(replicationStream, syncRuleStorage);
+  }
+
+  addClearingJob(replicationStreamId: number, promise: Promise<void>): void {
+    this.clearingJobs.set(replicationStreamId, promise);
+  }
+
+  get heartbeatIntervalNanosForTest(): bigint | null {
+    return (this as any).heartbeatIntervalNanos;
+  }
+
+  shouldHandleStreamForTest(
+    replicationStream: PersistedReplicationStream,
+    loadedSyncRules: string | undefined,
+    loadedVersionLabel: string | undefined
+  ): boolean {
+    return (this as any).shouldHandleReplicationStream(replicationStream, loadedSyncRules, loadedVersionLabel);
+  }
+}
+
+describe('AbstractReplicator heartbeat interval', () => {
+  const options: AbstractReplicatorOptions = {
+    id: 'test',
+    storageEngine: {} as AbstractReplicatorOptions['storageEngine'],
+    metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+    syncRuleProvider: {} as AbstractReplicatorOptions['syncRuleProvider'],
+    rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+  };
+
+  it.each([undefined, null])('uses the default for %s', (heartbeatIntervalSeconds) => {
+    const replicator = new TestReplicator(async () => {}, { ...options, heartbeatIntervalSeconds });
+
+    expect(replicator.heartbeatIntervalNanosForTest).toBe(60_000_000_000n);
+  });
+
+  it('disables the heartbeat interval with 0', () => {
+    const replicator = new TestReplicator(async () => {}, { ...options, heartbeatIntervalSeconds: 0 });
+
+    expect(replicator.heartbeatIntervalNanosForTest).toBeNull();
+  });
+
+  it('converts a positive heartbeat interval to nanoseconds', () => {
+    const replicator = new TestReplicator(async () => {}, { ...options, heartbeatIntervalSeconds: 5 });
+
+    expect(replicator.heartbeatIntervalNanosForTest).toBe(5_000_000_000n);
+  });
+});
+
+describe('AbstractReplicator stopped stream cleanup', () => {
+  it('holds the replication stream lock across source and storage cleanup', async () => {
+    const calls: string[] = [];
+    const release = vi.fn(async () => {
+      calls.push('release');
+    });
+    const replicationStream = {
+      async lock() {
+        calls.push('lock');
+        return { sync_rules_id: 1, release };
+      }
+    } as unknown as PersistedReplicationStream;
+    const syncRuleStorage = {
+      logger: { info: vi.fn() },
+      async terminate() {
+        calls.push('terminate');
+      }
+    } as unknown as SyncRulesBucketStorage;
+    const replicator = new TestReplicator(async () => {
+      calls.push('cleanup');
+    });
+
+    await replicator.terminateStoppedStream(replicationStream, syncRuleStorage);
+
+    expect(calls).toEqual(['lock', 'cleanup', 'terminate', 'release']);
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it('releases the replication stream lock when cleanup fails', async () => {
+    const cleanupError = new Error('cleanup failed');
+    const release = vi.fn(async () => {});
+    const replicationStream = {
+      async lock() {
+        return { sync_rules_id: 1, release };
+      }
+    } as unknown as PersistedReplicationStream;
+    const terminate = vi.fn(async () => {});
+    const syncRuleStorage = {
+      logger: { info: vi.fn() },
+      terminate
+    } as unknown as SyncRulesBucketStorage;
+    const replicator = new TestReplicator(async () => {
+      throw cleanupError;
+    });
+
+    await expect(replicator.terminateStoppedStream(replicationStream, syncRuleStorage)).rejects.toBe(cleanupError);
+
+    expect(terminate).not.toHaveBeenCalled();
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it('waits for stopped stream cleanup when stopping', async () => {
+    let finishCleanup: () => void;
+    const cleanup = new Promise<void>((resolve) => {
+      finishCleanup = resolve;
+    });
+    const replicator = new TestReplicator(async () => {});
+    replicator.addClearingJob(1, cleanup);
+
+    let stopped = false;
+    const stop = replicator.stop().then(() => {
+      stopped = true;
+    });
+    await Promise.resolve();
+    expect(stopped).toBe(false);
+
+    finishCleanup!();
+    await stop;
+    expect(stopped).toBe(true);
+  });
+});
+
+describe('AbstractReplicator rolling deployment config matching', () => {
+  const processingStream = (version_label: string | undefined): PersistedReplicationStream =>
+    ({
+      syncConfigContent: [
+        {
+          syncConfigState: 'PROCESSING',
+          sync_rules_content: 'bucket_definitions: {}',
+          version_label
+        }
+      ]
+    }) as unknown as PersistedReplicationStream;
+
+  it('requires both YAML and version label to match a processing config', () => {
+    const replicator = new TestReplicator(async () => {});
+    const stream = processingStream('v2');
+
+    expect(replicator.shouldHandleStreamForTest(stream, 'bucket_definitions: {}', 'v2')).toBe(true);
+    expect(replicator.shouldHandleStreamForTest(stream, 'bucket_definitions: {}', 'v1')).toBe(false);
+    expect(replicator.shouldHandleStreamForTest(stream, 'bucket_definitions: {}', undefined)).toBe(false);
+  });
+});

package/test/src/MetricAttributeFilteringExporter.test.ts

@@ -0,0 +1,96 @@
+import { MetricAttributeFilteringExporter } from '@/metrics/open-telemetry/MetricAttributeFilteringExporter.js';
+import { Attributes } from '@opentelemetry/api';
+import { ExportResult } from '@opentelemetry/core';
+import { DataPointType, PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { describe, expect, it, vi } from 'vitest';
+
+type ExportMetrics = (metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void) => void;
+
+describe('MetricAttributeFilteringExporter', () => {
+  it('filters configured attributes without changing the collected metrics', () => {
+    const exportMetrics = vi.fn<ExportMetrics>();
+    const delegate = {
+      export: exportMetrics,
+      forceFlush: vi.fn(async () => {}),
+      shutdown: vi.fn(async () => {})
+    } satisfies PushMetricExporter;
+    const exporter = new MetricAttributeFilteringExporter(delegate, new Set(['version_label']));
+    const attributes: Attributes = {
+      sync_config_id: 'config-a',
+      sync_config_state: 'ACTIVE',
+      version_label: 'customer-version'
+    };
+    const metrics = {
+      resource: {},
+      scopeMetrics: [
+        {
+          scope: {},
+          metrics: [
+            {
+              dataPointType: DataPointType.GAUGE,
+              dataPoints: [{ attributes, value: 100 }]
+            }
+          ]
+        }
+      ]
+    } as unknown as ResourceMetrics;
+    const callback = vi.fn();
+
+    exporter.export(metrics, callback);
+
+    expect(exportMetrics).toHaveBeenCalledWith(
+      expect.objectContaining({
+        scopeMetrics: [
+          expect.objectContaining({
+            metrics: [
+              expect.objectContaining({
+                dataPoints: [
+                  expect.objectContaining({
+                    attributes: { sync_config_id: 'config-a', sync_config_state: 'ACTIVE' }
+                  })
+                ]
+              })
+            ]
+          })
+        ]
+      }),
+      callback
+    );
+    expect(metrics.scopeMetrics[0].metrics[0].dataPoints[0].attributes).toBe(attributes);
+  });
+
+  it('forwards rather than merges data points whose attributes become identical', () => {
+    const exportMetrics = vi.fn<ExportMetrics>();
+    const delegate = {
+      export: exportMetrics,
+      forceFlush: vi.fn(async () => {}),
+      shutdown: vi.fn(async () => {})
+    } satisfies PushMetricExporter;
+    const exporter = new MetricAttributeFilteringExporter(delegate, new Set(['filtered']));
+    const metrics = {
+      resource: {},
+      scopeMetrics: [
+        {
+          scope: {},
+          metrics: [
+            {
+              dataPointType: DataPointType.GAUGE,
+              dataPoints: [
+                { attributes: { retained: 'same', filtered: 'a' }, value: 10 },
+                { attributes: { retained: 'same', filtered: 'b' }, value: 20 }
+              ]
+            }
+          ]
+        }
+      ]
+    } as unknown as ResourceMetrics;
+
+    exporter.export(metrics, vi.fn());
+
+    const exported = exportMetrics.mock.calls[0][0];
+    expect(exported.scopeMetrics[0].metrics[0].dataPoints).toMatchObject([
+      { attributes: { retained: 'same' }, value: 10 },
+      { attributes: { retained: 'same' }, value: 20 }
+    ]);
+  });
+});