@rsdk/core 4.1.0 → 4.2.0-next.1

package/src/tracing/http.headers.ts

@@ -0,0 +1,32 @@
+import type { MaybeReadonlyArray } from '@rsdk/common.node';
+
+/**
+ * @description хелпер для нормализованного извлечения заголовков из http запроса
+ */
+export class HttpHeaders {
+  constructor(private headers: Record<string, string>) {
+    this.normalizedHeaders = Object.fromEntries(
+      Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]),
+    );
+  }
+
+  get<K extends string>(
+    key: MaybeReadonlyArray<K>,
+  ): Record<K, string | undefined>;
+
+  get(key: string): string | undefined;
+
+  get(
+    key: string | MaybeReadonlyArray<string>,
+  ): Record<string, string | undefined> | string | undefined {
+    if (Array.isArray(key)) {
+      return Object.fromEntries(key.map((k) => [k, this.get(k)])) as Record<
+        string,
+        any
+      >;
+    }
+    return this.normalizedHeaders[(key as string).toLowerCase()];
+  }
+
+  private normalizedHeaders: Record<string, string>;
+}

package/src/tracing/index.ts

@@ -1,7 +1,6 @@
 export * from './active-span.module';
 export * from './request-metadata.module';
 export * from './services/active-span.storage';
-export * from './services/request-metadata.storage';
 export * from './tracing.module';
 export * from './utils/create-span';
 export * from './utils/save-async-hooks-context';

package/src/tracing/open-telemetry.interceptor.ts

@@ -0,0 +1,114 @@
+import type {
+  CallHandler,
+  ExecutionContext,
+  NestInterceptor,
+} from '@nestjs/common';
+import { trace } from '@opentelemetry/api';
+import {
+  X_B3_PARENT_SPAN_ID,
+  X_B3_SPAN_ID,
+  X_B3_TRACE_ID,
+} from '@opentelemetry/propagator-b3';
+import { api } from '@opentelemetry/sdk-node';
+import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
+import { catchError, mergeMap, Observable, of, throwError } from 'rxjs';
+
+import { OpenTelemetryProvider } from './services/request-id.provider';
+import { TraceInjector } from './services';
+
+export class OpenTelemetryInterceptor implements NestInterceptor {
+  intercept(
+    _context: ExecutionContext,
+    next: CallHandler<any>,
+  ): Observable<any> | Promise<Observable<any>> {
+    const tracer = trace.getTracer('@rsdk/open-telemetry', '1.0.0');
+
+    const spanName = TraceInjector.createSpanName(
+      OpenTelemetryInterceptor.name,
+      'intercept',
+    );
+
+    /**
+     * Создаем новый спан
+     */
+    const span = tracer.startSpan(spanName, {});
+
+    const openTelemetryValues = OpenTelemetryProvider.getOrThrow();
+
+    const parentSpanId = openTelemetryValues[X_B3_PARENT_SPAN_ID];
+    if (parentSpanId) {
+      (span as any).parentSpanId = parentSpanId;
+    }
+
+    const spanId = openTelemetryValues[X_B3_SPAN_ID];
+    /**
+     * После создания контекста ранее при входе в приложение, у нас новый спан ид
+     * мы перетираем значением которе получили через заголовок
+     * в рамках приложения он корректный, но при переходе из одного приложения в другой - слетает
+     * и чтобы 100% все было норм, мы всегда патчим его
+     */
+    if (spanId) {
+      span.spanContext().spanId = spanId;
+    }
+
+    const traceId = openTelemetryValues[X_B3_TRACE_ID];
+    /**
+     * Патчим трайс ид, причина выше
+     */
+    if (traceId) {
+      span.spanContext().traceId = traceId;
+    }
+    /**
+     * Обычно самая первая точка входа это фронтовый запрос, который содержит некие заголовки хттп
+     * мы их кладем в рутовый спан
+     */
+    if (openTelemetryValues.http) {
+      span.setAttribute(
+        SemanticAttributes.HTTP_METHOD,
+        openTelemetryValues.http.httpMethod,
+      );
+      span.setAttribute(
+        SemanticAttributes.HTTP_URL,
+        openTelemetryValues.http.httpUrl,
+      );
+      span.setAttribute(
+        SemanticAttributes.HTTP_ROUTE,
+        openTelemetryValues.http.httpRoute,
+      );
+    }
+    /**
+     * Чтобы пробросить пропатченный спан нужно запустить две строчки ниже:
+     * 1) создаем контекст в котором активный спан перебиваем новым
+     * 2) созданный контекст ставим основным и в нем запускаем под процесс
+     */
+    const spanContext = api.trace.setSpan(api.context.active(), span);
+
+    return new Observable((observer) => {
+      api.context.with(spanContext, () => {
+        next
+          .handle()
+          .pipe(
+            mergeMap((result) => {
+              TraceInjector.enrich(span, result);
+              span.end();
+              return of(result);
+            }),
+            catchError((error) => {
+              TraceInjector.recordAndRethrow(error, span);
+              span.end();
+              return throwError(() => error);
+            }),
+          )
+          .subscribe({
+            complete: () => {
+              observer.complete();
+            },
+            error: (error) => {
+              observer.error(error);
+            },
+            next: (res) => observer.next(res),
+          });
+      });
+    });
+  }
+}

package/src/tracing/request-metadata.module.ts

@@ -1,13 +1,8 @@
 import { Global, Module } from '@nestjs/common';
 
-import { RequestMetadataStorage } from './services/request-metadata.storage';
-
 /**
  * Модуль для хранения и получения данных из аскин локал стораджа
  */
 @Global()
-@Module({
-  providers: [RequestMetadataStorage],
-  exports: [RequestMetadataStorage],
-})
+@Module({})
 export class RequestMetadataModule {}

package/src/tracing/services/instrumentation.service.ts

@@ -2,21 +2,10 @@ import { Injectable } from '@nestjs/common';
 
 import { TracingInterceptor } from '../tracing.interceptor';
 
-import { RequestMetadataInjector } from './request-metadata.injector';
 import { TraceInjector } from './trace.injector';
 
 @Injectable()
 export class InstrumentationService {
-  public injectWrapRequestMetadataInjector(): void {
-    /**
-     * Оборачиваем интерцептор в логику которая несет с собою асинк локал сторадж с requestId
-     */
-    RequestMetadataInjector.wrap(
-      TracingInterceptor.prototype,
-      TracingInterceptor.prototype['intercept'],
-    );
-  }
-
   public injectWrapTraceInjector(): void {
     /**
      * Оборачиваем интерцептор в логику которая несет с собою асинк локал сторадж с traceId, spanId

package/src/tracing/services/request-id.provider.ts

@@ -0,0 +1,21 @@
+import type {
+  X_B3_PARENT_SPAN_ID,
+  X_B3_SPAN_ID,
+  X_B3_TRACE_ID,
+} from '@opentelemetry/propagator-b3';
+import { createAsyncContextProvider } from '@rsdk/actx';
+
+export const RequestIdProvider = createAsyncContextProvider<string>({
+  name: 'RequestId',
+  rewritable: false,
+});
+
+export const OpenTelemetryProvider = createAsyncContextProvider<{
+  [X_B3_SPAN_ID]?: string;
+  [X_B3_TRACE_ID]?: string;
+  [X_B3_PARENT_SPAN_ID]?: string;
+  http?: { httpMethod: string; httpUrl: string; httpRoute: string };
+}>({
+  name: 'OpenTelemetryPropagation',
+  rewritable: false,
+});

package/src/tracing/services/trace.injector.ts

@@ -1,13 +1,6 @@
-import type { ExecutionContext } from '@nestjs/common';
 import type { AttributeValue, Span } from '@opentelemetry/api';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
-import {
-  X_B3_PARENT_SPAN_ID,
-  X_B3_SPAN_ID,
-  X_B3_TRACE_ID,
-} from '@opentelemetry/propagator-b3';
 import { api } from '@opentelemetry/sdk-node';
-import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
 import type { ErrorLike } from '@rsdk/common';
 import { isPrimitive, isRecord, normalizer } from '@rsdk/common';
 import { redecorate } from '@rsdk/decorators';
@@ -82,165 +75,23 @@ export class TraceInjector {
   private static createWrapper(
     original: any,
     spanName: string,
-    isTracingInterceptor?: boolean,
+    _isTracingInterceptor?: boolean,
   ): any {
     return {
       [original.name](...args: any[]): any {
         const tracer = trace.getTracer('@rsdk/open-telemetry', '1.0.0');
-        const executionContext: ExecutionContext = args[0];
 
         /**
          * Переменный для хранения значений которые получаем для опен телеметрии
          */
         let traceId: string | undefined;
         let spanId: string | undefined;
-        let parentSpanId: string | undefined;
-        /**
-         * Этот флаг нужен для детекта первого входа и старта трейсинга, логика использования ниже в контексте
-         */
-        let hasParentSpanId = false;
-
-        /**
-         * Переменная для хранения Request/виртуального рекRequestвеста
-         */
-        let req: any;
-
-        /**
-         * Первый вход обычно происходит в глобальном интерцепторе
-         * он оборачивается в некий свой интернал тип спана который и передает этот флаг isTracingInterceptor=true
-         */
-        if (isTracingInterceptor) {
-          if (executionContext.getType() === 'rpc') {
-            const metadata = executionContext.switchToRpc().getContext();
-            /**
-             * Если мы пришли в GRPC и у нас есть методы для работы с Metadata
-             * то мы конвертируем Metadata в некий виртуальный request с заголовками (заголовки выбраны как общий стандарт проброса мета информации)
-             */
-            if (metadata?.get) {
-              req = {
-                headers: {
-                  /**
-                   * Пробрасываем текущий трейс ид запроса
-                   */
-                  ...(metadata.get(X_B3_TRACE_ID).length > 0
-                    ? {
-                        [X_B3_TRACE_ID]: metadata.get(X_B3_TRACE_ID)[0],
-                      }
-                    : {}),
-                  /**
-                   * Пробрасываем текущий спан ид, он нужен чтобы установить цепочку с парентами и могли видеть правильную вложенность в графане
-                   */
-                  ...(metadata.get(X_B3_SPAN_ID).length > 0
-                    ? {
-                        [X_B3_SPAN_ID]: metadata.get(X_B3_SPAN_ID)[0],
-                      }
-                    : {}),
-                  /**
-                   * Вот это не обычная переменная, она нужна для определения общего входа и детекта рутового спан ид,
-                   * эта переменная нужна для работы флага hasParentSpanId
-                   */
-                  ...(metadata.get(X_B3_PARENT_SPAN_ID).length > 0
-                    ? {
-                        [X_B3_PARENT_SPAN_ID]:
-                          metadata.get(X_B3_PARENT_SPAN_ID)[0],
-                      }
-                    : {}),
-                },
-              };
-            }
-          }
-
-          if (executionContext.getType() === 'http') {
-            req = executionContext.switchToHttp().getRequest();
-          }
-
-          if (executionContext.getType<string>() === 'graphql') {
-            req = executionContext.getArgs()[2]?.req; // аналог GqlExecutionContext.create(executionContext).getContext().req
-
-            if (req.connectionInitReceived) {
-              /**
-               * При работе с сабскрипшен через веб сокет, заголовки передаются в опции подключения к сабскрипшен в переменную connectionParams
-               * и мы перегоняем эти данные в request заголовки
-               */
-              req.headers = {
-                ...req?.headers,
-                ...Object.entries(req?.connectionParams?.headers || {}).reduce(
-                  (acc, [key, value]) => {
-                    acc[key] = value;
-                    return acc;
-                  },
-                  <Record<string, unknown>>{},
-                ),
-              };
-            }
-          }
-        }
-
-        if (req?.headers) {
-          /**
-           * Мы приводим все ключи заголовков к одному **lower_case** регистру, так как у разных транспортов разные регистры в именовании ключей для заголовков
-           */
-          req.headers = {
-            ...Object.entries(req.headers).reduce(
-              (acc, [key, value]) => {
-                acc[key.toLowerCase()] =
-                  req.headers[key.toLowerCase()] || value;
-                return acc;
-              },
-              <Record<string, unknown>>{},
-            ),
-          };
-
-          /**
-           * Трейс ид - входящий рутовый идентификатор, он по всем цепочкам идет
-           */
-          traceId = req.headers[X_B3_TRACE_ID];
-          /**
-           * Спан ид - идентификатор который нужен для построения цепочки вызовов
-           */
-          spanId = req.headers[X_B3_SPAN_ID];
-          /**
-           * Флаг определяет находимся ли мы на рутовой позиции (самая первая точка входа)
-           * определяется просто - если с клиента не передали заголовок X_B3_PARENT_SPAN_ID то значит мы в точке входа,
-           * иначе мы являемся частью другой общей цепочки
-           */
-          hasParentSpanId = !!Object.getOwnPropertyDescriptor(
-            req.headers,
-            X_B3_PARENT_SPAN_ID,
-          );
-          /**
-           * Идентификатор родительского спана - больше нужен для определения рутового состояния в различных кодах по опен телеметрии
-           */
-          parentSpanId = req.headers[X_B3_PARENT_SPAN_ID];
-        }
-
-        if (isTracingInterceptor) {
-          /**
-           * Когда мы находимся в интерцепторе, то названием спана является название класса + метод интерцептора
-           * мы перебиваем на название класса + метод который трекаем
-           */
-          spanName = TraceInjector.createSpanName(
-            executionContext.getClass().name,
-            executionContext.getHandler().name,
-          );
-        }
 
         /**
          * Создаем новый спан
          */
         const span = tracer.startSpan(spanName, {});
 
-        // path parentSpanId for correct link to parent span
-        if (isTracingInterceptor && hasParentSpanId && parentSpanId) {
-          /**
-           * Так как опентелеметрия ставит свой некий парент спан ид, то наш слетает
-           * если мы работаем в рамках монолита то ничего не слетает
-           * как только мы перемещаемся между приложениями - он слетает
-           * чтобы иметь корректный парент спан ид - мы патчим его жестко (из коробки нельзя это сделать)
-           */
-          (span as any).parentSpanId = parentSpanId;
-        }
-
         /**
          * После создания контекста ранее при входе в приложение, у нас новый спан ид
          * мы перетираем значением которе получили через заголовок
@@ -257,23 +108,6 @@ export class TraceInjector {
         if (traceId) {
           span.spanContext().traceId = traceId;
         }
-
-        if (req?.headers) {
-          /**
-           * Обычно самая первая точка входа это фронтовый запрос, который содержит некие заголовки хттп
-           * мы их кладем в рутовый спан
-           */
-          span.setAttribute(SemanticAttributes.HTTP_METHOD, req.method);
-          span.setAttribute(
-            SemanticAttributes.HTTP_URL,
-            req.originalUrl || req.url,
-          );
-          span.setAttribute(
-            SemanticAttributes.HTTP_ROUTE,
-            req.route?.path || req.routeOptions?.url || req.routerPath,
-          );
-        }
-
         /**
          * Чтобы пробросить пропатченный спан нужно запустить две строчки ниже:
          * 1) создаем контекст в котором активный спан перебиваем новым
@@ -352,7 +186,7 @@ export class TraceInjector {
     }[original.name];
   }
 
-  private static createSpanName(className: string, methodName: string): string {
+  static createSpanName(className: string, methodName: string): string {
     /**
      * Всего лишь правила формирования имени спана (не более того), для новой логики нужен был именно такой код
      */
@@ -380,7 +214,7 @@ export class TraceInjector {
     Reflect.defineMetadata(Constants.TRACE_METADATA_ACTIVE, NOOP, prototype);
   }
 
-  private static recordAndRethrow(error: unknown, span: Span): void {
+  static recordAndRethrow(error: unknown, span: Span): void {
     span.recordException(error as ErrorLike);
     span.setStatus({
       code: SpanStatusCode.ERROR,
@@ -390,7 +224,7 @@ export class TraceInjector {
     throw error;
   }
 
-  private static enrich(span: Span, data: unknown): unknown {
+  static enrich(span: Span, data: unknown): unknown {
     span.setAttribute('response', TraceInjector.toAttribute(data));
     span.setStatus({ code: SpanStatusCode.OK });
 

package/src/tracing/tracing.interceptor.ts

@@ -4,15 +4,141 @@ import type {
   NestInterceptor,
 } from '@nestjs/common';
 import { Injectable } from '@nestjs/common';
+import {
+  X_B3_PARENT_SPAN_ID,
+  X_B3_SPAN_ID,
+  X_B3_TRACE_ID,
+} from '@opentelemetry/propagator-b3';
+import { omitUndefined } from '@rsdk/common.node';
+import { randomUUID } from 'node:crypto';
 import type { Observable } from 'rxjs';
 
-/**
- * Интернал глобальный интерцептор для работы опентелеметрии
- * его поведение будет модифицировано в зависимости от включенного или выключенного состояния глобального трэйсинга
- */
+import {
+  OpenTelemetryProvider,
+  RequestIdProvider,
+} from './services/request-id.provider';
+import { X_REQUEST_ID } from './constants';
+import { GrpcHeaders } from './grpc.headers';
+import { HttpHeaders } from './http.headers';
+
+type TracingHeaders = {
+  [X_REQUEST_ID]: string;
+  [X_B3_SPAN_ID]?: string;
+  [X_B3_TRACE_ID]?: string;
+  [X_B3_PARENT_SPAN_ID]?: string;
+  http?: { httpMethod: string; httpUrl: string; httpRoute: string };
+};
+const tracingHeaders = [
+  X_REQUEST_ID,
+  X_B3_TRACE_ID,
+  X_B3_SPAN_ID,
+  X_B3_PARENT_SPAN_ID,
+] as const;
+
 @Injectable()
 export class TracingInterceptor implements NestInterceptor {
-  intercept(_context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const requestId = TracingInterceptor.extractTracingHeaders(context);
+
+    RequestIdProvider.set(requestId[X_REQUEST_ID]);
+    OpenTelemetryProvider.set(omitUndefined(requestId));
     return next.handle();
   }
+
+  private static extractTracingHeaders(
+    executionContext: ExecutionContext,
+  ): TracingHeaders {
+    /**
+     * В зависимости от типа контекста запускаем парсинг переданной Metadata
+     */
+    switch (executionContext.getType<string>()) {
+      case 'rpc':
+        return this.extractFromRpc(executionContext);
+      case 'http':
+        return this.extractFromHttp(executionContext);
+      case 'graphql':
+        return this.extractFromGraphql(executionContext);
+    }
+    return {
+      [X_REQUEST_ID]: this.createRequestId(),
+    };
+  }
+
+  private static extractFromGraphql(
+    executionContext: ExecutionContext,
+  ): TracingHeaders {
+    const req = executionContext.getArgs()[2]?.req; // аналог GqlExecutionContext.create(executionContext).getContext().req
+
+    /**
+     * При работе с сабскрипшен через веб сокет, заголовки передаются в опции подключения к сабскрипшен в переменную connectionParams
+     * и мы перегоняем эти данные в request заголовки
+     */
+    const headers = {
+      ...req?.headers,
+      ...req?.connectionParams?.headers,
+    };
+
+    const extractedHeaders = new HttpHeaders(headers).get([
+      X_REQUEST_ID,
+      X_B3_TRACE_ID,
+      X_B3_SPAN_ID,
+    ]);
+
+    const h = extractedHeaders as TracingHeaders;
+
+    h.http = {
+      httpMethod: req.method!,
+      httpRoute: req.route?.path || req.routeOptions?.url || req.routerPath,
+      httpUrl: req.originalUrl || req.url,
+    };
+
+    h[X_REQUEST_ID] ??= randomUUID();
+    return h as TracingHeaders;
+  }
+
+  private static extractFromHttp(
+    executionContext: ExecutionContext,
+  ): TracingHeaders {
+    // TODO:
+    const req = executionContext.switchToHttp().getRequest<any>();
+
+    const headers = new HttpHeaders(req.headers as Record<string, string>).get(
+      tracingHeaders,
+    );
+
+    const h: TracingHeaders = headers as TracingHeaders;
+
+    h[X_REQUEST_ID] ??= randomUUID();
+    h.http = {
+      httpMethod: req.method!,
+      httpRoute: req.route?.path || req.routeOptions?.url || req.routerPath,
+      httpUrl: req.originalUrl || req.url,
+    };
+    return headers as TracingHeaders;
+  }
+
+  private static extractFromRpc(
+    executionContext: ExecutionContext,
+  ): TracingHeaders {
+    const metadata = executionContext.switchToRpc().getContext();
+    /**
+     * Если мы пришли в GRPC и у нас есть методы для работы с Metadata
+     * то мы конвертируем Metadata в некий виртуальный request с заголовками (заголовки выбраны как общий стандарт проброса мета информации)
+     */
+    if (metadata?.get) {
+      const grpcHeaders = new GrpcHeaders(metadata);
+
+      const h = grpcHeaders.get(tracingHeaders);
+
+      h[X_REQUEST_ID] ??= this.createRequestId();
+      return h as TracingHeaders;
+    }
+    return {
+      [X_REQUEST_ID]: randomUUID(),
+    };
+  }
+
+  private static createRequestId(): string {
+    return randomUUID();
+  }
 }

package/src/tracing/tracing.module.ts

@@ -1,4 +1,4 @@
-import type { DynamicModule, Provider } from '@nestjs/common';
+import type { DynamicModule, OnModuleInit, Provider } from '@nestjs/common';
 import { Module } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { context, trace } from '@opentelemetry/api';
@@ -18,9 +18,10 @@ import { ILogger, LoggerFactory } from '@rsdk/logging';
 
 import { InjectLogger } from '../logging';
 
-import { RequestMetadataStorage } from './services/request-metadata.storage';
+import { RequestIdProvider } from './services/request-id.provider';
 import { ActiveSpanModule } from './active-span.module';
 import { autoInstumentationOptions } from './auto-instrumentations.config';
+import { OpenTelemetryInterceptor } from './open-telemetry.interceptor';
 import { RequestMetadataModule } from './request-metadata.module';
 import { InstrumentationService } from './services';
 import { TracingModuleConfig } from './tracing.config';
@@ -33,7 +34,7 @@ export interface TracingModuleOptions {
 }
 
 @Module({})
-export class TracingModule {
+export class TracingModule implements OnModuleInit {
   constructor(
     @InjectLogger(TracingModule) private readonly logger: ILogger,
     private readonly instrumentations: InstrumentationService,
@@ -46,27 +47,24 @@ export class TracingModule {
       module: TracingModule,
       imports: [RequestMetadataModule, ActiveSpanModule],
       providers: [
+        { provide: APP_INTERCEPTOR, useValue: new TracingInterceptor() },
+        {
+          provide: APP_INTERCEPTOR,
+          useValue: new OpenTelemetryInterceptor(),
+        },
         InstrumentationService,
         this.createSDKProvider(options),
-        /**
-         * Глобальный интерцептор для проброса входящих traceId, spanId и requestId из заголовков и метадаты в активный AsyncLocalStorage запроса
-         */
-        { provide: APP_INTERCEPTOR, useClass: TracingInterceptor },
       ],
     };
   }
 
   // Можно добавить включение и выключение при изменении конфига.
   async onModuleInit(): Promise<void> {
-    this.logger.debug('Injecting request-metadata storage...');
-    this.instrumentations.injectWrapRequestMetadataInjector();
-
     if (!this.config.enabled) {
       this.logger.info('Tracing is disabled');
 
       LoggerFactory.applyInstrumentations((record) => {
-        record['request_id'] =
-          RequestMetadataStorage.getInstance()?.getRequestMetadata().requestId;
+        record['request_id'] = RequestIdProvider.get();
       });
 
       return;

package/src/types/options.ts

@@ -84,4 +84,5 @@ export type PlatformAppOptions = RequiredFields<
   'transports' | 'modules'
 >;
 
-export type PlatformExtendedOptions = PlatformOptions & ManifestData;
+export type PlatformExtendedOptions = PlatformOptions &
+  ManifestData & { appScope: string };

package/dist/tracing/services/request-metadata.injector.d.ts

@@ -1,6 +0,0 @@
-export declare class RequestMetadataInjector {
-    static wrap(cls: any, original: Function): void;
-    private static createWrapper;
-    private static isWrapped;
-    private static setWrapped;
-}