@devopsplaybook.io/otel-utils-fastify 1.2.1-beta.33.4459dff → 1.3.0-beta.34.170b681

package/README.md

@@ -8,7 +8,14 @@ Fastify integration for `@devopsplaybook.io/otel-utils`. Automatically creates a
 npm install @devopsplaybook.io/otel-utils-fastify
 ```
 
-Requires `@devopsplaybook.io/otel-utils` as a peer dependency — it must be installed and configured in the consuming project.
+Peer dependencies that must be installed and configured in the consuming project:
+
+| Peer dependency                 | Version  |
+| ------------------------------- | -------- |
+| `@devopsplaybook.io/otel-utils` | `^1.3.0` |
+| `fastify`                       | `^5.0.0` |
+
+Requires Node.js >= 22.
 
 ## Usage
 
@@ -18,12 +25,15 @@ import {
   StandardMeter,
   StandardTracer,
 } from "@devopsplaybook.io/otel-utils";
-import { StandardTracerFastifyRegisterHooks } from "@devopsplaybook.io/otel-utils-fastify";
+import {
+  OTelRequestContext,
+  OTelRequestSpan,
+  StandardTracerFastifyRegisterHooks,
+} from "@devopsplaybook.io/otel-utils-fastify";
+import { context } from "@opentelemetry/api";
 import Fastify from "fastify";
 
-const config = {
-  /* ... ConfigOTelInterface ... */
-};
+const config = {/* ... ConfigOTelInterface ... */};
 
 const tracer = new StandardTracer(config);
 const meter = new StandardMeter(config);
@@ -32,7 +42,7 @@ logger.initOTel(config);
 
 const fastify = Fastify();
 
-// Register hooks once at startup
+// Register hooks once at startup, at the root of the Fastify instance
 StandardTracerFastifyRegisterHooks(fastify, tracer, logger, {
   rootApiPath: "/api",
   ignoreList: ["GET-/api/health"],
@@ -49,41 +59,114 @@ fastify.get("/api/files/:id", async (req, res) => {
   }
   // ...
 });
+
+// Or run handler work inside the request context so everything created
+// within it automatically becomes a child of the HTTP span:
+fastify.get("/api/files", async (req, res) => {
+  const ctx = OTelRequestContext(req);
+  if (!ctx) {
+    return res.send({ files: [] });
+  }
+  return context.with(ctx, async () => {
+    const childSpan = tracer.startSpan("load-files");
+    // ... do work ...
+    childSpan.end();
+  });
+});
 ```
 
 ## Exported API
 
 ### `StandardTracerFastifyRegisterHooks(fastify, standardTracer, standardLogger, options?)`
 
-Registers three Fastify hooks:
+Registers five Fastify hooks:
 
-| Hook         | Behavior                                                                                                                                                                                                                                                   |
-| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `onRequest`  | Extracts W3C trace context from incoming headers. Creates a span named `METHOD-/path` and stores it in a `WeakMap<FastifyRequest, Span>`. Skips OPTIONS requests and paths outside `rootApiPath`. Supports an `ignoreList` to exclude specific span names. |
-| `onResponse` | Sets span status (OK/ERROR based on status code), records `http.response.status_code`, ends the span, and removes it from the WeakMap.                                                                                                                     |
-| `onError`    | Sets span status to ERROR, records the exception, and logs the error via `ModuleLogger` with trace context.                                                                                                                                                |
+| Hook             | Behavior                                                                                                                                                                                                                                                                                                      |
+| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `onRequest`      | Extracts W3C trace context from incoming headers. Creates a `SpanKind.SERVER` span named after the route (`METHOD-<route template>`, path fallback when no route matched) and stores it plus its context in internal `WeakMap`s. Skips OPTIONS requests, paths outside `rootApiPath`, and ignored span names. |
+| `onResponse`     | Sets span status (OK for status <= 299, ERROR otherwise), records `http.response.status_code`, ends the span, and removes it from the `WeakMap`s.                                                                                                                                                             |
+| `onError`        | Sets span status to ERROR, records `error.type` and the exception, and logs the error via `ModuleLogger` with trace context. Non-`Error` throws are normalized to an `Error` first.                                                                                                                           |
+| `onRequestAbort` | Ends the span with ERROR status and `error.type = "client_abort"` when the client aborts the request.                                                                                                                                                                                                         |
+| `onTimeout`      | Ends the span with ERROR status and `error.type = "timeout"` when the connection times out.                                                                                                                                                                                                                   |
+
+Registration is idempotent per Fastify instance: a second registration on the same instance is ignored with a warning. Hooks are registered globally and cannot be removed — register them **once**, at the root of the Fastify instance.
 
 **Options:**
 
-| Field              | Type        | Default  | Description                                                            |
-| ------------------ | ----------- | -------- | ---------------------------------------------------------------------- |
-| `rootApiPath`      | `string?`   | `"/api"` | Only trace requests under this path prefix                             |
-| `ignoreList`       | `string[]?` | —        | Exact span names to skip. Format: `"METHOD-/path"`                     |
-| `ignoreListPrefix` | `string[]?` | —        | Skip when span name **starts with** any of these (native `startsWith`) |
-| `ignoreListSuffix` | `string[]?` | —        | Skip when span name **ends with** any of these (native `endsWith`)     |
+| Field              | Type        | Default  | Description                                                                                                                                                                                |
+| ------------------ | ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `rootApiPath`      | `string?`   | `"/api"` | Only trace the path itself and paths under `"<rootApiPath>/"` (boundary check: `/apiary` is **not** traced, `/apiary/...` neither). `"/"` traces everything. Trailing slashes are ignored. |
+| `ignoreList`       | `string[]?` | —        | Exact span names to skip. Format: `"METHOD-/route"`, using the route template for parameterized routes (e.g. `"GET-/api/files/_id"`).                                                      |
+| `ignoreListPrefix` | `string[]?` | —        | Skip when span name **starts with** any of these (native `startsWith`).                                                                                                                    |
+| `ignoreListSuffix` | `string[]?` | —        | Skip when span name **ends with** any of these (native `endsWith`).                                                                                                                        |
 
 All three ignore lists are checked **in order** (exact → prefix → suffix) with **short-circuit evaluation** — as soon as one matches, the remaining checks are skipped for maximum performance.
 
+### Span naming and attributes
+
+Span names follow `METHOD-<route>`:
+
+- Matched routes use the **route template**: `GET /api/files/:id` → span name `GET-/api/files/_id`.
+- Unmatched routes (e.g. 404) fall back to the request path: `GET /api/unknown` → `GET-/api/unknown`.
+- The query string is never part of the span name.
+- Span names are sanitized with the same regex used by `@devopsplaybook.io/otel-utils` (`[^a-zA-Z0-9-_/]` → `_`), so `ignoreList` entries match the exported span name.
+- Spans are created with `SpanKind.SERVER` and the usual synthetic `StandardTracer` attributes (`http.request_method=BACKEND`, synthetic `http.route`) are **not** added — real HTTP attributes are set instead.
+
+Attributes set on each HTTP span:
+
+| Attribute                   | Value                                                                    |
+| --------------------------- | ------------------------------------------------------------------------ |
+| `http.request.method`       | Request method (`GET`, `POST`, ...)                                      |
+| `url.path`                  | Request path, **without** query string                                   |
+| `http.route`                | Route template — only when the request matched a route                   |
+| `http.response.status_code` | Response status code                                                     |
+| `error.type`                | Error name, or `client_abort` / `timeout` for aborted/timed out requests |
+
+The query string is not recorded (`url.query` is not set).
+
 ### `OTelRequestSpan(req)`
 
-Retrieves the active span for a Fastify request from the internal WeakMap.
+Retrieves the active span for a Fastify request from the internal `WeakMap`.
+
+|               |                                                                                        |
+| ------------- | -------------------------------------------------------------------------------------- |
+| **Parameter** | `req: FastifyRequest`                                                                  |
+| **Returns**   | `Span \| undefined` — `undefined` when the request was skipped or after the span ended |
+
+Use it to parent spans created in route handlers:
 
-|               |                                                                                                                     |
-| ------------- | ------------------------------------------------------------------------------------------------------------------- |
-| **Parameter** | `req: FastifyRequest`                                                                                               |
-| **Returns**   | `Span \| undefined` — `undefined` when the request was skipped (OPTIONS, outside `rootApiPath`, or in `ignoreList`) |
+```typescript
+const childSpan = tracer.startSpan("my-work", OTelRequestSpan(req));
+```
+
+### `OTelRequestContext(req)`
+
+Retrieves the OpenTelemetry `Context` for a Fastify request: the incoming W3C trace context with the HTTP span set as active span.
 
-Used in route handlers to access the current span for custom attributes or sub-spans.
+|               |                                                                                           |
+| ------------- | ----------------------------------------------------------------------------------------- |
+| **Parameter** | `req: FastifyRequest`                                                                     |
+| **Returns**   | `Context \| undefined` — `undefined` when the request was skipped or after the span ended |
+
+Because Fastify runs hooks and handlers in separate async contexts, the span cannot be active automatically after the `onRequest` hook returns. Wrapping handler work in `context.with(OTelRequestContext(req), ...)` makes any span created inside it a child of the HTTP span:
+
+```typescript
+fastify.get("/api/files/:id", async (req, res) => {
+  const ctx = OTelRequestContext(req);
+  if (!ctx) {
+    return res.send({});
+  }
+  return context.with(ctx, async () => {
+    const childSpan = tracer.startSpan("load-file"); // child of the HTTP span
+    // ...
+    childSpan.end();
+  });
+});
+```
+
+### Deprecated: `req.tracerSpanApi`
+
+The span is also assigned to `req.tracerSpanApi` as a deprecated compatibility alias. Use `OTelRequestSpan(req)` instead.
 
 ## Architecture
 
@@ -91,36 +174,49 @@ Used in route handlers to access the current span for custom attributes or sub-s
 Incoming Request
   │
   ▼
-  onRequest hook
-    ├── propagator.extract(headers)  ← W3C trace context from caller
-    ├── context.with(ctx, () => { ... })
-    │     └── standardTracer.startSpan("METHOD-/path")
-    │           └── WeakMap<req, span>
-    └── Route handler
-          └── OTelRequestSpan(req) → span
-  onResponse / onError
-    └── WeakMap.get(req) → span
-          ├── span.setStatus({ code })
-          ├── span.setAttribute(...)
-          ├── span.end() / span.recordException(error)
-          └── WeakMap.delete(req)
+onRequest hook
+  ├── propagator.extract(headers)  ← W3C trace context from caller
+  ├── context.with(ctx, () => { ... })
+  │     └── standardTracer.startSpan(spanName, undefined, { kind: SERVER })
+  │           └── WeakMap<req, span> + WeakMap<req, context>
+  └── Route handler
+        └── OTelRequestSpan(req)
+              or context.with(OTelRequestContext(req), () => ...)
+onResponse / onError / onRequestAbort / onTimeout
+  └── WeakMap.get(req) → span
+        ├── span.setStatus({ code })
+        ├── span.setAttribute(...)
+        ├── span.end() / span.recordException(error)
+        └── WeakMap.delete(req)
 ```
 
-The span is stored in a `WeakMap` rather than as a property on the request object, avoiding type pollution and allowing natural garbage collection.
+The span and context are stored in `WeakMap`s rather than as properties on the request object, avoiding type pollution and allowing natural garbage collection. The `tracerSpanApi` alias is deleted when the span ends (it is a plain property, so it must be removed explicitly).
+
+## Behavior changes in 1.3.0
+
+- Span names now use the **route template** for matched routes and the path fallback otherwise (previously the raw path, including dynamic segments), and are sanitized like `StandardTracer` span names. Update `ignoreList` entries accordingly (e.g. `"GET-/api/files/_id"`).
+- `url.path` is now recorded **without** the query string.
+- Spans are `SpanKind.SERVER`; synthetic `BACKEND` attributes from `StandardTracer` are no longer added.
+- Client aborts and connection timeouts end the span with ERROR status and `error.type`.
+- `rootApiPath` uses a segment boundary check (`/apiary` is no longer traced).
+- Requires `@devopsplaybook.io/otel-utils` `^1.3.0` (uses `StandardTracer.startSpan(name, parentSpan?, options?)`).
 
 ## Dependencies
 
-| Package                               | Purpose                                     |
-| ------------------------------------- | ------------------------------------------- |
-| `@devopsplaybook.io/otel-utils`       | StandardTracer and StandardLogger instances |
-| `@opentelemetry/api`                  | Context management, span status codes       |
-| `@opentelemetry/core`                 | W3C trace context propagator                |
-| `@opentelemetry/sdk-trace-base`       | Span type                                   |
-| `@opentelemetry/semantic-conventions` | HTTP semantic attribute constants           |
-| `fastify`                             | Fastify web framework                       |
+| Package                               | Type       | Purpose                                     |
+| ------------------------------------- | ---------- | ------------------------------------------- |
+| `@devopsplaybook.io/otel-utils`       | peer       | StandardTracer and StandardLogger instances |
+| `fastify`                             | peer       | Fastify web framework (v5)                  |
+| `@opentelemetry/api`                  | dependency | Context management, span status codes       |
+| `@opentelemetry/core`                 | dependency | W3C trace context propagator                |
+| `@opentelemetry/sdk-trace-base`       | dependency | Span type                                   |
+| `@opentelemetry/semantic-conventions` | dependency | HTTP semantic attribute constants           |
 
-## Build
+## Build, lint, test
 
 ```bash
-npm run build   # tsc → dist/, then type-checks the spec files (tsc --noEmit)
+npm run build    # tsc → dist/, then type-checks the spec files (tsc --noEmit)
+npm run lint     # oxlint index.ts src && prettier --check .
+npm run format   # prettier --write .
+npm test         # jest --coverage (coverage thresholds enforced)
 ```

package/dist/src/StandardTracerFastify.d.ts

@@ -1,4 +1,5 @@
 import { StandardLogger, StandardTracer } from "@devopsplaybook.io/otel-utils";
+import { Context } from "@opentelemetry/api";
 import { Span } from "@opentelemetry/sdk-trace-base";
 import { FastifyInstance, FastifyRequest } from "fastify";
 /**
@@ -7,13 +8,16 @@ import { FastifyInstance, FastifyRequest } from "fastify";
 export interface StandardTracerFastifyRegisterHooksOptions {
     /**
      * Root path prefix for API routes.
-     * Only requests starting with this path will be traced. Default `"/api"`.
+     * Only requests under this path (the path itself or paths starting with
+     * `"<rootApiPath>/"`) will be traced. Default `"/api"`.
      */
     rootApiPath?: string;
     /**
      * Span names to skip by exact match (e.g. `"GET-/api/health"`).
-     * Checked first — O(1) per entry via hash-optimized string compare.
-     * Format: `"METHOD-/path"` — the same format used for span names.
+     * Checked first, with a linear scan over the array entries.
+     * Format: `"METHOD-/route"` — the same sanitized format used for span names,
+     * with the route template for parameterized routes (e.g.
+     * `"GET-/api/files/_id"` for `/api/files/:id`).
      */
     ignoreList?: string[];
     /**
@@ -34,12 +38,25 @@ export interface StandardTracerFastifyRegisterHooksOptions {
  * OpenTelemetry spans for each matching API request.
  *
  * - Extracts incoming W3C trace context from request headers for distributed tracing.
- * - Records HTTP method, URL path, and response status code as span attributes.
+ * - Creates a `SpanKind.SERVER` span named `METHOD-<route>` (route template for
+ *   matched routes, e.g. `GET-/api/files/_id` for `/api/files/:id`; path
+ *   fallback when no route matched), with `http.request.method`, `url.path`
+ *   (path only, no query string) and `http.route` (route template) attributes.
  * - Marks spans as ERROR on 4xx/5xx responses or when exceptions occur.
+ * - Ends the span on response, handler error, client abort or connection timeout.
  * - Logs errors via the provided {@link StandardLogger} with trace context.
  * - Skips OPTIONS requests and requests outside the configured `rootApiPath`.
  * - Additional filtering via `ignoreList` (exact), `ignoreListPrefix`, `ignoreListSuffix`
- *   — checked in that order with short-circuit evaluation for maximum performance.
+ *   — checked in that order with short-circuit evaluation.
+ *
+ * Register the hooks **once**, at the root of the Fastify instance: a second
+ * registration on the same instance is ignored (with a warning), and hooks
+ * registered inside an encapsulated plugin only see the requests routed
+ * through that plugin scope.
+ *
+ * Use {@link OTelRequestContext} (or {@link OTelRequestSpan} as an explicit
+ * parent) inside route handlers to attach the work of the request to the
+ * HTTP span.
  *
  * @param fastify         - The Fastify instance to attach hooks to.
  * @param standardTracer  - A configured {@link StandardTracer} instance.
@@ -52,9 +69,25 @@ export declare function StandardTracerFastifyRegisterHooks(fastify: FastifyInsta
  *
  * The span is created during the `onRequest` hook and stored in an internal
  * `WeakMap` keyed on the request object. Returns `undefined` when no span
- * exists (e.g., the request was skipped by filtering).
+ * exists (e.g., the request was skipped by filtering) or once the span ended.
+ *
+ * Use it to parent spans created in route handlers:
+ * `standardTracer.startSpan("my-work", OTelRequestSpan(req))`.
  *
  * @param req - The Fastify request object.
  * @returns The active span, or `undefined` if no span was created for this request.
  */
 export declare function OTelRequestSpan(req: FastifyRequest): Span | undefined;
+/**
+ * Retrieves the OpenTelemetry context associated with a Fastify request.
+ *
+ * The context holds the incoming W3C trace context with the HTTP request span
+ * set as the active span, so spans created inside
+ * `context.with(OTelRequestContext(req), () => ...)` become children of the
+ * HTTP span. Returns `undefined` when no span was created (skipped request)
+ * or once the span ended.
+ *
+ * @param req - The Fastify request object.
+ * @returns The request context, or `undefined` if no span was created for this request.
+ */
+export declare function OTelRequestContext(req: FastifyRequest): Context | undefined;

package/dist/src/StandardTracerFastify.js

@@ -2,22 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StandardTracerFastifyRegisterHooks = StandardTracerFastifyRegisterHooks;
 exports.OTelRequestSpan = OTelRequestSpan;
+exports.OTelRequestContext = OTelRequestContext;
 const api_1 = require("@opentelemetry/api");
 const core_1 = require("@opentelemetry/core");
 const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
 const propagator = new core_1.W3CTraceContextPropagator();
+// Same sanitization as @devopsplaybook.io/otel-utils, applied here so that
+// `ignoreList` entries are matched against the exported span name.
+const SPAN_NAME_SANITIZE_RE = /[^a-zA-Z0-9-_/]/g;
+const DEFAULT_ROOT_API_PATH = "/api";
 const requestSpans = new WeakMap();
+const requestContexts = new WeakMap();
+const registeredFastifyInstances = new WeakSet();
 /**
  * Registers Fastify lifecycle hooks that automatically create and manage
  * OpenTelemetry spans for each matching API request.
  *
  * - Extracts incoming W3C trace context from request headers for distributed tracing.
- * - Records HTTP method, URL path, and response status code as span attributes.
+ * - Creates a `SpanKind.SERVER` span named `METHOD-<route>` (route template for
+ *   matched routes, e.g. `GET-/api/files/_id` for `/api/files/:id`; path
+ *   fallback when no route matched), with `http.request.method`, `url.path`
+ *   (path only, no query string) and `http.route` (route template) attributes.
  * - Marks spans as ERROR on 4xx/5xx responses or when exceptions occur.
+ * - Ends the span on response, handler error, client abort or connection timeout.
  * - Logs errors via the provided {@link StandardLogger} with trace context.
  * - Skips OPTIONS requests and requests outside the configured `rootApiPath`.
  * - Additional filtering via `ignoreList` (exact), `ignoreListPrefix`, `ignoreListSuffix`
- *   — checked in that order with short-circuit evaluation for maximum performance.
+ *   — checked in that order with short-circuit evaluation.
+ *
+ * Register the hooks **once**, at the root of the Fastify instance: a second
+ * registration on the same instance is ignored (with a warning), and hooks
+ * registered inside an encapsulated plugin only see the requests routed
+ * through that plugin scope.
+ *
+ * Use {@link OTelRequestContext} (or {@link OTelRequestSpan} as an explicit
+ * parent) inside route handlers to attach the work of the request to the
+ * HTTP span.
  *
  * @param fastify         - The Fastify instance to attach hooks to.
  * @param standardTracer  - A configured {@link StandardTracer} instance.
@@ -26,54 +46,104 @@ const requestSpans = new WeakMap();
  */
 function StandardTracerFastifyRegisterHooks(fastify, standardTracer, standardLogger, options) {
     const logger = standardLogger.createModuleLogger("Fastify");
+    if (registeredFastifyInstances.has(fastify)) {
+        logger.warn("StandardTracerFastifyRegisterHooks is already registered on this Fastify instance: ignoring the duplicate registration.");
+        return;
+    }
+    registeredFastifyInstances.add(fastify);
+    const rootApiPath = normalizeRootApiPath(options === null || options === void 0 ? void 0 : options.rootApiPath);
+    const endSpan = (req, end = {}) => {
+        const span = requestSpans.get(req);
+        if (!span) {
+            return;
+        }
+        requestSpans.delete(req);
+        requestContexts.delete(req);
+        delete req.tracerSpanApi;
+        if (end.errorType) {
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+            span.setAttribute(semantic_conventions_1.ATTR_ERROR_TYPE, end.errorType);
+        }
+        else if (end.statusCode !== undefined) {
+            span.setStatus({
+                code: end.statusCode > 299 ? api_1.SpanStatusCode.ERROR : api_1.SpanStatusCode.OK,
+            });
+            span.setAttribute(semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE, end.statusCode);
+        }
+        span.end();
+    };
     fastify.addHook("onRequest", async (req) => {
         var _a, _b, _c;
-        if (req.method === "OPTIONS" ||
-            !req.url.startsWith((options === null || options === void 0 ? void 0 : options.rootApiPath) || "/api")) {
+        if (req.method === "OPTIONS") {
+            return;
+        }
+        const path = req.url.split("?")[0];
+        if (rootApiPath !== "/" &&
+            path !== rootApiPath &&
+            !path.startsWith(`${rootApiPath}/`)) {
             return;
         }
-        const spanName = `${req.method}-${req.url.split("?")[0]}`;
+        const routeTemplate = req.routeOptions.url;
+        const spanName = sanitizeSpanName(`${req.method}-${routeTemplate || path}`);
         if (((_a = options === null || options === void 0 ? void 0 : options.ignoreList) === null || _a === void 0 ? void 0 : _a.includes(spanName)) ||
             ((_b = options === null || options === void 0 ? void 0 : options.ignoreListPrefix) === null || _b === void 0 ? void 0 : _b.some((p) => spanName.startsWith(p))) ||
             ((_c = options === null || options === void 0 ? void 0 : options.ignoreListSuffix) === null || _c === void 0 ? void 0 : _c.some((s) => spanName.endsWith(s)))) {
             return;
         }
         const callerContext = propagator.extract(api_1.ROOT_CONTEXT, req.headers, api_1.defaultTextMapGetter);
-        api_1.context.with(callerContext, () => {
-            const span = standardTracer.startSpan(spanName);
-            span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, req.method);
-            span.setAttribute(semantic_conventions_1.ATTR_URL_PATH, req.url);
-            requestSpans.set(req, span);
-        });
+        // The span is created inside the extracted context so that it becomes a
+        // child of the caller span when the request carries a `traceparent`.
+        const span = api_1.context.with(callerContext, () => standardTracer.startSpan(spanName, undefined, {
+            kind: api_1.SpanKind.SERVER,
+        }));
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, req.method);
+        span.setAttribute(semantic_conventions_1.ATTR_URL_PATH, path);
+        if (routeTemplate) {
+            span.setAttribute(semantic_conventions_1.ATTR_HTTP_ROUTE, routeTemplate);
+        }
+        requestSpans.set(req, span);
+        requestContexts.set(req, api_1.trace.setSpan(callerContext, span));
+        // Deprecated alias kept for consumers that reimplemented the accessor
+        // (`req.tracerSpanApi` before 1.1.0); use OTelRequestSpan(req) instead.
+        req.tracerSpanApi = span;
     });
     fastify.addHook("onResponse", async (req, reply) => {
-        const span = requestSpans.get(req);
-        if (!span) {
-            return;
-        }
-        span.setStatus({
-            code: reply.statusCode > 299 ? api_1.SpanStatusCode.ERROR : api_1.SpanStatusCode.OK,
-        });
-        span.setAttribute(semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
-        span.end();
-        requestSpans.delete(req);
+        endSpan(req, { statusCode: reply.statusCode });
     });
     fastify.addHook("onError", async (req, _reply, error) => {
         const span = requestSpans.get(req);
         if (!span) {
             return;
         }
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
         span.setStatus({ code: api_1.SpanStatusCode.ERROR });
-        span.recordException(error);
-        logger.error(error.message, error, span);
+        span.setAttribute(semantic_conventions_1.ATTR_ERROR_TYPE, normalizedError.name);
+        span.recordException(normalizedError);
+        logger.error(normalizedError.message, normalizedError, span);
     });
+    fastify.addHook("onRequestAbort", async (req) => {
+        endSpan(req, { errorType: "client_abort" });
+    });
+    fastify.addHook("onTimeout", async (req, _reply) => {
+        endSpan(req, { errorType: "timeout" });
+    });
+}
+function normalizeRootApiPath(rootApiPath) {
+    const normalized = (rootApiPath || DEFAULT_ROOT_API_PATH).replace(/\/+$/, "");
+    return normalized === "" ? "/" : normalized;
+}
+function sanitizeSpanName(name) {
+    return name.replace(SPAN_NAME_SANITIZE_RE, "_");
 }
 /**
  * Retrieves the OpenTelemetry span associated with a Fastify request.
  *
  * The span is created during the `onRequest` hook and stored in an internal
  * `WeakMap` keyed on the request object. Returns `undefined` when no span
- * exists (e.g., the request was skipped by filtering).
+ * exists (e.g., the request was skipped by filtering) or once the span ended.
+ *
+ * Use it to parent spans created in route handlers:
+ * `standardTracer.startSpan("my-work", OTelRequestSpan(req))`.
  *
  * @param req - The Fastify request object.
  * @returns The active span, or `undefined` if no span was created for this request.
@@ -81,3 +151,18 @@ function StandardTracerFastifyRegisterHooks(fastify, standardTracer, standardLog
 function OTelRequestSpan(req) {
     return requestSpans.get(req);
 }
+/**
+ * Retrieves the OpenTelemetry context associated with a Fastify request.
+ *
+ * The context holds the incoming W3C trace context with the HTTP request span
+ * set as the active span, so spans created inside
+ * `context.with(OTelRequestContext(req), () => ...)` become children of the
+ * HTTP span. Returns `undefined` when no span was created (skipped request)
+ * or once the span ended.
+ *
+ * @param req - The Fastify request object.
+ * @returns The request context, or `undefined` if no span was created for this request.
+ */
+function OTelRequestContext(req) {
+    return requestContexts.get(req);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devopsplaybook.io/otel-utils-fastify",
-  "version": "1.2.1-beta.33.4459dff",
+  "version": "1.3.0-beta.34.170b681",
   "description": "Utility to simplify integration with Open Telemetry for Fastify API Server",
   "keywords": [
     "Open Telemetry",
@@ -14,26 +14,39 @@
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "tsc && tsc -p tsconfig.spec.json --noEmit",
-    "lint": "oxlint src",
+    "format": "prettier --write .",
+    "lint": "oxlint index.ts src && prettier --check .",
     "test": "jest --coverage"
   },
+  "peerDependencies": {
+    "@devopsplaybook.io/otel-utils": "^1.3.0",
+    "fastify": "^5.0.0"
+  },
   "dependencies": {
-    "@devopsplaybook.io/otel-utils": "^1.2.1",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/core": "^2.11.0",
     "@opentelemetry/sdk-trace-base": "^2.11.0",
-    "@opentelemetry/semantic-conventions": "^1.43.0",
-    "fastify": "^5.12.5"
+    "@opentelemetry/semantic-conventions": "^1.43.0"
   },
   "devDependencies": {
+    "@devopsplaybook.io/otel-utils": "^1.3.0",
+    "@opentelemetry/sdk-trace-node": "^2.11.0",
     "@swc/core": "^1.16.2",
     "@swc/jest": "^0.2.39",
     "@types/jest": "^30.0.0",
     "@types/node": "^26.6.2",
+    "fastify": "^5.12.5",
     "jest": "^30.5.2",
     "oxlint": "^1.85.0",
+    "prettier": "^3.9.9",
     "typescript": "^7.0.2"
   },
   "publishConfig": {

package/.github/workflows/main-build.yml

@@ -1,16 +0,0 @@
-name: Main Build
-
-on:
-  push:
-    branches: ["main"]
-
-  workflow_dispatch:
-
-jobs:
-  npm-merge:
-    uses: devopsplaybook-io/common-utils/.github/workflows/reusable-npm-merge.yml@main
-    with:
-      npm_package_name: "@devopsplaybook.io/otel-utils-fastify"
-      node_version: "22"
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/pr-check.yml

@@ -1,25 +0,0 @@
-name: PR Check
-
-on:
-  pull_request:
-    branches: ["main"]
-
-  workflow_dispatch:
-
-concurrency:
-  group: pr-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-  pull-requests: write
-  issues: write
-
-jobs:
-  npm-pr:
-    uses: devopsplaybook-io/common-utils/.github/workflows/reusable-npm-pr.yml@main
-    with:
-      npm_package_name: "@devopsplaybook.io/otel-utils-fastify"
-      node_version: "22"
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/index.ts

@@ -1 +0,0 @@
-export * from "./src/StandardTracerFastify";

package/jest.config.js

@@ -1,17 +0,0 @@
-module.exports = {
-  moduleFileExtensions: ["ts", "js"],
-  transform: {
-    "^.+\\.(ts|tsx)$": [
-      "@swc/jest",
-      {
-        jsc: {
-          target: "es2019",
-        },
-      },
-    ],
-  },
-  coverageProvider: "v8",
-  testMatch: ["/**/src/**/*.spec.(ts|js)"],
-  testPathIgnorePatterns: ["/node_modules/", "/dist/"],
-  testEnvironment: "node",
-};

package/prettierrc.json

@@ -1,5 +0,0 @@
-{
-  "tabWidth": 2,
-  "semi": true,
-  "singleQuote": false
-}

package/src/StandardTracerFastify.spec.ts

@@ -1,308 +0,0 @@
-import Fastify from "fastify";
-import { SpanStatusCode } from "@opentelemetry/api";
-import {
-  StandardTracerFastifyRegisterHooks,
-  StandardTracerFastifyRegisterHooksOptions,
-  OTelRequestSpan,
-} from "./StandardTracerFastify";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function createMockSpan() {
-  return {
-    setAttribute: jest.fn().mockReturnThis(),
-    setStatus: jest.fn().mockReturnThis(),
-    end: jest.fn(),
-    recordException: jest.fn(),
-  };
-}
-
-function createMockTracer(mockSpan: ReturnType<typeof createMockSpan>) {
-  return { startSpan: jest.fn().mockReturnValue(mockSpan) };
-}
-
-function createMockLogger() {
-  return {
-    createModuleLogger: jest.fn().mockReturnValue({
-      info: jest.fn(),
-      error: jest.fn(),
-    }),
-  };
-}
-
-/** Build a Fastify app with hooks registered and a few test routes. */
-function buildApp(options?: StandardTracerFastifyRegisterHooksOptions) {
-  const mockSpan = createMockSpan();
-  const mockTracer = createMockTracer(mockSpan);
-  const mockLogger = createMockLogger();
-
-  const app = Fastify();
-
-  app.get("/api/test", async () => ({ ok: true }));
-  app.get("/api/status", async (_req, res) =>
-    res.status(400).send({ error: "bad" }),
-  );
-  app.get("/api/error-test", async () => {
-    throw new Error("test error");
-  });
-  app.get("/api/echo", async (req, res) => {
-    const span = OTelRequestSpan(req);
-    return res.send({ hasSpan: !!span });
-  });
-  app.options("/api/echo", async (req, res) => {
-    const span = OTelRequestSpan(req);
-    return res.send({ hasSpan: !!span });
-  });
-  app.get("/api/pub/health", async () => ({ ok: true }));
-  app.get("/api/pub/metrics", async () => ({ ok: true }));
-  app.get("/api/health", async () => ({ ok: true }));
-
-  StandardTracerFastifyRegisterHooks(
-    app,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mockTracer as any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mockLogger as any,
-    options,
-  );
-
-  return { app, mockSpan, mockTracer, mockLogger };
-}
-
-// ---------------------------------------------------------------------------
-// Request filtering
-// ---------------------------------------------------------------------------
-
-describe("request filtering", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test("skips OPTIONS requests", async () => {
-    const { app, mockTracer } = buildApp();
-    await app.inject({ method: "OPTIONS", url: "/api/test" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("skips requests outside rootApiPath", async () => {
-    const { app, mockTracer } = buildApp({ rootApiPath: "/api/v2" });
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("traces requests inside rootApiPath", async () => {
-    const { app, mockTracer } = buildApp({ rootApiPath: "/api/v2" });
-    app.get("/api/v2/data", async () => ({ ok: true }));
-    await app.inject({ method: "GET", url: "/api/v2/data" });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/v2/data");
-  });
-
-  test("skips requests matching exact ignoreList", async () => {
-    const { app, mockTracer } = buildApp({ ignoreList: ["GET-/api/test"] });
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("traces requests not in ignoreList", async () => {
-    const { app, mockTracer } = buildApp({ ignoreList: ["GET-/api/other"] });
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockTracer.startSpan).toHaveBeenCalled();
-  });
-
-  test("skips requests matching ignoreListPrefix", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreListPrefix: ["GET-/api/pub"],
-    });
-    await app.inject({ method: "GET", url: "/api/pub/health" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("skips requests matching ignoreListPrefix (nested path)", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreListPrefix: ["GET-/api/pub"],
-    });
-    await app.inject({ method: "GET", url: "/api/pub/metrics" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("does not skip requests not matching ignoreListPrefix", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreListPrefix: ["GET-/api/private"],
-    });
-    await app.inject({ method: "GET", url: "/api/pub/health" });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/pub/health");
-  });
-
-  test("skips requests matching ignoreListSuffix", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreListSuffix: ["/health"],
-    });
-    await app.inject({ method: "GET", url: "/api/health" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("does not skip requests not matching ignoreListSuffix", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreListSuffix: ["/other"],
-    });
-    await app.inject({ method: "GET", url: "/api/health" });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/health");
-  });
-
-  test("skips when exact match takes priority over prefix", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreList: ["GET-/api/test"],
-      ignoreListPrefix: ["GET-/api/other"],
-    });
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockTracer.startSpan).not.toHaveBeenCalled();
-  });
-
-  test("traces when no ignore list matches", async () => {
-    const { app, mockTracer } = buildApp({
-      ignoreList: ["GET-/api/health"],
-      ignoreListPrefix: ["GET-/api/pub"],
-      ignoreListSuffix: ["/metrics"],
-    });
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/test");
-  });
-
-  test("traces when callerContext propagation works silently", async () => {
-    const { app, mockTracer } = buildApp();
-    await app.inject({
-      method: "GET",
-      url: "/api/test",
-      headers: {
-        traceparent: "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01",
-      },
-    });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/test");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Span lifecycle
-// ---------------------------------------------------------------------------
-
-describe("span lifecycle", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test("creates span with method-path name on onRequest", async () => {
-    const { app, mockTracer } = buildApp();
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/test");
-  });
-
-  test("strips query string from span name", async () => {
-    const { app, mockTracer } = buildApp();
-    await app.inject({ method: "GET", url: "/api/test?foo=bar" });
-    expect(mockTracer.startSpan).toHaveBeenCalledWith("GET-/api/test");
-  });
-
-  test("sets http.request_method attribute", async () => {
-    const { app, mockSpan } = buildApp();
-    await app.inject({ method: "POST", url: "/api/test" });
-    expect(mockSpan.setAttribute).toHaveBeenCalledWith(
-      "http.request.method",
-      "POST",
-    );
-  });
-
-  test("sets url.path attribute", async () => {
-    const { app, mockSpan } = buildApp();
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockSpan.setAttribute).toHaveBeenCalledWith("url.path", "/api/test");
-  });
-
-  test("sets status and ends span on success response", async () => {
-    const { app, mockSpan } = buildApp();
-    await app.inject({ method: "GET", url: "/api/test" });
-    expect(mockSpan.setStatus).toHaveBeenCalledWith({
-      code: SpanStatusCode.OK,
-    });
-    expect(mockSpan.setAttribute).toHaveBeenCalledWith(
-      "http.response.status_code",
-      200,
-    );
-    expect(mockSpan.end).toHaveBeenCalledTimes(1);
-  });
-
-  test("sets ERROR status on 4xx response", async () => {
-    const { app, mockSpan } = buildApp();
-    await app.inject({ method: "GET", url: "/api/status" });
-    expect(mockSpan.setStatus).toHaveBeenCalledWith({
-      code: SpanStatusCode.ERROR,
-    });
-  });
-
-  test("records exception on handler error", async () => {
-    const { app, mockSpan } = buildApp();
-    await app.inject({ method: "GET", url: "/api/error-test" });
-    expect(mockSpan.recordException).toHaveBeenCalledWith(expect.any(Error));
-    expect(mockSpan.setStatus).toHaveBeenCalledWith({
-      code: SpanStatusCode.ERROR,
-    });
-  });
-
-  test("logger.error is called on handler error", async () => {
-    const { app, mockLogger } = buildApp();
-    await app.inject({ method: "GET", url: "/api/error-test" });
-    const moduleLogger = mockLogger.createModuleLogger.mock.results[0].value;
-    expect(moduleLogger.error).toHaveBeenCalledWith(
-      "test error",
-      expect.any(Error),
-      expect.any(Object),
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// OTelRequestSpan
-// ---------------------------------------------------------------------------
-
-describe("OTelRequestSpan", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test("returns a span for traced requests", async () => {
-    const { app } = buildApp();
-    const res = await app.inject({ method: "GET", url: "/api/echo" });
-    expect(JSON.parse(res.body)).toEqual({ hasSpan: true });
-  });
-
-  test("returns undefined for OPTIONS requests", async () => {
-    const { app } = buildApp();
-    const res = await app.inject({ method: "OPTIONS", url: "/api/echo" });
-    expect(JSON.parse(res.body)).toEqual({ hasSpan: false });
-  });
-
-  test("returns undefined for requests outside rootApiPath", async () => {
-    const { app } = buildApp({ rootApiPath: "/api/v2" });
-    const res = await app.inject({ method: "GET", url: "/api/echo" });
-    expect(JSON.parse(res.body)).toEqual({ hasSpan: false });
-  });
-
-  test("returns undefined for requests matching ignoreList", async () => {
-    const { app } = buildApp({ ignoreList: ["GET-/api/echo"] });
-    const res = await app.inject({ method: "GET", url: "/api/echo" });
-    expect(JSON.parse(res.body)).toEqual({ hasSpan: false });
-  });
-
-  test("returns undefined for requests matching ignoreListPrefix", async () => {
-    const { app } = buildApp({ ignoreListPrefix: ["GET-/api/ech"] });
-    const res = await app.inject({ method: "GET", url: "/api/echo" });
-    expect(JSON.parse(res.body)).toEqual({ hasSpan: false });
-  });
-
-  test("returns undefined for requests matching ignoreListSuffix", async () => {
-    const { app } = buildApp({ ignoreListSuffix: ["/echo"] });
-    const res = await app.inject({ method: "GET", url: "/api/echo" });
-    expect(JSON.parse(res.body)).toEqual({ hasSpan: false });
-  });
-});

package/src/StandardTracerFastify.ts

@@ -1,144 +0,0 @@
-import { StandardLogger, StandardTracer } from "@devopsplaybook.io/otel-utils";
-import {
-  context,
-  defaultTextMapGetter,
-  ROOT_CONTEXT,
-  SpanStatusCode,
-} from "@opentelemetry/api";
-import { W3CTraceContextPropagator } from "@opentelemetry/core";
-import { Span } from "@opentelemetry/sdk-trace-base";
-import {
-  ATTR_HTTP_REQUEST_METHOD,
-  ATTR_HTTP_RESPONSE_STATUS_CODE,
-  ATTR_URL_PATH,
-} from "@opentelemetry/semantic-conventions";
-import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
-
-const propagator = new W3CTraceContextPropagator();
-const requestSpans = new WeakMap<FastifyRequest, Span>();
-
-/**
- * Options for {@link StandardTracerFastifyRegisterHooks}.
- */
-export interface StandardTracerFastifyRegisterHooksOptions {
-  /**
-   * Root path prefix for API routes.
-   * Only requests starting with this path will be traced. Default `"/api"`.
-   */
-  rootApiPath?: string;
-  /**
-   * Span names to skip by exact match (e.g. `"GET-/api/health"`).
-   * Checked first — O(1) per entry via hash-optimized string compare.
-   * Format: `"METHOD-/path"` — the same format used for span names.
-   */
-  ignoreList?: string[];
-  /**
-   * Span names to skip when the span name **starts with** one of these strings.
-   * Checked after exact match. Uses native `String.prototype.startsWith`.
-   * Example: `["GET-/api/public/"]` ignores all GET requests under that prefix.
-   */
-  ignoreListPrefix?: string[];
-  /**
-   * Span names to skip when the span name **ends with** one of these strings.
-   * Checked last. Uses native `String.prototype.endsWith`.
-   * Example: `["/health", "/metrics"]` ignores all methods targeting those paths.
-   */
-  ignoreListSuffix?: string[];
-}
-
-/**
- * Registers Fastify lifecycle hooks that automatically create and manage
- * OpenTelemetry spans for each matching API request.
- *
- * - Extracts incoming W3C trace context from request headers for distributed tracing.
- * - Records HTTP method, URL path, and response status code as span attributes.
- * - Marks spans as ERROR on 4xx/5xx responses or when exceptions occur.
- * - Logs errors via the provided {@link StandardLogger} with trace context.
- * - Skips OPTIONS requests and requests outside the configured `rootApiPath`.
- * - Additional filtering via `ignoreList` (exact), `ignoreListPrefix`, `ignoreListSuffix`
- *   — checked in that order with short-circuit evaluation for maximum performance.
- *
- * @param fastify         - The Fastify instance to attach hooks to.
- * @param standardTracer  - A configured {@link StandardTracer} instance.
- * @param standardLogger  - A configured {@link StandardLogger} instance.
- * @param options         - Optional path filtering and ignore lists.
- */
-export function StandardTracerFastifyRegisterHooks(
-  fastify: FastifyInstance,
-  standardTracer: StandardTracer,
-  standardLogger: StandardLogger,
-  options?: StandardTracerFastifyRegisterHooksOptions,
-): void {
-  const logger = standardLogger.createModuleLogger("Fastify");
-
-  fastify.addHook("onRequest", async (req: FastifyRequest) => {
-    if (
-      req.method === "OPTIONS" ||
-      !req.url.startsWith(options?.rootApiPath || "/api")
-    ) {
-      return;
-    }
-    const spanName = `${req.method}-${req.url.split("?")[0]}`;
-    if (
-      options?.ignoreList?.includes(spanName) ||
-      options?.ignoreListPrefix?.some((p) => spanName.startsWith(p)) ||
-      options?.ignoreListSuffix?.some((s) => spanName.endsWith(s))
-    ) {
-      return;
-    }
-    const callerContext = propagator.extract(
-      ROOT_CONTEXT,
-      req.headers,
-      defaultTextMapGetter,
-    );
-    context.with(callerContext, () => {
-      const span = standardTracer.startSpan(spanName);
-      span.setAttribute(ATTR_HTTP_REQUEST_METHOD, req.method);
-      span.setAttribute(ATTR_URL_PATH, req.url);
-      requestSpans.set(req, span);
-    });
-  });
-
-  fastify.addHook(
-    "onResponse",
-    async (req: FastifyRequest, reply: FastifyReply) => {
-      const span = requestSpans.get(req);
-      if (!span) {
-        return;
-      }
-      span.setStatus({
-        code: reply.statusCode > 299 ? SpanStatusCode.ERROR : SpanStatusCode.OK,
-      });
-      span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
-      span.end();
-      requestSpans.delete(req);
-    },
-  );
-
-  fastify.addHook(
-    "onError",
-    async (req: FastifyRequest, _reply: FastifyReply, error: Error) => {
-      const span = requestSpans.get(req);
-      if (!span) {
-        return;
-      }
-      span.setStatus({ code: SpanStatusCode.ERROR });
-      span.recordException(error);
-      logger.error(error.message, error, span);
-    },
-  );
-}
-
-/**
- * Retrieves the OpenTelemetry span associated with a Fastify request.
- *
- * The span is created during the `onRequest` hook and stored in an internal
- * `WeakMap` keyed on the request object. Returns `undefined` when no span
- * exists (e.g., the request was skipped by filtering).
- *
- * @param req - The Fastify request object.
- * @returns The active span, or `undefined` if no span was created for this request.
- */
-export function OTelRequestSpan(req: FastifyRequest): Span | undefined {
-  return requestSpans.get(req);
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2019",
-    "module": "commonjs",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["index.ts", "src/**/*"],
-  "exclude": ["**/*.spec.ts"]
-}

package/tsconfig.spec.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "types": ["jest", "node"]
-  },
-  "include": ["src/**/*.spec.ts"],
-  "exclude": []
-}