@rsdk/core 4.0.0-next.9 → 4.0.0

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

@@ -1,145 +1,31 @@
 import { Injectable } from '@nestjs/common';
-import {
-  EXCEPTION_FILTERS_METADATA,
-  GUARDS_METADATA,
-  INTERCEPTORS_METADATA,
-  PIPES_METADATA,
-} from '@nestjs/common/constants';
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
-import { ILogger } from '@rsdk/logging';
 
-import { InjectLogger } from '../../logging';
+import { TracingInterceptor } from '../tracing.interceptor';
 
-import { ExtendedMetadataScanner } from './metadata.scanner';
+import { RequestMetadataInjector } from './request-metadata.injector';
 import { TraceInjector } from './trace.injector';
 
-const types = [
-  EXCEPTION_FILTERS_METADATA,
-  GUARDS_METADATA,
-  INTERCEPTORS_METADATA,
-  PIPES_METADATA,
-] as const;
-
 @Injectable()
 export class InstrumentationService {
-  constructor(
-    @InjectLogger(InstrumentationService) private readonly logger: ILogger,
-    protected readonly scanner: ExtendedMetadataScanner,
-  ) {}
-
-  public inject(): void {
-    /**
-     * Для каждого контроллера
-     */
-    for (const controller of this.scanner.getControllers()) {
-      /**
-       * Перебираем методы контроллера и оборачиваем их.
-       */
-      this.wrapMethods(controller.metatype.prototype);
-
-      this.wrapAugmentations(controller.metatype);
-
-      /**
-       * Для каждого метода контроллера
-       */
-      for (const name of this.scanner.getMethods(
-        controller.metatype.prototype,
-      )) {
-        /**
-         * Во вложенном цикле находим все гарды, интерцепторы, пайпы и фильтры,
-         * привязанные к методу.
-         * Уровни вложенности, как в цикле выше
-         */
-        const method = controller.metatype.prototype[name];
-
-        this.wrapAugmentations(method);
-      }
-    }
-
-    /**
-     * Глобальные гарды, интерцепторы, пайпы и фильтры находятся
-     * в общем списке провайдеров по injection-токенам.
-     */
-    for (const { metatype, token } of this.scanner.getProviders()) {
-      if (typeof token !== 'string') {
-        continue;
-      }
-
-      if (
-        token.includes(APP_GUARD) ||
-        token.includes(APP_PIPE) ||
-        token.includes(APP_INTERCEPTOR) ||
-        token.includes(APP_FILTER)
-      ) {
-        this.wrapMethods(metatype.prototype);
-      }
-    }
-
+  public injectWrapRequestMetadataInjector(): void {
     /**
-     * Глобальные гарды, интерцепторы, пайпы и фильтры находятся
-     * в общем списке провайдеров по injection-токенам.
+     * Оборачиваем интерцептор в логику которая несет с собою асинк локал сторадж с requestId
      */
-    for (const {
-      metatype: { name, prototype },
-    } of this.scanner.getProviders()) {
-      if (name.toLowerCase().endsWith('module')) {
-        continue;
-      }
-
-      if (
-        name === 'ModuleRef' ||
-        name === 'Reflector' ||
-        name === 'OrphanedReferenceRegistry' ||
-        name === 'TypeFieldsAccessor' ||
-        name === 'TypeMapperSevice' ||
-        name === 'TypeDefinitionsStorage' ||
-        name === 'FileSystemHelper' ||
-        name === 'TypeDefinitionsGenerator' ||
-        name === 'GraphQLSchemaFactory' ||
-        name === 'AstDefinitionNodeFactory' ||
-        name === 'UnionDefinitionFactory' ||
-        name === 'SubscriptionTypeFactory' ||
-        name === 'RootTypeFactory' ||
-        name === 'ResolveTypeFactory' ||
-        name === 'QueryTypeFactory' ||
-        name === 'OrphanedTypesFactory' ||
-        name === 'OutputTypeFactory' ||
-        name === 'ObjectTypeDefinitionFactory' ||
-        name === 'MutationTypeFactory' ||
-        name === 'InterfaceDefinitionFactory' ||
-        name === 'InputTypeFactory' ||
-        name === 'ArgsFactory' ||
-        name === 'InputTypeDefinitionFactory' ||
-        name === 'EnumDefinitionFactory'
-      ) {
-        continue;
-      }
-
-      this.wrapMethods(prototype);
-    }
+    RequestMetadataInjector.wrap(
+      TracingInterceptor.prototype,
+      TracingInterceptor.prototype['intercept'],
+    );
   }
 
-  private wrapAugmentations(metatype: object): void {
+  public injectWrapTraceInjector(): void {
     /**
-     * Перебираем во вложенных циклах все гарды, интерцепторы, пайпы и фильтры,
-     * повешенные на переданный прототип (metatype).
-     * 1-й уровень - типы сущностей: интерцепторы, гарды, пайпы, фильтры
-     * 2-й уровень - методы сущностей
+     * Оборачиваем интерцептор в логику которая несет с собою асинк локал сторадж с traceId, spanId
      */
-    for (const metakey of types) {
-      for (const instance of Reflect.getMetadata(metakey, metatype) || []) {
-        this.wrapMethods(instance);
-      }
-    }
-  }
-
-  private wrapMethods(obj: any): void {
-    const prototype = obj.prototype ?? obj;
-
-    this.logger.trace(`Wrapping methods of ${prototype.constructor.name}...`);
-
-    for (const name of this.scanner.getMethods(prototype)) {
-      TraceInjector.wrap(prototype, prototype[name]);
-    }
+    TraceInjector.wrap(
+      TracingInterceptor.prototype,
+      TracingInterceptor.prototype['intercept'],
+      undefined,
+      true,
+    );
   }
 }

package/src/tracing/services/request-metadata.injector.ts

@@ -0,0 +1,153 @@
+import type { ExecutionContext } from '@nestjs/common';
+import { redecorate } from '@rsdk/decorators';
+import { LoggerFactory } from '@rsdk/logging';
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+
+import { Constants, X_REQUEST_ID } from '../constants';
+
+import { RequestMetadataStorage } from './request-metadata.storage';
+
+const logger = LoggerFactory.create('RequestMetadataInjector');
+
+export class RequestMetadataInjector {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  static wrap(
+    cls: any,
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    original: Function,
+  ): void {
+    /**
+     * Означает, что данный метод уже обёрнут
+     */
+    if (RequestMetadataInjector.isWrapped(original)) {
+      return;
+    }
+
+    logger.trace(`Wrapping method: ${cls.constructor.name}.${original.name}()`);
+
+    const wrapped = RequestMetadataInjector.createWrapper(original);
+
+    redecorate(original, wrapped);
+
+    cls[original.name] = wrapped;
+
+    /**
+     * Отмечает метод, как обёрнутый (чтобы избежать повторного оборачивания)
+     */
+    RequestMetadataInjector.setWrapped(wrapped);
+  }
+
+  private static createWrapper(original: any): any {
+    return {
+      [original.name](...args: any[]): any {
+        const executionContext: ExecutionContext = args[0];
+
+        /**
+         * Переменный для хранения значений
+         */
+        let requestId: string | undefined;
+
+        /**
+         * Переменная для хранения Request/виртуального Request
+         */
+        let req: any;
+
+        /**
+         * В зависимости от типа контекста запускаем парсинг переданной Metadata
+         */
+        if (executionContext.getType() === 'rpc') {
+          const metadata = executionContext.switchToRpc().getContext();
+          /**
+           * Если мы пришли в GRPC и у нас есть методы для работы с Metadata
+           * то мы конвертируем Metadata в некий виртуальный request с заголовками (заголовки выбраны как общий стандарт проброса мета информации)
+           */
+          if (metadata?.get) {
+            req = {
+              headers: {
+                /**
+                 * Пробрасываем текущий ид запроса
+                 */
+                ...(metadata.get(X_REQUEST_ID).length > 0
+                  ? {
+                      [X_REQUEST_ID]: metadata.get(X_REQUEST_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;
+                },
+                {},
+              ),
+            };
+          }
+        }
+
+        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;
+            }, {}),
+          };
+
+          /**
+           * Идентификатор запроса, если не передали то генерируем рандомный
+           */
+          requestId = req.headers[X_REQUEST_ID] || randomUUID();
+        }
+
+        return (
+          RequestMetadataStorage.getInstance()?.run({ requestId }, async () => {
+            return original.apply(this, args);
+          }) ?? original.apply(this, args)
+        );
+      },
+    }[original.name];
+  }
+
+  private static isWrapped(prototype: object): boolean {
+    assert.ok(prototype);
+
+    return Reflect.hasMetadata(
+      Constants.REQUEST_METADATA_ASYNC_LOCAL_STORAGE_ACTIVE,
+      prototype,
+    );
+  }
+
+  private static setWrapped(prototype: object): void {
+    assert.ok(prototype);
+
+    // Value doesn't matter
+    const NOOP = 1;
+
+    Reflect.defineMetadata(
+      Constants.REQUEST_METADATA_ASYNC_LOCAL_STORAGE_ACTIVE,
+      NOOP,
+      prototype,
+    );
+  }
+}

package/src/tracing/services/request-metadata.storage.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export type RequestMetadata = {
+  requestId: string | undefined;
+};
+
+/**
+ * Обертка вокруг `AsyncLocalStorage`
+ * В теории можно запустить с пустым `payload`, для того чтобы добавлять
+ * значения в процессе
+ */
+@Injectable()
+export class RequestMetadataStorage {
+  /**
+   * Так как этот сервис используется в разных местах, чтобы не усложнять существующий код путем проксирования модулей и сервисов
+   * после создания ложим инстанс в эту статик переменную
+   */
+  private static instance: RequestMetadataStorage | undefined;
+
+  private asyncLocalStorage = new AsyncLocalStorage<{
+    requestMetadata: RequestMetadata;
+  }>();
+
+  constructor() {
+    if (!RequestMetadataStorage.instance) {
+      RequestMetadataStorage.instance = this;
+    }
+  }
+
+  static getInstance(): RequestMetadataStorage | undefined {
+    return RequestMetadataStorage.instance;
+  }
+
+  /**
+   * Получает новое значение из контекста
+   */
+  async getRequestMetadata(): Promise<RequestMetadata> {
+    return (
+      RequestMetadataStorage.instance?.asyncLocalStorage.getStore()
+        ?.requestMetadata ?? {
+        requestId: undefined,
+      }
+    );
+  }
+
+  /**
+   * Запускает переданную фунцию в контексте
+   * @template TResult
+   * @template TArgs
+   * @param context Контекст исполнения (данные)
+   * @param fn Функция для запуска
+   * @param args Аргументы функции
+   * @returns Результат выполнения функции
+   */
+  run<TResult, TArgs extends any[]>(
+    requestMetadata: RequestMetadata,
+    fn: (...args: TArgs) => TResult,
+    ...args: TArgs
+  ): TResult {
+    return (
+      RequestMetadataStorage?.instance?.asyncLocalStorage.run(
+        { requestMetadata },
+        fn,
+        ...args,
+      ) ?? fn(...args)
+    );
+  }
+}