@inversifyjs/http-instrumentation-core 0.0.0-stage → 5.8.0

package/.gitignore

@@ -0,0 +1,17 @@
+# Typescript compiled files
+/lib/**
+
+/tsconfig.tsbuildinfo
+/tsconfig.esm.tsbuildinfo
+
+# Test coverage report
+/coverage
+
+# Test mutation report
+/reports
+
+# node modules
+/node_modules/
+
+# Turborepo files
+.turbo/

package/.lintstagedrc.json

@@ -0,0 +1,4 @@
+{
+  "*.js": ["prettier --write"],
+  "*.ts": ["prettier --write", "eslint"]
+}

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @inversifyjs/http-instrumentation-core
+
+## 5.8.0
+
+No changes in this release.
+
+## 5.7.0
+
+### Minor Changes
+
+Add optional HTTP instrumentation sinks. Event types and the sink live in `@inversifyjs/http-instrumentation-core`. Adapters emit pipeline events only when at least one sink is configured. The Express 5 adapter also records native middleware, and the Express 5, Fastify, Hono, and uWebSockets adapters record request and response headers and status.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 inversify
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,6 @@
-# Temporary Holding Version
+[![Test coverage](https://codecov.io/gh/inversify/monorepo/branch/main/graph/badge.svg?flag=%40inversifyjs%2Fhttp-instrumentation-core)](https://codecov.io/gh/inversify/monorepo/branch/main/graph/badge.svg?flag=%40inversifyjs%2Fhttp-instrumentation-core)
+[![npm version](https://img.shields.io/github/package-json/v/inversify/monorepo?filename=packages%2Fframework%2Fhttp%2Flibraries%2Finstrumentation-core%2Fpackage.json&style=plastic)](https://www.npmjs.com/package/@inversifyjs/http-instrumentation-core)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @inversifyjs/http-instrumentation-core
+
+Event types, sink, and execution scope for InversifyJS HTTP instrumentation.

package/eslint.config.mjs

@@ -0,0 +1,23 @@
+import { buildDefaultConfig } from '@inversifyjs/foundation-eslint-config';
+
+import plugin from '@inversifyjs/eslint-plugin-require-extensions';
+
+export default [
+  ...buildDefaultConfig(
+    {
+      '@typescript-eslint/consistent-type-imports': [
+        'error',
+        {
+          disallowTypeAnnotations: true,
+          fixStyle: 'inline-type-imports',
+          prefer: 'type-imports',
+        },
+      ],
+      'require-extensions/require-extensions': 'error',
+      'require-extensions/require-index': 'error',
+    },
+    {
+      'require-extensions': plugin,
+    },
+  ),
+];

package/package.json

@@ -1,6 +1,67 @@
 {
+  "author": "Adrián Martínez Jiménez",
+  "bugs": {
+    "url": "https://github.com/inversify/monorepo/issues"
+  },
+  "description": "InversifyJS HTTP instrumentation events and sink",
+  "dependencies": {
+    "@inversifyjs/common": "2.0.1",
+    "@inversifyjs/framework-core": "2.2.0"
+  },
+  "devDependencies": {
+    "@inversifyjs/eslint-plugin-require-extensions": "0.2.0",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/typescript-checker": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
+    "@types/node": "24.19.1",
+    "@vitest/coverage-v8": "5.0.3",
+    "eslint": "10.12.0",
+    "prettier": "3.9.9",
+    "rimraf": "6.1.3",
+    "typescript": "6.0.3",
+    "vitest": "5.0.3"
+  },
+  "devEngines": {
+    "node": "^24.10.0",
+    "pnpm": "^12.0.0"
+  },
+  "homepage": "https://inversify.io",
+  "keywords": [
+    "dependency injection",
+    "dependency inversion",
+    "di",
+    "instrumentation",
+    "inversion of control container",
+    "ioc",
+    "javascript",
+    "node",
+    "typescript"
+  ],
+  "license": "MIT",
+  "exports": {
+    ".": "./lib/index.js"
+  },
   "name": "@inversifyjs/http-instrumentation-core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/inversify/monorepo.git"
+  },
+  "version": "5.8.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "build:clean": "rimraf lib",
+    "format": "prettier --write ./src",
+    "lint": "eslint ./src",
+    "prebuild": "pnpm run build:clean",
+    "test": "vitest run",
+    "test:integration": "pnpm run test --project Integration",
+    "test:coverage": "pnpm run test:unit --coverage",
+    "test:mutation": "stryker run",
+    "test:uncommitted": "pnpm run test --changed=HEAD",
+    "test:unit": "pnpm run test --project Unit"
+  }
 }

package/prettier.config.mjs

@@ -0,0 +1,3 @@
+import config from '@inversifyjs/foundation-prettier-config';
+
+export default config;

package/src/actions/emitHttpInstrumentationEvent.spec.ts

@@ -0,0 +1,130 @@
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  it,
+  type Mock,
+  vitest,
+} from 'vitest';
+
+import { type EventSink } from '../models/EventSink.js';
+import { type HttpInstrumentationEvent } from '../models/HttpInstrumentationEvent.js';
+import { emitHttpInstrumentationEvent } from './emitHttpInstrumentationEvent.js';
+
+describe(emitHttpInstrumentationEvent, () => {
+  describe('having three sinks and a middle sink that throws', () => {
+    let events: HttpInstrumentationEvent[];
+    let reportSinkError: Mock<(error: unknown) => void>;
+    let eventFixture: HttpInstrumentationEvent;
+
+    beforeAll(() => {
+      events = [];
+      reportSinkError = vitest.fn<(error: unknown) => void>();
+      eventFixture = {
+        executionId: 'execution-1',
+        headers: {},
+        method: 'GET',
+        requestId: 'request-1',
+        timestamp: 1,
+        type: 'http.request.started',
+        url: '/orders',
+      };
+
+      const sinks: EventSink<HttpInstrumentationEvent>[] = [
+        {
+          emit: (event: HttpInstrumentationEvent): void => {
+            events.push(event);
+          },
+        },
+        {
+          emit: (): void => {
+            throw new Error('sink failed');
+          },
+        },
+        {
+          emit: (event: HttpInstrumentationEvent): void => {
+            events.push(event);
+          },
+        },
+      ];
+
+      emitHttpInstrumentationEvent(sinks, eventFixture, reportSinkError);
+    });
+
+    afterAll(() => {
+      vitest.clearAllMocks();
+    });
+
+    it('should deliver the event to the sinks that do not throw', () => {
+      expect(events).toStrictEqual([eventFixture, eventFixture]);
+    });
+
+    it('should freeze the event', () => {
+      expect(Object.isFrozen(eventFixture)).toBe(true);
+    });
+
+    it('should report the sink failure', () => {
+      expect(reportSinkError).toHaveBeenCalledExactlyOnceWith(
+        expect.any(Error),
+      );
+    });
+  });
+
+  describe('having a sink that returns a rejected promise', () => {
+    let events: HttpInstrumentationEvent[];
+    let reportSinkError: Mock<(error: unknown) => void>;
+    let eventFixture: HttpInstrumentationEvent;
+    let sinkError: Error;
+
+    beforeAll(async () => {
+      events = [];
+      reportSinkError = vitest.fn<(error: unknown) => void>();
+      sinkError = new Error('async sink');
+      eventFixture = {
+        executionId: 'execution-1',
+        headers: {},
+        method: 'GET',
+        requestId: 'request-1',
+        timestamp: 1,
+        type: 'http.request.started',
+        url: '/orders',
+      };
+
+      const fulfilledSink: {
+        emit: (event: HttpInstrumentationEvent) => Promise<void>;
+      } = {
+        emit: async (event: HttpInstrumentationEvent): Promise<void> => {
+          events.push(event);
+        },
+      };
+      const rejectedSink: { emit: () => Promise<void> } = {
+        emit: async (): Promise<void> => Promise.reject(sinkError),
+      };
+      const sinks: EventSink<HttpInstrumentationEvent>[] = [
+        fulfilledSink,
+        rejectedSink,
+        {
+          emit: (event: HttpInstrumentationEvent): void => {
+            events.push(event);
+          },
+        },
+      ];
+
+      emitHttpInstrumentationEvent(sinks, eventFixture, reportSinkError);
+      await Promise.resolve();
+    });
+
+    afterAll(() => {
+      vitest.clearAllMocks();
+    });
+
+    it('should deliver the event to the other sinks', () => {
+      expect(events).toStrictEqual([eventFixture, eventFixture]);
+    });
+
+    it('should report the rejection', () => {
+      expect(reportSinkError).toHaveBeenCalledExactlyOnceWith(sinkError);
+    });
+  });
+});

package/src/actions/emitHttpInstrumentationEvent.ts

@@ -0,0 +1,28 @@
+import { isPromise } from '@inversifyjs/common';
+
+import { type EventSink } from '../models/EventSink.js';
+import { type HttpInstrumentationEvent } from '../models/HttpInstrumentationEvent.js';
+
+export function emitHttpInstrumentationEvent(
+  sinks: readonly EventSink<HttpInstrumentationEvent>[],
+  event: HttpInstrumentationEvent,
+  reportSinkError: (error: unknown) => void,
+): void {
+  const publishedEvent: HttpInstrumentationEvent = Object.freeze(event);
+
+  for (const sink of sinks) {
+    try {
+      // EventSink.emit is typed as void, and an async implementation still type-checks.
+      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+      const result: unknown = sink.emit(publishedEvent);
+
+      if (isPromise(result)) {
+        void result.then(undefined, (error: unknown): void => {
+          reportSinkError(error);
+        });
+      }
+    } catch (error: unknown) {
+      reportSinkError(error);
+    }
+  }
+}

package/src/actions/httpInstrumentationState.spec.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+
+import { type HttpInstrumentationScope } from '../models/HttpInstrumentationScope.js';
+import {
+  closeHttpInstrumentationScope,
+  initializeHttpInstrumentationRequest,
+  openHttpInstrumentationScope,
+} from './httpInstrumentationState.js';
+
+describe(openHttpInstrumentationScope, () => {
+  describe('having a request with a nested execution', () => {
+    describe('when called', () => {
+      it('should parent the inner scope to the outer execution', () => {
+        const request: object = {};
+
+        initializeHttpInstrumentationRequest(request, 'request-1');
+
+        const outer: HttpInstrumentationScope = openHttpInstrumentationScope(
+          request,
+          'execution-outer',
+        );
+        const inner: HttpInstrumentationScope = openHttpInstrumentationScope(
+          request,
+          'execution-inner',
+        );
+
+        expect(outer).toStrictEqual({
+          executionId: 'execution-outer',
+          parentExecutionId: undefined,
+          requestId: 'request-1',
+        });
+        expect(inner).toStrictEqual({
+          executionId: 'execution-inner',
+          parentExecutionId: 'execution-outer',
+          requestId: 'request-1',
+        });
+
+        closeHttpInstrumentationScope(request, inner.executionId);
+
+        const sibling: HttpInstrumentationScope = openHttpInstrumentationScope(
+          request,
+          'execution-sibling',
+        );
+
+        expect(sibling.parentExecutionId).toBe('execution-outer');
+      });
+    });
+  });
+});

package/src/actions/httpInstrumentationState.ts

@@ -0,0 +1,93 @@
+import { randomUUID } from 'node:crypto';
+
+import { type HttpInstrumentationScope } from '../models/HttpInstrumentationScope.js';
+import {
+  type HttpInstrumentationState,
+  httpInstrumentationStateSymbol,
+} from '../models/httpInstrumentationStateSymbol.js';
+
+interface HttpInstrumentationStateCarrier {
+  [httpInstrumentationStateSymbol]?: HttpInstrumentationState | undefined;
+}
+
+export function initializeHttpInstrumentationRequest(
+  request: object,
+  requestId: string,
+): void {
+  const carrier: HttpInstrumentationStateCarrier = request;
+
+  if (carrier[httpInstrumentationStateSymbol] !== undefined) {
+    return;
+  }
+
+  carrier[httpInstrumentationStateSymbol] = {
+    executionStack: [],
+    requestId,
+  };
+}
+
+export function openHttpInstrumentationScope(
+  request: object,
+  executionId: string,
+): HttpInstrumentationScope {
+  const state: HttpInstrumentationState =
+    getOrCreateHttpInstrumentationState(request);
+  const parentExecutionId: string | undefined = state.executionStack.at(-1);
+
+  state.executionStack.push(executionId);
+
+  return {
+    executionId,
+    parentExecutionId,
+    requestId: state.requestId,
+  };
+}
+
+export function closeHttpInstrumentationScope(
+  request: object,
+  executionId: string,
+): void {
+  const state: HttpInstrumentationState | undefined =
+    readHttpInstrumentationState(request);
+
+  if (state === undefined) {
+    return;
+  }
+
+  const executionIndex: number = state.executionStack.lastIndexOf(executionId);
+
+  if (executionIndex === -1) {
+    return;
+  }
+
+  state.executionStack.splice(executionIndex, 1);
+}
+
+function getOrCreateHttpInstrumentationState(
+  request: object,
+): HttpInstrumentationState {
+  const carrier: HttpInstrumentationStateCarrier = request;
+  const state: HttpInstrumentationState | undefined =
+    carrier[httpInstrumentationStateSymbol];
+
+  if (state !== undefined) {
+    return state;
+  }
+
+  const createdState: HttpInstrumentationState = {
+    executionStack: [],
+    requestId: randomUUID(),
+  };
+
+  carrier[httpInstrumentationStateSymbol] = createdState;
+
+  return createdState;
+}
+
+function readHttpInstrumentationState(
+  request: object,
+): HttpInstrumentationState | undefined {
+  return (request as HttpInstrumentationStateCarrier)[
+    httpInstrumentationStateSymbol
+  ];
+}

package/src/actions/markHttpInstrumentedHandler.ts

@@ -0,0 +1,16 @@
+import { httpInstrumentedHandlerSymbol } from '../models/httpInstrumentedHandlerSymbol.js';
+
+export function markHttpInstrumentedHandler(handler: object): void {
+  Object.defineProperty(handler, httpInstrumentedHandlerSymbol, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false,
+  });
+}
+
+export function isHttpInstrumentedHandler(handler: object): boolean {
+  const record: Record<symbol, unknown> = handler as Record<symbol, unknown>;
+
+  return record[httpInstrumentedHandlerSymbol] === true;
+}

package/src/actions/runInstrumentedHttpStage.ts

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto';
+
+import { startHttpStage } from '../calculations/startHttpStage.js';
+import { type HttpInstrumentationContext } from '../models/HttpInstrumentationContext.js';
+import { type HttpInstrumentationEvent } from '../models/HttpInstrumentationEvent.js';
+import { type HttpInstrumentationScope } from '../models/HttpInstrumentationScope.js';
+import { type HttpStageClock } from '../models/HttpStageClock.js';
+import { emitHttpInstrumentationEvent } from './emitHttpInstrumentationEvent.js';
+import {
+  closeHttpInstrumentationScope,
+  openHttpInstrumentationScope,
+} from './httpInstrumentationState.js';
+
+export type HttpStageOutcome<TResult> =
+  | {
+      readonly error: unknown;
+    }
+  | {
+      readonly result: TResult;
+    };
+
+export async function runInstrumentedHttpStage<TResult>(
+  instrumentation: HttpInstrumentationContext,
+  request: object,
+  createStartedEvent: (
+    scope: HttpInstrumentationScope,
+    stage: HttpStageClock,
+  ) => HttpInstrumentationEvent,
+  operation: () => Promise<TResult>,
+  createExecutedEvent: (
+    scope: HttpInstrumentationScope,
+    stage: HttpStageClock,
+    outcome: HttpStageOutcome<TResult>,
+  ) => HttpInstrumentationEvent,
+  recover: (error: unknown) => Promise<TResult>,
+): Promise<TResult> {
+  const scope: HttpInstrumentationScope = openHttpInstrumentationScope(
+    request,
+    randomUUID(),
+  );
+  const stage: HttpStageClock = startHttpStage();
+
+  try {
+    emitHttpInstrumentationEvent(
+      instrumentation.sinks,
+      createStartedEvent(scope, stage),
+      instrumentation.reportSinkError,
+    );
+
+    try {
+      const result: TResult = await operation();
+
+      emitHttpInstrumentationEvent(
+        instrumentation.sinks,
+        createExecutedEvent(scope, stage, {
+          result,
+        }),
+        instrumentation.reportSinkError,
+      );
+
+      return result;
+    } catch (error: unknown) {
+      emitHttpInstrumentationEvent(
+        instrumentation.sinks,
+        createExecutedEvent(scope, stage, {
+          error,
+        }),
+        instrumentation.reportSinkError,
+      );
+
+      return await recover(error);
+    }
+  } finally {
+    closeHttpInstrumentationScope(request, scope.executionId);
+  }
+}

package/src/calculations/buildHttpInstrumentationContext.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { type EventSink } from '../models/EventSink.js';
+import { type HttpInstrumentationEvent } from '../models/HttpInstrumentationEvent.js';
+import { buildHttpInstrumentationContext } from './buildHttpInstrumentationContext.js';
+
+describe(buildHttpInstrumentationContext, () => {
+  describe('having no sinks', () => {
+    describe('when called', () => {
+      it('should leave instrumentation disabled', () => {
+        expect(
+          buildHttpInstrumentationContext(undefined, (): void => undefined),
+        ).toBeUndefined();
+        expect(
+          buildHttpInstrumentationContext([], (): void => undefined),
+        ).toBeUndefined();
+      });
+    });
+  });
+
+  describe('having sinks', () => {
+    describe('when called', () => {
+      it('should keep the sinks', () => {
+        const sink: EventSink<HttpInstrumentationEvent> = {
+          emit: (): void => undefined,
+        };
+
+        expect(
+          buildHttpInstrumentationContext([sink], (): void => undefined),
+        ).toStrictEqual({
+          reportSinkError: expect.any(Function),
+          sinks: [sink],
+        });
+      });
+    });
+  });
+});

package/src/calculations/buildHttpInstrumentationContext.ts

@@ -0,0 +1,17 @@
+import { type EventSink } from '../models/EventSink.js';
+import { type HttpInstrumentationContext } from '../models/HttpInstrumentationContext.js';
+import { type HttpInstrumentationEvent } from '../models/HttpInstrumentationEvent.js';
+
+export function buildHttpInstrumentationContext(
+  sinks: readonly EventSink<HttpInstrumentationEvent>[] | undefined,
+  reportSinkError: (error: unknown) => void,
+): HttpInstrumentationContext | undefined {
+  if (sinks === undefined || sinks.length === 0) {
+    return undefined;
+  }
+
+  return {
+    reportSinkError,
+    sinks,
+  };
+}

package/src/calculations/redactHttpHeaders.spec.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+
+import { redactHttpHeaders } from './redactHttpHeaders.js';
+
+describe(redactHttpHeaders, () => {
+  describe('having credential headers', () => {
+    describe('when called', () => {
+      it('should redact credential headers and keep the others', () => {
+        const headers: Readonly<Record<string, string | readonly string[]>> =
+          redactHttpHeaders({
+            authorization: 'secret',
+            'content-length': 12,
+            cookie: 'session=1',
+            'proxy-authorization': 'basic secret',
+            'set-cookie': ['a=1', 'b=2'],
+            'x-api-key': 'key-1',
+            'x-auth-token': 'token-1',
+            'x-empty': undefined,
+            'x-request-id': 'req-1',
+          });
+
+        expect(Object.isFrozen(headers)).toBe(true);
+        expect(headers).toStrictEqual({
+          authorization: '[redacted]',
+          'content-length': '12',
+          cookie: '[redacted]',
+          'proxy-authorization': '[redacted]',
+          'set-cookie': '[redacted]',
+          'x-api-key': '[redacted]',
+          'x-auth-token': '[redacted]',
+          'x-request-id': 'req-1',
+        });
+      });
+    });
+  });
+});

package/src/calculations/redactHttpHeaders.ts

@@ -0,0 +1,38 @@
+const REDACTED_HEADER_VALUE: string = '[redacted]';
+
+const REDACTED_HTTP_HEADER_NAMES: ReadonlySet<string> = new Set([
+  'authorization',
+  'cookie',
+  'proxy-authorization',
+  'set-cookie',
+  'x-api-key',
+  'x-auth-token',
+]);
+
+export function redactHttpHeaders(
+  headers: Readonly<
+    Record<string, number | string | readonly string[] | undefined>
+  >,
+): Record<string, string | readonly string[]> {
+  const redactedHeaders: Record<string, string | readonly string[]> = {};
+
+  for (const key in headers) {
+    if (!Object.hasOwn(headers, key)) {
+      continue;
+    }
+
+    const value: number | string | readonly string[] | undefined = headers[key];
+
+    if (value === undefined) {
+      continue;
+    }
+
+    redactedHeaders[key] = REDACTED_HTTP_HEADER_NAMES.has(key.toLowerCase())
+      ? REDACTED_HEADER_VALUE
+      : typeof value === 'number'
+        ? value.toString()
+        : value;
+  }
+
+  return Object.freeze(redactedHeaders);
+}

package/src/calculations/startHttpStage.ts

@@ -0,0 +1,12 @@
+import { type HttpStageClock } from '../models/HttpStageClock.js';
+
+export function startHttpStage(): HttpStageClock {
+  return {
+    startedAt: Date.now(),
+    startTick: performance.now(),
+  };
+}
+
+export function readHttpStageDuration(stage: HttpStageClock): number {
+  return performance.now() - stage.startTick;
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+export { emitHttpInstrumentationEvent } from './actions/emitHttpInstrumentationEvent.js';
+export {
+  closeHttpInstrumentationScope,
+  initializeHttpInstrumentationRequest,
+  openHttpInstrumentationScope,
+} from './actions/httpInstrumentationState.js';
+export {
+  isHttpInstrumentedHandler,
+  markHttpInstrumentedHandler,
+} from './actions/markHttpInstrumentedHandler.js';
+export {
+  type HttpStageOutcome,
+  runInstrumentedHttpStage,
+} from './actions/runInstrumentedHttpStage.js';
+export { buildHttpInstrumentationContext } from './calculations/buildHttpInstrumentationContext.js';
+export { redactHttpHeaders } from './calculations/redactHttpHeaders.js';
+export {
+  readHttpStageDuration,
+  startHttpStage,
+} from './calculations/startHttpStage.js';
+export { type EventSink } from './models/EventSink.js';
+export { type HttpInstrumentationContext } from './models/HttpInstrumentationContext.js';
+export { type HttpInstrumentationEvent } from './models/HttpInstrumentationEvent.js';
+export { type HttpInstrumentationScope } from './models/HttpInstrumentationScope.js';
+export { httpInstrumentedHandlerSymbol } from './models/httpInstrumentedHandlerSymbol.js';
+export { type HttpStageClock } from './models/HttpStageClock.js';

package/src/models/EventSink.ts

@@ -0,0 +1,3 @@
+export interface EventSink<TEvent> {
+  emit(event: TEvent): void;
+}

package/src/models/HttpInstrumentationContext.ts

@@ -0,0 +1,7 @@
+import { type EventSink } from './EventSink.js';
+import { type HttpInstrumentationEvent } from './HttpInstrumentationEvent.js';
+
+export interface HttpInstrumentationContext {
+  readonly reportSinkError: (error: unknown) => void;
+  readonly sinks: readonly EventSink<HttpInstrumentationEvent>[];
+}

package/src/models/HttpInstrumentationEvent.ts

@@ -0,0 +1,187 @@
+import { type MiddlewarePhase } from '@inversifyjs/framework-core';
+
+interface HttpControllerExecutedEvent {
+  readonly controller: string;
+  readonly duration: number;
+  readonly error?: unknown;
+  readonly executionId: string;
+  readonly method: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.controller.executed';
+}
+
+interface HttpControllerStartedEvent {
+  readonly controller: string;
+  readonly executionId: string;
+  readonly method: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.controller.started';
+}
+
+interface HttpErrorEvent {
+  readonly duration: number;
+  readonly error: unknown;
+  readonly executionId: string;
+  readonly filter?: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.error';
+}
+
+interface HttpGuardExecutedEvent {
+  readonly allowed?: boolean;
+  readonly duration: number;
+  readonly error?: unknown;
+  readonly executionId: string;
+  readonly guard: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.guard.executed';
+}
+
+interface HttpGuardStartedEvent {
+  readonly executionId: string;
+  readonly guard: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.guard.started';
+}
+
+interface HttpInterceptorExecutedEvent {
+  readonly duration: number;
+  readonly error?: unknown;
+  readonly executionId: string;
+  readonly interceptor: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.interceptor.executed';
+}
+
+interface HttpInterceptorStartedEvent {
+  readonly executionId: string;
+  readonly interceptor: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.interceptor.started';
+}
+
+interface HttpMiddlewareExecutedEvent {
+  readonly duration: number;
+  readonly error?: unknown;
+  readonly executionId: string;
+  readonly middleware: string;
+  readonly parentExecutionId?: string;
+  readonly phase: MiddlewarePhase;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.middleware.executed';
+}
+
+interface HttpMiddlewareStartedEvent {
+  readonly executionId: string;
+  readonly middleware: string;
+  readonly parentExecutionId?: string;
+  readonly phase: MiddlewarePhase;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.middleware.started';
+}
+
+interface HttpNativeMiddlewareExecutedEvent {
+  readonly duration: number;
+  readonly error?: unknown;
+  readonly executionId: string;
+  readonly name: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.nativeMiddleware.executed';
+}
+
+interface HttpNativeMiddlewareStartedEvent {
+  readonly executionId: string;
+  readonly name: string;
+  readonly parentExecutionId?: string;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.nativeMiddleware.started';
+}
+
+interface HttpPipeExecutedEvent {
+  readonly duration: number;
+  readonly error?: unknown;
+  readonly executionId: string;
+  readonly method: string;
+  readonly parameterIndex: number;
+  readonly parentExecutionId?: string;
+  readonly pipe: string;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly timestamp: number;
+  readonly type: 'http.pipe.executed';
+}
+
+interface HttpPipeStartedEvent {
+  readonly executionId: string;
+  readonly method: string;
+  readonly parameterIndex: number;
+  readonly parentExecutionId?: string;
+  readonly pipe: string;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.pipe.started';
+}
+
+interface HttpRequestStartedEvent {
+  readonly executionId: string;
+  readonly headers: Readonly<Record<string, string | readonly string[]>>;
+  readonly method: string;
+  readonly requestId: string;
+  readonly timestamp: number;
+  readonly type: 'http.request.started';
+  readonly url: string;
+}
+
+interface HttpResponseSentEvent {
+  readonly aborted: boolean;
+  readonly duration: number;
+  readonly executionId: string;
+  readonly headers: Readonly<Record<string, string | readonly string[]>>;
+  readonly requestId: string;
+  readonly startedAt: number;
+  readonly statusCode: number;
+  readonly timestamp: number;
+  readonly type: 'http.response.sent';
+}
+
+export type HttpInstrumentationEvent =
+  | HttpControllerExecutedEvent
+  | HttpControllerStartedEvent
+  | HttpErrorEvent
+  | HttpGuardExecutedEvent
+  | HttpGuardStartedEvent
+  | HttpInterceptorExecutedEvent
+  | HttpInterceptorStartedEvent
+  | HttpMiddlewareExecutedEvent
+  | HttpMiddlewareStartedEvent
+  | HttpNativeMiddlewareExecutedEvent
+  | HttpNativeMiddlewareStartedEvent
+  | HttpPipeExecutedEvent
+  | HttpPipeStartedEvent
+  | HttpRequestStartedEvent
+  | HttpResponseSentEvent;

package/src/models/HttpInstrumentationScope.ts

@@ -0,0 +1,5 @@
+export interface HttpInstrumentationScope {
+  readonly executionId: string;
+  readonly parentExecutionId: string | undefined;
+  readonly requestId: string;
+}

package/src/models/HttpStageClock.ts

@@ -0,0 +1,4 @@
+export interface HttpStageClock {
+  readonly startedAt: number;
+  readonly startTick: number;
+}

package/src/models/httpInstrumentationStateSymbol.ts

@@ -0,0 +1,8 @@
+export const httpInstrumentationStateSymbol: unique symbol = Symbol.for(
+  '@inversifyjs/http-instrumentation-core/httpInstrumentationState',
+);
+
+export interface HttpInstrumentationState {
+  executionStack: string[];
+  requestId: string;
+}

package/src/models/httpInstrumentedHandlerSymbol.ts

@@ -0,0 +1,3 @@
+export const httpInstrumentedHandlerSymbol: unique symbol = Symbol.for(
+  '@inversifyjs/http-instrumentation-core/httpInstrumentedHandler',
+);

package/stryker.config.mjs

@@ -0,0 +1,3 @@
+import config from '@inversifyjs/foundation-stryker-config';
+
+export default config;

package/tsconfig.esm.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json.schemastore.org/tsconfig",
+  "extends": "@inversifyjs/foundation-typescript-config/tsconfig.base.esm.json",
+  "compilerOptions": {
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "tsconfig.esm.tsbuildinfo",
+    "types": ["node"]
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "http://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.esm.json"
+}

package/vitest.config.mjs

@@ -0,0 +1,3 @@
+import { defaultConfig } from '@inversifyjs/foundation-vitest-config';
+
+export default defaultConfig;

package/vitest.config.stryker.mjs

@@ -0,0 +1,3 @@
+import { strykerConfig } from '@inversifyjs/foundation-vitest-config';
+
+export default strykerConfig;