@tramvai/module-opentelemetry 4.41.99

package/lib/instrumentation/server.js

@@ -0,0 +1,135 @@
+'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 tokensCommon = require('@tramvai/tokens-common');
+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, envManager }) => {
+            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) => {
+                    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 = api.propagation.extract(api.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: 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);
+                        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);
+                        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,
+            envManager: tokensCommon.ENV_MANAGER_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensServerPrivate.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 (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: (_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: {},
+    }),
+];
+
+exports.REQUEST_SPAN = REQUEST_SPAN;
+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,127 @@
+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, 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';
+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 !== null && spanProcessors !== void 0 ? 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, 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 });
+                },
+                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,135 @@
+'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 !== null && spanProcessors !== void 0 ? 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, 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: 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,41 @@
+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
+ * - 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>, 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;
+};
+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,18 @@
+import type { Context, Span, SpanOptions, Tracer } from '@opentelemetry/api';
+import type { TraceParams, TramvaiTracer } from '../tokens';
+export declare class TramvaiTracerImpl implements TramvaiTracer {
+    private 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>, 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

@@ -0,0 +1,78 @@
+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, { skipError = () => false }) {
+    var _a;
+    span.recordException(error);
+    if (!(skipError(error) || isSilentError(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();
+    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) {
+        var _a;
+        const name = args[0];
+        let fn;
+        let options;
+        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;
+        const ctx = (_a = spanContext !== null && spanContext !== void 0 ? spanContext : context.active()) !== null && _a !== void 0 ? _a : 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, params);
+                    });
+                }
+                // otherwise, end span immediately
+                span.end();
+                return result;
+            }
+            catch (error) {
+                recordAndThrowError(span, error, params);
+            }
+        });
+    }
+}
+/* eslint-enable prefer-destructuring */
+
+export { TramvaiTracerImpl };