@munlib/common 1.0.248 → 1.1.2

package/README.md

@@ -1,8 +1,30 @@
+# @munlib/common
 
+## HTTP logs in MongoDB
+
+`createHttpLogger` captures completed Express requests and responses. The consuming service owns the MongoDB connection and collection; a logging failure is swallowed and never changes the HTTP response.
+
+```ts
+import mongoose from "mongoose";
+import { createHttpLogger } from "@munlib/common";
+
+app.use(createHttpLogger({
+  serviceName: "payment",
+  environment: process.env.ENVIRONMENT,
+  write: (document) => mongoose.connection
+    .collection(process.env.HTTP_LOG_COLLECTION || "http_logs")
+    .insertOne(document)
+}));
+```
+
+Register the middleware after the JSON parser and before authentication or routes. It automatically redacts credentials and payment-sensitive fields, limits request and response payloads to 16 KB, adds `x-request-id`, and only persists complete JSON response bodies. Other response types are represented by safe metadata.
+
+Use `redactFields`, `maxPayloadBytes`, `shouldLog`, and `onWriteError` to customize the behavior.
+
+## Publishing
+
+```sh
 npm run build
 npm publish --dry-run
-npm run pub -- --otp=token de npm 
-npm config set "//registry.npmjs.org/:_authToken=TU_TOKEN_NUEVO" --location=user
-luego
-npm whoami
-npm publish
+npm run pub -- --otp=token-de-npm
+```

package/build/index.d.ts

@@ -11,4 +11,5 @@ export * from './middlewares/validate-request';
 export * from './events/subjects';
 export * from './events/types/order-status';
 export * from './events/types/instituciones-pagos';
+export * from './logs/logger';
 export * from "./errors/erroresStatus";

package/build/index.js

@@ -29,6 +29,6 @@ __exportStar(require("./middlewares/validate-request"), exports);
 __exportStar(require("./events/subjects"), exports);
 __exportStar(require("./events/types/order-status"), exports);
 __exportStar(require("./events/types/instituciones-pagos"), exports);
-//export * from './logs/logger';
+__exportStar(require("./logs/logger"), exports);
 __exportStar(require("./errors/erroresStatus"), exports);
 //export * from './middlewares/apm';

package/build/logs/logger.d.ts

@@ -0,0 +1,37 @@
+import { Request, RequestHandler } from "express";
+export interface HttpLogDocument {
+    timestamp: Date;
+    serviceName: string;
+    environment?: string;
+    requestId: string;
+    method: string;
+    path: string;
+    clientIp?: string;
+    userAgent?: string;
+    request: {
+        headers: {
+            [key: string]: unknown;
+        };
+        query: unknown;
+        params: unknown;
+        body: unknown;
+    };
+    response: {
+        statusCode: number;
+        headers: {
+            [key: string]: unknown;
+        };
+        body: unknown;
+    };
+    durationMs: number;
+}
+export interface HttpLoggerOptions {
+    serviceName: string;
+    write: (document: HttpLogDocument) => Promise<unknown> | unknown;
+    environment?: string;
+    redactFields?: string[];
+    maxPayloadBytes?: number;
+    shouldLog?: (request: Request) => boolean;
+    onWriteError?: (error: unknown) => void;
+}
+export declare function createHttpLogger(options: HttpLoggerOptions): RequestHandler;

package/build/logs/logger.js

@@ -1,10 +1,229 @@
 "use strict";
-//@ts-ignore
-/* import { LogService } from "logstash-winston-3";
-
-export const logger = LogService.getInstance({
-  serviceName:  process.env.SERVICE_NAME,
-  logstashHost: process.env.LOGS_SERVER,
-  logstashPort: process.env.LOGS_PORT,
-});
- */ 
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpLogger = createHttpLogger;
+var DEFAULT_REDACTED_FIELDS = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "api-key",
+    "password",
+    "token",
+    "access-token",
+    "refresh-token",
+    "secret",
+    "cvv",
+    "card-number"
+];
+function normalizeFieldName(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isSensitiveField(fieldName, redactedFields) {
+    var normalized = normalizeFieldName(fieldName);
+    return redactedFields.indexOf(normalized) !== -1
+        || normalized.indexOf("password") !== -1
+        || normalized.indexOf("token") !== -1
+        || normalized.indexOf("secret") !== -1
+        || normalized.indexOf("authorization") !== -1
+        || normalized.indexOf("cookie") !== -1
+        || normalized.indexOf("apikey") !== -1
+        || normalized.indexOf("cardnumber") !== -1
+        || normalized === "cvv";
+}
+function sanitize(value, redactedFields, ancestors, depth) {
+    if (ancestors === void 0) { ancestors = []; }
+    if (depth === void 0) { depth = 0; }
+    if (value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (depth >= 8) {
+        return "[Truncated: maximum depth]";
+    }
+    if (typeof value !== "object") {
+        return String(value);
+    }
+    if (ancestors.indexOf(value) !== -1) {
+        return "[Circular]";
+    }
+    var nextAncestors = ancestors.concat([value]);
+    if (Array.isArray(value)) {
+        return value.map(function (item) { return sanitize(item, redactedFields, nextAncestors, depth + 1); });
+    }
+    var result = {};
+    Object.keys(value).forEach(function (key) {
+        var record = value;
+        result[key] = isSensitiveField(key, redactedFields)
+            ? "[REDACTED]"
+            : sanitize(record[key], redactedFields, nextAncestors, depth + 1);
+    });
+    return result;
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+function truncateText(value, maxBytes) {
+    if (byteLength(value) <= maxBytes) {
+        return value;
+    }
+    var result = "";
+    for (var index = 0; index < value.length; index += 1) {
+        var next = result + value[index];
+        if (byteLength(next) > maxBytes) {
+            break;
+        }
+        result = next;
+    }
+    return result;
+}
+function limitPayload(value, maxBytes) {
+    var serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch (_error) {
+        serialized = String(value);
+    }
+    if (byteLength(serialized) <= maxBytes) {
+        return value;
+    }
+    return {
+        truncated: true,
+        sizeBytes: byteLength(serialized),
+        preview: truncateText(serialized, maxBytes)
+    };
+}
+function responseBody(content, contentType, wasTruncated, maxBytes, redactedFields) {
+    var normalizedContentType = contentType ? contentType.toLowerCase() : "";
+    var jsonContent = normalizedContentType.indexOf("application/json") !== -1;
+    if (!jsonContent) {
+        return { omitted: true, reason: "non-json-response" };
+    }
+    if (wasTruncated) {
+        return { truncated: true, capturedBytes: byteLength(content) };
+    }
+    try {
+        return limitPayload(sanitize(JSON.parse(content), redactedFields), maxBytes);
+    }
+    catch (_error) {
+        return { omitted: true, reason: "invalid-json-response" };
+    }
+}
+function createRequestId() {
+    return Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 10);
+}
+function reportWriteError(error, onWriteError) {
+    if (!onWriteError) {
+        return;
+    }
+    try {
+        onWriteError(error);
+    }
+    catch (_callbackError) {
+        // Logging failures must never affect the request lifecycle.
+    }
+}
+function createHttpLogger(options) {
+    var maxPayloadBytes = options.maxPayloadBytes || 16 * 1024;
+    var redactedFields = DEFAULT_REDACTED_FIELDS
+        .concat(options.redactFields || [])
+        .map(normalizeFieldName);
+    return function (req, res, next) {
+        try {
+            if (options.shouldLog && !options.shouldLog(req)) {
+                next();
+                return;
+            }
+            var startedAt_1 = Date.now();
+            var suppliedRequestId = req.header("x-request-id");
+            var requestId_1 = suppliedRequestId && suppliedRequestId.length <= 128
+                ? suppliedRequestId
+                : createRequestId();
+            var responseContent_1 = "";
+            var responseTruncated_1 = false;
+            var originalWrite_1 = res.write.bind(res);
+            var originalEnd_1 = res.end.bind(res);
+            res.setHeader("x-request-id", requestId_1);
+            var captureResponseChunk_1 = function (chunk) {
+                try {
+                    if (chunk === undefined || chunk === null || responseTruncated_1) {
+                        return;
+                    }
+                    var text = typeof chunk === "string"
+                        ? chunk
+                        : typeof chunk.toString === "function"
+                            ? chunk.toString("utf8")
+                            : undefined;
+                    if (text === undefined) {
+                        return;
+                    }
+                    var availableBytes = maxPayloadBytes - byteLength(responseContent_1);
+                    if (availableBytes <= 0) {
+                        responseTruncated_1 = true;
+                        return;
+                    }
+                    if (byteLength(text) > availableBytes) {
+                        responseContent_1 += truncateText(text, availableBytes);
+                        responseTruncated_1 = true;
+                        return;
+                    }
+                    responseContent_1 += text;
+                }
+                catch (error) {
+                    reportWriteError(error, options.onWriteError);
+                }
+            };
+            res.write = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                captureResponseChunk_1(args[0]);
+                return originalWrite_1.apply(void 0, args);
+            };
+            res.end = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                captureResponseChunk_1(args[0]);
+                return originalEnd_1.apply(void 0, args);
+            };
+            res.once("finish", function () {
+                try {
+                    var document = {
+                        timestamp: new Date(),
+                        serviceName: options.serviceName,
+                        environment: options.environment,
+                        requestId: requestId_1,
+                        method: req.method,
+                        path: req.path,
+                        clientIp: req.ip,
+                        userAgent: req.get("user-agent"),
+                        request: {
+                            headers: sanitize(req.headers, redactedFields),
+                            query: limitPayload(sanitize(req.query, redactedFields), maxPayloadBytes),
+                            params: limitPayload(sanitize(req.params, redactedFields), maxPayloadBytes),
+                            body: limitPayload(sanitize(req.body, redactedFields), maxPayloadBytes)
+                        },
+                        response: {
+                            statusCode: res.statusCode,
+                            headers: sanitize(res.getHeaders(), redactedFields),
+                            body: responseBody(responseContent_1, res.getHeader("content-type"), responseTruncated_1, maxPayloadBytes, redactedFields)
+                        },
+                        durationMs: Date.now() - startedAt_1
+                    };
+                    Promise.resolve(options.write(document)).catch(function (error) {
+                        reportWriteError(error, options.onWriteError);
+                    });
+                }
+                catch (error) {
+                    reportWriteError(error, options.onWriteError);
+                }
+            });
+        }
+        catch (error) {
+            reportWriteError(error, options.onWriteError);
+        }
+        next();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@munlib/common",
-  "version": "1.0.248",
+  "version": "1.1.2",
   "description": "Common errors, middlewares and shared types for Munlib services",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",