feat: create memory logger

brettkolodny · brettkolodny · commit 461797474e14 · 2025-04-01T16:08:36.000-04:00
diff --git a/src/extension.ts b/src/extension.ts
@@ -11,8 +11,12 @@ import { Remote } from "./remote"
 import { Storage } from "./storage"
 import { toSafeHost } from "./util"
 import { WorkspaceQuery, WorkspaceProvider } from "./workspacesProvider"
+import { getMemoryLogger } from "./memoryLogger"
 
 export async function activate(ctx: vscode.ExtensionContext): Promise<void> {
+  // Initialize the memory logger right when the extension starts.
+  getMemoryLogger();
+
   // The Remote SSH extension's proposed APIs are used to override the SSH host
   // name in VS Code itself. It's visually unappealing having a lengthy name!
   //
diff --git a/src/memoryLogger.ts b/src/memoryLogger.ts
@@ -0,0 +1,214 @@
+import * as vscode from "vscode"
+import * as os from "os"
+import * as path from "path"
+import * as fs from "fs/promises"
+
+/**
+ * A class for tracking memory usage and logging resource lifecycles
+ * to help identify memory leaks in the extension.
+ */
+export class MemoryLogger {
+  private outputChannel: vscode.OutputChannel
+  private logFile: string | undefined
+  private resourceCounts = new Map<string, number>()
+  private startTime: number = Date.now()
+  private logInterval: NodeJS.Timeout | undefined
+  private disposed: boolean = false
+
+  constructor() {
+    this.outputChannel = vscode.window.createOutputChannel("Coder Memory Logging")
+    this.outputChannel.show()
+
+    // Setup periodic logging of memory usage
+    this.startPeriodicLogging()
+  }
+
+  /**
+   * Start logging memory usage periodically
+   */
+  private startPeriodicLogging(intervalMs = 60000) {
+    if (this.logInterval) {
+      clearInterval(this.logInterval)
+    }
+
+    this.logInterval = setInterval(() => {
+      if (this.disposed) return
+      this.logMemoryUsage("PERIODIC")
+      this.logResourceCounts()
+    }, intervalMs)
+  }
+
+  /**
+   * Initialize the log file for persistent logging
+   */
+  public async initLogFile(globalStoragePath: string): Promise<void> {
+    try {
+      const logDir = path.join(globalStoragePath, "logs")
+      await fs.mkdir(logDir, { recursive: true })
+
+      this.logFile = path.join(logDir, `memory-log-${new Date().toISOString().replace(/[:.]/g, "-")}.txt`)
+
+      await this.writeToLogFile("Memory logging initialized")
+      this.info("Memory logging initialized to file: " + this.logFile)
+
+      // Log initial memory state
+      this.logMemoryUsage("INIT")
+    } catch (err) {
+      this.error(`Failed to initialize log file: ${err}`)
+    }
+  }
+
+  /**
+   * Log a new resource creation
+   */
+  public trackResourceCreated(resourceType: string, id: string = ""): void {
+    const count = (this.resourceCounts.get(resourceType) || 0) + 1
+    this.resourceCounts.set(resourceType, count)
+    this.info(`RESOURCE_CREATED: ${resourceType}${id ? ":" + id : ""} (Total: ${count})`)
+  }
+
+  /**
+   * Log a resource disposal
+   */
+  public trackResourceDisposed(resourceType: string, id: string = ""): void {
+    const count = Math.max(0, (this.resourceCounts.get(resourceType) || 1) - 1)
+    if (count === 0) {
+      this.resourceCounts.delete(resourceType)
+    } else {
+      this.resourceCounts.set(resourceType, count)
+    }
+
+    this.info(`RESOURCE_DISPOSED: ${resourceType}${id ? ":" + id : ""} (Remaining: ${count})`)
+  }
+
+  /**
+   * Log error with memory usage
+   */
+  public error(message: string, error?: unknown): void {
+    const errorMsg = error ? `: ${error instanceof Error ? error.stack || error.message : String(error)}` : ""
+    const fullMessage = `[ERROR] ${message}${errorMsg}`
+
+    this.outputChannel.appendLine(fullMessage)
+    this.writeToLogFile(fullMessage)
+    this.logMemoryUsage("ERROR")
+  }
+
+  /**
+   * Log info with timestamp
+   */
+  public info(message: string): void {
+    const fullMessage = `[INFO] ${message}`
+    this.outputChannel.appendLine(fullMessage)
+    this.writeToLogFile(fullMessage)
+  }
+
+  /**
+   * Log debug info (only to file)
+   */
+  public debug(message: string): void {
+    const fullMessage = `[DEBUG] ${message}`
+    this.writeToLogFile(fullMessage)
+  }
+
+  /**
+   * Log current memory usage
+   */
+  public logMemoryUsage(context: string): void {
+    try {
+      const memoryUsage = process.memoryUsage()
+      const nodeMemoryInfo = {
+        rss: `${(memoryUsage.rss / 1024 / 1024).toFixed(2)}MB`,
+        heapTotal: `${(memoryUsage.heapTotal / 1024 / 1024).toFixed(2)}MB`,
+        heapUsed: `${(memoryUsage.heapUsed / 1024 / 1024).toFixed(2)}MB`,
+        external: `${(memoryUsage.external / 1024 / 1024).toFixed(2)}MB`,
+        uptime: formatDuration(process.uptime() * 1000),
+        totalUptime: formatDuration(Date.now() - this.startTime)
+      }
+
+      const systemMemoryInfo = {
+        totalMem: `${(os.totalmem() / 1024 / 1024 / 1024).toFixed(2)}GB`,
+        freeMem: `${(os.freemem() / 1024 / 1024 / 1024).toFixed(2)}GB`,
+        loadAvg: os.loadavg().map(load => load.toFixed(2)).join(", ")
+      }
+
+      const memoryLog = `[MEMORY:${context}] Node: ${JSON.stringify(nodeMemoryInfo)} | System: ${JSON.stringify(systemMemoryInfo)}`
+      this.outputChannel.appendLine(memoryLog)
+      this.writeToLogFile(memoryLog)
+    } catch (err) {
+      this.outputChannel.appendLine(`[ERROR] Failed to log memory usage: ${err}`)
+    }
+  }
+
+  /**
+   * Log the current counts of active resources
+   */
+  private logResourceCounts(): void {
+    const counts = Array.from(this.resourceCounts.entries())
+      .map(([type, count]) => `${type}=${count}`)
+      .join(", ")
+
+    const message = `[RESOURCES] Active resources: ${counts || "none"}`
+    this.outputChannel.appendLine(message)
+    this.writeToLogFile(message)
+  }
+
+  /**
+   * Write to log file
+   */
+  private async writeToLogFile(message: string): Promise<void> {
+    if (!this.logFile) return
+
+    try {
+      const timestamp = new Date().toISOString()
+      await fs.appendFile(this.logFile, `${timestamp} ${message}\n`)
+    } catch (err) {
+      // Don't recursively call this.error to avoid potential loops
+      this.outputChannel.appendLine(`[ERROR] Failed to write to log file: ${err}`)
+    }
+  }
+
+  /**
+   * Show the log in the output channel
+   */
+  public show(): void {
+    this.outputChannel.show()
+  }
+
+  /**
+   * Dispose of the logger
+   */
+  public dispose(): void {
+    this.disposed = true
+    if (this.logInterval) {
+      clearInterval(this.logInterval)
+      this.logInterval = undefined
+    }
+    this.logMemoryUsage("DISPOSE")
+    this.outputChannel.dispose()
+  }
+}
+
+/**
+ * Format duration in milliseconds to a human-readable string
+ */
+function formatDuration(ms: number): string {
+  const seconds = Math.floor((ms / 1000) % 60)
+  const minutes = Math.floor((ms / (1000 * 60)) % 60)
+  const hours = Math.floor((ms / (1000 * 60 * 60)) % 24)
+  const days = Math.floor(ms / (1000 * 60 * 60 * 24))
+
+  return `${days}d ${hours}h ${minutes}m ${seconds}s`
+}
+
+// Singleton instance
+let instance: MemoryLogger | undefined
+
+/**
+ * Get or initialize the memory logger instance
+ */
+export function getMemoryLogger(): MemoryLogger {
+  if (!instance) {
+    instance = new MemoryLogger()
+  }
+  return instance
+}
