src/utils/Logger.ts

/*
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */
import chalk from "chalk";
import Client from "../core/Client";
import { AnyFunction } from "../types/Utils";
import { developmentMode } from "./utils";

export enum LogLevel {
    Debug,
    Info,
    Warn,
    Error,
    Fatal,
    Critical,
    Success,
    Event
}

export class Logger {
    private readonly formatter = Intl.DateTimeFormat("en-US", {
        dateStyle: "long",
        timeStyle: "long"
    });

    public constructor(private readonly name: string, private readonly logTime: boolean = false) {
        for (const key in this) {
            if (typeof this[key] === "function") {
                (this[key] as AnyFunction) = (this[key] as AnyFunction).bind(this);
            }
        }
    }

    public log(level: LogLevel, ...args: unknown[]) {
        const levelName = LogLevel[level].toLowerCase();
        const methodName =
            level === LogLevel.Info || level === LogLevel.Success || level === LogLevel.Event
                ? "info"
                : level === LogLevel.Debug
                ? "debug"
                : level === LogLevel.Warn
                ? "warn"
                : "error";
        const beginning = `${
            this.logTime ? `${chalk.gray(this.formatter.format(new Date()))} ` : ""
        }${this.colorize(`${this.name}:${levelName}`, level)}`;
        this.print(methodName, beginning, ...args);

        if (level === LogLevel.Fatal) {
            console.log("Critical error occurred. Exiting.");
            process.exit(-1);
        }
    }

    public print(methodName: "log" | "info" | "warn" | "error" | "debug", ...args: unknown[]) {
        const logServerEnabled = Client.instance?.configManager?.systemConfig?.log_server?.enabled;

        if (process.env.SUPRESS_LOGS) {
            return;
        }

        console[methodName].call(console, ...args);
        const message = args
            .map(arg => (typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)))
            .join(" ");

        if (logServerEnabled) {
            Client.instance.logServer?.log(message);
        }
    }

    private colorize(text: string, level: LogLevel) {
        switch (level) {
            case LogLevel.Debug:
                return chalk.gray.dim(text);

            case LogLevel.Critical:
            case LogLevel.Fatal:
                return chalk.redBright(text);

            case LogLevel.Error:
                return chalk.red(text);

            case LogLevel.Warn:
                return chalk.yellowBright(text);

            case LogLevel.Info:
                return chalk.blueBright(text);

            case LogLevel.Success:
            case LogLevel.Event:
                return chalk.greenBright(text);
        }
    }

    public debug(...args: unknown[]) {
        if (!developmentMode()) {
            return;
        }

        this.log(LogLevel.Debug, ...args);
    }

    public info(...args: unknown[]) {
        this.log(LogLevel.Info, ...args);
    }

    public warn(...args: unknown[]) {
        this.log(LogLevel.Warn, ...args);
    }

    public error(...args: unknown[]) {
        this.log(LogLevel.Error, ...args);
    }

    public fatal(...args: unknown[]) {
        this.log(LogLevel.Fatal, ...args);
    }

    public critical(...args: unknown[]) {
        this.log(LogLevel.Critical, ...args);
    }

    public success(...args: unknown[]) {
        this.log(LogLevel.Success, ...args);
    }

    public event(...args: unknown[]) {
        this.log(LogLevel.Event, ...args);
    }
}

/**
 * Logs a debug message to the console.
 *
 * @deprecated Use the logger instance instead.
 */
export const logDebug = (...args: unknown[]) => Client.getLogger().debug(...args);

/**
 * Alias of logDebug.
 *
 * @deprecated Use the logger instance instead.
 */
export const log = logDebug;

/**
 * Logs an info message to the console.
 *
 * @deprecated Use the logger instance instead.
 */
export const logInfo = (...args: unknown[]) => Client.getLogger().info(...args);

/**
 * Logs a warning to the console.
 *
 * @deprecated Use the logger instance instead.
 */
export const logWarn = (...args: unknown[]) => Client.getLogger().warn(...args);

/**
 * Logs an error to the console.
 *
 * @deprecated Use the logger instance instead.
 */

export const logError = (...args: unknown[]) => Client.getLogger().error(...args);

/**
 * Logs a fatal error to the console and exits the process.
 *
 * @deprecated Use the logger instance instead.
 */

export const logFatal = (...args: unknown[]) => Client.getLogger().fatal(...args);

/**
 * Logs a critical error to the console.
 *
 * @deprecated Use the logger instance instead.
 */

export const logCritical = (...args: unknown[]) => Client.getLogger().critical(...args);

/**
 * Logs a success message to the console.
 *
 * @deprecated Use the logger instance instead.
 */

export const logSuccess = (...args: unknown[]) => Client.getLogger().success(...args);

/**
 * Logs an event message to the console.
 *
 * @deprecated Use the logger instance instead.
 */

export const logEvent = (...args: unknown[]) => Client.getLogger().event(...args);

/**
 * Logs a message to the console with a specified log level.
 *
 * @deprecated Use the logger instance instead.
 */

export const logWithLevel = (level: LogLevel, ...args: unknown[]) =>
    Client.getLogger().log(level, ...args);
1	rakinar2	577	/*
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19			import chalk from "chalk";
20			import Client from "../core/Client";
21			import { AnyFunction } from "../types/Utils";
22			import { developmentMode } from "./utils";
23
24			export enum LogLevel {
25			Debug,
26			Info,
27			Warn,
28			Error,
29			Fatal,
30			Critical,
31			Success,
32			Event
33			}
34
35			export class Logger {
36			private readonly formatter = Intl.DateTimeFormat("en-US", {
37			dateStyle: "long",
38			timeStyle: "long"
39			});
40
41			public constructor(private readonly name: string, private readonly logTime: boolean = false) {
42			for (const key in this) {
43			if (typeof this[key] === "function") {
44			(this[key] as AnyFunction) = (this[key] as AnyFunction).bind(this);
45			}
46			}
47			}
48
49			public log(level: LogLevel, ...args: unknown[]) {
50			const levelName = LogLevel[level].toLowerCase();
51			const methodName =
52			level === LogLevel.Info \|\| level === LogLevel.Success \|\| level === LogLevel.Event
53			? "info"
54			: level === LogLevel.Debug
55			? "debug"
56			: level === LogLevel.Warn
57			? "warn"
58			: "error";
59			const beginning = `${
60			this.logTime ? `${chalk.gray(this.formatter.format(new Date()))} ` : ""
61			}${this.colorize(`${this.name}:${levelName}`, level)}`;
62			this.print(methodName, beginning, ...args);
63
64			if (level === LogLevel.Fatal) {
65			console.log("Critical error occurred. Exiting.");
66			process.exit(-1);
67			}
68			}
69
70			public print(methodName: "log" \| "info" \| "warn" \| "error" \| "debug", ...args: unknown[]) {
71			const logServerEnabled = Client.instance?.configManager?.systemConfig?.log_server?.enabled;
72
73			if (process.env.SUPRESS_LOGS) {
74			return;
75			}
76
77			console[methodName].call(console, ...args);
78			const message = args
79			.map(arg => (typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)))
80			.join(" ");
81
82			if (logServerEnabled) {
83			Client.instance.logServer?.log(message);
84			}
85			}
86
87			private colorize(text: string, level: LogLevel) {
88			switch (level) {
89			case LogLevel.Debug:
90			return chalk.gray.dim(text);
91
92			case LogLevel.Critical:
93			case LogLevel.Fatal:
94			return chalk.redBright(text);
95
96			case LogLevel.Error:
97			return chalk.red(text);
98
99			case LogLevel.Warn:
100			return chalk.yellowBright(text);
101
102			case LogLevel.Info:
103			return chalk.blueBright(text);
104
105			case LogLevel.Success:
106			case LogLevel.Event:
107			return chalk.greenBright(text);
108			}
109			}
110
111			public debug(...args: unknown[]) {
112			if (!developmentMode()) {
113			return;
114			}
115
116			this.log(LogLevel.Debug, ...args);
117			}
118
119			public info(...args: unknown[]) {
120			this.log(LogLevel.Info, ...args);
121			}
122
123			public warn(...args: unknown[]) {
124			this.log(LogLevel.Warn, ...args);
125			}
126
127			public error(...args: unknown[]) {
128			this.log(LogLevel.Error, ...args);
129			}
130
131			public fatal(...args: unknown[]) {
132			this.log(LogLevel.Fatal, ...args);
133			}
134
135			public critical(...args: unknown[]) {
136			this.log(LogLevel.Critical, ...args);
137			}
138
139			public success(...args: unknown[]) {
140			this.log(LogLevel.Success, ...args);
141			}
142
143			public event(...args: unknown[]) {
144			this.log(LogLevel.Event, ...args);
145			}
146			}
147
148			/**
149			* Logs a debug message to the console.
150			*
151			* @deprecated Use the logger instance instead.
152			*/
153			export const logDebug = (...args: unknown[]) => Client.getLogger().debug(...args);
154
155			/**
156			* Alias of logDebug.
157			*
158			* @deprecated Use the logger instance instead.
159			*/
160			export const log = logDebug;
161
162			/**
163			* Logs an info message to the console.
164			*
165			* @deprecated Use the logger instance instead.
166			*/
167			export const logInfo = (...args: unknown[]) => Client.getLogger().info(...args);
168
169			/**
170			* Logs a warning to the console.
171			*
172			* @deprecated Use the logger instance instead.
173			*/
174			export const logWarn = (...args: unknown[]) => Client.getLogger().warn(...args);
175
176			/**
177			* Logs an error to the console.
178			*
179			* @deprecated Use the logger instance instead.
180			*/
181
182			export const logError = (...args: unknown[]) => Client.getLogger().error(...args);
183
184			/**
185			* Logs a fatal error to the console and exits the process.
186			*
187			* @deprecated Use the logger instance instead.
188			*/
189
190			export const logFatal = (...args: unknown[]) => Client.getLogger().fatal(...args);
191
192			/**
193			* Logs a critical error to the console.
194			*
195			* @deprecated Use the logger instance instead.
196			*/
197
198			export const logCritical = (...args: unknown[]) => Client.getLogger().critical(...args);
199
200			/**
201			* Logs a success message to the console.
202			*
203			* @deprecated Use the logger instance instead.
204			*/
205
206			export const logSuccess = (...args: unknown[]) => Client.getLogger().success(...args);
207
208			/**
209			* Logs an event message to the console.
210			*
211			* @deprecated Use the logger instance instead.
212			*/
213
214			export const logEvent = (...args: unknown[]) => Client.getLogger().event(...args);
215
216			/**
217			* Logs a message to the console with a specified log level.
218			*
219			* @deprecated Use the logger instance instead.
220			*/
221
222			export const logWithLevel = (level: LogLevel, ...args: unknown[]) =>
223			Client.getLogger().log(level, ...args);