edge-master/dist/interceptors/logging.js

A Micro Framework for Edges

import { InterceptorType } from '../types/interceptor';
const LOG_LEVELS = {
    debug: 0,
    info: 1,
    warn: 2,
    error: 3,
};
const defaultLogger = (level, message, data) => {
    const logFn = console[level] || console.log;
    if (data) {
        logFn(`[${level.toUpperCase()}] ${message}`, data);
    }
    else {
        logFn(`[${level.toUpperCase()}] ${message}`);
    }
};
/**
 * Creates a request logging interceptor
 */
export function requestLoggingInterceptor(options = {}) {
    const { level = 'info', logger = defaultLogger, logRequest = true, } = options;
    const minLevel = LOG_LEVELS[level];
    return {
        type: InterceptorType.Request,
        async intercept(ctx) {
            if (!logRequest || LOG_LEVELS.info < minLevel) {
                return ctx.reqCtx.req;
            }
            const req = ctx.reqCtx.req;
            const url = new URL(req.url);
            logger('info', 'Incoming request', {
                method: req.method,
                url: req.url,
                pathname: url.pathname,
                search: url.search,
                headers: Object.fromEntries(req.headers.entries()),
            });
            // Store request start time in state for timing
            ctx.state.set('__requestStartTime', Date.now());
            return req;
        },
    };
}
/**
 * Creates a response logging interceptor
 */
export function responseLoggingInterceptor(options = {}) {
    const { level = 'info', logger = defaultLogger, logResponse = true, logTiming = true, } = options;
    const minLevel = LOG_LEVELS[level];
    return {
        type: InterceptorType.Response,
        async intercept(ctx) {
            if (!logResponse || LOG_LEVELS.info < minLevel) {
                return ctx.res;
            }
            const url = new URL(ctx.reqCtx.req.url);
            const logData = {
                method: ctx.reqCtx.req.method,
                pathname: url.pathname,
                status: ctx.res.status,
                statusText: ctx.res.statusText,
            };
            // Add timing information if available
            if (logTiming) {
                const startTime = ctx.state.get('__requestStartTime');
                if (startTime) {
                    logData.duration = `${Date.now() - startTime}ms`;
                }
            }
            // Log based on status code
            if (ctx.res.status >= 500) {
                logger('error', 'Response error', logData);
            }
            else if (ctx.res.status >= 400) {
                logger('warn', 'Response client error', logData);
            }
            else {
                logger('info', 'Response success', logData);
            }
            return ctx.res;
        },
    };
}
/**
 * Creates both request and response logging interceptors
 */
export function loggingInterceptor(options = {}) {
    return {
        request: requestLoggingInterceptor(options),
        response: responseLoggingInterceptor(options),
    };
}