Extract functions from server roarr into shared logging module

Author: nodeexx

src/lib/server/roarr/client.ts

@@ -1,21 +1,23 @@
 import { Roarr, logLevels, type LogLevelName } from 'roarr';
-import callsites from 'callsites';
 import { config } from '$lib/server/core/config';
 import type {
-  LoggerContext,
-  LoggerContextWithError,
-  LoggerLoggingMethodName,
+  ServerLoggerContext,
+  ServerLoggerContextWithError,
+  ServerLoggerLoggingMethodName,
 } from './types';
 import { serializeError } from 'serialize-error';
 import { sentry } from '$lib/shared/sentry';
-import { getTraceId } from '$lib/shared/sentry/utils';
 import type { SeverityLevel } from '$lib/shared/sentry/types';
+import {
+  enrichContextWithDebugInfo,
+  enrichLoggerContextWithSentryTraceId,
+} from '$lib/shared/logging/utils';
 
 export const roarr = (function () {
-  const createLogger = (methodName: LoggerLoggingMethodName) => {
+  const createLogger = (methodName: ServerLoggerLoggingMethodName) => {
     return (
       message: string,
-      context: LoggerContextWithError = {},
+      context: ServerLoggerContextWithError = {},
       stackLevel: number = 3,
     ) => {
       if (!shouldBeLogged(methodName)) {
@@ -24,11 +26,15 @@ export const roarr = (function () {
 
       let contextClone = serializeErrorInContext(context);
       contextClone = enrichContextWithLogType(contextClone);
-      contextClone = enrichContextWithSentryTraceId(contextClone);
+      contextClone = enrichLoggerContextWithSentryTraceId(contextClone);
 
       Roarr[methodName](
         config.roarr.isDebugContextShown
-          ? enrichContextWithDebugInfo(contextClone, stackLevel)
+          ? enrichContextWithDebugInfo(
+              contextClone,
+              config.folders.root,
+              stackLevel,
+            )
           : contextClone,
         message,
       );
@@ -44,9 +50,9 @@ export const roarr = (function () {
 
   const roarrLoggingMethodNamesNoOnce = Object.keys(Roarr).filter((property) =>
     Object.keys(logLevels).includes(property),
-  ) as LoggerLoggingMethodName[];
+  ) as ServerLoggerLoggingMethodName[];
   const roarrLoggingMethodNamesOnce = roarrLoggingMethodNamesNoOnce.map(
-    (methodName) => `${methodName}Once` as LoggerLoggingMethodName,
+    (methodName) => `${methodName}Once` as ServerLoggerLoggingMethodName,
   );
   const roarrLoggingMethodNames = [
     ...roarrLoggingMethodNamesNoOnce,
@@ -58,10 +64,10 @@ export const roarr = (function () {
       return acc;
     },
     {} as Record<
-      LoggerLoggingMethodName,
+      ServerLoggerLoggingMethodName,
       (
         message: string,
-        context?: LoggerContextWithError,
+        context?: ServerLoggerContextWithError,
         stackLevel?: number,
       ) => void
     >,
@@ -70,7 +76,7 @@ export const roarr = (function () {
   return roarrLogger;
 })();
 
-function shouldBeLogged(methodName: LoggerLoggingMethodName): boolean {
+function shouldBeLogged(methodName: ServerLoggerLoggingMethodName): boolean {
   const requestedLogLevelName = methodName.replace('Once', '') as LogLevelName;
   const requestedLogLevel = logLevels[requestedLogLevelName];
   const minLogLevel = logLevels[config.roarr.minLogLevel as LogLevelName];
@@ -79,11 +85,11 @@ function shouldBeLogged(methodName: LoggerLoggingMethodName): boolean {
 }
 
 function serializeErrorInContext(
-  context: LoggerContextWithError,
-): LoggerContext {
+  context: ServerLoggerContextWithError,
+): ServerLoggerContext {
   const errorContext = context.error;
   if (!errorContext || !(errorContext instanceof Error)) {
-    return { ...context } as LoggerContext;
+    return { ...context } as ServerLoggerContext;
   }
 
   return {
@@ -92,65 +98,17 @@ function serializeErrorInContext(
   };
 }
 
-function enrichContextWithSentryTraceId(context: LoggerContext): LoggerContext {
-  if (!sentry) {
-    return { ...context };
-  }
-
-  const traceId = getTraceId();
-  if (!traceId) {
-    return { ...context };
-  }
-
-  return {
-    ...context,
-    sentryTraceId: traceId,
-  };
-}
-
-function enrichContextWithDebugInfo(
-  context: LoggerContext = {},
-  stackLevel: number = 3,
-): LoggerContext {
-  return {
-    ...context,
-    callName: getCallName(stackLevel),
-    fileName: getFileName(stackLevel),
-  };
-}
-
-function enrichContextWithLogType(context: LoggerContext): LoggerContext {
+function enrichContextWithLogType(
+  context: ServerLoggerContext,
+): ServerLoggerContext {
   return {
     logType: 'app',
     ...context,
   };
 }
 
-function getCallName(stackLevel: number = 3): string {
-  const typeName = callsites()[stackLevel]?.getTypeName() ?? '';
-  const functionName =
-    callsites()[3]?.getFunctionName() ??
-    callsites()[stackLevel]?.getMethodName() ??
-    '';
-
-  if (typeName) {
-    return `${typeName}.${functionName}`;
-  }
-
-  return functionName;
-}
-
-function getFileName(stackLevel: number = 3): string {
-  const fileName =
-    callsites()[stackLevel]?.getFileName() ??
-    callsites()[stackLevel]?.getEvalOrigin() ??
-    '';
-
-  return fileName.replace(config.folders.root, '');
-}
-
 function convertLogLevelNameRoarrToSentry(
-  methodName: LoggerLoggingMethodName,
+  methodName: ServerLoggerLoggingMethodName,
 ): SeverityLevel {
   const methodNameWithoutOnce = methodName.replace('Once', '');
 

src/lib/server/roarr/types/index.ts

@@ -3,11 +3,12 @@
  * Don't import from `node_modules/roarr/src/types.ts` directly to avoid type errors.
  */
 
+import type { LoggerContext } from '$lib/shared/logging/types';
 import type { LogLevelName } from 'roarr';
 
-export type LoggerLoggingMethodName =
-  | LoggerLoggingMethodNameNoOnce
-  | LoggerLoggingMethodNameOnce;
+export type ServerLoggerLoggingMethodName =
+  | ServerLoggerLoggingMethodNameNoOnce
+  | ServerLoggerLoggingMethodNameOnce;
 
 export type JsonObject = {
   [k: string]: JsonValue;
@@ -22,18 +23,19 @@ export type JsonValue =
   | null
   | undefined;
 
-export interface LoggerContext extends JsonObject {
+export interface ServerLoggerContext extends JsonObject, LoggerContext {
   error?: JsonValue;
   sentryTraceId?: string;
 }
 
-export interface LoggerContextWithError {
+export interface ServerLoggerContextWithError extends LoggerContext {
   error?: Error | JsonValue;
   sentryTraceId?: string;
   // WARN: Other properties should not have an `Error` type, but I don't know
   // how to enforce it in combination with the type of `error` property.
   [k: string]: Error | JsonValue;
 }
 
-type LoggerLoggingMethodNameNoOnce = LogLevelName;
-type LoggerLoggingMethodNameOnce = `${LoggerLoggingMethodNameNoOnce}Once`;
+type ServerLoggerLoggingMethodNameNoOnce = LogLevelName;
+type ServerLoggerLoggingMethodNameOnce =
+  `${ServerLoggerLoggingMethodNameNoOnce}Once`;

src/lib/shared/logging/types/index.ts

@@ -0,0 +1,4 @@
+export interface LoggerContext {
+  sentryTraceId?: string;
+  [k: string]: any;
+}

src/lib/shared/logging/utils/index.ts

@@ -0,0 +1,57 @@
+import { sentry } from '$lib/shared/sentry';
+import { getTraceId } from '$lib/shared/sentry/utils';
+import callsites from 'callsites';
+import type { LoggerContext } from '../types';
+
+export function enrichLoggerContextWithSentryTraceId<T extends LoggerContext>(
+  context: T,
+): T {
+  if (!sentry) {
+    return { ...context };
+  }
+
+  const traceId = getTraceId();
+  if (!traceId) {
+    return { ...context };
+  }
+
+  return {
+    ...context,
+    sentryTraceId: traceId,
+  };
+}
+
+export function enrichContextWithDebugInfo(
+  context: LoggerContext = {},
+  rootFolder = '',
+  stackLevel: number = 3,
+): LoggerContext {
+  return {
+    ...context,
+    callName: getCallName(stackLevel),
+    fileName: getFileName(rootFolder, stackLevel),
+  };
+}
+
+function getCallName(stackLevel: number = 3): string {
+  const typeName = callsites()[stackLevel]?.getTypeName() ?? '';
+  const functionName =
+    callsites()[3]?.getFunctionName() ??
+    callsites()[stackLevel]?.getMethodName() ??
+    '';
+
+  if (typeName) {
+    return `${typeName}.${functionName}`;
+  }
+
+  return functionName;
+}
+
+function getFileName(rootFolder = '', stackLevel: number = 3): string {
+  const fileName =
+    callsites()[stackLevel]?.getFileName() ??
+    callsites()[stackLevel]?.getEvalOrigin() ??
+    '';
+
+  return fileName.replace(rootFolder, '');
+}