better feature flag cache

core/util/GlobalContext.ts

@@ -1,20 +1,30 @@
-import fs from "node:fs";
+import { PosthogFeatureFlag } from "./posthog";
 
 import { ModelRole } from "@continuedev/config-yaml";
-
+import fs from "node:fs";
 import { SiteIndexingConfig } from "..";
+
 import {
   salvageSharedConfig,
   sharedConfigSchema,
   SharedConfigSchema,
 } from "../config/sharedConfig";
-
 import { getGlobalContextFilePath } from "./paths";
 
 export type GlobalContextModelSelections = Partial<
   Record<ModelRole, string | null>
 >;
 
+// Add this type near the top of the file
+export type FeatureFlagCacheEntry = {
+  lastUpdated: number;
+  value: any;
+};
+
+export type FeatureFlagCache = {
+  flags: Partial<Record<PosthogFeatureFlag, FeatureFlagCacheEntry>>;
+};
+
 export type GlobalContextType = {
   indexingPaused: boolean;
   lastSelectedProfileForWorkspace: {
@@ -37,6 +47,7 @@ export type GlobalContextType = {
   hasAlreadyCreatedAPromptFile: boolean;
   showConfigUpdateToast: boolean;
   isSupportedLanceDbCpuTargetForLinux: boolean;
+  featureFlagCache: FeatureFlagCache;
   sharedConfig: SharedConfigSchema;
   failedDocs: SiteIndexingConfig[];
 };

core/util/posthog.ts

@@ -1,3 +1,9 @@
+import {
+  FeatureFlagCache,
+  FeatureFlagCacheEntry,
+  GlobalContext,
+} from "./GlobalContext";
+
 import os from "node:os";
 
 import { TeamAnalytics } from "../control-plane/TeamAnalytics.js";
@@ -107,28 +113,65 @@ export class Telemetry {
   }
 
   private static featureValueCache: Record<string, any> = {};
+  private static globalContext = new GlobalContext();
 
-  static async getFeatureFlag(flag: PosthogFeatureFlag) {
-    const value = Telemetry.client?.getFeatureFlag(flag, Telemetry.uniqueId);
+  private static shouldRefreshFlag(flag: PosthogFeatureFlag): boolean {
+    const cache = Telemetry.globalContext.get("featureFlagCache");
+    if (!cache?.flags[flag]) return true;
+
+    const ONE_DAY = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+    const now = Date.now();
+    return now - cache.flags[flag].lastUpdated > ONE_DAY;
+  }
+
+  private static async updateFlagCache(flag: PosthogFeatureFlag, value: any) {
+    const cache = Telemetry.globalContext.get("featureFlagCache") || {
+      flags: {},
+    };
+
+    const newEntry: FeatureFlagCacheEntry = {
+      lastUpdated: Date.now(),
+      value,
+    };
 
+    const updatedCache: FeatureFlagCache = {
+      flags: {
+        ...cache.flags,
+        [flag]: newEntry,
+      },
+    };
+
+    Telemetry.globalContext.update("featureFlagCache", updatedCache);
     Telemetry.featureValueCache[flag] = value;
-    return value;
   }
 
   static async getValueForFeatureFlag(flag: PosthogFeatureFlag) {
     try {
-      if (Telemetry.featureValueCache[flag]) {
-        return Telemetry.featureValueCache[flag];
+      // Check if we have a valid cached value
+      const cache = Telemetry.globalContext.get("featureFlagCache");
+      if (cache?.flags[flag] && !Telemetry.shouldRefreshFlag(flag)) {
+        return cache.flags[flag].value;
       }
 
+      // If we need to refresh, get the new value
       const userGroup = await Telemetry.getFeatureFlag(flag);
       if (typeof userGroup === "string") {
-        return EXPERIMENTS[flag][userGroup].value;
+        const value = EXPERIMENTS[flag][userGroup].value;
+        await Telemetry.updateFlagCache(flag, value);
+        return value;
       }
 
+      // If no value is found, cache undefined to prevent repeated lookups
+      await Telemetry.updateFlagCache(flag, undefined);
       return undefined;
     } catch {
       return undefined;
     }
   }
+
+  // The getFeatureFlag method can remain unchanged
+  static async getFeatureFlag(flag: PosthogFeatureFlag) {
+    const value = Telemetry.client?.getFeatureFlag(flag, Telemetry.uniqueId);
+    return value;
+  }
 }