Merge pull request #436 from Achal1607/updated-transform-events

Fixed telemetry event issues

Author: sid-srini

vscode/src/telemetry/events/baseEvent.ts

@@ -15,8 +15,8 @@
 */
 import { LOGGER } from "../../logger";
 import { AnonymousIdManager } from "../impl/AnonymousIdManager";
-import { cacheService } from "../impl/cacheServiceImpl";
-import { getHashCode } from "../utils";
+import { cacheServiceIndex } from "../impl/cache";
+import { getHashCode, getValuesToBeTransformed, transformValue } from "../utils";
 
 export interface BaseEventPayload {
     vsCodeId: string;
@@ -26,6 +26,7 @@ export interface BaseEventPayload {
 export abstract class BaseEvent<T> {
     protected _payload: T & BaseEventPayload;
     protected _data: T
+    private static readonly blockedValues = getValuesToBeTransformed();
 
     constructor(public readonly NAME: string,
         public readonly ENDPOINT: string,
@@ -47,6 +48,13 @@ export abstract class BaseEvent<T> {
         return this._data;
     }
 
+    protected static transformEvent = (propertiesToTransform: string[], payload: Record<string, any>): any => {
+        const replacedValue = "_REM_";
+
+        return transformValue(null, this.blockedValues, propertiesToTransform, replacedValue, payload);
+    };
+
+
     public onSuccessPostEventCallback = async (): Promise<void> => {
         LOGGER.debug(`${this.NAME} sent successfully`);
     }
@@ -58,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/jdkFeature.ts

@@ -25,9 +25,11 @@ export interface JdkFeatureEventData {
 export class JdkFeatureEvent extends BaseEvent<JdkFeatureEventData> {
     public static readonly NAME = "jdkFeature";
     public static readonly ENDPOINT = "/jdkFeature";
+    private static readonly propertiesToTransform = ['javaVersion'];
 
     constructor(payload: JdkFeatureEventData) {
-        super(JdkFeatureEvent.NAME, JdkFeatureEvent.ENDPOINT, payload);
+        const updatedPayload: JdkFeatureEventData = BaseEvent.transformEvent(JdkFeatureEvent.propertiesToTransform, payload);
+        super(JdkFeatureEvent.NAME, JdkFeatureEvent.ENDPOINT, updatedPayload);
     }
 
     public static concatEvents(events:JdkFeatureEvent[]): JdkFeatureEvent[] {

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";
@@ -53,9 +53,11 @@ export interface StartEventData {
 export class ExtensionStartEvent extends BaseEvent<StartEventData> {
     public static readonly NAME = "startup";
     public static readonly ENDPOINT = "/start";
+    private static readonly propertiesToTransform = ['osVersion'];
 
     constructor(payload: StartEventData) {
-        super(ExtensionStartEvent.NAME, ExtensionStartEvent.ENDPOINT, payload);
+        const updatedPayload: StartEventData = BaseEvent.transformEvent(ExtensionStartEvent.propertiesToTransform, payload);
+        super(ExtensionStartEvent.NAME, ExtensionStartEvent.ENDPOINT, updatedPayload);
     }
 
     onSuccessPostEventCallback = async (): Promise<void> => {
@@ -65,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;
@@ -37,9 +40,32 @@ let workspaceChangeEventTimeout: NodeJS.Timeout | null = null;
 export class WorkspaceChangeEvent extends BaseEvent<WorkspaceChangeData> {
     public static readonly NAME = "workspaceChange";
     public static readonly ENDPOINT = "/workspaceChange";
+    private static readonly propertiesToTransform = ['javaVersion'];
 
     constructor(payload: WorkspaceChangeData) {
-        super(WorkspaceChangeEvent.NAME, WorkspaceChangeEvent.ENDPOINT, 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> => {

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();