chore: split report and filter flags, add gauge

Author: nunogois

src/lib/features/metrics/client-metrics/metrics-service-v2.ts

@@ -125,37 +125,49 @@ export default class ClientMetricsServiceV2 {
         validatedToggleNames: string[];
         unknownToggleNames: string[];
     }> {
+        let toggleNamesToValidate: string[] = toggleNames;
         let unknownToggleNames: string[] = [];
 
-        if (this.flagResolver.isEnabled('filterExistingFlagNames')) {
+        const shouldFilter = this.flagResolver.isEnabled(
+            'filterExistingFlagNames',
+        );
+        const shouldReport = this.flagResolver.isEnabled('reportUnknownFlags');
+
+        if (shouldFilter || shouldReport) {
             try {
-                const validNames = await this.cachedFeatureNames();
+                const existingFlags = await this.cachedFeatureNames();
 
                 const existingNames = toggleNames.filter((name) =>
-                    validNames.includes(name),
+                    existingFlags.includes(name),
+                );
+                const nonExistingNames = toggleNames.filter(
+                    (name) => !existingFlags.includes(name),
                 );
-                if (this.flagResolver.isEnabled('reportUnknownFlags')) {
-                    unknownToggleNames = toggleNames
-                        .filter((name) => !existingNames.includes(name))
-                        .slice(0, MAX_UNKNOWN_FLAGS);
+
+                if (shouldFilter) {
+                    toggleNamesToValidate = existingNames;
+
+                    if (existingNames.length !== toggleNames.length) {
+                        this.logger.info(
+                            `Filtered out ${toggleNames.length - existingNames.length} toggles with non-existing names`,
+                        );
+                    }
                 }
-                if (existingNames.length !== toggleNames.length) {
-                    this.logger.info(
-                        `Filtered out ${toggleNames.length - existingNames.length} toggles with non-existing names`,
+
+                if (shouldReport) {
+                    unknownToggleNames = nonExistingNames.slice(
+                        0,
+                        MAX_UNKNOWN_FLAGS,
                     );
                 }
-
-                const validatedToggleNames =
-                    await this.filterValidToggleNames(existingNames);
-
-                return { validatedToggleNames, unknownToggleNames };
             } catch (e) {
                 this.logger.error(e);
             }
         }
 
-        const validatedToggleNames =
-            await this.filterValidToggleNames(toggleNames);
+        const validatedToggleNames = await this.filterValidToggleNames(
+            toggleNamesToValidate,
+        );
 
         return { validatedToggleNames, unknownToggleNames };
     }

src/lib/features/metrics/unknown-flags/fake-unknown-flags-store.ts

@@ -30,4 +30,8 @@ export class FakeUnknownFlagsStore implements IUnknownFlagsStore {
     async deleteAll(): Promise<void> {
         this.unknownFlagMap.clear();
     }
+
+    async count(): Promise<number> {
+        return this.unknownFlagMap.size;
+    }
 }

src/lib/features/metrics/unknown-flags/unknown-flags-controller.ts

@@ -13,6 +13,7 @@ import { NONE } from '../../../types/permissions';
 import { serializeDates } from '../../../types/serialize-dates';
 import type { IUnleashServices } from '../../../types/services';
 import type { UnknownFlagsService } from './unknown-flags-service';
+import { NotFoundError } from '../../../error';
 
 export default class UnknownFlagsController extends Controller {
     private unknownFlagsService: UnknownFlagsService;
@@ -54,9 +55,12 @@ export default class UnknownFlagsController extends Controller {
     }
 
     async getUnknownFlags(
-        req: IAuthRequest,
+        _: IAuthRequest,
         res: Response<UnknownFlagsResponseSchema>,
     ): Promise<void> {
+        if (!this.flagResolver.isEnabled('reportUnknownFlags')) {
+            throw new NotFoundError();
+        }
         const unknownFlags =
             await this.unknownFlagsService.getGroupedUnknownFlags();
 

src/lib/features/metrics/unknown-flags/unknown-flags-service.ts

@@ -1,15 +1,19 @@
 import type { Logger } from '../../../logger';
-import type { IUnknownFlagsStore, IUnleashConfig } from '../../../types';
+import type {
+    IFlagResolver,
+    IUnknownFlagsStore,
+    IUnleashConfig,
+} from '../../../types';
 import type { IUnleashStores } from '../../../types';
 import type { UnknownFlag } from './unknown-flags-store';
 
 export const MAX_UNKNOWN_FLAGS = 10;
 
 export class UnknownFlagsService {
-    private config: IUnleashConfig;
-
     private logger: Logger;
 
+    private flagResolver: IFlagResolver;
+
     private unknownFlagsStore: IUnknownFlagsStore;
 
     private unknownFlagsCache: Map<string, UnknownFlag>;
@@ -19,7 +23,7 @@ export class UnknownFlagsService {
         config: IUnleashConfig,
     ) {
         this.unknownFlagsStore = unknownFlagsStore;
-        this.config = config;
+        this.flagResolver = config.flagResolver;
         this.logger = config.getLogger(
             '/features/metrics/unknown-flags/unknown-flags-service.ts',
         );
@@ -51,6 +55,7 @@ export class UnknownFlagsService {
     }
 
     async flush(): Promise<void> {
+        if (!this.flagResolver.isEnabled('reportUnknownFlags')) return;
         if (this.unknownFlagsCache.size === 0) return;
 
         const existing = await this.unknownFlagsStore.getAll();
@@ -96,6 +101,7 @@ export class UnknownFlagsService {
     }
 
     async clear(hoursAgo: number) {
+        if (!this.flagResolver.isEnabled('reportUnknownFlags')) return;
         return this.unknownFlagsStore.clear(hoursAgo);
     }
 }

src/lib/features/metrics/unknown-flags/unknown-flags-store.ts

@@ -14,6 +14,7 @@ export interface IUnknownFlagsStore {
     getAll(): Promise<UnknownFlag[]>;
     clear(hoursAgo: number): Promise<void>;
     deleteAll(): Promise<void>;
+    count(): Promise<number>;
 }
 
 export class UnknownFlagsStore implements IUnknownFlagsStore {
@@ -58,4 +59,9 @@ export class UnknownFlagsStore implements IUnknownFlagsStore {
     async deleteAll(): Promise<void> {
         await this.db(TABLE).delete();
     }
+
+    async count(): Promise<number> {
+        const row = await this.db(TABLE).count('* as count').first();
+        return Number(row?.count ?? 0);
+    }
 }

src/lib/metrics.ts

@@ -736,6 +736,11 @@ export function registerPrometheusMetrics(
         labelNames: ['result', 'destination'],
     });
 
+    const unknownFlagsGauge = createGauge({
+        name: 'unknown_flags',
+        help: 'Number of unknown flags reported in the last 24 hours, if any. Maximum of 10.',
+    });
+
     // register event listeners
     eventBus.on(
         events.EXCEEDS_LIMIT,
@@ -1136,6 +1141,10 @@ export function registerPrometheusMetrics(
                 productionChanges60.set(productionChanges.last60);
                 productionChanges90.reset();
                 productionChanges90.set(productionChanges.last90);
+
+                const unknownFlags = await stores.unknownFlagsStore.count();
+                unknownFlagsGauge.reset();
+                unknownFlagsGauge.set(unknownFlags);
             } catch (e) {}
         },
     };