updated cacheService interface and some other minor changes

Author: Achal1607

vscode/src/telemetry/events/baseEvent.ts

@@ -15,7 +15,7 @@
 */
 import { LOGGER } from "../../logger";
 import { AnonymousIdManager } from "../impl/AnonymousIdManager";
-import { cacheService } from "../impl/cacheServiceImpl";
+import { cacheServiceIndex } from "../impl/cache";
 import { getHashCode, getValuesToBeTransformed, transformValue } from "../utils";
 
 export interface BaseEventPayload {
@@ -66,7 +66,7 @@ export abstract class BaseEvent<T> {
     protected addEventToCache = (): void => {
         const dataString = JSON.stringify(this.getData);
         const calculatedHashVal = getHashCode(dataString);
-        cacheService.put(this.NAME, calculatedHashVal).then((isAdded: boolean) => {
+        cacheServiceIndex.simpleCache.put(this.NAME, calculatedHashVal).then((isAdded: boolean) => {
             LOGGER.debug(`${this.NAME} added in cache ${isAdded ? "Successfully" : "Unsucessfully"}`);
         });
     }

vscode/src/telemetry/events/start.ts

@@ -15,7 +15,7 @@
 */
 import { globalState } from "../../globalState";
 import { LOGGER } from "../../logger";
-import { cacheService } from "../impl/cacheServiceImpl";
+import { cacheServiceIndex } from "../impl/cache";
 import { getEnvironmentInfo } from "../impl/enviromentDetails";
 import { getHashCode } from "../utils";
 import { BaseEvent } from "./baseEvent";
@@ -67,7 +67,7 @@ export class ExtensionStartEvent extends BaseEvent<StartEventData> {
 
     public static builder = (): ExtensionStartEvent | null => {
         const startEventData = getEnvironmentInfo(globalState.getExtensionContextInfo());
-        const cachedValue: string | undefined = cacheService.get(this.NAME);
+        const cachedValue: string | undefined = cacheServiceIndex.simpleCache.get(this.NAME);
         const envString = JSON.stringify(startEventData);
         const newValue = getHashCode(envString);
 

vscode/src/telemetry/events/workspaceChange.ts

@@ -13,9 +13,12 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */
+import { randomUUID } from "crypto";
 import { LOGGER } from "../../logger";
 import { Telemetry } from "../telemetry";
 import { BaseEvent } from "./baseEvent";
+import { cacheServiceIndex } from "../impl/cache";
+import { ProjectCacheValue } from "../impl/cache/projectCacheValue";
 
 interface ProjectInfo {
     id: string;
@@ -40,9 +43,30 @@ export class WorkspaceChangeEvent extends BaseEvent<WorkspaceChangeData> {
     private static readonly propertiesToTransform = ['javaVersion'];
 
     constructor(payload: WorkspaceChangeData) {
-        const updatedPayload: WorkspaceChangeData = BaseEvent.transformEvent(WorkspaceChangeEvent.propertiesToTransform, payload);
+        const updatedPayload: WorkspaceChangeData = WorkspaceChangeEvent.transformPayload(payload);
         super(WorkspaceChangeEvent.NAME, WorkspaceChangeEvent.ENDPOINT, updatedPayload);
     }
+    
+    private static transformPayload = (payload: WorkspaceChangeData) => {
+        const transformedPayload: WorkspaceChangeData = BaseEvent.transformEvent(WorkspaceChangeEvent.propertiesToTransform, payload);
+        return WorkspaceChangeEvent.updateProjectId(transformedPayload)
+    }
+
+    private static updateProjectId = (payload: WorkspaceChangeData) => {
+        const updatedProjectInfo = payload.projectInfo.map(project => {
+            const existingId = cacheServiceIndex.projectCache.get(project.id);
+            const uniqueId = existingId ?? randomUUID();
+
+            if (!existingId) {
+                // Cannot be awaited because the caller is constructor and it cannot be a async call
+                cacheServiceIndex.projectCache.put(project.id, new ProjectCacheValue(uniqueId));
+            }
+
+            return { ...project, id: uniqueId };
+        });
+
+        return { ...payload, projectInfo: updatedProjectInfo };
+    }
 
     public onSuccessPostEventCallback = async (): Promise<void> => {
         LOGGER.debug(`WorkspaceChange event sent successfully`);

vscode/src/telemetry/impl/cache/BaseCacheValue.ts

@@ -0,0 +1,29 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+export type CacheValueObj<T> = {
+    type: string;
+    payload: T;
+    lastUsed: number;
+}
+
+export abstract class BaseCacheValue<T> {
+    public readonly lastUsed: number;
+
+    constructor(public readonly type: string, public readonly payload: T, lastUsed?: number) {
+        this.lastUsed = lastUsed ?? Date.now();
+    }
+}

vscode/src/telemetry/impl/cache/index.ts

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { ProjectCacheService } from "./projectCacheService";
+import { SimpleCacheService } from "./simpleCacheService";
+
+export namespace cacheServiceIndex {
+    export const simpleCache = new SimpleCacheService();
+    export const projectCache = new ProjectCacheService();
+}

vscode/src/telemetry/impl/cache/projectCacheService.ts

@@ -0,0 +1,83 @@
+/*
+  Copyright (c) 2024-2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+import { CacheService } from "../../types";
+import { LOGGER } from "../../../logger";
+import { globalState } from "../../../globalState";
+import { isError } from "../../../utils";
+import { removeEntriesOnOverflow } from "./utils";
+import { ProjectCacheValue } from "./projectCacheValue";
+
+export class ProjectCacheService implements CacheService<ProjectCacheValue, String> {
+    readonly MAX_KEYS_SIZE: number = 5000;
+    private removingKeys: boolean = false;
+
+    public get = (key: string) => {
+        try {
+            const updatedKey = this.getUpdatedKey(key);
+            const vscGlobalState = globalState.getExtensionContextInfo().getVscGlobalState();
+
+            const value = vscGlobalState.get<ProjectCacheValue>(updatedKey);
+            if (value) {
+                this.put(updatedKey, ProjectCacheValue.fromObject({ ...value, lastUsed: Date.now() }));
+            }
+
+            return value?.payload;
+        } catch (err) {
+            LOGGER.error(`Error while retrieving ${key} from cache: ${(err as Error).message}`);
+            return undefined;
+        }
+    }
+
+    public put = async (key: string, value: ProjectCacheValue) => {
+        try {
+            const updatedKey = this.getUpdatedKey(key);
+            const vscGlobalState = globalState.getExtensionContextInfo().getVscGlobalState();
+
+            await vscGlobalState.update(updatedKey, value);
+            if (vscGlobalState.keys().length > this.MAX_KEYS_SIZE) {
+                this.removeOnOverflow();
+            }
+            LOGGER.debug(`Updating key: ${key} to ${value}`);
+
+            return true;
+        } catch (err) {
+            LOGGER.error(`Error while storing ${key} in cache: ${(err as Error).message}`);
+            return false;
+        }
+    }
+
+    public removeOnOverflow = async () => {
+        try {
+            if (this.removingKeys) {
+                LOGGER.log("Ignoring removing keys request, since it is already in progress");
+                return;
+            }
+            this.removingKeys = true;
+
+            const vscGlobalState = globalState.getExtensionContextInfo().getVscGlobalState();
+            const comparator = (a: ProjectCacheValue, b: ProjectCacheValue) => (a.lastUsed - b.lastUsed);
+
+            await removeEntriesOnOverflow(vscGlobalState, ProjectCacheValue.type, comparator);
+        } catch (error) {
+            LOGGER.error("Some error occurred while removing keys " + (isError(error) ? error.message : error));
+        } finally {
+            this.removingKeys = false;
+        }
+    }
+
+    // for unit tests needs to be public
+    public getUpdatedKey = (key: string) => `${ProjectCacheValue.type}.${key}`;
+}

vscode/src/telemetry/impl/cache/projectCacheValue.ts

@@ -0,0 +1,34 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { BaseCacheValue, CacheValueObj } from "./BaseCacheValue";
+
+export class ProjectCacheValue extends BaseCacheValue<string> {
+    public static readonly type = "prjId";
+
+    constructor(payload: string, lastUsed?: number){
+        super(ProjectCacheValue.type, payload, lastUsed);
+    }
+
+    public static fromObject(obj: CacheValueObj<string>): ProjectCacheValue {
+        if (obj.type !== ProjectCacheValue.type) {
+            throw new Error(`Invalid object type for ProjectCacheEntry: received ${obj.type}`);
+        }
+        const entry = new ProjectCacheValue(obj.payload, obj.lastUsed);
+        
+        return entry;
+    }
+}

vscode/src/telemetry/impl/cacheServiceImpl.ts renamed to vscode/src/telemetry/impl/cache/simpleCacheService.ts

@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2024-2025, Oracle and/or its affiliates.
+  Copyright (c) 2025, Oracle and/or its affiliates.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -13,32 +13,32 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */
-import { CacheService } from "../types";
-import { LOGGER } from "../../logger";
-import { globalState } from "../../globalState";
 
-class CacheServiceImpl implements CacheService {
-    public get = (key: string): string | undefined => {
+import { globalState } from "../../../globalState";
+import { LOGGER } from "../../../logger";
+import { CacheService } from "../../types";
+
+export class SimpleCacheService implements CacheService<string, string> {
+    get(key: string) {
         try {
             const vscGlobalState = globalState.getExtensionContextInfo().getVscGlobalState();
-            return vscGlobalState.get(key);
+            return vscGlobalState.get<string>(key);
         } catch (err) {
             LOGGER.error(`Error while retrieving ${key} from cache: ${(err as Error).message}`);
             return undefined;
         }
     }
-
-    public put = async (key: string, value: string): Promise<boolean> => {
+    
+    async put(key: string, value: string) {
         try {
             const vscGlobalState = globalState.getExtensionContextInfo().getVscGlobalState();
             await vscGlobalState.update(key, value);
             LOGGER.debug(`Updating key: ${key} to ${value}`);
+
             return true;
         } catch (err) {
             LOGGER.error(`Error while storing ${key} in cache: ${(err as Error).message}`);
             return false;
         }
     }
 }
-
-export const cacheService = new CacheServiceImpl();

vscode/src/telemetry/impl/cache/utils.ts

@@ -0,0 +1,49 @@
+/*
+  Copyright (c) 2025, Oracle and/or its affiliates.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Memento } from "vscode";
+import { LOGGER } from "../../../logger";
+import { BaseCacheValue } from "./BaseCacheValue";
+
+export const removeEntriesOnOverflow = async <T>(globalCache: Memento & {
+    setKeysForSync(keys: readonly string[]): void;
+},
+    type: string,
+    comparator: (a: BaseCacheValue<T>, b: BaseCacheValue<T>) => number
+) => {
+    const allKeys = globalCache.keys();
+
+    const entries: (BaseCacheValue<T> & { key: string })[] = [];
+
+    for (const key of allKeys) {
+        const value = globalCache.get<BaseCacheValue<T>>(key);
+        if (value?.type === type) {
+            entries.push({ key, ...value });
+        }
+    }
+
+    const half = Math.floor(entries.length / 2);
+    entries.sort(comparator);
+    const toEvict = entries.slice(0, half);
+    LOGGER.debug(toEvict.toString());
+    const toEvictPromises: Promise<void>[] = [];
+    for (const entry of toEvict) {
+        toEvictPromises.push(Promise.resolve(globalCache.update(entry.key, undefined)));
+    }
+    await Promise.allSettled(toEvictPromises);
+
+    LOGGER.debug(`Evicted ${toEvict.length} least-used cache keys due to overflow.`);
+}