@ogcio/fastify-logging-wrapper 4.0.0

package/README.md

@@ -0,0 +1,55 @@
+# Fastify Logging Wrapper
+
+This logging wrapper goal is to standardize the records written by our Fastify services.
+
+## How to
+
+To use this package three steps are needed:
+- install the package with
+```
+npm i @ogcio/fastify-logging-wrapper
+```
+
+- use the `getLoggingConfiguration()` method to get the configuration for the `fastify` server
+```
+const server = fastify({
+    ...getLoggingConfiguration()
+});
+```
+
+- after the server is initialized, invoke the `initializeLoggingHooks(server)` to setup the needed `fastify` hooks
+```
+initializeLoggingHooks(server);
+```
+
+That's it! Just log as you usually do!
+
+## Default records
+
+We will have 3 mandatory log entries that will be written for each request the service manages.
+
+Those 3 records are:
+- **New Request**, written when a request is received
+```
+{"level":30,"level_name":"INFO","hostname":"hostname","request_id":"q9Y6NwwbRimle4TxcXRPkQ-0000000000","timestamp":1713868947766,"request":{"scheme":"http","method":"GET","path":"/ping","hostname":"localhost:80","query_params":{},"headers":{"user-agent":"lightMyRequest","host":"localhost:80"},"client_ip":"127.0.0.1","user_agent":"lightMyRequest"},"message":"NEW_REQUEST"}
+```
+- **Response**, containing most of the response data
+```
+{"level":30,"level_name":"INFO","hostname":"hostname","request_id":"q9Y6NwwbRimle4TxcXRPkQ-0000000000","timestamp":1713868947769,"request":{"scheme":"http","method":"GET","path":"/ping","hostname":"localhost:80","query_params":{}},"response":{"status_code":200,"headers":{"content-type":"application/json; charset=utf-8","content-length":"17"}},"message":"RESPONSE"}
+```
+- **API Track**, it contains data about the lifecycle of the request, including errors, if any
+```
+{"level":30,"level_name":"INFO","hostname":"hostname","request_id":"5c_RLAnSS4y9-Q5STsJyiQ-0000000008","timestamp":1713869128434,"request":{"scheme":"http","method":"GET","path":"/this-path-must-not-exist","hostname":"localhost:80","query_params":{"status_code":"404","error_message":"Not Found"}},"response":{"status_code":404,"headers":{"content-type":"application/json; charset=utf-8","content-length":"107"}},"error":{"class":"REQUEST_ERROR","message":"Not Found","code":"FST_ERR_NOT_FOUND"},"message":"API_TRACK"}
+```
+
+### Error record
+
+If an error is thrown, a log entry is automatically written.
+
+```
+{"level":50,"level_name":"ERROR","hostname":"hostname","request_id":"1kPptKhMSeyZ9OwcSwBxhg-0000000008","timestamp":1713869258238,"request":{"scheme":"http","method":"GET","path":"/this-path-must-not-exist","hostname":"localhost:80","query_params":{"status_code":"404","error_message":"Not Found"}},"error":{"class":"REQUEST_ERROR","message":"Not Found","trace":"FastifyError: Not Found..... The whole trace here","code":"FST_ERR_NOT_FOUND"},"message":"ERROR"}
+```
+
+## Additional entries
+
+Additional log entries can be added as needed, but they will include, thanks to this package, common info about the request context that will be useful for future troubleshooting.

package/__tests__/fastify-logging-wrapper.errors.test.ts

@@ -0,0 +1,127 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { LogErrorClasses } from "../src/logging-wrapper-entities.js";
+import {
+  DEFAULT_METHOD,
+  checkExpectedApiTrackEntry,
+  checkExpectedErrorEntry,
+  checkExpectedRequestEntry,
+  checkExpectedResponseEntry,
+  initializeServer,
+  parseLogEntry,
+  runErrorTest,
+} from "./helpers/fastify-test-helpers.js";
+import { httpErrors } from '@fastify/sensible';
+
+test("Error data are correctly set", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  await runErrorTest({
+    server,
+    loggingDestination,
+    inputStatusCode: "500",
+    expectedStatusCode: 500,
+    errorMessage: "WHoooopS!",
+    expectedClass: LogErrorClasses.ServerError,
+  });
+});
+
+test("Unknown Error route logs expected values", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  await runErrorTest({
+    server,
+    loggingDestination,
+    inputStatusCode: "399",
+    expectedStatusCode: 500,
+    errorMessage: "Unknown!",
+    expectedClass: LogErrorClasses.UnknownError,
+  });
+});
+
+test("400 Error route logs expected values", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  await runErrorTest({
+    server,
+    loggingDestination,
+    inputStatusCode: "400",
+    expectedStatusCode: 400,
+    errorMessage: "Bad request!",
+    expectedClass: LogErrorClasses.RequestError,
+  });
+});
+
+test("422 Validation Error route logs expected values", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  await runErrorTest({
+    server,
+    loggingDestination,
+    inputStatusCode: "422",
+    expectedStatusCode: 422,
+    errorMessage: "Bad request!",
+    expectedClass: LogErrorClasses.ValidationError,
+  });
+});
+
+test("Error without status code logs expected values", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  await runErrorTest({
+    server,
+    loggingDestination,
+    inputStatusCode: undefined,
+    expectedStatusCode: 500,
+    errorMessage: "Unknown!",
+    expectedClass: LogErrorClasses.UnknownError,
+    expectedFastifyCode: "UNHANDLED_EXCEPTION",
+  });
+});
+
+test("Life events error logs expected values", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: "/life-events-error",
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response.statusCode, 500);
+  const loggedRecords = loggingDestination.getLoggedRecords();
+  assert.equal(loggedRecords.length, 4);
+  const mockErrorInstance = httpErrors.createError("mock");
+  checkExpectedRequestEntry({
+    requestLogEntry: loggedRecords[0],
+    inputPath: "/life-events-error",
+  });
+
+  checkExpectedErrorEntry({
+    errorLogEntry: loggedRecords[1],
+    inputPath: "/life-events-error",
+    errorClass: LogErrorClasses.ServerError,
+    errorMessage: "mock",
+    errorCode: mockErrorInstance.name,
+    expectedLevelName: "ERROR",
+  });
+  const parsed = parseLogEntry(loggedRecords[1]);
+  assert.equal(parsed.error.process, "TESTING");
+  assert.equal(parsed.error.parent.message, "I am the parent");
+  assert.equal(parsed.error.parent.name, "Error");
+  assert.equal(typeof parsed.error.parent.stack, "string");
+
+  checkExpectedResponseEntry({
+    responseLogEntry: loggedRecords[2],
+    inputPath: "/life-events-error",
+    responseStatusCode: 500,
+  });
+  checkExpectedApiTrackEntry({
+    apiTrackLogEntry: loggedRecords[3],
+    inputPath: "/life-events-error",
+    responseStatusCode: 500,
+    errorClass: LogErrorClasses.ServerError,
+    errorMessage: "mock",
+    errorCode: mockErrorInstance.name,
+  });
+});

package/__tests__/fastify-logging-wrapper.test.ts

@@ -0,0 +1,106 @@
+import { LogMessages } from "../src/logging-wrapper-entities.js";
+import { initializeServer, DEFAULT_METHOD, DEFAULT_PATH, checkExpectedRequestEntry, checkExpectedResponseEntry, parseLogEntry, checkGenericEntryFields } from "./helpers/fastify-test-helpers.js";
+import { REQUEST_ID_HEADER } from "@ogcio/shared-errors";
+import assert from "node:assert";
+import { test } from 'node:test';
+
+test("Logging entries when all works fine are the expected ones", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: DEFAULT_PATH,
+  });
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 200);
+  const loggedRecords = loggingDestination.getLoggedRecords();
+  assert.equal(loggedRecords.length, 3);
+  checkExpectedRequestEntry({
+    requestLogEntry: loggedRecords[0],
+  });
+  checkExpectedResponseEntry({
+    responseLogEntry: loggedRecords[1],
+    responseStatusCode: 200,
+  });
+  checkExpectedResponseEntry({
+    responseLogEntry: loggedRecords[2],
+    responseStatusCode: 200,
+    expectedMessage: LogMessages.ApiTrack,
+  });
+});
+
+test("Request id is overriden by header", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  const customRequestId = "Another request id";
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: DEFAULT_PATH,
+    headers: { [REQUEST_ID_HEADER]: customRequestId },
+  });
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 200);
+  const logged = loggingDestination.getLoggedRecords();
+  checkExpectedRequestEntry({
+    requestLogEntry: logged[0],
+    inputHeaders: { [REQUEST_ID_HEADER]: customRequestId },
+  });
+  const parsedEntry = parseLogEntry(logged[0]);
+  assert.deepEqual(parsedEntry.request_id, customRequestId);
+});
+
+test("Logging context is reset between requests", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+
+  let response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: DEFAULT_PATH,
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 200);
+  let loggedRecords = loggingDestination.getLoggedRecords();
+  assert.equal(loggedRecords.length, 3);
+  let parsedResponse = parseLogEntry(loggedRecords[1]);
+  assert.ok(typeof parsedResponse.response !== "undefined");
+
+  response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: DEFAULT_PATH,
+  });
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 200);
+  loggedRecords = loggingDestination.getLoggedRecords();
+  assert.equal(loggedRecords.length, 6);
+  // 3 is the New Request for 2nd call
+  parsedResponse = parseLogEntry(loggedRecords[3]);
+  // if undefined it means that the logging context
+  // has been reset between requests
+  assert.ok(typeof parsedResponse.response === "undefined");
+});
+
+test("Additional logs are correctly written", async (t) => {
+  const { server, loggingDestination } = initializeServer();
+  t.after(() => server.close());
+  const logMessage = "Testing additional logs";
+
+  const response = await server.inject({
+    method: "POST",
+    url: "/logs",
+    body: { log_entry: logMessage },
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response?.statusCode, 200);
+  const loggedRecords = loggingDestination.getLoggedRecords();
+  assert.equal(loggedRecords.length, 4);
+  const parsedAdditional = parseLogEntry(loggedRecords[1]);
+  checkGenericEntryFields({
+    parsedEntry: parsedAdditional,
+    expectedLevelName: "INFO",
+    expectedMessage: logMessage,
+  });
+  assert.ok(typeof parsedAdditional.request !== "undefined");
+});

package/__tests__/helpers/build-fastify.ts

@@ -0,0 +1,54 @@
+import Fastify from "fastify";
+import {
+  getLoggingConfiguration,
+  initializeLoggingHooks,
+} from "../../src/fastify-logging-wrapper.js";
+import { DestinationStream } from "pino";
+import { createError } from "@fastify/error";
+import { httpErrors } from "@fastify/sensible";
+
+export const buildFastify = (loggerDestination?: DestinationStream) => {
+  const server = Fastify({
+    ...getLoggingConfiguration(loggerDestination),
+  });
+
+  initializeLoggingHooks(server);
+
+  server.get("/ping", async (_request, _reply) => {
+    return { data: "pong\n" };
+  });
+
+  server.get("/error", async (request, _reply) => {
+    const parsed = request.query as { [x: string]: unknown };
+    const requestedStatusCode = Number(parsed["status_code"] ?? "500");
+    const requestedMessage = String(parsed["error_message"] ?? "WHOOOPS");
+
+    if (!parsed["status_code"]) {
+      throw new Error(requestedMessage);
+    }
+
+    throw createError(
+      "CUSTOM_CODE",
+      requestedMessage as string,
+      requestedStatusCode as number
+    )();
+  });
+
+  server.get("/life-events-error", async (_request, _reply) => {
+    throw httpErrors.createError(500, "mock", {
+      parentError: new Error("I am the parent"),
+      errorProcess: "TESTING",
+    });
+  });
+
+  server.post("/logs", async (request, _reply) => {
+    const body = request.body as { [x: string]: unknown };
+    const logMessage = body.log_entry ?? "Default additional message";
+
+    request.log.info(logMessage);
+
+    return { data: { message: logMessage } };
+  });
+
+  return server;
+};

package/__tests__/helpers/build-logger.ts

@@ -0,0 +1,28 @@
+import { PinoLoggerOptions } from "fastify/types/logger.js";
+import { pino } from "pino";
+
+export const buildLogger = (loggerConfiguration: PinoLoggerOptions) => {
+  const { loggerDestination, getLoggedRecords } = getTestingDestinationLogger();
+
+  return {
+    logger: pino(loggerConfiguration, loggerDestination),
+    loggedRecordsMethod: getLoggedRecords,
+  };
+};
+
+export interface TestingLoggerDestination {
+  loggerDestination: {
+    write: (_data: string) => number;
+  };
+  getLoggedRecords: () => string[];
+}
+
+export const getTestingDestinationLogger = (): TestingLoggerDestination => {
+  const testCaseRecords: string[] = [];
+  const getLoggedRecords = () => testCaseRecords;
+  const loggerDestination = {
+    write: (data: string) => testCaseRecords.push(data),
+  };
+
+  return { loggerDestination, getLoggedRecords };
+};

package/__tests__/helpers/fastify-test-helpers.ts

@@ -0,0 +1,258 @@
+import { FastifyInstance } from "fastify";
+import { buildFastify } from "./build-fastify.js";
+import {
+  TestingLoggerDestination,
+  getTestingDestinationLogger,
+} from "./build-logger.js";
+import {
+  LogErrorClasses,
+  LogMessages,
+} from "../../src/logging-wrapper-entities.js";
+import assert from 'node:assert/strict';
+
+export const DEFAULT_HOSTNAME = "localhost:80";
+export const DEFAULT_USER_AGENT = "lightMyRequest";
+export const DEFAULT_REQUEST_HEADERS = {
+  "user-agent": "lightMyRequest",
+  host: "localhost:80",
+};
+export const DEFAULT_CLIENT_IP = "127.0.0.1";
+export const DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8";
+export const DEFAULT_METHOD = "GET";
+export const DEFAULT_SCHEME = "http";
+export const DEFAULT_PATH = "/ping";
+
+export const initializeServer = (): {
+  server: FastifyInstance;
+  loggingDestination: TestingLoggerDestination;
+} => {
+  const loggingDestination = getTestingDestinationLogger();
+  const server = buildFastify(loggingDestination.loggerDestination);
+
+  return { server, loggingDestination };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const parseLogEntry = (logEntry: string): { [x: string]: any } =>
+  JSON.parse(logEntry);
+
+export const checkGenericEntryFields = (params: {
+  parsedEntry: { [x: string]: unknown };
+  expectedLevelName: string;
+  expectedMessage: string;
+}): void => {
+  const { parsedEntry, expectedLevelName, expectedMessage } = params;
+
+  assert.equal(parsedEntry.level_name, expectedLevelName);
+  assert.ok(typeof parsedEntry.level !== "undefined");
+  assert.equal(typeof parsedEntry.level, "number");
+  assert.equal(parsedEntry.message, expectedMessage);
+  assert.ok(typeof parsedEntry.request_id !== "undefined");
+  assert.equal(typeof parsedEntry.request_id, "string");
+  assert.ok(typeof parsedEntry.timestamp !== "undefined");
+  assert.equal(typeof parsedEntry.timestamp, "number");
+};
+
+export const checkExpectedRequestEntry = (params: {
+  requestLogEntry: string;
+  inputScheme?: string;
+  inputQueryParams?: { [x: string]: unknown };
+  inputMethod?: string;
+  inputPath?: string;
+  inputHeaders?: { [x: string]: unknown };
+}): void => {
+  const parsed = parseLogEntry(params.requestLogEntry);
+  params.inputMethod = params.inputMethod ?? DEFAULT_METHOD;
+  params.inputScheme = params.inputScheme ?? DEFAULT_SCHEME;
+  params.inputPath = params.inputPath ?? DEFAULT_PATH;
+  checkGenericEntryFields({
+    parsedEntry: parsed,
+    expectedLevelName: "INFO",
+    expectedMessage: LogMessages.NewRequest,
+  });
+  assert.ok(typeof parsed.request !== "undefined");
+  assert.equal(parsed.request?.scheme, params.inputScheme);
+  assert.equal(parsed.request?.method, params.inputMethod);
+  assert.equal(parsed.request?.path, params.inputPath);
+  assert.equal(parsed.request?.hostname, DEFAULT_HOSTNAME);
+  assert.deepStrictEqual(parsed.request?.query_params, params.inputQueryParams ?? {});
+  assert.deepStrictEqual(parsed.request?.headers, {
+    ...DEFAULT_REQUEST_HEADERS,
+    ...(params.inputHeaders ?? {}),
+  });
+  assert.equal(parsed.request?.client_ip, DEFAULT_CLIENT_IP);
+  assert.equal(parsed.request?.user_agent, DEFAULT_USER_AGENT);
+};
+
+export const checkExpectedResponseEntry = (params: {
+  responseLogEntry: string;
+  inputScheme?: string;
+  inputQueryParams?: { [x: string]: unknown };
+  inputMethod?: string;
+  inputPath?: string;
+  responseStatusCode: number;
+  expectedMessage?: string;
+}): void => {
+  const parsed = parseLogEntry(params.responseLogEntry);
+  params.inputMethod = params.inputMethod ?? DEFAULT_METHOD;
+  params.inputScheme = params.inputScheme ?? DEFAULT_SCHEME;
+  params.inputPath = params.inputPath ?? DEFAULT_PATH;
+
+  checkGenericEntryFields({
+    parsedEntry: parsed,
+    expectedLevelName: "INFO",
+    expectedMessage: params.expectedMessage ?? LogMessages.Response,
+  });
+  assert.ok(typeof parsed.request !== "undefined");
+  assert.equal(parsed.request.scheme, params.inputScheme);
+  assert.equal(parsed.request.method, params.inputMethod);
+  assert.equal(parsed.request.path, params.inputPath);
+  assert.equal(parsed.request.hostname, DEFAULT_HOSTNAME);
+  assert.deepStrictEqual(parsed.request.query_params, params.inputQueryParams ?? {});
+  assert.ok(typeof parsed.response !== "undefined");
+  assert.equal(parsed.response.status_code, params.responseStatusCode);
+  assert.equal(parsed.response.headers["content-type"], DEFAULT_CONTENT_TYPE);
+};
+
+export const checkExpectedApiTrackEntry = (params: {
+  apiTrackLogEntry: string;
+  inputScheme?: string;
+  inputQueryParams?: { [x: string]: unknown };
+  inputMethod?: string;
+  inputPath?: string;
+  errorClass?: string;
+  errorMessage?: string;
+  errorCode?: string;
+  responseStatusCode: number;
+}) => {
+  params.inputMethod = params.inputMethod ?? DEFAULT_METHOD;
+  params.inputScheme = params.inputScheme ?? DEFAULT_SCHEME;
+  params.inputPath = params.inputPath ?? DEFAULT_PATH;
+
+  checkExpectedResponseEntry({
+    ...params,
+    responseLogEntry: params.apiTrackLogEntry,
+    expectedMessage: LogMessages.ApiTrack,
+  });
+
+  if (!params.errorClass) {
+    return;
+  }
+
+  const parsed = parseLogEntry(params.apiTrackLogEntry);
+
+  assert.ok(typeof parsed.error !== "undefined");
+  assert.equal(parsed.error.class, params.errorClass);
+  assert.equal(parsed.error.message, params.errorMessage);
+  assert.equal(parsed.error.code, params.errorCode);
+};
+
+export const checkExpectedErrorEntry = (params: {
+  errorLogEntry: string;
+  inputScheme?: string;
+  inputQueryParams?: { [x: string]: unknown };
+  inputMethod?: string;
+  inputPath?: string;
+  errorClass: string;
+  errorMessage: string;
+  errorCode: string;
+  expectedLevelName?: string;
+}): void => {
+  const parsed = parseLogEntry(params.errorLogEntry);
+  params.inputMethod = params.inputMethod ?? DEFAULT_METHOD;
+  params.inputScheme = params.inputScheme ?? DEFAULT_SCHEME;
+  params.inputPath = params.inputPath ?? DEFAULT_PATH;
+  params.expectedLevelName = params.expectedLevelName ?? "ERROR";
+  checkGenericEntryFields({
+    parsedEntry: parsed,
+    expectedLevelName: params.expectedLevelName,
+    expectedMessage: "ERROR",
+  });
+  assert.ok(typeof parsed.request !== "undefined");
+  assert.equal(parsed.request?.scheme, params.inputScheme);
+  assert.equal(parsed.request?.method, params.inputMethod);
+  assert.equal(parsed.request?.path, params.inputPath);
+  assert.equal(parsed.request?.hostname, DEFAULT_HOSTNAME);
+  assert.deepStrictEqual(parsed.request?.query_params, params.inputQueryParams ?? {});
+  assert.ok(typeof parsed.error !== "undefined");
+  assert.equal(parsed.error.class, params.errorClass);
+  assert.equal(parsed.error.code, params.errorCode);
+  assert.equal(parsed.error.message, params.errorMessage);
+  assert.ok(typeof parsed.error.trace !== "undefined");
+  assert.equal(typeof parsed.error.trace, "string");
+};
+
+export const runErrorTest = async (params: {
+  server: FastifyInstance;
+  loggingDestination: TestingLoggerDestination;
+  inputStatusCode?: string;
+  errorMessage: string;
+  expectedClass: LogErrorClasses;
+  expectedStatusCode: number;
+  expectedErrorMessage?: string;
+  path?: string;
+  expectedFastifyCode?: string;
+}) => {
+  const {
+    server,
+    loggingDestination,
+    inputStatusCode,
+    errorMessage,
+    expectedClass,
+    expectedStatusCode,
+    expectedErrorMessage,
+  } = params;
+  const path = params.path ?? "/error";
+  const expectedFastifyCode = params.expectedFastifyCode ?? "CUSTOM_CODE";
+  const inputHeaders = { accept: DEFAULT_CONTENT_TYPE };
+  const query: { error_message: string; status_code?: string } = {
+    error_message: errorMessage,
+  };
+  if (inputStatusCode) {
+    query.status_code = inputStatusCode;
+  }
+
+  const response = await server.inject({
+    method: DEFAULT_METHOD,
+    url: path,
+    query,
+    headers: inputHeaders,
+  });
+
+  assert.ok(typeof response !== "undefined");
+  assert.equal(response.statusCode, expectedStatusCode);
+  const loggedRecords = loggingDestination.getLoggedRecords();
+  assert.equal(loggedRecords.length, 4);
+  checkExpectedRequestEntry({
+    requestLogEntry: loggedRecords[0],
+    inputPath: path,
+    inputQueryParams: query,
+    inputHeaders,
+  });
+  checkExpectedErrorEntry({
+    errorLogEntry: loggedRecords[1],
+    inputPath: path,
+    errorClass: expectedClass,
+    errorMessage,
+    errorCode: expectedFastifyCode,
+    inputQueryParams: query,
+    expectedLevelName: "ERROR",
+  });
+
+  checkExpectedResponseEntry({
+    responseLogEntry: loggedRecords[2],
+    inputPath: path,
+    inputQueryParams: query,
+    responseStatusCode: Number(expectedStatusCode),
+    expectedMessage: expectedErrorMessage,
+  });
+  checkExpectedApiTrackEntry({
+    apiTrackLogEntry: loggedRecords[3],
+    inputPath: path,
+    inputQueryParams: query,
+    responseStatusCode: Number(expectedStatusCode),
+    errorClass: expectedClass,
+    errorMessage,
+    errorCode: expectedFastifyCode,
+  });
+};