hotelme-nuxt-logger 1.4.0 → 1.6.0

package/README.md

@@ -151,6 +151,74 @@ const response = await $fetch('/api/hotels', {
 })
 ```
 
+## OpenTelemetry (з 1.5.0)
+
+Трейсинг вимкнено за замовчуванням. Вмикається в nuxt.config — SDK, OTLP gRPC
+експортер і `@opentelemetry/api` вже є в залежностях модуля, ставити окремо не треба.
+
+```typescript
+logger: {
+  projectName: 'widgets-ssr',
+  otel: {
+    enabled: true,
+    ignorePaths: ['/nuxt_img/'],                 // + типові /_nuxt/, /_ipx/, /__nuxt, clientErrorEndpoint
+    ignoreUserAgents: ['^Slackbot-LinkExpanding ', '^kube-probe/'],
+    slowMs: 1000,                                // порятунок повільних, env OTEL_TRACES_SLOW_MS
+  },
+}
+```
+
+Env (читає SDK):
+
+| Змінна | Типово |
+|---|---|
+| `OTEL_SERVICE_NAME` | `projectName` |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` / `OTEL_EXPORTER_OTLP_ENDPOINT` | — (обов'язкова: без неї трейсинг не вмикається, лог `otel_disabled`) |
+| `OTEL_TRACES_SAMPLER` / `OTEL_TRACES_SAMPLER_ARG` | `parentbased_always_on` |
+
+Env модуля (перекриває `slowMs` з nuxt.config):
+
+| Змінна | Типово |
+|---|---|
+| `OTEL_TRACES_SLOW_MS` | — (0 — без порятунку) |
+
+Напр. 25% трейсів + повільні ≥ 1 с з решти:
+
+```yaml
+OTEL_TRACES_SAMPLER: parentbased_traceidratio
+OTEL_TRACES_SAMPLER_ARG: "0.25"
+OTEL_TRACES_SLOW_MS: "1000"
+```
+
+Що робить модуль:
+
+- **Активний контекст на весь запит.** Плагін обгортає `nitroApp.h3App.handler`, тож middleware, handler'и та SSR-рендер виконуються всередині `context.with(serverSpan)` — span'и з коду застосунку стають дочірніми без обгорток.
+- **Server span** на кожен запит, батько — вхідний `traceparent`. Без нього trace id = `X-Request-ID` без дефісів (`2e285875-f20c-…` → `2e285875f20c…`, як у libwts3), якщо це UUID / 32 hex; інакше випадковий. У `event.context`: `otelSpan`; у відповіді — `X-Trace-Id`. 5xx → статус ERROR, 4xx — ні.
+- **Вихідні fetch** (native `fetch`, `$fetch`, ofetch на зовнішній URL) — `@opentelemetry/instrumentation-undici` через diagnostics_channel: CLIENT span `GET <host>` (повний URL — в `url.full`), `traceparent` і `X-Request-ID` сторінки, якщо виклик не поставив свій. Поза запитом span'и не пишуться.
+- **Внутрішні SSR-виклики** (`$fetch('/api/…')` → Nitro localFetch) ідуть у тому ж async-ланцюжку, тож span роуту стає дочірнім span'а сторінки, а logger-middleware бере reqid сторінки. Заголовки руками не потрібні.
+- **Назва span'а** — шаблон, ніколи сирий шлях (кожна назва — окремий stream у VictoriaTraces), визначається сама після роутингу:
+  - сторінка → `route.name` з Vue Router без i18n-суфікса: `GET weather-citynameid`, `GET index` (аліаси теж). Локаль — в атрибуті `i18n.locale`;
+  - Nitro-хендлер → шаблон з файлової структури: `GET /api/city_info`, `GET /record/**`;
+  - решта (відповідь з server middleware, невідомий шлях) → `GET /api/*` / `GET /*`; точний шлях — в `url.path`, статус — в `http.response.status_code`.
+- **Фільтри** (статика, `ignorePaths`, `ignoreUserAgents`) не міняють поведінку запиту: він обробляється як завжди, але в невибраному (sampled=0) контексті — без span'ів у нього, його внутрішніх викликів і бекенда (`traceparent …-00`; libwts3 з `OTEL_TRACES_SLOW_MS` все ж відправить свій повільний запит — без батька з цього боку). Потрібен parent-based семплер (типовий).
+- **Вибірка «head + порятунок повільних»** (`slowMs` > 0 і семплер вибирає < 100%):
+  - частка з `OTEL_TRACES_SAMPLER_ARG` вибирається на старті root span'а за trace id, як у `parentbased_traceidratio` — `traceparent …-01` іде в бекенд, трейс повний. Підтримуються `always_on` / `always_off` / `traceidratio` (з `parentbased_` чи без — семплер завжди parent-based); інший семплер (`jaeger_remote` тощо) → warn `otel_config_invalid`, порятунок вимкнено;
+  - решта пишеться в пам'ять (`traceparent …-00`) і буферизується до кінця свого локального root span'а — окремо для кожного запиту, навіть з одним trace id. Root тривав ≥ `slowMs` → експортуються він (`sampling.kept_by: "slow"`) і всі його локальні дочірні span'и (`/api/*`, CLIENT span'и вихідних fetch з тривалістю); інакше буфер скидається. Так само працює `OTEL_TRACES_SLOW_MS` у libwts3;
+  - span'и бекенда в такому трейсі є, лише якщо бекенд врятував їх сам: libwts3 на `…-00` теж пише в пам'ять і відправляє запит, що тривав ≥ свого `OTEL_TRACES_SLOW_MS` (типово 1000). Повільний бекенд робить повільним і root тут, тож трейс зв'язний; швидкого бекенда в ньому немає;
+  - вхідний `traceparent …-01` — вибраний, `…-00` — та сама логіка порятунку; фільтри (статика, `ignorePaths`, `ignoreUserAgents`) не пишуться взагалі;
+  - буфер обмежено: 2000 трейсів у польоті, 512 span'ів на трейс.
+- **`?force_otel=1`** у запиті (як у libwts3) — трейс вибраний завжди: попри частку семплера, фільтри (`ignorePaths`, `ignoreUserAgents`, статика) і вхідний `traceparent …-00`. Позначка в контексті, тож вибрані й дочірні span'и (внутрішні `/api/*`, вихідні fetch), а бекенд отримує `traceparent …-01` і пише свою частину повністю. Root — з `sampling.kept_by: "force"`. Працює з `always_*` / `traceidratio` (з `parentbased_` чи без); з іншим семплером (`jaeger_remote`) параметр ігнорується, `otel_initialized` пише `force_otel: false`. Параметр публічний: будь-хто може форсувати трейс — як і в libwts3.
+- **Flush при зупинці**: span'и батчуються до 5 с, на `close` provider робить shutdown.
+- Помилки експорту (`diag`) пишуться JSON-логером як `otel_diag`.
+
+Хелпер (auto-import у Nitro або `import … from 'hotelme-nuxt-logger/runtime/otel'`), працює і з вимкненим трейсингом:
+
+```typescript
+// X-Request-ID сторінки (явна подія або поточна) — для бекендів, коли OTel вимкнено
+const headers = traceHeaders(event)
+
+```
+
 ## API
 
 ### Logger методи

package/dist/module.cjs

@@ -17,7 +17,13 @@ const module$1 = kit.defineNuxtModule({
     enableRequestLogging: true,
     enableErrorLogging: true,
     enableClientErrorLogging: true,
-    clientErrorEndpoint: "/_logger/client-error"
+    clientErrorEndpoint: "/_logger/client-error",
+    otel: {
+      enabled: false,
+      ignorePaths: ["/_nuxt/", "/_ipx/", "/__nuxt"],
+      ignoreStaticAssets: true,
+      ignoreUserAgents: []
+    }
   },
   setup(options, nuxt) {
     const moduleDir = typeof __dirname !== "undefined" ? __dirname : path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href))));
@@ -28,8 +34,14 @@ const module$1 = kit.defineNuxtModule({
     kit.addImportsDir(resolver.resolve("./runtime"));
     kit.addServerImports([
       { name: "logger", from: resolver.resolve("./runtime/logger") },
-      { name: "getRequestId", from: resolver.resolve("./runtime/logger") }
+      { name: "getRequestId", from: resolver.resolve("./runtime/logger") },
+      { name: "traceHeaders", from: resolver.resolve("./runtime/server/otel/tracing") }
     ]);
+    const { enabled: otelEnabled, ignorePaths = [], ...otel } = options.otel ?? {};
+    nuxt.options.runtimeConfig.logger = {
+      ...nuxt.options.runtimeConfig.logger,
+      otel: { ...otel, ignorePaths: [.../* @__PURE__ */ new Set([...ignorePaths, clientErrorEndpoint])] }
+    };
     if (options.enableRequestLogging) {
       kit.addServerHandler({
         handler: resolver.resolve("./runtime/middleware/logger.server"),
@@ -50,6 +62,14 @@ const module$1 = kit.defineNuxtModule({
         handler: resolver.resolve("./runtime/server/routes/client-error.post")
       });
     }
+    if (otelEnabled) {
+      kit.addServerPlugin(resolver.resolve("./runtime/server/otel/plugin"));
+      kit.addPlugin({
+        src: resolver.resolve("./runtime/plugins/otelPageName.server"),
+        mode: "server"
+      });
+    }
+    kit.addServerPlugin(resolver.resolve("./runtime/server/contextPlugin"));
   }
 });
 

package/dist/module.d.cts

@@ -27,8 +27,45 @@ interface ModuleOptions {
      * @default '/_logger/client-error'
      */
     clientErrorEndpoint?: string;
+    /**
+     * OpenTelemetry-трейсинг (OTLP gRPC). Вимкнено за замовчуванням.
+     * Хелпер `traceHeaders` доступний й з вимкненим трейсингом.
+     */
+    otel?: OtelOptions;
+}
+interface OtelOptions {
+    /**
+     * Tracer provider, OTLP-експортер і server span на кожен запит.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Префікси шляхів без span'ів (разом з дочірніми). Додаються до типових.
+     * @default ['/_nuxt/', '/_ipx/', '/__nuxt', clientErrorEndpoint]
+     */
+    ignorePaths?: string[];
+    /**
+     * Без span'ів для статики (css, js, картинки, шрифти, json, txt, xml, map).
+     * @default true
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Regex-рядки User-Agent без span'ів (k8s probe, боти прев'ю посилань), напр.
+     * `'^kube-probe/'`, `'^Slackbot-LinkExpanding '`. Трейсинг вимикається на
+     * весь запит, разом із його внутрішніми /api-викликами та вихідними fetch.
+     * @default []
+     */
+    ignoreUserAgents?: string[];
+    /**
+     * Трейси поза вибіркою семплера з `OTEL_TRACES_SAMPLER*` (`always_*`,
+     * `traceidratio`, з `parentbased_` чи без), чий server span тривав ≥ `slowMs`,
+     * теж експортуються — увесь запит з локальними дочірніми span'ами, як
+     * `OTEL_TRACES_SLOW_MS` у libwts3. Бекенд рятує свою частину сам. Перекривається env
+     * `OTEL_TRACES_SLOW_MS`. 0 — вимкнено.
+     */
+    slowMs?: number;
 }
 declare const _default: any;
 
 export { _default as default };
-export type { ModuleOptions };
+export type { ModuleOptions, OtelOptions };

package/dist/module.d.mts

@@ -27,8 +27,45 @@ interface ModuleOptions {
      * @default '/_logger/client-error'
      */
     clientErrorEndpoint?: string;
+    /**
+     * OpenTelemetry-трейсинг (OTLP gRPC). Вимкнено за замовчуванням.
+     * Хелпер `traceHeaders` доступний й з вимкненим трейсингом.
+     */
+    otel?: OtelOptions;
+}
+interface OtelOptions {
+    /**
+     * Tracer provider, OTLP-експортер і server span на кожен запит.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Префікси шляхів без span'ів (разом з дочірніми). Додаються до типових.
+     * @default ['/_nuxt/', '/_ipx/', '/__nuxt', clientErrorEndpoint]
+     */
+    ignorePaths?: string[];
+    /**
+     * Без span'ів для статики (css, js, картинки, шрифти, json, txt, xml, map).
+     * @default true
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Regex-рядки User-Agent без span'ів (k8s probe, боти прев'ю посилань), напр.
+     * `'^kube-probe/'`, `'^Slackbot-LinkExpanding '`. Трейсинг вимикається на
+     * весь запит, разом із його внутрішніми /api-викликами та вихідними fetch.
+     * @default []
+     */
+    ignoreUserAgents?: string[];
+    /**
+     * Трейси поза вибіркою семплера з `OTEL_TRACES_SAMPLER*` (`always_*`,
+     * `traceidratio`, з `parentbased_` чи без), чий server span тривав ≥ `slowMs`,
+     * теж експортуються — увесь запит з локальними дочірніми span'ами, як
+     * `OTEL_TRACES_SLOW_MS` у libwts3. Бекенд рятує свою частину сам. Перекривається env
+     * `OTEL_TRACES_SLOW_MS`. 0 — вимкнено.
+     */
+    slowMs?: number;
 }
 declare const _default: any;
 
 export { _default as default };
-export type { ModuleOptions };
+export type { ModuleOptions, OtelOptions };

package/dist/module.d.ts

@@ -27,8 +27,45 @@ interface ModuleOptions {
      * @default '/_logger/client-error'
      */
     clientErrorEndpoint?: string;
+    /**
+     * OpenTelemetry-трейсинг (OTLP gRPC). Вимкнено за замовчуванням.
+     * Хелпер `traceHeaders` доступний й з вимкненим трейсингом.
+     */
+    otel?: OtelOptions;
+}
+interface OtelOptions {
+    /**
+     * Tracer provider, OTLP-експортер і server span на кожен запит.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Префікси шляхів без span'ів (разом з дочірніми). Додаються до типових.
+     * @default ['/_nuxt/', '/_ipx/', '/__nuxt', clientErrorEndpoint]
+     */
+    ignorePaths?: string[];
+    /**
+     * Без span'ів для статики (css, js, картинки, шрифти, json, txt, xml, map).
+     * @default true
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Regex-рядки User-Agent без span'ів (k8s probe, боти прев'ю посилань), напр.
+     * `'^kube-probe/'`, `'^Slackbot-LinkExpanding '`. Трейсинг вимикається на
+     * весь запит, разом із його внутрішніми /api-викликами та вихідними fetch.
+     * @default []
+     */
+    ignoreUserAgents?: string[];
+    /**
+     * Трейси поза вибіркою семплера з `OTEL_TRACES_SAMPLER*` (`always_*`,
+     * `traceidratio`, з `parentbased_` чи без), чий server span тривав ≥ `slowMs`,
+     * теж експортуються — увесь запит з локальними дочірніми span'ами, як
+     * `OTEL_TRACES_SLOW_MS` у libwts3. Бекенд рятує свою частину сам. Перекривається env
+     * `OTEL_TRACES_SLOW_MS`. 0 — вимкнено.
+     */
+    slowMs?: number;
 }
 declare const _default: any;
 
 export { _default as default };
-export type { ModuleOptions };
+export type { ModuleOptions, OtelOptions };

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.0.0 || ^4.0.0"
   },
-  "version": "1.4.0",
+  "version": "1.6.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -23,7 +23,13 @@ const module = defineNuxtModule({
     enableRequestLogging: true,
     enableErrorLogging: true,
     enableClientErrorLogging: true,
-    clientErrorEndpoint: "/_logger/client-error"
+    clientErrorEndpoint: "/_logger/client-error",
+    otel: {
+      enabled: false,
+      ignorePaths: ["/_nuxt/", "/_ipx/", "/__nuxt"],
+      ignoreStaticAssets: true,
+      ignoreUserAgents: []
+    }
   },
   setup(options, nuxt) {
     const moduleDir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
@@ -34,8 +40,14 @@ const module = defineNuxtModule({
     addImportsDir(resolver.resolve("./runtime"));
     addServerImports([
       { name: "logger", from: resolver.resolve("./runtime/logger") },
-      { name: "getRequestId", from: resolver.resolve("./runtime/logger") }
+      { name: "getRequestId", from: resolver.resolve("./runtime/logger") },
+      { name: "traceHeaders", from: resolver.resolve("./runtime/server/otel/tracing") }
     ]);
+    const { enabled: otelEnabled, ignorePaths = [], ...otel } = options.otel ?? {};
+    nuxt.options.runtimeConfig.logger = {
+      ...nuxt.options.runtimeConfig.logger,
+      otel: { ...otel, ignorePaths: [.../* @__PURE__ */ new Set([...ignorePaths, clientErrorEndpoint])] }
+    };
     if (options.enableRequestLogging) {
       addServerHandler({
         handler: resolver.resolve("./runtime/middleware/logger.server"),
@@ -56,6 +68,14 @@ const module = defineNuxtModule({
         handler: resolver.resolve("./runtime/server/routes/client-error.post")
       });
     }
+    if (otelEnabled) {
+      addServerPlugin(resolver.resolve("./runtime/server/otel/plugin"));
+      addPlugin({
+        src: resolver.resolve("./runtime/plugins/otelPageName.server"),
+        mode: "server"
+      });
+    }
+    addServerPlugin(resolver.resolve("./runtime/server/contextPlugin"));
   }
 });
 

package/dist/runtime/plugins/otelPageName.server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Назва роута сторінки для server span'а (див. resolvedRouteName у serverSpan).
+ *
+ * `router.resolve`, а не `afterEach`: початкова навігація SSR відбувається ще в
+ * плагіні роутера Nuxt, до цього плагіна, і може впасти в route middleware
+ * (404, редирект) — тоді `currentRoute` лишається порожнім. Resolve лише
+ * зіставляє URL з таблицею роутів, незалежно від результату навігації.
+ * Аліаси (`/widgets/weather` → `index`) дають назву основного роута.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/otelPageName.server.js

@@ -0,0 +1,12 @@
+import { defineNuxtPlugin, useRequestEvent } from "#imports";
+const I18N_SEPARATOR = "___";
+export default defineNuxtPlugin((nuxtApp) => {
+  const event = useRequestEvent();
+  const url = nuxtApp.ssrContext?.url;
+  if (!event?.context.otelSpan || !url) return;
+  const name = nuxtApp.$router.resolve(url).name;
+  if (typeof name !== "string") return;
+  const [baseName, locale] = name.split(I18N_SEPARATOR);
+  event.context.otelPageName = baseName;
+  if (locale) event.context.otelSpan.setAttribute("i18n.locale", locale);
+});

package/dist/runtime/server/contextPlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Весь pipeline запиту (middleware, handler, SSR-рендер) — всередині
+ * AsyncLocalStorage з його подією, див. requestContext.ts. Той самий прийом,
+ * що й `experimental.asyncContext` у Nitro: toNodeListener і localFetch читають
+ * `h3App.handler` на кожен запит.
+ */
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/contextPlugin.js

@@ -0,0 +1,6 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { runInRequestContext } from "./requestContext.js";
+export default defineNitroPlugin((nitroApp) => {
+  const handler = nitroApp.h3App.handler;
+  nitroApp.h3App.handler = (event) => runInRequestContext(event, () => handler(event));
+});

package/dist/runtime/server/otel/config.d.ts

@@ -0,0 +1,39 @@
+import { type Sampler } from '@opentelemetry/sdk-trace-base';
+/** Серіалізована форма `logger.otel` з nuxt.config (див. module.ts). */
+export interface OtelRuntimeConfig {
+    ignorePaths?: string[];
+    ignoreStaticAssets?: boolean;
+    ignoreUserAgents?: string[];
+    slowMs?: number;
+}
+export interface OtelSettings {
+    ignorePaths: string[];
+    ignoreStaticAssets: boolean;
+    ignoreUserAgent?: RegExp;
+}
+export declare const TRACER_NAME = "hotelme-nuxt-logger";
+export declare function otelRuntimeConfig(): OtelRuntimeConfig;
+/** Регекспи компілюються один раз, на першому запиті. */
+export declare function otelSettings(): OtelSettings;
+export interface OtelSampling {
+    /** Частка head-вибірки з OTEL_TRACES_SAMPLER*, 0–1 */
+    ratio: number;
+    /** Поріг порятунку повільних трейсів, мс */
+    slowMs: number;
+}
+/**
+ * Той самий семплер, що SDK зібрав би з env сам (`buildSamplerFromEnv` не
+ * експортується) — щоб обгорнути його ForceSampler'ом. undefined — семплер,
+ * якого тут немає: лишається на SDK.
+ */
+export declare function envSampler(): Sampler | undefined;
+/**
+ * Порятунок повільних: `OTEL_TRACES_SLOW_MS` (перекриває `logger.otel.slowMs`)
+ * > 0 і семплер з `OTEL_TRACES_SAMPLER*` вибирає менше 100%. Інакше undefined —
+ * семплер з env без порятунку (envSampler), як до 1.6.0.
+ *
+ * Семплер з порятунком завжди parent-based: `traceidratio` без префікса
+ * поводиться як `parentbased_traceidratio` — фільтри serverSpan.ts без цього
+ * не працюють.
+ */
+export declare function otelSampling(): OtelSampling | undefined;

package/dist/runtime/server/otel/config.js

@@ -0,0 +1,59 @@
+import { useRuntimeConfig } from "#imports";
+import { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
+import { logger } from "../../logger.js";
+export const TRACER_NAME = "hotelme-nuxt-logger";
+export function otelRuntimeConfig() {
+  return useRuntimeConfig().logger?.otel ?? {};
+}
+let settings;
+export function otelSettings() {
+  if (settings) return settings;
+  const config = otelRuntimeConfig();
+  const userAgents = (config.ignoreUserAgents ?? []).filter(Boolean);
+  settings = {
+    ignorePaths: config.ignorePaths ?? [],
+    ignoreStaticAssets: config.ignoreStaticAssets ?? true,
+    ignoreUserAgent: userAgents.length ? new RegExp(userAgents.map((ua) => `(?:${ua})`).join("|"), "i") : void 0
+  };
+  return settings;
+}
+function envNumber(name) {
+  const raw = process.env[name]?.trim();
+  if (!raw) return void 0;
+  const value = Number(raw);
+  if (Number.isFinite(value)) return value;
+  logger.warn("otel_config_invalid", { error: `${name}=${raw} is not a number, ignored` });
+  return void 0;
+}
+function envSamplerConfig() {
+  const sampler = process.env.OTEL_TRACES_SAMPLER?.trim().toLowerCase() || "parentbased_always_on";
+  const parentBased = sampler.startsWith("parentbased_");
+  switch (parentBased ? sampler.slice("parentbased_".length) : sampler) {
+    case "always_on":
+      return { ratio: 1, parentBased };
+    case "always_off":
+      return { ratio: 0, parentBased };
+    case "traceidratio": {
+      const ratio = envNumber("OTEL_TRACES_SAMPLER_ARG");
+      return { ratio: ratio !== void 0 && ratio >= 0 && ratio <= 1 ? ratio : 1, parentBased };
+    }
+    default:
+      return void 0;
+  }
+}
+export function envSampler() {
+  const config = envSamplerConfig();
+  if (!config) return void 0;
+  const root = config.ratio >= 1 ? new AlwaysOnSampler() : config.ratio <= 0 ? new AlwaysOffSampler() : new TraceIdRatioBasedSampler(config.ratio);
+  return config.parentBased ? new ParentBasedSampler({ root }) : root;
+}
+export function otelSampling() {
+  const slowMs = envNumber("OTEL_TRACES_SLOW_MS") ?? otelRuntimeConfig().slowMs ?? 0;
+  if (slowMs <= 0) return void 0;
+  const ratio = envSamplerConfig()?.ratio;
+  if (ratio === void 0) {
+    logger.warn("otel_config_invalid", { error: `OTEL_TRACES_SLOW_MS ignored: unsupported OTEL_TRACES_SAMPLER=${process.env.OTEL_TRACES_SAMPLER}` });
+    return void 0;
+  }
+  return ratio < 1 ? { ratio, slowMs } : void 0;
+}

package/dist/runtime/server/otel/plugin.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tracer provider з OTLP gRPC експортером.
+ *
+ * Env, які SDK читає сам:
+ * - OTEL_EXPORTER_OTLP_TRACES_ENDPOINT / OTEL_EXPORTER_OTLP_ENDPOINT
+ *   (insecure чи TLS — за схемою URL). Без них трейсинг не вмикається:
+ *   експортер SDK інакше мовчки слав би на localhost:4317.
+ * - OTEL_TRACES_SAMPLER / OTEL_TRACES_SAMPLER_ARG (типово parentbased_always_on).
+ *
+ * OTEL_TRACES_SLOW_MS (config.ts → otelSampling) — порятунок трейсів поза
+ * вибіркою, чий root тривав довше порогу (див. sampling.ts). Тоді семплер —
+ * HeadSampler з тією ж часткою, що в OTEL_TRACES_SAMPLER_ARG.
+ *
+ * `?force_otel=1` у запиті — трейс вибраний завжди (ForceSampler, як у libwts3).
+ *
+ * Root trace id — з `X-Request-ID`, див. requestTraceId.ts.
+ *
+ * service.name: env OTEL_SERVICE_NAME → `logger.projectName`.
+ */
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/otel/plugin.js

@@ -0,0 +1,94 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { useRuntimeConfig } from "#imports";
+import { context, diag, DiagLogLevel, propagation, trace } from "@opentelemetry/api";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+import { logger } from "../../logger.js";
+import { currentRequestEvent, requestIdOf } from "../requestContext.js";
+import { serverSpanContext } from "./serverSpan.js";
+import { requestIdGenerator } from "./requestTraceId.js";
+import { envSampler, otelSampling } from "./config.js";
+import { ForceSampler, HeadSampler, SlowTraceSpanProcessor } from "./sampling.js";
+const diagLogger = {
+  error: (message, ...args) => logger.error("otel_diag", { error: message, args }),
+  warn: (message, ...args) => logger.warn("otel_diag", { error: message, args }),
+  info: () => {
+  },
+  debug: () => {
+  },
+  verbose: () => {
+  }
+};
+function hasHeader(request, name) {
+  const { headers } = request;
+  if (typeof headers === "string") return new RegExp(`(^|\\r\\n)${name}:`, "i").test(headers);
+  for (let i = 0; i < headers.length; i += 2) {
+    if (String(headers[i]).toLowerCase() === name) return true;
+  }
+  return false;
+}
+function undiciInstrumentation() {
+  return new UndiciInstrumentation({
+    requireParentforSpans: true,
+    requestHook: (span, request) => {
+      span.updateName(`${request.method} ${new URL(request.origin).hostname}`);
+      const reqid = requestIdOf(currentRequestEvent());
+      if (reqid && !hasHeader(request, "x-request-id")) request.addHeader("x-request-id", reqid);
+    }
+  });
+}
+export default defineNitroPlugin((nitroApp) => {
+  const endpoint = process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  if (!endpoint) {
+    logger.warn("otel_disabled", { error: "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT / OTEL_EXPORTER_OTLP_ENDPOINT not set" });
+    return;
+  }
+  diag.setLogger(diagLogger, DiagLogLevel.WARN);
+  const serviceName = process.env.OTEL_SERVICE_NAME || String(useRuntimeConfig().public.projectName || "hotelme");
+  const batchProcessor = new BatchSpanProcessor(new OTLPTraceExporter(), {
+    maxQueueSize: 2048,
+    maxExportBatchSize: 512,
+    scheduledDelayMillis: 5e3,
+    exportTimeoutMillis: 1e4
+  });
+  const sampling = otelSampling();
+  const spanProcessor = sampling ? new SlowTraceSpanProcessor(batchProcessor, sampling.slowMs) : batchProcessor;
+  const baseSampler = sampling ? new HeadSampler(sampling.ratio) : envSampler();
+  const provider = new NodeTracerProvider({
+    resource: resourceFromAttributes({ "service.name": serviceName }),
+    ...baseSampler && { sampler: new ForceSampler(baseSampler) },
+    spanProcessors: [spanProcessor],
+    idGenerator: requestIdGenerator
+  });
+  provider.register();
+  const unregisterInstrumentations = registerInstrumentations({
+    tracerProvider: provider,
+    instrumentations: [undiciInstrumentation()]
+  });
+  const handler = nitroApp.h3App.handler;
+  nitroApp.h3App.handler = (event) => context.with(serverSpanContext(event), () => handler(event));
+  nitroApp.hooks.hook("close", async () => {
+    unregisterInstrumentations();
+    try {
+      await provider.shutdown();
+    } catch (error) {
+      logger.error("otel_shutdown_failed", { error: error instanceof Error ? error.message : String(error) });
+    } finally {
+      trace.disable();
+      propagation.disable();
+      context.disable();
+    }
+  });
+  logger.info("otel_initialized", {
+    service: serviceName,
+    endpoint,
+    sampler: process.env.OTEL_TRACES_SAMPLER || "parentbased_always_on",
+    sampler_arg: process.env.OTEL_TRACES_SAMPLER_ARG,
+    slow_ms: sampling?.slowMs,
+    force_otel: !!baseSampler
+  });
+});

package/dist/runtime/server/otel/requestTraceId.d.ts

@@ -0,0 +1,10 @@
+import { type IdGenerator } from '@opentelemetry/sdk-trace-base';
+/**
+ * Trace id як у libwts3: `X-Request-ID` поточного запиту без дефісів
+ * (`2e285875-f20c-4c86-b6c0-dead22613ca9` → `2e285875f20c4c86b6c0dead22613ca9`),
+ * щоб reqid з логів напряму відкривав трейс. Не UUID / 32 hex — випадковий.
+ *
+ * Tracer викликає generateTraceId лише для span'а без батька, тобто server
+ * span'а запиту без вхідного `traceparent`.
+ */
+export declare const requestIdGenerator: IdGenerator;

package/dist/runtime/server/otel/requestTraceId.js

@@ -0,0 +1,11 @@
+import { isValidTraceId } from "@opentelemetry/api";
+import { RandomIdGenerator } from "@opentelemetry/sdk-trace-base";
+import { currentRequestEvent, requestIdOf } from "../requestContext.js";
+const random = new RandomIdGenerator();
+export const requestIdGenerator = {
+  generateTraceId: () => {
+    const traceId = requestIdOf(currentRequestEvent())?.replace(/-/g, "").toLowerCase();
+    return traceId && /^[0-9a-f]{32}$/.test(traceId) && isValidTraceId(traceId) ? traceId : random.generateTraceId();
+  },
+  generateSpanId: () => random.generateSpanId()
+};

package/dist/runtime/server/otel/sampling.d.ts

@@ -0,0 +1,64 @@
+import { type Attributes, type Context, type Link, type SpanKind } from '@opentelemetry/api';
+import { type ReadableSpan, type Sampler, type SamplingResult, type Span, type SpanProcessor } from '@opentelemetry/sdk-trace-base';
+/** Контекст, у якому ForceSampler вибирає кожен span — його й усіх дочірніх. */
+export declare function forceSampled(context: Context): Context;
+/**
+ * `?force_otel=1` як у libwts3: запит вибраний попри частку семплера, фільтри
+ * й вхідний `traceparent …-00`. Позначка живе в контексті, тож дочірні span'и
+ * (внутрішні `/api/*`, вихідні fetch) теж вибрані, а бекенд отримує
+ * `traceparent …-01` і пише свою частину повністю. Решта — `base`.
+ */
+export declare class ForceSampler implements Sampler {
+    private readonly base;
+    constructor(base: Sampler);
+    shouldSample(context: Context, traceId: string, spanName: string, spanKind: SpanKind, attributes: Attributes, links: Link[]): SamplingResult;
+    toString(): string;
+}
+/**
+ * `parentbased_traceidratio`, у якого решта трейсів — RECORD замість
+ * NOT_RECORD: span'и пишуться в пам'ять для SlowTraceSpanProcessor, але
+ * назовні йде `traceparent …-00`: бекенд вирішує сам (libwts3 теж рятує
+ * повільні).
+ *
+ * Батько вибраний → вибраний. Невибраний батько:
+ * - власний record-only span або вхідний `traceparent …-00` → RECORD;
+ * - unsampledContext із serverSpan.ts (статика, ignorePaths, ignoreUserAgents) —
+ *   локальний non-recording span → NOT_RECORD, фільтри працюють як раніше.
+ */
+export declare class HeadSampler implements Sampler {
+    private readonly ratio;
+    constructor(ratio: number);
+    shouldSample(context: Context, traceId: string): SamplingResult;
+    toString(): string;
+}
+/**
+ * Порятунок повільних трейсів, які не потрапили в head-вибірку — як
+ * OTEL_TRACES_SLOW_MS у libwts3: рішення на весь запит, а не на окремий span.
+ *
+ * Вибрані span'и йдуть у `next` одразу. Record-only (див. HeadSampler)
+ * буферизуються до кінця свого локального root'а — server span'а без батька
+ * або з віддаленим батьком. Root тривав ≥ `slowMs` → увесь запит іде в `next`
+ * з прапорцем sampled, root — з `sampling.kept_by: "slow"`; інакше буфер
+ * скидається. Бекенд отримав `traceparent …-00`, тож його span'и в трейсі є,
+ * лише якщо він сам їх врятував (libwts3: тривав ≥ свого OTEL_TRACES_SLOW_MS).
+ *
+ * Ключ буфера — span id локального root'а, не trace id: кілька запитів з одним
+ * trace id (один вхідний `traceparent`, повтор `X-Request-ID`) вирішуються
+ * кожен за своєю тривалістю.
+ *
+ * Рішення пам'ятається, щоб span'и, які закінчились після root'а
+ * (fire-and-forget fetch), пішли за ним, а не зависли в буфері.
+ */
+export declare class SlowTraceSpanProcessor implements SpanProcessor {
+    private readonly next;
+    private readonly slowMs;
+    /** Record-only span → span id його локального root'а */
+    private readonly roots;
+    private readonly pending;
+    private readonly decisions;
+    constructor(next: SpanProcessor, slowMs: number);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/runtime/server/otel/sampling.js

@@ -0,0 +1,126 @@
+import { createContextKey, isSpanContextValid, trace, TraceFlags } from "@opentelemetry/api";
+import { hrTimeToMilliseconds } from "@opentelemetry/core";
+import {
+  SamplingDecision,
+  TraceIdRatioBasedSampler
+} from "@opentelemetry/sdk-trace-base";
+const SAMPLED = { decision: SamplingDecision.RECORD_AND_SAMPLED };
+const RECORDED = { decision: SamplingDecision.RECORD };
+const DROPPED = { decision: SamplingDecision.NOT_RECORD };
+const FORCED = createContextKey("hotelme-nuxt-logger.force_otel");
+export function forceSampled(context) {
+  return context.setValue(FORCED, true);
+}
+export class ForceSampler {
+  constructor(base) {
+    this.base = base;
+  }
+  shouldSample(context, traceId, spanName, spanKind, attributes, links) {
+    if (context.getValue(FORCED)) return SAMPLED;
+    return this.base.shouldSample(context, traceId, spanName, spanKind, attributes, links);
+  }
+  toString() {
+    return `ForceSampler{${this.base}}`;
+  }
+}
+export class HeadSampler {
+  ratio;
+  constructor(ratio) {
+    this.ratio = new TraceIdRatioBasedSampler(ratio);
+  }
+  shouldSample(context, traceId) {
+    const parentSpan = trace.getSpan(context);
+    const parent = parentSpan?.spanContext();
+    if (!parentSpan || !parent || !isSpanContextValid(parent)) {
+      return this.ratio.shouldSample(context, traceId).decision === SamplingDecision.RECORD_AND_SAMPLED ? SAMPLED : RECORDED;
+    }
+    if (parent.traceFlags & TraceFlags.SAMPLED) return SAMPLED;
+    return parent.isRemote || parentSpan.isRecording() ? RECORDED : DROPPED;
+  }
+  toString() {
+    return `HeadSampler{${this.ratio}}`;
+  }
+}
+const MAX_PENDING_TRACES = 2e3;
+const MAX_SPANS_PER_TRACE = 512;
+const MAX_DECISIONS = 2e3;
+function rememberBounded(map, key, value, max) {
+  if (map.size >= max) map.delete(map.keys().next().value);
+  map.set(key, value);
+}
+function isLocalRoot(span) {
+  return !span.parentSpanContext || !!span.parentSpanContext.isRemote;
+}
+function asSampled(span, extraAttributes) {
+  const spanContext = { ...span.spanContext(), traceFlags: span.spanContext().traceFlags | TraceFlags.SAMPLED };
+  return {
+    name: span.name,
+    kind: span.kind,
+    spanContext: () => spanContext,
+    parentSpanContext: span.parentSpanContext,
+    startTime: span.startTime,
+    endTime: span.endTime,
+    status: span.status,
+    attributes: extraAttributes ? { ...span.attributes, ...extraAttributes } : span.attributes,
+    links: span.links,
+    events: span.events,
+    duration: span.duration,
+    ended: span.ended,
+    resource: span.resource,
+    instrumentationScope: span.instrumentationScope,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount
+  };
+}
+export class SlowTraceSpanProcessor {
+  constructor(next, slowMs) {
+    this.next = next;
+    this.slowMs = slowMs;
+  }
+  /** Record-only span → span id його локального root'а */
+  roots = /* @__PURE__ */ new WeakMap();
+  pending = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  onStart(span, parentContext) {
+    if (!(span.spanContext().traceFlags & TraceFlags.SAMPLED)) {
+      const parent = trace.getSpan(parentContext);
+      const root = !isLocalRoot(span) && parent ? this.roots.get(parent) : void 0;
+      this.roots.set(span, root ?? span.spanContext().spanId);
+    }
+    this.next.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    if (span.spanContext().traceFlags & TraceFlags.SAMPLED) return this.next.onEnd(span);
+    const root = this.roots.get(span) ?? span.spanContext().spanId;
+    const decision = this.decisions.get(root);
+    if (decision !== void 0) {
+      if (decision) this.next.onEnd(asSampled(span));
+      return;
+    }
+    if (!isLocalRoot(span)) {
+      let spans2 = this.pending.get(root);
+      if (!spans2) {
+        spans2 = [];
+        rememberBounded(this.pending, root, spans2, MAX_PENDING_TRACES);
+      }
+      if (spans2.length < MAX_SPANS_PER_TRACE) spans2.push(span);
+      return;
+    }
+    const spans = this.pending.get(root) ?? [];
+    this.pending.delete(root);
+    const keep = hrTimeToMilliseconds(span.duration) >= this.slowMs;
+    rememberBounded(this.decisions, root, keep, MAX_DECISIONS);
+    if (!keep) return;
+    for (const child of spans) this.next.onEnd(asSampled(child));
+    this.next.onEnd(asSampled(span, { "sampling.kept_by": "slow" }));
+  }
+  forceFlush() {
+    return this.next.forceFlush();
+  }
+  shutdown() {
+    this.pending.clear();
+    this.decisions.clear();
+    return this.next.shutdown();
+  }
+}

package/dist/runtime/server/otel/serverSpan.d.ts

@@ -0,0 +1,29 @@
+import { type H3Event } from 'h3';
+import { type Context } from '@opentelemetry/api';
+declare module 'h3' {
+    interface H3EventContext {
+        /** Назва роута сторінки з Vue Router, ставить plugins/otelPageName.server */
+        otelPageName?: string;
+    }
+}
+/**
+ * Контекст, у якому виконується весь pipeline запиту (див. plugin.ts).
+ *
+ * Server span з батьком із вхідного W3C `traceparent`, а для внутрішнього
+ * SSR-виклику (`$fetch('/api/…')` → localFetch) — з активного контексту
+ * сторінки: localFetch іде в тому ж async-ланцюжку, тож span роуту стає
+ * дочірнім без жодних заголовків. Без батька trace id — з `X-Request-ID`
+ * (requestIdGenerator).
+ *
+ * Відфільтровані запити (статика, ignorePaths, ignoreUserAgents) отримують
+ * невибраний контекст, а не просто відсутність span'а: інакше їхні внутрішні
+ * /api-виклики, вихідні fetch і span'и бекенда стали б осиротілими
+ * root-трейсами. Дочірні запити успадковують його через parent-based семплер.
+ *
+ * `?force_otel=1` (як у libwts3) — трейс вибраний попри фільтри, частку
+ * семплера й вхідний `traceparent …-00`, root з `sampling.kept_by: "force"`.
+ *
+ * Кладе в event.context `otelSpan` (назва сторінки, `i18n.locale`), віддає
+ * `X-Trace-Id` у відповіді.
+ */
+export declare function serverSpanContext(event: H3Event): Context;

package/dist/runtime/server/otel/serverSpan.js

@@ -0,0 +1,69 @@
+import { getHeader, setResponseHeader } from "h3";
+import { context, isSpanContextValid, propagation, trace, SpanKind, SpanStatusCode, TraceFlags } from "@opentelemetry/api";
+import { isTracingSuppressed } from "@opentelemetry/core";
+import { requestIdOf } from "../requestContext.js";
+import { otelSettings, TRACER_NAME } from "./config.js";
+import { forceSampled } from "./sampling.js";
+import { requestIdGenerator } from "./requestTraceId.js";
+const STATIC_ASSET = /\.(css|m?js|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|map|json|txt|xml)$/i;
+function unsampledContext(active) {
+  return trace.setSpanContext(active, {
+    traceId: requestIdGenerator.generateTraceId(),
+    spanId: requestIdGenerator.generateSpanId(),
+    traceFlags: TraceFlags.NONE
+  });
+}
+function resolvedRouteName(event) {
+  if (event.context.otelPageName) return event.context.otelPageName;
+  const route = event.context.matchedRoute?.path;
+  return route && route !== "/**" ? route : void 0;
+}
+export function serverSpanContext(event) {
+  const active = context.active();
+  const settings = otelSettings();
+  const userAgent = getHeader(event, "user-agent") ?? "";
+  const [pathname = "", query = ""] = event.path.split("?");
+  if (isTracingSuppressed(active)) return active;
+  const forced = new URLSearchParams(query).get("force_otel") === "1";
+  if (!forced && (settings.ignoreUserAgent?.test(userAgent) || settings.ignorePaths.some((prefix) => pathname.startsWith(prefix)) || settings.ignoreStaticAssets && STATIC_ASSET.test(pathname))) {
+    return unsampledContext(active);
+  }
+  const carrier = {};
+  const traceparent = getHeader(event, "traceparent");
+  const tracestate = getHeader(event, "tracestate");
+  if (traceparent) carrier.traceparent = traceparent;
+  if (tracestate) carrier.tracestate = tracestate;
+  const extracted = propagation.extract(active, carrier);
+  const parentCtx = forced ? forceSampled(extracted) : extracted;
+  const span = trace.getTracer(TRACER_NAME).startSpan(
+    `${event.method} ${pathname.startsWith("/api/") ? "/api/*" : "/*"}`,
+    {
+      kind: SpanKind.SERVER,
+      attributes: {
+        "http.request.method": event.method,
+        "url.path": pathname,
+        "url.query": query,
+        "server.address": getHeader(event, "host") ?? "",
+        "user_agent.original": userAgent,
+        ...forced && { "sampling.kept_by": "force" }
+      }
+    },
+    parentCtx
+  );
+  event.context.otelSpan = span;
+  if (isSpanContextValid(span.spanContext())) {
+    setResponseHeader(event, "X-Trace-Id", span.spanContext().traceId);
+  }
+  const res = event.node.res;
+  res.once("close", () => {
+    const route = resolvedRouteName(event);
+    if (route) span.updateName(`${event.method} ${route}`);
+    span.setAttribute("request_id", requestIdOf(event) ?? "");
+    const statusSent = res.headersSent || res.writableFinished;
+    if (statusSent) span.setAttribute("http.response.status_code", res.statusCode);
+    if (!res.writableFinished) span.setAttribute("error.type", "aborted");
+    if (statusSent && res.statusCode >= 500) span.setStatus({ code: SpanStatusCode.ERROR });
+    span.end();
+  });
+  return trace.setSpan(parentCtx, span);
+}

package/dist/runtime/server/otel/tracing.d.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+import type { Span } from '@opentelemetry/api';
+declare module 'h3' {
+    interface H3EventContext {
+        otelSpan?: Span;
+    }
+}
+/**
+ * `X-Request-ID` сторінки для вихідного запиту — щоб access-log бекенда мав
+ * той самий id, що й `stats`/`api request` цього pod'а. Подія — явна або
+ * поточна з AsyncLocalStorage. `traceparent` тут немає: його в кожен fetch
+ * додає instrumentation-undici, другий такий заголовок зламав би зв'язок.
+ */
+export declare function traceHeaders(event?: H3Event | undefined): Record<string, string>;

package/dist/runtime/server/otel/tracing.js

@@ -0,0 +1,5 @@
+import { currentRequestEvent, requestIdOf } from "../requestContext.js";
+export function traceHeaders(event = currentRequestEvent()) {
+  const reqid = requestIdOf(event);
+  return reqid ? { "X-Request-ID": reqid } : {};
+}

package/dist/runtime/server/requestContext.d.ts

@@ -0,0 +1,15 @@
+import type { H3Event } from 'h3';
+/**
+ * H3-подія запиту, всередині якого виконується поточний код (middleware,
+ * handler, SSR-рендер, їхні await'и). `undefined` поза запитом.
+ */
+export declare function currentRequestEvent(): H3Event | undefined;
+/** reqid події: від logger-middleware або сирий `X-Request-ID`. */
+export declare function requestIdOf(event: H3Event | undefined): string | undefined;
+/**
+ * Запускає `handler` з подією в AsyncLocalStorage. Внутрішній SSR-виклик
+ * (`$fetch('/api/…')` → Nitro localFetch) іде в тому ж async-ланцюжку, тож тут
+ * видно батьківську подію: її reqid стає `X-Request-ID` дочірнього запиту, і
+ * logger-middleware не генерує новий.
+ */
+export declare function runInRequestContext<T>(event: H3Event, handler: () => T): T;

package/dist/runtime/server/requestContext.js

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+export function currentRequestEvent() {
+  return storage.getStore();
+}
+export function requestIdOf(event) {
+  const reqid = event?.context.reqid || event?.node.req.headers["x-request-id"];
+  return typeof reqid === "string" && reqid ? reqid : void 0;
+}
+export function runInRequestContext(event, handler) {
+  const parentReqid = requestIdOf(storage.getStore());
+  if (parentReqid && !event.node.req.headers["x-request-id"]) {
+    event.node.req.headers["x-request-id"] = parentReqid;
+  }
+  return storage.run(event, handler);
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "hotelme-nuxt-logger",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Стандартний logger для Nuxt проектів з JSON виводом сумісним з бекенд-логами",
   "keywords": [
     "nuxt",
     "nuxt-module",
     "logger",
     "logging",
-    "json-logger"
+    "json-logger",
+    "opentelemetry"
   ],
   "repository": {
     "type": "git",
@@ -24,6 +25,10 @@
     "./runtime/logger": {
       "types": "./dist/runtime/logger.d.ts",
       "import": "./dist/runtime/logger.js"
+    },
+    "./runtime/otel": {
+      "types": "./dist/runtime/server/otel/tracing.d.ts",
+      "import": "./dist/runtime/server/otel/tracing.js"
     }
   },
   "main": "./dist/module.cjs",
@@ -41,7 +46,15 @@
     "test": "echo \"No tests yet\""
   },
   "dependencies": {
-    "@nuxt/kit": "^3.0.0"
+    "@nuxt/kit": "^3.0.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/core": "^2.11.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
+    "@opentelemetry/instrumentation": "^0.222.0",
+    "@opentelemetry/instrumentation-undici": "^0.32.0",
+    "@opentelemetry/resources": "^2.11.0",
+    "@opentelemetry/sdk-trace-base": "^2.11.0",
+    "@opentelemetry/sdk-trace-node": "^2.11.0"
   },
   "devDependencies": {
     "@nuxt/module-builder": "^0.8.0",