@rabbit-company/logger 5.0.0 → 5.1.0

package/README.md

@@ -12,7 +12,7 @@ A versatile, multi-transport logging library for Node.js and browser environment
 
 ## Features ✨
 
-- **Multiple log levels**: ERROR, WARN, INFO, HTTP, VERBOSE, DEBUG, SILLY
+- **Multiple log levels**: ERROR, WARN, AUDIT, INFO, HTTP, DEBUG, VERBOSE, SILLY
 - **Structured logging**: Attach metadata objects to log entries
 - **Transport system**: Console, NDJSON, and Loki transports included
 - **Loki optimized**: Automatic label management and batching
@@ -48,6 +48,42 @@ logger.error("Database connection failed", {
 });
 ```
 
+## Console Formatting 🖥️
+
+The console transport supports extensive datetime formatting:
+
+### Available Placeholders
+
+#### UTC Formats:
+
+- `{iso}`: Full ISO-8601 (2023-11-15T14:30:45.123Z)
+- `{datetime}`: Simplified (2023-11-15 14:30:45)
+- `{date}`: Date only (2023-11-15)
+- `{time}`: Time only (14:30:45)
+- `{utc}`: UTC string (Wed, 15 Nov 2023 14:30:45 GMT)
+- `{ms}`: Milliseconds since epoch
+
+#### Local Time Formats:
+
+- `{datetime-local}`: Local datetime (2023-11-15 14:30:45)
+- `{date-local}`: Local date only (2023-11-15)
+- `{time-local}`: Local time only (14:30:45)
+- `{full-local}`: Complete local string with timezone
+
+#### Log Content:
+
+- `{type}`: Log level (INFO, ERROR, etc.)
+- `{message}`: The log message
+
+```js
+import { ConsoleTransport } from "@rabbit-company/logger";
+
+// Custom format examples
+new ConsoleTransport("[{datetime-local}] {type} {message}");
+new ConsoleTransport("{time} | {type} | {message}", false);
+new ConsoleTransport("EPOCH:{ms} {message}");
+```
+
 ## Transports 🚚
 
 ### Console Transport (Default)
@@ -58,7 +94,7 @@ import { ConsoleTransport } from "@rabbit-company/logger";
 const logger = new Logger({
 	transports: [
 		new ConsoleTransport(
-			"[{date}] {type} {message}", // Custom format
+			"[{time-local}] {type} {message}", // Custom format
 			true // Enable colors
 		),
 	],
@@ -104,11 +140,12 @@ const logger = new Logger({
 enum Levels {
   ERROR,    // Critical errors
   WARN,     // Warnings
-  INFO,     // Informational messages
-  HTTP,     // HTTP-related logs
-  VERBOSE,  // Verbose debugging
-  DEBUG,    // Debug messages
-  SILLY     // Very low-level logs
+  AUDIT,    // Security audits
+  INFO,     // Informational
+  HTTP,     // HTTP traffic
+  DEBUG,    // Debugging
+  VERBOSE,  // Detailed tracing
+  SILLY     // Very low-level
 }
 ```
 
@@ -117,6 +154,7 @@ enum Levels {
 ```js
 logger.error(message: string, metadata?: object): void
 logger.warn(message: string, metadata?: object): void
+logger.audit(message: string, metadata?: object): void
 logger.info(message: string, metadata?: object): void
 logger.http(message: string, metadata?: object): void
 logger.verbose(message: string, metadata?: object): void

package/module/logger.d.ts

@@ -45,43 +45,68 @@ export declare const enum Colors {
  *
  * The levels are ordered from most important (ERROR) to least important (SILLY).
  * When setting a log level, only messages of that level or higher will be emitted.
+ *
+ * @example
+ * // Set logger to display DEBUG level and above
+ * logger.setLevel(Levels.DEBUG);
  */
 export declare enum Levels {
 	/**
 	 * Error level. Indicates critical issues that require immediate attention.
 	 * Use for unrecoverable errors that prevent normal operation.
+	 * @example
+	 * logger.error("Database connection failed");
 	 */
 	ERROR = 0,
 	/**
 	 * Warning level. Indicates potential issues or noteworthy conditions.
 	 * Use for recoverable issues that don't prevent normal operation.
+	 * @example
+	 * logger.warn("High memory usage detected");
 	 */
 	WARN = 1,
+	/**
+	 * Audit level. For security-sensitive operations and compliance logging.
+	 * Use for tracking authentication, authorization, and sensitive data access.
+	 * @example
+	 * logger.audit("User permissions changed", { user: "admin", changes: [...] });
+	 */
+	AUDIT = 2,
 	/**
 	 * Informational level. Provides general information about the application's state.
 	 * Use for normal operational messages that highlight progress.
+	 * @example
+	 * logger.info("Application started on port 3000");
 	 */
-	INFO = 2,
+	INFO = 3,
 	/**
 	 * HTTP-related level. Logs HTTP requests and responses.
 	 * Use for tracking HTTP API calls and their status.
+	 * @example
+	 * logger.http("GET /api/users 200 45ms");
 	 */
-	HTTP = 3,
-	/**
-	 * Verbose level. Provides detailed information for in-depth analysis.
-	 * Use for detailed operational logs that are typically only needed during debugging.
-	 */
-	VERBOSE = 4,
+	HTTP = 4,
 	/**
 	 * Debug level. Provides detailed context for debugging purposes.
 	 * Use for extended debugging information during development.
+	 * @example
+	 * logger.debug("Database query", { query: "...", duration: "120ms" });
 	 */
 	DEBUG = 5,
+	/**
+	 * Verbose level. Provides detailed information for in-depth analysis.
+	 * Use for detailed operational logs that are typically only needed during debugging.
+	 * @example
+	 * logger.verbose("Cache update cycle completed", { entries: 1423 });
+	 */
+	VERBOSE = 6,
 	/**
 	 * Silly level. Logs very low-level messages.
 	 * Use for extremely verbose logging messages.
+	 * @example
+	 * logger.silly("Iteration 14563 completed");
 	 */
-	SILLY = 6
+	SILLY = 7
 }
 /**
  * Represents a single log entry with message, severity level, timestamp, and optional metadata
@@ -216,103 +241,290 @@ export declare class Logger {
 	 */
 	private processEntry;
 	/**
-	 * Logs an error message
+	 * Logs an error message (highest severity)
 	 * @param message The error message
 	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.error("Database connection failed", { error: error.stack });
 	 */
 	error(message: string, metadata?: Record<string, any>): void;
 	/**
 	 * Logs a warning message
 	 * @param message The warning message
 	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.warn("High memory usage detected", { usage: "85%" });
 	 */
 	warn(message: string, metadata?: Record<string, any>): void;
+	/**
+	 * Logs security-sensitive audit events
+	 * @param message The audit message
+	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.audit("User permissions modified", {
+	 *   actor: "admin@example.com",
+	 *   action: "role_change",
+	 *   target: "user:1234"
+	 * });
+	 */
+	audit(message: string, metadata?: Record<string, any>): void;
 	/**
 	 * Logs an informational message
 	 * @param message The info message
 	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.info("Server started", { port: 3000, env: "production" });
 	 */
 	info(message: string, metadata?: Record<string, any>): void;
 	/**
-	 * Logs an HTTP-related message
+	 * Logs HTTP-related messages
 	 * @param message The HTTP message
 	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.http("Request completed", {
+	 *   method: "GET",
+	 *   path: "/api/users",
+	 *   status: 200,
+	 *   duration: "45ms"
+	 * });
 	 */
 	http(message: string, metadata?: Record<string, any>): void;
 	/**
-	 * Logs a verbose message
-	 * @param message The verbose message
+	 * Logs debug information (for development environments)
+	 * @param message The debug message
 	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.debug("Database query", {
+	 *   query: "SELECT * FROM users",
+	 *   parameters: { limit: 50 }
+	 * });
 	 */
-	verbose(message: string, metadata?: Record<string, any>): void;
+	debug(message: string, metadata?: Record<string, any>): void;
 	/**
-	 * Logs a debug message
-	 * @param message The debug message
+	 * Logs verbose tracing information (very detailed)
+	 * @param message The verbose message
 	 * @param metadata Optional metadata object
+	 * @example
+	 * logger.verbose("Cache update cycle", {
+	 *   entriesProcessed: 1423,
+	 *   memoryUsage: "1.2MB"
+	 * });
 	 */
-	debug(message: string, metadata?: Record<string, any>): void;
+	verbose(message: string, metadata?: Record<string, any>): void;
 	/**
-	 * Logs a silly message (lowest level)
+	 * Logs extremely low-level details (lowest severity)
 	 * @param message The silly message
-	 * @param metadata Optional metadata object
+	 * @param metadata Optional metadata data
+	 * @example
+	 * logger.silly("Iteration complete", { iteration: 14563 });
 	 */
 	silly(message: string, metadata?: Record<string, any>): void;
 	/**
 	 * Adds a new transport to the logger
 	 * @param transport The transport to add
+	 * @example
+	 * logger.addTransport(new LokiTransport({ url: "http://loki:3100" }));
 	 */
 	addTransport(transport: Transport): void;
 	/**
 	 * Removes a transport from the logger
 	 * @param transport The transport to remove
+	 * @example
+	 * logger.removeTransport(consoleTransport);
 	 */
 	removeTransport(transport: Transport): void;
 	/**
 	 * Sets the minimum log level
 	 * @param level The new minimum log level
+	 * @example
+	 * // Only show errors and warnings
+	 * logger.setLevel(Levels.WARN);
 	 */
 	setLevel(level: Levels): void;
 }
 /**
- * Transport that outputs logs to the console with configurable formatting
+ * Transport that outputs logs to the console with configurable formatting and colors.
+ *
+ * Features:
+ * - Customizable output format with extensive placeholder support
+ * - ANSI color support (enabled by default)
+ * - Cross-platform compatibility (Node.js and browsers)
+ * - Lightweight and performant
+ *
+ * @example
+ * // Basic usage with default formatting
+ * const transport = new ConsoleTransport();
+ *
+ * @example
+ * // Custom format with local timestamps
+ * const transport = new ConsoleTransport(
+ *   "[{datetime-local}] {type} - {message}",
+ *   true
+ * );
  */
 export declare class ConsoleTransport implements Transport {
 	private format;
 	private colors;
 	/**
-	 * Create a ConsoleTransport instance
-	 * @param format Format string using {date}, {type}, {message} placeholders
-	 * @param colors Enable colored output
+	 * Creates a new ConsoleTransport instance
+	 * @param format Format string supporting these placeholders:
+	 *
+	 * ### Time/Date Formats
+	 * - `{iso}`: Full ISO-8601 UTC format (YYYY-MM-DDTHH:MM:SS.mmmZ)
+	 * - `{datetime}`: Simplified UTC (YYYY-MM-DD HH:MM:SS)
+	 * - `{date}`: UTC date only (YYYY-MM-DD)
+	 * - `{time}`: UTC time only (HH:MM:SS)
+	 * - `{datetime-local}`: Local datetime (YYYY-MM-DD HH:MM:SS)
+	 * - `{date-local}`: Local date only (YYYY-MM-DD)
+	 * - `{time-local}`: Local time only (HH:MM:SS)
+	 * - `{ms}`: Milliseconds since epoch
+	 *
+	 * ### Log Content
+	 * - `{type}`: Log level name (e.g., "INFO")
+	 * - `{message}`: The log message content
+	 *
+	 * @default "[{datetime-local}] {type} {message}"
+	 *
+	 * @param colors Enable ANSI color output. When disabled:
+	 *   - Improves performance in non-TTY environments
+	 *   - Removes all color formatting
+	 * @default true
+	 *
+	 * @example
+	 * // UTC format example
+	 * new ConsoleTransport("{date} {time} [{type}] {message}");
+	 *
+	 * @example
+	 * // Local time with colors disabled
+	 * new ConsoleTransport("{time-local} - {message}", false);
 	 */
 	constructor(format?: string, colors?: boolean);
 	/**
-	 * Output a log entry to the console
-	 * @param entry The log entry to output
+	 * Formats and outputs a log entry to the console.
+	 *
+	 * Applies the configured format with these features:
+	 * - All specified placeholders are replaced
+	 * - Colors are applied to level names and messages
+	 * - Timestamps are dimmed for better readability
+	 *
+	 * @param entry The log entry containing:
+	 *   - message: string - The primary log content
+	 *   - level: Levels - The severity level
+	 *   - timestamp: number - Creation time (ms since epoch)
+	 *
+	 * @example
+	 * // With all placeholder types
+	 * transport.log({
+	 *   message: "User logged in",
+	 *   level: Levels.INFO,
+	 *   timestamp: Date.now()
+	 * });
 	 */
 	log(entry: LogEntry): void;
 }
 /**
- * Transport that collects logs in NDJSON (Newline Delimited JSON) format
+ * Transport that collects logs in NDJSON (Newline Delimited JSON) format.
+ *
+ * This transport accumulates log entries in memory as NDJSON strings,
+ * which can be retrieved or cleared as needed. Useful for:
+ * - Log aggregation
+ * - Bulk exporting logs
+ * - Integration with log processing pipelines
+ *
+ * @example
+ * // Basic usage
+ * const transport = new NDJsonTransport();
+ * const logger = new Logger({ transports: [transport] });
+ *
+ * // Get logs as NDJSON string
+ * const logs = transport.getData();
+ *
+ * @example
+ * // Periodic log flushing
+ * setInterval(() => {
+ *   const logs = transport.getData();
+ *   if (logs) {
+ *     sendToServer(logs);
+ *     transport.reset();
+ *   }
+ * }, 60000);
  */
 export declare class NDJsonTransport implements Transport {
 	private data;
 	/**
-	 * Append a log entry to the NDJSON buffer
-	 * @param entry The log entry to append
+	 * Appends a log entry to the internal NDJSON buffer.
+	 *
+	 * Automatically adds newline separators between entries.
+	 *
+	 * @param entry The log entry to append. Must contain:
+	 * - message: string
+	 * - level: Levels
+	 * - timestamp: number
+	 * - metadata?: object
+	 *
+	 * @example
+	 * transport.log({
+	 *   message: "System started",
+	 *   level: Levels.INFO,
+	 *   timestamp: Date.now()
+	 * });
 	 */
 	log(entry: LogEntry): void;
 	/**
-	 * Get the accumulated NDJSON data
-	 * @returns The NDJSON formatted log data
+	 * Retrieves all accumulated logs as an NDJSON string.
+	 *
+	 * The returned string will contain one log entry per line,
+	 * with each line being a valid JSON string.
+	 *
+	 * @returns {string} NDJSON formatted log data. Returns empty string if no logs.
+	 *
+	 * @example
+	 * // Get logs for API response
+	 * app.get('/logs', (req, res) => {
+	 *   res.type('application/x-ndjson');
+	 *   res.send(transport.getData());
+	 * });
 	 */
 	getData(): string;
 	/**
-	 * Clear the accumulated log data
+	 * Clears all accumulated log data from memory.
+	 *
+	 * Typically called after successfully transmitting logs
+	 * to prevent duplicate processing.
+	 *
+	 * @example
+	 * // Clear after successful upload
+	 * if (uploadLogs(transport.getData())) {
+	 *   transport.reset();
+	 * }
 	 */
 	reset(): void;
 }
 /**
- * Transport that sends logs to a Grafana Loki server
+ * Transport that sends logs to a Grafana Loki server with batching and retry support.
+ *
+ * Features:
+ * - Automatic batching of logs for efficient transmission
+ * - Configurable batch size and timeout
+ * - Label management with cardinality control
+ * - Multi-tenancy support via X-Scope-OrgID
+ * - Basic authentication support
+ *
+ * @example
+ * // Basic configuration
+ * const lokiTransport = new LokiTransport({
+ *   url: "http://localhost:3100",
+ *   labels: { app: "my-app", env: "production" }
+ * });
+ *
+ * @example
+ * // With authentication and custom batching
+ * const securedTransport = new LokiTransport({
+ *   url: "http://loki.example.com",
+ *   basicAuth: { username: "user", password: "pass" },
+ *   batchSize: 20,
+ *   batchTimeout: 10000 // 10 seconds
+ * });
  */
 export declare class LokiTransport implements Transport {
 	private config;
@@ -323,19 +535,48 @@ export declare class LokiTransport implements Transport {
 	private maxLabelCount;
 	private debug;
 	/**
-	 * Create a LokiTransport instance
+	 * Creates a new LokiTransport instance
 	 * @param config Configuration options for Loki
+	 * @param config.url Required Loki server URL (e.g., "http://localhost:3100")
+	 * @param config.labels Base labels to attach to all log entries
+	 * @param config.basicAuth Basic authentication credentials
+	 * @param config.batchSize Maximum number of logs to batch before sending (default: 10)
+	 * @param config.batchTimeout Maximum time (ms) to wait before sending a batch (default: 5000)
+	 * @param config.tenantID Tenant ID for multi-tenant Loki setups
+	 * @param config.maxLabelCount Maximum number of labels allowed (default: 50)
+	 * @param config.debug Enable debug logging for transport errors (default: false)
 	 * @throws {Error} If URL is not provided
 	 */
 	constructor(config: LokiConfig);
 	/**
-	 * Add a log entry to the batch (may trigger send if batch size is reached)
-	 * @param entry The log entry to send
+	 * Adds a log entry to the current batch. Automatically sends the batch when:
+	 * - The batch reaches the configured size, OR
+	 * - The batch timeout is reached
+	 *
+	 * @param entry The log entry to send. Metadata will be converted to Loki labels
+	 *              following the configured maxLabelCount rules.
+	 *
+	 * @example
+	 * transport.log({
+	 *   message: "User logged in",
+	 *   level: Levels.INFO,
+	 *   timestamp: Date.now(),
+	 *   metadata: { userId: "123", device: "mobile" }
+	 * });
 	 */
 	log(entry: LogEntry): void;
 	/**
-	 * Send the current batch of logs to Loki
+	 * Immediately sends the current batch of logs to Loki.
 	 * @private
+	 *
+	 * Handles:
+	 * - HTTP headers including auth and tenant ID
+	 * - Batch timeout clearing
+	 * - Error logging (when debug enabled)
+	 * - Batch management
+	 *
+	 * Note: This method is called automatically by the transport
+	 * and typically doesn't need to be called directly.
 	 */
 	private sendBatch;
 }

package/module/logger.js

@@ -26,38 +26,68 @@ var Levels;
 ((Levels2) => {
   Levels2[Levels2["ERROR"] = 0] = "ERROR";
   Levels2[Levels2["WARN"] = 1] = "WARN";
-  Levels2[Levels2["INFO"] = 2] = "INFO";
-  Levels2[Levels2["HTTP"] = 3] = "HTTP";
-  Levels2[Levels2["VERBOSE"] = 4] = "VERBOSE";
+  Levels2[Levels2["AUDIT"] = 2] = "AUDIT";
+  Levels2[Levels2["INFO"] = 3] = "INFO";
+  Levels2[Levels2["HTTP"] = 4] = "HTTP";
   Levels2[Levels2["DEBUG"] = 5] = "DEBUG";
-  Levels2[Levels2["SILLY"] = 6] = "SILLY";
+  Levels2[Levels2["VERBOSE"] = 6] = "VERBOSE";
+  Levels2[Levels2["SILLY"] = 7] = "SILLY";
 })(Levels ||= {});
 var LevelColors = {
   [0 /* ERROR */]: "\x1B[31m" /* RED */,
   [1 /* WARN */]: "\x1B[93m" /* BRIGHT_YELLOW */,
-  [2 /* INFO */]: "\x1B[36m" /* CYAN */,
-  [3 /* HTTP */]: "\x1B[34m" /* BLUE */,
-  [4 /* VERBOSE */]: "\x1B[34m" /* BLUE */,
-  [5 /* DEBUG */]: "\x1B[90m" /* BRIGHT_BLACK */,
-  [6 /* SILLY */]: "\x1B[90m" /* BRIGHT_BLACK */
+  [2 /* AUDIT */]: "\x1B[35m" /* MAGENTA */,
+  [3 /* INFO */]: "\x1B[36m" /* CYAN */,
+  [4 /* HTTP */]: "\x1B[34m" /* BLUE */,
+  [5 /* DEBUG */]: "\x1B[34m" /* BLUE */,
+  [6 /* VERBOSE */]: "\x1B[90m" /* BRIGHT_BLACK */,
+  [7 /* SILLY */]: "\x1B[90m" /* BRIGHT_BLACK */
 };
 // src/formatters/consoleFormatter.ts
 function formatConsoleMessage(message, logLevel, format, colorsEnabled) {
-  let type = Levels[logLevel];
-  let date = new Date().toISOString().split(".")[0].replace("T", " ");
+  const now = new Date;
+  const type = Levels[logLevel];
+  const utcFormats = {
+    "{iso}": now.toISOString(),
+    "{datetime}": now.toISOString().split(".")[0].replace("T", " "),
+    "{time}": now.toISOString().split("T")[1].split(".")[0],
+    "{date}": now.toISOString().split("T")[0],
+    "{utc}": now.toUTCString(),
+    "{ms}": now.getTime().toString()
+  };
+  const localFormats = {
+    "{datetime-local}": now.toLocaleString("sv-SE").replace(" ", "T").split(".")[0].replace("T", " "),
+    "{time-local}": now.toLocaleTimeString("sv-SE"),
+    "{date-local}": now.toLocaleDateString("sv-SE"),
+    "{full-local}": now.toString()
+  };
+  let coloredType = type;
+  let coloredMessage = message;
   if (colorsEnabled) {
-    date = "\x1B[90m" /* BRIGHT_BLACK */ + date + "\x1B[0m" /* RESET */;
-    type = "\x1B[1m" /* BOLD */ + LevelColors[logLevel] + type + "\x1B[0m" /* RESET */;
-    message = LevelColors[logLevel] + message + "\x1B[0m" /* RESET */;
+    const color = LevelColors[logLevel];
+    const colorize = (text) => "\x1B[90m" /* BRIGHT_BLACK */ + text + "\x1B[0m" /* RESET */;
+    Object.keys(utcFormats).forEach((key) => {
+      utcFormats[key] = colorize(utcFormats[key]);
+    });
+    Object.keys(localFormats).forEach((key) => {
+      localFormats[key] = colorize(localFormats[key]);
+    });
+    coloredType = "\x1B[1m" /* BOLD */ + color + type + "\x1B[0m" /* RESET */;
+    coloredMessage = color + message + "\x1B[0m" /* RESET */;
   }
-  return format.replace("{date}", date).replace("{type}", type).replace("{message}", message);
+  let output = format;
+  const allFormats = { ...utcFormats, ...localFormats };
+  for (const [placeholder, value] of Object.entries(allFormats)) {
+    output = output.replace(new RegExp(placeholder, "g"), value);
+  }
+  return output.replace(/{type}/g, coloredType).replace(/{message}/g, coloredMessage);
 }
 
 // src/transports/consoleTransport.ts
 class ConsoleTransport {
   format;
   colors;
-  constructor(format = "[{date}] {type} {message}", colors = true) {
+  constructor(format = "[{datetime-local}] {type} {message}", colors = true) {
     this.format = format;
     this.colors = colors;
   }
@@ -68,7 +98,7 @@ class ConsoleTransport {
 
 // src/logger.ts
 class Logger {
-  level = 2 /* INFO */;
+  level = 3 /* INFO */;
   transports = [new ConsoleTransport];
   constructor(config) {
     if (config?.level !== undefined) {
@@ -102,20 +132,23 @@ class Logger {
   warn(message, metadata) {
     this.processEntry(this.createLogEntry(message, 1 /* WARN */, metadata));
   }
+  audit(message, metadata) {
+    this.processEntry(this.createLogEntry(message, 2 /* AUDIT */, metadata));
+  }
   info(message, metadata) {
-    this.processEntry(this.createLogEntry(message, 2 /* INFO */, metadata));
+    this.processEntry(this.createLogEntry(message, 3 /* INFO */, metadata));
   }
   http(message, metadata) {
-    this.processEntry(this.createLogEntry(message, 3 /* HTTP */, metadata));
-  }
-  verbose(message, metadata) {
-    this.processEntry(this.createLogEntry(message, 4 /* VERBOSE */, metadata));
+    this.processEntry(this.createLogEntry(message, 4 /* HTTP */, metadata));
   }
   debug(message, metadata) {
     this.processEntry(this.createLogEntry(message, 5 /* DEBUG */, metadata));
   }
+  verbose(message, metadata) {
+    this.processEntry(this.createLogEntry(message, 6 /* VERBOSE */, metadata));
+  }
   silly(message, metadata) {
-    this.processEntry(this.createLogEntry(message, 6 /* SILLY */, metadata));
+    this.processEntry(this.createLogEntry(message, 7 /* SILLY */, metadata));
   }
   addTransport(transport) {
     this.transports.push(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rabbit-company/logger",
-	"version": "5.0.0",
+	"version": "5.1.0",
 	"description": "A simple and lightweight logger",
 	"main": "./module/index.js",
 	"type": "module",
@@ -31,6 +31,7 @@
 		"logger",
 		"console",
 		"ndjson",
+		"grafana",
 		"loki"
 	],
 	"devDependencies": {