Add LS daemon to monitor error and performance (#925)

Author: Eskibear

package-lock.json

@@ -7,7 +7,7 @@
   "publisher": "vscjava",
   "preview": true,
   "engines": {
-    "vscode": "^1.52.0"
+    "vscode": "^1.64.0"
   },
   "aiKey": "b4a8a622-6ac7-4cf8-83aa-f325e1890795",
   "icon": "logo.png",
@@ -218,6 +218,12 @@
           "default": true,
           "description": "Show release notes of Extension Pack for Java on startup.",
           "scope": "window"
+        },
+        "java.help.shareDiagnostics": {
+          "type": "boolean",
+          "default": false,
+          "description": "Whether to send back detailed information from error logs for diagnostic purpose.",
+          "scope": "window"
         }
       }
     },
@@ -295,7 +301,7 @@
     "@types/react-dom": "^16.9.14",
     "@types/react-redux": "^7.1.22",
     "@types/semver": "^5.5.0",
-    "@types/vscode": "1.52.0",
+    "@types/vscode": "1.64.0",
     "@types/winreg": "^1.2.31",
     "@types/xmldom": "^0.1.31",
     "autoprefixer": "^10.4.2",

package.json

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as vscode from "vscode";
+import { ProcessWatcher } from "./processWatcher";
+import { LogWatcher } from "./serverLog/logWatcher";
+
+
+export class LSDaemon {
+
+    public logWatcher: LogWatcher;
+    public processWatcher: ProcessWatcher;
+
+    constructor(public context: vscode.ExtensionContext) {
+        this.processWatcher = new ProcessWatcher(this);
+        this.logWatcher = new LogWatcher(this);
+    }
+
+    public async initialize() {
+        await this.logWatcher.start();
+    }
+
+
+}

src/daemon/daemon.ts

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { promisify } from "util";
+import * as vscode from "vscode";
+import { sendError } from "vscode-extension-telemetry-wrapper";
+import { LSDaemon } from "./daemon";
+
+const delay = promisify(setTimeout);
+
+let daemon: LSDaemon;
+export async function initDaemon(context: vscode.ExtensionContext) {
+   daemon = new LSDaemon(context);
+   await daemon.initialize()
+
+   const activated = await checkJavaExtActivated(context);
+   if (activated) {
+      daemon.logWatcher.sendStartupMetadata("redhat.java activated");
+   }
+}
+
+async function checkJavaExtActivated(_context: vscode.ExtensionContext): Promise<boolean> {
+   const javaExt = vscode.extensions.getExtension("redhat.java");
+   if (!javaExt) {
+      return false;
+   }
+
+   // wait javaExt to activate
+   const timeout = 30 * 60 * 1000; // wait 30 min at most
+   let count = 0;
+   while(!javaExt.isActive && count < timeout) {
+      await delay(1000);
+      count += 1000;
+   }
+
+   if (!javaExt.isActive) {
+      sendError(new Error("redhat.java extension not activated within 30 min"));
+      daemon.logWatcher.sendStartupMetadata("redhat.java activation timeout");
+      return false;
+   }
+
+   // on ServiceReady
+   javaExt.exports.onDidServerModeChange(async (mode: string) => {
+      if (mode === "Standard") {
+         daemon.logWatcher.sendStartupMetadata("jdtls standard server ready");
+
+         // watchdog
+         if (await daemon.processWatcher.start()) {
+            daemon.processWatcher.monitor();
+         } else {
+            sendError(new Error("jdtls watchdog is not started"));
+         }
+      }
+   });
+
+   return true;
+}

src/daemon/index.ts

@@ -0,0 +1,141 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as cp from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { promisify } from "util";
+import * as vscode from "vscode";
+import { sendInfo } from "vscode-extension-telemetry-wrapper";
+import { LSDaemon } from "./daemon";
+const execFile = promisify(cp.execFile);
+
+interface IJdtlsMetadata {
+   pid?: string;
+   jreHome?: string;
+   workspace?: string;
+}
+
+
+export class ProcessWatcher {
+   private workspace?: string;
+   private pid?: string;
+   private jreHome?: string;
+   private lastHeartbeat?: string;
+   private context: vscode.ExtensionContext
+   constructor(private daemon: LSDaemon) {
+      this.context = daemon.context;
+   }
+
+   public async start(): Promise<boolean> {
+      const javaExt = vscode.extensions.getExtension("redhat.java");
+      if (!javaExt) {
+         return false;
+      }
+      // get embedded JRE Home
+      let jreHome: string | undefined;
+      try {
+         const jreFolder = path.join(javaExt.extensionPath, "jre");
+         const jreDistros = await fs.promises.readdir(jreFolder);
+         if (jreDistros.length > 0) {
+            jreHome = path.join(jreFolder, jreDistros[0]);
+         }
+      } catch (error) {
+         console.error(error);
+      }
+      if (!jreHome) {
+         return false;
+      }
+      this.jreHome = jreHome;
+
+      const jdtlsmeta = await getPidAndWS(jreHome, this.context);
+      this.pid = jdtlsmeta.pid;
+      this.workspace = jdtlsmeta.workspace;
+
+      return (this.pid !== undefined && this.workspace !== undefined);
+   }
+
+   public monitor() {
+      const id = setInterval(() => {
+         this.upTime().then(seconds => {
+            this.lastHeartbeat = seconds;
+         }).catch(_e => {
+            clearInterval(id);
+            this.onDidJdtlsCrash(this.lastHeartbeat);
+         });
+      }, 5000);
+      // TBD: e.g. constantly monitor heap size and uptime
+   }
+
+   public async upTime(): Promise<string | undefined> {
+      if (!this.jreHome || !this.pid) {
+         throw new Error("unsupported");
+      }
+
+      const execRes = await execFile(path.join(this.jreHome, "bin", "jcmd"), [this.pid, "VM.uptime"]);
+      const r = /\d+\.\d+ s/;
+      return execRes.stdout.match(r)?.toString();
+   }
+
+   public async heapSize(): Promise<string> {
+      if (!this.jreHome || !this.pid) {
+         throw new Error("unsupported");
+      }
+
+      const execRes = await execFile(path.join(this.jreHome, "bin", "jcmd"), [this.pid, "GC.heap_info"]);
+      const ryoung = /PSYoungGen\s+total \d+K, used \d+K/;
+      const y = execRes.stdout.match(ryoung)?.toString();
+
+      const rold = /ParOldGen\s+total \d+K, used \d+K/;
+      const o = execRes.stdout.match(rold)?.toString();
+      return [y, o].join(os.EOL);
+   }
+
+   private onDidJdtlsCrash(lastHeartbeat?: string) {
+      sendInfo("", {
+         name: "jdtls-last-heartbeat",
+         message: lastHeartbeat!
+      });
+      const consentToCollectLogs = vscode.workspace.getConfiguration("java").get<boolean>("help.shareDiagnostics");
+      if (!consentToCollectLogs) {
+         vscode.window.showInformationMessage("Java Language Server is crashed. Do you want to share error logs with us for diagnostic purpose?", "Yes").then(choice => {
+            if (choice) {
+               vscode.workspace.getConfiguration("java").update("help.shareDiagnostics", true);
+               this.daemon.logWatcher.sendErrorAndStackOnCrash();
+            }
+         });
+      }
+   }
+}
+
+
+function parseJdtlsJps(jdtlsJpsLine: string): IJdtlsMetadata {
+   const spaceIdx = jdtlsJpsLine.indexOf(" ");
+   const pid = jdtlsJpsLine.slice(0, spaceIdx);
+   const cmd = jdtlsJpsLine.slice(spaceIdx + 1);
+   const res = cmd.match(/-XX:HeapDumpPath=(.*(redhat.java|vscodesws_[0-9a-f]{5}))/);
+   let workspace;
+   if (res && res[1]) {
+      workspace = res[1];
+   }
+
+   return {
+      pid,
+      workspace
+   };
+}
+
+
+async function getPidAndWS(jreHome: string, context:vscode.ExtensionContext) {
+   const jpsExecRes = await execFile(path.join(jreHome, "bin", "jps"), ["-v"]);
+   const jdtlsLines = jpsExecRes.stdout.split(os.EOL).filter(line => line.includes("org.eclipse.jdt.ls.core"));
+   let jdtlsJpsLine;
+   if (context.storageUri) {
+      jdtlsJpsLine = jdtlsLines.find(line => line.includes(path.dirname(context.storageUri!.fsPath)));
+   } else {
+      jdtlsJpsLine = jdtlsLines.find(line => line.includes("vscodesws_"));
+   }
+
+   return jdtlsJpsLine ? parseJdtlsJps(jdtlsJpsLine) : {};
+}