Using aws xray with serverless

Question

Pulumi · Accepted Answer

AWS X-Ray is a service that helps developers analyze and debug distributed applications, such as those built using a serverless architecture on AWS. With AWS X-Ray, you can understand how your application and its underlying services are performing to identify and troubleshoot the root cause of performance issues and errors.

In a serverless context, typically, AWS Lambda functions are the main components of your infrastructure. By integrating X-Ray with your Lambda functions, you can get insights into the execution of your functions and the performance of the AWS services they rely on.

Below is a Pulumi program written in TypeScript that demonstrates how you can create a serverless application with AWS Lambda and configure AWS X-Ray for tracing. The program will do the following:

1. Create a new AWS X-Ray sampling rule to define how your application's requests are sampled for tracing.
2. Set up a new AWS Lambda function.
3. Give the Lambda function permission to write trace data to AWS X-Ray.
4. Integrate the Lambda function with AWS X-Ray usage.

Let's start with the program:

```typescript
import * as aws from "@pulumi/aws";

// Define an AWS X-Ray sampling rule to collect traces
const xraySamplingRule = new aws.xray.SamplingRule("my-xray-sampling-rule", {
    // The name of the sampling rule
    ruleName: "MyAppSamplingRule",
    // Higher priority rules are evaluated first
    priority: 1,
    // The URL path to match for sampling
    urlPath: "/api/*",
    // The HTTP method to match for sampling
    httpMethod: "*",
    // The percentage of matching requests to trace
    fixedRate: 0.01,
    // The number of traces to record per second
    reservoirSize: 1,
    // The service to match
    serviceName: "*",
    // The type of service to match
    serviceType: "*",
    // The version of the service to match
    version: 1,
    // The host to match for sampling
    host: "*",
    // Optional: Additional tags can be configured here if desired
});

// Define an IAM role for the Lambda function with X-Ray write permissions
const lambdaRole = new aws.iam.Role("my-lambda-role", {
    assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal({ Service: "lambda.amazonaws.com" }),
});

// Attach the AWSXrayWriteOnlyAccess policy to the role to allow writing trace data to X-Ray
new aws.iam.RolePolicyAttachment("my-xray-policy-attachment", {
    role: lambdaRole,
    policyArn: "arn:aws:iam::aws:policy/AWSXrayWriteOnlyAccess",
});

// Create a Lambda function integrated with AWS X-Ray
const myLambdaFunction = new aws.lambda.Function("myLambdaFunction", {
    // Configuration for the Lambda function
    code: new pulumi.asset.AssetArchive({
        "index.js": new pulumi.asset.StringAsset('exports.handler = function(event, context) { /* your Lambda handler code */ }'),
    }),
    runtime: aws.lambda.NodeJS14dXRuntime,
    role: lambdaRole.arn,
    handler: "index.handler",
    // Enable X-Ray Tracing
    tracingConfig: {
        mode: "Active",
    },
});

// Export the Lambda function name and sampling rule ARN
export const lambdaFunctionName = myLambdaFunction.name;
export const xraySamplingRuleArn = xraySamplingRule.arn;
```

In this program:

- We begin by importing the necessary AWS modules from Pulumi's AWS SDK.

- We set up a new AWS X-Ray sampling rule called `my-xray-sampling-rule` using `aws.xray.SamplingRule`. This sampling rule specifies the criteria for requests that X-Ray will trace. Parameters like `urlPath`, `httpMethod`, and `fixedRate` are used to configure which requests to match and at what frequency traces should be recorded.

- Next, we create an IAM role `my-lambda-role` for our Lambda function. This role includes a trust policy that allows the function to assume the role, and we attach the `AWSXrayWriteOnlyAccess` policy to this role so that the Lambda can write trace data to AWS X-Ray.

- We proceed to define a new Lambda function `myLambdaFunction`. In the function configuration, we specify the necessary information such as the runtime, the IAM role, and the handler. Notably, with `tracingConfig`, we enable the X-Ray tracing feature by setting the mode to `Active`.

- Lastly, we export the Lambda function name and the X-Ray sampling rule ARN as stack outputs, which can be useful for external references or integrations.

After deploying this Pulumi program with `pulumi up`, you will have a serverless Lambda function configured to send trace data to AWS X-Ray, helping you monitor and debug your application effectively. Remember that the actual Lambda function code should be written in place of `/* your Lambda handler code */` in the asset definition.