If you're using a Lambda function without a layer, you'll need to instrument New Relic based on your chosen runtime. Select your runtime below and follow the setup instructions.
To instrument your Go-language Lambda:
Download our Go agent package, and place it in the same directory as your function.
Install the agent by running:
bash$go get -u github.com/newrelic/go-agent/v3/newrelicInstall the
nrlambda
integration by running:bash$go get -u github.com/newrelic/go-agent/v3/integrations/nrlambda
In your Lambda code, import our components, create an application, and update how you start your Lambda. See our instrumentation examples:
Optionally, add custom events that will be associated with your Lambda invocation by using the
RecordCustomEvent
API. For example:func handler(ctx context.Context) {if txn := newrelic.FromContext(ctx); nil != txn {txn.Application().RecordCustomEvent("MyEvent", map[string]interface{}{"zip": "zap",})}fmt.Println("hello world!")}Build and zip your Lambda function and upload it to AWS.
Here are suggestions for zipping and uploading the Lambda:
Build the binary for execution on Linux. This produces a binary file called
main
. You can use:bash$GOOS=linux go build -o mainZip the binary into a deployment package using:
bash$zip deployment.zip mainUpload the zip file to AWS using either the AWS Lambda console or the AWS CLI. Name the handler
main
(to match the name given during the binary build).
The following environment variables are not required for Lambda monitoring to function, but they are required if you want your Lambda functions to be included in distributed traces. To enable distributed tracing, set these environment variables in the AWS console:
NEW_RELIC_ACCOUNT_ID
. Your account ID.NEW_RELIC_TRUSTED_ACCOUNT_KEY
. This is also your account ID. If your account is a child account, this is the account ID for the root/parent account.
Optionally, to configure logging, see Go agent logging.
Invoke the Lambda at least once. This creates a CloudWatch log group, which must be present for the next step to work.
Our wrapper gathers data about the Lambda execution, generates a JSON message, and logs it to CloudWatch Logs. Next, you'll configure CloudWatch to send those logs to New Relic.
Monitoring for AWS Lambda in Java doesn't use our APM Java agent. Instead, it uses these two OpenTracing dependencies:
AWS Lambda OpenTracing Java SDK: OpenTracing instrumentation for AWS Lambda RequestHandler and RequestStreamHandler.
Our AWS Lambda OpenTracing Tracer: An OpenTracing Tracer implementation designed to monitor AWS Lambda. It generates spans, error events, transaction events, error traces, and provides distributed tracing support.
Tip
Supported OpenTracing Versions
- OpenTracing 0.31.0:
- Lambda Tracer: com.newrelic.opentracing:newrelic-java-lambda:1.1.1
- Lambda SDK: com.newrelic.opentracing:java-aws-lambda:1.0.0
- OpenTracing 0.32.0, 0.33.0:
- Lambda Tracer: com.newrelic.opentracing:newrelic-java-lambda:2.2.3
- Lambda SDK: com.newrelic.opentracing:java-aws-lambda:2.1.1
To instrument your Java Lambda:
- OpenTracing 0.31.0:
In your project's
build.gradle
file, include our OpenTracing AWS Lambda Tracer and the AWS Lambda OpenTracing SDK dependencies:dependencies {compile("com.newrelic.opentracing:java-aws-lambda:2.1.1")compile("com.newrelic.opentracing:newrelic-java-lambda:2.2.3")compile("io.opentracing:opentracing-util:0.33.0")}Implement the AWS Lambda
RequestHandler
interface as shown in the Java Lambda example and override thedoHandleRequest
method.In the
doHandleRequest
method, call theLambdaTracing.instrument(...)
API to create a root span to trace the lambda function's execution. This is also where you will define your business logic for the lambda function.Register a
LambdaTracer.INSTANCE
as the OpenTracing Global tracer, as shown in the Java Lambda example.Create a ZIP deployment package and upload it to AWS Lambda. Or deploy it via other means.
In the AWS Lambda console, set the handler. For the example Java Lambda, the handler would be
com.handler.example.MyLambdaHandler::handleRequest
. BecausehandleRequest
is assumed, you could also usecom.handler.example.MyLambdaHandler
.The following AWS console environment variables are required if you want your Lambda function to be included in distributed tracing. This is recommended.
NEW_RELIC_ACCOUNT_ID
. Your account ID.NEW_RELIC_PRIMARY_APPLICATION_ID
. This is also your account ID.NEW_RELIC_TRUSTED_ACCOUNT_KEY
. This is also your account ID. If your account is a child account, this must be the account ID for the root/parent account.
Optional: In the Lambda console, enable debug logging by adding this environment variable:
NEW_RELIC_DEBUG
istrue
.Invoke the Lambda at least once. This creates a CloudWatch log group, which must be present for the next step to work.
Our wrapper gathers data about the Lambda execution, generates a JSON message, and logs it to CloudWatch Logs. Next, you'll configure CloudWatch to send those logs to New Relic.
Please see the AWS Lambda distributed tracing example for a complete project that illustrates common use cases such as:
- Distributed tracing between Lambda functions
- Manual span creation (aka custom instrumentation)
- Tracing external calls
- Adding custom attributes (aka Tags) to spans
To instrument your Node.js Lambda:
Download our Node.js agent package and place it in the same directory as your function, ensuring the agent is installed as a dependency in the
node_modules
directory. Use the Node Package Manager:bash$npm install newrelic --saveIn your Lambda code, require the agent module at the top of the file, and wrap the handler function. For example:
const newrelic = require('newrelic');// Other module loads go under the require statement abovemodule.exports.handler = newrelic.setLambdaHandler((event, context, callback) => {// This is your handler function codeconsole.log('Lambda executed');callback();});Optional: You can also add custom events to your Lambda using the
recordCustomEvent
API. For example:module.exports.handler = newrelic.setLambdaHandler((event, context, callback) => {newrelic.recordCustomEvent('MyEventType', { foo: 'bar' });console.log('Lambda executed');callback();});Zip your Lambda function and the Node.js agent folder together. Requirements and recommendations:
- The New Relic files outside the New Relic agent folder don't need to be included.
- If your Lambda function file name is, for example,
lambda_function.node
, we recommend naming your zip filelambda_function.zip
. Do not use a tarball. - Your Lambda and its associated modules must all be in the zip file's root directory. This means that if you zip a folder that contains the files, it won't work.
Upload the zipped file to your AWS Lambda account.
In the AWS console, set these environment variables:
NEW_RELIC_NO_CONFIG_FILE
. Set totrue
if not using a configuration file.NEW_RELIC_APP_NAME
: Your application name.NEW_RELIC_ACCOUNT_ID
. Your account ID.NEW_RELIC_TRUSTED_ACCOUNT_KEY
. This is also your account ID. If your account is a child account, this needs to be the account ID for the root/parent account.
Optional: To run the agent in serverless mode outside of AWS in a local environment, set the environment variable
NEW_RELIC_SERVERLESS_MODE_ENABLED
totrue
. (When executing this in an AWS Lambda environment, the agent will automatically run in serverless mode. Do not use this variable if you're running in AWS.)Optional: To enable logging in serverless mode, set these environment variables:
- Set
NEW_RELIC_LOG_ENABLED
totrue
. - Set
NEW_RELIC_LOG
tostdout
for output to CloudWatch, or set to any writeable file location. NEW_RELIC_LOG_LEVEL
is set toinfo
by default, and it's only used when sending function logs in your Lambda. See other log levels.
- Set
Optional: If your Lambda function is using ES Modules, set the environment variable
NEW_RELIC_USE_ESM
totrue
. Note that if using ES Modules, you must use async/await or promises for your function. Callback-based functions are not supported.Invoke the Lambda at least once. This creates a CloudWatch log group, which must be present for the next step to work.
Our wrapper gathers data about the Lambda execution, generates a JSON message, and logs it to CloudWatch Logs. Next you'll configure CloudWatch to send those logs to New Relic.
Read more on how to send function logs with Lambda.
To instrument your Python Lambda:
Download both the Python agent and Python lambda wrapper packages and place them in the same directory as your function code. To do this, use pip:
bash$pip install -t . newrelic newrelic-lambdaImportant
If you use Homebrew, you may get this error:
DistutilsOptionError: must supply either home or prefix/exec-prefix -- not both
. For details, see the Homebrew GitHub post.In your Lambda code, import both the Python agent module and the Python lambda wrapper module.
Decorate the handler function using the New Relic decorator. The New Relic package must be imported first in your code. Here's an example:
import newrelic.agentfrom newrelic_lambda.lambda_handler import lambda_handlernewrelic.agent.initialize()@lambda_handler()def handler(event, context):...Optional: You can also add custom events to your Lambda using the
record_custom_event
API. Here's an example:@lambda_handler()def handler(event, context):newrelic.agent.record_custom_event('CustomEvent', {'foo': 'bar'})...Zip your
lambda_function.py
andnewrelic/
folder together using these guidelines:- The New Relic files outside the
newrelic/
folder don't need to be included. - If your Lambda function file name is, for example,
lambda_function.py
, name your zip filelambda_function.zip
. Do not use a tarball. - Your Lambda and its associated modules must all be in the zip file's root directory. This means that if you zip a folder that contains the files, it won't work.
- The New Relic files outside the
Upload the zipped file to your AWS Lambda account.
In the AWS console, set this environment variable:
NEW_RELIC_SERVERLESS_MODE_ENABLED
. Set totrue
The following environment variables are not required for Lambda monitoring to function but they are required if you want your Lambda functions to be included in distributed traces. To enable distributed tracing, set these environment variables in the AWS console:
NEW_RELIC_DISTRIBUTED_TRACING_ENABLED
. Set to true.NEW_RELIC_ACCOUNT_ID
. Your account ID.NEW_RELIC_TRUSTED_ACCOUNT_KEY
. This is also your account ID. If your account is a child account, this needs to be the account ID for the root/parent account.
Optional: To configure logging, use the
NEW_RELIC_LOG
andNEW_RELIC_LOG_LEVEL
environment variables in the AWS Console.Invoke the Lambda at least once. This creates a CloudWatch log group, which must be present for the next step to work.
The New Relic decorator gathers data about the Lambda execution, generates a JSON message, and logs it to CloudWatch Logs. Next, configure CloudWatch to send those logs to New Relic.
New Relic doesn't have a layerless Ruby instrumentation method. If you're using layers, see our Instrument your non-containerized Lambda function document.
In most cases, the .NET Agent will automatically instrument your AWS Lambda function and switch into a "serverless mode" that will disable sending data directly to New Relic as well some other features. You must either use the New Relic Lambda Extension or the newrelic-log-ingestion
lambda method to send data to New Relic.
To instrument your .NET Lambda:
- Add the NewRelic.Agent nuget package to your AWS Lambda project. For more information, see our installation guide.
- Add the required environment variables to your project.
NEW_RELIC_LICENSE_KEY
isn't required since the agent won't attempt to contact or send data directly to New Relic. - Set the optional environment variables:
NEW_RELIC_APP_NAME
- Publish the project to your AWS Lambda account.
- Configure either the New Relic Lambda Extension or the
newrelic-log-ingestion
lambda. - Optional: To configure logging, use the
NEWRELIC_LOG_CONSOLE
andNEWRELIC_LOG_LEVEL
environment variables in the AWS Console. - Invoke the Lambda at least once to check for errors and ensure the data is visible in the New Relic UI.