@tramvai/module-opentelemetry 4.41.99

package/README.md

@@ -0,0 +1,153 @@
+# @tramvai/module-opentelemetry
+
+## Explanation
+
+Telemetry and distributed tracing is a important part of complete application monitoring.
+
+Tramvai provides a deep integration with [OpenTelemetry](https://opentelemetry.io/) Node.js SDK, with custom automatic instrumentation for internal Node.js modules and core Tramvai mechanisms.
+
+## Usage
+
+### Installation
+
+You need to install `@tramvai/module-opentelemetry`:
+
+```bash npm2yarn
+npm i --save @tramvai/module-module-opentelemetry
+```
+
+Then connect to the project:
+
+```ts
+import { createApp } from '@tramvai/core';
+import { OpenTelemetryModule } from '@tramvai/module-opentelemetry';
+
+createApp({
+  name: 'tincoin',
+  modules: [ OpenTelemetryModule ],
+});
+```
+
+This will enable OpenTelemetry with automatic instrumentation, and provide `Tracer` into the application.
+
+### Create spans
+
+Simplest way to wrap operation in span is to use `Tracer.trace` method, e.g.:
+
+```ts
+import { OPENTELEMETRY_TRACER_TOKEN } from '@tramvai/module-opentelemetry';
+
+const provider = {
+  provide: commandLineListTokens.resolvePageDeps,
+  useFactory: ({ tracer, apiService }) => {
+    return async function getSmth() {
+      tracer?.trace('get-smth', async (span) => {
+        // set attribute to the span
+        span.setAttribute('key', 'value');
+
+        // span will be ended automatically after `apiService.get` method resolves or rejects
+        return apiService.get('/smth');
+      });
+    }
+  },
+  deps: {
+    // tracer exists only server-side
+    tracer: optional(OPENTELEMETRY_TRACER_TOKEN),
+    apiService: API_SERVICE_TOKEN,
+  },
+};
+```
+
+For more flexibility methods [Tracer.startActiveSpan](https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api.Tracer.html#startActiveSpan) and [Tracer.startSpan](https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api.Tracer.html#startSpan) is available.
+
+`Tracer.trace` and other span creation methods calls can be nested, with [automatic](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-context-async-hooks) context propagation.
+
+### Export traces
+
+For export traces to OpenTelemetry collector, you need to provide custom span processor and exporter with `OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN` token.
+
+If you have a gRPC collector (e.g. Jaeger), library `@opentelemetry/exporter-trace-otlp-grpc` can be used:
+
+```ts
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN } from '@tramvai/module-opentelemetry';
+
+const provider = {
+  provide: OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN,
+  useFactory: ({ envManager }) => {
+    const url = envManager.get('OTEL_GRPC_COLLECTOR_ENDPOINT');
+    const exporter = new OTLPTraceExporter({ url });
+
+    return new BatchSpanProcessor(exporter);
+  },
+  deps: {
+    envManager: ENV_MANAGER_TOKEN,
+  },
+};
+```
+
+### Resource attributes
+
+If you need to extend [resource](https://opentelemetry.io/docs/concepts/resources/) attributes, use `OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN` token. Also, `@opentelemetry/semantic-conventions` library contains some of attribute names.
+
+```ts
+import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN } from '@tramvai/module-opentelemetry';
+
+const provider = {
+  provide: OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
+  useFactory: ({ appInfo }) => {
+    return {
+      [ATTR_SERVICE_NAME]: appInfo.appName,
+    }
+  },
+  deps: {
+    appInfo: APP_INFO_TOKEN,
+  },
+};
+```
+
+### Active span
+
+If you need to set attributes to the active span, use `Tracer.getActiveSpan` method:
+
+```ts
+// tracer from OPENTELEMETRY_TRACER_TOKEN
+function doSmt({ tracer }) {
+  const span = tracer.getActiveSpan();
+
+  // span can be absent, for example in `init` or `listen` command line stages
+  span?.setAttribute('key', 'value');
+}
+```
+
+## Automatic instrumentation
+
+[OpenTelemetry instrumentation libraries](https://www.npmjs.com/package/@opentelemetry/instrumentation) is not supported, because of it limitations:
+- instrumentations are registered before the module to instrument is require'ed
+- modules are not included in a bundle
+
+Instead, module provides custom instrumentation for all significant cases:
+
+### Server module
+
+All incoming requests are automatically wrapped in **root span**, where current request and response parameters will be set (path, method, status code, error).
+
+Naming and attributes follow [semantic conventions](https://opentelemetry.io/docs/specs/semconv/http/http-spans/).
+
+### Context propagation
+
+`OpenTelemetryModule` provides [context propagation](https://opentelemetry.io/docs/languages/js/propagation/) for incoming and outgoing requests.
+
+### Logs correlation
+
+`OpenTelemetryModule` inject context for [logs correlation](https://opentelemetry.io/docs/specs/otel/logs/#log-correlation).
+
+All application logs will be extended with current span and trace ids in `spanId` and `traceId` properties.
+
+## Debug and testing
+
+By default, in `development` mode [ConsoleSpanExporter](https://open-telemetry.github.io/opentelemetry-js/classes/_opentelemetry_sdk_trace_base.ConsoleSpanExporter.html) is used, which prints all spans to the console.
+
+For testing purposes, you can use [InMemorySpanExporter](https://open-telemetry.github.io/opentelemetry-js/classes/_opentelemetry_sdk_trace_base.InMemorySpanExporter.html).

package/lib/browser.d.ts

@@ -0,0 +1,4 @@
+export * from './tokens';
+export declare class OpenTelemetryModule {
+}
+//# sourceMappingURL=browser.d.ts.map

package/lib/browser.js

@@ -0,0 +1,15 @@
+import { __decorate } from 'tslib';
+import { Module } from '@tramvai/core';
+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.browser.js';
+
+let OpenTelemetryModule = class OpenTelemetryModule {
+};
+OpenTelemetryModule = __decorate([
+    Module({
+        imports: [],
+        providers: [],
+    })
+], OpenTelemetryModule);
+// todo declareModule!
+
+export { OpenTelemetryModule };

package/lib/instrumentation/httpClient.d.ts

@@ -0,0 +1,11 @@
+export declare const providers: import("@tramvai/core").Provider<{
+    tracer: import("../tokens").TramvaiTracer & {
+        __type?: "base token" | undefined;
+    };
+    metricsServicesRegistry: import("@tramvai/tokens-metrics").MetricsServicesRegistryInterface & {
+        __type?: "base token" | undefined;
+    };
+}, import("@tramvai/http-client").HttpClientInterceptor & {
+    __type?: "multi token" | undefined;
+}>[];
+//# sourceMappingURL=httpClient.d.ts.map

package/lib/instrumentation/httpClient.es.js

@@ -0,0 +1,97 @@
+import { provide } from '@tramvai/core';
+import { DEFAULT_HTTP_CLIENT_INTERCEPTORS } from '@tramvai/tokens-http-client';
+import { METRICS_SERVICES_REGISTRY_TOKEN } from '@tramvai/tokens-metrics';
+import { propagation, context, SpanKind } from '@opentelemetry/api';
+import { ATTR_HTTP_REQUEST_METHOD, ATTR_SERVER_ADDRESS, ATTR_URL_PATH, ATTR_URL_QUERY, ATTR_URL_SCHEME, ATTR_URL_FULL, ATTR_HTTP_RESPONSE_STATUS_CODE } from '@opentelemetry/semantic-conventions';
+import { OPENTELEMETRY_TRACER_TOKEN } from '../tokens.es.js';
+
+const providers = [
+    provide({
+        provide: DEFAULT_HTTP_CLIENT_INTERCEPTORS,
+        useFactory: ({ tracer, metricsServicesRegistry }) => {
+            return (request, next) => {
+                var _a, _b, _c, _d;
+                const url = (_a = request.url) !== null && _a !== void 0 ? _a : 
+                // todo add leading slash before path if needed
+                (request.baseUrl ? `${request.baseUrl}${request.path}` : (_b = request.path) !== null && _b !== void 0 ? _b : '');
+                const parsedUrl = new URL(request.query ? `${url}?${new URLSearchParams(request.query).toString()}` : url);
+                const serviceName = (_c = metricsServicesRegistry.getServiceName(url, request)) !== null && _c !== void 0 ? _c : 'unknown';
+                const method = (_d = request.method) !== null && _d !== void 0 ? _d : 'GET';
+                // propagate context from outgoing request
+                // https://opentelemetry.io/docs/languages/js/propagation/#manual-context-propagation
+                const output = {};
+                propagation.inject(context.active(), output);
+                if (output.traceparent) {
+                    if (!request.headers) {
+                        request.headers = {};
+                    }
+                    request.headers.traceparent = output.traceparent;
+                }
+                if (output.tracestate) {
+                    if (!request.headers) {
+                        request.headers = {};
+                    }
+                    request.headers.tracestate = output.tracestate;
+                }
+                // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#http-client
+                return tracer.trace(`${method} ${serviceName}`, { kind: SpanKind.CLIENT }, (span) => {
+                    // todo: move custom tramvai attrs to constants
+                    /**
+                     * - `tramvai.http-client.transport` - internal HTTP client, `node-fetch` at server-side (possible `undici` in future), `fetch` at client-side
+                     */
+                    span.setAttribute('tramvai.scope', 'http-client');
+                    span.setAttribute('tramvai.http-client.transport', 'node-fetch');
+                    span.setAttribute(ATTR_HTTP_REQUEST_METHOD, method);
+                    span.setAttribute(ATTR_SERVER_ADDRESS, parsedUrl.hostname);
+                    span.setAttribute(ATTR_URL_PATH, parsedUrl.pathname);
+                    span.setAttribute(ATTR_URL_QUERY, parsedUrl.search.replace('?', ''));
+                    span.setAttribute(ATTR_URL_SCHEME, parsedUrl.protocol.replace(':', ''));
+                    span.setAttribute(ATTR_URL_FULL, parsedUrl.href);
+                    // todo req/res headers?
+                    // todo http.request.resend_count?
+                    return next(request)
+                        .then((response) => {
+                        span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+                        const meta = response.__meta;
+                        if (meta) {
+                            writeMetaAttributes(span, meta);
+                        }
+                        return response;
+                    })
+                        .catch((error) => {
+                        var _a;
+                        span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, (_a = error === null || error === void 0 ? void 0 : error.status) !== null && _a !== void 0 ? _a : 500);
+                        const meta = error.__meta;
+                        if (meta) {
+                            writeMetaAttributes(span, meta);
+                        }
+                        throw error;
+                    });
+                });
+            };
+        },
+        deps: {
+            tracer: OPENTELEMETRY_TRACER_TOKEN,
+            metricsServicesRegistry: METRICS_SERVICES_REGISTRY_TOKEN,
+        },
+    }),
+];
+function writeMetaAttributes(span, meta) {
+    const { cache, CIRCUIT_BREAKER } = meta;
+    if (cache) {
+        span.setAttribute('tramvai.http-client.cache.forced', cache.forced);
+        span.setAttribute('tramvai.http-client.cache.enabled', cache.enabled);
+        span.setAttribute('tramvai.http-client.cache.enabled', cache.enabled);
+        span.setAttribute('tramvai.http-client.cache.memory.enabled', cache.memoryEnabled);
+        span.setAttribute('tramvai.http-client.cache.memory.force', cache.memoryForce);
+        span.setAttribute('tramvai.http-client.cache.memory.cache', cache.memoryCache);
+        span.setAttribute('tramvai.http-client.cache.memory.cache.outdated', cache.memoryCacheOutdated);
+        span.setAttribute('tramvai.http-client.cache.deduplicate.enabled', cache.deduplicateEnabled);
+        span.setAttribute('tramvai.http-client.cache.deduplicate.force', cache.deduplicateForce);
+    }
+    if (CIRCUIT_BREAKER) {
+        span.setAttribute('tramvai.http-client.circuit-breaker.open', CIRCUIT_BREAKER === null || CIRCUIT_BREAKER === void 0 ? void 0 : CIRCUIT_BREAKER.open);
+    }
+}
+
+export { providers };

package/lib/instrumentation/httpClient.js

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensHttpClient = require('@tramvai/tokens-http-client');
+var tokensMetrics = require('@tramvai/tokens-metrics');
+var api = require('@opentelemetry/api');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var tokens = require('../tokens.js');
+
+const providers = [
+    core.provide({
+        provide: tokensHttpClient.DEFAULT_HTTP_CLIENT_INTERCEPTORS,
+        useFactory: ({ tracer, metricsServicesRegistry }) => {
+            return (request, next) => {
+                var _a, _b, _c, _d;
+                const url = (_a = request.url) !== null && _a !== void 0 ? _a : 
+                // todo add leading slash before path if needed
+                (request.baseUrl ? `${request.baseUrl}${request.path}` : (_b = request.path) !== null && _b !== void 0 ? _b : '');
+                const parsedUrl = new URL(request.query ? `${url}?${new URLSearchParams(request.query).toString()}` : url);
+                const serviceName = (_c = metricsServicesRegistry.getServiceName(url, request)) !== null && _c !== void 0 ? _c : 'unknown';
+                const method = (_d = request.method) !== null && _d !== void 0 ? _d : 'GET';
+                // propagate context from outgoing request
+                // https://opentelemetry.io/docs/languages/js/propagation/#manual-context-propagation
+                const output = {};
+                api.propagation.inject(api.context.active(), output);
+                if (output.traceparent) {
+                    if (!request.headers) {
+                        request.headers = {};
+                    }
+                    request.headers.traceparent = output.traceparent;
+                }
+                if (output.tracestate) {
+                    if (!request.headers) {
+                        request.headers = {};
+                    }
+                    request.headers.tracestate = output.tracestate;
+                }
+                // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#http-client
+                return tracer.trace(`${method} ${serviceName}`, { kind: api.SpanKind.CLIENT }, (span) => {
+                    // todo: move custom tramvai attrs to constants
+                    /**
+                     * - `tramvai.http-client.transport` - internal HTTP client, `node-fetch` at server-side (possible `undici` in future), `fetch` at client-side
+                     */
+                    span.setAttribute('tramvai.scope', 'http-client');
+                    span.setAttribute('tramvai.http-client.transport', 'node-fetch');
+                    span.setAttribute(semanticConventions.ATTR_HTTP_REQUEST_METHOD, method);
+                    span.setAttribute(semanticConventions.ATTR_SERVER_ADDRESS, parsedUrl.hostname);
+                    span.setAttribute(semanticConventions.ATTR_URL_PATH, parsedUrl.pathname);
+                    span.setAttribute(semanticConventions.ATTR_URL_QUERY, parsedUrl.search.replace('?', ''));
+                    span.setAttribute(semanticConventions.ATTR_URL_SCHEME, parsedUrl.protocol.replace(':', ''));
+                    span.setAttribute(semanticConventions.ATTR_URL_FULL, parsedUrl.href);
+                    // todo req/res headers?
+                    // todo http.request.resend_count?
+                    return next(request)
+                        .then((response) => {
+                        span.setAttribute(semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+                        const meta = response.__meta;
+                        if (meta) {
+                            writeMetaAttributes(span, meta);
+                        }
+                        return response;
+                    })
+                        .catch((error) => {
+                        var _a;
+                        span.setAttribute(semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE, (_a = error === null || error === void 0 ? void 0 : error.status) !== null && _a !== void 0 ? _a : 500);
+                        const meta = error.__meta;
+                        if (meta) {
+                            writeMetaAttributes(span, meta);
+                        }
+                        throw error;
+                    });
+                });
+            };
+        },
+        deps: {
+            tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+            metricsServicesRegistry: tokensMetrics.METRICS_SERVICES_REGISTRY_TOKEN,
+        },
+    }),
+];
+function writeMetaAttributes(span, meta) {
+    const { cache, CIRCUIT_BREAKER } = meta;
+    if (cache) {
+        span.setAttribute('tramvai.http-client.cache.forced', cache.forced);
+        span.setAttribute('tramvai.http-client.cache.enabled', cache.enabled);
+        span.setAttribute('tramvai.http-client.cache.enabled', cache.enabled);
+        span.setAttribute('tramvai.http-client.cache.memory.enabled', cache.memoryEnabled);
+        span.setAttribute('tramvai.http-client.cache.memory.force', cache.memoryForce);
+        span.setAttribute('tramvai.http-client.cache.memory.cache', cache.memoryCache);
+        span.setAttribute('tramvai.http-client.cache.memory.cache.outdated', cache.memoryCacheOutdated);
+        span.setAttribute('tramvai.http-client.cache.deduplicate.enabled', cache.deduplicateEnabled);
+        span.setAttribute('tramvai.http-client.cache.deduplicate.force', cache.deduplicateForce);
+    }
+    if (CIRCUIT_BREAKER) {
+        span.setAttribute('tramvai.http-client.circuit-breaker.open', CIRCUIT_BREAKER === null || CIRCUIT_BREAKER === void 0 ? void 0 : CIRCUIT_BREAKER.open);
+    }
+}
+
+exports.providers = providers;

package/lib/instrumentation/logs.d.ts

@@ -0,0 +1,4 @@
+export declare const providers: import("@tramvai/core").Provider<unknown, ((logger: import("@tramvai/tokens-common").LoggerFactory) => void) & {
+    __type?: "multi token" | undefined;
+}>[];
+//# sourceMappingURL=logs.d.ts.map

package/lib/instrumentation/logs.es.js

@@ -0,0 +1,27 @@
+import { trace, context } from '@opentelemetry/api';
+import { provide } from '@tramvai/core';
+import { LOGGER_INIT_HOOK } from '@tramvai/tokens-common';
+
+const providers = [
+    provide({
+        provide: LOGGER_INIT_HOOK,
+        useValue: (loggerInstance) => {
+            loggerInstance.addExtension({
+                extend(logObj) {
+                    var _a;
+                    const activeSpanContext = (_a = trace.getSpan(context.active())) === null || _a === void 0 ? void 0 : _a.spanContext();
+                    if (activeSpanContext) {
+                        return {
+                            ...logObj,
+                            spanId: activeSpanContext.spanId,
+                            traceId: activeSpanContext.traceId,
+                        };
+                    }
+                    return logObj;
+                },
+            });
+        },
+    }),
+];
+
+export { providers };

package/lib/instrumentation/logs.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api = require('@opentelemetry/api');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+
+const providers = [
+    core.provide({
+        provide: tokensCommon.LOGGER_INIT_HOOK,
+        useValue: (loggerInstance) => {
+            loggerInstance.addExtension({
+                extend(logObj) {
+                    var _a;
+                    const activeSpanContext = (_a = api.trace.getSpan(api.context.active())) === null || _a === void 0 ? void 0 : _a.spanContext();
+                    if (activeSpanContext) {
+                        return {
+                            ...logObj,
+                            spanId: activeSpanContext.spanId,
+                            traceId: activeSpanContext.traceId,
+                        };
+                    }
+                    return logObj;
+                },
+            });
+        },
+    }),
+];
+
+exports.providers = providers;

package/lib/instrumentation/server.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { type Span } from '@opentelemetry/api';
+export declare const REQUEST_SPAN: unique symbol;
+declare module 'fastify' {
+    interface FastifyRequest {
+        [REQUEST_SPAN]?: Span;
+    }
+}
+export declare const providers: (import("@tramvai/core").Provider<{
+    app: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & {
+        __type?: "base token" | undefined;
+    };
+    tracer: import("../tokens").TramvaiTracer & {
+        __type?: "base token" | undefined;
+    };
+    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;
+}>)[];
+//# sourceMappingURL=server.d.ts.map

package/lib/instrumentation/server.es.js

@@ -0,0 +1,125 @@
+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';
+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, envManager }) => {
+            return () => {
+                // todo copypaste from @tinkoff/measure-fastify-requests
+                const excludePatterns = flatten(tracesExcludePaths).map((p) => pathToRegexp(p));
+                app.addHook('onRequest', (req, reply, done) => {
+                    var _a;
+                    // skip traces for healthchecks
+                    if (excludePatterns.some((p) => p.test(req.url))) {
+                        done();
+                        return;
+                    }
+                    // propagate context from incoming request
+                    // https://opentelemetry.io/docs/languages/js/propagation/#manual-context-propagation
+                    const activeContext = propagation.extract(ROOT_CONTEXT, req.headers);
+                    const httpMethod = req.method;
+                    // todo useful because always get `*`, rewrite with tramvai router route?
+                    const httpRoute = ((_a = req.routeOptions) === null || _a === void 0 ? void 0 : _a.url)
+                        ? req.routeOptions.url // since fastify@4.10.0
+                        : req.routerPath;
+                    const parsedUrl = new URL(`http://localhost${req.url}`);
+                    // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#name
+                    tracer.startActiveSpan(`${httpMethod} ${httpRoute === '*' ? 'APP' : httpRoute}`, 
+                    // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/http/http-spans.md#http-server-semantic-conventions
+                    { kind: SpanKind.SERVER }, activeContext, (span) => {
+                        req[REQUEST_SPAN] = span;
+                        // todo: move custom tramvai attrs to constants
+                        /**
+                         * let's add some conventions for tramvai attributes:
+                         * - `tramvai` prefix for all specific attributes in tramvai instrumentation
+                         * - `tramvai.scope` second prefix to define module, e.g. `tramvai.scope: server`
+                         * - `tramvai.*` second prefix for specific modules, e.g. `tramvai.server`
+                         * - `tramvai.server.handler` - `app` value for pages handler, another possible values - `papi`, `request-limiter`
+                         * - `tramvai.server.framework` - reserved for future, if we will add support for other server frameworks
+                         */
+                        span.setAttribute('tramvai.scope', 'server');
+                        span.setAttribute('tramvai.server.handler', 'app');
+                        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);
+                        span.setAttribute(ATTR_URL_QUERY, parsedUrl.search.replace('?', ''));
+                        span.setAttribute(ATTR_URL_SCHEME, parsedUrl.protocol.replace(':', ''));
+                        span.setAttribute(ATTR_URL_FULL, parsedUrl.href);
+                        done();
+                    });
+                });
+                app.addHook('onResponse', (req, reply) => {
+                    if (req[REQUEST_SPAN]) {
+                        const span = req[REQUEST_SPAN];
+                        if (reply.statusCode >= 400) ;
+                        else {
+                            span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
+                            // todo req/res headers?
+                            span.end();
+                        }
+                    }
+                });
+            };
+        },
+        deps: {
+            app: WEB_FASTIFY_APP_TOKEN,
+            tracer: OPENTELEMETRY_TRACER_TOKEN,
+            tracesExcludePaths: UTILITY_SERVER_PATHS,
+            envManager: ENV_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: WEB_FASTIFY_APP_AFTER_ERROR_TOKEN,
+        useFactory: (deps) => {
+            return (error, req, reply) => {
+                var _a;
+                if (req[REQUEST_SPAN]) {
+                    const span = req[REQUEST_SPAN];
+                    let httpStatus;
+                    // todo duplicated logic from packages/modules/server/src/server/error/prepareLogsForError.ts
+                    if (isNotFoundError(error)) {
+                        httpStatus = error.httpStatus || 404;
+                    }
+                    else if (isHttpError(error)) {
+                        httpStatus = error.httpStatus || 500;
+                    }
+                    else {
+                        httpStatus = error.statusCode || 500;
+                    }
+                    span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, httpStatus);
+                    // todo req/res headers?
+                    // todo "error.type" attribute?
+                    // do not set error status for incoming requests with 4xx status
+                    // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status
+                    if (httpStatus >= 500) {
+                        span.recordException(error);
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : 'Unknown error',
+                        });
+                    }
+                    span.end();
+                    // todo RootErrorBoundary is out of scope, because it is rendered after `WEB_FASTIFY_APP_AFTER_ERROR_TOKEN` hooks
+                }
+            };
+        },
+        deps: {},
+    }),
+];
+
+export { REQUEST_SPAN, providers };