refactor(config-service): update quota scheduler reload logic and add tests (#414)

- Changed the condition for reloading the quota scheduler to check if it
is initialized instead of checking for registered checkers.
- Added a new `isInitialized` method to the `QuotaScheduler` class to
encapsulate the initialization state.
- Updated tests for `ConfigService` to verify the reload behavior when
the scheduler is initialized.
- Enhanced `QuotaScheduler` tests to ensure proper handling of checker
updates and rescheduling on reload.

_When Plexus starts with no quota checkers configured, an admin can
later add the first provider quota checker from the UI and have it take
effect immediately, without restarting the server. Previously, the
scheduler reload was skipped because there were no existing checker IDs,
so the new checker was saved but not registered or scheduled._

Co-authored-by: Matt Cowger <mcowger@users.noreply.github.com>

Author: docloulou

packages/backend/src/services/__tests__/config-service.test.ts

@@ -1,11 +1,15 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import type { ProviderConfig } from '../../config';
+
+const mockScheduler = vi.hoisted(() => ({
+  getCheckerIds: vi.fn(() => []),
+  isInitialized: vi.fn(() => true),
+  reload: vi.fn(() => Promise.resolve()),
+}));
 
 vi.mock('../quota/quota-scheduler', () => ({
   QuotaScheduler: {
-    getInstance: vi.fn(() => ({
-      getCheckerIds: vi.fn(() => []),
-      reload: vi.fn(),
-    })),
+    getInstance: vi.fn(() => mockScheduler),
   },
 }));
 
@@ -57,6 +61,9 @@ describe('ConfigService write coalescing', () => {
     ConfigService.resetInstance();
     rebuildCount = 0;
     mockRepo = createMockRepo();
+    mockScheduler.getCheckerIds.mockReturnValue([]);
+    mockScheduler.isInitialized.mockReturnValue(true);
+    mockScheduler.reload.mockClear();
 
     service = new ConfigService(mockRepo as any);
 
@@ -120,4 +127,30 @@ describe('ConfigService write coalescing', () => {
 
     vi.useRealTimers();
   });
+
+  it('reloads quota scheduler after first quota checker is saved when scheduler is initialized', async () => {
+    vi.useFakeTimers();
+
+    const providerConfig: ProviderConfig = {
+      api_base_url: 'https://api.synthetic.new',
+      api_key: 'synthetic-key',
+      disable_cooldown: false,
+      estimateTokens: false,
+      useClaudeMasking: false,
+      quota_checker: {
+        type: 'synthetic',
+        enabled: true,
+        intervalMinutes: 60,
+        options: {},
+      },
+    };
+
+    await service.saveProvider('synthetic-provider', providerConfig);
+    await service.flush();
+
+    expect(mockScheduler.isInitialized).toHaveBeenCalled();
+    expect(mockScheduler.reload).toHaveBeenCalled();
+
+    vi.useRealTimers();
+  });
 });

packages/backend/src/services/config-service.ts

@@ -408,10 +408,10 @@ export class ConfigService {
 
     // Reload the quota scheduler with the updated quota configs so that
     // changes saved via the UI take effect without a restart.
-    // Only reload if the scheduler has already been initialized (has checkers registered);
+    // Only reload if the scheduler has already been initialized;
     // on startup, index.ts calls quotaScheduler.initialize() explicitly after this.
     const scheduler = QuotaScheduler.getInstance();
-    if (scheduler.getCheckerIds().length > 0) {
+    if (scheduler.isInitialized()) {
       scheduler.reload(quotas).catch((err) => {
         logger.warn(`Failed to reload QuotaScheduler after config change: ${err}`);
       });

packages/backend/src/services/quota/__tests__/quota-scheduler.test.ts

@@ -12,6 +12,7 @@ import { QuotaScheduler } from '../quota-scheduler';
 import { CooldownManager } from '../../cooldown-manager';
 import type { MeterCheckResult, Meter } from '../../../types/meter';
 import type { QuotaConfig } from '../../../config';
+import { registerSpy } from '../../../../test/test-utils';
 
 const CHECKER_ID = 'quota-persistence-checker';
 
@@ -153,6 +154,60 @@ describe('QuotaScheduler persistence', () => {
     expect(rows[0]?.utilizationState).toBe('reported');
     expect(rows[0]?.utilizationPercent).toBeCloseTo(15);
   });
+
+  it('marks scheduler initialized when initialize receives no quota configs', async () => {
+    const scheduler = QuotaScheduler.getInstance();
+
+    await scheduler.initialize([]);
+
+    expect(scheduler.isInitialized()).toBe(true);
+    expect(scheduler.getCheckerIds()).toEqual([]);
+  });
+
+  it('updates existing checker options and reschedules interval changes on reload', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const scheduler = QuotaScheduler.getInstance();
+      const runCheckNow = registerSpy(scheduler, 'runCheckNow').mockResolvedValue(null);
+      const initialConfig: QuotaConfig = {
+        id: 'synthetic-reload-checker',
+        provider: 'synthetic-provider',
+        type: 'synthetic',
+        enabled: true,
+        intervalMinutes: 60,
+        options: {
+          apiKey: 'synthetic-key',
+          endpoint: 'https://old.example.com/v2/quotas',
+        },
+      };
+
+      await scheduler.initialize([initialConfig]);
+      runCheckNow.mockClear();
+
+      await scheduler.reload([
+        {
+          ...initialConfig,
+          intervalMinutes: 1,
+          options: {
+            apiKey: 'synthetic-key',
+            endpoint: 'https://new.example.com/v2/quotas',
+          },
+        },
+      ]);
+
+      const configs = Reflect.get(scheduler, 'configs') as Map<string, QuotaConfig>;
+      const updatedConfig = configs.get('synthetic-reload-checker');
+      expect(updatedConfig?.intervalMinutes).toBe(1);
+      expect(updatedConfig?.options.endpoint).toBe('https://new.example.com/v2/quotas');
+
+      await vi.advanceTimersByTimeAsync(60_000);
+
+      expect(runCheckNow).toHaveBeenCalledWith('synthetic-reload-checker');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });
 
 describe('QuotaScheduler maxUtilizationPercent', () => {

packages/backend/src/services/quota/quota-scheduler.ts

@@ -272,6 +272,10 @@ export class QuotaScheduler {
     return Array.from(this.configs.keys());
   }
 
+  isInitialized(): boolean {
+    return this.checkersLoaded;
+  }
+
   async getLatestQuota(checkerId: string): Promise<MeterCheckResult | null> {
     try {
       const { db, schema } = this.ensureDb();
@@ -397,39 +401,64 @@ export class QuotaScheduler {
     }
 
     const existingIds = new Set(this.configs.keys());
-    const newConfigs = quotaConfigs.filter((c) => !existingIds.has(c.id) && c.enabled);
+    const activeConfigs = quotaConfigs.filter((c) => c.enabled);
+    const activeIds = new Set(activeConfigs.map((c) => c.id));
 
-    for (const config of newConfigs) {
+    for (const id of existingIds) {
+      if (!activeIds.has(id)) {
+        const intervalId = this.intervals.get(id);
+        if (intervalId) {
+          clearInterval(intervalId);
+          this.intervals.delete(id);
+        }
+        this.configs.delete(id);
+        logger.info(`Removed quota checker '${id}' on reload`);
+      }
+    }
+
+    for (const config of activeConfigs) {
       if (!getCheckerDefinition(config.type)) {
         logger.error(`Unknown quota checker type '${config.type}' for checker '${config.id}'`);
         continue;
       }
+
+      const existingConfig = this.configs.get(config.id);
+      const intervalChanged = existingConfig?.intervalMinutes !== config.intervalMinutes;
+
       this.configs.set(config.id, config);
+
+      if (existingConfig && !intervalChanged) {
+        logger.debug(`Updated quota checker '${config.id}' on reload`);
+        continue;
+      }
+
+      if (existingConfig && intervalChanged) {
+        const intervalId = this.intervals.get(config.id);
+        if (intervalId) clearInterval(intervalId);
+        this.intervals.delete(config.id);
+        logger.info(
+          `Rescheduled quota checker '${config.id}' from ${existingConfig.intervalMinutes} to ${config.intervalMinutes} minutes`
+        );
+      } else {
+        logger.info(
+          `Registered quota checker '${config.id}' (${config.type}) for provider '${config.provider}'`
+        );
+      }
+
+      if (this.intervals.has(config.id)) continue;
+
       logger.info(
-        `Registered quota checker '${config.id}' (${config.type}) for provider '${config.provider}'`
+        `Scheduled quota checker '${config.id}' to run every ${config.intervalMinutes} minutes`
       );
 
       const intervalMs = config.intervalMinutes * 60 * 1000;
       const intervalId = setInterval(() => this.runCheckNow(config.id), intervalMs);
       this.intervals.set(config.id, intervalId);
-      logger.info(
-        `Scheduled quota checker '${config.id}' to run every ${config.intervalMinutes} minutes`
-      );
-      this.runCheckNow(config.id).catch((error) => {
-        logger.error(`Initial quota check failed for '${config.id}' on reload: ${error}`);
-      });
-    }
 
-    const loadedIds = new Set(quotaConfigs.filter((c) => c.enabled).map((c) => c.id));
-    for (const id of existingIds) {
-      if (!loadedIds.has(id)) {
-        const intervalId = this.intervals.get(id);
-        if (intervalId) {
-          clearInterval(intervalId);
-          this.intervals.delete(id);
-        }
-        this.configs.delete(id);
-        logger.info(`Removed quota checker '${id}' on reload`);
+      if (!existingConfig) {
+        this.runCheckNow(config.id).catch((error) => {
+          logger.error(`Initial quota check failed for '${config.id}' on reload: ${error}`);
+        });
       }
     }
   }