APM Traces on NestJs application

[TheVoid-0]

Hi, thanks for all the work and effort put on DataDog, me and my team love using it, and it works great on our nodeJs APIs, but, recently we started migrating our APIs from pure nodeJs with Typescript to a NestJs application, and we noticed that our APM tracer logs are not showing up with all the details it did before. On our pure express APIs we can see detailed traces with lots of infos and even the queries that are made, but in NestJs we can only see one line sayng error: true wich is kind of useless. Can someone tell me what is needed for a NestJs to be traced with DataDog?

Thanks in advance!

[rochdev]

NestJS has a fairly complicated module and dependency injection system that we don't currently support, so it's possible that some features of tracing don't work properly. For errors specifically, if there is anywhere you can handle the error within the framework, it would be possible to attach it to the root span. If you can provide a reproduction snippet I can try to provide more information about how to do this for your use case specifically.

[TheVoid-0]

Hi, thanks for answering!

I don't know if I've addressed this issue correctly, but this is what I've done so far:

I created an NestJs Interceptor, which is basically, a middleware where you have access to the function that will handle the request, while also being able to "listen" for the request response, since in Nest, the response is propragated with a rxjs Observable.

// This class intercept method will be called for every request reaching the application before being handled by the controller
export class DataDogApmInterceptor  {
  // apmTracer in this context represents the configured tracer from 'dd-trace' and is the same object
  constructor(private readonly apmTracer: ApmTracer) {
  }

  public intercept(context: ExecutionContext, next: CallHandler): Observable<any> | Promise<Observable<any>> {
    const handlerObservable = next.handle();

    // Creates a pipe on the observable to perform a callback inside the dd-tracer context with the handler (that is the Controller) response
    const pipedObservable = this.apmTracer.trace(`DataDogTracerInterceptor`, (span, callback) => {
      // Returns an observable with the pipe executing the callback inside tracer context
      return handlerObservable.pipe(
        tap({
          complete: () => callback(undefined),
          error: err => {
            callback(err);
          },
        }),
      );
    });

    return pipedObservable;
  }
}

With this it seems data dog can correctly display the error traces using the original error throwed from inside application logic.
Just not sure it is enough for all use cases, or if it mimic the "normal" trace behavior on plain NodeJs applications.

[rochdev]

Do you still get traces even without creating any custom span? If that's the case and assuming that the right span would be active in the interceptor you could set the error on the request span instead of a new custom span.

For example:

const handlerObservable = next.handle()
const span = tracer.scope().active()

// Returns an observable with the pipe executing the callback inside tracer context
return handlerObservable.pipe(
  tap({
    error: err => {
      span.setTag('error', err)
    }
  })
)

[TheVoid-0]

Hi, sorry for the delay, I had to let this matter aside until now. Thanks for you answer I tried and it worked too, and is more simple than mine. Now I'm trying to know if it's possible to attach multiple errors on the same request. On pure nodeJs applications there are usually more than one error per request even though it's the same, they appear for each step of the request (e.g middleware, router, controller). I want to be able to set another tag with another error. I've tried span.addTags({someKey: new Error()}) but I didn't noticed any difference on the final trace

[rochdev]

Only one error is supported by span, but for middleware specifically it should be possible to attach the error to individual middleware spans instead. This is already done automatically if the error is thrown or passed to next(), but for handled errors it can be done manually:

const span = tracer.scope().active()
span.setTag('error', error)