swaf/src/components/LogRequestsComponent.ts

import ApplicationComponent from "../ApplicationComponent";
import onFinished from "on-finished";
import Logger from "../Logger";
import {Request, Response, Router} from "express";
import {HttpError} from "../HttpError";

export default class LogRequestsComponent extends ApplicationComponent {
    private static fullRequests: boolean = false;

    public static logFullHttpRequests(): void {
        this.fullRequests = true;
        Logger.info('Http requests will be logged with more details.');
    }

    public static logRequest(
        req: Request,
        res: Response,
        err?: unknown,
        additionalStr: string = '',
        silent: boolean = false,
    ): string {
        if (LogRequestsComponent.fullRequests) {
            const requestObj = JSON.stringify({
                ip: req.ip,
                host: req.hostname,
                method: req.method,
                url: req.originalUrl,
                headers: req.headers,
                query: req.query,
                params: req.params,
                body: req.body,
                files: req.files,
                cookies: req.cookies,
                sessionId: req.session?.id,
                result: {
                    code: res.statusCode,
                },
            }, null, 4);
            if (err) {
                if (err instanceof Error) {
                    return Logger.error(err, requestObj, err);
                } else {
                    return Logger.error(new Error(String(err)), requestObj);
                }
            } else {
                Logger.info(requestObj);
            }
        } else {
            let logStr = `${req.method} ${req.originalUrl} - ${res.statusCode}`;
            if (err) {
                if (err instanceof Error) {
                    if (silent) {
                        if (err instanceof HttpError) logStr += ` ${err.errorCode}`;
                        logStr += ` ${err.name}`;
                        return Logger.silentError(err, logStr);
                    } else {
                        return Logger.error(err, logStr, additionalStr, err);
                    }
                } else {
                    return Logger.error(new Error(String(err)), logStr);
                }
            } else {
                Logger.info(logStr);
            }
        }

        return '';
    }

    public async init(router: Router): Promise<void> {
        router.use((req, res, next) => {
            onFinished(res, (err) => {
                if (!err) {
                    LogRequestsComponent.logRequest(req, res);
                }
            });
            next();
        });
    }
}