Implement logging using Roarr on server

Author: nodeexx

scripts/stack/_lib/actions.js

@@ -152,10 +152,14 @@ export function runLocalApp() {
   console.log('app (local): running');
 
   try {
-    execSync('npx vite dev', {
-      stdio: 'inherit',
-      env: process.env,
-    });
+    execSync(
+      'npx vite dev | npx roarr --include-date true --output-format pretty', // pretty | json
+      {
+        stdio: 'inherit',
+        shell: '/bin/bash',
+        env: process.env,
+      },
+    );
   } catch (e) {
     console.log('app (local): exited');
   }

src/hooks.server.ts

@@ -14,6 +14,7 @@ import {
 import { setSentryUserIdentity } from '$lib/server/sentry/hooks';
 import { posthog, setupNodePosthogClient } from '$lib/server/posthog';
 import { getServerSentryIntegrations } from '$lib/server/sentry/utils';
+import { roarr } from '$lib/shared/roarr';
 
 setupNodePosthogClient(config.posthog.projectApiKey, config.posthog.apiHost);
 setupSentryClient({
@@ -23,6 +24,8 @@ setupSentryClient({
   integrations: [...getServerSentryIntegrations(config.sentry.organization)],
 });
 
+roarr.info('Starting the app server...');
+
 export const handle = (async (input) => {
   const maintenanceModeHandles: Handle[] = [maintenanceModeHandle];
   const nonMaintenanceModeHandles: Handle[] = [

src/lib/server/core/config/index.ts

@@ -1,5 +1,7 @@
 import { env as privateEnv } from '$env/dynamic/private';
 import { env as publicEnv } from '$env/dynamic/public';
+import path from 'path';
+import url from 'url';
 
 export const config = {
   get origin(): string {
@@ -8,6 +10,14 @@ export const config = {
   get isMaintenanceMode(): boolean {
     return privateEnv.MAINTENANCE_MODE === 'true';
   },
+  folders: {
+    get root(): string {
+      return path.resolve(
+        path.dirname(url.fileURLToPath(import.meta.url)),
+        '../../../../../',
+      );
+    },
+  },
   db: {
     get url(): string {
       return privateEnv.DATABASE_URL;
@@ -45,4 +55,15 @@ export const config = {
       return publicEnv.PUBLIC_SENTRY_ORGANIZATION;
     },
   },
+  roarr: {
+    get isEnabled(): boolean {
+      return privateEnv.ROARR_LOG === 'true';
+    },
+    get minLogLevel(): string {
+      return privateEnv.ROARR_MIN_LOG_LEVEL || 'info';
+    },
+    get isDebugContextShown(): boolean {
+      return privateEnv.ROARR_SHOW_DEBUG_CONTEXT === 'true';
+    },
+  },
 };

src/lib/shared/roarr/client.ts

@@ -0,0 +1,79 @@
+import { Roarr, logLevels, type LogLevelName } from 'roarr';
+import callsites from 'callsites';
+import { config } from '$lib/server/core/config';
+import type { JsonObject, LoggerLoggingMethodName } from './types';
+
+export const roarr = (function () {
+  const createLogger = (methodName: LoggerLoggingMethodName) => {
+    return (message: string, context: JsonObject = {}) => {
+      if (!shouldBeLogged(methodName)) {
+        return;
+      }
+
+      Roarr[methodName](
+        config.roarr.isDebugContextShown
+          ? enrichContextWithDebugInfo(context)
+          : context,
+        message,
+      );
+    };
+  };
+
+  const roarrLoggingMethodNamesNoOnce = Object.keys(Roarr).filter((property) =>
+    Object.keys(logLevels).includes(property),
+  ) as LoggerLoggingMethodName[];
+  const roarrLoggingMethodNamesOnce = roarrLoggingMethodNamesNoOnce.map(
+    (methodName) => `${methodName}Once` as LoggerLoggingMethodName,
+  );
+  const roarrLoggingMethodNames = [
+    ...roarrLoggingMethodNamesNoOnce,
+    ...roarrLoggingMethodNamesOnce,
+  ];
+  const roarrLogger = roarrLoggingMethodNames.reduce(
+    (acc, methodName) => {
+      acc[methodName] = createLogger(methodName);
+      return acc;
+    },
+    {} as Record<
+      LoggerLoggingMethodName,
+      (message: string, context?: JsonObject) => void
+    >,
+  );
+
+  return roarrLogger;
+})();
+
+function shouldBeLogged(methodName: LoggerLoggingMethodName): boolean {
+  const requestedLogLevelName = methodName.replace('Once', '') as LogLevelName;
+  const requestedLogLevel = logLevels[requestedLogLevelName];
+  const minLogLevel = logLevels[config.roarr.minLogLevel as LogLevelName];
+
+  return requestedLogLevel >= minLogLevel;
+}
+
+function enrichContextWithDebugInfo(override: JsonObject = {}): JsonObject {
+  return {
+    callName: getCallName(),
+    fileName: getFileName(),
+    ...override,
+  };
+}
+
+function getCallName(): string {
+  const typeName = callsites()[3]?.getTypeName() ?? '';
+  const functionName =
+    callsites()[3]?.getFunctionName() ?? callsites()[3]?.getMethodName() ?? '';
+
+  if (typeName) {
+    return `${typeName}.${functionName}`;
+  }
+
+  return functionName;
+}
+
+function getFileName(): string {
+  const fileName =
+    callsites()[3]?.getFileName() ?? callsites()[3]?.getEvalOrigin() ?? '';
+
+  return fileName.replace(config.folders.root, '');
+}

src/lib/shared/roarr/index.ts

@@ -0,0 +1 @@
+export * from './client';

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

@@ -0,0 +1,26 @@
+/**
+ * Types partially copied from `node_modules/roarr/src/types.ts`.
+ * Don't import from `node_modules/roarr/src/types.ts` directly to avoid type errors.
+ */
+
+import type { LogLevelName } from 'roarr';
+
+export type LoggerLoggingMethodName =
+  | LoggerLoggingMethodNameNoOnce
+  | LoggerLoggingMethodNameOnce;
+export type JsonObject = {
+  [k: string]: JsonValue;
+};
+
+type LoggerLoggingMethodNameNoOnce = LogLevelName;
+type LoggerLoggingMethodNameOnce = `${LoggerLoggingMethodNameNoOnce}Once`;
+
+type JsonValue =
+  | JsonObject
+  | JsonValue[]
+  | boolean
+  | number
+  | string
+  | readonly JsonValue[]
+  | null
+  | undefined;