Integration Options

Using Layers
Without Layers
Serverless Framework
AWS SAM
AWS CDK
Using Layers
Integrating Thundra using the AWS Lambda Layers is the recommended and easier way to get start with Thundra. Depending on your choice to use custom runtime, you can integrate Thundra with no code change at all or just by wrapping your handler function.
Step 1: Deploy your function to AWS Lambda
Bundle all your Node.js lambda function files, along with any additional required packages and upload it to the AWS Lambda console using the 'Upload a.zip file' option for the code entry type option. Note that Thundra dependencies are not expected to be in the artifact to be uploaded as it comes with layer that will be mentioned at later steps.
Step 2: Configure your function
Add Thundra's Node.js layer to your Lambda function using the below ARN. Note that the ARN contains a region and a version parameter which you should set correctly. Set region value to your Lambda function's region and version value to the layer version you want to use with your Lambda function. 
arn:aws:lambda:${region}:269863060030:layer:thundra-lambda-node-layer-minified:${version}

Latest version of the Thundra Node.js layer
After having added the Thundra layer ARN, you can continue using custom runtime or without using the custom runtime. Regardless of you choice make sure to also set thundra_apiKeyenvironment variable to your api key you get from the Thundra console.
Step 3: Configure Handler
a. Auto wrap
Set handler to thundra_handler.wrapperand then set thundra_agent_lambda_handler environment variable value to to your original handler (for ex. index.handler).
b. Manual wrap
You can wrap your Lambda handler to integrate Thundra as below.
index.js
const thundra = require("@thundra/core")();
​
exports.handler = thundra((event, context,callback) => {
    callback(null, "Hello Thundra!");
});

In the above code example, required @thundra/core package is already available in the Thundra's Node.js layer we have added before. Thus, you don't need to install the package and bundle it with your lambda function.
Step 4: Invoke your function!
Now you can try to invoke your Lambda function and see the details of your invocation in the Thundra console!
Without Layers
Without using AWS Lambda Layers
If you do not want to use AWS Lambda Layers, you can still easily integrate Thundra to your Node.js Lambda functions. All you have to do is installing @thundra/core package via npm. 
Step 1: Install the @thundra/core package
npm install @thundra/core --save
Step 2: Wrap your Lambda handler
After installing the thundra/core module, you will need to wrap your lambda handlers. Thundra will monitor your AWS Lambda functions automatically, supporting callback along with various context functions.
handler.js
const thundra = require("@thundra/core")();
​
exports.handler = thundra((event, context,callback) => {
    callback(null, "Hello Thundra!");
});
Step 3: Deploy your function to AWS Lambda
Bundle your function along with any additional required Node.js packages and upload it to the AWS Lambda console using the 'Upload a.zip file' option for the code entry type option. 
Step 4: Configure your function
In the AWS Lambda console,  set the thundra_apiKey the environment variable to the api key value you got from the Thundra console.
Step 5: Invoke your function!
Now you can try to invoke your Lambda function and see the details of your invocation in the Thundra console!
Serverless Framework
Serverless Framework
Step 1: Install Thundra’s serverless plugin to automatically wrap your functions
npm install serverless-plugin-thundra
Step 2: Adding Thundra's Serverless Plugin in serverless.yml File

After installing Thundra’s serverless plugin, please specify it as a plugin for your serverless environment by adding it under the plugins section of your serverless.yml file.
serverless.yml
plugins:  
    - serverless-plugin-thundra
Step 3: Add thundra_apiKey to environment variables under provider section in serverless.yml 
serverless.yml
provider: 
    environment:
        thundra_apiKey: <YOUR THUNDRA API KEY>
Step 4: Deploy
serverless deploy
Step 5: Invoke your function!
Now you can try to invoke your Lambda function and see the details of your invocation in the Thundra console!
AWS SAM
AWS SAM
Step 1: Add configuration changes on SAM template.yml
Add thundra_apiKey environment variable with your thundra api key. 
Globals:
  Function:
    Environment:
      Variables:
          thundra_apiKey: <your_api_key>
Add the Thundra layer to Layers in globals section. ThundraAWSAccountNo and ThundraPythonLayerVersion parameters are defined under the Parameters section in the following configuration:
Latest version of the Thundra's Node.js layer: ​
Parameters:
  ThundraAWSAccountNo:
    Type: Number
    Default: 269863060030
​
  ThundraNodeLayerVersion:
    Type: Number
    Default: 24 # Or use any other version
​
Globals:
  	Function:
      Layers:
    	- !Sub arn:aws:lambda:${AWS::Region}:${ThundraAWSAccountNo}:layer:thundra-lambda-node-layer:${ThundraNodeLayerVersion}
​
	…
​
Change Runtime of your functions to provided
Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: provided
      Handler: handler.hello
An example configuration:
Parameters:
  ThundraAWSAccountNo:
    Type: Number
    Default: 269863060030
  ThundraNodeLayerVersion:
    Type: Number
    Default: 24 # Or use any other version
​
Globals:
  Function:
    Runtime: provided
    Timeout: 5
    Environment:
      Variables:
          thundra_apiKey: <your_api_key>
    Layers:
    	- !Sub arn:aws:lambda:${AWS::Region}:${ThundraAWSAccountNo}:layer:thundra-lambda-node-layer:${ThundraNodeLayerVersion}
​
Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ./
      Handler: handler.hello
​
Step 2: Test / Deploy
To build & run your functions locally:
sam build && sam local invoke
Then, package and deploy your function using sam.
Step 2: Invoke your function!
Now you can try to invoke your Lambda function and see the details of your invocation in the Thundra console!
AWS CDK
AWS CDK
Step 1: Apply configuration changes on your function properties.
Add thundra_apiKey environment variable with your thundra api key. 
import {Function} from "@aws-cdk/aws-lambda";
​
export class YourConstructClass extends core.Construct {
​
  const thundraApiKey = <your_api_key>;
​
  constructor(scope: core.Construct, id: string) {
    const yourFunction = new Function(this, "YourHandler", {
        ..., // other function properties
        environment: {
          ..., // other environment variables
          thundra_apiKey: thundraApiKey
        } 
    });
  }
}
Define Thundra layer and add it to your function properties. 
Latest version of the Thundra's Node.js layer: ​
import {Aws} from "@aws-cdk/core";
import {Function, LayerVersion} from "@aws-cdk/aws-lambda";
​
export class YourConstructClass extends core.Construct {
  
  const thundraApiKey = <your_api_key>;
  const thundraAWSAccountNo = 269863060030;
  const thundraNodeLayerVersion = 48; // or any other version 
  const thundraLayer = LayerVersion.fromLayerVersionArn(
    this,
    "ThundraLayer",
    `arn:aws:lambda:${Aws.REGION}:${thundraAWSAccountNo}:layer:thundra-lambda-node-layer:${thundraNodeLayerVersion}`
  );
      
  constructor(scope: core.Construct, id: string) {
    const yourFunction = new Function(<scope>, <id>, {
        ..., // other function properties
        environment: {
          ..., // other environment variables
          thundra_apiKey: thundraApiKey
        },
        layers: [
          thundraLayer,
          ... // other layers
        ] 
    });
  }
}
Aws.REGION is a pseudo parameter which is bootstrapped from your stack's environment configuration
Change Runtime of your function to provided
import {Function, LayerVersion, Runtime} from "@aws-cdk/aws-lambda";
import {Aws} from "@aws-cdk/core";
import {Function, LayerVersion} from "@aws-cdk/aws-lambda";
​
export class YourConstructClass extends core.Construct {
  
  const thundraApiKey = <your_api_key>;
  const thundraAWSAccountNo = 269863060030;
  const thundraNodeLayerVersion = 48; // or any other version 
  const thundraLayer = LayerVersion.fromLayerVersionArn(
    this,
    "ThundraLayer",
    `arn:aws:lambda:${Aws.REGION}:${thundraAWSAccountNo}:layer:thundra-lambda-node-layer:${thundraNodeLayerVersion}`
  );
      
  constructor(scope: core.Construct, id: string) {
    const yourFunction = new Function(this, "YourFunction", {
        ..., // other function properties
        runtime: Runtime.PROVIDED,
        environment: {
          ..., // other environment variables
          thundra_apiKey: thundraApiKey
        },
        layers: [
          thundraLayer,
          ... // other layers
        ] 
    });
  }
}
An example configuration:
import {Aws} from "@aws-cdk/core";
import {Code, Function, Runtime, LayerVersion} from "@aws-cdk/aws-lambda";
​
export class YourConstructClass extends core.Construct {
  
  const thundraApiKey = <your_api_key>;
  const thundraAWSAccountNo = 269863060030;
  const thundraNodeLayerVersion = 48; // or any other version 
  const thundraLayer = LayerVersion.fromLayerVersionArn(
    this,
    "ThundraLayer",
    `arn:aws:lambda:${Aws.REGION}:${thundraAWSAccountNo}:layer:thundra-lambda-node-layer:${thundraNodeLayerVersion}`
  );
      
  constructor(scope: core.Construct, id: string) {
    const handler = new Function(this, "MyFunction", {
      runtime: Runtime.PROVIDED, 
      code: Code.asset("/path/to/your/resource"),
      handler: "your.handler",
      environment: {
        thundra_apiKey: thundraApiKey
      },
      layers: [
        thundraLayer
      ]
    });
  }
}
Step 2: Build / Deploy
npm run build && cdk deploy
Step 3: Invoke your function!
Now you can try to invoke your Lambda function and see the details of your invocation in the Thundra console!
​
​
Report Tab
Next - Node.js
Configuration Options
Last updated 2 months ago