@middy/input-output-logger/index.js

const defaults = {
    logger: console.log,
    awsContext: false,
    omitPaths: [],
    mask: undefined,
    replacer: undefined
};
const inputOutputLoggerMiddleware = (opts = {})=>{
    const { logger, awsContext, omitPaths, mask, replacer } = {
        ...defaults,
        ...opts
    };
    if (typeof logger !== 'function') {
        throw new Error('logger must be a function', {
            cause: {
                package: '@middy/input-output-logger'
            }
        });
    }
    const omitPathTree = buildPathTree(omitPaths);
    const omitAndLog = (param, request)=>{
        const message = {
            [param]: request[param]
        };
        if (awsContext) {
            message.context = pick(request.context, awsContextKeys);
        }
        let cloneMessage = message;
        if (omitPaths.length) {
            cloneMessage = structuredClone(message, replacer);
            omit(cloneMessage, {
                [param]: omitPathTree[param]
            });
        }
        logger(cloneMessage);
    };
    const omit = (obj, pathTree = {})=>{
        if (Array.isArray(obj) && pathTree['[]']) {
            for(let i = 0, l = obj.length; i < l; i++){
                omit(obj[i], pathTree['[]']);
            }
        } else if (isObject(obj)) {
            for(const key in pathTree){
                if (pathTree[key] === true) {
                    if (mask) {
                        obj[key] = mask;
                    } else {
                        delete obj[key];
                    }
                } else {
                    omit(obj[key], pathTree[key]);
                }
            }
        }
    };
    const inputOutputLoggerMiddlewareBefore = async (request)=>omitAndLog('event', request);
    const inputOutputLoggerMiddlewareAfter = async (request)=>omitAndLog('response', request);
    const inputOutputLoggerMiddlewareOnError = async (request)=>{
        if (request.response === undefined) return;
        omitAndLog('response', request);
    };
    return {
        before: inputOutputLoggerMiddlewareBefore,
        after: inputOutputLoggerMiddlewareAfter,
        onError: inputOutputLoggerMiddlewareOnError
    };
};
const awsContextKeys = [
    'functionName',
    'functionVersion',
    'invokedFunctionArn',
    'memoryLimitInMB',
    'awsRequestId',
    'logGroupName',
    'logStreamName',
    'identity',
    'clientContext',
    'callbackWaitsForEmptyEventLoop'
];
const pick = (originalObject = {}, keysToPick = [])=>{
    const newObject = {};
    for (const path of keysToPick){
        if (originalObject[path] !== undefined) {
            newObject[path] = originalObject[path];
        }
    }
    return newObject;
};
const buildPathTree = (paths)=>{
    const tree = {};
    for (let path of paths.sort().reverse()){
        if (!Array.isArray(path)) path = path.split('.');
        if (path.includes('__proto__')) continue;
        path.slice(0).reduce((a, b, idx)=>{
            if (idx < path.length - 1) {
                a[b] ??= {};
                return a[b];
            }
            a[b] = true;
            return true;
        }, tree);
    }
    return tree;
};
const isObject = (value)=>value && typeof value === 'object' && value.constructor === Object;
export default inputOutputLoggerMiddleware;