Extract logger as an interface

Author: award999

lldb/tools/lldb-dap/src-ts/debug-adapter-factory.ts

@@ -5,7 +5,7 @@ import * as child_process from "child_process";
 import * as fs from "node:fs/promises";
 import { ConfigureButton, OpenSettingsButton } from "./ui/show-error-message";
 import { ErrorWithNotification } from "./ui/error-with-notification";
-import { Logger } from "./logger";
+import { LogFilePathProvider, Logger } from "./logger";
 
 const exec = util.promisify(child_process.execFile);
 
@@ -178,13 +178,15 @@ function formatDate(date: Date): string {
  * debug configuration. Assumes that the given debug configuration is for a local launch of lldb-dap.
  *
  * @param logger The {@link Logger} to get default session log location
+ * @param logFilePath The {@link LogFilePathProvider} for determining where to put session logs
  * @param workspaceFolder The {@link vscode.WorkspaceFolder} that the debug session will be launched within
  * @param configuration The {@link vscode.DebugConfiguration} that will be launched
  * @throws An {@link ErrorWithNotification} if something went wrong
  * @returns The {@link vscode.DebugAdapterExecutable} that can be used to launch lldb-dap
  */
 export async function createDebugAdapterExecutable(
   logger: Logger,
+  logFilePath: LogFilePathProvider,
   workspaceFolder: vscode.WorkspaceFolder | undefined,
   configuration: vscode.DebugConfiguration,
 ): Promise<vscode.DebugAdapterExecutable> {
@@ -194,7 +196,7 @@ export async function createDebugAdapterExecutable(
   if (log_path) {
     env["LLDBDAP_LOG"] = log_path;
   } else if (vscode.workspace.getConfiguration("lldb-dap").get("verboseLogging", false)) {
-    env["LLDBDAP_LOG"] = logger.logFilePath(`lldb-dap-session-${formatDate(new Date())}.log`);
+    env["LLDBDAP_LOG"] = logFilePath(`lldb-dap-session-${formatDate(new Date())}.log`);
   }
   const configEnvironment =
     config.get<{ [key: string]: string }>("environment") || {};
@@ -224,7 +226,7 @@ export async function createDebugAdapterExecutable(
 export class LLDBDapDescriptorFactory
   implements vscode.DebugAdapterDescriptorFactory
 {
-  constructor(private readonly logger: Logger) {}
+  constructor(private readonly logger: Logger, private logFilePath: LogFilePathProvider) {}
 
   async createDebugAdapterDescriptor(
     session: vscode.DebugSession,
@@ -251,6 +253,7 @@ export class LLDBDapDescriptorFactory
 
     return createDebugAdapterExecutable(
       this.logger,
+      this.logFilePath,
       session.workspaceFolder,
       session.configuration,
     );

lldb/tools/lldb-dap/src-ts/debug-configuration-provider.ts

@@ -5,7 +5,7 @@ import { LLDBDapServer } from "./lldb-dap-server";
 import { createDebugAdapterExecutable } from "./debug-adapter-factory";
 import { ConfigureButton, showErrorMessage } from "./ui/show-error-message";
 import { ErrorWithNotification } from "./ui/error-with-notification";
-import { Logger } from "./logger";
+import { LogFilePathProvider, Logger } from "./logger";
 
 const exec = util.promisify(child_process.execFile);
 
@@ -72,7 +72,7 @@ const configurations: Record<string, DefaultConfig> = {
 export class LLDBDapConfigurationProvider
   implements vscode.DebugConfigurationProvider
 {
-  constructor(private readonly server: LLDBDapServer, private readonly logger: Logger) {}
+  constructor(private readonly server: LLDBDapServer, private readonly logger: Logger, private readonly logFilePath: LogFilePathProvider) {}
 
   async resolveDebugConfiguration(
     folder: vscode.WorkspaceFolder | undefined,
@@ -156,6 +156,7 @@ export class LLDBDapConfigurationProvider
         // if there are any.
         const executable = await createDebugAdapterExecutable(
           this.logger,
+          this.logFilePath,
           folder,
           debugConfiguration,
         );
@@ -192,7 +193,7 @@ export class LLDBDapConfigurationProvider
 
       return debugConfiguration;
     } catch (error) {
-      this.logger.error(error);
+      this.logger.error(error as Error);
       // Show a better error message to the user if possible
       if (!(error instanceof ErrorWithNotification)) {
         throw error;

lldb/tools/lldb-dap/src-ts/extension.ts

@@ -11,14 +11,14 @@ import {
   ModulesDataProvider,
   ModuleProperty,
 } from "./ui/modules-data-provider";
-import { Logger } from "./logger";
+import { LLDBDAPLogger, LogFilePathProvider } from "./logger";
 
 /**
  * This class represents the extension and manages its life cycle. Other extensions
  * using it as as library should use this class as the main entry point.
  */
 export class LLDBDapExtension extends DisposableContext {
-  constructor(logger: Logger, outputChannel: vscode.OutputChannel) {
+  constructor(logger: LLDBDAPLogger, logFilePath: LogFilePathProvider, outputChannel: vscode.OutputChannel) {
     super();
 
     const lldbDapServer = new LLDBDapServer();
@@ -31,11 +31,11 @@ export class LLDBDapExtension extends DisposableContext {
       sessionTracker,
       vscode.debug.registerDebugConfigurationProvider(
         "lldb-dap",
-        new LLDBDapConfigurationProvider(lldbDapServer, logger),
+        new LLDBDapConfigurationProvider(lldbDapServer, logger, logFilePath),
       ),
       vscode.debug.registerDebugAdapterDescriptorFactory(
         "lldb-dap",
-        new LLDBDapDescriptorFactory(logger),
+        new LLDBDapDescriptorFactory(logger, logFilePath),
       ),
       vscode.debug.registerDebugAdapterTrackerFactory(
         "lldb-dap",
@@ -61,8 +61,9 @@ export class LLDBDapExtension extends DisposableContext {
 export async function activate(context: vscode.ExtensionContext) {
   await vscode.workspace.fs.createDirectory(context.logUri);
   const outputChannel = vscode.window.createOutputChannel("LLDB-DAP");
-  const logger = new Logger((name) => path.join(context.logUri.fsPath, name), outputChannel);
+  const logFilePath: LogFilePathProvider = (name) => path.join(context.logUri.fsPath, name);
+  const logger = new LLDBDAPLogger(logFilePath("lldb-dap-extension.log"), outputChannel);
   logger.info("LLDB-Dap extension activating...");
-  context.subscriptions.push(new LLDBDapExtension(logger, outputChannel));
+  context.subscriptions.push(new LLDBDapExtension(logger, logFilePath, outputChannel));
   logger.info("LLDB-Dap extension activated");
 }

lldb/tools/lldb-dap/src-ts/logger.ts

@@ -13,16 +13,25 @@ class OutputChannelTransport extends Transport {
     }
 }
 
-export class Logger implements vscode.Disposable {
+export type LogFilePathProvider = (name: string) => string;
+
+export interface Logger {
+  debug(message: string, ...args: any[]): void
+  error(error: string | Error, ...args: any[]): void
+  info(message: string, ...args: any[]): void
+  warn(message: string, ...args: any[]): void
+}
+
+export class LLDBDAPLogger implements vscode.Disposable {
     private disposables: vscode.Disposable[] = [];
     private logger: winston.Logger;
 
-    constructor(public readonly logFilePath: (name: string) => string, ouptutChannel: vscode.OutputChannel) {
+    constructor(public readonly logFilePath: string, ouptutChannel: vscode.OutputChannel) {
         const ouptutChannelTransport = new OutputChannelTransport(ouptutChannel);
         ouptutChannelTransport.level = this.outputChannelLevel();
         this.logger = winston.createLogger({
             transports: [
-                new winston.transports.File({ filename: logFilePath("lldb-dap-extension.log"), level: "debug" }), // File logging at the 'debug' level
+                new winston.transports.File({ filename: logFilePath, level: "debug" }), // File logging at the 'debug' level
                 ouptutChannelTransport
             ],
             format: winston.format.combine(
@@ -48,24 +57,25 @@ export class Logger implements vscode.Disposable {
         );
     }
 
-    debug(message: any) {
-        this.logger.debug(this.normalizeMessage(message));
+    debug(message: string, ...args: any[]) {
+        this.logger.debug([message, ...args].map(m => this.normalizeMessage(m)).join(" "));
     }
 
-    info(message: any) {
-        this.logger.info(this.normalizeMessage(message));
+    info(message: string, ...args: any[]) {
+        this.logger.info([message, ...args].map(m => this.normalizeMessage(m)).join(" "));
     }
 
-    warn(message: any) {
-        this.logger.warn(this.normalizeMessage(message));
+    warn(message: string, ...args: any[]) {
+        this.logger.warn([message, ...args].map(m => this.normalizeMessage(m)).join(" "));
     }
 
-    error(message: any) {
+    error(message: Error | string, ...args: any[]) {
         if (message instanceof Error) {
             this.logger.error(message);
+            this.logger.error([...args].map(m => this.normalizeMessage(m)).join(" "));
             return;
         }
-        this.logger.error(this.normalizeMessage(message));
+        this.logger.error([message, ...args].map(m => this.normalizeMessage(m)).join(" "));
     }
 
     private normalizeMessage(message: any) {