@tramvai/module-opentelemetry 5.50.0 → 6.59.0

package/lib/browser.js

@@ -1,13 +1,50 @@
 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';
+import { Module, provide } from '@tramvai/core';
+import once from '@tinkoff/utils/function/once';
+import { DEFAULT_HTTP_CLIENT_INTERCEPTORS } from '@tramvai/tokens-http-client';
+import { OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN } from './tokens.browser.js';
+export { OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN, 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';
 
+const extractTraceparentHeader = once(() => {
+    if (typeof window !== 'undefined') {
+        const traceparentMeta = Array.from(document.getElementsByTagName('meta')).filter((element) => element.name === 'traceparent');
+        if (traceparentMeta.length !== 1) {
+            return undefined;
+        }
+        return traceparentMeta[0].content;
+    }
+    return undefined;
+});
 let OpenTelemetryModule = class OpenTelemetryModule {
 };
 OpenTelemetryModule = __decorate([
     Module({
         imports: [],
-        providers: [],
+        providers: [
+            provide({
+                provide: DEFAULT_HTTP_CLIENT_INTERCEPTORS,
+                useFactory: ({ headerInclude }) => (req, next) => {
+                    const url = req.url ?? (req.baseUrl ? `${req.baseUrl}${req.path}` : (req.path ?? ''));
+                    if (!headerInclude(url)) {
+                        return next(req);
+                    }
+                    return next({
+                        ...req,
+                        headers: {
+                            traceparent: extractTraceparentHeader(),
+                            ...req.headers,
+                        },
+                    });
+                },
+                deps: {
+                    headerInclude: OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN,
+                },
+            }),
+            provide({
+                provide: OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN,
+                useValue: () => true,
+            }),
+        ],
     })
 ], OpenTelemetryModule);
 // todo declareModule!

package/lib/instrumentation/childApp/configResolution.d.ts

@@ -0,0 +1,9 @@
+import { type ChildAppConfigResolutionPlugin } from '@tramvai/tokens-child-app';
+export declare const providers: import("@tinkoff/dippy").Provider<{
+    tracer: import("../../tokens").TramvaiTracer & {
+        __type?: "base token" | undefined;
+    };
+}, ChildAppConfigResolutionPlugin & {
+    __type?: "multi token" | undefined;
+}>[];
+//# sourceMappingURL=configResolution.d.ts.map

package/lib/instrumentation/childApp/configResolution.es.js

@@ -0,0 +1,31 @@
+import { provide } from '@tinkoff/dippy';
+import { SpanKind } from '@opentelemetry/api';
+import { CHILD_APP_CONFIG_RESOLUTION_PLUGIN } from '@tramvai/tokens-child-app';
+import { OPENTELEMETRY_TRACER_TOKEN } from '../../tokens.es.js';
+
+class ChildAppConfigResolutionOpenTelemetryPlugin {
+    tracer;
+    constructor({ tracer }) {
+        this.tracer = tracer;
+    }
+    apply(hooks) {
+        hooks.fetchConfig.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app fetch config', { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app.fetch_config');
+                const configs = await next(payload);
+                return configs;
+            });
+        });
+    }
+}
+const providers = [
+    provide({
+        provide: CHILD_APP_CONFIG_RESOLUTION_PLUGIN,
+        useClass: ChildAppConfigResolutionOpenTelemetryPlugin,
+        deps: {
+            tracer: OPENTELEMETRY_TRACER_TOKEN,
+        },
+    }),
+];
+
+export { providers };

package/lib/instrumentation/childApp/configResolution.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+var api = require('@opentelemetry/api');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokens = require('../../tokens.js');
+
+class ChildAppConfigResolutionOpenTelemetryPlugin {
+    tracer;
+    constructor({ tracer }) {
+        this.tracer = tracer;
+    }
+    apply(hooks) {
+        hooks.fetchConfig.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app fetch config', { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app.fetch_config');
+                const configs = await next(payload);
+                return configs;
+            });
+        });
+    }
+}
+const providers = [
+    dippy.provide({
+        provide: tokensChildApp.CHILD_APP_CONFIG_RESOLUTION_PLUGIN,
+        useClass: ChildAppConfigResolutionOpenTelemetryPlugin,
+        deps: {
+            tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+        },
+    }),
+];
+
+exports.providers = providers;

package/lib/instrumentation/childApp/loader.d.ts

@@ -0,0 +1,9 @@
+import { type ChildAppLoaderPlugin } from '@tramvai/tokens-child-app';
+export declare const providers: import("@tinkoff/dippy").Provider<{
+    tracer: import("../../tokens").TramvaiTracer & {
+        __type?: "base token" | undefined;
+    };
+}, ChildAppLoaderPlugin & {
+    __type?: "multi token" | undefined;
+}>[];
+//# sourceMappingURL=loader.d.ts.map

package/lib/instrumentation/childApp/loader.es.js

@@ -0,0 +1,39 @@
+import { provide, Scope } from '@tinkoff/dippy';
+import { SpanKind } from '@opentelemetry/api';
+import { CHILD_APP_LOADER_PLUGIN } from '@tramvai/tokens-child-app';
+import { OPENTELEMETRY_TRACER_TOKEN } from '../../tokens.es.js';
+
+class ChildAppLoaderOpenTelemetryPlugin {
+    tracer;
+    constructor({ tracer }) {
+        this.tracer = tracer;
+    }
+    apply(hooks) {
+        hooks.loadModule.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app load', { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app');
+                span.setAttribute('tramvai.child_app.name', payload.config.name);
+                span.setAttribute('tramvai.child_app.version', payload.config.version);
+                span.setAttribute('tramvai.child_app.tag', payload.config.tag);
+                span.setAttribute('tramvai.child_app.client.baseUrl', payload.config.client.baseUrl);
+                span.setAttribute('tramvai.child_app.client.entry', payload.config.client.entry);
+                span.setAttribute('tramvai.child_app.client.stats', payload.config.client.stats);
+                span.setAttribute('tramvai.child_app.client.statsLoadable', payload.config.client.statsLoadable);
+                const childApp = await next(payload);
+                return childApp;
+            });
+        });
+    }
+}
+const providers = [
+    provide({
+        scope: Scope.SINGLETON,
+        provide: CHILD_APP_LOADER_PLUGIN,
+        useClass: ChildAppLoaderOpenTelemetryPlugin,
+        deps: {
+            tracer: OPENTELEMETRY_TRACER_TOKEN,
+        },
+    }),
+];
+
+export { providers };

package/lib/instrumentation/childApp/loader.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+var api = require('@opentelemetry/api');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokens = require('../../tokens.js');
+
+class ChildAppLoaderOpenTelemetryPlugin {
+    tracer;
+    constructor({ tracer }) {
+        this.tracer = tracer;
+    }
+    apply(hooks) {
+        hooks.loadModule.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app load', { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app');
+                span.setAttribute('tramvai.child_app.name', payload.config.name);
+                span.setAttribute('tramvai.child_app.version', payload.config.version);
+                span.setAttribute('tramvai.child_app.tag', payload.config.tag);
+                span.setAttribute('tramvai.child_app.client.baseUrl', payload.config.client.baseUrl);
+                span.setAttribute('tramvai.child_app.client.entry', payload.config.client.entry);
+                span.setAttribute('tramvai.child_app.client.stats', payload.config.client.stats);
+                span.setAttribute('tramvai.child_app.client.statsLoadable', payload.config.client.statsLoadable);
+                const childApp = await next(payload);
+                return childApp;
+            });
+        });
+    }
+}
+const providers = [
+    dippy.provide({
+        scope: dippy.Scope.SINGLETON,
+        provide: tokensChildApp.CHILD_APP_LOADER_PLUGIN,
+        useClass: ChildAppLoaderOpenTelemetryPlugin,
+        deps: {
+            tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+        },
+    }),
+];
+
+exports.providers = providers;

package/lib/instrumentation/childApp/preload.d.ts

@@ -0,0 +1,9 @@
+import { type ChildAppPreloadManagerPlugin } from '@tramvai/tokens-child-app';
+export declare const providers: import("@tinkoff/dippy").Provider<{
+    tracer: import("../../tokens").TramvaiTracer & {
+        __type?: "base token" | undefined;
+    };
+}, ChildAppPreloadManagerPlugin & {
+    __type?: "multi token" | undefined;
+}>[];
+//# sourceMappingURL=preload.d.ts.map

package/lib/instrumentation/childApp/preload.es.js

@@ -0,0 +1,44 @@
+import { provide } from '@tinkoff/dippy';
+import { SpanKind } from '@opentelemetry/api';
+import { CHILD_APP_PRELOAD_MANAGER_PLUGIN } from '@tramvai/tokens-child-app';
+import { OPENTELEMETRY_TRACER_TOKEN } from '../../tokens.es.js';
+
+class ChildAppPreloadManagerOpenTelemetryPlugin {
+    tracer;
+    constructor({ tracer }) {
+        this.tracer = tracer;
+    }
+    apply(hooks) {
+        hooks.preloadChildApp.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app preload', { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app');
+                span.setAttribute('tramvai.child_app.name', payload.config.name);
+                span.setAttribute('tramvai.child_app.version', payload.config.version);
+                span.setAttribute('tramvai.child_app.tag', payload.config.tag);
+                await next(payload);
+            });
+        });
+        hooks.runChildAppCommandLine.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app run command line', { kind: SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app');
+                span.setAttribute('tramvai.child_app.name', payload.config.name);
+                span.setAttribute('tramvai.child_app.version', payload.config.version);
+                span.setAttribute('tramvai.child_app.tag', payload.config.tag);
+                span.setAttribute('tramvai.child_app.line', payload.line);
+                span.setAttribute('tramvai.child_app.status', payload.status);
+                await next(payload);
+            });
+        });
+    }
+}
+const providers = [
+    provide({
+        provide: CHILD_APP_PRELOAD_MANAGER_PLUGIN,
+        useClass: ChildAppPreloadManagerOpenTelemetryPlugin,
+        deps: {
+            tracer: OPENTELEMETRY_TRACER_TOKEN,
+        },
+    }),
+];
+
+export { providers };

package/lib/instrumentation/childApp/preload.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dippy = require('@tinkoff/dippy');
+var api = require('@opentelemetry/api');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokens = require('../../tokens.js');
+
+class ChildAppPreloadManagerOpenTelemetryPlugin {
+    tracer;
+    constructor({ tracer }) {
+        this.tracer = tracer;
+    }
+    apply(hooks) {
+        hooks.preloadChildApp.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app preload', { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app');
+                span.setAttribute('tramvai.child_app.name', payload.config.name);
+                span.setAttribute('tramvai.child_app.version', payload.config.version);
+                span.setAttribute('tramvai.child_app.tag', payload.config.tag);
+                await next(payload);
+            });
+        });
+        hooks.runChildAppCommandLine.wrap(async (_, payload, next) => {
+            return this.tracer.trace('child app run command line', { kind: api.SpanKind.SERVER }, async (span) => {
+                span.setAttribute('tramvai.scope', 'child_app');
+                span.setAttribute('tramvai.child_app.name', payload.config.name);
+                span.setAttribute('tramvai.child_app.version', payload.config.version);
+                span.setAttribute('tramvai.child_app.tag', payload.config.tag);
+                span.setAttribute('tramvai.child_app.line', payload.line);
+                span.setAttribute('tramvai.child_app.status', payload.status);
+                await next(payload);
+            });
+        });
+    }
+}
+const providers = [
+    dippy.provide({
+        provide: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_PLUGIN,
+        useClass: ChildAppPreloadManagerOpenTelemetryPlugin,
+        deps: {
+            tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+        },
+    }),
+];
+
+exports.providers = providers;

package/lib/instrumentation/commandLineRunner.es.js

@@ -4,6 +4,7 @@ import { SpanKind } from '@opentelemetry/api';
 import { OPENTELEMETRY_TRACER_TOKEN } from '../tokens.es.js';
 
 class CommandLineRunnerOpenTelemetryPlugin {
+    tracer;
     constructor({ tracer }) {
         this.tracer = tracer;
     }

package/lib/instrumentation/commandLineRunner.js

@@ -8,6 +8,7 @@ var api = require('@opentelemetry/api');
 var tokens = require('../tokens.js');
 
 class CommandLineRunnerOpenTelemetryPlugin {
+    tracer;
     constructor({ tracer }) {
         this.tracer = tracer;
     }

package/lib/instrumentation/httpClient.es.js

@@ -1,7 +1,7 @@
 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 { 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';
 
@@ -16,21 +16,18 @@ const providers = [
                 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) {
+                const { traceparent, tracestate } = tracer.propagateContext();
+                if (traceparent !== undefined) {
                     if (!request.headers) {
                         request.headers = {};
                     }
-                    request.headers.traceparent = output.traceparent;
+                    request.headers.traceparent = traceparent;
                 }
-                if (output.tracestate) {
+                if (tracestate !== undefined) {
                     if (!request.headers) {
                         request.headers = {};
                     }
-                    request.headers.tracestate = output.tracestate;
+                    request.headers.tracestate = 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) => {

package/lib/instrumentation/httpClient.js

@@ -20,21 +20,18 @@ const providers = [
                 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) {
+                const { traceparent, tracestate } = tracer.propagateContext();
+                if (traceparent !== undefined) {
                     if (!request.headers) {
                         request.headers = {};
                     }
-                    request.headers.traceparent = output.traceparent;
+                    request.headers.traceparent = traceparent;
                 }
-                if (output.tracestate) {
+                if (tracestate !== undefined) {
                     if (!request.headers) {
                         request.headers = {};
                     }
-                    request.headers.tracestate = output.tracestate;
+                    request.headers.tracestate = 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) => {

package/lib/instrumentation/router.es.js

@@ -11,6 +11,8 @@ function skipError(error) {
     return isRedirectFoundError(error) || isNotFoundError(error);
 }
 class OpentelemetryRouterPlugin {
+    tracer;
+    request;
     constructor({ tracer, request }) {
         this.tracer = tracer;
         this.request = request;

package/lib/instrumentation/router.js

@@ -15,6 +15,8 @@ function skipError(error) {
     return errors.isRedirectFoundError(error) || errors.isNotFoundError(error);
 }
 class OpentelemetryRouterPlugin {
+    tracer;
+    request;
     constructor({ tracer, request }) {
         this.tracer = tracer;
         this.request = request;

package/lib/server.es.js

@@ -4,14 +4,19 @@ import { NodeTracerProvider, SimpleSpanProcessor, ConsoleSpanExporter } from '@o
 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 { ResourceSlot, ResourceType, RESOURCES_REGISTRY } from '@tramvai/tokens-render';
+import { OPENTELEMETRY_PROVIDER_TOKEN, OPENTELEMETRY_TRACER_TOKEN, OPENTELEMETRY_PROVIDER_CONFIG_TOKEN, OPENTELEMETRY_PROVIDER_RESOURCE_TOKEN, OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN, OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN } from './tokens.es.js';
+export { OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN, 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';
-import { providers as providers$3 } from './instrumentation/commandLineRunner.es.js';
-import { providers as providers$4 } from './instrumentation/router.es.js';
+import { providers as providers$3 } from './instrumentation/server.es.js';
+import { providers as providers$4 } from './instrumentation/httpClient.es.js';
+import { providers as providers$5 } from './instrumentation/logs.es.js';
+import { providers as providers$6 } from './instrumentation/commandLineRunner.es.js';
+import { providers as providers$7 } from './instrumentation/router.es.js';
+import { providers } from './instrumentation/childApp/configResolution.es.js';
+import { providers as providers$1 } from './instrumentation/childApp/loader.es.js';
+import { providers as providers$2 } from './instrumentation/childApp/preload.es.js';
+import { getTraceparentHeader } from './tracer/get-traceparent-header.es.js';
 
 let OpenTelemetryModule = class OpenTelemetryModule {
 };
@@ -24,6 +29,9 @@ OpenTelemetryModule = __decorate([
             ...providers$2,
             ...providers$3,
             ...providers$4,
+            ...providers$5,
+            ...providers$6,
+            ...providers$7,
             provide({
                 provide: commandLineListTokens.init,
                 useFactory: ({ provider }) => {
@@ -53,6 +61,25 @@ OpenTelemetryModule = __decorate([
                     logger: LOGGER_TOKEN,
                 },
             }),
+            provide({
+                provide: commandLineListTokens.customerStart,
+                useFactory: ({ tracer, resourcesRegistry }) => {
+                    return function insertTraceIdToResourcesRegistry() {
+                        const traceparent = getTraceparentHeader(tracer);
+                        if (traceparent !== undefined) {
+                            resourcesRegistry.register({
+                                slot: ResourceSlot.HEAD_META,
+                                type: ResourceType.meta,
+                                payload: `<meta name="traceparent" content="${traceparent}">`,
+                            });
+                        }
+                    };
+                },
+                deps: {
+                    tracer: OPENTELEMETRY_TRACER_TOKEN,
+                    resourcesRegistry: RESOURCES_REGISTRY,
+                },
+            }),
             provide({
                 provide: OPENTELEMETRY_PROVIDER_TOKEN,
                 useFactory: ({ config }) => {

package/lib/server.js

@@ -8,6 +8,7 @@ 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 tokensRender = require('@tramvai/tokens-render');
 var tokens = require('./tokens.js');
 var tracer = require('./tracer/tracer.js');
 var server = require('./instrumentation/server.js');
@@ -15,6 +16,10 @@ var httpClient = require('./instrumentation/httpClient.js');
 var logs = require('./instrumentation/logs.js');
 var commandLineRunner = require('./instrumentation/commandLineRunner.js');
 var router = require('./instrumentation/router.js');
+var configResolution = require('./instrumentation/childApp/configResolution.js');
+var loader = require('./instrumentation/childApp/loader.js');
+var preload = require('./instrumentation/childApp/preload.js');
+var getTraceparentHeader = require('./tracer/get-traceparent-header.js');
 
 exports.OpenTelemetryModule = class OpenTelemetryModule {
 };
@@ -22,6 +27,9 @@ exports.OpenTelemetryModule = tslib.__decorate([
     core.Module({
         imports: [],
         providers: [
+            ...configResolution.providers,
+            ...loader.providers,
+            ...preload.providers,
             ...server.providers,
             ...httpClient.providers,
             ...logs.providers,
@@ -56,6 +64,25 @@ exports.OpenTelemetryModule = tslib.__decorate([
                     logger: tokensCommon.LOGGER_TOKEN,
                 },
             }),
+            core.provide({
+                provide: core.commandLineListTokens.customerStart,
+                useFactory: ({ tracer, resourcesRegistry }) => {
+                    return function insertTraceIdToResourcesRegistry() {
+                        const traceparent = getTraceparentHeader.getTraceparentHeader(tracer);
+                        if (traceparent !== undefined) {
+                            resourcesRegistry.register({
+                                slot: tokensRender.ResourceSlot.HEAD_META,
+                                type: tokensRender.ResourceType.meta,
+                                payload: `<meta name="traceparent" content="${traceparent}">`,
+                            });
+                        }
+                    };
+                },
+                deps: {
+                    tracer: tokens.OPENTELEMETRY_TRACER_TOKEN,
+                    resourcesRegistry: tokensRender.RESOURCES_REGISTRY,
+                },
+            }),
             core.provide({
                 provide: tokens.OPENTELEMETRY_PROVIDER_TOKEN,
                 useFactory: ({ config }) => {
@@ -131,6 +158,7 @@ exports.OpenTelemetryModule = tslib.__decorate([
 ], exports.OpenTelemetryModule);
 // todo declareModule!
 
+exports.OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN = tokens.OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN;
 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;

package/lib/tokens.browser.js

@@ -6,5 +6,6 @@ const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = createToken('tramvai opentel
 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 });
+const OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN = createToken('tramvai opentelemetry http client browser traceparent header filter');
 
-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 };
+export { OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN, 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

@@ -4,6 +4,20 @@ import type { Resource } from '@opentelemetry/resources';
 export type TraceParams = {
     skipError?: (error: Error) => boolean;
 };
+export type PropagationCarrier = {
+    /**
+     * Traceparent context appropriate W3C format:
+     * `version-traceId-spanId-sampled`.
+     *
+     * version – There is only `00` version at the moment.
+     * sampled – Was trace sampled. We are sampling all the traces currently.
+     *
+     * @see https://www.w3.org/TR/trace-context/#version
+     * @see https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/plugins/web/opentelemetry-instrumentation-document-load#optional-send-a-trace-parent-from-your-server
+     */
+    traceparent?: string;
+    tracestate?: string;
+};
 /**
  * API inspired by:
  * - https://github.com/DataDog/dd-trace-js/blob/59e9a2a75f4256755b4e6c9951a0bdf8d39b4015/index.d.ts#L9
@@ -19,6 +33,7 @@ export interface TramvaiTracer {
     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;
+    propagateContext(carrier?: PropagationCarrier): PropagationCarrier;
 }
 export declare const OPENTELEMETRY_PROVIDER_TOKEN: BasicTracerProvider & {
     __type?: "base token" | undefined;
@@ -38,4 +53,7 @@ export declare const OPENTELEMETRY_PROVIDER_RESOURCE_ATTRIBUTES_TOKEN: import("@
 export declare const OPENTELEMETRY_TRACER_TOKEN: TramvaiTracer & {
     __type?: "base token" | undefined;
 };
+export declare const OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN: ((url: string) => boolean) & {
+    __type?: "base token" | undefined;
+};
 //# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -6,5 +6,6 @@ const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = createToken('tramvai opentel
 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 });
+const OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN = createToken('tramvai opentelemetry http client browser traceparent header filter');
 
-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 };
+export { OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN, 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

@@ -10,7 +10,9 @@ const OPENTELEMETRY_PROVIDER_SPAN_PROCESSOR_TOKEN = dippy.createToken('tramvai o
 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 });
+const OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN = dippy.createToken('tramvai opentelemetry http client browser traceparent header filter');
 
+exports.OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN = OPENTELEMETRY_HTTP_CLIENT_BROWSER_HEADERS_INCLUDE_TOKEN;
 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;

package/lib/tracer/get-traceparent-header.d.ts

@@ -0,0 +1,3 @@
+import { TramvaiTracer } from '../tokens';
+export declare const getTraceparentHeader: (tracer: TramvaiTracer) => string | undefined;
+//# sourceMappingURL=get-traceparent-header.d.ts.map

package/lib/tracer/get-traceparent-header.es.js

@@ -0,0 +1,3 @@
+const getTraceparentHeader = (tracer) => tracer.propagateContext().traceparent;
+
+export { getTraceparentHeader };

package/lib/tracer/get-traceparent-header.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const getTraceparentHeader = (tracer) => tracer.propagateContext().traceparent;
+
+exports.getTraceparentHeader = getTraceparentHeader;

package/lib/tracer/tracer.d.ts

@@ -1,5 +1,5 @@
-import type { Context, Span, SpanOptions, Tracer } from '@opentelemetry/api';
-import type { TraceParams, TramvaiTracer } from '../tokens';
+import { Context, Span, SpanOptions, Tracer } from '@opentelemetry/api';
+import { PropagationCarrier, TraceParams, TramvaiTracer } from '../tokens';
 export declare class TramvaiTracerImpl implements TramvaiTracer {
     private tracer;
     constructor({ tracer }: {
@@ -14,5 +14,12 @@ export declare class TramvaiTracerImpl implements TramvaiTracer {
     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;
+    /**
+     * Propagate context from outgoing request
+     * @param carrier
+     *
+     * @see https://opentelemetry.io/docs/languages/js/propagation/#manual-context-propagation
+     */
+    propagateContext(carrier?: PropagationCarrier): PropagationCarrier;
 }
 //# sourceMappingURL=tracer.d.ts.map

package/lib/tracer/tracer.es.js

@@ -1,5 +1,5 @@
 import isPromise from '@tinkoff/utils/is/promise';
-import { trace, context, ROOT_CONTEXT, SpanStatusCode } from '@opentelemetry/api';
+import { trace, context, ROOT_CONTEXT, propagation, SpanStatusCode } from '@opentelemetry/api';
 import { isSilentError } from '@tinkoff/errors';
 
 /* eslint-disable prefer-destructuring */
@@ -15,6 +15,7 @@ function recordAndThrowError(span, error, { skipError = () => false }) {
     throw error;
 }
 class TramvaiTracerImpl {
+    tracer;
     constructor({ tracer }) {
         this.tracer = tracer;
     }
@@ -70,6 +71,17 @@ class TramvaiTracerImpl {
             }
         });
     }
+    /**
+     * Propagate context from outgoing request
+     * @param carrier
+     *
+     * @see https://opentelemetry.io/docs/languages/js/propagation/#manual-context-propagation
+     */
+    propagateContext(carrier) {
+        const payload = carrier ?? {};
+        propagation.inject(context.active(), payload);
+        return payload;
+    }
 }
 /* eslint-enable prefer-destructuring */
 

package/lib/tracer/tracer.js

@@ -23,6 +23,7 @@ function recordAndThrowError(span, error, { skipError = () => false }) {
     throw error;
 }
 class TramvaiTracerImpl {
+    tracer;
     constructor({ tracer }) {
         this.tracer = tracer;
     }
@@ -78,6 +79,17 @@ class TramvaiTracerImpl {
             }
         });
     }
+    /**
+     * Propagate context from outgoing request
+     * @param carrier
+     *
+     * @see https://opentelemetry.io/docs/languages/js/propagation/#manual-context-propagation
+     */
+    propagateContext(carrier) {
+        const payload = carrier ?? {};
+        api.propagation.inject(api.context.active(), payload);
+        return payload;
+    }
 }
 /* eslint-enable prefer-destructuring */
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@tramvai/module-opentelemetry",
-  "version": "5.50.0",
+  "version": "6.59.0",
   "description": "Интеграция OpenTelemetry",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
   "module": "lib/server.es.js",
-  "typings": "lib/server.d.d.ts",
+  "typings": "lib/server.d.ts",
   "files": [
     "lib"
   ],
@@ -27,19 +27,21 @@
     "@opentelemetry/resources": "^1.28.0",
     "@opentelemetry/sdk-trace-node": "^1.28.0",
     "@opentelemetry/semantic-conventions": "^1.28.0",
-    "@tinkoff/errors": "0.6.2",
+    "@tinkoff/errors": "0.7.1",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/tokens-common": "5.50.0",
-    "@tramvai/tokens-http-client": "5.50.0",
-    "@tramvai/tokens-metrics": "5.50.0",
-    "@tramvai/tokens-router": "5.50.0",
-    "@tramvai/tokens-server": "5.50.0",
-    "@tramvai/tokens-server-private": "5.50.0",
-    "path-to-regexp": "0.1.7"
+    "@tramvai/tokens-child-app": "6.59.0",
+    "@tramvai/tokens-common": "6.59.0",
+    "@tramvai/tokens-http-client": "6.59.0",
+    "@tramvai/tokens-metrics": "6.59.0",
+    "@tramvai/tokens-render": "6.59.0",
+    "@tramvai/tokens-router": "6.59.0",
+    "@tramvai/tokens-server": "6.59.0",
+    "@tramvai/tokens-server-private": "6.59.0",
+    "path-to-regexp": "^0.1.12"
   },
   "peerDependencies": {
-    "@tinkoff/dippy": "0.11.4",
-    "@tramvai/core": "5.50.0",
+    "@tinkoff/dippy": "0.12.3",
+    "@tramvai/core": "6.59.0",
     "tslib": "^2.4.0"
   }
 }