@energica-city/shared-amplify-utils/dist/middleware/rest/RestRequestLogger.js

Shared utilities for AWS Amplify projects

import { logger } from '../../log';
import { sanitizeObject } from '../utils/sanitization';
import { extractEventInfo, parseJsonBodyWithFallback, initializeRestMiddleware, } from './utils';
/**
 * Builds structured log data for incoming REST requests
 * @param input - REST input containing event and context
 * @param config - Logger configuration options
 * @returns Object containing sanitized request information for logging
 */
function buildEventLog(input, config) {
    const { event } = input;
    const { logRequestBody = false, excludeEventFields = [], maxDepth = 3, } = config;
    const basicInfo = extractEventInfo(event);
    if (logRequestBody && event.body) {
        const parsedBody = parseJsonBodyWithFallback(event.body, '[Invalid JSON]');
        return {
            ...basicInfo,
            body: sanitizeObject(parsedBody, {
                excludeFields: excludeEventFields,
                maxDepth,
            }),
        };
    }
    return basicInfo;
}
/**
 * Builds structured log data for outgoing REST responses
 * @param response - REST response object
 * @param config - Logger configuration options
 * @param duration - Request processing duration
 * @param requestId - Request identifier for tracking
 * @returns Object containing sanitized response information for logging
 */
function buildResponseLog(response, config, duration, requestId) {
    const { excludeResponseFields = [], maxDepth = 3 } = config;
    let responseBody = null;
    if (response.body) {
        const parsedBody = parseJsonBodyWithFallback(response.body, '[Invalid JSON]');
        responseBody = sanitizeObject(parsedBody, {
            excludeFields: excludeResponseFields,
            maxDepth,
        });
    }
    return {
        statusCode: response.statusCode,
        body: responseBody,
        headers: response.headers || {},
        duration,
        requestId,
    };
}
/**
 * Creates REST request logger middleware for comprehensive request/response logging
 *
 * Provides structured logging of HTTP requests and responses with configurable detail levels,
 * timing information, and data sanitization. Supports different log levels and can exclude
 * sensitive fields from logs.
 *
 * @param config - Configuration options for logging behavior
 * @returns Middleware function that logs requests and responses
 *
 * @example
 * ```typescript
 * // Basic logging
 * const logger = createRestRequestLogger({
 *   logEvent: true,
 *   logResponse: true,
 *   logTiming: true
 * });
 *
 * // Production logging with sensitive data exclusion
 * const prodLogger = createRestRequestLogger({
 *   logRequestBody: false,
 *   excludeEventFields: ['authorization', 'password'],
 *   excludeResponseFields: ['token', 'secret'],
 *   logLevel: 'info'
 * });
 *
 * chain.use('logger', logger);
 * ```
 */
export function createRestRequestLogger(config = {}) {
    const { logEvent = true, logResponse = true, logTiming = true, defaultContext = {}, logLevel = 'info', forceStructuredLogging = true, } = config;
    return async (input, next) => {
        const startTime = Date.now();
        const { context, requestId } = initializeRestMiddleware(input, {
            defaultContext,
            forceStructuredLogging,
            operation: 'requestLogging',
        });
        if (logEvent) {
            const eventLog = buildEventLog(input, config);
            logger[logLevel]('REST request received', {
                ...context,
            }, [eventLog]);
        }
        try {
            const response = await next(input);
            const duration = logTiming ? `${Date.now() - startTime}ms` : '0ms';
            if (logResponse) {
                const responseLog = buildResponseLog(response, config, duration, requestId);
                logger[logLevel]('REST response sent', {
                    ...context,
                }, [responseLog]);
            }
            return response;
        }
        catch (error) {
            const duration = logTiming ? `${Date.now() - startTime}ms` : '0ms';
            logger.error('REST request failed', {
                ...context,
                duration,
                error: error instanceof Error ? error.message : String(error),
            });
            throw error;
        }
    };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RestRequestLogger.js","sourceRoot":"","sources":["../../../middleware/rest/RestRequestLogger.ts"],"names":[],"mappings":"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","sourcesContent":["import { logger } from '../../log';\nimport type { Middleware } from '../middlewareChain';\nimport type {\n  RestInputWithModels,\n  RestRequestLoggerConfig,\n  RestResponse,\n  DefaultModelTypes,\n} from './types';\nimport type { AmplifyModelType } from '../../queries/types';\nimport { sanitizeObject } from '../utils/sanitization';\nimport {\n  extractEventInfo,\n  parseJsonBodyWithFallback,\n  initializeRestMiddleware,\n} from './utils';\n\n/**\n * Builds structured log data for incoming REST requests\n * @param input - REST input containing event and context\n * @param config - Logger configuration options\n * @returns Object containing sanitized request information for logging\n */\nfunction buildEventLog(\n  input: RestInputWithModels,\n  config: RestRequestLoggerConfig,\n): Record<string, unknown> {\n  const { event } = input;\n  const {\n    logRequestBody = false,\n    excludeEventFields = [],\n    maxDepth = 3,\n  } = config;\n\n  const basicInfo = extractEventInfo(event);\n\n  if (logRequestBody && event.body) {\n    const parsedBody = parseJsonBodyWithFallback(event.body, '[Invalid JSON]');\n    return {\n      ...basicInfo,\n      body: sanitizeObject(parsedBody, {\n        excludeFields: excludeEventFields,\n        maxDepth,\n      }),\n    };\n  }\n\n  return basicInfo;\n}\n\n/**\n * Builds structured log data for outgoing REST responses\n * @param response - REST response object\n * @param config - Logger configuration options\n * @param duration - Request processing duration\n * @param requestId - Request identifier for tracking\n * @returns Object containing sanitized response information for logging\n */\nfunction buildResponseLog(\n  response: RestResponse,\n  config: RestRequestLoggerConfig,\n  duration: string,\n  requestId: string,\n): Record<string, unknown> {\n  const { excludeResponseFields = [], maxDepth = 3 } = config;\n\n  let responseBody = null;\n  if (response.body) {\n    const parsedBody = parseJsonBodyWithFallback(\n      response.body,\n      '[Invalid JSON]',\n    );\n    responseBody = sanitizeObject(parsedBody, {\n      excludeFields: excludeResponseFields,\n      maxDepth,\n    });\n  }\n\n  return {\n    statusCode: response.statusCode,\n    body: responseBody,\n    headers: response.headers || {},\n    duration,\n    requestId,\n  };\n}\n\n/**\n * Creates REST request logger middleware for comprehensive request/response logging\n *\n * Provides structured logging of HTTP requests and responses with configurable detail levels,\n * timing information, and data sanitization. Supports different log levels and can exclude\n * sensitive fields from logs.\n *\n * @param config - Configuration options for logging behavior\n * @returns Middleware function that logs requests and responses\n *\n * @example\n * ```typescript\n * // Basic logging\n * const logger = createRestRequestLogger({\n *   logEvent: true,\n *   logResponse: true,\n *   logTiming: true\n * });\n *\n * // Production logging with sensitive data exclusion\n * const prodLogger = createRestRequestLogger({\n *   logRequestBody: false,\n *   excludeEventFields: ['authorization', 'password'],\n *   excludeResponseFields: ['token', 'secret'],\n *   logLevel: 'info'\n * });\n *\n * chain.use('logger', logger);\n * ```\n */\nexport function createRestRequestLogger<\n  TTypes extends Record<string, AmplifyModelType> = DefaultModelTypes,\n>(\n  config: RestRequestLoggerConfig = {},\n): Middleware<RestInputWithModels<TTypes>, RestResponse> {\n  const {\n    logEvent = true,\n    logResponse = true,\n    logTiming = true,\n    defaultContext = {},\n    logLevel = 'info',\n    forceStructuredLogging = true,\n  } = config;\n\n  return async (input, next) => {\n    const startTime = Date.now();\n\n    const { context, requestId } = initializeRestMiddleware(\n      input as RestInputWithModels,\n      {\n        defaultContext,\n        forceStructuredLogging,\n        operation: 'requestLogging',\n      },\n    );\n\n    if (logEvent) {\n      const eventLog = buildEventLog(input as RestInputWithModels, config);\n      logger[logLevel](\n        'REST request received',\n        {\n          ...context,\n        },\n        [eventLog],\n      );\n    }\n\n    try {\n      const response = await next(input);\n      const duration = logTiming ? `${Date.now() - startTime}ms` : '0ms';\n\n      if (logResponse) {\n        const responseLog = buildResponseLog(\n          response,\n          config,\n          duration,\n          requestId,\n        );\n        logger[logLevel](\n          'REST response sent',\n          {\n            ...context,\n          },\n          [responseLog],\n        );\n      }\n\n      return response;\n    } catch (error) {\n      const duration = logTiming ? `${Date.now() - startTime}ms` : '0ms';\n\n      logger.error('REST request failed', {\n        ...context,\n        duration,\n        error: error instanceof Error ? error.message : String(error),\n      });\n\n      throw error;\n    }\n  };\n}\n"]}