AWS Lambda automatically monitors Lambda functions and sends log entries to Amazon CloudWatch. Your Lambda function comes with a CloudWatch Logs log group and a log stream for each instance of your function. The Lambda runtime environment sends details about each invocation and other output from your function's code to the log stream. For more information about CloudWatch Logs, seeSending Lambda function logs to CloudWatch Logs.

To output logs from your function code, you can use the built-inlogging module. For more detailed entries, you can use any logging library that writes tostdout orstderr.

Printing to the log

To send basic output to the logs, you can use aprint method in your function. The following example logs the values of the CloudWatch Logs log group and stream, and the event object.

Note that if your function outputs logs using Pythonprint statements, Lambda can only send log outputs to CloudWatch Logs in plain text format. To capture logs in structured JSON, you need to use a supported logging library. SeeUsing Lambda advanced logging controls with Python for more information.

import osdef lambda_handler(event, context):    print('## ENVIRONMENT VARIABLES')    print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])    print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])    print('## EVENT')    print(event)

START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST## ENVIRONMENT VARIABLES/aws/lambda/my-function2025/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c## EVENT{'key': 'value'}END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95  Duration: 15.74 ms  Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 130.49 msXRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1   SegmentId: 07f5xmpl2d1f6f85 Sampled: true

The Python runtime logs theSTART,END, andREPORT lines for each invocation. TheREPORT line includes the following data:

Using a logging library

For more detailed logs, use thelogging module in the standard library, or any third party logging library that writes tostdout orstderr.

For supported Python runtimes, you can choose whether logs created using the standardlogging module are captured in plain text or JSON. To learn more, seeUsing Lambda advanced logging controls with Python.

Currently, the default log format for all Python runtimes is plain text. The following example shows how log outputs created using the standardlogging module are captured in plain text in CloudWatch Logs.

import osimport logginglogger = logging.getLogger()logger.setLevel("INFO")  def lambda_handler(event, context):    logger.info('## ENVIRONMENT VARIABLES')    logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])    logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])    logger.info('## EVENT')    logger.info(event)

The output fromlogger includes the log level, timestamp, and request ID.

START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST[INFO]  2025-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## ENVIRONMENT VARIABLES[INFO]  2025-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    /aws/lambda/my-function[INFO]  2025-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    2025/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d[INFO]  2025-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## EVENT[INFO]  2025-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125{'key': 'value'}END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125  Duration: 2.75 ms   Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 113.51 msXRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370   SegmentId: 073cxmpl3e442861 Sampled: true

Using Lambda advanced logging controls with Python

To give you more control over how your functions’ logs are captured, processed, and consumed, you can configure the following logging options for supported Lambda Python runtimes:

For more information about these logging options, and instructions on how to configure your function to use them, seeConfiguring advanced logging controls for Lambda functions.

To learn more about using the log format and log level options with your Python Lambda functions, see the guidance in the following sections.

Using structured JSON logs with Python

If you select JSON for your function’s log format, Lambda will send logs output by the Python standard logging library to CloudWatch as structured JSON. Each JSON log object contains at least four key value pairs with the following keys:

The Pythonlogging library can also add extra key value pairs such as"logger" to this JSON object.

The examples in the following sections show how log outputs generated using the Pythonlogging library are captured in CloudWatch Logs when you configure your function's log format as JSON.

Note that if you use theprint method to produce basic log outputs as described inPrinting to the log, Lambda will capture these outputs as plain text, even if you configure your function’s logging format as JSON.

Standard JSON log outputs using Python logging library

The following example code snippet and log output show how standard log outputs generated using the Pythonlogging library are captured in CloudWatch Logs when your function's log format is set to JSON.

import logging  logger = logging.getLogger()def lambda_handler(event, context):    logger.info("Inside the handler function")

{    "timestamp":"2025-10-27T19:17:45.586Z",    "level":"INFO",    "message":"Inside the handler function",    "logger": "root",    "requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"}

Logging extra parameters in JSON

When your function's log format is set to JSON, you can also log additional parameters with the standard Pythonlogging library by using theextra keyword to pass a Python dictionary to the log output.

import loggingdef lambda_handler(event, context):    logging.info(        "extra parameters example",         extra={"a":"b", "b": [3]},    )

{  "timestamp": "2025-11-02T15:26:28Z",  "level": "INFO",  "message": "extra parameters example",  "logger": "root",  "requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",  "a": "b",  "b": [    3  ]}

Logging exceptions in JSON

The following code snippet shows how Python exceptions are captured in your function's log output when you configure the log format as JSON. Note that log outputs generated usinglogging.exception are assigned the log level ERROR.

import loggingdef lambda_handler(event, context):    try:        raise Exception("exception")    except:        logging.exception("msg")

{  "timestamp": "2025-11-02T16:18:57Z",  "level": "ERROR",  "message": "msg",  "logger": "root",  "stackTrace": [    "  File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n    raise Exception(\"exception\")\n"  ],  "errorType": "Exception",  "errorMessage": "exception",  "requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",  "location": "/var/task/lambda_function.py:lambda_handler:17"}

JSON structured logs with other logging tools

If your code already uses another logging library, such as Powertools for AWS Lambda, to produce JSON structured logs, you don’t need to make any changes. AWS Lambda doesn’t double-encode any logs that are already JSON encoded. Even if you configure your function to use the JSON log format, your logging outputs appear in CloudWatch in the JSON structure you define.

The following example shows how log outputs generated using the Powertools for AWS Lambda package are captured in CloudWatch Logs. The format of this log output is the same whether your function’s logging configuration is set to JSON or TEXT. For more information about using Powertools for AWS Lambda, seeUsing Powertools for AWS Lambda (Python) and AWS SAM for structured logging andUsing Powertools for AWS Lambda (Python) and AWS CDK for structured logging

from aws_lambda_powertools import Loggerlogger = Logger()def lambda_handler(event, context):    logger.info("Inside the handler function")

{     "level": "INFO",     "location": "lambda_handler:7",     "message": "Inside the handler function",     "timestamp": "2025-10-31 22:38:21,010+0000",     "service": "service_undefined",     "xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30" }

Using log-level filtering with Python

By configuring log-level filtering, you can choose to send only logs of a certain logging level or lower to CloudWatch Logs. To learn how to configure log-level filtering for your function, seeLog-level filtering.

For AWS Lambda to filter your application logs according to their log level, your function must use JSON formatted logs. You can achieve this in two ways:

For Lambda to filter your function's logs, you must also include a"timestamp" key value pair in your JSON log output. The time must be specified in validRFC 3339 timestamp format. If you don't supply a valid timestamp, Lambda will assign the log the level INFO and add a timestamp for you.

Viewing logs in Lambda console

You can use the Lambda console to view log output after you invoke a Lambda function.

If your code can be tested from the embeddedCode editor, you will find logs in theexecution results. When you use the console test feature to invoke a function, you'll findLog output in theDetails section.

Viewing logs in CloudWatch console

You can use the Amazon CloudWatch console to view logs for all Lambda function invocations.

Each log stream corresponds to aninstance of your function. A log stream appears when you update your Lambda function, and when additional instances are created to handle concurrent invocations. To find logs for a specific invocation, we recommend instrumenting your function with AWS X-Ray. X-Ray records details about the request and the log stream in the trace.

Viewing logs with AWS CLI

The AWS CLI is an open-source tool that enables you to interact with AWS services using commands in your command line shell. To complete the steps in this section, you must have theAWS CLI version 2.

You can use theAWS CLI to retrieve logs for an invocation using the--log-type command option. The response contains aLogResult field that contains up to 4 KB of base64-encoded logs from the invocation.

aws lambda invoke --function-name my-function out --log-type Tail

{    "StatusCode": 200,    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",    "ExecutedVersion": "$LATEST"}

aws lambda invoke --function-name my-function out --log-type Tail \--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode

START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB

#!/bin/bashaws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' outsed -i'' -e 's/"//g' outsleep 15aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-namestream1 --limit 5

chmod -R 755 get-logs.sh

./get-logs.sh

{    "StatusCode": 200,    "ExecutedVersion": "$LATEST"}{    "events": [{            "timestamp": 1559763003171,            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",            "ingestionTime": 1559763003309        },{            "timestamp": 1559763003173,            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",            "ingestionTime": 1559763018353        },{            "timestamp": 1559763003173,            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",            "ingestionTime": 1559763018353        },{            "timestamp": 1559763003218,            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",            "ingestionTime": 1559763018353        },{            "timestamp": 1559763003218,            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",            "ingestionTime": 1559763018353        }    ],    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"}

Deleting logs

Log groups aren't deleted automatically when you delete a function. To avoid storing logs indefinitely, delete the log group, orconfigure a retention period after which logs are deleted automatically.

Using other logging tools and libraries

Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity. TheLogger utility provides a Lambda optimized logger which includes additional information about function context across all your functions with output structured as JSON. Use this utility to do the following:

Using Powertools for AWS Lambda (Python) and AWS SAM for structured logging

Follow the steps below to download, build, and deploy a sample Hello World Python application with integratedPowertools for Python modules using the AWS SAM. This application implements a basic API backend and uses Powertools for emitting logs, metrics, and traces. It consists of an Amazon API Gateway endpoint and a Lambda function. When you send a GET request to the API Gateway endpoint, the Lambda function invokes, sends logs and metrics using Embedded Metric Format to CloudWatch, and sends traces to AWS X-Ray. The function returns ahello world message.

Managing log retention

Log groups aren't deleted automatically when you delete a function. To avoid storing logs indefinitely, delete the log group, or configure a retention period after which CloudWatch automatically deletes the logs. To set up log retention, add the following to your AWS SAM template:

Resources:  HelloWorldFunction:    Type: AWS::Serverless::Function    Properties:      # Omitting other properties  LogGroup:    Type: AWS::Logs::LogGroup    Properties:      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"      RetentionInDays: 7

Using Powertools for AWS Lambda (Python) and AWS CDK for structured logging

Follow the steps below to download, build, and deploy a sample Hello World Python application with integratedPowertools for AWS Lambda (Python) modules using the AWS CDK. This application implements a basic API backend and uses Powertools for emitting logs, metrics, and traces. It consists of an Amazon API Gateway endpoint and a Lambda function. When you send a GET request to the API Gateway endpoint, the Lambda function invokes, sends logs and metrics using Embedded Metric Format to CloudWatch, and sends traces to AWS X-Ray. The function returns a hello world message.

Thanks for letting us know we're doing a good job!

If you've got a moment, please tell us what we did right so we can do more of it.

Thanks for letting us know this page needs work. We're sorry we let you down.

If you've got a moment, please tell us how we can make the documentation better.