Question - Support for traces? about nestjs-sentry HOT 6 OPEN

SentryModule.forRoot({
   enabled: true,
   dsn: process.env.SENTRY_DSN,
   debug: false,
   environment: 'production',
   integrations: [
      new Sentry.Integrations.Http({ tracing: true })
   ],
   tracesSampleRate: 1.0,
})

import {
  Injectable,
  NestMiddleware,
} from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';
import { InjectSentry, SentryService } from '@ntegral/nestjs-sentry';

@Injectable()
export class TraceMiddleware implements NestMiddleware {
  constructor(@InjectSentry() private readonly sentry: SentryService) {}
  use(req: Request, res: Response, next: NextFunction): void {
    const transaction = this.sentry.instance().startTransaction({
      op: 'request',
      name: req.url,
    });

    this.sentry.instance().getCurrentHub().configureScope(scope => {
      scope.addEventProcessor(event => {
        event.request = {
          method: req.method,
          url: req.url,
        };
        return event;
      });
    });

    this.sentry.instance().configureScope(scope => {
      scope.setSpan(transaction);
    });

    req.on('close', () => {
      transaction.setHttpStatus(res.statusCode);
      transaction.finish();
    });

    next();
  }
}

export class AppModule {
    configure(consumer: MiddlewareConsumer): void {
        consumer.apply(TraceMiddleware).forRoutes('*');
    }
}

import { Injectable, NestMiddleware } from '@nestjs/common';
import { InjectSentry, SentryService } from '@ntegral/nestjs-sentry';
import { Handlers } from '@sentry/node';
import { NextFunction, Request, Response } from 'express';

@Injectable()
export class RequestMiddleware implements NestMiddleware {
  private readonly handler = Handlers.requestHandler({
    include: {
      ip: true,
      user: true,
      request: true,
      transaction: 'methodPath',
    },
  });

  constructor(@InjectSentry() private readonly sentry: SentryService) {}
  use(req: Request, res: Response, next: NextFunction): void {
    this.handler(req, res, next);
  }
}

import { Injectable, NestMiddleware } from '@nestjs/common';
import { InjectSentry, SentryService } from '@ntegral/nestjs-sentry';
import { Handlers } from '@sentry/node';
import { NextFunction, Request, Response } from 'express';

@Injectable()
export class TraceMiddleware implements NestMiddleware {
  private readonly handler = Handlers.tracingHandler();

  constructor(@InjectSentry() private readonly sentry: SentryService) {}
  use(req: Request, res: Response, next: NextFunction): void {
    this.handler(req, res, next);
  }
}

export class WebModule {
  configure(consumer: MiddlewareConsumer): void {
    consumer.apply(TraceMiddleware).forRoutes('*');
    consumer.apply(RequestMiddleware).forRoutes('*');
  }
}

import { CallHandler, ExecutionContext, HttpException } from '@nestjs/common';
import {
  SentryInterceptor as BaseInterceptor,
  InjectSentry,
  SentryService,
} from '@ntegral/nestjs-sentry';
import { Handlers } from '@sentry/node';
import { Observable, catchError, throwError } from 'rxjs';
import { EntityNotFoundError } from 'typeorm';

export class SentryInterceptor extends BaseInterceptor {
  private readonly handler = Handlers.errorHandler();

  constructor(@InjectSentry() private readonly sentry: SentryService) {
    super({
      filters: [
        {
          type: HttpException,
          filter: (e: HttpException) => e.getStatus() < 500,
        },
        {
          type: EntityNotFoundError,
        },
      ],
    });
  }

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError((error) => {
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore
        if (this.shouldReport(error)) {
          const http = context.switchToHttp();
          this.handler(error, http.getRequest(), http.getResponse(), () => {});
        }

        return throwError(() => error);
      }),
    );
  }
}

    SentryCoreModule.forRootAsync({
      inject: [ConfigService, VersionService, HttpAdapterHost],
      useFactory: async (
        config: ConfigService,
        version: VersionService,
        host: HttpAdapterHost,
      ) => ({
        dsn: config.get('SENTRY_DSN'),
        release: await version.release(),
        environment: config.get('NODE_ENV'),
        tracesSampleRate: 1.0,
        integrations: [
          new Sentry.Integrations.Http({ tracing: true }),
          new Mysql(),
          host?.httpAdapter
            ? new Tracing.Integrations.Express({
                app: host.httpAdapter.getInstance(),
              })
            : null,
        ].filter((i) => !!i),
      }),
    }),

import type { Hub } from '@sentry/core';
import type { EventProcessor, Integration } from '@sentry/types';
import { fill, loadModule, logger } from '@sentry/utils';

interface MysqlConnection {
  createQuery: () => void;
}

/** Tracing integration for node-mysql package */
export class Mysql implements Integration {
  /**
   * @inheritDoc
   */
  public static id = 'Mysql';

  /**
   * @inheritDoc
   */
  public name: string = Mysql.id;

  /**
   * @inheritDoc
   */
  public setupOnce(
    _: (callback: EventProcessor) => void,
    getCurrentHub: () => Hub,
  ): void {
    const pkg = loadModule<MysqlConnection>('mysql2/lib/connection.js');

    if (!pkg) {
      __DEBUG_BUILD__ &&
        logger.error(
          'Mysql Integration was unable to require `mysql2` package.',
        );
      return;
    }

    fill(pkg, 'createQuery', function (orig: () => void) {
      return function (
        this: unknown,
        sql: unknown,
        values: unknown,
        cb: Function,
        config: any,
      ) {
        let options: Record<string, any> = {
          rowsAsArray: config?.rowsAsArray,
        };

        if (typeof sql === 'object') {
          // query(options, cb)
          options = sql;
          if (typeof values === 'function') {
            cb = values;
          } else if (values !== undefined) {
            options.values = values;
          }
        } else if (typeof values === 'function') {
          // query(sql, cb)
          cb = values;
          options.sql = sql;
          options.values = undefined;
        } else {
          // query(sql, values, cb)
          options.sql = sql;
          options.values = values;
        }

        const scope = getCurrentHub().getScope();
        const parentSpan = scope?.getSpan();
        const span = parentSpan?.startChild({
          description: options.sql,
          op: 'db',
        });

        const ret = orig.call(this, ...arguments); // eslint-disable-line prefer-rest-params

        ret.on('end', () => {
          span?.finish();
        });

        return ret;
      };
    });
  }
}