@pristine-ts/logging 0.0.170 → 0.0.174

package/dist/types/loggers/file.logger.d.ts

@@ -4,11 +4,52 @@ import { LoggerInterface } from "../interfaces/logger.interface";
 import { Readable, Writable } from "stream";
 import { OutputModeEnum } from "../enums/output-mode.enum";
 import { BaseLogger } from "./base.logger";
+/**
+ * The FileLogger outputs the logs into file.
+ * It is registered with the tag Logger so that it can be injected along with all the other Loggers.
+ * It is module scoped to the logging module so that it is only registered if the logging module is imported.
+ */
 export declare class FileLogger extends BaseLogger implements LoggerInterface {
     private readonly filePath;
+    /**
+     * The readable stream from which the logger reads the logs that need to be outputted.
+     */
     readableStream: Readable;
+    /**
+     * The writable stream used to write to the file.
+     * @private
+     */
     writableStream: Writable;
-    constructor(numberOfStackedLogs: number, logSeverityLevelConfiguration: number, logDebugDepthConfiguration: number, logInfoDepthConfiguration: number, logWarningDepthConfiguration: number, logErrorDepthConfiguration: number, logCriticalDepthConfiguration: number, isActive: boolean, outputMode: OutputModeEnum, fileLoggerPretty: boolean, filePath: string);
+    /**
+     * The ConsoleLogger outputs the logs in the console.
+     * @param numberOfStackedLogs The number of logs to keep in the stack and to print once a log with a high enough severity arrives.
+     * @param logSeverityLevelConfiguration The number representing the severity from which logs should be outputted.
+     * For example, if this is set to 3, any log that has a severity of Error(3) or critical(4) will be outputted.
+     * @param logDebugDepthConfiguration The number of level to go down in an object when printing a log with the Debug severity.
+     * We often do not need to go to the bottom layer of an object, so we can truncate at a certain depth.
+     * @param logInfoDepthConfiguration The number of level to go down in an object when printing a log with the Info severity.
+     * We often do not need to go to the bottom layer of an object, so we can truncate at a certain depth.
+     * @param logWarningDepthConfiguration The number of level to go down in an object when printing a log with the Warning severity.
+     * We often do not need to go to the bottom layer of an object, so we can truncate at a certain depth.
+     * @param logErrorDepthConfiguration The number of level to go down in an object when printing a log with the Error severity.
+     * We often do not need to go to the bottom layer of an object, so we can truncate at a certain depth.
+     * @param logCriticalDepthConfiguration The number of level to go down in an object when printing a log with the Critical severity.
+     * We often do not need to go to the bottom layer of an object, so we can truncate at a certain depth.
+     * @param isActivated Whether or not this particular logger is activated and should output logs.
+     * @param outputMode The output mode, that the logger should use.
+     * @param fileLoggerPretty Whether or not the file logger should prettify the output.
+     * @param filePath The file path where to output the log.
+     */
+    constructor(numberOfStackedLogs: number, logSeverityLevelConfiguration: number, logDebugDepthConfiguration: number, logInfoDepthConfiguration: number, logWarningDepthConfiguration: number, logErrorDepthConfiguration: number, logCriticalDepthConfiguration: number, isActivated: boolean, outputMode: OutputModeEnum, fileLoggerPretty: boolean, filePath: string);
+    /**
+     * Initializes the file logger, and opens the write stream.
+     * @protected
+     */
     protected initialize(): void;
+    /**
+     * Outputs the log in the file.
+     * @param log The log to be outputted
+     * @protected
+     */
     protected log(log: LogModel): void;
 }

package/dist/types/loggers/loggers.d.ts

@@ -1 +1,2 @@
 export * from "./console.logger";
+export * from "./file.logger";

package/dist/types/logging.module.d.ts

@@ -2,8 +2,8 @@ import { ModuleInterface } from "@pristine-ts/common";
 export * from "./enums/enums";
 export * from "./handlers/handlers";
 export * from "./interfaces/interfaces";
-export * from "./models/models";
 export * from "./loggers/loggers";
+export * from "./models/models";
 export * from "./utils/utils";
 export * from "./logging.module.keyname";
 export declare const LoggingModule: ModuleInterface;

package/dist/types/models/diagnostics.model.d.ts

@@ -1,15 +1,52 @@
+/**
+ * The diagnostic model represents detailed information to help debug that will be outputted in the extras of the log
+ * when diagnostic is enabled.
+ */
 export declare class DiagnosticsModel {
+    /**
+     * The node version on which the code was executed.
+     */
     nodeVersion?: string;
+    /**
+     * An array representing the stack trace from which the log originated.
+     */
     stackTrace: {
+        /**
+         * The class name at which it was called in the stack trace.
+         */
         className: string;
+        /**
+         * The class name at which it was called in the stack trace.
+         */
         filename: string;
+        /**
+         * The line at which it was called in the stack trace
+         */
         line: string;
+        /**
+         * The column at which it was called in the stack trace
+         */
         column: string;
     }[];
+    /**
+     * The very last element of the stack trace to know precisely where the log originated from.
+     */
     lastStackTrace?: {
+        /**
+         * The class name at which it was called in the stack trace.
+         */
         className: string;
+        /**
+         * The class name at which it was called in the stack trace.
+         */
         filename: string;
+        /**
+         * The line at which it was called in the stack trace
+         */
         line: string;
+        /**
+         * The column at which it was called in the stack trace
+         */
         column: string;
     };
 }

package/dist/types/models/log.model.d.ts

@@ -1,11 +1,35 @@
 import { SeverityEnum } from "../enums/severity.enum";
+/**
+ * The model that represents a log
+ */
 export declare class LogModel {
     severity: SeverityEnum;
     message: string;
+    /**
+     * The trace id from which the log originated.
+     */
     traceId?: string;
+    /**
+     * The kernel instantiation id from which the log originated.
+     */
+    kernelInstantiationId?: string;
+    /**
+     * The date at which the log was created.
+     */
     date: Date;
+    /**
+     * The module from which the log originated.
+     * By default it will be the application module.
+     */
     module: string;
+    /**
+     * Any extras that need to be outputted along with the message.
+     */
     extra: any;
-    kernelInstantiationId?: string;
+    /**
+     * The model that represents a log
+     * @param severity The log severity.
+     * @param message The actual log message that needs to be outputted.
+     */
     constructor(severity: SeverityEnum, message: string);
 }

package/dist/types/utils/utils.d.ts

@@ -2,13 +2,49 @@ import { LogModel } from "../models/log.model";
 import { OutputModeEnum } from "../enums/output-mode.enum";
 import { SeverityEnum } from "../enums/severity.enum";
 import { DiagnosticsModel } from "../models/diagnostics.model";
+/**
+ * This class provides some utility functions to help with the logging.
+ */
 export declare class Utils {
     static flatTypes: (DateConstructor | StringConstructor | NumberConstructor | BooleanConstructor)[];
+    /**
+     * Returns whether or not the value is defined
+     * @param val
+     */
     static isDefined(val: any): boolean;
+    /**
+     * Returns whether or not the value is flat, meaning it is not an object.
+     * @param val
+     */
     static isFlat(val: any): number | true;
+    /**
+     * Gets the deep keys of an object.
+     * @param obj The object.
+     */
     static getDeepKeys(obj: any): string[];
+    /**
+     * This function truncates an object to the max depth required.
+     * @param object The object to truncate.
+     * @param maxDepth The max depth of the object.
+     * @param curDepth The current depth at which we are at.
+     */
     static truncate(object: any, maxDepth: number, curDepth?: number): any;
+    /**
+     * Gets the string representing a value of the log severity enum.
+     * @param logSeverity The log severity for which to get the string representation.
+     */
     static getSeverityText(logSeverity: SeverityEnum): string;
+    /**
+     * Returns the string formatted log based on the output model.
+     * @param log The log to be string formatted.
+     * @param outputMode The output mode desired.
+     * @param logDepth The log depth.
+     * @param spaceNumber The number of spaces for a tab.
+     */
     static outputLog(log: LogModel, outputMode: OutputModeEnum, logDepth: number, spaceNumber?: number): string;
+    /**
+     * Creates the diagnostic model from an error object to attach to a log.
+     * @param error The error object from which to get the stack trace.
+     */
     static getDiagnostics(error: Error): DiagnosticsModel;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/logging",
-  "version": "0.0.170",
+  "version": "0.0.174",
   "description": "",
   "module": "dist/lib/esm/logging.module.js",
   "main": "dist/lib/cjs/logging.module.js",
@@ -11,8 +11,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@pristine-ts/common": "^0.0.170",
-    "@pristine-ts/configuration": "^0.0.170",
+    "@pristine-ts/common": "^0.0.174",
+    "@pristine-ts/configuration": "^0.0.174",
     "date-fns": "^2.22.1"
   },
   "files": [
@@ -57,5 +57,5 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "03decbb25315a120f2ead0b4f663e4148d8548a8"
+  "gitHead": "578d6b9fe5faf8ef55c729bae70048446777a4b9"
 }