Avoid fetching dereferenced segments in server-side

CHANGES.txt

@@ -1,3 +1,6 @@
+2.4.1 (XXX XX, 2025)
+ - Updated synchronization to avoid fetching dereferenced segments in server-side, which were resulting in 404 response errors.
+
 2.4.0 (May 27, 2025)
  - Added support for rule-based segments. These segments determine membership at runtime by evaluating their configured rules against the user attributes provided to the SDK.
  - Added support for feature flag prerequisites. This allows customers to define dependency conditions between flags, which are evaluated before any allowlists or targeting rules.

src/storages/AbstractMySegmentsCacheSync.ts

@@ -11,6 +11,7 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
   protected abstract addSegment(name: string): boolean
   protected abstract removeSegment(name: string): boolean
   protected abstract setChangeNumber(changeNumber?: number): boolean | void
+  protected abstract getSegments(): string[]
 
   /**
    * For server-side synchronizer: check if `key` is in `name` segment.
@@ -27,14 +28,14 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
 
 
   // No-op. Not used in client-side.
-  registerSegments(): boolean { return false; }
   update() { return false; }
 
   /**
-   * For server-side synchronizer: get the list of segments to fetch changes.
-   * Also used for the `seC` (segment count) telemetry stat.
+   * Used for the `seC` (segment count) telemetry stat.
    */
-  abstract getRegisteredSegments(): string[]
+  getSegmentsCount() {
+    return this.getSegments().length;
+  }
 
   /**
    * Only used for the `skC`(segment keys count) telemetry stat: 1 for client-side, and total count of keys in server-side.
@@ -68,7 +69,7 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
     }
 
     const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-    const storedSegmentKeys = this.getRegisteredSegments().sort();
+    const storedSegmentKeys = this.getSegments().sort();
 
     // Extreme fast => everything is empty
     if (!names.length && !storedSegmentKeys.length) return false;

src/storages/AbstractSplitsCacheAsync.ts

@@ -31,7 +31,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
 
-  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
+  // @TODO revisit segment-related methods ('usesSegments')
   // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
   usesSegments(): Promise<boolean> {
     return Promise.resolve(true);

src/storages/KeyBuilderSS.ts

@@ -29,10 +29,6 @@ export class KeyBuilderSS extends KeyBuilder {
     this.versionablePrefix = `${metadata.s}/${metadata.n}/${metadata.i}`;
   }
 
-  buildRegisteredSegmentsKey() {
-    return `${this.prefix}.segments.registered`;
-  }
-
   buildImpressionsKey() {
     return `${this.prefix}.impressions`;
   }

src/storages/__tests__/KeyBuilder.spec.ts

@@ -36,15 +36,8 @@ test('KEYS / segments keys', () => {
   const expectedKey = `SPLITIO.segment.${segmentName}`;
   const expectedTill = `SPLITIO.segment.${segmentName}.till`;
 
-  const expectedSegmentRegistered = 'SPLITIO.segments.registered';
-
   expect(builder.buildSegmentNameKey(segmentName) === expectedKey).toBe(true);
   expect(builder.buildSegmentTillKey(segmentName) === expectedTill).toBe(true);
-  expect(builder.buildRegisteredSegmentsKey() === expectedSegmentRegistered).toBe(true);
-
-  // NOT USED
-  // const expectedReady = 'SPLITIO.segments.ready';
-  // expect(builder.buildSegmentsReady() === expectedReady).toBe(true);
 });
 
 test('KEYS / traffic type keys', () => {

src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -46,7 +46,7 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
-  getRegisteredSegments(): string[] {
+  protected getSegments(): string[] {
     // Scan current values from localStorage
     return Object.keys(localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);

src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -105,6 +105,10 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
     return item && JSON.parse(item);
   }
 
+  getAll(): IRBSegment[] {
+    return this.getNames().map(name => this.get(name) as IRBSegment);
+  }
+
   contains(names: Set<string>): boolean {
     const namesArray = setToArray(names);
     const namesInStorage = this.getNames();

src/storages/inLocalStorage/__tests__/MySegmentsCacheInLocal.spec.ts

@@ -17,7 +17,6 @@ test('SEGMENT CACHE / in LocalStorage', () => {
     expect(cache.getChangeNumber()).toBe(-1);
 
     expect(cache.isInSegment('mocked-segment')).toBe(true);
-    expect(cache.getRegisteredSegments()).toEqual(['mocked-segment', 'mocked-segment-2']);
     expect(cache.getKeysCount()).toBe(1);
   });
 
@@ -29,7 +28,6 @@ test('SEGMENT CACHE / in LocalStorage', () => {
     });
 
     expect(cache.isInSegment('mocked-segment')).toBe(false);
-    expect(cache.getRegisteredSegments()).toEqual(['mocked-segment-2']);
     expect(cache.getKeysCount()).toBe(1);
   });
 

src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -38,7 +38,7 @@ export class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
     return this.cn || -1;
   }
 
-  getRegisteredSegments() {
+  protected getSegments() {
     return Object.keys(this.segmentCache);
   }
 

src/storages/inMemory/RBSegmentsCacheInMemory.ts

@@ -51,6 +51,10 @@ export class RBSegmentsCacheInMemory implements IRBSegmentsCacheSync {
     return this.cache[name] || null;
   }
 
+  getAll(): IRBSegment[] {
+    return this.getNames().map(name => this.get(name) as IRBSegment);
+  }
+
   contains(names: Set<string>): boolean {
     const namesArray = setToArray(names);
     const namesInStorage = this.getNames();

src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -36,24 +36,8 @@ export class SegmentsCacheInMemory implements ISegmentsCacheSync {
     this.segmentChangeNumber = {};
   }
 
-  private _registerSegment(name: string) {
-    if (!this.segmentCache[name]) {
-      this.segmentCache[name] = new Set<string>();
-    }
-
-    return true;
-  }
-
-  registerSegments(names: string[]) {
-    for (let i = 0; i < names.length; i++) {
-      this._registerSegment(names[i]);
-    }
-
-    return true;
-  }
-
-  getRegisteredSegments() {
-    return Object.keys(this.segmentCache);
+  getSegmentsCount() {
+    return Object.keys(this.segmentCache).length;
   }
 
   getKeysCount() {

src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -49,9 +49,9 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       iDe: this.getImpressionStats(DEDUPED),
       iDr: this.getImpressionStats(DROPPED),
       spC: this.splits && this.splits.getSplitNames().length,
-      seC: this.segments && this.segments.getRegisteredSegments().length,
+      seC: this.segments && this.segments.getSegmentsCount(),
       skC: this.segments && this.segments.getKeysCount(),
-      lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+      lsC: this.largeSegments && this.largeSegments.getSegmentsCount(),
       lskC: this.largeSegments && this.largeSegments.getKeysCount(),
       sL: this.getSessionLength(),
       eQ: this.getEventStats(QUEUED),

src/storages/inMemory/__tests__/MySegmentsCacheInMemory.spec.ts

@@ -9,16 +9,13 @@ test('MY SEGMENTS CACHE / in memory', () => {
   expect(cache.getChangeNumber()).toBe(-1);
 
   expect(cache.isInSegment('mocked-segment')).toBe(true);
-  expect(cache.getRegisteredSegments()).toEqual(['mocked-segment', 'mocked-segment-2']);
   expect(cache.getKeysCount()).toBe(1);
 
   expect(cache.resetSegments({ k: [{ n: 'mocked-segment-2' }], cn: 150})).toBe(true);
 
   expect(cache.isInSegment('mocked-segment')).toBe(false);
-  expect(cache.getRegisteredSegments()).toEqual(['mocked-segment-2']);
   expect(cache.getKeysCount()).toBe(1);
 
   cache.clear();
-  expect(cache.getRegisteredSegments()).toEqual([]);
   expect(cache.getChangeNumber()).toBe(-1);
 });

src/storages/inMemory/__tests__/SegmentsCacheInMemory.spec.ts

@@ -29,16 +29,4 @@ describe('SEGMENTS CACHE IN MEMORY', () => {
     expect(cache.getKeysCount()).toBe(0);
   });
 
-  test('registerSegment / getRegisteredSegments', async () => {
-    const cache = new SegmentsCacheInMemory();
-
-    await cache.registerSegments(['s1']);
-    await cache.registerSegments(['s2']);
-    await cache.registerSegments(['s2', 's3', 's4']);
-
-    const segments = cache.getRegisteredSegments();
-
-    ['s1', 's2', 's3', 's4'].forEach(s => expect(segments.indexOf(s) !== -1).toBe(true));
-  });
-
 });

src/storages/inRedis/RBSegmentsCacheInRedis.ts

@@ -30,6 +30,12 @@ export class RBSegmentsCacheInRedis implements IRBSegmentsCacheAsync {
     );
   }
 
+  getAll(): Promise<IRBSegment[]> {
+    return this.getNames().then(names => {
+      return Promise.all(names.map(name => this.get(name) as Promise<IRBSegment>));
+    });
+  }
+
   contains(names: Set<string>): Promise<boolean> {
     const namesArray = setToArray(names);
     return this.getNames().then(namesInStorage => {

src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -51,18 +51,6 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     });
   }
 
-  registerSegments(segments: string[]) {
-    if (segments.length) {
-      return this.redis.sadd(this.keys.buildRegisteredSegmentsKey(), segments).then(() => true);
-    } else {
-      return Promise.resolve(true);
-    }
-  }
-
-  getRegisteredSegments() {
-    return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
-  }
-
   // @TODO remove or implement. It is not being used.
   clear() {
     return Promise.resolve();

src/storages/inRedis/__tests__/SegmentsCacheInRedis.spec.ts

@@ -36,21 +36,4 @@ describe('SEGMENTS CACHE IN REDIS', () => {
     await connection.disconnect();
   });
 
-  test('registerSegment / getRegisteredSegments', async () => {
-    const connection = new RedisAdapter(loggerMock);
-    const cache = new SegmentsCacheInRedis(loggerMock, keys, connection);
-
-    await cache.registerSegments(['s1']);
-    await cache.registerSegments(['s2']);
-    await cache.registerSegments(['s2', 's3', 's4']);
-
-    const segments = await cache.getRegisteredSegments();
-
-    ['s1', 's2', 's3', 's4'].forEach(s => expect(segments.indexOf(s) !== -1).toBe(true));
-
-    // Teardown
-    await connection.del(await connection.keys(`${prefix}.segment*`)); // @TODO use `cache.clear` method when implemented
-    await connection.disconnect();
-  });
-
 });

src/storages/pluggable/RBSegmentsCachePluggable.ts

@@ -29,6 +29,12 @@ export class RBSegmentsCachePluggable implements IRBSegmentsCacheAsync {
     );
   }
 
+  getAll(): Promise<IRBSegment[]> {
+    return this.getNames().then(names => {
+      return Promise.all(names.map(name => this.get(name) as Promise<IRBSegment>));
+    });
+  }
+
   contains(names: Set<string>): Promise<boolean> {
     const namesArray = setToArray(names);
     return this.getNames().then(namesInStorage => {

src/storages/pluggable/SegmentsCachePluggable.ts

@@ -62,26 +62,6 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
     });
   }
 
-  /**
-   * Add the given segment names to the set of registered segments.
-   * The returned promise is resolved when the operation success,
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  registerSegments(segments: string[]) {
-    if (segments.length) {
-      return this.wrapper.addItems(this.keys.buildRegisteredSegmentsKey(), segments);
-    } else {
-      return Promise.resolve();
-    }
-  }
-
-  /**
-   * Returns a promise that resolves with the set of registered segments in a list,
-   * or rejected if it fails (e.g., wrapper operation fails).
-   */
-  getRegisteredSegments() {
-    return this.wrapper.getItems(this.keys.buildRegisteredSegmentsKey());
-  }
 
   // @TODO implement if required by DataLoader or Producer mode
   clear(): Promise<boolean> {

src/storages/pluggable/__tests__/SegmentsCachePluggable.spec.ts

@@ -37,16 +37,4 @@ describe('SEGMENTS CACHE PLUGGABLE', () => {
     expect(await cache.isInSegment('inexistent-segment', 'a')).toBe(false);
   });
 
-  test('registerSegment / getRegisteredSegments', async () => {
-    const cache = new SegmentsCachePluggable(loggerMock, keyBuilder, wrapperMock);
-
-    await cache.registerSegments(['s1']);
-    await cache.registerSegments(['s2']);
-    await cache.registerSegments(['s2', 's3', 's4']);
-
-    const segments = await cache.getRegisteredSegments();
-
-    ['s1', 's2', 's3', 's4'].forEach(s => expect(segments.indexOf(s) !== -1).toBe(true));
-  });
-
 });

src/storages/types.ts

@@ -229,6 +229,7 @@ export interface IRBSegmentsCacheBase {
   getChangeNumber(): MaybeThenable<number>,
   clear(): MaybeThenable<boolean | void>,
   contains(names: Set<string>): MaybeThenable<boolean>,
+  getAll(): MaybeThenable<IRBSegment[]>,
 }
 
 export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
@@ -237,6 +238,7 @@ export interface IRBSegmentsCacheSync extends IRBSegmentsCacheBase {
   getChangeNumber(): number,
   clear(): void,
   contains(names: Set<string>): boolean,
+  getAll(): IRBSegment[],
   // Used only for smart pausing in client-side standalone. Returns true if the storage contains a RBSegment using segments or large segments matchers
   usesSegments(): boolean,
 }
@@ -247,14 +249,13 @@ export interface IRBSegmentsCacheAsync extends IRBSegmentsCacheBase {
   getChangeNumber(): Promise<number>,
   clear(): Promise<boolean | void>,
   contains(names: Set<string>): Promise<boolean>,
+  getAll(): Promise<IRBSegment[]>,
 }
 
 /** Segments cache */
 
 export interface ISegmentsCacheBase {
   isInSegment(name: string, key?: string): MaybeThenable<boolean> // different signature on Server and Client-Side
-  registerSegments(names: string[]): MaybeThenable<boolean | void> // only for Server-Side
-  getRegisteredSegments(): MaybeThenable<string[]> // only for Server-Side
   getChangeNumber(name: string): MaybeThenable<number | undefined> // only for Server-Side
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean> // only for Server-Side
   clear(): MaybeThenable<boolean | void>
@@ -263,19 +264,17 @@ export interface ISegmentsCacheBase {
 // Same API for both variants: SegmentsCache and MySegmentsCache (client-side API)
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   isInSegment(name: string, key?: string): boolean
-  registerSegments(names: string[]): boolean
-  getRegisteredSegments(): string[]
-  getKeysCount(): number // only used for telemetry
   getChangeNumber(name?: string): number | undefined
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean // only for Server-Side
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
+  // only used for telemetry:
+  getKeysCount(): number
+  getSegmentsCount(): number
 }
 
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
   isInSegment(name: string, key: string): Promise<boolean>
-  registerSegments(names: string[]): Promise<boolean | void>
-  getRegisteredSegments(): Promise<string[]>
   getChangeNumber(name: string): Promise<number | undefined>
   update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>
   clear(): Promise<boolean | void>

src/sync/polling/syncTasks/segmentsSyncTask.ts

@@ -21,7 +21,7 @@ export function segmentsSyncTaskFactory(
     segmentChangesUpdaterFactory(
       settings.log,
       segmentChangesFetcherFactory(fetchSegmentChanges),
-      storage.segments,
+      storage,
       readiness,
     ),
     settings.scheduler.segmentsRefreshRate,