@tramvai/module-opentelemetry 5.22.0 → 5.40.0

package/lib/instrumentation/router.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export declare const providers: import("@tramvai/core").Provider<{
+    tracer: import("../tokens").TramvaiTracer & {
+        __type?: "base token" | undefined;
+    };
+    request: import("fastify").FastifyRequest<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown, import("fastify").FastifyBaseLogger, import("fastify/types/type-provider").ResolveFastifyRequestType<import("fastify").FastifyTypeProviderDefault, import("fastify").FastifySchema, import("fastify").RouteGenericInterface>> & {
+        __type?: "base token" | undefined;
+    };
+}, import("@tinkoff/router").RouterPlugin & {
+    __type?: "multi token" | undefined;
+}>[];
+//# sourceMappingURL=router.d.ts.map

package/lib/instrumentation/router.es.js

@@ -0,0 +1,115 @@
+import { isRedirectFoundError, isNotFoundError } from '@tinkoff/errors';
+import { provide } from '@tramvai/core';
+import { ROUTER_PLUGIN } from '@tramvai/tokens-router';
+import { SpanKind } from '@opentelemetry/api';
+import { ATTR_URL_PATH, ATTR_HTTP_ROUTE, ATTR_URL_QUERY, ATTR_URL_FULL } from '@opentelemetry/semantic-conventions';
+import { FASTIFY_REQUEST } from '@tramvai/tokens-server-private';
+import { OPENTELEMETRY_TRACER_TOKEN } from '../tokens.es.js';
+import { REQUEST_SPAN } from './server.es.js';
+
+function skipError(error) {
+    return isRedirectFoundError(error) || isNotFoundError(error);
+}
+class OpentelemetryRouterPlugin {
+    constructor({ tracer, request }) {
+        this.tracer = tracer;
+        this.request = request;
+    }
+    apply(router) {
+        router.navigateHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`navigate`, { kind: SpanKind.SERVER }, async (span) => {
+                const url = typeof payload.navigateOptions === 'string'
+                    ? payload.navigateOptions
+                    : payload.navigateOptions.url;
+                span.setAttribute('tramvai.scope', 'router');
+                if (url) {
+                    span.setAttribute(ATTR_URL_PATH, url);
+                }
+                await next(payload);
+            }, { skipError });
+        });
+        // TODO: is updateCurrentRoute tracing necessary at server-side?
+        // router.updateHook.wrap(async (_, payload, next) => {
+        //   return this.tracer.trace(`update`, { kind: SpanKind.SERVER }, async (span) => {
+        //     span.setAttribute('tramvai.scope', 'router');
+        //     await next(payload);
+        //   });
+        // });
+        router.runNavigateHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`run navigate`, { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.to && payload.navigation.url) {
+                    const { path } = payload.navigation.to;
+                    const { pathname, search, href } = payload.navigation.url;
+                    span.setAttribute(ATTR_HTTP_ROUTE, path);
+                    span.setAttribute(ATTR_URL_PATH, pathname);
+                    span.setAttribute(ATTR_URL_QUERY, search.replace('?', ''));
+                    span.setAttribute(ATTR_URL_FULL, href);
+                    // bubble current page route to root server request span
+                    if (this.request[REQUEST_SPAN]) {
+                        this.request[REQUEST_SPAN].setAttribute(ATTR_HTTP_ROUTE, path);
+                    }
+                }
+                await next(payload);
+            });
+        });
+        router.redirectHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`redirect`, { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.url) {
+                    // TODO не корректный урл, как будто уже после модификации
+                    span.setAttribute('tramvai.router.redirect.from', payload.navigation.fromUrl.href);
+                    span.setAttribute('tramvai.router.redirect.to', payload.navigation.url.href);
+                    if (payload.navigation.code) {
+                        span.setAttribute('tramvai.router.redirect.code', payload.navigation.code);
+                    }
+                }
+                await next(payload);
+            });
+        });
+        router.notfoundHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`notfound`, { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.url) {
+                    span.setAttribute('tramvai.router.notfound.url', payload.navigation.url.href);
+                }
+                await next(payload);
+            });
+        });
+        router.blockHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`block`, { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.url) {
+                    span.setAttribute('tramvai.router.block.url', payload.navigation.url.href);
+                }
+                await next(payload);
+            });
+        });
+        for (const [hookName, hook] of router.hooks.entries()) {
+            hook.wrap(async (_, payload, next) => {
+                return this.tracer.trace(`${hookName} hooks`, { kind: SpanKind.SERVER }, async (span) => {
+                    span.setAttribute('tramvai.scope', 'router');
+                    await next(payload);
+                });
+            });
+        }
+        router.guards.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`guards`, { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                await next(payload);
+            });
+        });
+    }
+}
+const providers = [
+    provide({
+        provide: ROUTER_PLUGIN,
+        useClass: OpentelemetryRouterPlugin,
+        deps: {
+            tracer: OPENTELEMETRY_TRACER_TOKEN,
+            request: FASTIFY_REQUEST,
+        },
+    }),
+];
+
+export { providers };

package/lib/instrumentation/router.js

@@ -0,0 +1,119 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('@tinkoff/errors');
+var core = require('@tramvai/core');
+var tokensRouter = require('@tramvai/tokens-router');
+var api = require('@opentelemetry/api');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var tokens = require('../tokens.js');
+var server = require('./server.js');
+
+function skipError(error) {
+    return errors.isRedirectFoundError(error) || errors.isNotFoundError(error);
+}
+class OpentelemetryRouterPlugin {
+    constructor({ tracer, request }) {
+        this.tracer = tracer;
+        this.request = request;
+    }
+    apply(router) {
+        router.navigateHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`navigate`, { kind: api.SpanKind.SERVER }, async (span) => {
+                const url = typeof payload.navigateOptions === 'string'
+                    ? payload.navigateOptions
+                    : payload.navigateOptions.url;
+                span.setAttribute('tramvai.scope', 'router');
+                if (url) {
+                    span.setAttribute(semanticConventions.ATTR_URL_PATH, url);
+                }
+                await next(payload);
+            }, { skipError });
+        });
+        // TODO: is updateCurrentRoute tracing necessary at server-side?
+        // router.updateHook.wrap(async (_, payload, next) => {
+        //   return this.tracer.trace(`update`, { kind: SpanKind.SERVER }, async (span) => {
+        //     span.setAttribute('tramvai.scope', 'router');
+        //     await next(payload);
+        //   });
+        // });
+        router.runNavigateHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`run navigate`, { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.to && payload.navigation.url) {
+                    const { path } = payload.navigation.to;
+                    const { pathname, search, href } = payload.navigation.url;
+                    span.setAttribute(semanticConventions.ATTR_HTTP_ROUTE, path);
+                    span.setAttribute(semanticConventions.ATTR_URL_PATH, pathname);
+                    span.setAttribute(semanticConventions.ATTR_URL_QUERY, search.replace('?', ''));
+                    span.setAttribute(semanticConventions.ATTR_URL_FULL, href);
+                    // bubble current page route to root server request span
+                    if (this.request[server.REQUEST_SPAN]) {
+                        this.request[server.REQUEST_SPAN].setAttribute(semanticConventions.ATTR_HTTP_ROUTE, path);
+                    }
+                }
+                await next(payload);
+            });
+        });
+        router.redirectHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`redirect`, { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.url) {
+                    // TODO не корректный урл, как будто уже после модификации
+                    span.setAttribute('tramvai.router.redirect.from', payload.navigation.fromUrl.href);
+                    span.setAttribute('tramvai.router.redirect.to', payload.navigation.url.href);
+                    if (payload.navigation.code) {
+                        span.setAttribute('tramvai.router.redirect.code', payload.navigation.code);
+                    }
+                }
+                await next(payload);
+            });
+        });
+        router.notfoundHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`notfound`, { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.url) {
+                    span.setAttribute('tramvai.router.notfound.url', payload.navigation.url.href);
+                }
+                await next(payload);
+            });
+        });
+        router.blockHook.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`block`, { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                if (payload.navigation.url) {
+                    span.setAttribute('tramvai.router.block.url', payload.navigation.url.href);
+                }
+                await next(payload);
+            });
+        });
+        for (const [hookName, hook] of router.hooks.entries()) {
+            hook.wrap(async (_, payload, next) => {
+                return this.tracer.trace(`${hookName} hooks`, { kind: api.SpanKind.SERVER }, async (span) => {
+                    span.setAttribute('tramvai.scope', 'router');
+                    await next(payload);
+                });
+            });
+        }
+        router.guards.wrap(async (_, payload, next) => {
+            return this.tracer.trace(`guards`, { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'router');
+                await next(payload);
+            });
+        });
+    }
+}
+const providers = [
+    core.provide({
+        provide: tokensRouter.ROUTER_PLUGIN,
+        useClass: OpentelemetryRouterPlugin,
+        deps: {
+            tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+            request: tokensServerPrivate.FASTIFY_REQUEST,
+        },
+    }),
+];
+
+exports.providers = providers;

package/lib/instrumentation/server.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { type Span } from '@opentelemetry/api';
-declare const REQUEST_SPAN: unique symbol;
+export declare const REQUEST_SPAN: unique symbol;
 declare module 'fastify' {
     interface FastifyRequest {
         [REQUEST_SPAN]?: Span;
@@ -16,10 +16,12 @@ export declare const providers: (import("@tramvai/core").Provider<{
     tracesExcludePaths: string & {
         __type?: "multi token" | undefined;
     };
+    envManager: import("@tramvai/tokens-common").EnvironmentManager & {
+        __type?: "base token" | undefined;
+    };
 }, import("@tramvai/tokens-server-private").FASTIFY_APP_INIT_HANDLER & {
     __type?: "multi token" | undefined;
 }> | import("@tramvai/core").Provider<{}, import("@tramvai/tokens-server-private").FASTIFY_APP_ERROR_HANDLER & {
     __type?: "multi token" | undefined;
 }>)[];
-export {};
 //# sourceMappingURL=server.d.ts.map

package/lib/instrumentation/server.es.js

@@ -1,4 +1,4 @@
-import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_ROUTE, ATTR_URL_PATH, ATTR_URL_QUERY, ATTR_URL_SCHEME, ATTR_URL_FULL, ATTR_HTTP_RESPONSE_STATUS_CODE } from '@opentelemetry/semantic-conventions';
+import { ATTR_HTTP_REQUEST_METHOD, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_HTTP_ROUTE, ATTR_URL_PATH, ATTR_URL_QUERY, ATTR_URL_SCHEME, ATTR_URL_FULL, ATTR_HTTP_RESPONSE_STATUS_CODE } from '@opentelemetry/semantic-conventions';
 import { propagation, ROOT_CONTEXT, SpanKind, SpanStatusCode } from '@opentelemetry/api';
 import pathToRegexp from 'path-to-regexp';
 import flatten from '@tinkoff/utils/array/flatten';
@@ -6,13 +6,14 @@ import { isNotFoundError, isHttpError } from '@tinkoff/errors';
 import { provide } from '@tramvai/core';
 import { UTILITY_SERVER_PATHS } from '@tramvai/tokens-server';
 import { WEB_FASTIFY_APP_INIT_TOKEN, WEB_FASTIFY_APP_TOKEN, WEB_FASTIFY_APP_AFTER_ERROR_TOKEN } from '@tramvai/tokens-server-private';
+import { ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { OPENTELEMETRY_TRACER_TOKEN } from '../tokens.es.js';
 
 const REQUEST_SPAN = Symbol('opentelemetry.tramvai.server.request.span');
 const providers = [
     provide({
         provide: WEB_FASTIFY_APP_INIT_TOKEN,
-        useFactory: ({ app, tracer, tracesExcludePaths }) => {
+        useFactory: ({ app, tracer, tracesExcludePaths, envManager }) => {
             return () => {
                 // todo copypaste from @tinkoff/measure-fastify-requests
                 const excludePatterns = flatten(tracesExcludePaths).map((p) => pathToRegexp(p));
@@ -50,6 +51,8 @@ const providers = [
                         span.setAttribute('tramvai.server.framework', 'fastify');
                         // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/http.md
                         span.setAttribute(ATTR_HTTP_REQUEST_METHOD, httpMethod);
+                        span.setAttribute(ATTR_SERVER_ADDRESS, req.headers['x-original-host'] || req.headers.host || envManager.get('PORT'));
+                        span.setAttribute(ATTR_SERVER_PORT, envManager.get('PORT'));
                         // route should have low-cardinality - https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/http.md
                         span.setAttribute(ATTR_HTTP_ROUTE, httpRoute);
                         span.setAttribute(ATTR_URL_PATH, parsedUrl.pathname);
@@ -76,6 +79,7 @@ const providers = [
             app: WEB_FASTIFY_APP_TOKEN,
             tracer: OPENTELEMETRY_TRACER_TOKEN,
             tracesExcludePaths: UTILITY_SERVER_PATHS,
+            envManager: ENV_MANAGER_TOKEN,
         },
     }),
     provide({
@@ -116,4 +120,4 @@ const providers = [
     }),
 ];
 
-export { providers };
+export { REQUEST_SPAN, providers };

package/lib/instrumentation/server.js

@@ -10,6 +10,7 @@ var errors = require('@tinkoff/errors');
 var core = require('@tramvai/core');
 var tokensServer = require('@tramvai/tokens-server');
 var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var tokensCommon = require('@tramvai/tokens-common');
 var tokens = require('../tokens.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -21,7 +22,7 @@ const REQUEST_SPAN = Symbol('opentelemetry.tramvai.server.request.span');
 const providers = [
     core.provide({
         provide: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN,
-        useFactory: ({ app, tracer, tracesExcludePaths }) => {
+        useFactory: ({ app, tracer, tracesExcludePaths, envManager }) => {
             return () => {
                 // todo copypaste from @tinkoff/measure-fastify-requests
                 const excludePatterns = flatten__default["default"](tracesExcludePaths).map((p) => pathToRegexp__default["default"](p));
@@ -59,6 +60,8 @@ const providers = [
                         span.setAttribute('tramvai.server.framework', 'fastify');
                         // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/http.md
                         span.setAttribute(semanticConventions.ATTR_HTTP_REQUEST_METHOD, httpMethod);
+                        span.setAttribute(semanticConventions.ATTR_SERVER_ADDRESS, req.headers['x-original-host'] || req.headers.host || envManager.get('PORT'));
+                        span.setAttribute(semanticConventions.ATTR_SERVER_PORT, envManager.get('PORT'));
                         // route should have low-cardinality - https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/http.md
                         span.setAttribute(semanticConventions.ATTR_HTTP_ROUTE, httpRoute);
                         span.setAttribute(semanticConventions.ATTR_URL_PATH, parsedUrl.pathname);
@@ -85,6 +88,7 @@ const providers = [
             app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
             tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
             tracesExcludePaths: tokensServer.UTILITY_SERVER_PATHS,
+            envManager: tokensCommon.ENV_MANAGER_TOKEN,
         },
     }),
     core.provide({
@@ -125,4 +129,5 @@ const providers = [
     }),
 ];
 
+exports.REQUEST_SPAN = REQUEST_SPAN;
 exports.providers = providers;

package/lib/server.es.js

@@ -2,8 +2,8 @@ import { __decorate } from 'tslib';
 import { Module, provide, commandLineListTokens, optional, APP_INFO_TOKEN } from '@tramvai/core';
 import { NodeTracerProvider, SimpleSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
 import { Resource } from '@opentelemetry/resources';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { OPENTELEMETRY_PROVIDER_TOKEN, OPENTELEMETRY_PROVIDER_CONFIG_TOKEN, OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN, OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN, OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN, OPENTELEMETRY_TRACER_TOKEN } from './tokens.es.js';
 export { OPENTELEMETRY_PROVIDER_CONFIG_TOKEN, OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN, OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN, OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN, OPENTELEMETRY_PROVIDER_TOKEN, OPENTELEMETRY_TRACER_TOKEN } from './tokens.es.js';
 import { TramvaiTracerImpl } from './tracer/tracer.es.js';
@@ -11,6 +11,7 @@ import { providers } from './instrumentation/server.es.js';
 import { providers as providers$1 } from './instrumentation/httpClient.es.js';
 import { providers as providers$2 } from './instrumentation/logs.es.js';
 import { providers as providers$3 } from './instrumentation/commandLineRunner.es.js';
+import { providers as providers$4 } from './instrumentation/router.es.js';
 
 let OpenTelemetryModule = class OpenTelemetryModule {
 };
@@ -22,6 +23,7 @@ OpenTelemetryModule = __decorate([
             ...providers$1,
             ...providers$2,
             ...providers$3,
+            ...providers$4,
             provide({
                 provide: commandLineListTokens.init,
                 useFactory: ({ provider }) => {
@@ -89,20 +91,22 @@ OpenTelemetryModule = __decorate([
             }),
             provide({
                 provide: OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
-                useFactory: ({ appInfo }) => {
+                useFactory: ({ appInfo, envManager }) => {
                     return {
                         [ATTR_SERVICE_NAME]: appInfo.appName,
+                        [ATTR_SERVICE_VERSION]: envManager.get('APP_VERSION'),
                     };
                 },
                 deps: {
                     appInfo: APP_INFO_TOKEN,
+                    envManager: ENV_MANAGER_TOKEN,
                 },
             }),
             provide({
                 provide: OPENTELEMETRY_TRACER_TOKEN,
                 useFactory: ({ provider }) => {
                     const tracer = provider.getTracer('tramvai', '1.0.0');
-                    return new TramvaiTracerImpl(tracer);
+                    return new TramvaiTracerImpl({ tracer });
                 },
                 deps: {
                     provider: OPENTELEMETRY_PROVIDER_TOKEN,

package/lib/server.js

@@ -14,6 +14,7 @@ var server = require('./instrumentation/server.js');
 var httpClient = require('./instrumentation/httpClient.js');
 var logs = require('./instrumentation/logs.js');
 var commandLineRunner = require('./instrumentation/commandLineRunner.js');
+var router = require('./instrumentation/router.js');
 
 exports.OpenTelemetryModule = class OpenTelemetryModule {
 };
@@ -25,6 +26,7 @@ exports.OpenTelemetryModule = tslib.__decorate([
             ...httpClient.providers,
             ...logs.providers,
             ...commandLineRunner.providers,
+            ...router.providers,
             core.provide({
                 provide: core.commandLineListTokens.init,
                 useFactory: ({ provider }) => {
@@ -92,20 +94,22 @@ exports.OpenTelemetryModule = tslib.__decorate([
             }),
             core.provide({
                 provide: tokens.OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
-                useFactory: ({ appInfo }) => {
+                useFactory: ({ appInfo, envManager }) => {
                     return {
                         [semanticConventions.ATTR_SERVICE_NAME]: appInfo.appName,
+                        [semanticConventions.ATTR_SERVICE_VERSION]: envManager.get('APP_VERSION'),
                     };
                 },
                 deps: {
                     appInfo: core.APP_INFO_TOKEN,
+                    envManager: tokensCommon.ENV_MANAGER_TOKEN,
                 },
             }),
             core.provide({
                 provide: tokens.OPENTELEMETRY_TRACER_TOKEN,
                 useFactory: ({ provider }) => {
                     const tracer$1 = provider.getTracer('tramvai', '1.0.0');
-                    return new tracer.TramvaiTracerImpl(tracer$1);
+                    return new tracer.TramvaiTracerImpl({ tracer: tracer$1 });
                 },
                 deps: {
                     provider: tokens.OPENTELEMETRY_PROVIDER_TOKEN,

package/lib/tokens.d.ts

@@ -1,6 +1,9 @@
 import type { Context, Span, SpanOptions } from '@opentelemetry/api';
 import type { SpanProcessor, TracerConfig, BasicTracerProvider } from '@opentelemetry/sdk-trace-node';
 import type { Resource } from '@opentelemetry/resources';
+export type TraceParams = {
+    skipError?: (error: Error) => boolean;
+};
 /**
  * API inspired by:
  * - https://github.com/DataDog/dd-trace-js/blob/59e9a2a75f4256755b4e6c9951a0bdf8d39b4015/index.d.ts#L9
@@ -12,10 +15,10 @@ export interface TramvaiTracer {
     startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
     startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, context: Context, fn: F): ReturnType<F>;
     getActiveSpan(): Span | undefined;
-    trace<T>(name: string, fn: (span: Span) => Promise<T>): Promise<T>;
-    trace<T>(name: string, fn: (span: Span) => T): T;
-    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
-    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => T): T;
+    trace<T>(name: string, fn: (span: Span) => Promise<T>, params?: TraceParams): Promise<T>;
+    trace<T>(name: string, fn: (span: Span) => T, params?: TraceParams): T;
+    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => Promise<T>, params?: TraceParams): Promise<T>;
+    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => T, params?: TraceParams): T;
 }
 export declare const OPENTELEMETRY_PROVIDER_TOKEN: BasicTracerProvider & {
     __type?: "base token" | undefined;

package/lib/tracer/tracer.d.ts

@@ -1,16 +1,18 @@
 import type { Context, Span, SpanOptions, Tracer } from '@opentelemetry/api';
-import type { TramvaiTracer } from '../tokens';
+import type { TraceParams, TramvaiTracer } from '../tokens';
 export declare class TramvaiTracerImpl implements TramvaiTracer {
     private tracer;
-    constructor(tracer: Tracer);
+    constructor({ tracer }: {
+        tracer: Tracer;
+    });
     startSpan(...args: any[]): Span;
     startActiveSpan<F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
     startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
     startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, ctx: Context, fn: F): ReturnType<F>;
     getActiveSpan(): Span | undefined;
-    trace<T>(name: string, fn: (span: Span) => Promise<T>): Promise<T>;
-    trace<T>(name: string, fn: (span: Span) => T): T;
-    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
-    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => T): T;
+    trace<T>(name: string, fn: (span: Span) => Promise<T>, params?: TraceParams): Promise<T>;
+    trace<T>(name: string, fn: (span: Span) => T, params?: TraceParams): T;
+    trace<T>(name: string, options: SpanOptions, fn: (span: Span) => Promise<T>, params?: TraceParams): Promise<T>;
+    trace<T>(name: string, options: SpanOptions, fn: (span: Span, params?: TraceParams) => T): T;
 }
 //# sourceMappingURL=tracer.d.ts.map

package/lib/tracer/tracer.es.js

@@ -1,18 +1,21 @@
 import isPromise from '@tinkoff/utils/is/promise';
 import { trace, context, ROOT_CONTEXT, SpanStatusCode } from '@opentelemetry/api';
+import { isSilentError } from '@tinkoff/errors';
 
 /* eslint-disable prefer-destructuring */
-function recordAndThrowError(span, error) {
+function recordAndThrowError(span, error, { skipError = () => false }) {
     span.recordException(error);
-    span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error?.message ?? 'Unknown error',
-    });
+    if (!(skipError(error) || isSilentError(error))) {
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: error?.message ?? 'Unknown error',
+        });
+    }
     span.end();
     throw error;
 }
 class TramvaiTracerImpl {
-    constructor(tracer) {
+    constructor({ tracer }) {
         this.tracer = tracer;
     }
     startSpan(...args) {
@@ -30,13 +33,16 @@ class TramvaiTracerImpl {
         const name = args[0];
         let fn;
         let options;
-        if (args.length === 2) {
+        let params;
+        if (args.length === 2 || (args.length === 3 && typeof args[2] === 'object')) {
             fn = args[1];
             options = {};
+            params = args[2] || {};
         }
         else {
             fn = args[2];
             options = args[1];
+            params = args[3] || {};
         }
         const activeSpan = trace.getSpan(context.active());
         const spanContext = activeSpan ? trace.setSpan(context.active(), activeSpan) : undefined;
@@ -52,7 +58,7 @@ class TramvaiTracerImpl {
                         return res;
                     })
                         .catch((error) => {
-                        recordAndThrowError(span, error);
+                        recordAndThrowError(span, error, params);
                     });
                 }
                 // otherwise, end span immediately
@@ -60,7 +66,7 @@ class TramvaiTracerImpl {
                 return result;
             }
             catch (error) {
-                recordAndThrowError(span, error);
+                recordAndThrowError(span, error, params);
             }
         });
     }

package/lib/tracer/tracer.js

@@ -4,23 +4,26 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var isPromise = require('@tinkoff/utils/is/promise');
 var api = require('@opentelemetry/api');
+var errors = require('@tinkoff/errors');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var isPromise__default = /*#__PURE__*/_interopDefaultLegacy(isPromise);
 
 /* eslint-disable prefer-destructuring */
-function recordAndThrowError(span, error) {
+function recordAndThrowError(span, error, { skipError = () => false }) {
     span.recordException(error);
-    span.setStatus({
-        code: api.SpanStatusCode.ERROR,
-        message: error?.message ?? 'Unknown error',
-    });
+    if (!(skipError(error) || errors.isSilentError(error))) {
+        span.setStatus({
+            code: api.SpanStatusCode.ERROR,
+            message: error?.message ?? 'Unknown error',
+        });
+    }
     span.end();
     throw error;
 }
 class TramvaiTracerImpl {
-    constructor(tracer) {
+    constructor({ tracer }) {
         this.tracer = tracer;
     }
     startSpan(...args) {
@@ -38,13 +41,16 @@ class TramvaiTracerImpl {
         const name = args[0];
         let fn;
         let options;
-        if (args.length === 2) {
+        let params;
+        if (args.length === 2 || (args.length === 3 && typeof args[2] === 'object')) {
             fn = args[1];
             options = {};
+            params = args[2] || {};
         }
         else {
             fn = args[2];
             options = args[1];
+            params = args[3] || {};
         }
         const activeSpan = api.trace.getSpan(api.context.active());
         const spanContext = activeSpan ? api.trace.setSpan(api.context.active(), activeSpan) : undefined;
@@ -60,7 +66,7 @@ class TramvaiTracerImpl {
                         return res;
                     })
                         .catch((error) => {
-                        recordAndThrowError(span, error);
+                        recordAndThrowError(span, error, params);
                     });
                 }
                 // otherwise, end span immediately
@@ -68,7 +74,7 @@ class TramvaiTracerImpl {
                 return result;
             }
             catch (error) {
-                recordAndThrowError(span, error);
+                recordAndThrowError(span, error, params);
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-opentelemetry",
-  "version": "5.22.0",
+  "version": "5.40.0",
   "description": "Интеграция OpenTelemetry",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -28,18 +28,19 @@
     "@opentelemetry/sdk-trace-node": "^1.28.0",
     "@opentelemetry/semantic-conventions": "^1.28.0",
     "path-to-regexp": "0.1.7",
-    "@tramvai/tokens-common": "5.22.0",
-    "@tramvai/tokens-metrics": "5.22.0",
-    "@tramvai/tokens-http-client": "5.22.0",
-    "@tramvai/tokens-server": "5.22.0",
-    "@tramvai/tokens-server-private": "5.22.0",
+    "@tramvai/tokens-common": "5.40.0",
+    "@tramvai/tokens-metrics": "5.40.0",
+    "@tramvai/tokens-http-client": "5.40.0",
+    "@tramvai/tokens-server": "5.40.0",
+    "@tramvai/tokens-router": "5.40.0",
+    "@tramvai/tokens-server-private": "5.40.0",
     "@tinkoff/utils": "^2.1.2",
     "@tinkoff/errors": "0.6.2"
   },
   "devDependencies": {},
   "peerDependencies": {
     "@tinkoff/dippy": "0.11.3",
-    "@tramvai/core": "5.22.0",
+    "@tramvai/core": "5.40.0",
     "tslib": "^2.4.0"
   }
 }