Add initial logger

Author: nojaf

package.json

@@ -233,6 +233,12 @@
           "type": "boolean",
           "default": true,
           "description": "Show compile status in the status bar (compiling/errors/warnings/success)."
+        },
+        "rescript.settings.logLevel": {
+          "type": "string",
+          "enum": ["error", "warn", "info", "log", "debug"],
+          "default": "info",
+          "description": "Verbosity of ReScript language server logs sent to the Output channel."
         }
       }
     },

server/src/config.ts

@@ -4,6 +4,7 @@ export type send = (msg: Message) => void;
 
 export interface extensionConfiguration {
   askToStartBuild?: boolean;
+  logLevel?: "error" | "warn" | "info" | "log";
   inlayHints?: {
     enable?: boolean;
     maxLength?: number | null;
@@ -33,6 +34,7 @@ export interface extensionConfiguration {
 let config: { extensionConfiguration: extensionConfiguration } = {
   extensionConfiguration: {
     askToStartBuild: true,
+    logLevel: "info",
     inlayHints: {
       enable: false,
       maxLength: 25,

server/src/logger.ts

@@ -0,0 +1,89 @@
+import * as p from "vscode-languageserver-protocol";
+import * as c from "./constants";
+
+export type LogLevel = "error" | "warn" | "info" | "log";
+
+const levelOrder: Record<LogLevel, number> = {
+  log: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+};
+
+export interface Logger {
+  error(message: string): void;
+  warn(message: string): void;
+  info(message: string): void;
+  log(message: string): void;
+}
+
+class NoOpLogger implements Logger {
+  error(_message: string): void {}
+  warn(_message: string): void {}
+  info(_message: string): void {}
+  log(_message: string): void {}
+}
+
+class LSPLogger implements Logger {
+  private logLevel: LogLevel = "info";
+
+  constructor(private send: (msg: p.Message) => void) {}
+
+  setLogLevel(level: LogLevel): void {
+    this.logLevel = level;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return levelOrder[level] >= levelOrder[this.logLevel];
+  }
+
+  error(message: string): void {
+    if (this.shouldLog("error")) {
+      this.sendLogMessage(message, p.MessageType.Error);
+    }
+  }
+
+  warn(message: string): void {
+    if (this.shouldLog("warn")) {
+      this.sendLogMessage(message, p.MessageType.Warning);
+    }
+  }
+
+  info(message: string): void {
+    if (this.shouldLog("info")) {
+      this.sendLogMessage(message, p.MessageType.Info);
+    }
+  }
+
+  log(message: string): void {
+    if (this.shouldLog("log")) {
+      this.sendLogMessage(message, p.MessageType.Log);
+    }
+  }
+
+  private sendLogMessage(message: string, type: p.MessageType): void {
+    const notification: p.NotificationMessage = {
+      jsonrpc: c.jsonrpcVersion,
+      method: "window/logMessage",
+      params: { type, message },
+    };
+    this.send(notification);
+  }
+}
+
+// Default no-op instance
+let instance: Logger = new NoOpLogger();
+
+export function initializeLogger(send: (msg: p.Message) => void): void {
+  instance = new LSPLogger(send);
+}
+
+export function setLogLevel(level: LogLevel): void {
+  if (instance instanceof LSPLogger) {
+    instance.setLogLevel(level);
+  }
+}
+
+export function getLogger(): Logger {
+  return instance;
+}

server/src/server.ts

@@ -29,6 +29,7 @@ import * as ic from "./incrementalCompilation";
 import config, { extensionConfiguration } from "./config";
 import { projectsFiles } from "./projectFiles";
 import { NormalizedPath } from "./utils";
+import { initializeLogger, getLogger, setLogLevel, LogLevel } from "./logger";
 
 // Absolute paths to all the workspace folders
 // Configured during the initialize request
@@ -548,10 +549,12 @@ export default function listen(useStdio = false) {
     let reader = new rpc.StreamMessageReader(process.stdin);
     // proper `this` scope for writer
     send = (msg: p.Message) => writer.write(msg);
+    initializeLogger(send);
     reader.listen(onMessage);
   } else {
     // proper `this` scope for process
     send = (msg: p.Message) => process.send!(msg);
+    initializeLogger(send);
     process.on("message", onMessage);
   }
 }
@@ -1453,6 +1456,7 @@ async function onMessage(msg: p.Message) {
       };
       send(response);
     } else if (msg.method === "initialize") {
+      getLogger().info("Received initialize request from client.");
       // Save initial configuration, if present
       let initParams = msg.params as InitializeParams;
       for (const workspaceFolder of initParams.workspaceFolders || []) {
@@ -1465,6 +1469,19 @@ async function onMessage(msg: p.Message) {
 
       if (initialConfiguration != null) {
         config.extensionConfiguration = initialConfiguration;
+
+        let initialLogLevel = initialConfiguration.logLevel as
+          | LogLevel
+          | undefined;
+
+        if (
+          initialLogLevel === "error" ||
+          initialLogLevel === "warn" ||
+          initialLogLevel === "info" ||
+          initialLogLevel === "log"
+        ) {
+          setLogLevel(initialLogLevel);
+        }
       }
 
       // These are static configuration options the client can set to enable certain