refactor(logs): move to core package (#4586)

packages/integrations/src/base/errors/decorator.ts

@@ -1,5 +1,5 @@
 import { isFunction } from "@homarr/common";
-import { logger } from "@homarr/log";
+import { createLogger } from "@homarr/core/infrastructure/logs";
 
 import type { Integration } from "../integration";
 import type { IIntegrationErrorHandler } from "./handler";
@@ -8,9 +8,7 @@ import { IntegrationError } from "./integration-error";
 import { IntegrationUnknownError } from "./integration-unknown-error";
 import { integrationJsonParseErrorHandler, integrationZodParseErrorHandler } from "./parse";
 
-const localLogger = logger.child({
-  module: "HandleIntegrationErrors",
-});
+const logger = createLogger({ module: "handleIntegrationErrors" });
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/no-explicit-any
 type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;
@@ -59,7 +57,7 @@ export const HandleIntegrationErrors = (errorHandlers: IIntegrationErrorHandler[
                 }
 
                 // If the error was handled and should be thrown again, throw it
-                localLogger.debug("Unhandled error in integration", {
+                logger.debug("Unhandled error in integration", {
                   error: error instanceof Error ? `${error.name}: ${error.message}` : undefined,
                   integrationName: this.publicIntegration.name,
                 });

packages/integrations/src/base/session-store.ts

@@ -1,10 +1,11 @@
 import superjson from "superjson";
 
 import { decryptSecret, encryptSecret } from "@homarr/common/server";
-import { logger } from "@homarr/log";
+import { createLogger } from "@homarr/core/infrastructure/logs";
+import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
 import { createGetSetChannel } from "@homarr/redis";
 
-const localLogger = logger.child({ module: "SessionStore" });
+const logger = createLogger({ module: "sessionStore" });
 
 export const createSessionStore = <TValue>(integration: { id: string }) => {
   const channelName = `session-store:${integration.id}`;
@@ -12,26 +13,26 @@ export const createSessionStore = <TValue>(integration: { id: string }) => {
 
   return {
     async getAsync() {
-      localLogger.debug("Getting session from store", { store: channelName });
+      logger.debug("Getting session from store", { store: channelName });
       const value = await channel.getAsync();
       if (!value) return null;
       try {
         return superjson.parse<TValue>(decryptSecret(value));
       } catch (error) {
-        localLogger.warn("Failed to load session", { store: channelName, error });
+        logger.warn("Failed to load session", { store: channelName, error });
         return null;
       }
     },
     async setAsync(value: TValue) {
-      localLogger.debug("Updating session in store", { store: channelName });
+      logger.debug("Updating session in store", { store: channelName });
       try {
         await channel.setAsync(encryptSecret(superjson.stringify(value)));
       } catch (error) {
-        localLogger.error("Failed to save session", { store: channelName, error });
+        logger.error(new ErrorWithMetadata("Failed to save session", { store: channelName }, { cause: error }));
       }
     },
     async clearAsync() {
-      localLogger.debug("Cleared session in store", { store: channelName });
+      logger.debug("Cleared session in store", { store: channelName });
       await channel.removeAsync();
     },
   };

packages/integrations/src/base/test-connection/test-connection-service.ts

@@ -7,7 +7,7 @@ import {
   getTrustedCertificateHostnamesAsync,
 } from "@homarr/certificates/server";
 import { getPortFromUrl } from "@homarr/common";
-import { logger } from "@homarr/log";
+import { createLogger } from "@homarr/core/infrastructure/logs";
 
 import type { IntegrationRequestErrorOfType } from "../errors/http/integration-request-error";
 import { IntegrationRequestError } from "../errors/http/integration-request-error";
@@ -15,8 +15,8 @@ import { IntegrationError } from "../errors/integration-error";
 import type { AnyTestConnectionError } from "./test-connection-error";
 import { TestConnectionError } from "./test-connection-error";
 
-const localLogger = logger.child({
-  module: "TestConnectionService",
+const logger = createLogger({
+  module: "testConnectionService",
 });
 
 export type TestingResult =
@@ -36,7 +36,7 @@ export class TestConnectionService {
   constructor(private url: URL) {}
 
   public async handleAsync(testingCallbackAsync: AsyncTestingCallback) {
-    localLogger.debug("Testing connection", {
+    logger.debug("Testing connection", {
       url: this.url.toString(),
     });
 
@@ -72,14 +72,14 @@ export class TestConnectionService {
       });
 
     if (testingResult.success) {
-      localLogger.debug("Testing connection succeeded", {
+      logger.debug("Testing connection succeeded", {
         url: this.url.toString(),
       });
 
       return testingResult;
     }
 
-    localLogger.debug("Testing connection failed", {
+    logger.debug("Testing connection failed", {
       url: this.url.toString(),
       error: `${testingResult.error.name}: ${testingResult.error.message}`,
     });
@@ -124,7 +124,7 @@ export class TestConnectionService {
     const x509 = socket.getPeerX509Certificate();
     socket.destroy();
 
-    localLogger.debug("Fetched certificate", {
+    logger.debug("Fetched certificate", {
       url: this.url.toString(),
       subject: x509?.subject,
       issuer: x509?.issuer,