Merged in chore/create-logger-tests (pull request #2996)

Tests for common/logger

* chore: add tests for createLogger

* chore: add tests for createLogger


Approved-by: Linus Flood

packages/common/logger/createLogger/index.ts

@@ -0,0 +1,67 @@
+import * as Sentry from "@sentry/nextjs"
+import { flatten } from "flat"
+
+import { minimumLogLevel } from "./minimumLogLevel"
+import { shouldLog } from "./shouldLog"
+
+import type { logLevels } from "./logLevels"
+
+function getLogValue(args: unknown[]): Record<string, unknown> | undefined {
+  if (!args || args.length === 0) {
+    return undefined
+  }
+  if (args.length === 1 && typeof args[0] === "object") {
+    return (args[0] as Record<string, unknown>) ?? undefined
+  }
+  if (args.length === 1) {
+    return { value: args[0] }
+  }
+  return flatten(args)
+}
+
+export function createLogger(loggerPrefix: string | (() => Promise<string>)) {
+  const asyncWrapper: () => Promise<string> =
+    typeof loggerPrefix === "string" ? async () => loggerPrefix : loggerPrefix
+
+  const getLoggerPrefix = async () => {
+    const prefix = await asyncWrapper()
+    if (!prefix) {
+      return ""
+    }
+
+    return `[${prefix}]`
+  }
+
+  async function log(
+    level: (typeof logLevels)[number],
+    message: string,
+    ...args: unknown[]
+  ) {
+    if (!shouldLog(level, minimumLogLevel)) {
+      return
+    }
+
+    const logValue = getLogValue(args)
+
+    Sentry.logger[level](
+      `${await getLoggerPrefix()} ${message}`.trim(),
+      logValue
+    )
+    console[level](`${await getLoggerPrefix()} ${message}`.trim(), ...args)
+  }
+
+  return {
+    async debug(message: string, ...args: unknown[]): Promise<void> {
+      await log("debug", message, ...args)
+    },
+    async info(message: string, ...args: unknown[]): Promise<void> {
+      await log("info", message, ...args)
+    },
+    async warn(message: string, ...args: unknown[]): Promise<void> {
+      await log("warn", message, ...args)
+    },
+    async error(message: string, ...args: unknown[]): Promise<void> {
+      await log("error", message, ...args)
+    },
+  }
+}

packages/common/logger/createLogger/logLevels.ts

@@ -0,0 +1,2 @@
+export const logLevels = ["debug", "info", "warn", "error"] as const
+export type LogLevel = (typeof logLevels)[number]

packages/common/logger/createLogger/minimumLogLevel.ts

@@ -0,0 +1,19 @@
+import { logLevels } from "./logLevels"
+
+export const minimumLogLevel = (() => {
+  const configuredMinimumLogLevel = (
+    (process.env.MINIMUM_LOG_LEVEL ||
+      process.env.NEXT_PUBLIC_MINIMUM_LOG_LEVEL) ??
+    "info"
+  ).toLowerCase() as (typeof logLevels)[number]
+
+  if (!logLevels.includes(configuredMinimumLogLevel)) {
+    console.warn(
+      `Invalid log level configured: ${configuredMinimumLogLevel}, defaulting to 'info'`
+    )
+
+    return "info"
+  }
+
+  return configuredMinimumLogLevel
+})()

packages/common/logger/createLogger/shouldLog.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest"
+
+import { shouldLog } from "./shouldLog"
+
+describe("shouldLog", () => {
+  it("returns true when log level is higher or equal to minimum", () => {
+    expect(shouldLog("info", "debug")).toBe(true)
+    expect(shouldLog("info", "info")).toBe(true)
+    expect(shouldLog("warn", "info")).toBe(true)
+    expect(shouldLog("warn", "warn")).toBe(true)
+    expect(shouldLog("error", "error")).toBe(true)
+  })
+
+  it("returns false when log level is lower than minimum", () => {
+    expect(shouldLog("debug", "info")).toBe(false)
+    expect(shouldLog("debug", "warn")).toBe(false)
+    expect(shouldLog("debug", "error")).toBe(false)
+    expect(shouldLog("info", "warn")).toBe(false)
+    expect(shouldLog("info", "error")).toBe(false)
+    expect(shouldLog("warn", "error")).toBe(false)
+  })
+})

packages/common/logger/createLogger/shouldLog.ts

@@ -0,0 +1,5 @@
+import { type LogLevel, logLevels } from "./logLevels"
+
+export function shouldLog(level: LogLevel, minimumLogLevel: LogLevel) {
+  return logLevels.indexOf(level) >= logLevels.indexOf(minimumLogLevel)
+}