@rsdk/core 4.2.4 → 4.3.0-next.0

package/src/platform.module.ts

@@ -8,23 +8,19 @@ import { PlatformPluginModule } from './plugin/plugin.module';
 import { PlatformTransportModule } from './transport/transport.module';
 import { AppMetadataModule } from './app-metadata';
 import { PlatformConfigModule } from './config';
-import { SequenceException } from './exceptions';
 import { LoggerInitializingModule } from './logging';
 import { TracingModule } from './tracing';
-import { PlatformExtendedOptions } from './types';
+import type { PlatformAppPlugin, PlatformExtendedOptions } from './types';
+import { APP_PLUGINS, APP_TRANSPORTS } from './types';
 
 export class PlatformModule implements NestModule {
-  constructor(
-    @Inject('PlatformExtendedOptions') private options: PlatformExtendedOptions,
-  ) {}
-
   static forRoot(options: PlatformExtendedOptions): DynamicModule {
     const imports: (DynamicModule | Constructor)[] = [
       /**
        * Последовательность принципиально важна так как в этом модуле происходит инициализация глобального асинхронного контекста (AsyncLocalStorage)
        */
       AsyncContextModule,
-      TracingModule.forRoot({ appName: options.name, processing: 'simple' }),
+      TracingModule.forRoot(),
 
       // Plugins
       PlatformPluginModule.forOptions(options),
@@ -36,32 +32,31 @@ export class PlatformModule implements NestModule {
       ...(options.modules ?? []),
     ];
 
-    // Adding transport module if needed
-    if (options.transports) {
-      imports.push(PlatformTransportModule.forOptions(options));
-    }
+    imports.push(PlatformTransportModule.forOptions(options));
+    const exportingProviders = [
+      {
+        provide: APP_PLUGINS,
+        useValue: new Set(options.plugins),
+      },
+      {
+        provide: APP_TRANSPORTS,
+        useValue: new Set(options.transports),
+      },
+    ];
 
     return {
       module: PlatformModule,
       imports,
-      providers: [
-        {
-          provide: 'PlatformExtendedOptions',
-          useValue: options,
-        },
-      ],
-      exports: ['PlatformExtendedOptions'],
+      global: true,
+      providers: exportingProviders,
+      exports: exportingProviders,
     };
   }
 
-  configure(consumer: MiddlewareConsumer): void {
-    if (!this.options) {
-      throw new SequenceException(
-        'Should call PlatformModule.setup() before configuring middleware!',
-      );
-    }
+  constructor(@Inject(APP_PLUGINS) private plugins: Set<PlatformAppPlugin>) {}
 
-    for (const plugin of this.options.plugins || []) {
+  configure(consumer: MiddlewareConsumer): void {
+    for (const plugin of this.plugins) {
       plugin?.configureMiddleware?.(consumer);
     }
   }

package/src/tracing/decorators/span.decorator.ts

@@ -22,13 +22,13 @@ export const Span = (): MethodDecorator & ClassDecorator =>
     }
     if (methodName && descriptor) {
       TraceInjector.wrap(target, descriptor.value, descriptor);
-    } else {
-      const prototype = (target as any).prototype ?? target;
+      return;
+    }
+    const prototype = (target as any).prototype ?? target;
 
-      for (const name of metadataScanner.getAllMethodNames(prototype)) {
-        if (name) {
-          TraceInjector.wrap(prototype, prototype[name]);
-        }
+    for (const name of metadataScanner.getAllMethodNames(prototype)) {
+      if (name) {
+        TraceInjector.wrap(prototype, prototype[name]);
       }
     }
   };

package/src/tracing/index.ts

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

package/src/tracing/services/index.ts

@@ -1,2 +1 @@
-export * from './instrumentation.service';
 export * from './trace.injector';

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

@@ -1,6 +1,5 @@
 import type { AttributeValue, Span } from '@opentelemetry/api';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
-import { api } from '@opentelemetry/sdk-node';
 import type { ErrorLike } from '@rsdk/common';
 import { isPrimitive, isRecord, normalizer } from '@rsdk/common';
 import { redecorate } from '@rsdk/decorators';
@@ -19,7 +18,6 @@ export class TraceInjector {
     // eslint-disable-next-line @typescript-eslint/ban-types
     original: Function,
     descriptor?: TypedPropertyDescriptor<any>,
-    isTracingInterceptor?: boolean,
   ): void {
     /**
      * Означает, что данный метод уже обёрнут
@@ -34,11 +32,7 @@ export class TraceInjector {
       cls.constructor.name,
       original.name,
     );
-    const wrapped = TraceInjector.createWrapper(
-      original,
-      spanName,
-      isTracingInterceptor,
-    );
+    const wrapped = TraceInjector.createWrapper(original, spanName);
 
     redecorate(original, wrapped);
 
@@ -72,50 +66,57 @@ export class TraceInjector {
     return 'data is undefined';
   }
 
-  private static createWrapper(
-    original: any,
-    spanName: string,
-    _isTracingInterceptor?: boolean,
-  ): any {
+  static enrich(span: Span, data: unknown): unknown {
+    span.setAttribute('result', TraceInjector.toAttribute(data));
+    span.setStatus({ code: SpanStatusCode.OK });
+
+    return data;
+  }
+
+  static createSpanName(className: string, methodName: string): string {
+    /**
+     * Всего лишь правила формирования имени спана (не более того), для новой логики нужен был именно такой код
+     */
+    return `${className} -> ${methodName}`;
+  }
+
+  static recordAndRethrow(error: unknown, span: Span): void {
+    span.recordException(error as ErrorLike);
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: (error as ErrorLike).message,
+    });
+
+    throw error;
+  }
+
+  private static isWrapped(prototype: object): boolean {
+    assert.ok(prototype);
+
+    return Reflect.hasMetadata(Constants.TRACE_METADATA_ACTIVE, prototype);
+  }
+
+  private static nowSpan(prototype: object): boolean {
+    assert.ok(prototype);
+
+    return Reflect.hasMetadata(Constants.NO_SPAN_METADATA, prototype);
+  }
+
+  private static setWrapped(prototype: object): void {
+    assert.ok(prototype);
+
+    // Value doesn't matter
+    const NOOP = 1;
+
+    Reflect.defineMetadata(Constants.TRACE_METADATA_ACTIVE, NOOP, prototype);
+  }
+
+  private static createWrapper(original: any, spanName: string): any {
     return {
       [original.name](...args: any[]): any {
         const tracer = trace.getTracer('@rsdk/open-telemetry', '1.0.0');
 
-        /**
-         * Переменный для хранения значений которые получаем для опен телеметрии
-         */
-        let traceId: string | undefined;
-        let spanId: string | undefined;
-
-        /**
-         * Создаем новый спан
-         */
-        const span = tracer.startSpan(spanName, {});
-
-        /**
-         * После создания контекста ранее при входе в приложение, у нас новый спан ид
-         * мы перетираем значением которе получили через заголовок
-         * в рамках приложения он корректный, но при переходе из одного приложения в другой - слетает
-         * и чтобы 100% все было норм, мы всегда патчим его
-         */
-        if (spanId) {
-          span.spanContext().spanId = spanId;
-        }
-
-        /**
-         * Патчим трайс ид, причина выше
-         */
-        if (traceId) {
-          span.spanContext().traceId = traceId;
-        }
-        /**
-         * Чтобы пробросить пропатченный спан нужно запустить две строчки ниже:
-         * 1) создаем контекст в котором активный спан перебиваем новым
-         * 2) созданный контекст ставим основным и в нем запускаем под процесс
-         */
-        const spanContext = api.trace.setSpan(api.context.active(), span);
-
-        return api.context.with(spanContext, async () => {
+        return tracer.startActiveSpan(spanName, (span) => {
           try {
             /**
              * При запуске функции обернутой в опентелеметрию мы выводим и трейсИд и спанИд
@@ -127,6 +128,7 @@ export class TraceInjector {
               }, spanId: ${span.spanContext().spanId}`,
             );
 
+            span.setAttribute('args', TraceInjector.toAttribute(args));
             const result = original.apply(this, args);
 
             /**
@@ -185,49 +187,4 @@ export class TraceInjector {
       },
     }[original.name];
   }
-
-  static createSpanName(className: string, methodName: string): string {
-    /**
-     * Всего лишь правила формирования имени спана (не более того), для новой логики нужен был именно такой код
-     */
-    return `${className} -> ${methodName}`;
-  }
-
-  private static isWrapped(prototype: object): boolean {
-    assert.ok(prototype);
-
-    return Reflect.hasMetadata(Constants.TRACE_METADATA_ACTIVE, prototype);
-  }
-
-  private static nowSpan(prototype: object): boolean {
-    assert.ok(prototype);
-
-    return Reflect.hasMetadata(Constants.NO_SPAN_METADATA, prototype);
-  }
-
-  private static setWrapped(prototype: object): void {
-    assert.ok(prototype);
-
-    // Value doesn't matter
-    const NOOP = 1;
-
-    Reflect.defineMetadata(Constants.TRACE_METADATA_ACTIVE, NOOP, prototype);
-  }
-
-  static recordAndRethrow(error: unknown, span: Span): void {
-    span.recordException(error as ErrorLike);
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: (error as ErrorLike).message,
-    });
-
-    throw error;
-  }
-
-  static enrich(span: Span, data: unknown): unknown {
-    span.setAttribute('response', TraceInjector.toAttribute(data));
-    span.setStatus({ code: SpanStatusCode.OK });
-
-    return data;
-  }
 }

package/src/tracing/tracing.interceptor.ts

@@ -4,141 +4,21 @@ 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 { RequestIdProvider } from '@rsdk/tracing';
 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';
+import { TracingHeadersExtractor } from '../types/tracing.headers-extractor';
 
-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;
+import { X_REQUEST_ID } from './constants';
 
 @Injectable()
 export class TracingInterceptor implements NestInterceptor {
+  constructor(private headersExtractor: TracingHeadersExtractor) {}
+
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    const requestId = TracingInterceptor.extractTracingHeaders(context);
+    const h = this.headersExtractor.extract(context).getHeaders();
 
-    RequestIdProvider.set(requestId[X_REQUEST_ID]);
-    OpenTelemetryProvider.set(omitUndefined(requestId));
+    RequestIdProvider.set(h[X_REQUEST_ID]);
     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,141 +1,56 @@
-import type {
-  BeforeApplicationShutdown,
-  DynamicModule,
-  OnModuleInit,
-  Provider,
-} from '@nestjs/common';
+import type { DynamicModule, OnModuleInit } from '@nestjs/common';
 import { Module } from '@nestjs/common';
 import { APP_INTERCEPTOR } from '@nestjs/core';
+import type { SpanContext } from '@opentelemetry/api';
 import { context, trace } from '@opentelemetry/api';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { CompositePropagator } from '@opentelemetry/core';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { B3InjectEncoding, B3Propagator } from '@opentelemetry/propagator-b3';
-import { Resource } from '@opentelemetry/resources';
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import type { SpanExporter } from '@opentelemetry/sdk-trace-base';
-import {
-  BatchSpanProcessor,
-  SimpleSpanProcessor,
-} from '@opentelemetry/sdk-trace-base';
-import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { ILogger, LoggerFactory } from '@rsdk/logging';
+import { RequestIdProvider } from '@rsdk/tracing';
 
 import { InjectLogger } from '../logging';
+import { TracingHeadersExtractor } from '../types/tracing.headers-extractor';
 
-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';
 import { TracingInterceptor } from './tracing.interceptor';
 
-export interface TracingModuleOptions {
-  appName: string;
-  processing: 'simple' | 'batch';
-  exporter?: SpanExporter;
-}
-
 @Module({})
-export class TracingModule implements OnModuleInit, BeforeApplicationShutdown {
+export class TracingModule implements OnModuleInit {
   constructor(
     @InjectLogger(TracingModule) private readonly logger: ILogger,
-    private readonly instrumentations: InstrumentationService,
-    private readonly sdk: NodeSDK,
     private readonly config: TracingModuleConfig,
   ) {}
 
-  static forRoot(options: TracingModuleOptions): DynamicModule {
+  static forRoot(): DynamicModule {
     return {
       module: TracingModule,
-      imports: [RequestMetadataModule, ActiveSpanModule],
+      imports: [RequestMetadataModule],
       providers: [
-        { provide: APP_INTERCEPTOR, useValue: new TracingInterceptor() },
-        {
-          provide: APP_INTERCEPTOR,
-          useValue: new OpenTelemetryInterceptor(),
-        },
-        InstrumentationService,
-        this.createSDKProvider(options),
+        { provide: APP_INTERCEPTOR, useClass: TracingInterceptor },
+        TracingHeadersExtractor,
       ],
     };
   }
 
   // Можно добавить включение и выключение при изменении конфига.
   async onModuleInit(): Promise<void> {
-    if (!this.config.enabled) {
-      this.logger.info('Tracing is disabled');
-
-      LoggerFactory.applyInstrumentations((record) => {
-        record['request_id'] = RequestIdProvider.get();
-      });
-
-      return;
-    }
+    LoggerFactory.applyInstrumentations((record) => {
+      record['request_id'] = RequestIdProvider.get();
+      const span = trace.getSpan(context.active());
+      if (!span) {
+        return;
+      }
+      const spanContext: SpanContext = span.spanContext();
 
+      record['trace_id'] = spanContext.traceId;
+      record['span_id'] = spanContext.spanId;
+    });
     this.logger.info('Tracing is enabled');
 
-    this.logger.debug('Starting Open Telemetry SDK...');
-    this.sdk.start();
-
-    this.logger.debug('Instrumenting nest.js entities...');
-    this.instrumentations.injectWrapTraceInjector();
-
     this.logger.debug('Attaching log messages to spans...');
-    LoggerFactory.applyInstrumentations();
     LoggerFactory.onMessage((level, msg) => {
       const span = trace.getSpan(context.active());
 
       span?.addEvent('log', { ...msg, level });
     });
   }
-
-  private static createSDKProvider(options: TracingModuleOptions): Provider {
-    return {
-      provide: NodeSDK,
-
-      inject: [TracingModuleConfig],
-      useFactory: (config: TracingModuleConfig): NodeSDK => {
-        const exporter =
-          options.exporter ||
-          new OTLPTraceExporter({
-            url: config.collectorUrl?.toString(),
-          });
-
-        const processor =
-          options.processing === 'simple'
-            ? new SimpleSpanProcessor(exporter)
-            : new BatchSpanProcessor(exporter);
-
-        return new NodeSDK({
-          autoDetectResources: true,
-          contextManager: new AsyncLocalStorageContextManager(),
-          instrumentations: config.enabled ? [autoInstumentationOptions] : [],
-          resource: new Resource({
-            [SemanticResourceAttributes.SERVICE_NAME]: options.appName,
-          }),
-          spanProcessor: processor,
-          textMapPropagator: new CompositePropagator({
-            propagators: [
-              new B3Propagator(),
-              new B3Propagator({
-                injectEncoding: B3InjectEncoding.MULTI_HEADER,
-              }),
-            ],
-          }),
-        });
-      },
-    };
-  }
-
-  async beforeApplicationShutdown(): Promise<void> {
-    if (!this.config.enabled) {
-      return;
-    }
-    this.logger.info('Shutting down Open Telemetry SDK...');
-    await this.sdk.shutdown();
-    this.logger.info('Shutting down Open Telemetry SDK has been done!');
-  }
 }

package/src/tracing/types.ts

@@ -0,0 +1,28 @@
+import { randomUUID } from 'node:crypto';
+
+import { X_REQUEST_ID } from './constants';
+
+export type Headers = {
+  [X_REQUEST_ID]: string;
+};
+
+export const tracingHeaders = [X_REQUEST_ID] as const;
+
+export class TracingHeaders {
+  constructor(headers: Partial<Headers>) {
+    this.headers = {
+      ...headers,
+      [X_REQUEST_ID]: headers[X_REQUEST_ID] ?? this.createRequestId(),
+    } as Headers;
+  }
+
+  getHeaders(): Headers {
+    return this.headers;
+  }
+
+  private createRequestId(): string {
+    return randomUUID();
+  }
+
+  private headers: Headers;
+}

package/src/tracing/utils/save-async-hooks-context.ts

@@ -3,7 +3,6 @@ import { api } from '@opentelemetry/sdk-node';
 import type { ErrorLike } from '@rsdk/common';
 
 import { TraceInjector } from '../services';
-import { ActiveSpanStorage } from '../services/active-span.storage';
 
 /**
  * Проблема: при передаче управления в rxjs теряется контекст асинк локал стораджа
@@ -26,10 +25,10 @@ import { ActiveSpanStorage } from '../services/active-span.storage';
 export function saveAsyncHooksContext<T>(
   fn: (...args: any[]) => Promise<T>,
 ): (...args: any[]) => Promise<T> {
-  const span = ActiveSpanStorage.getInstance()?.getActiveSpan();
+  const span = api.trace.getActiveSpan();
 
   return async function (...args): Promise<T> {
-    const activeSpan = ActiveSpanStorage.getInstance()?.getActiveSpan();
+    const activeSpan = api.trace.getActiveSpan();
     if (activeSpan) {
       Object.assign(activeSpan.spanContext(), span?.spanContext());
       return fn(...args);

package/src/transport/protocol.detector.ts

@@ -6,7 +6,7 @@ import type { ITransport } from '../types';
 export class ProtocolDetector {
   constructor(private transports: ITransport[]) {}
 
-  getProtocol(context: ArgumentsHost): string | undefined {
+  getTransport(context: ArgumentsHost): ITransport | undefined {
     if (this.transports.length === 0) {
       return;
     }
@@ -27,6 +27,10 @@ export class ProtocolDetector {
     if (matched.length === 0) {
       return;
     }
-    return matched[0].tr.getProtocol();
+    return matched[0].tr;
+  }
+
+  getProtocol(context: ArgumentsHost): string | undefined {
+    return this.getTransport(context)?.getProtocol();
   }
 }

package/src/transport/transport.module.ts

@@ -43,7 +43,7 @@ export class PlatformTransportModule {
       providers: [
         {
           provide: ProtocolDetector,
-          useFactory: () => new ProtocolDetector(options.transports ?? []),
+          useValue: new ProtocolDetector(options.transports ?? []),
         },
       ],
       global: true,

package/src/types/constants.ts

@@ -0,0 +1,2 @@
+export const APP_PLUGINS = Symbol('PLUGINS');
+export const APP_TRANSPORTS = Symbol('TRANSPORTS');