Group Lambda functions under a single APM entity

NEW_RELIC_APP_NAME is a Lambda environment variable that controls which APM entity your function's telemetry is attributed to in New Relic. When set, telemetry from your Lambda function appears under a named APM entity of your choice instead of defaulting to the Lambda function name.

How it works

When NEW_RELIC_APM_LAMBDA_MODE is true, the New Relic Lambda Extension makes an APM connect call at each cold start. It uses NEW_RELIC_APP_NAME (or falls back to AWS_LAMBDA_FUNCTION_NAME if it is not set) as the app_name in that call. The APM collector resolves or creates an entity for that name and returns its GUID. All telemetry produced during that invocation is tagged with that GUID and appears under the named entity in New Relic.

Configuration

Set NEW_RELIC_APP_NAME as a Lambda environment variable. No code changes are required — the extension handles it automatically at cold start.

NEW_RELIC_APP_NAME = my-entity-name

Supported runtimes

NEW_RELIC_APP_NAME is supported across all APM-mode Lambda runtimes - Python, Node.js, Java, Ruby. .NET, and Go.

Entity behavior

Functions sharing the same NEW_RELIC_APP_NAME value and New Relic account are grouped under a single APM entity in the New Relic UI.

If the name you set matches an existing APM entity — for example, one already created by a non-Lambda service — telemetry from your Lambda function merges into that entity automatically. There is no separate entity created.

Multi-region reporting

Multiple Lambda functions deployed across different AWS regions can share the same NEW_RELIC_APP_NAME. All of these functions report into a single APM entity, regardless of which region they are deployed in.

To distinguish individual functions or region-specific deployments within the grouped entity, filter by the tags.aws.arn attribute in NRQL or use the tag filter bar in the entity view.

Cross-runtime reporting

Lambda functions using different runtimes (for example, a Python function and a Node.js function) that share the same NEW_RELIC_APP_NAME create separate APM entities — one per runtime. The grouping does not cross runtime boundaries.

Same app name across Lambda and non-Lambda services

If a Lambda function and a non-Lambda APM service (for example, a traditional web application or microservice) are both configured with the same NEW_RELIC_APP_NAME, they report into the same APM entity.

This can be intentional: if you want a unified view of a service that runs on both Lambda and server-based infrastructure, sharing the name allows all telemetry — transactions, errors, throughput — to appear in one place.

However, if done unintentionally, it can cause confusion. Metrics, error rates, and throughput from the Lambda function and the non-Lambda service are combined, which may make it harder to diagnose issues or understand performance independently.

Entity lifecycle and tag expiration

When a Lambda function stops reporting, its APM entity is not immediately removed. Entity tags (including aws.arn) expire after approximately 1–2 days of no incoming telemetry. The entity itself may persist longer depending on your account's retention settings.

Troubleshoot

Telemetry still appears under the function name after setting NEW_RELIC_APP_NAME

• Confirm the variable is set at the Lambda environment level, not only in application code.
• Check CloudWatch logs for [NR_EXT] APM connect entries — the app_name field should reflect your custom value.
• Ensure the New Relic Lambda Extension version in your layer supports this feature.

Two separate entities exist for the same function

This is expected when NEW_RELIC_APP_NAME is added or changed after the function was already reporting. The old entity retains its historical data; all new telemetry goes to the new entity.

Two Lambda functions with the same app name show as separate entities

This is expected behavior when the runtimes differ (for example, Python vs. Node.js). Functions sharing the same runtime and the same NEW_RELIC_APP_NAME will report into one entity.