elegant-logger 1.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the same
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# elegant-logs
+
+A professional, beautiful, and highly customizable Express request and error logger middleware for Node.js services.
+
+## Features
+
+- 🎨 **Colorized Terminal Output**: Beautifully structured logs with ANSI colors based on HTTP method, response time, and status codes.
+- 🔒 **Auto-Redaction**: Automatically redacts sensitive fields from request bodies (e.g., `password`, `token`, `secret`, `apiKey`, `authorization`).
+- ⚡ **Precision Timing**: High-resolution response timers formatted with appropriate units (e.g., microseconds `μs`, milliseconds `ms`, or seconds `s`).
+- ⚙️ **Customizable Log Content**: Optionally include or skip request body, query parameters, or HTTP headers.
+- 🛠️ **Custom Loggers**: Easily hook into your log stream (e.g., to send structured logs to Datadog, Logstash, or Sentry).
+- 🐛 **Elegant Error Logging**: Standardized middleware to print clean error stack traces in development.
+- 📦 **Zero-Configuration Bundling**: Pre-packaged as both ES Module (ESM) and CommonJS (CJS) with full TypeScript definitions.
+
+---
+
+## Installation
+
+Install via your preferred package manager:
+
+```bash
+# Using npm
+npm install elegant-logs
+
+# Using pnpm
+pnpm add elegant-logs
+
+# Using yarn
+yarn add elegant-logs
+```
+
+*Note: Since `elegant-logs` is designed specifically for Express apps, make sure you have `express` installed in your project.*
+
+---
+
+## Getting Started
+
+### 1. Request Logger Middleware
+
+Import and use the middleware in your Express application:
+
+```typescript
+import express from 'express';
+import { loggerMiddleware } from 'elegant-logs';
+
+const app = express();
+
+app.use(express.json());
+
+// Apply logger middleware
+app.use(loggerMiddleware({
+  includeBody: true,    // Log request body (defaults to true)
+  includeQuery: true,   // Log query parameters (defaults to true)
+  includeHeaders: false // Log headers (defaults to false)
+}));
+
+app.get('/api/users', (req, res) => {
+  res.json({ ok: true });
+});
+
+app.listen(3000, () => {
+  console.log('Server is running on http://localhost:3000');
+});
+```
+
+### 2. Error Logger Middleware
+
+Add the error logger middleware **after** all of your application routes:
+
+```typescript
+import { errorLoggerMiddleware } from 'elegant-logs';
+
+// ... your routes here ...
+
+// Apply error logger
+app.use(errorLoggerMiddleware);
+```
+
+---
+
+## Options
+
+`loggerMiddleware` accepts an optional configuration object of type `LoggerOptions`:
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `skip` | `(req, res) => boolean` | `undefined` | A function to determine if a specific request should skip logging. |
+| `includeBody` | `boolean` | `true` | When true, logs the JSON request body (redacting sensitive fields). |
+| `includeQuery` | `boolean` | `true` | When true, logs the request query parameters. |
+| `includeHeaders` | `boolean` | `false` | When true, logs the request headers. |
+| `customLogger` | `(logData: LogData) => void` | `undefined` | A custom function to handle raw structured log objects (disables default console printing). |
+
+### Custom Logger Example
+
+If you want to send logs to an external service or a filesytem logger:
+
+```typescript
+app.use(loggerMiddleware({
+  customLogger: (logData) => {
+    // Send structured data to external metrics/log store
+    myTelemetryClient.send(logData);
+  }
+}));
+```
+
+### Log Data Schema
+
+When using `customLogger`, your function receives a `LogData` object with the following schema:
+
+```typescript
+interface LogData {
+  timestamp: string;      // ISO format string (YYYY-MM-DD HH:mm:ss)
+  method: string;         // HTTP Method (GET, POST, etc.)
+  url: string;            // The request URL path
+  statusCode: number;     // The response status code
+  responseTime: number;   // Response duration in milliseconds
+  clientIP: string;       // Client IP address (considers X-Forwarded-For)
+  userAgent?: string;     // The browser or client user agent header
+  body?: unknown;         // The request body (sanitized)
+  query?: unknown;        // The request query params
+  headers?: unknown;      // The request headers
+}
+```
+
+---
+
+## License
+
+ISC License (see [LICENSE](LICENSE) or package details).

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from 'express';
+
+interface LoggerOptions {
+    skip?: (req: Request, res: Response) => boolean;
+    includeBody?: boolean;
+    includeQuery?: boolean;
+    includeHeaders?: boolean;
+    customLogger?: (logData: LogData) => void;
+}
+interface LogData {
+    timestamp: string;
+    method: string;
+    url: string;
+    statusCode: number;
+    responseTime: number;
+    clientIP: string;
+    userAgent?: string;
+    body?: unknown;
+    query?: unknown;
+    headers?: unknown;
+}
+/**
+ * Professional Express logger middleware
+ * Logs HTTP requests with colors, timing, and structured data
+ */
+declare const loggerMiddleware: (options?: LoggerOptions) => (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Simple error logger middleware
+ * Should be used after all routes
+ */
+declare const errorLoggerMiddleware: (err: Error, req: Request, res: Response, next: NextFunction) => void;
+
+export { type LogData, type LoggerOptions, loggerMiddleware as default, errorLoggerMiddleware, loggerMiddleware };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from 'express';
+
+interface LoggerOptions {
+    skip?: (req: Request, res: Response) => boolean;
+    includeBody?: boolean;
+    includeQuery?: boolean;
+    includeHeaders?: boolean;
+    customLogger?: (logData: LogData) => void;
+}
+interface LogData {
+    timestamp: string;
+    method: string;
+    url: string;
+    statusCode: number;
+    responseTime: number;
+    clientIP: string;
+    userAgent?: string;
+    body?: unknown;
+    query?: unknown;
+    headers?: unknown;
+}
+/**
+ * Professional Express logger middleware
+ * Logs HTTP requests with colors, timing, and structured data
+ */
+declare const loggerMiddleware: (options?: LoggerOptions) => (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Simple error logger middleware
+ * Should be used after all routes
+ */
+declare const errorLoggerMiddleware: (err: Error, req: Request, res: Response, next: NextFunction) => void;
+
+export { type LogData, type LoggerOptions, loggerMiddleware as default, errorLoggerMiddleware, loggerMiddleware };

package/dist/index.js

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  errorLoggerMiddleware: () => errorLoggerMiddleware,
+  loggerMiddleware: () => loggerMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Text colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m"
+};
+var methodColors = {
+  GET: colors.green,
+  POST: colors.blue,
+  PUT: colors.yellow,
+  PATCH: colors.magenta,
+  DELETE: colors.red,
+  OPTIONS: colors.cyan,
+  HEAD: colors.gray
+};
+var getStatusColor = (statusCode) => {
+  if (statusCode >= 500) return colors.red;
+  if (statusCode >= 400) return colors.yellow;
+  if (statusCode >= 300) return colors.cyan;
+  if (statusCode >= 200) return colors.green;
+  return colors.white;
+};
+var formatResponseTime = (ms) => {
+  if (ms < 1) return `${(ms * 1e3).toFixed(0)}\u03BCs`;
+  if (ms < 1e3) return `${ms.toFixed(0)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+};
+var getTimestamp = () => {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString().replace("T", " ").substring(0, 19);
+};
+var getClientIP = (req) => {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (typeof forwarded === "string") {
+    return forwarded.split(",")[0].trim();
+  }
+  return req.socket.remoteAddress || "unknown";
+};
+var truncate = (str, maxLength = 100) => {
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength) + "...";
+};
+var formatBody = (body) => {
+  if (!body || typeof body !== "object") return "";
+  const bodyObj = body;
+  if (Object.keys(bodyObj).length === 0) return "";
+  const sanitized = { ...bodyObj };
+  const sensitiveFields = [
+    "password",
+    "token",
+    "secret",
+    "apiKey",
+    "authorization"
+  ];
+  for (const field of sensitiveFields) {
+    if (sanitized[field]) {
+      sanitized[field] = "[REDACTED]";
+    }
+  }
+  try {
+    return truncate(JSON.stringify(sanitized), 200);
+  } catch {
+    return "[Unable to stringify body]";
+  }
+};
+var loggerMiddleware = (options = {}) => {
+  const {
+    skip,
+    includeBody = true,
+    includeQuery = true,
+    includeHeaders = false,
+    customLogger
+  } = options;
+  return (req, res, next) => {
+    const startTime = process.hrtime.bigint();
+    const originalEnd = res.end.bind(res);
+    res.end = function(chunk, encodingOrCb, cb) {
+      const endTime = process.hrtime.bigint();
+      const responseTimeNs = Number(endTime - startTime);
+      const responseTimeMs = responseTimeNs / 1e6;
+      if (skip && skip(req, res)) {
+        return originalEnd(chunk, encodingOrCb, cb);
+      }
+      const logData = {
+        timestamp: getTimestamp(),
+        method: req.method,
+        url: req.originalUrl || req.url,
+        statusCode: res.statusCode,
+        responseTime: responseTimeMs,
+        clientIP: getClientIP(req),
+        userAgent: req.headers["user-agent"]
+      };
+      if (includeBody && req.body && Object.keys(req.body).length > 0) {
+        logData.body = req.body;
+      }
+      if (includeQuery && req.query && Object.keys(req.query).length > 0) {
+        logData.query = req.query;
+      }
+      if (includeHeaders) {
+        logData.headers = req.headers;
+      }
+      if (customLogger) {
+        customLogger(logData);
+      } else {
+        const methodColor = methodColors[req.method] || colors.white;
+        const statusColor = getStatusColor(res.statusCode);
+        const timeFormatted = formatResponseTime(responseTimeMs);
+        const logParts = [
+          `${colors.gray}[${logData.timestamp}]${colors.reset}`,
+          `${methodColor}${colors.bright}${req.method.padEnd(7)}${colors.reset}`,
+          `${colors.white}${logData.url.padEnd(40)}${colors.reset}`,
+          `${statusColor}${colors.bright}${res.statusCode}${colors.reset}`,
+          `${colors.dim}${timeFormatted.padEnd(10)}${colors.reset}`,
+          `${colors.gray}${logData.clientIP}${colors.reset}`
+        ];
+        console.log(logParts.join(" \u2502 "));
+        if (includeBody && logData.body) {
+          console.log(
+            `${colors.gray}  \u2514\u2500 Body: ${formatBody(logData.body)}${colors.reset}`
+          );
+        }
+        if (includeQuery && logData.query) {
+          console.log(
+            `${colors.gray}  \u2514\u2500 Query: ${JSON.stringify(logData.query)}${colors.reset}`
+          );
+        }
+      }
+      return originalEnd(chunk, encodingOrCb, cb);
+    };
+    next();
+  };
+};
+var errorLoggerMiddleware = (err, req, res, next) => {
+  const timestamp = getTimestamp();
+  console.error(
+    `${colors.bgRed}${colors.white}${colors.bright} ERROR ${colors.reset}`,
+    `${colors.gray}[${timestamp}]${colors.reset}`,
+    `${colors.red}${req.method} ${req.url}${colors.reset}`
+  );
+  console.error(`${colors.red}  \u2514\u2500 ${err.message}${colors.reset}`);
+  if (process.env.NODE_ENV !== "production") {
+    console.error(`${colors.dim}${err.stack}${colors.reset}`);
+  }
+  next(err);
+};
+var index_default = loggerMiddleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorLoggerMiddleware,
+  loggerMiddleware
+});

package/dist/index.mjs

@@ -0,0 +1,167 @@
+// index.ts
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Text colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m"
+};
+var methodColors = {
+  GET: colors.green,
+  POST: colors.blue,
+  PUT: colors.yellow,
+  PATCH: colors.magenta,
+  DELETE: colors.red,
+  OPTIONS: colors.cyan,
+  HEAD: colors.gray
+};
+var getStatusColor = (statusCode) => {
+  if (statusCode >= 500) return colors.red;
+  if (statusCode >= 400) return colors.yellow;
+  if (statusCode >= 300) return colors.cyan;
+  if (statusCode >= 200) return colors.green;
+  return colors.white;
+};
+var formatResponseTime = (ms) => {
+  if (ms < 1) return `${(ms * 1e3).toFixed(0)}\u03BCs`;
+  if (ms < 1e3) return `${ms.toFixed(0)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+};
+var getTimestamp = () => {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString().replace("T", " ").substring(0, 19);
+};
+var getClientIP = (req) => {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (typeof forwarded === "string") {
+    return forwarded.split(",")[0].trim();
+  }
+  return req.socket.remoteAddress || "unknown";
+};
+var truncate = (str, maxLength = 100) => {
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength) + "...";
+};
+var formatBody = (body) => {
+  if (!body || typeof body !== "object") return "";
+  const bodyObj = body;
+  if (Object.keys(bodyObj).length === 0) return "";
+  const sanitized = { ...bodyObj };
+  const sensitiveFields = [
+    "password",
+    "token",
+    "secret",
+    "apiKey",
+    "authorization"
+  ];
+  for (const field of sensitiveFields) {
+    if (sanitized[field]) {
+      sanitized[field] = "[REDACTED]";
+    }
+  }
+  try {
+    return truncate(JSON.stringify(sanitized), 200);
+  } catch {
+    return "[Unable to stringify body]";
+  }
+};
+var loggerMiddleware = (options = {}) => {
+  const {
+    skip,
+    includeBody = true,
+    includeQuery = true,
+    includeHeaders = false,
+    customLogger
+  } = options;
+  return (req, res, next) => {
+    const startTime = process.hrtime.bigint();
+    const originalEnd = res.end.bind(res);
+    res.end = function(chunk, encodingOrCb, cb) {
+      const endTime = process.hrtime.bigint();
+      const responseTimeNs = Number(endTime - startTime);
+      const responseTimeMs = responseTimeNs / 1e6;
+      if (skip && skip(req, res)) {
+        return originalEnd(chunk, encodingOrCb, cb);
+      }
+      const logData = {
+        timestamp: getTimestamp(),
+        method: req.method,
+        url: req.originalUrl || req.url,
+        statusCode: res.statusCode,
+        responseTime: responseTimeMs,
+        clientIP: getClientIP(req),
+        userAgent: req.headers["user-agent"]
+      };
+      if (includeBody && req.body && Object.keys(req.body).length > 0) {
+        logData.body = req.body;
+      }
+      if (includeQuery && req.query && Object.keys(req.query).length > 0) {
+        logData.query = req.query;
+      }
+      if (includeHeaders) {
+        logData.headers = req.headers;
+      }
+      if (customLogger) {
+        customLogger(logData);
+      } else {
+        const methodColor = methodColors[req.method] || colors.white;
+        const statusColor = getStatusColor(res.statusCode);
+        const timeFormatted = formatResponseTime(responseTimeMs);
+        const logParts = [
+          `${colors.gray}[${logData.timestamp}]${colors.reset}`,
+          `${methodColor}${colors.bright}${req.method.padEnd(7)}${colors.reset}`,
+          `${colors.white}${logData.url.padEnd(40)}${colors.reset}`,
+          `${statusColor}${colors.bright}${res.statusCode}${colors.reset}`,
+          `${colors.dim}${timeFormatted.padEnd(10)}${colors.reset}`,
+          `${colors.gray}${logData.clientIP}${colors.reset}`
+        ];
+        console.log(logParts.join(" \u2502 "));
+        if (includeBody && logData.body) {
+          console.log(
+            `${colors.gray}  \u2514\u2500 Body: ${formatBody(logData.body)}${colors.reset}`
+          );
+        }
+        if (includeQuery && logData.query) {
+          console.log(
+            `${colors.gray}  \u2514\u2500 Query: ${JSON.stringify(logData.query)}${colors.reset}`
+          );
+        }
+      }
+      return originalEnd(chunk, encodingOrCb, cb);
+    };
+    next();
+  };
+};
+var errorLoggerMiddleware = (err, req, res, next) => {
+  const timestamp = getTimestamp();
+  console.error(
+    `${colors.bgRed}${colors.white}${colors.bright} ERROR ${colors.reset}`,
+    `${colors.gray}[${timestamp}]${colors.reset}`,
+    `${colors.red}${req.method} ${req.url}${colors.reset}`
+  );
+  console.error(`${colors.red}  \u2514\u2500 ${err.message}${colors.reset}`);
+  if (process.env.NODE_ENV !== "production") {
+    console.error(`${colors.dim}${err.stack}${colors.reset}`);
+  }
+  next(err);
+};
+var index_default = loggerMiddleware;
+export {
+  index_default as default,
+  errorLoggerMiddleware,
+  loggerMiddleware
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "elegant-logger",
+  "version": "1.0.1",
+  "description": "A professional, beautiful, and highly customizable Express request and error logger middleware for Node.js services.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "express",
+    "logger",
+    "middleware",
+    "typescript",
+    "ansi-colors",
+    "request-logger"
+  ],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "express": "^5.2.1",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0 || ^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup index.ts --format cjs,esm --dts --clean",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}