Debugging serverless applications, particularly AWS Lambda functions, can be a challenging task due to their stateless and ephemeral nature. Traditional debugging approaches often fall short when trying to inspect code running in a remote, serverless environment. However, with Lightrun's innovative platform, debugging Lambda applications in Python and Node.js has never been easier. In this blog post, we will explore how Lightrun simplifies the debugging process, providing a seamless experience for developers, along with best practices for creating snapshots and logs. About Lightrun Lightrun is a powerful solution that is designed to streamline the process of debugging and understanding complex live applications. It allows developers to insert real-time log-based breakpoints directly into their running applications, enabling them to instantly inspect and troubleshoot code without the need for redeployment. With Lightrun, developers can accelerate the debugging process, reducing downtime and enhancing the efficiency of their applications running in any environment. The Power of Lightrun's Platform when Debugging Lambda Functions Lightrun's platform handles the entire process of spinning up an agent and tearing it down gracefully. By integrating the Lightrun’s agent into your Lambda code, you can enable debugging capabilities without any invasive changes. The solution simplifies the debugging process, allowing developers to focus on identifying and resolving issues without worrying about managing the underlying infrastructure. Starting to Debug Serverless Architecture with Lightrun is simple and consists of the following steps that happens when using our lightrun/lambda library: out-of-the-box and does not require any specific implementation Lightrun’s debugging functionality is Enabled. Agent will show up in the developer's Lightrun’s IDE plugin. Original function is executed. Any log or snapshot that was added prior to triggering the lambda will take effect if running as part of the lambda execution. The lightrun functionality is cleaned up and deactivated (the agent disappears from the Lightrun’s IDE plugin). Code Example We’ll demonstrate the flow with a real example of a Lambda function that aggregates 30 random wikipedia page titles and returns them to the screen. Once triggered via a Function URL, we expect to see 30 different titles scraped from real wikipedia pages: Let’s present the code that was used, breaking it down to index.js, package.json and the Dockerfile that was used to build the image that was deployed to ECR all the way to the Lambda image. index.js const lightrun = require("lightrun/lambda");
const axios = require('axios');

async function scrapeWikipediaTitle() {
  try {
    const response = await axios.get('https://en.wikipedia.org/wiki/Special:Random');
    const responseData = response.data;
    const titleStart = responseData.indexOf('<title>');
    if (titleStart === -1) return null;
    
    const titleEnd = responseData.indexOf('</title>', titleStart);
    if (titleEnd === -1) return null;
  
    return responseData.substring(titleStart + 7, titleEnd);
  } catch (error) {
    console.error('Error scraping title:', error.message);
    return null;
  }
}

async function main() {
  const titles = [];

  for (let i = 0; i < 30; i++) {
    const title = await scrapeWikipediaTitle();

    if (!title) {
      console.log('Unable to scrape Wikipedia Title. Exiting...');
      return;
    }
    console.log('Wikipedia Title:');
    console.log(title);
    titles.push(title);
  }

  const result = titles.join('\n');
  return result;
}

exports.handler = lightrun.wrap( async (event, context) => {
        response = main();
        return response;
    }, {
      lightrunSecret: '<LIGHTRUN_KEY>',
      agentLog: {
        logsPath: "",
        level: "debug"
      },
      lightrunWaitForInit: true, 
      lightrunInitWaitTimeMs: 10000,
      metadata: {
        registration: {
            tags: ['aws-lambda-function-nodejs','us-east-1','wikipedia-headline-extraction']
        }
      }
    }
); Notes: Storing Lightrun’s Secret - you can use the section and the key in transit and at rest, keeping it secure without exposing it in the code. Environment Variables encrypt Ensure that your Lambda function has the necessary permissions to communicate with the Lightrun server. Double-check IAM roles and permissions to avoid any access issues. package.json {
  "name": "docker_web_app",
  "version": "1.0.0",
  "description": "Node.js on Docker",
  "author": "Tal Yitzhak",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.18.2",
    "lightrun": "1.13.0",
    "axios": "1.4.0"
  }
} Dockerfile FROM public.ecr.aws/lambda/nodejs:12
COPY index.js package.json ./
RUN npm install
CMD [ "index.handler" ] We Build and deploy the image to ECR using the following process (login and push commands can be taken from ECR console), and afterwards deploy the docker image to your Lambda: aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin dkr.ecr.us-east-1.amazonaws.com

docker build -t aws-lambda-function-nodejs . --platform=linux/amd64
docker tag aws-lambda-function-nodejs:latest dkr.ecr.us-east-1.amazonaws.com/aws-lambda-function-nodejs:latest
docker push dkr.ecr.us-east-1.amazonaws.com/aws-lambda-function-nodejs:latest

rm -rf node_modules
# Now update the function image in AWS Lambda Now you can trigger your Lambda, and on any execution you have all Lightrun’s debugging capabilities! For example, when creating a for line index.js:31 with a hit limit of 1, and then triggering the Lambda Function we can receive the following hit: snapshot For better visibility on only the interesting relevant variables within a snapshot, please refer to our documentation for more information. Watch Expressions Best Practices Lightrun's advanced tagging system empowers developers to create snapshots and logs at critical points in the Lambda function's execution. By strategically placing tags within your lambda agents, describing the region they are deployed, their purpose, owner, environment, etc - you can later on create a snapshot or add a dynamic log which captures the state of variables, monitor execution flow, and gain valuable insights that match ONLY the lambdas that are deployed with an agent with that tag. Creating Snapshots and Logs based on Lightrun Tags: You have 5 lambdas running, in 5 different regions thousands of times per day. Every lambda is wrapped with Lightrun’s agent and is tagged with the relevant region it is deployed in AWS. Example: You NEED to research an anomaly on one of the regions, then you would choose, when creating a snapshot/log, the tag with the relevant region; region:us-east1 - which will take effect only for lambdas in that region, making your debugging experience very smooth. What if you need to research an anomaly that happens in 2 different regions? Well, you can use and group them to one source and then refer to that source while creating a snapshot/log. Custom Sources When debugging lambdas with our service, we recommend customers to start working with long-lived lambdas. The reason is that on long-lived lambdas, our agent has sufficient time to register with the server, ensuring a smoother debugging experience. Long-lived lambdas allow the agent to establish a stable connection, improving the debugging process. : Onboard with Long-Lived Lambdas Conclusion Lightrun's seamless integration with AWS Lambda applications in Python and Node.js brings a new level of simplicity and efficiency to the debugging process. By utilizing Lightrun's wrapper, developers can focus on resolving issues quickly and effectively, without the headache of managing debugging infrastructure. Embrace the power of Lightrun and take your AWS Lambda debugging to new heights! Watch the demo on our youtube channel: Debugging AWS Lambda Serverless with Lightrun

This writer has a vested interest be it monetary, business, or otherwise, with 1 or more of the products or companies mentioned within.

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Accelerate Troubleshooting in AWS: Lightrun's Seamless Debugging for Lambda Functions

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

101 Stories To Learn About Cloud Infrastructure

10 Things in Engineering We Don't Spend Enough Time On

10 Things I Did To Increase CloudTrail Logs Security

10 reasons to give cloud computing a go

10 Lessons from 10 Years of AWS (part 2)

101 Stories To Learn About Cloud Infrastructure

10 Things in Engineering We Don't Spend Enough Time On

10 Things I Did To Increase CloudTrail Logs Security

10 reasons to give cloud computing a go

10 Lessons from 10 Years of AWS (part 2)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps