Merge pull request #2 from bubablue/feat/optimizations-improvements

feat(optimizations improvements): Optimize single instance running

Author: bubablue

package.json

@@ -127,7 +127,7 @@
         },
         "systemGraph.updateInterval": {
           "type": "number",
-          "default": 2000,
+          "default": 4000,
           "minimum": 500,
           "maximum": 10000,
           "description": "Update interval in milliseconds"

src/extension.ts

@@ -4,10 +4,34 @@ import { StatusBarManager } from "./statusBarManager";
 import { SystemMonitor } from "./systemMonitor";
 import { SystemResourcesProvider } from "./systemResourcesProvider";
 
+interface GlobalExtensionState {
+  systemMonitor: SystemMonitor | undefined;
+  provider: SystemResourcesProvider | undefined;
+  windowInstances: Map<string, {
+    statusBarItems: StatusBarItems;
+    statusBarManager: StatusBarManager;
+  }>;
+  instanceCount: number;
+}
+
+const GLOBAL_STATE_KEY = Symbol.for('system-performance-extension.globalState');
+const globalThis_ = globalThis as any;
+
+function getGlobalState(): GlobalExtensionState {
+  if (!globalThis_[GLOBAL_STATE_KEY]) {
+    globalThis_[GLOBAL_STATE_KEY] = {
+      systemMonitor: undefined,
+      provider: undefined,
+      windowInstances: new Map(),
+      instanceCount: 0,
+    };
+  }
+  return globalThis_[GLOBAL_STATE_KEY];
+}
+
 let statusBarItems: StatusBarItems | undefined;
 let statusBarManager: StatusBarManager;
-let systemMonitor: SystemMonitor;
-let provider: SystemResourcesProvider;
+let windowId: string;
 
 async function requestSystemPermissions(context: vscode.ExtensionContext): Promise<boolean> {
   const permissionsGranted = context.globalState.get<boolean>('systemPermissionsGranted');
@@ -43,19 +67,34 @@ export function activate(context: vscode.ExtensionContext) {
       return;
     }
 
-    provider = new SystemResourcesProvider(context.extensionUri);
+    const globalState = getGlobalState();
+    globalState.instanceCount++;
+    
+    windowId = `window-${Date.now()}-${Math.random()}`;
+    
     statusBarManager = new StatusBarManager();
-    systemMonitor = new SystemMonitor(statusBarManager, provider);
+    statusBarItems = statusBarManager.createStatusBarItems();
+    
+    if (!globalState.systemMonitor) {
+      globalState.provider = new SystemResourcesProvider(context.extensionUri);
+      globalState.systemMonitor = new SystemMonitor(statusBarManager, globalState.provider);
+    } else {
+      globalState.systemMonitor.addStatusBarInstance(statusBarItems);
+    }
+    
+    globalState.windowInstances.set(windowId, {
+      statusBarItems,
+      statusBarManager
+    });
 
     context.subscriptions.push(
       vscode.window.registerWebviewViewProvider(
         SystemResourcesProvider.viewType,
-        provider
+        globalState.provider!
       )
     );
 
-    statusBarItems = statusBarManager.createStatusBarItems();
-    systemMonitor.startSystemMonitoring(statusBarItems);
+    globalState.systemMonitor.startSystemMonitoring(statusBarItems);
 
     const showGraphDisposable = vscode.commands.registerCommand(
       "system-performance.showGraph",
@@ -75,7 +114,8 @@ export function activate(context: vscode.ExtensionContext) {
       "system-performance.refresh",
       () => {
         if (statusBarItems) {
-          systemMonitor.startSystemMonitoring(statusBarItems);
+          const globalState = getGlobalState();
+          globalState.systemMonitor?.startSystemMonitoring(statusBarItems);
         }
       }
     );
@@ -84,7 +124,8 @@ export function activate(context: vscode.ExtensionContext) {
       "system-performance.toggleMonitoring",
       () => {
         if (statusBarItems) {
-          systemMonitor.toggleMonitoring(statusBarItems);
+          const globalState = getGlobalState();
+          globalState.systemMonitor?.toggleMonitoring(statusBarItems);
         }
       }
     );
@@ -127,10 +168,29 @@ export function activate(context: vscode.ExtensionContext) {
 }
 
 export function deactivate() {
-  if (systemMonitor) {
-    systemMonitor.dispose();
+  const globalState = getGlobalState();
+  
+  if (globalState.systemMonitor && statusBarItems) {
+    globalState.systemMonitor.removeStatusBarInstance(statusBarItems);
+  }
+  
+  if (windowId) {
+    globalState.windowInstances.delete(windowId);
   }
+  
+  globalState.instanceCount--;
+  
   if (statusBarItems) {
     statusBarManager.disposeStatusBarItems(statusBarItems);
+    statusBarItems = undefined;
+  }
+  
+  if (globalState.instanceCount <= 0) {
+    if (globalState.systemMonitor) {
+      globalState.systemMonitor.dispose();
+      globalState.systemMonitor = undefined;
+    }
+    globalState.provider = undefined;
+    globalState.windowInstances.clear();
   }
 }

src/systemMonitor.ts

@@ -25,6 +25,7 @@ export class SystemMonitor {
   private static lastUpdateTime = 0;
   private static isUpdating = false;
   private static lastSystemData: any = null;
+  private readonly statusBarInstances: StatusBarItems[] = [];
 
   constructor(
     private readonly statusBarManager: StatusBarManager,
@@ -33,39 +34,53 @@ export class SystemMonitor {
     SystemMonitor.activeMonitors.add(this);
   }
 
+  public addStatusBarInstance(statusBarItems: StatusBarItems): void {
+    if (!this.statusBarInstances.includes(statusBarItems)) {
+      this.statusBarInstances.push(statusBarItems);
+    }
+  }
+
+  public removeStatusBarInstance(statusBarItems: StatusBarItems): void {
+    const index = this.statusBarInstances.indexOf(statusBarItems);
+    if (index > -1) {
+      this.statusBarInstances.splice(index, 1);
+    }
+  }
+
   public startSystemMonitoring(statusBarItems: StatusBarItems): void {
+    this.addStatusBarInstance(statusBarItems);
+
     if (this.updateInterval) {
       clearInterval(this.updateInterval);
       this.updateInterval = undefined;
     }
 
     const config = vscode.workspace.getConfiguration("systemGraph");
-    const updateIntervalMs = config.get("updateInterval", 2000);
+    const updateIntervalMs = config.get("updateInterval", 4000);
 
     if (!this.isPaused && this.monitoringEnabled) {
-      SystemMonitor.globalInterval ??= setInterval(async () => {
-        if (SystemMonitor.isUpdating) {
-          return;
-        }
+      if (SystemMonitor.globalInterval) {
+        clearInterval(SystemMonitor.globalInterval);
+        SystemMonitor.globalInterval = undefined;
+      }
 
-        const now = Date.now();
-        if (now - SystemMonitor.lastUpdateTime < updateIntervalMs - 200) {
+      SystemMonitor.globalInterval = setInterval(async () => {
+        if (SystemMonitor.isUpdating) {
           return;
         }
 
         SystemMonitor.isUpdating = true;
-        SystemMonitor.lastUpdateTime = now;
+        SystemMonitor.lastUpdateTime = Date.now();
 
         try {
           const systemData = await SystemMonitor.collectSystemData();
           SystemMonitor.lastSystemData = systemData;
 
           SystemMonitor.activeMonitors.forEach((monitor) => {
             if (monitor.monitoringEnabled && !monitor.isPaused) {
-              const items = monitor.statusBarManager.getStatusBarItems();
-              if (items) {
+              monitor.statusBarInstances.forEach((items) => {
                 monitor.updateWithSystemData(items, systemData);
-              }
+              });
             }
           });
         } catch (error) {
@@ -117,7 +132,7 @@ export class SystemMonitor {
     }
   }
 
-  public toggleMonitoring(statusBarItems: StatusBarItems): void {
+  public toggleMonitoring(_statusBarItems: StatusBarItems): void {
     this.isPaused = !this.isPaused;
     const config = vscode.workspace.getConfiguration("systemGraph");
     config.update(
@@ -138,7 +153,10 @@ export class SystemMonitor {
       vscode.window.showInformationMessage("System monitoring paused");
 
       this.monitoringEnabled = false;
-      this.statusBarManager.hideAllStatusBarItems(statusBarItems);
+
+      this.statusBarInstances.forEach((items) => {
+        this.statusBarManager.hideAllStatusBarItems(items);
+      });
 
       const anyActiveMonitor = Array.from(SystemMonitor.activeMonitors).some(
         (monitor) => monitor.monitoringEnabled && !monitor.isPaused
@@ -154,8 +172,14 @@ export class SystemMonitor {
       vscode.window.showInformationMessage("System monitoring resumed");
 
       this.monitoringEnabled = true;
-      this.startSystemMonitoring(statusBarItems);
-      this.statusBarManager.updateStatusBarVisibility(statusBarItems);
+
+      if (this.statusBarInstances.length > 0) {
+        this.startSystemMonitoring(this.statusBarInstances[0]);
+      }
+
+      this.statusBarInstances.forEach((items) => {
+        this.statusBarManager.updateStatusBarVisibility(items);
+      });
     }
   }
 
@@ -202,13 +226,11 @@ export class SystemMonitor {
 
       const cpuPercent = Math.round(cpu.currentLoad);
 
-      // Calculate total CPU usage of all processes
       const totalProcessCpu = processes.list.reduce(
         (sum, p) => sum + (p.cpu || 0),
         0
       );
 
-      // Calculate VS Code CPU as percentage of all process CPU usage
       const vscodeCpuRelative =
         totalProcessCpu > 0
           ? Math.round((vscodeCpu / totalProcessCpu) * 100)
@@ -347,7 +369,7 @@ export class SystemMonitor {
       data.vscodeMemoryMBRounded
     }MB\n${generateMiniGraph(
       this.historyData.vscodeMemory,
-      2000
+      4000
     )}\nClick to focus System Resources view`;
     statusBarItems.vscodeMemory.color = undefined;
 

src/test/e2e/extension.test.ts

@@ -1,19 +1,16 @@
 import * as assert from "assert";
 import * as vscode from "vscode";
+import { TestHelper } from "./testHelper";
 
 suite("System Performance Extension E2E Tests", () => {
   let extension: vscode.Extension<any>;
 
   setup(async () => {
-    extension = vscode.extensions.getExtension(
-      "bubablue00.system-performance"
-    )!;
-
-    if (!extension.isActive) {
-      await extension.activate();
-    }
+    extension = await TestHelper.setupExtensionForTesting();
+  });
 
-    await new Promise((resolve) => setTimeout(resolve, 2000));
+  teardown(async () => {
+    await TestHelper.cleanupExtension();
   });
 
   test("Extension should be present and activated", async () => {
@@ -87,8 +84,8 @@ suite("System Performance Extension E2E Tests", () => {
     );
     assert.strictEqual(
       config.get("updateInterval"),
-      2000,
-      "updateInterval should default to 2000"
+      4000,
+      "updateInterval should default to 4000"
     );
   });
 
@@ -150,17 +147,28 @@ suite("System Performance Extension E2E Tests", () => {
   test("Status bar configuration should work", async () => {
     const config = vscode.workspace.getConfiguration("systemGraph");
 
+    await config.update(
+      "statusBarEnabled",
+      true,
+      vscode.ConfigurationTarget.Global
+    );
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Now test disabling
     await config.update(
       "statusBarEnabled",
       false,
       vscode.ConfigurationTarget.Global
     );
 
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve) => setTimeout(resolve, 2000));
 
-    const updatedValue = config.get("statusBarEnabled");
+    const freshConfig = vscode.workspace.getConfiguration("systemGraph");
+    const updatedValue = freshConfig.get("statusBarEnabled");
+    
     assert.strictEqual(updatedValue, false, "Status bar should be disabled");
 
+    // Restore to true for cleanup
     await config.update(
       "statusBarEnabled",
       true,
@@ -173,7 +181,7 @@ suite("System Performance Extension E2E Tests", () => {
   test("System information should be collected", async () => {
     await vscode.commands.executeCommand("system-performance.refresh");
 
-    await new Promise((resolve) => setTimeout(resolve, 2000));
+    await new Promise((resolve) => setTimeout(resolve, 4000));
 
     assert.ok(true, "System information collection works");
   });

src/test/e2e/performance.test.ts

@@ -1,19 +1,14 @@
 import * as assert from "assert";
 import * as vscode from "vscode";
+import { TestHelper } from "./testHelper";
 
 suite("System Performance Extension Performance Tests", () => {
-  let extension: vscode.Extension<any>;
-
   setup(async () => {
-    extension = vscode.extensions.getExtension(
-      "bubablue00.system-performance"
-    )!;
-
-    if (!extension.isActive) {
-      await extension.activate();
-    }
+    await TestHelper.setupExtensionForTesting();
+  });
 
-    await new Promise((resolve) => setTimeout(resolve, 2000));
+  teardown(async () => {
+    await TestHelper.cleanupExtension();
   });
 
   test("Extension activation should be fast", async () => {
@@ -99,7 +94,7 @@ suite("System Performance Extension Performance Tests", () => {
 
     await config.update(
       "updateInterval",
-      2000,
+      4000,
       vscode.ConfigurationTarget.Global
     );
   });
@@ -137,7 +132,7 @@ suite("System Performance Extension Performance Tests", () => {
       config.update("updateInterval", 1000, vscode.ConfigurationTarget.Global),
       config.update("showCpu", true, vscode.ConfigurationTarget.Global),
       config.update("showMemory", true, vscode.ConfigurationTarget.Global),
-      config.update("updateInterval", 2000, vscode.ConfigurationTarget.Global),
+      config.update("updateInterval", 4000, vscode.ConfigurationTarget.Global),
     ];
 
     await Promise.all(configChanges);