This post was originally published on this site

Dynatrace provides the world’s first automatic observability solutions for AWS Lambda functions via traces without any code change. From every user transaction across cloud-native and hybrid application stacks to serverless functions, Dynatrace delivers end-to-end distributed tracing out-of-the-box. Our AI-engine Davis identifies issues and pinpoints root causes in applications and serverless functions fully automatically.

We’ve worked closely with our partner AWS to deliver a complete, end-to-end picture of your cloud environment that includes monitoring support for all AWS services. Now Dynatrace is pleased to announce another industry first: automatic, end-to-end observability for AWS Lambda functions in Node.js and Python via traces.

By leveraging the AWS Lambda Extensions API, Dynatrace brings the unique value of its Davis AI-engine for fully automatic root cause analysis to AWS Lambda. This means, you don’t need to change even a single line of code in the serverless functions themselves.

Serverless functions extend applications to accelerate speed of innovation

AWS Lambda functions, currently the most popular offering in the serverless space, typically co-exist and interact with other services that operate within our customers’ hybrid cloud environments. These serverless functions allow developers to focus on their business logic. They may be used to, for example, integrate a new payment service or create a new interface for a booking platform.

Although the adoption of serverless functions brings many benefits, including scalability, quick deployments, and updates, it also introduces visibility and monitoring challenges to CloudOps and DevOps.

Why you need end-to-end observability for your AWS Lambda functions

Serverless functions and services are highly dynamic and ephemeral. This results in potential gaps and blind spots that make it difficult to identify issues and find their root cause before they impact your business or customer experience.

Additionally, serverless functions usually don’t exist in a vacuum. Therefore, it’s critical to understand how they impact customer-facing web or mobile apps or APIs and how they interact with other functions, services, or classical stacks that may be running in an on-premises datacenter. Other tools in the market for monitoring AWS Lambda traces can’t deliver real end-to-end visibility from the end-user perspective across all the moving parts; they also require heavy manual lifting.

Dynatrace provides in-context service-level insights into AWS Lambda functions automatically

The Dynatrace Software Intelligence Platform, with its new AWS Lambda Extension API, gives you an easy way to gain automatic insights into your Lambda functions. Dynatrace can monitor AWS Lambda functions automatically, just like any other service. All you have to do is set up the OneAgent Lambda Layer for a function. This approach gives you:

  • End-to-end observability across your functions and services
  • Easy identification of the source of problems with automatic detection of root cause
  • Deep insights and automatic detection of cold starts to analyze individual invocations of your functions
  • Full integration with existing Dynatrace capabilities for AWS Lambda (for example, metric ingestion via AWS Cloud Watch)

Now let’s take a look how each of these advantages reveal themselves in Dynatrace.

Fully integrated with existing Dynatrace capabilities for AWS Lambda, including metric ingestion via AWS Cloud Watch

In the screenshot below, Dynatrace displays a Lambda function in the same way that it displays any other detected service. However, it also includes key metrics that are ingested via AWS Cloud Watch (for example, the number of Concurrent executions or Throttled invocations).

This example shows that the checkout function running in the EU-Central-1 region processes between 20 and 80 invocations per minute.

Automatic, cold-start detection for every Lambda invocation

Now you can easily understand how cold starts affect your end users. As invocations that lead to the cold start of a Lambda function usually have a significantly higher response time, it’s critical that you know how often cold starts occur, and which individual invocations are affected by them.

For each individual invocation, the Dynatrace Lambda extension automatically detects when a function is cold started. This is critical to understanding how individual cold starts affect your end users and your upstream services. This additional insight enables you to design strategies for handling the effects of cold starts, like warming up your functions or configuring provisioned concurrency for your functions.

For the Checkout function example (see below), the median response time is around 580ms. You can now simply filter for cold started invocations of this function and instantly see that each invocation takes longer than 1 second.

From here you can use Dynatrace analytics capabilities to understand the response time, or failures, or jump to individual PurePaths.

Dynatrace automatically follows the invocations of your AWS Lambda functions, whether they’re invoked via an API Gateway or the AWS Lambda SDK, and puts them into context with a distributed trace, which is represented using patented Dynatrace PurePath technology. This means that you can easily see how your AWS Lambda functions are integrated into your overall service landscape.

Set up in 3 easy steps

Before you begin, be sure to sign-up for the Preview program. Once you’ve received your invitation to the Preview program you need to:

1. Attach the OneAgent Lambda Layer that fits the runtime of your function.

2. Within the Dynatrace web UI, go to Deploy Dynatrace > Install OneAgent > AWS Lambda functions to configure the relevant settings.

3. Set the corresponding environment variables for the function to enable the extension and forward monitoring data securely to your Dynatrace environment.

With these steps complete, your Lambda functions are now fully monitored. They’re displayed alongside all the other monitored services that are listed on the Transactions and services page of your Dynatrace environment (and everywhere else you’d expect to see services in the Dynatrace web UI). You can easily find Lambda functions on this page by filtering for Technology: AWS Lambda.

How to participate in the Preview Program

To participate in this Preview, please complete this enrollment form.

What’s next

End-to-end observability for AWS Lambda via Dynatrace Lambda extensions currently supports Node.js and Python. This easy integration via AWS Lambda layers replace the existing preview for Node.js and adds additional support for Python based functions. This is, however, just the beginning as we have additional plans for leveraging the AWS Lambda extensions. In upcoming sprints, additional improvements will include:

  • Support for Java-based functions
  • Improved mapping and topology detection
  • Support for additional deployment tools

So please stay tuned!

This syndicated content is provided by Dynatrace and was originally posted at https://www.dynatrace.com/news/blog/dynatrace-launches-automatic-end-to-end-observability-via-traces-for-aws-lambda-preview-program/