@tellann/backend-sdk 0.1.0 → 0.3.0

package/dist/core/trackApi.js

@@ -2,16 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trackApiEvent = trackApiEvent;
 const uuid_1 = require("uuid");
+const capture_1 = require("./capture");
+const requestContext_1 = require("./requestContext");
+const qaEvidence_1 = require("./qaEvidence");
 const MAX_EVENT_SIZE_BYTES = 32 * 1024; // 32 KB limit
+function eventBytes(event) {
+    try {
+        return Buffer.byteLength(JSON.stringify(event), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
 async function trackApiEvent(config, options) {
+    const capture = (0, capture_1.resolveCaptureConfig)(config.capture);
+    const context = (0, requestContext_1.currentRequestContext)();
+    const models = options.models?.length
+        ? options.models.map((entry) => ({
+            model: String(entry.model),
+            operation: entry.operation ?? null,
+            records: entry.records ?? null,
+        }))
+        : (0, requestContext_1.summarizeDataAccess)(context?.dataAccess ?? []);
+    const requestBody = capture.requestBody ? (0, capture_1.sanitizePayload)(options.requestBody, capture) : undefined;
+    const responseBody = capture.responseBody ? (0, capture_1.sanitizePayload)(options.responseBody, capture) : undefined;
+    const query = (0, capture_1.sanitizePayload)(options.query, capture);
     const event = {
         eventId: (0, uuid_1.v4)(),
-        sessionId: options.sessionId ?? config.sessionId ?? (0, uuid_1.v4)(),
+        sessionId: options.sessionId ?? context?.sessionId ?? config.sessionId ?? (0, uuid_1.v4)(),
         tenantId: config.tenantId ?? 'unknown',
         applicationId: config.applicationId,
         environmentId: config.environmentId ?? null,
-        runId: options.runId ?? config.runId ?? null,
-        traceId: options.traceId ?? config.traceId ?? null,
+        runId: options.runId ?? context?.runId ?? config.runId ?? null,
+        traceId: options.traceId ?? context?.traceId ?? config.traceId ?? null,
         agentVersion: config.agentVersion ?? null,
         instrumentationManifestVersion: config.instrumentationManifestVersion ?? null,
         source: 'backend-sdk',
@@ -21,24 +44,48 @@ async function trackApiEvent(config, options) {
         metadata: {
             requestId: options.requestId ?? (0, uuid_1.v4)(),
             endpoint: options.endpoint,
+            route: options.route ?? context?.route ?? null,
             method: options.method.toUpperCase(),
             statusCode: options.statusCode,
             durationMs: options.durationMs,
+            handler: options.handler ?? null,
+            framework: options.framework ?? null,
+            // Sizes are reported even when the bodies themselves are not captured,
+            // so a run can still show throughput for an endpoint whose payloads are
+            // switched off.
+            requestBytes: (0, capture_1.payloadBytes)(options.requestBody) ?? null,
+            responseBytes: (0, capture_1.payloadBytes)(options.responseBody) ?? null,
+            models,
+            ...(query === undefined ? {} : { query }),
+            ...(requestBody === undefined ? {} : { requestBody }),
+            ...(responseBody === undefined ? {} : { responseBody }),
+            ...(() => {
+                const requestHeaders = (0, capture_1.sanitizeHeaders)(options.requestHeaders, capture);
+                const responseHeaders = (0, capture_1.sanitizeHeaders)(options.responseHeaders, capture);
+                return {
+                    ...(requestHeaders ? { requestHeaders } : {}),
+                    ...(responseHeaders ? { responseHeaders } : {}),
+                };
+            })(),
         },
     };
-    // Enforce Size Limit
-    try {
-        const eventJson = JSON.stringify(event);
-        const eventSize = Buffer.byteLength(eventJson, 'utf8');
-        if (eventSize > MAX_EVENT_SIZE_BYTES) {
-            console.error(`[Tellann Backend] API request event discarded. Size (${eventSize} bytes) exceeds limit of ${MAX_EVENT_SIZE_BYTES} bytes.`);
+    // Enforce the size limit. An oversized event used to be dropped whole, which
+    // silently lost the request from the run because one of its payloads was
+    // large. Shedding the payloads keeps the request, its timing and its models.
+    const size = eventBytes(event);
+    if (size === null)
+        return;
+    if (size > MAX_EVENT_SIZE_BYTES) {
+        const metadata = event.metadata;
+        delete metadata.requestBody;
+        delete metadata.responseBody;
+        metadata.payloadsOmitted = 'EVENT_SIZE_LIMIT';
+        const reduced = eventBytes(event);
+        if (reduced === null || reduced > MAX_EVENT_SIZE_BYTES) {
+            console.error(`[Tellann Backend] API request event discarded. Size (${size} bytes) exceeds limit of ${MAX_EVENT_SIZE_BYTES} bytes.`);
             return;
         }
     }
-    catch (err) {
-        console.error('[Tellann Backend] Failed to compute size of API event, discarding', err);
-        return;
-    }
     try {
         const headers = { 'Content-Type': 'application/json' };
         if (config.apiKey) {
@@ -47,10 +94,10 @@ async function trackApiEvent(config, options) {
         if (config.environmentId) {
             headers['x-tellann-environment-id'] = config.environmentId;
         }
-        if (config.runId)
-            headers['x-tellann-run-id'] = config.runId;
-        if (config.traceId)
-            headers['x-tellann-trace-id'] = config.traceId;
+        if (event.runId)
+            headers['x-tellann-run-id'] = event.runId;
+        if (event.traceId)
+            headers['x-tellann-trace-id'] = event.traceId;
         await fetch(`${config.endpoint}/v1/events`, {
             method: 'POST',
             headers,
@@ -60,4 +107,12 @@ async function trackApiEvent(config, options) {
     catch {
         // Silently swallow
     }
+    // A no-op unless this process is configured with a standing ingestion key
+    // rather than a per-run relay credential — see `postQaEvidence`.
+    await (0, qaEvidence_1.postQaEvidence)(config, {
+        eventType: 'QA_BACKEND_REQUEST',
+        metadata: event.metadata,
+        traceId: event.traceId,
+        runId: event.runId,
+    });
 }

package/dist/core/trackDataAccess.d.ts

@@ -0,0 +1,34 @@
+import type { TellannBackendConfig } from './TELLANN';
+import { type TellannRequestContext } from './requestContext';
+export interface TrackDataAccessOptions {
+    /** The model, table or collection the operation ran against. */
+    model: string;
+    /** The operation as the data layer names it: `findMany`, `UPDATE`, `save`. */
+    operation: string;
+    /** How many records it read or changed, where the data layer reports it. */
+    records?: number | null;
+    durationMs?: number | null;
+    /** Leave unset to infer from the operation name. */
+    mutation?: boolean;
+    sessionId?: string;
+    runId?: string;
+    traceId?: string;
+}
+export declare function isMutationOperation(operation: string): boolean;
+/**
+ * Reports one persistence operation.
+ *
+ * Inside a request it is recorded and nothing is sent: the request's own
+ * middleware flushes one event per model and operation when the response is
+ * done, so a handler that reads a model in a loop produces one row rather than
+ * a thousand. Outside a request - a migration, a queue consumer, a management
+ * command - there is nothing to flush it later, so it is sent immediately.
+ */
+export declare function trackDataAccessEvent(config: TellannBackendConfig, options: TrackDataAccessOptions): Promise<void>;
+/**
+ * Sends one event per model and operation the request touched.
+ *
+ * Called by the framework integrations once the response is done. Safe to call
+ * twice: the context is emptied as it is flushed.
+ */
+export declare function flushRequestDataAccess(config: TellannBackendConfig, context: TellannRequestContext | undefined): Promise<void>;

package/dist/core/trackDataAccess.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMutationOperation = isMutationOperation;
+exports.trackDataAccessEvent = trackDataAccessEvent;
+exports.flushRequestDataAccess = flushRequestDataAccess;
+const uuid_1 = require("uuid");
+const requestContext_1 = require("./requestContext");
+const qaEvidence_1 = require("./qaEvidence");
+const MUTATION_PATTERN = /create|update|delete|upsert|insert|write|save|remove|drop|truncate/i;
+function isMutationOperation(operation) {
+    return MUTATION_PATTERN.test(operation);
+}
+/**
+ * Reports one persistence operation.
+ *
+ * Inside a request it is recorded and nothing is sent: the request's own
+ * middleware flushes one event per model and operation when the response is
+ * done, so a handler that reads a model in a loop produces one row rather than
+ * a thousand. Outside a request - a migration, a queue consumer, a management
+ * command - there is nothing to flush it later, so it is sent immediately.
+ */
+async function trackDataAccessEvent(config, options) {
+    const mutation = options.mutation ?? isMutationOperation(options.operation);
+    const recorded = (0, requestContext_1.recordDataAccess)({
+        model: options.model,
+        operation: options.operation,
+        records: options.records ?? null,
+        durationMs: options.durationMs ?? null,
+        mutation,
+    });
+    if (recorded)
+        return;
+    await sendDataAccessEvent(config, {
+        model: options.model,
+        operation: options.operation,
+        records: options.records ?? null,
+        durationMs: options.durationMs ?? null,
+        mutation,
+        count: 1,
+    }, (0, requestContext_1.currentRequestContext)(), options);
+}
+/**
+ * Sends one event per model and operation the request touched.
+ *
+ * Called by the framework integrations once the response is done. Safe to call
+ * twice: the context is emptied as it is flushed.
+ */
+async function flushRequestDataAccess(config, context) {
+    if (!context?.dataAccess.length)
+        return;
+    const summary = (0, requestContext_1.summarizeDataAccess)(context.dataAccess);
+    context.dataAccess = [];
+    await Promise.all(summary.map((entry) => sendDataAccessEvent(config, {
+        model: entry.model,
+        operation: entry.operation,
+        records: entry.records,
+        durationMs: null,
+        mutation: entry.mutation,
+        count: entry.count,
+    }, context, {})));
+}
+async function sendDataAccessEvent(config, access, context, options) {
+    const { model, operation, records, durationMs, mutation } = access;
+    const event = {
+        eventId: (0, uuid_1.v4)(),
+        sessionId: options.sessionId ?? context?.sessionId ?? config.sessionId ?? (0, uuid_1.v4)(),
+        tenantId: config.tenantId ?? 'unknown',
+        applicationId: config.applicationId,
+        environmentId: config.environmentId ?? null,
+        runId: options.runId ?? context?.runId ?? config.runId ?? null,
+        traceId: options.traceId ?? context?.traceId ?? config.traceId ?? null,
+        agentVersion: config.agentVersion ?? null,
+        instrumentationManifestVersion: config.instrumentationManifestVersion ?? null,
+        source: 'backend-sdk',
+        eventVersion: '1.0',
+        eventType: 'BUSINESS_EVENT',
+        timestamp: new Date().toISOString(),
+        metadata: {
+            // The desktop routes on this discriminator, the same way it routes
+            // client-state evidence from the frontend adapters.
+            businessEventType: 'QA_BACKEND_DATA_ACCESS',
+            model: String(model).slice(0, 120),
+            operation: String(operation).slice(0, 60),
+            records,
+            durationMs,
+            mutation,
+            // How many individual operations this row stands for.
+            count: access.count,
+            route: context?.route ?? null,
+            method: context?.method ?? null,
+        },
+    };
+    try {
+        const headers = { 'Content-Type': 'application/json' };
+        if (config.apiKey)
+            headers.Authorization = `Bearer ${config.apiKey}`;
+        if (config.environmentId)
+            headers['x-tellann-environment-id'] = config.environmentId;
+        if (event.runId)
+            headers['x-tellann-run-id'] = event.runId;
+        if (event.traceId)
+            headers['x-tellann-trace-id'] = event.traceId;
+        await fetch(`${config.endpoint}/v1/events`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(event),
+        });
+    }
+    catch {
+        // Telemetry never fails the operation it describes.
+    }
+    await (0, qaEvidence_1.postQaEvidence)(config, {
+        eventType: 'QA_BACKEND_DATA_ACCESS',
+        metadata: event.metadata,
+        traceId: event.traceId,
+        runId: event.runId,
+    });
+}

package/dist/index.d.ts

@@ -1,13 +1,21 @@
 import { TrackApiOptions } from './core/trackApi';
 import { CaptureErrorOptions } from './core/captureError';
 import { TrackStateOptions } from './core/trackState';
+import { TrackDataAccessOptions } from './core/trackDataAccess';
 export * from './core/TELLANN';
 export type { EventType, TellannEvent } from './event-types';
 export { TrackApiOptions } from './core/trackApi';
 export { CaptureErrorOptions } from './core/captureError';
 export { TrackStateOptions } from './core/trackState';
+export { TrackDataAccessOptions, isMutationOperation } from './core/trackDataAccess';
+export type { TellannCaptureConfig } from './core/capture';
+export { currentRequestContext, recordDataAccess, runInRequestContext, summarizeDataAccess, } from './core/requestContext';
+export type { TellannDataAccess, TellannRequestContext } from './core/requestContext';
 export * from './integrations/express';
 export * from './integrations/fastify';
+export * from './integrations/koa';
+export * from './integrations/hapi';
+export * from './integrations/prisma';
 /**
  * Backward compatible helper to track an API call using the initialized TELLANN singleton.
  */
@@ -20,3 +28,8 @@ export declare function captureError(options: CaptureErrorOptions): Promise<void
  * Backward compatible helper to track a state transition using the initialized TELLANN singleton.
  */
 export declare function trackState(options: TrackStateOptions): Promise<void>;
+/**
+ * Backward compatible helper to report a persistence operation using the
+ * initialized TELLANN singleton.
+ */
+export declare function trackDataAccess(options: TrackDataAccessOptions): Promise<void>;

package/dist/index.js

@@ -14,13 +14,25 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeDataAccess = exports.runInRequestContext = exports.recordDataAccess = exports.currentRequestContext = exports.isMutationOperation = void 0;
 exports.trackApi = trackApi;
 exports.captureError = captureError;
 exports.trackState = trackState;
+exports.trackDataAccess = trackDataAccess;
 const TELLANN_1 = require("./core/TELLANN");
 __exportStar(require("./core/TELLANN"), exports);
+var trackDataAccess_1 = require("./core/trackDataAccess");
+Object.defineProperty(exports, "isMutationOperation", { enumerable: true, get: function () { return trackDataAccess_1.isMutationOperation; } });
+var requestContext_1 = require("./core/requestContext");
+Object.defineProperty(exports, "currentRequestContext", { enumerable: true, get: function () { return requestContext_1.currentRequestContext; } });
+Object.defineProperty(exports, "recordDataAccess", { enumerable: true, get: function () { return requestContext_1.recordDataAccess; } });
+Object.defineProperty(exports, "runInRequestContext", { enumerable: true, get: function () { return requestContext_1.runInRequestContext; } });
+Object.defineProperty(exports, "summarizeDataAccess", { enumerable: true, get: function () { return requestContext_1.summarizeDataAccess; } });
 __exportStar(require("./integrations/express"), exports);
 __exportStar(require("./integrations/fastify"), exports);
+__exportStar(require("./integrations/koa"), exports);
+__exportStar(require("./integrations/hapi"), exports);
+__exportStar(require("./integrations/prisma"), exports);
 /**
  * Backward compatible helper to track an API call using the initialized TELLANN singleton.
  */
@@ -39,3 +51,10 @@ async function captureError(options) {
 async function trackState(options) {
     await TELLANN_1.TELLANN.trackState(options);
 }
+/**
+ * Backward compatible helper to report a persistence operation using the
+ * initialized TELLANN singleton.
+ */
+async function trackDataAccess(options) {
+    await TELLANN_1.TELLANN.trackDataAccess(options);
+}

package/dist/integrations/express/index.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorRequestHandler, RequestHandler } from 'express';
+import type { Request, ErrorRequestHandler, RequestHandler } from 'express';
 declare global {
     namespace Express {
         interface Request {
@@ -16,11 +16,23 @@ export declare function extractCorrelationContext(headers: Record<string, any>):
     runId?: string;
     traceId?: string;
 };
+/**
+ * The route template Express matched, e.g. `/orders/:id`.
+ *
+ * `req.route` is only populated once a route handler has run, and a router
+ * mounted under a prefix reports its own path, so the mount point is prepended.
+ * When nothing matched - a 404, or an error thrown in middleware - there is no
+ * template, and the caller falls back to the concrete path.
+ */
+export declare function expressRouteTemplate(req: Request): string | undefined;
 /**
  * Express middleware that automatically tracks every API request and hydrates req.tellann context.
  *
  * The middleware reads the `X-TELLANN-Session-ID` or W3C `traceparent` header to correlate
  * backend API calls with the originating frontend session.
+ *
+ * Register it before the body parser and the routes: it opens the per-request
+ * context that the ORM hooks report into, and the handlers run inside it.
  */
 export declare function tellannExpressMiddleware(): RequestHandler;
 /**

package/dist/integrations/express/index.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expressMiddleware = void 0;
 exports.extractSessionId = extractSessionId;
 exports.extractCorrelationContext = extractCorrelationContext;
+exports.expressRouteTemplate = expressRouteTemplate;
 exports.tellannExpressMiddleware = tellannExpressMiddleware;
 exports.tellannExpressErrorHandler = tellannExpressErrorHandler;
 const TELLANN_1 = require("../../core/TELLANN");
+const requestContext_1 = require("../../core/requestContext");
 function extractSessionId(headers) {
     if (headers['x-tellann-session-id'] || headers['x-tellann-session-id']) {
         return (headers['x-tellann-session-id'] || headers['x-tellann-session-id']);
@@ -29,11 +31,56 @@ function extractCorrelationContext(headers) {
         traceId,
     };
 }
+/**
+ * The route template Express matched, e.g. `/orders/:id`.
+ *
+ * `req.route` is only populated once a route handler has run, and a router
+ * mounted under a prefix reports its own path, so the mount point is prepended.
+ * When nothing matched - a 404, or an error thrown in middleware - there is no
+ * template, and the caller falls back to the concrete path.
+ */
+function expressRouteTemplate(req) {
+    const route = req.route?.path;
+    if (!route)
+        return undefined;
+    const base = req.baseUrl ?? '';
+    const joined = `${base}${route}`.replace(/\/{2,}/g, '/');
+    return joined === '' ? '/' : joined;
+}
+/**
+ * Captures a response body without changing what the client receives.
+ *
+ * `res.json` and `res.send` are wrapped rather than the socket being tapped:
+ * the wrapper sees the value the application passed, which is what a QA run
+ * should show, and it avoids buffering streamed or piped responses.
+ */
+function captureResponseBody(res, onBody) {
+    const json = res.json.bind(res);
+    const send = res.send.bind(res);
+    let captured = false;
+    res.json = ((body) => {
+        if (!captured) {
+            captured = true;
+            onBody(body);
+        }
+        return json(body);
+    });
+    res.send = ((body) => {
+        if (!captured) {
+            captured = true;
+            onBody(body);
+        }
+        return send(body);
+    });
+}
 /**
  * Express middleware that automatically tracks every API request and hydrates req.tellann context.
  *
  * The middleware reads the `X-TELLANN-Session-ID` or W3C `traceparent` header to correlate
  * backend API calls with the originating frontend session.
+ *
+ * Register it before the body parser and the routes: it opens the per-request
+ * context that the ORM hooks report into, and the handlers run inside it.
  */
 function tellannExpressMiddleware() {
     return (req, res, next) => {
@@ -43,9 +90,26 @@ function tellannExpressMiddleware() {
         const requestId = req.headers['x-request-id'];
         // Decorate request object
         req.tellann = correlation;
+        let responseBody;
+        captureResponseBody(res, (body) => { responseBody = body; });
+        // Held explicitly rather than read back from async storage at report time.
+        // `finish` is emitted by the socket, and a listener does not inherit the
+        // context it was registered in, so relying on the store here would lose
+        // the models on exactly the streamed responses that take longest.
+        const context = {
+            ...correlation,
+            method: req.method,
+            // The template is not known until a route matches, so the context
+            // starts with the concrete path and is corrected once one does.
+            route: req.originalUrl?.split('?')[0] ?? req.path,
+            dataAccess: [],
+        };
         res.on('finish', () => {
+            context.route = expressRouteTemplate(req) ?? context.route;
+            const models = (0, requestContext_1.summarizeDataAccess)(context.dataAccess);
             TELLANN_1.TELLANN.trackApi({
-                endpoint: req.path,
+                endpoint: req.originalUrl?.split('?')[0] ?? req.path,
+                route: expressRouteTemplate(req),
                 method: req.method,
                 statusCode: res.statusCode,
                 durationMs: Date.now() - start,
@@ -53,9 +117,19 @@ function tellannExpressMiddleware() {
                 requestId,
                 runId: correlation.runId,
                 traceId: correlation.traceId,
+                framework: 'express',
+                models,
+                query: req.query,
+                // `req.body` is whatever the body parser produced. With no parser
+                // registered it is undefined, and the request is reported without one.
+                requestBody: req.body,
+                responseBody,
+                requestHeaders: req.headers,
+                responseHeaders: res.getHeaders(),
             });
+            void TELLANN_1.TELLANN.flushDataAccess(context);
         });
-        next();
+        (0, requestContext_1.runInRequestContext)(context, () => next());
     };
 }
 /**
@@ -72,6 +146,7 @@ function tellannExpressErrorHandler() {
             traceId: req.tellann?.traceId,
             context: {
                 path: req.path,
+                route: expressRouteTemplate(req),
                 method: req.method,
                 query: req.query,
             },

package/dist/integrations/fastify/index.js

@@ -7,6 +7,7 @@ exports.fastifyPlugin = exports.tellannFastifyPlugin = void 0;
 const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
 const TELLANN_1 = require("../../core/TELLANN");
 const express_1 = require("../express");
+const requestContext_1 = require("../../core/requestContext");
 /**
  * Fastify plugin that automatically tracks every API request and handles error correlation.
  *
@@ -21,13 +22,32 @@ const tellannFastifyPluginImpl = async (fastify) => {
     // Add preHandler to extract session metadata
     fastify.addHook('onRequest', async (request) => {
         request.tellann = (0, express_1.extractCorrelationContext)(request.headers);
+        // Kept on the request as well as in async storage: the `onResponse` hook
+        // runs after the response is out, where the store is no longer reliable.
+        request.tellannContext =
+            (0, requestContext_1.enterRequestContext)({
+                ...request.tellann,
+                method: request.method,
+                route: request.routeOptions?.url ?? request.url.split('?')[0],
+                dataAccess: [],
+            });
+    });
+    // The payload is only available on `onSend`, and it is the serialized body
+    // rather than the value the handler returned, so it is parsed back for the
+    // run to display. Nothing is changed on the way through.
+    fastify.addHook('onSend', async (request, _reply, payload) => {
+        request.tellannResponseBody = payload;
+        return payload;
     });
     // Track API completion
     fastify.addHook('onResponse', async (request, reply) => {
         const sessionId = request.tellann?.sessionId;
         const requestId = request.headers['x-request-id'];
+        const rawBody = request.tellannResponseBody;
+        const context = request.tellannContext;
         await TELLANN_1.TELLANN.trackApi({
-            endpoint: request.routeOptions?.url ?? request.url,
+            endpoint: request.url.split('?')[0],
+            route: request.routeOptions?.url ?? request.url.split('?')[0],
             method: request.method,
             statusCode: reply.statusCode,
             durationMs: Math.round(reply.elapsedTime),
@@ -35,7 +55,22 @@ const tellannFastifyPluginImpl = async (fastify) => {
             requestId,
             runId: request.tellann?.runId,
             traceId: request.tellann?.traceId,
+            framework: 'fastify',
+            models: (0, requestContext_1.summarizeDataAccess)(context?.dataAccess ?? []),
+            query: request.query,
+            requestBody: request.body,
+            responseBody: typeof rawBody === 'string'
+                ? (() => { try {
+                    return JSON.parse(rawBody);
+                }
+                catch {
+                    return rawBody;
+                } })()
+                : rawBody,
+            requestHeaders: request.headers,
+            responseHeaders: reply.getHeaders(),
         });
+        await TELLANN_1.TELLANN.flushDataAccess(context);
     });
     // Track errors
     fastify.addHook('onError', async (request, reply, error) => {
@@ -46,6 +81,9 @@ const tellannFastifyPluginImpl = async (fastify) => {
             eventType: 'SERVER_ERROR',
             runId: request.tellann?.runId,
             traceId: request.tellann?.traceId,
+            route: request.routeOptions?.url ?? request.url.split('?')[0],
+            method: request.method,
+            statusCode: reply.statusCode,
             context: {
                 url: request.url,
                 method: request.method,

package/dist/integrations/hapi/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * hapi integration, written as a hapi plugin.
+ *
+ * As with the Koa integration, hapi's types are described structurally so that
+ * this SDK never requires `@hapi/hapi` to be installed in a project that does
+ * not use it.
+ */
+export type TellannHapiRequest = {
+    method: string;
+    path: string;
+    headers: Record<string, any>;
+    query?: Record<string, unknown>;
+    payload?: unknown;
+    /** The route table entry; its `path` is the pattern, not the request path. */
+    route?: {
+        path?: string;
+    };
+    response?: {
+        statusCode?: number;
+        isBoom?: boolean;
+        source?: unknown;
+        headers?: Record<string, any>;
+        output?: {
+            statusCode?: number;
+        };
+    };
+    app: Record<string, any>;
+    info?: {
+        received?: number;
+    };
+};
+export type TellannHapiServer = {
+    ext(event: string, handler: (request: TellannHapiRequest, h: any) => any): void;
+    events?: {
+        on(name: string, handler: (...args: any[]) => void): void;
+    };
+};
+/**
+ * The hapi plugin object, registered with `await server.register(tellannHapiPlugin)`.
+ */
+export declare const tellannHapiPlugin: {
+    name: string;
+    version: string;
+    register(server: TellannHapiServer): void;
+};