@tramvai/module-opentelemetry 5.14.9

package/README.md

@@ -0,0 +1,3 @@
+# @tramvai/module-opentelemetry
+
+[Actual documentation](03-features/014-monitoring/03-telemetry.md)

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,95 @@
+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) => {
+                const url = request.url ??
+                    // todo add leading slash before path if needed
+                    (request.baseUrl ? `${request.baseUrl}${request.path}` : request.path ?? '');
+                const parsedUrl = new URL(request.query ? `${url}?${new URLSearchParams(request.query).toString()}` : url);
+                const serviceName = metricsServicesRegistry.getServiceName(url, request) ?? 'unknown';
+                const method = request.method ?? '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) => {
+                        span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, error?.status ?? 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?.open);
+    }
+}
+
+export { providers };

package/lib/instrumentation/httpClient.js

@@ -0,0 +1,99 @@
+'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) => {
+                const url = request.url ??
+                    // todo add leading slash before path if needed
+                    (request.baseUrl ? `${request.baseUrl}${request.path}` : request.path ?? '');
+                const parsedUrl = new URL(request.query ? `${url}?${new URLSearchParams(request.query).toString()}` : url);
+                const serviceName = metricsServicesRegistry.getServiceName(url, request) ?? 'unknown';
+                const method = request.method ?? '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) => {
+                        span.setAttribute(semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE, error?.status ?? 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?.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,26 @@
+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) {
+                    const activeSpanContext = trace.getSpan(context.active())?.spanContext();
+                    if (activeSpanContext) {
+                        return {
+                            ...logObj,
+                            spanId: activeSpanContext.spanId,
+                            traceId: activeSpanContext.traceId,
+                        };
+                    }
+                    return logObj;
+                },
+            });
+        },
+    }),
+];
+
+export { providers };

package/lib/instrumentation/logs.js

@@ -0,0 +1,30 @@
+'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) {
+                    const activeSpanContext = api.trace.getSpan(api.context.active())?.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,25 @@
+/// <reference types="node" />
+import { type Span } from '@opentelemetry/api';
+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;
+    };
+}, 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

@@ -0,0 +1,119 @@
+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 { 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 { 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 }) => {
+            return () => {
+                // todo copypaste from @tinkoff/measure-fastify-requests
+                const excludePatterns = flatten(tracesExcludePaths).map((p) => pathToRegexp(p));
+                app.addHook('onRequest', (req, reply, done) => {
+                    // 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 = req.routeOptions?.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);
+                        // 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,
+        },
+    }),
+    provide({
+        provide: WEB_FASTIFY_APP_AFTER_ERROR_TOKEN,
+        useFactory: (deps) => {
+            return (error, req, reply) => {
+                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: error?.message ?? 'Unknown error',
+                        });
+                    }
+                    span.end();
+                    // todo RootErrorBoundary is out of scope, because it is rendered after `WEB_FASTIFY_APP_AFTER_ERROR_TOKEN` hooks
+                }
+            };
+        },
+        deps: {},
+    }),
+];
+
+export { providers };

package/lib/instrumentation/server.js

@@ -0,0 +1,128 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var api = require('@opentelemetry/api');
+var pathToRegexp = require('path-to-regexp');
+var flatten = require('@tinkoff/utils/array/flatten');
+var errors = require('@tinkoff/errors');
+var core = require('@tramvai/core');
+var tokensServer = require('@tramvai/tokens-server');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var tokens = require('../tokens.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var pathToRegexp__default = /*#__PURE__*/_interopDefaultLegacy(pathToRegexp);
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+
+const REQUEST_SPAN = Symbol('opentelemetry.tramvai.server.request.span');
+const providers = [
+    core.provide({
+        provide: tokensServerPrivate.WEB_FASTIFY_APP_INIT_TOKEN,
+        useFactory: ({ app, tracer, tracesExcludePaths }) => {
+            return () => {
+                // todo copypaste from @tinkoff/measure-fastify-requests
+                const excludePatterns = flatten__default["default"](tracesExcludePaths).map((p) => pathToRegexp__default["default"](p));
+                app.addHook('onRequest', (req, reply, done) => {
+                    // 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 = api.propagation.extract(api.ROOT_CONTEXT, req.headers);
+                    const httpMethod = req.method;
+                    // todo useful because always get `*`, rewrite with tramvai router route?
+                    const httpRoute = req.routeOptions?.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: api.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(semanticConventions.ATTR_HTTP_REQUEST_METHOD, httpMethod);
+                        // 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);
+                        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);
+                        done();
+                    });
+                });
+                app.addHook('onResponse', (req, reply) => {
+                    if (req[REQUEST_SPAN]) {
+                        const span = req[REQUEST_SPAN];
+                        if (reply.statusCode >= 400) ;
+                        else {
+                            span.setAttribute(semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
+                            // todo req/res headers?
+                            span.end();
+                        }
+                    }
+                });
+            };
+        },
+        deps: {
+            app: tokensServerPrivate.WEB_FASTIFY_APP_TOKEN,
+            tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+            tracesExcludePaths: tokensServer.UTILITY_SERVER_PATHS,
+        },
+    }),
+    core.provide({
+        provide: tokensServerPrivate.WEB_FASTIFY_APP_AFTER_ERROR_TOKEN,
+        useFactory: (deps) => {
+            return (error, req, reply) => {
+                if (req[REQUEST_SPAN]) {
+                    const span = req[REQUEST_SPAN];
+                    let httpStatus;
+                    // todo duplicated logic from packages/modules/server/src/server/error/prepareLogsForError.ts
+                    if (errors.isNotFoundError(error)) {
+                        httpStatus = error.httpStatus || 404;
+                    }
+                    else if (errors.isHttpError(error)) {
+                        httpStatus = error.httpStatus || 500;
+                    }
+                    else {
+                        httpStatus = error.statusCode || 500;
+                    }
+                    span.setAttribute(semanticConventions.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: api.SpanStatusCode.ERROR,
+                            message: error?.message ?? 'Unknown error',
+                        });
+                    }
+                    span.end();
+                    // todo RootErrorBoundary is out of scope, because it is rendered after `WEB_FASTIFY_APP_AFTER_ERROR_TOKEN` hooks
+                }
+            };
+        },
+        deps: {},
+    }),
+];
+
+exports.providers = providers;

package/lib/server.d.ts

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

package/lib/server.es.js

@@ -0,0 +1,125 @@
+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 { 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';
+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';
+
+let OpenTelemetryModule = class OpenTelemetryModule {
+};
+OpenTelemetryModule = __decorate([
+    Module({
+        imports: [],
+        providers: [
+            ...providers,
+            ...providers$1,
+            ...providers$2,
+            provide({
+                provide: commandLineListTokens.init,
+                useFactory: ({ provider }) => {
+                    return function initializeOpenTelemetryProvider() {
+                        provider.register();
+                    };
+                },
+                deps: {
+                    provider: OPENTELEMETRY_PROVIDER_TOKEN,
+                },
+            }),
+            provide({
+                provide: commandLineListTokens.close,
+                useFactory: ({ provider, logger }) => {
+                    return function shutdownOpenTelemetryProvider() {
+                        const log = logger('opentelemetry');
+                        provider.shutdown().catch((error) => {
+                            log.error({
+                                event: 'provider-shutdown-error',
+                                error,
+                            });
+                        });
+                    };
+                },
+                deps: {
+                    provider: OPENTELEMETRY_PROVIDER_TOKEN,
+                    logger: LOGGER_TOKEN,
+                },
+            }),
+            provide({
+                provide: OPENTELEMETRY_PROVIDER_TOKEN,
+                useFactory: ({ config }) => {
+                    return new NodeTracerProvider(config);
+                },
+                deps: {
+                    config: OPENTELEMETRY_PROVIDER_CONFIG_TOKEN,
+                },
+            }),
+            // todo maybe not needed?
+            provide({
+                provide: OPENTELEMETRY_PROVIDER_CONFIG_TOKEN,
+                useFactory: ({ resource, spanProcessors }) => {
+                    return { resource, spanProcessors: spanProcessors ?? [] };
+                },
+                deps: {
+                    resource: OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN,
+                    spanProcessors: optional(OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN),
+                },
+            }),
+            provide({
+                provide: OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN,
+                useFactory: ({ attributesList }) => {
+                    const attributes = attributesList.reduce((acc, attribute) => {
+                        return {
+                            ...acc,
+                            ...attribute,
+                        };
+                    }, {});
+                    // todo async attributes
+                    return new Resource(attributes);
+                },
+                deps: {
+                    attributesList: OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
+                },
+            }),
+            provide({
+                provide: OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
+                useFactory: ({ appInfo }) => {
+                    return {
+                        [ATTR_SERVICE_NAME]: appInfo.appName,
+                    };
+                },
+                deps: {
+                    appInfo: APP_INFO_TOKEN,
+                },
+            }),
+            provide({
+                provide: OPENTELEMETRY_TRACER_TOKEN,
+                useFactory: ({ provider }) => {
+                    const tracer = provider.getTracer('tramvai', '1.0.0');
+                    return new TramvaiTracerImpl(tracer);
+                },
+                deps: {
+                    provider: OPENTELEMETRY_PROVIDER_TOKEN,
+                },
+            }),
+            // todo open telemetry debug flag or wrap ConsoleSpanExporter in logger
+            ...(process.env.NODE_ENV === 'development'
+                ? [
+                    provide({
+                        provide: OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN,
+                        useFactory: () => {
+                            return new SimpleSpanProcessor(new ConsoleSpanExporter());
+                        },
+                    }),
+                ]
+                : []),
+        ],
+    })
+], OpenTelemetryModule);
+// todo declareModule!
+
+export { OpenTelemetryModule };

package/lib/server.js

@@ -0,0 +1,133 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var resources = require('@opentelemetry/resources');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokens = require('./tokens.js');
+var tracer = require('./tracer/tracer.js');
+var server = require('./instrumentation/server.js');
+var httpClient = require('./instrumentation/httpClient.js');
+var logs = require('./instrumentation/logs.js');
+
+exports.OpenTelemetryModule = class OpenTelemetryModule {
+};
+exports.OpenTelemetryModule = tslib.__decorate([
+    core.Module({
+        imports: [],
+        providers: [
+            ...server.providers,
+            ...httpClient.providers,
+            ...logs.providers,
+            core.provide({
+                provide: core.commandLineListTokens.init,
+                useFactory: ({ provider }) => {
+                    return function initializeOpenTelemetryProvider() {
+                        provider.register();
+                    };
+                },
+                deps: {
+                    provider: tokens.OPENTELEMETRY_PROVIDER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.close,
+                useFactory: ({ provider, logger }) => {
+                    return function shutdownOpenTelemetryProvider() {
+                        const log = logger('opentelemetry');
+                        provider.shutdown().catch((error) => {
+                            log.error({
+                                event: 'provider-shutdown-error',
+                                error,
+                            });
+                        });
+                    };
+                },
+                deps: {
+                    provider: tokens.OPENTELEMETRY_PROVIDER_TOKEN,
+                    logger: tokensCommon.LOGGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokens.OPENTELEMETRY_PROVIDER_TOKEN,
+                useFactory: ({ config }) => {
+                    return new sdkTraceNode.NodeTracerProvider(config);
+                },
+                deps: {
+                    config: tokens.OPENTELEMETRY_PROVIDER_CONFIG_TOKEN,
+                },
+            }),
+            // todo maybe not needed?
+            core.provide({
+                provide: tokens.OPENTELEMETRY_PROVIDER_CONFIG_TOKEN,
+                useFactory: ({ resource, spanProcessors }) => {
+                    return { resource, spanProcessors: spanProcessors ?? [] };
+                },
+                deps: {
+                    resource: tokens.OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN,
+                    spanProcessors: core.optional(tokens.OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN),
+                },
+            }),
+            core.provide({
+                provide: tokens.OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN,
+                useFactory: ({ attributesList }) => {
+                    const attributes = attributesList.reduce((acc, attribute) => {
+                        return {
+                            ...acc,
+                            ...attribute,
+                        };
+                    }, {});
+                    // todo async attributes
+                    return new resources.Resource(attributes);
+                },
+                deps: {
+                    attributesList: tokens.OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokens.OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN,
+                useFactory: ({ appInfo }) => {
+                    return {
+                        [semanticConventions.ATTR_SERVICE_NAME]: appInfo.appName,
+                    };
+                },
+                deps: {
+                    appInfo: core.APP_INFO_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);
+                },
+                deps: {
+                    provider: tokens.OPENTELEMETRY_PROVIDER_TOKEN,
+                },
+            }),
+            // todo open telemetry debug flag or wrap ConsoleSpanExporter in logger
+            ...(process.env.NODE_ENV === 'development'
+                ? [
+                    core.provide({
+                        provide: tokens.OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN,
+                        useFactory: () => {
+                            return new sdkTraceNode.SimpleSpanProcessor(new sdkTraceNode.ConsoleSpanExporter());
+                        },
+                    }),
+                ]
+                : []),
+        ],
+    })
+], exports.OpenTelemetryModule);
+// todo declareModule!
+
+exports.OPENTELEMETRY_PROVIDER_CONFIG_TOKEN = tokens.OPENTELEMETRY_PROVIDER_CONFIG_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN = tokens.OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN = tokens.OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = tokens.OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_TOKEN = tokens.OPENTELEMETRY_PROVIDER_TOKEN;
+exports.OPENTELEMETRY_TRACER_TOKEN = tokens.OPENTELEMETRY_TRACER_TOKEN;

package/lib/tokens.browser.js

@@ -0,0 +1,10 @@
+import { createToken, Scope } from '@tinkoff/dippy';
+
+const OPENTELEMETRY_PROVIDER_TOKEN = createToken('tramvai opentelemetry provider', { scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_CONFIG_TOKEN = createToken('tramvai opentelemetry provider config', { scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = createToken('tramvai opentelemetry provider span processor', { multi: true, scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN = createToken('tramvai opentelemetry provider resource', { scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN = createToken('tramvai opentelemetry provider resource attributes', { multi: true, scope: Scope.SINGLETON });
+const OPENTELEMETRY_TRACER_TOKEN = createToken('tramvai opentelemetry tracer', { scope: Scope.SINGLETON });
+
+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 };

package/lib/tokens.d.ts

@@ -0,0 +1,38 @@
+import type { Context, Span, SpanOptions } from '@opentelemetry/api';
+import type { SpanProcessor, TracerConfig, BasicTracerProvider } from '@opentelemetry/sdk-trace-node';
+import type { Resource } from '@opentelemetry/resources';
+/**
+ * API inspired by:
+ * - https://github.com/DataDog/dd-trace-js/blob/59e9a2a75f4256755b4e6c9951a0bdf8d39b4015/index.d.ts#L9
+ * - https://github.com/vercel/next.js/blob/9a1cd356dbafbfcf23d1b9ec05f772f766d05580/packages/next/src/server/lib/trace/tracer.ts#L74
+ */
+export interface TramvaiTracer {
+    startSpan(name: string, options?: SpanOptions, context?: Context): 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, 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;
+}
+export declare const OPENTELEMETRY_PROVIDER_TOKEN: BasicTracerProvider & {
+    __type?: "base token" | undefined;
+};
+export declare const OPENTELEMETRY_PROVIDER_CONFIG_TOKEN: TracerConfig & {
+    __type?: "base token" | undefined;
+};
+export declare const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN: SpanProcessor & {
+    __type?: "multi token" | undefined;
+};
+export declare const OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN: Resource & {
+    __type?: "base token" | undefined;
+};
+export declare const OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN: import("@opentelemetry/api").Attributes & {
+    __type?: "multi token" | undefined;
+};
+export declare const OPENTELEMETRY_TRACER_TOKEN: TramvaiTracer & {
+    __type?: "base token" | undefined;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -0,0 +1,10 @@
+import { createToken, Scope } from '@tinkoff/dippy';
+
+const OPENTELEMETRY_PROVIDER_TOKEN = createToken('tramvai opentelemetry provider', { scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_CONFIG_TOKEN = createToken('tramvai opentelemetry provider config', { scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = createToken('tramvai opentelemetry provider span processor', { multi: true, scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN = createToken('tramvai opentelemetry provider resource', { scope: Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN = createToken('tramvai opentelemetry provider resource attributes', { multi: true, scope: Scope.SINGLETON });
+const OPENTELEMETRY_TRACER_TOKEN = createToken('tramvai opentelemetry tracer', { scope: Scope.SINGLETON });
+
+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 };

package/lib/tokens.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+
+const OPENTELEMETRY_PROVIDER_TOKEN = dippy.createToken('tramvai opentelemetry provider', { scope: dippy.Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_CONFIG_TOKEN = dippy.createToken('tramvai opentelemetry provider config', { scope: dippy.Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = dippy.createToken('tramvai opentelemetry provider span processor', { multi: true, scope: dippy.Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN = dippy.createToken('tramvai opentelemetry provider resource', { scope: dippy.Scope.SINGLETON });
+const OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN = dippy.createToken('tramvai opentelemetry provider resource attributes', { multi: true, scope: dippy.Scope.SINGLETON });
+const OPENTELEMETRY_TRACER_TOKEN = dippy.createToken('tramvai opentelemetry tracer', { scope: dippy.Scope.SINGLETON });
+
+exports.OPENTELEMETRY_PROVIDER_CONFIG_TOKEN = OPENTELEMETRY_PROVIDER_CONFIG_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN = OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN = OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN;
+exports.OPENTELEMETRY_PROVIDER_TOKEN = OPENTELEMETRY_PROVIDER_TOKEN;
+exports.OPENTELEMETRY_TRACER_TOKEN = OPENTELEMETRY_TRACER_TOKEN;

package/lib/tracer/tracer.d.ts

@@ -0,0 +1,16 @@
+import type { Context, Span, SpanOptions, Tracer } from '@opentelemetry/api';
+import type { TramvaiTracer } from '../tokens';
+export declare class TramvaiTracerImpl implements TramvaiTracer {
+    private tracer;
+    constructor(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;
+}
+//# sourceMappingURL=tracer.d.ts.map

package/lib/tracer/tracer.es.js

@@ -0,0 +1,70 @@
+import isPromise from '@tinkoff/utils/is/promise';
+import { trace, context, ROOT_CONTEXT, SpanStatusCode } from '@opentelemetry/api';
+
+/* eslint-disable prefer-destructuring */
+function recordAndThrowError(span, error) {
+    span.recordException(error);
+    span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error?.message ?? 'Unknown error',
+    });
+    span.end();
+    throw error;
+}
+class TramvaiTracerImpl {
+    constructor(tracer) {
+        this.tracer = tracer;
+    }
+    startSpan(...args) {
+        // @ts-expect-error
+        return this.tracer.startSpan(...args);
+    }
+    startActiveSpan(...args) {
+        // @ts-expect-error
+        return this.tracer.startActiveSpan(...args);
+    }
+    getActiveSpan() {
+        return trace.getSpan(context.active());
+    }
+    trace(...args) {
+        const name = args[0];
+        let fn;
+        let options;
+        if (args.length === 2) {
+            fn = args[1];
+            options = {};
+        }
+        else {
+            fn = args[2];
+            options = args[1];
+        }
+        const activeSpan = trace.getSpan(context.active());
+        const spanContext = activeSpan ? trace.setSpan(context.active(), activeSpan) : undefined;
+        const ctx = spanContext ?? context.active() ?? ROOT_CONTEXT;
+        return this.startActiveSpan(name, options, ctx, (span) => {
+            try {
+                const result = fn(span);
+                // wrap promise fn, end span if promise is resolved or rejected
+                if (isPromise(result)) {
+                    return result
+                        .then((res) => {
+                        span.end();
+                        return res;
+                    })
+                        .catch((error) => {
+                        recordAndThrowError(span, error);
+                    });
+                }
+                // otherwise, end span immediately
+                span.end();
+                return result;
+            }
+            catch (error) {
+                recordAndThrowError(span, error);
+            }
+        });
+    }
+}
+/* eslint-enable prefer-destructuring */
+
+export { TramvaiTracerImpl };

package/lib/tracer/tracer.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isPromise = require('@tinkoff/utils/is/promise');
+var api = require('@opentelemetry/api');
+
+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) {
+    span.recordException(error);
+    span.setStatus({
+        code: api.SpanStatusCode.ERROR,
+        message: error?.message ?? 'Unknown error',
+    });
+    span.end();
+    throw error;
+}
+class TramvaiTracerImpl {
+    constructor(tracer) {
+        this.tracer = tracer;
+    }
+    startSpan(...args) {
+        // @ts-expect-error
+        return this.tracer.startSpan(...args);
+    }
+    startActiveSpan(...args) {
+        // @ts-expect-error
+        return this.tracer.startActiveSpan(...args);
+    }
+    getActiveSpan() {
+        return api.trace.getSpan(api.context.active());
+    }
+    trace(...args) {
+        const name = args[0];
+        let fn;
+        let options;
+        if (args.length === 2) {
+            fn = args[1];
+            options = {};
+        }
+        else {
+            fn = args[2];
+            options = args[1];
+        }
+        const activeSpan = api.trace.getSpan(api.context.active());
+        const spanContext = activeSpan ? api.trace.setSpan(api.context.active(), activeSpan) : undefined;
+        const ctx = spanContext ?? api.context.active() ?? api.ROOT_CONTEXT;
+        return this.startActiveSpan(name, options, ctx, (span) => {
+            try {
+                const result = fn(span);
+                // wrap promise fn, end span if promise is resolved or rejected
+                if (isPromise__default["default"](result)) {
+                    return result
+                        .then((res) => {
+                        span.end();
+                        return res;
+                    })
+                        .catch((error) => {
+                        recordAndThrowError(span, error);
+                    });
+                }
+                // otherwise, end span immediately
+                span.end();
+                return result;
+            }
+            catch (error) {
+                recordAndThrowError(span, error);
+            }
+        });
+    }
+}
+/* eslint-enable prefer-destructuring */
+
+exports.TramvaiTracerImpl = TramvaiTracerImpl;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@tramvai/module-opentelemetry",
+  "version": "5.14.9",
+  "description": "Интеграция OpenTelemetry",
+  "browser": "lib/browser.js",
+  "main": "lib/server.js",
+  "module": "lib/server.es.js",
+  "typings": "lib/server.d.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/tramvaijs/tramvai.git"
+  },
+  "scripts": {
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/resources": "^1.28.0",
+    "@opentelemetry/sdk-trace-node": "^1.28.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
+    "path-to-regexp": "0.1.7",
+    "@tramvai/tokens-common": "5.14.9",
+    "@tramvai/tokens-metrics": "5.14.9",
+    "@tramvai/tokens-http-client": "5.14.9",
+    "@tramvai/tokens-server": "5.14.9",
+    "@tramvai/tokens-server-private": "5.14.9",
+    "@tinkoff/utils": "^2.1.2",
+    "@tinkoff/errors": "0.6.2"
+  },
+  "devDependencies": {},
+  "peerDependencies": {
+    "@tinkoff/dippy": "0.11.3",
+    "@tramvai/core": "5.14.9",
+    "tslib": "^2.4.0"
+  }
+}