Remove jitter and migrate tasks to execute immediately

src/lib/metrics-gauge.ts

@@ -1,11 +1,18 @@
+import type { Logger } from './logger';
+import type { IUnleashConfig } from './types';
 import { createGauge, type Gauge } from './util/metrics';
 
 type RestrictedRecord<T extends readonly string[]> = Record<T[number], string>;
 type Query<R> = () => Promise<R | undefined | null>;
-type MapResult<R> = (result: R) => {
+type MapResult<R> = (result: R) =>
-    count: number;
+    | {
-    labels: RestrictedRecord<GaugeDefinition<R>['labelNames']>;
+          count: number;
-};
+          labels: RestrictedRecord<GaugeDefinition<R>['labelNames']>;
+      }
+    | {
+          count: number;
+          labels: RestrictedRecord<GaugeDefinition<R>['labelNames']>;
+      }[];
 
 type GaugeDefinition<T> = {
     name: string;
@@ -19,18 +26,31 @@ type Task = () => Promise<void>;
 export class DbMetricsMonitor {
     private tasks: Set<Task> = new Set();
     private gauges: Map<string, Gauge<string>> = new Map();
+    private logger: Logger;
 
-    constructor() {}
+    constructor(config: IUnleashConfig) {
+        this.logger = config.getLogger('gauge-metrics');
+    }
+
+    private asArray<T>(value: T | T[]): T[] {
+        return Array.isArray(value) ? value : [value];
+    }
 
     registerGaugeDbMetric<T>(definition: GaugeDefinition<T>): Task {
         const gauge = createGauge(definition);
         this.gauges.set(definition.name, gauge);
         const task = async () => {
-            const result = await definition.query();
+            try {
-            if (result !== null && result !== undefined) {
+                const result = await definition.query();
-                const { count, labels } = definition.map(result);
+                if (result !== null && result !== undefined) {
-                gauge.reset();
+                    const results = this.asArray(definition.map(result));
-                gauge.labels(labels).set(count);
+                    gauge.reset();
+                    for (const r of results) {
+                        gauge.labels(r.labels).set(r.count);
+                    }
+                }
+            } catch (e) {
+                this.logger.warn(`Failed to refresh ${definition.name}`, e);
             }
         };
         this.tasks.add(task);

src/lib/metrics.ts

@@ -57,7 +57,7 @@ export default class MetricsMonitor {
 
         const { eventStore, environmentStore } = stores;
         const { flagResolver } = config;
-        const dbMetrics = new DbMetricsMonitor();
+        const dbMetrics = new DbMetricsMonitor(config);
 
         const cachedEnvironments: () => Promise<IEnvironment[]> = memoizee(
             async () => environmentStore.getAll(),
@@ -260,11 +260,18 @@ export default class MetricsMonitor {
             help: 'Number of strategies',
         });
 
-        const clientAppsTotal = createGauge({
+        // execute immediately to get initial values
+        await dbMetrics.registerGaugeDbMetric({
             name: 'client_apps_total',
             help: 'Number of registered client apps aggregated by range by last seen',
             labelNames: ['range'],
-        });
+            query: () => instanceStatsService.getLabeledAppCounts(),
+            map: (result) =>
+                Object.entries(result).map(([range, count]) => ({
+                    count,
+                    labels: { range },
+                })),
+        })();
 
         const samlEnabled = createGauge({
             name: 'saml_enabled',
@@ -628,11 +635,6 @@ export default class MetricsMonitor {
                 oidcEnabled.reset();
                 oidcEnabled.set(stats.OIDCenabled ? 1 : 0);
 
-                clientAppsTotal.reset();
-                stats.clientApps.forEach(({ range, count }) =>
-                    clientAppsTotal.labels({ range }).set(count),
-                );
-
                 rateLimits.reset();
                 rateLimits
                     .labels({
@@ -695,7 +697,6 @@ export default class MetricsMonitor {
             collectStaticCounters.bind(this),
             hoursToMilliseconds(2),
             'collectStaticCounters',
-            0, // no jitter
         );
 
         eventBus.on(