@aws-lambda-powertools/logger/lib/cjs/middleware/middy.js

The logging package for the Powertools for AWS Lambda (TypeScript) library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.injectLambdaContext = void 0;
const commons_1 = require("@aws-lambda-powertools/commons");
const constants_js_1 = require("../constants.js");
const Logger_js_1 = require("../Logger.js");
/**
 * A Middy.js-compatible middleware to enrich your logs with AWS Lambda context information.
 *
 * Using this middleware on your handler function will automatically adds context information to logs,
 * as well as optionally log the event and clear attributes set during the invocation.
 *
 * @example
 * ```typescript
 * import { Logger } from '@aws-lambda-powertools/logger';
 * import { injectLambdaContext } from '@aws-lambda-powertools/logger/middleware';
 * import middy from '@middy/core';
 *
 * const logger = new Logger({ serviceName: 'serverlessAirline' });
 *
 * export const handler = middy(() => {
 *   logger.info('This is an INFO log with some context');
 * }).use(injectLambdaContext(logger));
 * ```
 *
 * **Logging the event payload**
 *
 * When debugging, you might want to log the event payload to understand the input to your Lambda function.
 * You can enable this by setting the `logEvent` option to `true` when creating the Logger instance.
 *
 * @example
 * ```typescript
 * const logger = new Logger({ serviceName: 'serverlessAirline' });
 *
 * export const handler = middy(() => {
 *   logger.info('This is an INFO log with some context');
 * }).use(injectLambdaContext(logger, {
 *   logEvent: true,
 * }));
 * ```
 *
 * **Resetting state**
 *
 * To avoid leaking sensitive information across invocations, you can reset the keys added via
 * {@link Logger.appendKeys()} by setting the `resetKeys` option to `true`.
 *
 * @example
 * ```typescript
 * const logger = new Logger({ serviceName: 'serverlessAirline' });
 *
 * export const handler = middy(() => {
 *   logger.appendKeys({ key1: 'value1' });
 *   logger.info('This is an INFO log with some context');
 * }).use(injectLambdaContext(logger, {
 *   resetKeys: true,
 * }));
 *
 * @param target - The Logger instance(s) to use for logging
 * @param options - Options for the middleware such as clearing state or resetting keys
 */
const injectLambdaContext = (target, options) => {
    const loggers = Array.isArray(target) ? target : [target];
    const isResetStateEnabled = options && (options.clearState || options.resetKeys);
    /**
     * Set the cleanup function to be called in case other middlewares return early.
     *
     * @param request - The request object
     */
    const setCleanupFunction = (request) => {
        request.internal = {
            ...request.internal,
            [commons_1.LOGGER_KEY]: after,
        };
    };
    const before = async (request) => {
        for (const logger of loggers) {
            if (isResetStateEnabled) {
                setCleanupFunction(request);
            }
            logger.refreshSampleRateCalculation();
            Logger_js_1.Logger.injectLambdaContextBefore(logger, request.event, request.context, options);
            if (options?.correlationIdPath) {
                logger.setCorrelationId(request.event, options.correlationIdPath);
            }
        }
    };
    const after = async () => {
        for (const logger of loggers) {
            logger.clearBuffer();
            if (isResetStateEnabled) {
                logger.resetKeys();
            }
        }
    };
    const onError = async ({ error }) => {
        for (const logger of loggers) {
            if (options?.flushBufferOnUncaughtError) {
                logger.flushBuffer();
                logger.error({
                    message: constants_js_1.UncaughtErrorLogMessage,
                    error,
                });
            }
            else {
                logger.clearBuffer();
            }
            if (isResetStateEnabled) {
                logger.resetKeys();
            }
        }
    };
    return {
        before,
        after,
        onError,
    };
};
exports.injectLambdaContext = injectLambdaContext;