Integrate Datadog in Node.js and track your backend performance

Integrate Datadog in Node.js and track your backend performance

In this article, we will see how to integrate a complete module for Datadog in Node.js and track your backend performance with Datadog.

We will use typeScript and NestJS to integrate the Datadog.
In this article, we will learn and see following things:

What is Datadog?

How to integrate the Datadog in NodeJs application?

Integrate the Datadog with moduler code.

How we track the event in Datadog?

How we track the service in Datadog?

How we track the each API call to the nodeJS app?

How to see the flow of service in Datadog?

Let's get started.

What is Datadog?

Datadog has products for the following operations:

How to integrate the Datadog in NodeJs application?

File: dd-metrics-events.ts

                                export const DD_REFERRAL_METRICS_EVENTS = {
                                    VALIDATE_PROMO_API_CALL_OK: "ValidateApiCall.OK",
                                    VALIDATE_PROMO_API_CALL_FAIL: "ValidateApiCall.FAIL"
                                }
                            

File: dd-metrics-publisher.ts

                    
                                import { Injectable } from '@nestjs/common';
                    
                                const metrics = require('datadog-metrics');
                                const ddApiKey = process.env.DD_CLIENT_TOKEN;
                                const ddHost = process.env.DD_AGENT_HOST;
                    
                                const nodeEnv = 'beta';
                                const appName = 'dd-idk-integration',
                                cont module = 'dd-demo'
                    
                    
                                metrics.init({
                                    apiKey: ddApiKey,
                                    defaultTags: [`env:${nodeEnv}`,"metric_submission_type:count", `host:${ddHost}`],
                                    flushIntervalSeconds: 30
                                });
                    
                                @Injectable()
                                export class DDMetrics {
                                    constructor() {}
                    
                                incrementCounter(metricName: string) {
                                    try {
                                    const podName = appName;
                                    if (ddApiKey) {
                                        const key = `${module}.${nodeEnv}.${metricName}`;
                                        const value = 1;
                                        const tags = [`pod:${podName}`];
                                        const timestamp = Date.now();
                                        metrics.increment(key, value, tags, timestamp);
                                    }
                                    } catch (error) {
                                    console.log(`Datadog metrics publish error for ${metricName} - ${JSON.stringify(error)}`)
                                    }
                                }
                                }
                            

How to use?

First, we need to import the DDMetrics module in the app.module.ts and then add the DDMetrics module to the providers array.

File: app.module.ts

                                import { DDMetrics } from 'src/datadog/dd-metrics-publisher';
                    
                                @Module({
                                    imports: [....],
                                    controllers: [...],
                                    providers: [DDMetrics,...],
                                    exports: [...],
                                })
                                export class AppModule {}
                    
                            

Now we have imported, now we need to use the service method of the Datadog to increment the event that we implemented earlier.

File: app.controller.ts

                            import { DDMetrics } from 'src/datadog/dd-metrics-publisher';
                    
                            @Controller()
                            export class AppController {
                                constructor(
                                    private ddMetricsPublisher: DDMetrics
                                ) {}
                    
                                @UseGuards(StrictAuthGuard)
                                @GET("/v1/validate")
                                async validatePromocode(
                                    @Body() validatePromoDto: ReferralValidatePromoCodeRequestDto
                                ) {
                                    this.ddMetricsPublisher.incrementCounter(DD_REFERRAL_METRICS_EVENTS.VALIDATE_PROMO_API_CALL_OK);
                                    .
                                    .
                                    .
                                }
                            }
                        

The above will be triggered when you call the API /v1/validate.  this will send an event to the Datadog and Datadog will increment the value and also create the dashboard and service on the Datadog.

Now you can see the following things in the Datalog:

Datadog Metrices for events:

Integrate Datadog in Node.js and track your backend performance

Datadog Service for App 'dd-idk-integration':

Integrate Datadog in Node.js and track your backend performance

Datadog service summary:

Integrate Datadog in Node.js and track your backend performance

Datadog resource summary:

Integrate Datadog in Node.js and track your backend performance

Datadog service detailed metrices:

Integrate Datadog in Node.js and track your backend performance

---

Conclusion:

In this article, we integrated Datadog in Node.js and tracked our backend performance with Datadog. We implemented a complete module and see the performance metrics in Datadog.