@ogcio/fastify-logging-wrapper 4.0.0

package/src/logging-wrapper-entities.ts

@@ -0,0 +1,130 @@
+import { FastifyError } from "fastify";
+import {
+  parseErrorForLogging,
+} from "@ogcio/shared-errors";
+import { HttpError} from "@fastify/sensible";
+import {isHttpError} from "http-errors";
+
+export interface LoggingRequest {
+  scheme: string;
+  method: string;
+  path: string | undefined;
+  hostname: string;
+  query_params: unknown;
+  [key: string]: unknown;
+}
+
+export interface FullLoggingRequest extends LoggingRequest {
+  headers: unknown;
+  user_agent: string | undefined;
+  client_ip: string;
+}
+
+export interface LoggingResponse {
+  headers: unknown;
+  status_code: number;
+  [key: string]: unknown;
+}
+
+export interface LoggingError {
+  class: LogErrorClasses;
+  message: string;
+  trace?: string;
+  parent?: { name: string; message: string; stack?: string };
+  [key: string]: unknown;
+}
+
+export interface LoggingContext {
+  request?: LoggingRequest;
+  response?: LoggingResponse;
+  error?: LoggingError;
+}
+
+export enum LogMessages {
+  NewRequest = "NEW_REQUEST",
+  Response = "RESPONSE",
+  Error = "ERROR",
+  ApiTrack = "API_TRACK",
+}
+
+export enum LogErrorClasses {
+  ServerError = "SERVER_ERROR",
+  ValidationError = "VALIDATION_ERROR",
+  RequestError = "REQUEST_ERROR",
+  GatewayError = "GATEWAY_ERROR",
+  UnknownError = "UNKNOWN_ERROR",
+}
+
+export const REDACTED_VALUE = "[redacted]";
+
+export const REDACTED_PATHS = [
+  '*.headers["x-amz-security-token"]',
+  '*.headers["x-api-key"]',
+  '*.headers["authorization"]',
+  '*.headers["cookie"]',
+  '*.headers["set-cookie"]',
+  '*.headers["proxy-authorization"]',
+];
+
+export const MESSAGE_KEY = "message";
+
+export const REQUEST_ID_LOG_LABEL = "request_id";
+
+const UNHANDLED_EXCEPTION_CODE = "UNHANDLED_EXCEPTION";
+
+export const toLoggingError = (
+  error: HttpError | FastifyError,
+): LoggingError => {
+  const output = {
+    class: parseErrorClass(error),
+    message: error.message,
+    trace: error.stack,
+  };
+
+  if (isHttpError(error)) {
+    const parentInput = error.parentError ?? error.parent;
+    const parent = parentInput
+      ? { parent: parseErrorForLogging(parentInput) }
+      : {};
+
+    return {
+      ...output,
+      code: error.name,
+      process: error.errorProcess,
+      ...parent,
+    };
+  }
+
+  return {
+    ...output,
+    code: error.code ?? UNHANDLED_EXCEPTION_CODE,
+  };
+};
+
+const parseErrorClass = (
+  error: FastifyError | HttpError,
+): LogErrorClasses => {
+  if (!error.statusCode) {
+    return LogErrorClasses.UnknownError;
+  }
+
+  const statusCode = Number(error.statusCode);
+
+  if (statusCode === 502) {
+    return LogErrorClasses.GatewayError;
+  }
+
+  if (statusCode >= 500) {
+    return LogErrorClasses.ServerError;
+  }
+
+  if (statusCode === 422) {
+    return LogErrorClasses.ValidationError;
+  }
+
+  if (statusCode >= 400) {
+    return LogErrorClasses.RequestError;
+  }
+
+  return LogErrorClasses.UnknownError;
+};

package/src/logging-wrapper.ts

@@ -0,0 +1,106 @@
+import { FastifyRequest, FastifyReply, FastifyError } from "fastify";
+import { hostname } from "os";
+import {
+  LoggingContext,
+  LoggingRequest,
+  FullLoggingRequest,
+  LoggingResponse,
+  LoggingError,
+  REDACTED_VALUE,
+  REDACTED_PATHS,
+  MESSAGE_KEY,
+  toLoggingError,
+} from "./logging-wrapper-entities.js";
+import { LogLevel, PinoLoggerOptions } from "fastify/types/logger.js";
+import { HttpError } from "@fastify/sensible";
+
+const loggingContext: LoggingContext = {};
+
+type INPUT_ERROR_TYPES = FastifyError | HttpError;
+
+export const getLoggingContext = (params: {
+  includeError: boolean;
+}): LoggingContext =>
+  params.includeError
+    ? loggingContext
+    : { ...loggingContext, error: undefined };
+
+export const setLoggingContext = (params: {
+  request?: FastifyRequest;
+  response?: FastifyReply;
+  error?: INPUT_ERROR_TYPES;
+}): void => {
+  if (params.request !== undefined) {
+    loggingContext.request = parseLoggingRequest(params.request);
+  }
+  if (params.response !== undefined) {
+    loggingContext.response = parseLoggingResponse(params.response);
+  }
+  if (params.error !== undefined) {
+    loggingContext.error = toLoggingError(params.error);
+  }
+};
+
+export const resetLoggingContext = (): void => {
+  loggingContext.request = undefined;
+  loggingContext.response = undefined;
+  loggingContext.error = undefined;
+};
+
+export const getLoggingContextError = (): LoggingError | undefined =>
+  getLoggingContext({ includeError: true }).error;
+
+export const getPartialLoggingContextError = ():
+  | Omit<LoggingError, "trace">
+  | undefined => ({
+  ...(getLoggingContext({ includeError: true }).error ?? {}),
+  trace: undefined,
+});
+
+const getPathWithoutParams = (req: FastifyRequest): string =>
+  req.routeOptions?.url ?? req.url.split("?")[0];
+
+const parseLoggingRequest = (req: FastifyRequest): LoggingRequest => ({
+  scheme: req.protocol,
+  method: req.method,
+  path: getPathWithoutParams(req),
+  hostname: req.hostname,
+  query_params: req.query,
+});
+
+export const parseFullLoggingRequest = (
+  req: FastifyRequest,
+): FullLoggingRequest => ({
+  ...parseLoggingRequest(req),
+  headers: req.headers,
+  client_ip: req.ip,
+  user_agent: req.headers["user-agent"] ?? undefined,
+});
+
+const parseLoggingResponse = (res: FastifyReply): LoggingResponse => ({
+  status_code: res.statusCode,
+  headers: res.getHeaders(),
+});
+
+export const getLoggerConfiguration = (
+  minimumLevel: LogLevel = "debug",
+): PinoLoggerOptions => ({
+  base: { hostname: hostname() },
+  messageKey: MESSAGE_KEY,
+  mixin: () => ({
+    timestamp: Date.now(),
+    ...getLoggingContext({ includeError: false }),
+  }),
+  redact: {
+    paths: REDACTED_PATHS,
+    censor: REDACTED_VALUE,
+  },
+  timestamp: false,
+  formatters: {
+    level: (name: string, levelVal: number) => ({
+      level: levelVal,
+      level_name: name.toUpperCase(),
+    }),
+  },
+  level: minimumLevel,
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+      "composite": true,
+      "outDir": "dist",
+      "rootDir": "src"
+    },
+    "include": ["src"],
+    "references": [
+      { "path": "../shared-errors" }
+    ]
+  }

package/tsconfig.prod.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["__tests__", "dist"]
+}