@biorate/nestjs-tools 2.4.0 → 2.5.2

package/README.md

@@ -8,7 +8,7 @@ Production‑grade middleware, guards, interceptors, filters, decorators, and HT
 - **Response time** — Prometheus histogram + `x-response-time` header.
 - **HTTP proxy** — Prometheus‑instrumented `http-proxy-middleware` wrapper.
 - **Tracing** — OpenTelemetry span attributes for incoming requests.
-- **Exception filter** — structured JSON error responses for HTTP, WS, and RPC.
+- **Exception filter** — structured JSON error responses for HTTP and WebSocket transports (RPC is unsupported).
 - **Auth** — `@AuthBasic()` decorator + `AuthGuardProvider`.
 - **Roles** — `@Roles()` decorator + `RolesGuardProvider`.
 - **CORS** — config‑driven origin validation.
@@ -25,14 +25,14 @@ Peer dependencies: `@nestjs/common`, `@nestjs/core`, `@nestjs/swagger`, `class-v
 
 ## Quick start
 
+`main.ts`:
+
 ```ts
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import {
   AllExceptionsFilter,
-  BootstrapProvider,
-  RequestCountMiddleware,
-  ResponseTimeMiddleware,
+  RoutesInterceptor,
   TracingInterceptor,
 } from '@biorate/nestjs-tools';
 
@@ -40,17 +40,38 @@ async function bootstrap() {
   const app = await NestFactory.create(AppModule, { bufferLogs: true });
 
   app.useGlobalFilters(new AllExceptionsFilter());
-  app.useGlobalInterceptors(new TracingInterceptor());
-
-  // Middleware
-  app.use(BootstrapProvider.create());
-  app.use(RequestCountMiddleware.create());
-  app.use(ResponseTimeMiddleware.create());
+  app.useGlobalInterceptors(new RoutesInterceptor(), new TracingInterceptor());
 
   await app.listen(3000);
 }
+
+bootstrap();
 ```
 
+`app.module.ts`:
+
+```ts
+import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
+import {
+  RequestCountMiddleware,
+  ResponseTimeMiddleware,
+} from '@biorate/nestjs-tools';
+
+@Module({ imports: [...] })
+export class AppModule implements NestModule {
+  public configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(RequestCountMiddleware, ResponseTimeMiddleware)
+      .forRoutes('*');
+  }
+}
+```
+
+> Middleware and interceptor classes use `@inject(Types.Config)` from the global
+> `@biorate/inversion` container — bootstrap the app via the `@biorate/launcher`
+> lifecycle with `Types.Config` bound, otherwise requests will fail with
+> `InversionInjectionIsUndefinedError`.
+
 ## Middlewares
 
 ### `RequestCountMiddleware`
@@ -59,8 +80,6 @@ Prometheus counter `http_server_requests_seconds_count` with labels `method`, `u
 
 ```ts
 consumer.apply(RequestCountMiddleware).forRoutes('*');
-// or via BootstrapProvider
-app.use(RequestCountMiddleware.create());
 ```
 
 Uses `RoutesInterceptor` to resolve the actual route path (e.g. `/api/users/:id` instead of `/api/users/123`).
@@ -72,17 +91,17 @@ Config option: `app.middleware.RequestCountMiddleware.log-base-url` (boolean, de
 Prometheus histogram `http_server_requests_seconds` + `x-response-time` header.
 
 ```ts
-app.use(ResponseTimeMiddleware.create());
+consumer.apply(ResponseTimeMiddleware).forRoutes('*');
 ```
 
 Config options:
 
-| Path                                                | Default     |
-|-----------------------------------------------------|-------------|
-| `app.middleware.ResponseTimeMiddleware.suffix`       | `true`      |
-| `app.middleware.ResponseTimeMiddleware.header`       | `x-response-time` |
-| `app.middleware.ResponseTimeMiddleware.digits`       | `3`         |
-| `app.middleware.ResponseTimeMiddleware.log-base-url` | `false`     |
+| Path                                                 | Default                 |
+| ---------------------------------------------------- | ----------------------- |
+| `app.middleware.ResponseTimeMiddleware.suffix`       | `true`                  |
+| `app.middleware.ResponseTimeMiddleware.header`       | `x-response-time`       |
+| `app.middleware.ResponseTimeMiddleware.digits`       | `3`                     |
+| `app.middleware.ResponseTimeMiddleware.log-base-url` | `false`                 |
 | `ResponseTimeMiddleware.histogram.buckets`           | `[0.005, 0.01, … , 10]` |
 
 ### `ProxyPrometheusMiddleware`
@@ -92,13 +111,18 @@ Prometheus‑instrumented HTTP proxy via `http-proxy-middleware`.
 ```ts
 import { ProxyPrometheusMiddleware } from '@biorate/nestjs-tools';
 
-consumer.apply(ProxyPrometheusMiddleware.create({
-  target: 'http://upstream.service:8080',
-  changeOrigin: true,
-})).forRoutes('/api/v2/legacy');
+consumer
+  .apply(
+    ProxyPrometheusMiddleware.create({
+      target: 'http://upstream.service:8080',
+      changeOrigin: true,
+    }),
+  )
+  .forRoutes('/api/v2/legacy');
 ```
 
 Creates two metrics:
+
 - `http_proxy_server_requests_seconds_count` (counter)
 - `http_proxy_server_requests_seconds` (histogram)
 
@@ -120,7 +144,7 @@ Catches all exceptions and returns a structured JSON response:
 }
 ```
 
-Supports HTTP, WebSocket, and RPC transport types. Maps `meta.status` from `@biorate/errors` to HTTP status codes.
+Supports HTTP and WebSocket transports; RPC is unsupported and throws `UnsupportedProtocolError`. Maps `meta.status` from `@biorate/errors` to HTTP status codes.
 
 ```ts
 app.useGlobalFilters(new AllExceptionsFilter());
@@ -145,13 +169,38 @@ incoming.response.data
 incoming.response.errorCode
 ```
 
-Config: `TracingInterceptor.excluded` — array of strings or RegExp to skip URLs.
+Config: `TracingInterceptor.excluded` — array of strings or RegExp to skip URLs
+(string entries match by substring inclusion, RegExp entries by test).
+
+#### Aspect exclusion
+
+Granular control over which span attributes are written:
+
+```json
+{
+  "TracingInterceptor": {
+    "excluded": ["/health"],
+    "excludedAttributes": ["response.data"],
+    "excludedByURL": [{ "url": "/files", "attributes": ["body", "response"] }]
+  }
+}
+```
+
+- `TracingInterceptor.excludedAttributes` — string[] of aspects to skip globally.
+- `TracingInterceptor.excludedByURL` — array of `{ url: string | RegExp, attributes: string[] }`
+  entries; aspects are skipped only for matching URLs (string entries match by
+  substring inclusion, RegExp entries by test).
+- An excluded item also matches aspect groups by prefix: `response` excludes
+  `response.headers`, `response.statusCode`, `response.data` and `response.errorCode`.
+- Accepted aliases: `url`, `method`, `headers`, `body`, `params`, `query`
+  (→ `incoming.request.*`), `statusCode`, `data`, `errorCode` (→ `incoming.response.*`);
+  full names (`request.body`, `response.data`, …) work as-is.
 
 ### `RoutesInterceptor`
 
 Resolves the full route path (controller + handler) and stores it in a `WeakMap<Request, { path }>` for use by `RequestCountMiddleware` and `ResponseTimeMiddleware`.
 
-Applied automatically when using the count/time middlewares.
+Not applied automatically: when using the count/time middlewares, register it globally via `app.useGlobalInterceptors(new RoutesInterceptor())` — otherwise they won't see the resolved route path and metrics fall back to `/`.
 
 ## Providers (Guards)
 
@@ -164,7 +213,9 @@ HTTP Basic Authentication guard. Validates `Authorization: Basic …` against co
 export class MyController {
   @Get('/admin')
   @AuthBasic()
-  public admin() { return 'secret data'; }
+  public admin() {
+    return 'secret data';
+  }
 }
 ```
 
@@ -173,13 +224,22 @@ export class MyController {
 Bitmask‑based role guard. Use with `@Roles()` decorator:
 
 ```ts
+import { Controller, Get } from '@nestjs/common';
 import { Roles, UserRoles } from '@biorate/nestjs-tools';
 
-@Roles(UserRoles.Admin | UserRoles.Manager)
-@Get('/admin')
-public admin() { return 'ok'; }
+@Controller()
+export class AdminController {
+  @Roles(UserRoles.Admin, UserRoles.Basic)
+  @Get('/admin')
+  public admin() {
+    return 'ok';
+  }
+}
 ```
 
+`Roles(...)` accepts a variadic list of roles (combined into a bitmask via
+bitwise OR internally). Built-in `UserRoles`: `Basic` (`1 << 0`), `Admin` (`1 << 1`).
+
 Override `getUser()` to load the user from your database:
 
 ```ts
@@ -192,20 +252,12 @@ export class CustomRolesGuard extends RolesGuardProvider {
 }
 ```
 
-### `BootstrapProvider`
-
-Convenience middleware that initializes the `@biorate/inversion` container lifecycle:
-
-```ts
-app.use(BootstrapProvider.create());
-```
-
 ## Decorators
 
-| Decorator     | Composition                                      |
-|---------------|--------------------------------------------------|
-| `@Roles(...)` | `SetMetadata(ROLES_KEY, bitmask)`                |
-| `@AuthBasic()`| `ApiBasicAuth()` + `UseGuards(AuthGuardProvider)` |
+| Decorator      | Composition                                       |
+| -------------- | ------------------------------------------------- |
+| `@Roles(...)`  | `SetMetadata(ROLES_KEY, bitmask)`                 |
+| `@AuthBasic()` | `ApiBasicAuth()` + `UseGuards(AuthGuardProvider)` |
 
 ## CORS
 
@@ -219,15 +271,18 @@ In non‑debug environments, validates the origin against `ALLOWED_ORIGIN` confi
 
 ## HTTP controllers
 
+> The `MetricsController`, `ProbeController`, and `LocalesController` in `src/http/controllers` are marked `@deprecated`. Their hexagonal replacements live in `src/app/infrastructure/controllers/` and are **not** exported individually at the package top level — `src/app/infrastructure/index.ts` re-exports them only as the `controllers` namespace (`export * as controllers from './controllers'`), so reach them as `import { controllers } from '@biorate/nestjs-tools'` (e.g. `controllers.MetricsController`).
+
 ### `MetricsController`
 
 Exposes `GET /metrics` with Prometheus metrics from the shared registry.
 
 ### `ProbeController`
 
-| Route           | Purpose             |
-|-----------------|---------------------|
-| `GET /probe`    | Liveness/readiness  |
+| Route                  | Purpose         |
+| ---------------------- | --------------- |
+| `GET /probe/readiness` | Readiness probe |
+| `GET /probe/healthz`   | Healthz probe   |
 
 ### `LocalesController`
 
@@ -255,14 +310,12 @@ src/app/
 └──────────┬───────────────────────────────────────────┘
            │
 ┌──────────▼───────────────────────────────────────────┐
-│ BootstrapProvider (DI lifecycle init)                 │
+│ RoutesInterceptor (path resolution)                   │
 ├──────────────────────────────────────────────────────┤
 │ RequestCountMiddleware (counter)                      │
 ├──────────────────────────────────────────────────────┤
 │ ResponseTimeMiddleware (histogram + header)           │
 ├──────────────────────────────────────────────────────┤
-│ RoutesInterceptor (path resolution)                   │
-├──────────────────────────────────────────────────────┤
 │ TracingInterceptor (OpenTelemetry span attrs)         │
 ├──────────────────────────────────────────────────────┤
 │ AllExceptionsFilter (structured error JSON)           │

package/dist/cjs/src/interceptors/tracing-interceptor.js

@@ -11,6 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var TracingInterceptor_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TracingInterceptor = void 0;
 const json_stringify_safe_1 = __importDefault(require("json-stringify-safe"));
@@ -18,44 +19,78 @@ const rxjs_1 = require("rxjs");
 const opentelemetry_1 = require("@biorate/opentelemetry");
 const common_1 = require("@nestjs/common");
 const inversion_1 = require("@biorate/inversion");
-let TracingInterceptor = class TracingInterceptor {
+const lodash_es_1 = require("lodash-es");
+let TracingInterceptor = TracingInterceptor_1 = class TracingInterceptor {
+    static normalizeAspect(name) {
+        const aliased = (0, lodash_es_1.get)(TracingInterceptor_1.aspectAliases, name);
+        if (aliased)
+            return aliased;
+        if (name.startsWith('request.'))
+            return name.slice('request.'.length);
+        return name;
+    }
     stringify(data) {
         return typeof data === 'object' ? (0, json_stringify_safe_1.default)(data) : String(data);
     }
     excluded(url) {
         const excluded = this.config.get('TracingInterceptor.excluded', []);
         for (const item of excluded) {
-            if (typeof item === 'string' && url.startsWith(item))
+            if (typeof item === 'string' && url.includes(item))
                 return true;
             if (item instanceof RegExp && item.test(url))
                 return true;
         }
         return false;
     }
+    excludedAttribute(url, aspect) {
+        const canonical = TracingInterceptor_1.normalizeAspect(aspect);
+        const match = (list) => list.some((item) => {
+            const target = TracingInterceptor_1.normalizeAspect(item);
+            return canonical === target || canonical.startsWith(`${target}.`);
+        });
+        if (match(this.config.get('TracingInterceptor.excludedAttributes', [])))
+            return true;
+        const byUrl = this.config.get('TracingInterceptor.excludedByURL', []);
+        for (const entry of byUrl) {
+            const hit = typeof entry?.url === 'string'
+                ? url.includes(entry.url)
+                : entry?.url instanceof RegExp && entry.url.test(url);
+            if (!hit)
+                continue;
+            if (match(entry?.attributes ?? []))
+                return true;
+        }
+        return false;
+    }
+    attr(span, url, aspect, value) {
+        if (this.excludedAttribute(url, aspect))
+            return;
+        span.setAttribute(TracingInterceptor_1.aspectKeys[aspect], this.stringify(value));
+    }
     http(span, context, next) {
         const host = context.switchToHttp();
         const req = host.getRequest();
         const res = host.getResponse();
         if (this.excluded(req.url))
             return next.handle();
-        span.setAttribute('incoming.request.url', this.stringify(req.url));
-        span.setAttribute('incoming.request.body', this.stringify(req.body));
-        span.setAttribute('incoming.request.headers', this.stringify(req.headers));
-        span.setAttribute('incoming.request.method', this.stringify(req.method));
-        span.setAttribute('incoming.request.params', this.stringify(req.params));
-        span.setAttribute('incoming.request.query', this.stringify(req.query));
+        this.attr(span, req.url, 'url', req.url);
+        this.attr(span, req.url, 'body', req.body);
+        this.attr(span, req.url, 'headers', req.headers);
+        this.attr(span, req.url, 'method', req.method);
+        this.attr(span, req.url, 'params', req.params);
+        this.attr(span, req.url, 'query', req.query);
         return next.handle().pipe((0, rxjs_1.catchError)((e) => {
-            span.setAttribute('incoming.response.headers', this.stringify(res.headers));
-            span.setAttribute('incoming.response.statusCode', this.stringify(res.statusCode));
-            span.setAttribute('incoming.response.errorCode', this.stringify(e.code));
-            span.setAttribute('incoming.response.data', this.stringify(e?.response?.data));
+            this.attr(span, req.url, 'response.headers', res.headers);
+            this.attr(span, req.url, 'response.statusCode', res.statusCode);
+            this.attr(span, req.url, 'response.errorCode', e.code);
+            this.attr(span, req.url, 'response.data', e?.response?.data);
             span.recordException(e);
             span.setStatus({ code: opentelemetry_1.SpanStatusCode.ERROR });
             throw e;
         }), (0, rxjs_1.tap)((data) => {
-            span.setAttribute('incoming.response.headers', this.stringify(res.headers));
-            span.setAttribute('incoming.response.statusCode', this.stringify(res.statusCode));
-            span.setAttribute('incoming.response.data', this.stringify(data));
+            this.attr(span, req.url, 'response.headers', res.headers);
+            this.attr(span, req.url, 'response.statusCode', res.statusCode);
+            this.attr(span, req.url, 'response.data', data);
         }));
     }
     ws(span, context, next) {
@@ -73,10 +108,33 @@ let TracingInterceptor = class TracingInterceptor {
     }
 };
 exports.TracingInterceptor = TracingInterceptor;
+TracingInterceptor.aspectAliases = {
+    'request.url': 'url',
+    'request.method': 'method',
+    'request.headers': 'headers',
+    'request.body': 'body',
+    'request.params': 'params',
+    'request.query': 'query',
+    statusCode: 'response.statusCode',
+    data: 'response.data',
+    errorCode: 'response.errorCode',
+};
+TracingInterceptor.aspectKeys = {
+    url: 'incoming.request.url',
+    method: 'incoming.request.method',
+    headers: 'incoming.request.headers',
+    body: 'incoming.request.body',
+    params: 'incoming.request.params',
+    query: 'incoming.request.query',
+    'response.headers': 'incoming.response.headers',
+    'response.statusCode': 'incoming.response.statusCode',
+    'response.data': 'incoming.response.data',
+    'response.errorCode': 'incoming.response.errorCode',
+};
 __decorate([
     (0, inversion_1.inject)(inversion_1.Types.Config),
     __metadata("design:type", Object)
 ], TracingInterceptor.prototype, "config", void 0);
-exports.TracingInterceptor = TracingInterceptor = __decorate([
+exports.TracingInterceptor = TracingInterceptor = TracingInterceptor_1 = __decorate([
     (0, common_1.Injectable)()
 ], TracingInterceptor);

package/dist/esm/src/interceptors/tracing-interceptor.js

@@ -7,49 +7,84 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var TracingInterceptor_1;
 import stringify from 'json-stringify-safe';
 import { tap, catchError } from 'rxjs';
 import { trace, SpanStatusCode } from '@biorate/opentelemetry';
 import { Injectable, } from '@nestjs/common';
 import { inject, Types } from '@biorate/inversion';
-let TracingInterceptor = class TracingInterceptor {
+import { get } from 'lodash-es';
+let TracingInterceptor = TracingInterceptor_1 = class TracingInterceptor {
+    static normalizeAspect(name) {
+        const aliased = get(TracingInterceptor_1.aspectAliases, name);
+        if (aliased)
+            return aliased;
+        if (name.startsWith('request.'))
+            return name.slice('request.'.length);
+        return name;
+    }
     stringify(data) {
         return typeof data === 'object' ? stringify(data) : String(data);
     }
     excluded(url) {
         const excluded = this.config.get('TracingInterceptor.excluded', []);
         for (const item of excluded) {
-            if (typeof item === 'string' && url.startsWith(item))
+            if (typeof item === 'string' && url.includes(item))
                 return true;
             if (item instanceof RegExp && item.test(url))
                 return true;
         }
         return false;
     }
+    excludedAttribute(url, aspect) {
+        const canonical = TracingInterceptor_1.normalizeAspect(aspect);
+        const match = (list) => list.some((item) => {
+            const target = TracingInterceptor_1.normalizeAspect(item);
+            return canonical === target || canonical.startsWith(`${target}.`);
+        });
+        if (match(this.config.get('TracingInterceptor.excludedAttributes', [])))
+            return true;
+        const byUrl = this.config.get('TracingInterceptor.excludedByURL', []);
+        for (const entry of byUrl) {
+            const hit = typeof entry?.url === 'string'
+                ? url.includes(entry.url)
+                : entry?.url instanceof RegExp && entry.url.test(url);
+            if (!hit)
+                continue;
+            if (match(entry?.attributes ?? []))
+                return true;
+        }
+        return false;
+    }
+    attr(span, url, aspect, value) {
+        if (this.excludedAttribute(url, aspect))
+            return;
+        span.setAttribute(TracingInterceptor_1.aspectKeys[aspect], this.stringify(value));
+    }
     http(span, context, next) {
         const host = context.switchToHttp();
         const req = host.getRequest();
         const res = host.getResponse();
         if (this.excluded(req.url))
             return next.handle();
-        span.setAttribute('incoming.request.url', this.stringify(req.url));
-        span.setAttribute('incoming.request.body', this.stringify(req.body));
-        span.setAttribute('incoming.request.headers', this.stringify(req.headers));
-        span.setAttribute('incoming.request.method', this.stringify(req.method));
-        span.setAttribute('incoming.request.params', this.stringify(req.params));
-        span.setAttribute('incoming.request.query', this.stringify(req.query));
+        this.attr(span, req.url, 'url', req.url);
+        this.attr(span, req.url, 'body', req.body);
+        this.attr(span, req.url, 'headers', req.headers);
+        this.attr(span, req.url, 'method', req.method);
+        this.attr(span, req.url, 'params', req.params);
+        this.attr(span, req.url, 'query', req.query);
         return next.handle().pipe(catchError((e) => {
-            span.setAttribute('incoming.response.headers', this.stringify(res.headers));
-            span.setAttribute('incoming.response.statusCode', this.stringify(res.statusCode));
-            span.setAttribute('incoming.response.errorCode', this.stringify(e.code));
-            span.setAttribute('incoming.response.data', this.stringify(e?.response?.data));
+            this.attr(span, req.url, 'response.headers', res.headers);
+            this.attr(span, req.url, 'response.statusCode', res.statusCode);
+            this.attr(span, req.url, 'response.errorCode', e.code);
+            this.attr(span, req.url, 'response.data', e?.response?.data);
             span.recordException(e);
             span.setStatus({ code: SpanStatusCode.ERROR });
             throw e;
         }), tap((data) => {
-            span.setAttribute('incoming.response.headers', this.stringify(res.headers));
-            span.setAttribute('incoming.response.statusCode', this.stringify(res.statusCode));
-            span.setAttribute('incoming.response.data', this.stringify(data));
+            this.attr(span, req.url, 'response.headers', res.headers);
+            this.attr(span, req.url, 'response.statusCode', res.statusCode);
+            this.attr(span, req.url, 'response.data', data);
         }));
     }
     ws(span, context, next) {
@@ -66,11 +101,34 @@ let TracingInterceptor = class TracingInterceptor {
         return this[type](span, context, next);
     }
 };
+TracingInterceptor.aspectAliases = {
+    'request.url': 'url',
+    'request.method': 'method',
+    'request.headers': 'headers',
+    'request.body': 'body',
+    'request.params': 'params',
+    'request.query': 'query',
+    statusCode: 'response.statusCode',
+    data: 'response.data',
+    errorCode: 'response.errorCode',
+};
+TracingInterceptor.aspectKeys = {
+    url: 'incoming.request.url',
+    method: 'incoming.request.method',
+    headers: 'incoming.request.headers',
+    body: 'incoming.request.body',
+    params: 'incoming.request.params',
+    query: 'incoming.request.query',
+    'response.headers': 'incoming.response.headers',
+    'response.statusCode': 'incoming.response.statusCode',
+    'response.data': 'incoming.response.data',
+    'response.errorCode': 'incoming.response.errorCode',
+};
 __decorate([
     inject(Types.Config),
     __metadata("design:type", Object)
 ], TracingInterceptor.prototype, "config", void 0);
-TracingInterceptor = __decorate([
+TracingInterceptor = TracingInterceptor_1 = __decorate([
     Injectable()
 ], TracingInterceptor);
 export { TracingInterceptor };

package/dist/types/src/interceptors/tracing-interceptor.d.ts

@@ -2,9 +2,14 @@ import { Span } from '@biorate/opentelemetry';
 import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
 import { IConfig } from '@biorate/config';
 export declare class TracingInterceptor implements NestInterceptor {
+    protected static aspectAliases: Record<string, string>;
+    protected static aspectKeys: Record<string, string>;
+    protected static normalizeAspect(name: string): string;
     protected readonly config: IConfig;
     protected stringify(data: unknown): string;
     protected excluded(url: string): boolean;
+    protected excludedAttribute(url: string, aspect: string): boolean;
+    protected attr(span: Span, url: string, aspect: string, value: unknown): void;
     protected http(span: Span, context: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;
     protected ws(span: Span, context: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;
     protected rpc(span: Span, context: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biorate/nestjs-tools",
-  "version": "2.4.0",
+  "version": "2.5.2",
   "description": "NestJS tools",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -45,7 +45,7 @@
   "keywords": [],
   "author": "llevkin",
   "license": "MIT",
-  "gitHead": "09ccd82d8fba90cb37750dccf41469452880b129",
+  "gitHead": "53c9b4fbcae2fd034c3ba129a5cbe52f4b80bff3",
   "peerDependencies": {
     "@nestjs/common": ">=10.4.15",
     "@nestjs/core": ">=10.4.15",
@@ -59,13 +59,13 @@
     "ws": ">=8.18.0"
   },
   "dependencies": {
-    "@biorate/axios": "3.4.0",
-    "@biorate/config": "3.2.3",
+    "@biorate/axios": "3.4.1",
+    "@biorate/config": "3.2.4",
     "@biorate/errors": "3.1.2",
-    "@biorate/inversion": "3.1.3",
-    "@biorate/opentelemetry": "2.4.2",
-    "@biorate/prometheus": "3.1.3",
-    "@biorate/tools": "3.1.2",
+    "@biorate/inversion": "3.1.4",
+    "@biorate/opentelemetry": "2.4.3",
+    "@biorate/prometheus": "3.1.4",
+    "@biorate/tools": "3.1.3",
     "http-proxy": "1.18.1",
     "http-proxy-middleware": "2.0.6",
     "json-stringify-safe": "5.0.1",