logger.ts

Go to the documentation of this file.

 
import * as vscode from 'vscode';
import { CodeConfig } from "./processConfiguration";
import { moduleName } from '../constants';
 
class LoggerInternals {
    constructor() { }
 
    getCorrectPrefix(info: boolean, warning: boolean, error: boolean, debug: boolean): string {
        if (info) {
            return "INFO: ";
        } else if (warning) {
            return "WARNING: ";
        } else if (error) {
            return "ERROR: ";
        } else if (debug) {
            return "DEBUG: ";
        } else {
            return "";
        }
    }
 
    getDatetime(): string {
        let date: Date = new Date();
        let finalString: string = "[";
        finalString += date.getDate() + "-";
        finalString += (date.getMonth() + 1) + "-";
        finalString += date.getFullYear() + " ";
        finalString += date.getHours() + ":";
        finalString += date.getMinutes() + ":";
        finalString += date.getSeconds() + ".";
        finalString += date.getMilliseconds();
        finalString += "]";
        return finalString;
    }
 
    getParentCaller(searchDepth: number = 2): string | undefined {
        const stack = new Error().stack;
        if (!stack) {
            return undefined;
        }
 
        const lines = stack.split("\n").map(line => line.trim());
 
        // Ensure the requested search depth exists in the stack
        if (lines.length > searchDepth) {
            const match = lines[searchDepth].match(/at (\w+)/);
            if (match) {
                return match[1];
            }
        }
 
        return undefined;
    }
 
    debugEnabled(): boolean {
        return CodeConfig.get("enableDebug");
    }
 
    checkIfExtensionInstalled(context: vscode.ExtensionContext | undefined): boolean {
        if (context === undefined) {
            return process.env.VSCODE_DEBUG_MODE?.toLocaleLowerCase() === 'true';
        }
        if (context.extensionMode === vscode.ExtensionMode.Development) {
            console.log("Running in debug/development mode");
            return false;
        } else if (context.extensionMode === vscode.ExtensionMode.Test) {
            console.log("Running in test mode");
            return false;
        } else {
            console.log("Running in production (installed) mode");
            return true;
        }
    }
 
    packageForUnsafe(message: string, info: boolean, warning: boolean, error: boolean, debug: boolean): string {
        const datetime: string = this.getDatetime();
        const correctPrefix: string = this.getCorrectPrefix(info, warning, error, debug);
        return `${datetime} ${moduleName}:initialising ${correctPrefix} '${message}'`;
    }
}
 
class Gui {
    private LI: LoggerInternals;
    private fullyLoaded: boolean = false;
 
    constructor(loggerInternals: LoggerInternals, fullyLoaded: boolean = false) {
        this.LI = loggerInternals;
        this.fullyLoaded = fullyLoaded;
    }
 
    updateLoadStatus(fullyLoaded: boolean = true): void {
        this.fullyLoaded = fullyLoaded;
    }
    info<T extends string>(message: string, ...items: T[]): Thenable<T | undefined> {
        if (!this.fullyLoaded) {
            console.log(this.LI.packageForUnsafe(message, true, false, false, false));
            return Promise.resolve(undefined);
        }
        let final: string = "";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(true, false, false, false);
        final += " '" + message + "'";
        return vscode.window.showInformationMessage<T>(message, ...items);
    }
 
    warning<T extends string>(message: string, ...items: T[]): Thenable<T | undefined> {
        if (!this.fullyLoaded) {
            console.warn(this.LI.packageForUnsafe(message, false, true, false, false));
            return Promise.resolve(undefined);
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(false, true, false, false);
        final += " '" + message + "'";
        return vscode.window.showWarningMessage<T>(message, ...items);
    }
 
    error<T extends string>(message: string, ...items: T[]): Thenable<T | undefined> {
        if (!this.fullyLoaded) {
            console.error(this.LI.packageForUnsafe(message, false, false, true, false));
            return Promise.resolve(undefined);
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(false, false, true, false);
        final += " '" + message + "'";
        return vscode.window.showErrorMessage<T>(message, ...items);
    }
 
    debug<T extends string>(message: string, ...items: T[]): Thenable<T | undefined> {
        if (!this.fullyLoaded) {
            return Promise.resolve(undefined);
        }
        if (!this.LI.debugEnabled()) {
            console.log(this.LI.packageForUnsafe(message, false, false, false, true));
            return Promise.resolve(undefined);
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(false, false, false, true);
        final += " '" + message + "'";
        return vscode.window.showInformationMessage<T>(final, ...items);
    }
}
 
class Log {
    private depthSearch: number = 3;
    private LI: LoggerInternals = new LoggerInternals();
    public Gui: Gui = new Gui(this.LI);
    private extensionInstalled: boolean = false;
    private fullyLoaded: boolean = false;
    private output: vscode.OutputChannel | undefined = undefined;
 
    constructor(context: vscode.ExtensionContext | undefined = undefined, fullyLoaded: boolean = false) {
        this.extensionInstalled = this.LI.checkIfExtensionInstalled(context);
        this.updateInitialisationStatus(fullyLoaded);
    }
 
    updateInitialisationStatus(extensionLoaded: boolean = true): void {
        if (extensionLoaded) {
            this.fullyLoaded = extensionLoaded;
            this.Gui.updateLoadStatus(this.fullyLoaded);
            this.output = vscode.window.createOutputChannel(CodeConfig.get("moduleName"));
            if (!this.extensionInstalled) {
                this.output.show();
            }
        } else {
            this.fullyLoaded = false;
            this.Gui.updateLoadStatus(this.fullyLoaded);
            if (this.output) {
                this.output.dispose();
                this.output = undefined;
            }
        }
    }
 
    updateInstallationState(context: vscode.ExtensionContext | undefined) {
        this.info(`In updateInstallationState`);
        this.extensionInstalled = this.LI.checkIfExtensionInstalled(context);
        this.info(`extensionInstalled = ${this.extensionInstalled}`);
        this.info("Out of updateInstallationState");
    }
    info(message: string, searchDepth: number | undefined = undefined) {
        if (!this.output) {
            console.log(this.LI.packageForUnsafe(message, true, false, false, false));
            return;
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(true, false, false, false);
        final += " <" + this.LI.getParentCaller(searchDepth || this.depthSearch) + ">";
        final += " '" + message + "'";
        this.output.appendLine(final);
        if (!this.extensionInstalled) {
            console.log(final);
        }
    }
 
    warning(message: string, searchDepth: number | undefined = undefined) {
        if (!this.output) {
            console.warn(this.LI.packageForUnsafe(message, false, true, false, false));
            return;
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(false, true, false, false);
        final += " <" + this.LI.getParentCaller(searchDepth || this.depthSearch) + ">";
        final += " '" + message + "'";
        this.output.appendLine(final);
        if (!this.extensionInstalled) {
            console.warn(final);
        }
    }
 
    error(message: string, searchDepth: number | undefined = undefined) {
        if (!this.output) {
            console.error(this.LI.packageForUnsafe(message, false, false, true, false));
            return;
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(false, false, true, false);
        final += " <" + this.LI.getParentCaller(searchDepth || this.depthSearch) + ">";
        final += " '" + message + "'";
        this.output.appendLine(final);
        if (!this.extensionInstalled) {
            console.error(final);
        }
    }
 
    debug(message: string, searchDepth: number | undefined = undefined) {
        if (this.LI.debugEnabled() === false) {
            return;
        }
        if (!this.output) {
            console.log(this.LI.packageForUnsafe(message, false, false, false, true));
            return;
        }
        let final: string = "";
        final += this.LI.getDatetime() + " ";
        final += CodeConfig.get("extensionName") + " ";
        final += this.LI.getCorrectPrefix(false, false, false, true);
        final += " <" + this.LI.getParentCaller(searchDepth || this.depthSearch) + ">";
        final += " '" + message + "'";
        this.output.appendLine(final);
        if (!this.extensionInstalled) {
            console.debug(final);
        }
    }
}
 
const instance = new Log();
 
export const logger: Log = instance;
 
export type LogType = Log;