@beignet/core/dist/server/hooks/logging.js

Core framework primitives for Beignet

/**
 * Logging hook utilities for @beignet/core/server
 */
import { resolveTrustedRequest, } from "../trusted-proxy.js";
import { getRequestIdFromContext } from "./utils.js";
function loggingRequestInfo(req, requestInfo) {
    return requestInfo ?? resolveTrustedRequest(req);
}
/**
 * Create request logging hooks.
 *
 * Logging observer errors are intentionally ignored so logging cannot break
 * request handling.
 */
export function createLoggingHooks(config) {
    const requestIdHeader = config.requestIdHeader;
    return {
        name: "logging",
        onRequest: ({ req, requestInfo, contract }) => {
            if (config.onRequestStart) {
                try {
                    config.onRequestStart({
                        req,
                        requestInfo: loggingRequestInfo(req, requestInfo),
                        contract,
                        ctx: undefined,
                    });
                }
                catch {
                    // Ignore logging errors
                }
                return undefined;
            }
            if (!config.logger)
                return undefined;
            try {
                config.logger.info({
                    method: req.method,
                    url: loggingRequestInfo(req, requestInfo).url.pathname,
                }, "Request start");
            }
            catch {
                // Ignore logging errors
            }
            return undefined;
        },
        ...(requestIdHeader
            ? {
                beforeSend: ({ ctx, response }) => {
                    const requestId = getRequestIdFromContext(ctx);
                    if (!requestId) {
                        return response;
                    }
                    return {
                        ...response,
                        headers: {
                            ...(response.headers ?? {}),
                            [requestIdHeader]: String(requestId),
                        },
                    };
                },
            }
            : {}),
        afterSend: ({ ctx, req, requestInfo, response, durationMs, contract, error, }) => {
            const headers = response.headers ?? {};
            if (config.onRequestEnd) {
                try {
                    config.onRequestEnd({
                        ctx,
                        req,
                        requestInfo: loggingRequestInfo(req, requestInfo),
                        res: { status: response.status, headers },
                        durationMs,
                        contract,
                        error,
                    });
                }
                catch {
                    // Ignore logging errors
                }
                return;
            }
            if (!config.logger)
                return;
            try {
                const requestId = getRequestIdFromContext(ctx);
                const payload = {
                    method: req.method,
                    url: loggingRequestInfo(req, requestInfo).url.pathname,
                    status: response.status,
                    durationMs: Math.round(durationMs),
                    ...(requestId !== undefined ? { requestId } : {}),
                    ...(error !== undefined ? { error } : {}),
                };
                if (error !== undefined) {
                    config.logger.error(payload, "Request complete with error");
                    return;
                }
                config.logger.info(payload, "Request complete");
            }
            catch {
                // Ignore logging errors
            }
        },
    };
}
//# sourceMappingURL=logging.js.map