NestJs SDK Guide

To integrate your NestJs application with APItoolkit, you need to use this SDK to monitor incoming traffic, aggregate the requests, and then send them to APItoolkit's servers. Kindly follow this guide to get started and learn about all the supported features of APItoolkit's NestJs SDK.

Note

NestJs is a progressive NodeJs framework for building efficient, reliable, and scalable server-side applications. With NestJs, you can choose between two popular HTTP server frameworks: Express (the default) and Fastify. With this, developers have the freedom to use the numerous third-party modules that are available for any of the frameworks selected.

APItoolkit already provides SDKs for both Express and Fastify, hence you can integrate any into your NestJs application. In the following sections of this guide, we will walk you through the process of integrating APIToolkit's ExpressJS SDK or FastifyJS SDK into your NestJs application.

Prerequisites

Ensure you have already completed the first three steps of the onboarding guide.

Installation

Kindly run the command below to install the SDK:

npm install apitoolkit-express

# Or

yarn add apitoolkit-express

npm install apitoolkit-fastify

# Or

yarn add apitoolkit-fastify

Configuration

Next, initialize APItoolkit in your application's entry point (e.g., index.js), like so:

import { NestFactory } from "@nestjs/core";
import { APIToolkit } from "apitoolkit-express";
import { AppModule } from "./app.module";

async function bootstrap() {
  const apiToolkitClient = APIToolkit.NewClient({
    apiKey: "{ENTER_YOUR_API_KEY_HERE}",
    debug: false,
    tags: ["environment: production", "region: us-east-1"],
    serviceVersion: "v2.0",
  });

  const app = await NestFactory.create(AppModule);
  // Initialize the APItoolkit client
  app.use(apiToolkitClient.expressMiddleware);
  // END Initialize the APItoolkit client

  await app.listen(3000);
}

bootstrap();

import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";
import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
import fastify from "fastify";
import APIToolkit from "apitoolkit-fastify";

async function bootstrap() {
  const fastifyInstance = fastify();
  const app = await NestFactory.create(
    AppModule,
    new FastifyAdapter(fastifyInstance)
  );

  // Initialize the APItoolkit client
  const apiToolkitClient = await APIToolkit.NewClient({
    fastify: fastifyInstance,
    apiKey: "{ENTER_YOUR_API_KEY_HERE}",
    debug: false,
    tags: ["environment: production", "region: us-east-1"],
    serviceVersion: "v2.0",
  });
  apiToolkitClient.init();
  // END Initialize the APItoolkit client

  await app.listen(3000);
}

bootstrap();

In the configuration above, only the apiKey option is required, but you can add the following optional fields:

Option	Description
`debug`	Set to `true` to enable debug mode.
`tags`	A list of defined tags for your services (used for grouping and filtering data on the dashboard).
`serviceVersion`	A defined string version of your application (used for further debugging on the dashboard).
`redactHeaders`	A list of HTTP header keys to redact.
`redactResponseBody`	A list of JSONPaths from the request body to redact.
`redactRequestBody`	A list of JSONPaths from the response body to redact.

Tip

The {ENTER_YOUR_API_KEY_HERE} demo string should be replaced with the API key generated from the APItoolkit dashboard.

Redacting Sensitive Data

If you have fields that are sensitive and should not be sent to APItoolkit servers, you can mark those fields to be redacted (the fields will never leave your servers).

To mark a field for redacting via this SDK, you need to add some additional arguments to the apitoolkitClient configuration object with paths to the fields that should be redacted. There are three arguments you can provide to configure what gets redacted, namely:

redactHeaders: A list of HTTP header keys.
redactRequestBody: A list of JSONPaths from the request body.
redactResponseBody: A list of JSONPaths from the response body.

JSONPath is a query language used to select and extract data from JSON files. For example, given the following sample user data JSON object:

{
  "user": {
    "name": "John Martha",
    "email": "[email protected]",
    "addresses": [
      {
        "street": "123 Main St",
        "city": "Anytown",
        "state": "CA",
        "zip": "12345"
      },
      {
        "street": "123 Main St",
        "city": "Anytown",
        "state": "CA",
        "zip": "12345"
      }
    ],
    "credit_card": {
      "number": "4111111111111111",
      "expiration": "12/28",
      "cvv": "123"
    }
  }
}

Examples of valid JSONPath expressions would be:

JSONPath	Description
`$.user.addresses[*].zip`	In this case, APItoolkit will replace the `zip` field in all the objects of the `addresses` list inside the `user` object with the string `[CLIENT_REDACTED]`.
`$.user.credit_card`	In this case, APItoolkit will replace the entire `credit_card` object inside the `user` object with the string `[CLIENT_REDACTED]`.

Tip

To learn more about JSONPaths, please take a look at the official docs or use this JSONPath Evaluator to validate your JSONPath expressions.

You can also use our JSON Redaction Tool to preview what the final data sent from your API to APItoolkit will look like, after redacting any given JSON object.

Here's an example of what the configuration would look like with redacted fields:

import { NestFactory } from "@nestjs/core";
import { APIToolkit } from "apitoolkit-express";

async function bootstrap() {
  const redactHeaders = ["Content-Type", "Authorization", "HOST"];
  const redactRequestBody = ["$.user.email", "$.user.addresses"];
  const redactResponseBody = ["$.users[*].email", "$.users[*].credit_card"];

  const apiToolkitClient = APIToolkit.NewClient({
    apiKey: "{ENTER_YOUR_API_KEY_HERE}",
    redactHeaders,
    redactRequestBody,
    redactResponseBody,
  });

  const app = await NestFactory.create(AppModule);
  app.use(apiToolkitClient.expressMiddleware);

  await app.listen(3000);
}

bootstrap();

import { NestFactory } from "@nestjs/core";
import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
import APIToolkit from "apitoolkit-fastify";
import Fastify from "fastify";
import { AppModule } from "./app.module";

async function bootstrap() {
  const fastify = fastify();
  const app = await NestFactory.create(AppModule, new FastifyAdapter(fastify));

  const apiKey = "{ENTER_YOUR_API_KEY_HERE}";
  const redactHeaders = ["content-type", "Authorization", "HOST"];
  const redactRequestBody = ["$.user.email", "$.user.addresses"];
  const redactResponseBody = ["$.users[*].email", "$.users[*].credit_card"];

  const apitoolkitClient = APIToolkit.NewClient({
    fastify,
    apiKey,
    redactHeaders,
    redactRequestBody,
    redactResponseBody,
  });
  apitoolkitClient.init();

  await app.listen(3000);
}

bootstrap();

Note

The redactHeaders config field expects a list of case-insensitive headers as strings.
The redactRequestBody and redactResponseBody config fields expect a list of JSONPaths as strings.
The list of items to be redacted will be applied to all endpoint requests and responses on your server.

Error Reporting

With APItoolkit, you can track and report different unhandled or uncaught errors, API issues, and anomalies at different parts of your application. This will help you associate more detail and context from your backend with any failing customer request.

The configuration process depends on whether you choose ExpressJS or FastifyJS as your framework. Hence, you can read our SDK documentation for both options by clicking any of the buttons below:

ExpressJS Error Reporting Guide

FastifyJS Error Reporting Guide

Monitoring Outgoing Requests

Outgoing requests are external API calls you make from your API. By default, APItoolkit monitors all requests users make from your application and they will all appear in the API Log Explorer page. However, you can separate outgoing requests from others and explore them in the Outgoing Integrations page, alongside the incoming request that triggered them.

The configuration process depends on whether you choose ExpressJS or FastifyJS as your framework. Hence, you can read our SDK documentation for both options by clicking any of the buttons below:

ExpressJS Monitoring Outgoing Requests Guide

FastifyJS Monitoring Outgoing Requests Guide

Explore the ExpressJS SDK

Explore the FastifyJS SDK