AWS Lambda: The Serverless Way to Send Emails and Analyze Logs

ByJordan Brown

AWS Lambda is a powerful serverless compute service that lets you run code without managing servers. With Lambda, you can build applications that automatically scale based on demand and only pay for the compute time your code actually consumes. Two common use cases for Lambda are sending emails and analyzing application logs – tasks that can be resource-intensive and challenging to manage with traditional server-based architectures.

In this guide, we‘ll walk through how to use AWS Lambda to send emails via Amazon Simple Email Service (SES) and export, store, and analyze Lambda function logs using Amazon CloudWatch, S3, and Athena. By the end, you‘ll have a working solution you can adapt for your own serverless applications. Let‘s get started!

Setting Up a Lambda Function to Send Emails

Our first step is to create a Lambda function that can send an email using Amazon SES. We‘ll write the function in Python, but Lambda supports a variety of programming languages including Node.js, Java, C#, and Go.

Here‘s the code for our email sending function:

import boto3
from botocore.exceptions import ClientError

def lambda_handler(event, context):


# Extract email parameters from event object
recipient = event[‘recipient‘]
subject = event[‘subject‘]  
body = event[‘body‘]
sender = "Your Name <[email protected]>"

# Create a new SES client
ses = boto3.client(‘ses‘) 

# Construct email message
message = {
    ‘Body‘: {
        ‘Text‘: {
            ‘Charset‘: ‘UTF-8‘,
            ‘Data‘: body,
        },
    },
    ‘Subject‘: {
        ‘Charset‘: ‘UTF-8‘, 
        ‘Data‘: subject,
    },
}

# Send the email
try:
    response = ses.send_email(
        Source=sender, 
        Destination={‘ToAddresses‘: [recipient]},
        Message=message
    )
except ClientError as e:
    print(e.response[‘Error‘][‘Message‘])
else:
    print("Email sent! Message ID:", response[‘MessageId‘])




This function does the following:


    

  1. 

    Extracts the recipient email address, subject, and body from the triggering event object. In this example, the event is a JSON object passed to the function when it‘s invoked.
    

    2. 

  2. 

    Creates a new boto3 SES client to interact with Amazon SES.
    

    3. 

  3. 

    Constructs the email message with the extracted parameters. 
    

    4. 

  4. 

    Sends the email using SES‘s send_email operation. It prints the message ID if successful, or the error message if the sending fails.
    

    5. 



Before you can use this function, you need to make sure your Amazon SES account is set up properly:


    

  • 

    Verify the sender and recipient email addresses (or entire domains) in the SES console. Start in sandbox mode for testing.
    

    • 

  • 

    Give your Lambda function‘s execution role permission to send emails with SES. Attach the following inline IAM policy:
    

    • 



{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow", 
      "Action": "ses:SendEmail",
      "Resource": "*"  
    }
  ]  
}



With the function deployed and SES configured, you can now trigger it by passing in an event object with the email parameters, either manually via a test event or by integrating with another AWS service like API Gateway, S3, or SNS.


Exporting Lambda Logs to S3


By default, logs from your Lambda function executions are sent to Amazon CloudWatch Logs. To analyze these logs, a common pattern is to export them to Amazon S3 so you can query them with a service like AWS Athena.


Here‘s how to set up log exporting from CloudWatch to S3:


    

  1. 

    Create an S3 bucket to store the exported logs. Make sure the bucket is in the same region as your Lambda function and CloudWatch log group.
    

    2. 

  2. 

    Give CloudWatch Logs permission to export to your S3 bucket. Go to the Properties tab for your log group and select "Edit" next to "Export to Amazon S3". Enable the export and choose a log retention setting. 
    

    3. 

  3. 

    Specify the S3 bucket and optional folder prefix where you want to store the logs. The prefix helps organize multiple log groups. For example: s3://my-lambda-logs/email-service/.
    

    4. 

  4. 

    If your S3 bucket is encrypted with KMS, you need to also give CloudWatch Logs permission to encrypt using your customer managed key (CMK). Add the cloudwatch logs service principal to your key‘s policy:
    

    5. 



{
  "Version": "2012-10-17", 
  "Statement": [    
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "logs.<region>.amazonaws.com"
      },  
      "Action": [
        "kms:Encrypt*",
        "kms:Decrypt*",
        "kms:GenerateDataKey*"
      ],
      "Resource": "*"
    }
  ]
}  



Once enabled, CloudWatch Logs will automatically export your Lambda function‘s logs to the designated S3 bucket in JSON format. New files are written periodically as log events are generated.


Analyzing Lambda Logs with Athena


With your Lambda logs flowing into S3, you can now use AWS Athena to run SQL queries and gain insights. Athena is a serverless interactive query service that makes it easy to analyze data in S3 using standard SQL.


To query your exported Lambda logs in Athena:


    

  1. 

    Open the Athena console and create a new database or use an existing one. For example: create database lambda_logs;
    

    2. 

  2. 

    Define a table schema that maps to the fields in the exported JSON logs. Use the "JSON" SerDe and specify the S3 location of your log files:
    

    3. 



CREATE EXTERNAL TABLE IF NOT EXISTS email_service_logs (
  `time` timestamp,
  `request_id` string,
  `event` string,
  `function_arn` string,
  `function_version` string
)
ROW FORMAT SERDE ‘org.openx.data.jsonserde.JsonSerDe‘
LOCATION ‘s3://my-lambda-logs/email-service/‘;  



    

  1. Now you can run SQL queries on the logs. For example, to see the 10 most recent requests:
    2. 



SELECT request_id, event, time
FROM email_service_logs
ORDER BY time DESC
LIMIT 10;



You can write more advanced queries to calculate metrics like invocation counts, average duration, error rates, etc. Athena charges per query based on the amount of data scanned, so be sure to filter and limit results where possible. 


Protip: Use Amazon QuickSight to visualize your log data sourced from Athena. QuickSight lets you build interactive dashboards very quickly.


Event-Driven Email Sending


A major benefit of using Lambda to send emails is the ability to trigger sending based on events from other AWS services. Some common event sources and use cases:


    

  • SES Receiving: Handle inbound emails received by SES and automate replying or forwarding them 
    • 

  • S3: Send an email notification when a file is uploaded or deleted in an S3 bucket
    • 

  • CloudWatch Events: Send periodic summary emails based on a cron-style schedule
    • 

  • SNS: Fan out email notifications to multiple recipients triggered by messages published to an SNS topic  
    • 

  • DynamoDB/Kinesis: Send transactional emails based on changes in a DynamoDB table or Kinesis stream
    • 

  • API Gateway: Expose an HTTP endpoint for your application to programmatically send emails via a Lambda backend
    • 



With Lambda, you can decouple your email sending logic from your application, automatically scale to handle variable workloads, and centrally manage the service across multiple event-driven use cases. 


Monitoring and Alerting


To ensure your serverless email service is running smoothly, it‘s important to set up monitoring and alerting. Some key metrics to watch in CloudWatch:


    

  • Invocations: The number of times your function is invoked
    • 

  • Duration: How long your function runs on average and per invocation  
    • 

  • Errors: The number and percentage of failed invocations
    • 

  • Throttles: The number of invocation attempts that were throttled due to concurrency limits
    • 



Set up CloudWatch alarms to notify you if any of these metrics exceed expected thresholds. This lets you proactively detect and investigate issues before they impact your application.


You can also proactively test your email sending pipeline with tools like AWS X-Ray, which helps trace requests as they pass through your serverless application. Use X-Ray SDK with Lambda to analyze and debug issues in your email functions.


Conclusion


In this guide, we‘ve seen how AWS Lambda provides a scalable, cost-effective, and event-driven way to send application emails and analyze the generated logs using services like SES, CloudWatch, S3, and Athena. With some basic configuration and a few lines of code, you can build a robust serverless email service that automatically scales to meet your workload demands.


Some key takeaways and best practices:


    

  • Use SES to reliably send, receive, and track application emails, while Lambda handles the triggering and processing logic
    • 

  • Set up CloudWatch Logs to automatically export your Lambda function logs to S3 for long-term storage and analytics
    • 

  • Use Athena to run ad-hoc queries on your logs and gain actionable insights
    • 

  • Leverage other AWS event sources like S3, SNS, and API Gateway to build event-driven email workflows
    • 

  • Monitor key metrics to ensure reliable operation of your email service and set up alarms to proactively detect and fix issues
    • 



With these tools and techniques, you‘ll be able to add powerful email capabilities to your applications without the operational overhead and complexity of managing dedicated email servers. You can focus on writing the core business logic and let AWS handle the heavy lifting of sending emails at scale. 


Ready to get started? Check out the AWS Lambda and SES documentation and start building your serverless email service today!


      
          
        How useful was this post?      
              
        Click on a star to rate it!      
        
      
                      
  •                       
    •                   
  •                       
    •                   
  •                       
    •                   
  •                       
    •                   
  •                       
    •               
    
    
        
      Average rating 0 / 5. Vote count: 0    
    
      No votes so far! Be the first to rate this post.    
    
  
          



You May Like to Read,

Similar Posts