CODEWITHSUNDEEP
node.jsamazon-web-servicesaws-lambda
Josh Kautz
Josh Kautz

Reputation: 631

How to asynchronously make HTTP Requests in AWS Lambda Node.js runtime

I have created an API endpoint that returns an integer when it is successfully accessed with an HTTP Post request. I want an AWS CloudWatch scheduled process to run an AWS Lambda function every minute to check the API endpoint so make sure the value is not zero. I have set up the scheduled AWS CloudWatch process and the AWS Lambda function, where the runtime is Node.js 10. However, when I look at the AWS CloudWatch group's stream log, the logs seem to be out of order. I suspect this is because of the HTTP Request to the API endpoint is running asynchronously, but I ultimately do not know. The time that it takes to log the value of this HTTP Request to the API end point seems to be much longer than the actual time to process the request.

Here is the Node.js lambda function that is being run on a minutely basis:

exports.handler = async (event) => {

    var datetime = new Date();

    var request = require("request");

    var options = {
        method: 'POST',
        url: 'https://website.com/api/getDataPoints',
        headers: 
            {
                'cache-control': 'no-cache',
                'content-type': 'text/plain'
            },
        body: '{"token" : "yT7g8urUFmEZwQrJNHgQGRDA9zScpNzPM3rb"}'
    };

    await request(options, function (error, response, body) {

        if (error)
        {
            throw new Error(error);
            // Email and SMS message that this is having an error
        }

        if (body == 0)
        {
            // Email and SMS message that this is having an error
            // Restart EC2 server
        }

        console.log(datetime.toString() + " - " + body + " Data Points!");

    });
};

Here is the AWS CloudWatch log, where it's easier to see the delay in logging the response from the HTTP Request:

AWS CloudWatch log

Any insight into the cause of this perceived log delay or suggestions on how to achieve similar results in a more efficient way would be greatly appreciated! Thank you!

Upvotes: 1

Views: 1943

Answers (1)

maschaub
maschaub

Reputation: 762

Here is what is happening: the await is returning immediately because the request function does not return a promise, so the callback is happening after the lambda function exits. The reason why there is such a long delay in seeing the log is that when your lambda function becomes idle (meaning all handler functions have returned, even if there are callbacks waiting) AWS can suspend any executing code until a new invocation of the function. So in your case when the next minute rolls around and the lambda function is invoked again, AWS will un-suspend any executing code and the callback kicks off immediately and you see the log for the previous invocation.

To solve this you want to make sure the handler function doesn't return until all work has been completed (which is what I think you were intending to do with the await). So wrap the request call in a function that returns a promise which is resolved in the callback and use await on the wrapper function.

function doRequest() {
    return new Promise((resolve, reject) => {
         request(options, function (error, response, body) {

                 if (error){
                     throw new Error(error);
                     // Email and SMS message that this is having an error
                 }

                 if (body == 0){
                     // Email and SMS message that this is having an error
                     // Restart EC2 server
                 }

                 console.log(datetime.toString() + " - " + body + " Data Points!");
                 resolve();
          });
    });
}

await doRequest();

Upvotes: 2

Related Questions