@warlock.js/logger 1.0.0

package/README.md

@@ -0,0 +1,381 @@
+# Warlock Logger
+
+A powerful yet simple logger for Node.js
+
+## Features
+
+- Fully async and non-blocking which doesn't affect the performance of your application.
+- Easy to use and configure.
+- Has multiple channels to log the messages to.
+- You can add your own custom channels for logging.
+
+## Installation
+
+`yarn add @warlock.js/logger`
+
+Or
+
+`npm i @warlock.js/logger`
+
+## Usage
+
+At an early point of the application, you need to initialize the logger:
+
+```ts
+import logger, { FileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [new FileLog(), new ConsoleLog()],
+});
+```
+
+Here we declared our logger configurations to use the `FileLog` and `ConsoleLog` channels, the file log channel will log all the logs to a file, and the console log channel will log all the logs to the console.
+
+## Logging Strategy
+
+To go any value simple use `log` function, it mainly receives 4 parameters:
+
+- `module`: the module name, it's used to group the logs, for example, if you have a module called `request`, all the logs related to the request module will be grouped under the `request` module.
+- `action`: the action name, it's used to group the logs, for example, if you have an action called `create`, all the logs related to the `create` action will be grouped under the `create` action.
+- `message`: the message to log.
+- `level`: there are 4 types of logging `warn`, `info`, `error`, `debug`, the default is `info`.
+
+## Examples
+
+```ts
+import { log } from "@warlock.js/logger";
+
+log("request", "create", "user created successfully", "info");
+```
+
+You can also use `log.info` `log.warn` `log.error` `log.debug` functions to log the message.
+
+```ts
+import { log } from "@warlock.js/logger";
+
+log.info("request", "create", "user created successfully");
+
+if (somethingWentWrong) {
+  log.error("request", "create", "something went wrong");
+}
+
+database.on("connection", () => {
+  log.success("database", "connection", "database connected successfully");
+});
+```
+
+## Console Log Channel
+
+The console log channel will log all the logs to the console, the message appears in the console will be colored based on the log level using [chalk](https://www.npmjs.com/package/chalk).
+
+```ts
+import logger, { ConsoleLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [new ConsoleLog()],
+});
+```
+
+## File Log Channel
+
+The file log channel will log all the logs to a **single file**, the file will be created in the `logs` directory in `/storage` directory with name `app` by default, and extension is set to `log` however, you can change the file name and the directory path.
+
+```ts
+import logger, { FileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [
+    new FileLog({
+      storageDirectory: process.cwd() + "/logs",
+      fileName: "app",
+      extension: "log",
+    }),
+  ],
+});
+```
+
+The message time is stored by default prefixed with current date/time in this format `YYYY-MM-DD HH:mm:ss`, however, you can change the format by passing the `dateFormat` option.
+
+```ts
+import logger, { FileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [
+    new FileLog({
+      dateFormat: {
+        date: "DD-MM-YYYY",
+        time: "HH:mm:ss",
+      },
+    }),
+  ],
+});
+```
+
+> You can see the available date/time formats in [dayjs](https://day.js.org/docs/en/display/format) documentation.
+
+This could be useful with small projects, but it's not recommended to use it if the application is large, because the file will be very large and it will affect the performance of the application, you can use the following channels to solve this problem.
+
+## Chunk mode Log Channel
+
+In the file log channel, there are three types of chunk modes:
+
+1. `single`: this is the default mode, all the logs will be stored in a single file.
+2. `daily`: the logs will be stored in a file based on the date, for example, if the date is `2021-01-01`, the file name will be `2021-01-01.log`.
+3. `hourly`: the logs will be stored in a file based on the date and hour, for example, if the hour is `14`, the file name will be `2021-01-01-14.log`.
+
+> Please note the hourly mode is set to 24 hours mode.
+
+```ts
+import logger, { ChunkFileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [
+    new ChunkFileLog({
+      chunk: "daily", // default is single
+    }),
+  ],
+});
+```
+
+For better performance, the file will be created in the `logs` directory in `/storage`, each file will be named based on the date, for example, if the date is `2021-01-01`, the file name will be `2021-01-01.log`, and the message time is stored by default prefixed with current date/time in this format `YYYY-MM-DD HH:mm:ss`, however, you can change the format by passing the `dateFormat` option.
+
+## JSON File Log Channel
+
+Works exactly in the same sense of [File Log Channel](#file-log-channel), but the difference is that the logs will be stored in JSON format.
+
+```ts
+import logger, { JSONFileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [new JSONFileLog()],
+});
+```
+
+Example of output log file
+
+`/storage/logs/01-04-2023.json`
+
+```json
+{
+  "messages": [
+    {
+      "module": "request",
+      "action": "create",
+      "message": "user created successfully",
+      "level": "info",
+      "date": "01-04-2023",
+      "time": "12:00:00"
+    }
+  ]
+}
+```
+
+If the log is an `error` log, the trace will also be included:
+
+`/storage/logs/01-04-2023.json`
+
+```json
+{
+  "date": "01-04-2023",
+  "logs": [
+    {
+      "module": "request",
+      "action": "create",
+      "message": "user created successfully",
+      "level": "error",
+      "date": "01-04-2023",
+      "time": "12:00:00",
+      "trace": "Error: something went wrong...."
+    }
+  ]
+}
+```
+
+## Group Log Channel by level, module or action
+
+Another way to reduce file sizes is to group the logs by level, module, or action, you can use the `groupBy` option to group the logs.
+
+The files in this case will be added in folders with the grouped names, for example, if the group is `level`, the files will be added in folders with the names `info`, `warn`, `error`, and `debug`.
+
+```ts
+import logger, { FileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [
+    new FileLog({
+      groupBy: ["level"],
+    }),
+  ],
+});
+```
+
+This will create the following structure:
+
+```
+logs
+├── info
+│   └── app.log
+├── warn
+│   └── app.log
+├── error
+│   └── app.log
+├── debug
+│   └── app.log
+├── success
+│   └── app.log
+```
+
+If the group is `module`, the files will be added in folders with the module names.
+
+```ts
+import logger, { FileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [
+    new FileLog({
+      groupBy: ["module"],
+    }),
+  ],
+});
+```
+
+This will create the following structure:
+
+```
+logs
+├── request
+│   └── app.log
+├── database
+│   └── app.log
+```
+
+### Group by multiple options
+
+You can group the logs by multiple options, for example, if you want to group the logs by `level` and `module`, you can pass the options
+
+```ts
+import logger, { FileLog } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [
+    new FileLog({
+      groupBy: ["level", "module"],
+    }),
+  ],
+});
+```
+
+This will create the following structure:
+
+```
+logs
+├── info
+│   ├── request
+│   │   └── app.log
+...
+```
+
+> The order you set in the groupBy array will be the order of the folders.
+
+## Create Custom Log Channel
+
+You can create your own log channel by extending the `LogChannel` class
+
+```ts
+import { type LogContract, LogChannel, LogLevel } from "@warlock.js/logger";
+
+export default class CustomLogChannel
+  extends LogChannel
+  implements LogContract
+{
+  /**
+   * Channel name
+   */
+  public name = "custom";
+
+  /**
+   * Log the message
+   *
+   * @param module
+   * @param action
+   * @param message
+   * @param level
+   */
+  public async log(
+    module: string,
+    action: string,
+    message: string,
+    level: LogLevel
+  ) {
+    // log the message
+  }
+}
+```
+
+If the log channel will output something in the terminal, mark the `terminal` property as `true`.
+
+```ts
+import { type LogContract, LogChannel, LogLevel } from "@warlock.js/logger";
+
+export default class CustomLogChannel
+  extends LogChannel
+  implements LogContract
+{
+  /**
+   * Whether the log channel will output something in the terminal
+   */
+  public terminal = true;
+
+  /**
+   * Channel name
+   */
+  public name = "custom";
+
+  /**
+   * Log the message
+   *
+   * @param module
+   * @param action
+   * @param message
+   * @param level
+   */
+  public async log(
+    module: string,
+    action: string,
+    message: string,
+    level: LogLevel
+  ) {
+    // log the message
+  }
+}
+```
+
+This will automatically parse and remove the ANSI color codes from the message.
+
+Now you can use the custom log channel in your application.
+
+```ts
+import logger, { CustomLogChannel } from "@warlock.js/logger";
+
+logger.configure({
+  channels: [new CustomLogChannel()],
+});
+```
+
+## Capture Uncaught Errors
+
+If you want automatically capture any unhandled errors, you can import `captureAnyUnhandledRejection` helper function and call it in your application entry point.
+
+```ts
+import { captureAnyUnhandledRejection } from "@warlock.js/logger";
+
+captureAnyUnhandledRejection();
+```
+
+## Tests
+
+To run the tests, you need to run the following command:
+
+```bash
+yarn test
+```

package/cjs/LogChannel.d.ts

@@ -0,0 +1,20 @@
+import { LogContract, LogLevel } from "./types";
+export declare abstract class LogChannel implements LogContract {
+    /**
+     * Channel name
+     */
+    name: string;
+    /**
+     * Channel description
+     */
+    description?: string;
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal: boolean;
+    /**
+     * Log the given message
+     */
+    abstract log(module: string, action: string, message: any, level: LogLevel): void | Promise<void>;
+}
+//# sourceMappingURL=LogChannel.d.ts.map

package/cjs/LogChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogChannel.d.ts","sourceRoot":"","sources":["../src/LogChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhD,8BAAsB,UAAW,YAAW,WAAW;IACrD;;OAEG;IACI,IAAI,EAAG,MAAM,CAAC;IAErB;;OAEG;IACI,WAAW,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACI,QAAQ,UAAS;IAExB;;OAEG;aACa,GAAG,CACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,GAAG,EACZ,KAAK,EAAE,QAAQ,GACd,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CACxB"}

package/cjs/LogChannel.js

@@ -0,0 +1,14 @@
+'use strict';class LogChannel {
+    /**
+     * Channel name
+     */
+    name;
+    /**
+     * Channel description
+     */
+    description;
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal = false;
+}exports.LogChannel=LogChannel;//# sourceMappingURL=LogChannel.js.map

package/cjs/LogChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogChannel.js","sources":["../src/LogChannel.ts"],"sourcesContent":[null],"names":[],"mappings":"mBAEsB,UAAU,CAAA;AAC9B;;AAEG;AACI,IAAA,IAAI,CAAU;AAErB;;AAEG;AACI,IAAA,WAAW,CAAU;AAE5B;;AAEG;IACI,QAAQ,GAAG,KAAK,CAAC;AAWzB"}

package/cjs/channels/console-log.d.ts

@@ -0,0 +1,17 @@
+import { LogChannel } from "../LogChannel";
+import { LogLevel } from "../types";
+export declare class ConsoleLog extends LogChannel {
+    /**
+     * {@inheritdoc}
+     */
+    name: string;
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal: boolean;
+    /**
+     * {@inheritdoc}
+     */
+    log(module: string, action: string, message: any, level: LogLevel): void;
+}
+//# sourceMappingURL=console-log.d.ts.map

package/cjs/channels/console-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-log.d.ts","sourceRoot":"","sources":["../../src/channels/console-log.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,qBAAa,UAAW,SAAQ,UAAU;IACxC;;OAEG;IACI,IAAI,SAAa;IAExB;;OAEG;IACI,QAAQ,UAAQ;IAEvB;;OAEG;IACI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ;CAsEzE"}

package/cjs/channels/console-log.js

@@ -0,0 +1,44 @@
+'use strict';var copper=require('@mongez/copper'),LogChannel=require('../LogChannel.js');class ConsoleLog extends LogChannel.LogChannel {
+    /**
+     * {@inheritdoc}
+     */
+    name = "console";
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal = true;
+    /**
+     * {@inheritdoc}
+     */
+    log(module, action, message, level) {
+        // display date and time with milliseconds
+        const date = new Date().toISOString(); // i.e 2021-01-01T00:00:00.000Z
+        switch (level) {
+            case "debug":
+                // add a debug icon
+                console.log(copper.colors.magentaBright("⚙"), copper.colors.yellow(`(${date})`), copper.colors.cyan(`[${module}]`), copper.colors.magenta(`[${action}]`), copper.colors.magentaBright(message));
+                break;
+            case "info":
+                // add an info icon
+                console.log(copper.colors.blueBright("ℹ"), copper.colors.yellow(`(${date})`), copper.colors.cyan(`[${module}]`), copper.colors.magenta(`[${action}]`), copper.colors.blueBright(message));
+                break;
+            case "warn":
+                // add a warning icon
+                console.log(copper.colors.yellow("⚠"), copper.colors.green(`(${date})`), copper.colors.cyan(`[${module}]`), copper.colors.magenta(`[${action}]`), copper.colors.yellowBright(message));
+                break;
+            case "error":
+                // add an error icon
+                console.log(copper.colors.red("✗"), copper.colors.yellow(`(${date})`), copper.colors.cyan(`[${module}]`), copper.colors.magenta(`[${action}]`), copper.colors.redBright(message));
+                break;
+            case "success":
+                // add a success icon
+                console.log(copper.colors.green("✓"), copper.colors.yellow(`(${date})`), copper.colors.cyan(`[${module}]`), copper.colors.magenta(`[${action}]`), copper.colors.greenBright(message));
+                break;
+            default:
+                console.log("[log]", copper.colors.yellow(`(${date})`), copper.colors.cyan(`[${module}]`), copper.colors.magenta(`[${action}]`), message);
+        }
+        if (typeof message === "object") {
+            console.log(message);
+        }
+    }
+}exports.ConsoleLog=ConsoleLog;//# sourceMappingURL=console-log.js.map

package/cjs/channels/console-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-log.js","sources":["../../src/channels/console-log.ts"],"sourcesContent":[null],"names":["LogChannel","colors"],"mappings":"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"}

package/cjs/channels/file-log.d.ts

@@ -0,0 +1,202 @@
+import { LogChannel } from "../LogChannel";
+import { LogContract, LogLevel } from "../types";
+export type FilteringOptions = {
+    level: LogLevel;
+    module: string;
+    action: string;
+};
+export type FileLogConfig = {
+    storagePath?: string;
+    /**
+     * File name, without extension
+     */
+    name?: string;
+    /**
+     * chunk mode
+     * If set to `single`, the logs will be created in a single file, unless the rotate is set to true
+     * If set to `daily`, the logs will be created in a daily file, unless the rotate is set to true
+     * If set to `hourly`, the logs will be created in an hourly file, unless the rotate is set to true
+     * @default single
+     */
+    chunk?: "single" | "daily" | "hourly";
+    /**
+     * Whether to rotate the file
+     *
+     * @default true
+     */
+    rotate?: boolean;
+    /**
+     * File Extension
+     *
+     * @default log
+     */
+    extension?: string;
+    /**
+     * If rotate is set, the rotate name will be added to the file name suffixed with `-`
+     *
+     * @default DD-MM-YYYY
+     */
+    rotateFileName?: string;
+    /**
+     * Max file size before rotating the file
+     *
+     * @default 10MB
+     */
+    maxFileSize?: number;
+    /**
+     * Set the max messages that needs to be added before writing to the file
+     *
+     * @default 100
+     */
+    maxMessagesToWrite?: number;
+    /**
+     * Group logs by
+     * Please note that the order matters here
+     * For example, if you set `groupBy: ['level', 'module']`, the logs will be added in level name first, then by module
+     *
+     * @default none
+     */
+    groupBy?: ("level" | "module" | "action")[];
+    /**
+     * Define what levels should be logged
+     *
+     * @default all
+     */
+    levels?: LogLevel[];
+    /**
+     * Filter what logs should be logged
+     *
+     * @default all
+     */
+    filter?: (options: FilteringOptions) => boolean;
+    /**
+     * Date and time format
+     */
+    dateFormat?: {
+        date?: string;
+        time?: string;
+    };
+};
+export type LogMessage = {
+    content: string;
+    level: LogLevel;
+    date: string;
+    module: string;
+    action: string;
+    stack: string;
+};
+export declare class FileLog extends LogChannel implements LogContract {
+    /**
+     * {@inheritdoc}
+     */
+    name: string;
+    /**
+     * Messages buffer
+     */
+    protected messages: LogMessage[];
+    /**
+     * Grouped messages
+     */
+    protected groupedMessages: Record<string, LogMessage[]>;
+    /**
+     * Default channel configurations
+     */
+    protected defaultConfigurations: FileLogConfig;
+    /**
+     * Last write time
+     */
+    protected lastWriteTime: number;
+    /**
+     * Channel configurations
+     */
+    protected channelConfigurations: FileLogConfig;
+    /**
+     * A flag to determine if the file is being written
+     */
+    protected isWriting: boolean;
+    /**
+     * Get config value
+     */
+    protected config<K extends keyof FileLogConfig>(key: K): FileLogConfig[K];
+    /**
+     * Constructor
+     */
+    constructor(configurations?: FileLogConfig);
+    /**
+     * Check file size for file rotation
+     */
+    protected checkAndRotateFile(filePath?: string): Promise<void>;
+    /**
+     * Rotate log file
+     */
+    protected rotateLogFile(): Promise<void>;
+    /**
+     * Flush messages
+     */
+    protected initMessageFlush(): void;
+    /**
+     * Get file path
+     */
+    get filePath(): string;
+    /**
+     * Get max messages
+     */
+    protected get maxMessagesToWrite(): number;
+    /**
+     * Get file name
+     */
+    get fileName(): string;
+    /**
+     * Get file extension
+     */
+    get extension(): string;
+    /**
+     * Get content
+     */
+    protected get content(): string;
+    /**
+     * Get storage path
+     */
+    get storagePath(): string;
+    /**
+     * {@inheritdoc}
+     */
+    protected init(): Promise<void>;
+    /**
+     * Set configurations
+     */
+    configurations(configurations: FileLogConfig): this;
+    /**
+     * {@inheritdoc}
+     */
+    log(module: string, action: string, message: any, level: LogLevel): Promise<void>;
+    /**
+     * Check if messages should be written
+     */
+    protected checkIfMessagesShouldBeWritten(): Promise<void>;
+    /**
+     * Should be called after messages are saved
+     */
+    protected onSave(): void;
+    /**
+     * Check if messages should be grouped
+     */
+    protected get messagedShouldBeGrouped(): boolean;
+    /**
+     * Write messages to the file
+     */
+    protected writeMessagesToFile(): Promise<void>;
+    /**
+     * Write grouped messages to the file
+     */
+    protected writeGroupedMessagesToFile(): Promise<void>;
+    /**
+     * Prepare grouped messages
+     */
+    protected prepareGroupedMessages(): void;
+    /**
+     * Start writing to the file
+     */
+    protected write(filePath: string, content: string): Promise<unknown>;
+}
+//# sourceMappingURL=file-log.d.ts.map