NestJS OpenTelemetry

This library, initially forked from @overbit/opentelemetry-nestjs, provides deeply integrated protocol-agnostic Nestjs OpenTelemetry instrumentations, metrics and SDK.

Description

Nestjs is a protocol-agnostic framework. That's why this library can able to work with different protocols like RabbitMQ, GRPC and HTTP. Also you can observe and trace Nestjs specific layers like Pipe, Guard, Controller and Provider.

It also includes auto trace and metric instrumentations for some popular Nestjs libraries.

Distributed Tracing
Metrics
- Setup

OpenTelemetry Metrics currently experimental. So, this library doesn't support metric decorators and Auto Observers until it's stable. but if you want to use it, you can use OpenTelemetry API directly.

Competability table for Nestjs versions.

Nestjs	Nestjs-OpenTelemetry
9.x	3.x.x
8.x	2.x.x

Installation

npm install @amplication/opentelemetry-nestjs --save

Configuration

This is a basic configuration without any trace and metric exporter, but includes default metrics and injectors

import { OpenTelemetryModule } from '@amplication/opentelemetry-nestjs';

@Module({
  imports: [
    OpenTelemetryModule.forRoot({
      serviceName: 'nestjs-opentelemetry-example',
    }),
  ],
})
export class AppModule {}

Async configuration example

import { OpenTelemetryModule } from '@amplication/opentelemetry-nestjs';
import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    OpenTelemetryModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        serviceName: configService.get('SERVICE_NAME'),
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

Default Parameters

key	value	description
traceAutoInjectors	ControllerInjector, GuardInjector, EventEmitterInjector, ScheduleInjector, PipeInjector, LoggerInjector	default auto trace instrumentations inherited from NodeSDKConfiguration
contextManager	AsyncLocalStorageContextManager	default trace context manager inherited from NodeSDKConfiguration
instrumentations	AutoInstrumentations	default instrumentations inherited from defaults of@opentelemetry/auto-instrumentations-node where: `@opentelemetry/instrumentation-dns` and `@opentelemetry/instrumentation-net` have been disabled to reduce noise `@opentelemetry/instrumentation-http` ignores common health check endpoints and creates span with name `"HTTP_METHOD PATH"` `@opentelemetry/instrumentation-fs`ignores operations on files under `node_modules` `@opentelemetry/instrumentation-express`ignores operations on files under `node_modules`
spanProcessor	NoopSpanProcessor	default spanProcessor inherited from NodeSDKConfiguration
textMapPropagator	JaegerPropagator, B3Propagator	default textMapPropagator inherited from NodeSDKConfiguration

OpenTelemetryModule.forRoot() takes OpenTelemetryModuleConfig as a parameter, this type is inherited by NodeSDKConfiguration so you can use same OpenTelemetry SDK parameter.

Distributed Tracing

Simple setup with Zipkin exporter, including with default trace instrumentations.

import { OpenTelemetryModule } from '@amplication/opentelemetry-nestjs';
import { ZipkinExporter } from '@opentelemetry/exporter-zipkin';
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';

@Module({
  imports: [
    OpenTelemetryModule.forRoot({
      spanProcessor: new SimpleSpanProcessor(
        new ZipkinExporter({
          url: 'your-zipkin-url',
        }),
      ),
    }),
  ],
})
export class AppModule {}

After setup, your application will be instrumented, so that you can see almost every layer of application in ZipkinUI, including Guards, Pipes, Controllers even global layers like this

List of supported official exporters here.

Trace Decorators

This library supports auto instrumentations for Nestjs layers, but sometimes you need to define custom span for specific method blocks like providers methods. In this case @Traceable and @Span decorators will help you.

`@Span`

import { Injectable } from '@nestjs/common';
import { Span } from '@amplication/opentelemetry-nestjs';

@Injectable()
export class AppService {
  @Span()
  getHello(): string {
    return 'Hello World!';
  }
}

Also @Span decorator takes name field as a parameter

@Span('hello')

`@Traceable`

@Traceable works like @Span but with the difference that it can be used at a class level to auto instrument every method of the class

import { Injectable } from '@nestjs/common';
import { Traceable } from '@amplication/opentelemetry-nestjs';

@Traceable()
@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

Trace Providers

In an advanced use cases, you need to access the native OpenTelemetry Trace provider to access them from Nestjs application context.

import { Injectable } from '@nestjs/common';
import { Tracer } from '@opentelemetry/sdk-trace-base';

@Injectable()
export class AppService {
  constructor(private readonly tracer: Tracer) {}

  getHello(): string {
    const span = this.tracer.startSpan('important_section_start');
    // do something important
    span.setAttributes({ userId: 1150 });
    span.end();
    return 'Hello World!';
  }
}

TraceService can access directly current span context and start new span.

import { Injectable } from '@nestjs/common';
import { TraceService } from '@amplication/opentelemetry-nestjs';

@Injectable()
export class AppService {
  constructor(private readonly traceService: TraceService) {}

  getHello(): string {
    const span = this.traceService.startSpan('hello');
    // do something
    span.end();
    return 'Hello World!';
  }
}

Auto Trace Instrumentations

The most helpful part of this library is that you already get all of the instrumentations by default if you set up a module without any extra configuration. If you need to avoid some of them, you can use the traceAutoInjectors parameter.

import { Module } from '@nestjs/common';
import {
  OpenTelemetryModule,
  ControllerInjector,
  EventEmitterInjector,
  GuardInjector,
  LoggerInjector,
  PipeInjector,
  ScheduleInjector,
} from '@amplication/opentelemetry-nestjs';
import { ZipkinExporter } from '@opentelemetry/exporter-zipkin';
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';

@Module({
  imports: [
    OpenTelemetryModule.forRoot({
      traceAutoInjectors: [
        ControllerInjector,
        GuardInjector,
        EventEmitterInjector,
        ScheduleInjector,
        PipeInjector,
        LoggerInjector,
      ],
      spanProcessor: new SimpleSpanProcessor(
        new ZipkinExporter({
          url: 'your-zipkin-url',
        }),
      ),
    }),
  ],
})
export class AppModule {}

List of Trace Injectors

Instance	Description
`ControllerInjector`	Auto trace all of module controllers
`GuardInjector`	Auto trace all of module guards including global guards
`PipeInjector`	Auto trace all of module pipes including global pipes
`EventEmitterInjector`	Auto trace for @nestjs/event-emitter library, supports all features
`ScheduleInjector`	Auto trace for @nestjs/schedule library, supports all features
`ConsoleLoggerInjector`	ConsoleLogger and Logger class tracer, logs with traceId

Distributed Logging with Trace ID

When you set up your environment with the LoggerInjector class or default configuration, you can see trace id with every log.

Trace Not @Injectable() classes

In some use cases, you need to trace instances of classes instanciated outside the NestJS DI container. In order to do so, use the TraceWrapper.trace() method to wrap every method of the instance in a new span as follow

import { TraceWrapper } from '@amplication/opentelemetry-nestjs';

class MyClass {
  hello() {
    console.log('Hi');
  }

  async bye() {
    await new Promise(() => console.log('bye bye'));
  }
}

// ....
const instance = new MyClass();
const tracedInstance = TraceWrapper.trace(instance);

// ....

Metrics

Simple setup with Prometheus exporter, you need install @opentelemetry/exporter-prometheus

import { OpenTelemetryModule } from '@amplication/opentelemetry-nestjs';
import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';

@Module({
  imports: [
    OpenTelemetryModule.forRoot({
      serviceName: 'nestjs-opentelemetry-example',
      metricReader: new PrometheusExporter({
        endpoint: 'metrics',
        port: 9464,
      }),
    }),
  ],
})
export class AppModule {}

Now you can access Prometheus exporter with auto collected metrics http://localhost:9464/metrics. Also, you can find different exporters here

Examples

import { Module } from '@nestjs/common';
import type { OpenTelemetryModule } from '@amplication/opentelemetry-nestjs';
import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
import { CompositePropagator } from '@opentelemetry/core';
import { JaegerPropagator } from '@opentelemetry/propagator-jaeger';
import { B3InjectEncoding, B3Propagator } from '@opentelemetry/propagator-b3';

@Module({
  imports: [
    OpenTelemetryModule.forRoot({
      serviceName: 'myservice-opentelemetry-example',
      metricReader: new PrometheusExporter({
        endpoint: 'metrics',
        port: 9464,
      }),
      spanProcessor: new BatchSpanProcessor(
        new OTLPTraceExporter({
          url: 'your-jaeger-url',
        }),
      ),
      textMapPropagator: new CompositePropagator({
        propagators: [
          new JaegerPropagator(),
          new B3Propagator(),
          new B3Propagator({
            injectEncoding: B3InjectEncoding.MULTI_HEADER,
          }),
        ],
      }),
    }),
  ],
})
export class AppModule {}

AWS XRay

For the integration with AWS X-Ray, follow the official instructions.

i.e.

import { Module } from '@nestjs/common';
import type {
  OpenTelemetryModule,
  OpenTelemetryModuleDefaultConfig,
} from '@amplication/opentelemetry-nestjs';
import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
import { CompositePropagator } from '@opentelemetry/core';
import { AWSXRayPropagator } from '@opentelemetry/propagator-aws-xray';
import { AWSXRayIdGenerator } from '@opentelemetry/id-generator-aws-xray';
import { AwsInstrumentation } from '@opentelemetry/instrumentation-aws-sdk';

@Module({
  imports: [
    OpenTelemetryModule.forRoot({
      serviceName: 'myservice-opentelemetry-example',
      metricReader: new PrometheusExporter({
        endpoint: 'metrics',
        port: 9464,
      }),
      instrumentations: [
        ...OpenTelemetryModuleDefaultConfig.instrumentations,
        new AwsInstrumentation({
          suppressInternalInstrumentation: true,
          sqsExtractContextPropagationFromPayload: true,
        }),
      ],
      idGenerator: new AWSXRayIdGenerator(),
      spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter({})),
      textMapPropagator: new AWSXRayPropagator(),
    }),
  ],
})
export class AppModule {}

testing-amplication-opentelemetry-nestjs

NestJS OpenTelemetry

Description

Distributed Tracing

Metrics

Installation

Configuration

Default Parameters

Distributed Tracing

Trace Decorators

`@Span`

`@Traceable`

Trace Providers

Auto Trace Instrumentations

List of Trace Injectors

Distributed Logging with Trace ID

Trace Not @Injectable() classes

Metrics

Examples

AWS XRay

Readme

Keywords

Package Sidebar

Install

Repository

Homepage

Weekly Downloads

Version

License

Unpacked Size

Total Files

Last publish

Collaborators

testing-amplication-opentelemetry-nestjs

Readme

Keywords

Package Sidebar

Install

Repository

Homepage

DownloadsWeekly Downloads

Version

License

Unpacked Size

Total Files

Last publish

Collaborators

Weekly Downloads