Implementing real-time logging with Azure Functions in Node.js applications

01 Oct 2023

In today’s world, it’s crucial for developers to have real-time insights into their applications’ behavior and performance. Azure Functions, a serverless compute service offered by Microsoft Azure, enables developers to build and deploy event-driven applications effortlessly. In this blog post, we will explore how to implement real-time logging with Azure Functions in Node.js applications.

Why Real-Time Logging Matters

Real-time logging allows developers to monitor their applications and quickly identify issues or anomalies. With real-time logs, you can proactively respond to errors, understand application performance, and troubleshoot any issues that may arise. This level of visibility is especially critical for production systems where downtime can have significant consequences.

Setting Up Azure Functions and Azure Monitor

Before we dive into the implementation details, let’s ensure that we have the necessary prerequisites in place:

Azure Account: You will need an active Azure account to create and deploy Azure Functions.
Node.js: Make sure you have Node.js installed on your development machine.
Azure CLI: Install the Azure CLI on your machine to interact with Azure services from the command line.

Once you have these prerequisites set up, follow these steps to create the necessary resources:

Create an Azure Function App: Use the Azure CLI to create an Azure Function App that will host our Azure Function.

 az functionapp create --name my-function-app --resource-group my-resource-group --consumption-plan-location <REGION> --runtime node

Enable Application Insights: Application Insights is a monitoring and diagnostics service provided by Azure. Enable it for your Function App using the Azure CLI:

 az functionapp config appsettings set --name my-function-app --resource-group my-resource-group --settings "APPINSIGHTS_INSTRUMENTATIONKEY=<INSTRUMENTATION_KEY>"

Now that we have our Azure resources set up, let’s proceed to implement real-time logging in our Azure Function.

Implementation Steps

Install dependencies: Create a new directory for your Azure Function application and navigate to it in a terminal. Run the following command to generate a new Node.js project:
```
 npm init -y
```
Install Azure Functions Core Tools: Install the Azure Functions Core Tools, which provide a command-line interface for running and debugging Azure Functions locally:
```
 npm install -g azure-functions-core-tools
```
Create a new Azure Function: Use the following command to create a new HTTP-triggered Azure Function:
```
 func new --template "HTTP trigger" --language JavaScript --name my-function
```

Configure Application Insights: Open the local.settings.json file in the root of your project and add the following key-value pair to enable Application Insights:

 {
     "IsEncrypted": false,
     "Values": {
         "AzureWebJobsStorage": "<STORAGE_CONNECTION_STRING>",
         "FUNCTIONS_WORKER_RUNTIME": "node",
         "APPINSIGHTS_INSTRUMENTATIONKEY": "<INSTRUMENTATION_KEY>"
     }
 }

Add logging to your Function: Open the my-function/index.js file and update the code to incorporate logging. Use the following code snippet as an example:

 module.exports = async function (context, req) {
     context.log('Function triggered.');
        
     // Your function logic here
        
     context.log('Function executed successfully.');
     context.done();
 };

Run and monitor your Function: Start the Azure Functions host locally by running the following command:
```
 func start
```
You can now trigger your function by making an HTTP request to http://localhost:7071/api/my-function. The logs will be visible in the console output.
View logs in Azure Monitor: Once your Function App is deployed to Azure, you can view the logs and telemetry data in Azure Monitor. This allows you to analyze and track the performance of your Function in a production environment.

Conclusion

Implementing real-time logging with Azure Functions in Node.js applications provides valuable insights for developers. By following the steps outlined in this blog post, you can easily set up Azure Functions, enable Application Insights, and incorporate real-time logging in your applications. This visibility will help you improve the reliability and performance of your applications.

#azurefunctions #logging