@k8slens/logger

Signed-off-by: Gabriel <gaccettola@mirantis.com>

packages/logger/src/feature.ts

@@ -0,0 +1,17 @@
+import { getFeature } from "@k8slens/feature-core";
+import { autoRegister } from "@ogre-tools/injectable-extension-for-auto-registration";
+
+export const loggerFeature = getFeature({
+  id: "logger-feature",
+
+  register: (di) => {
+    autoRegister({
+      di,
+      targetModule: module,
+      getRequireContexts: () => [
+        require.context("./", true, /\.injectable\.(ts|tsx)$/),
+      ],
+    });
+  },
+
+});

packages/logger/src/logger.injectable.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import type { Logger } from "./logger";
+import { winstonLoggerInjectable } from "./winston-logger.injectable";
+
+export const loggerInjectable = getInjectable({
+  id: "logger",
+  instantiate: (di): Logger => {
+    const baseLogger = di.inject(winstonLoggerInjectable);
+
+    return {
+      debug: (message, ...data) => baseLogger.debug(message, ...data),
+      info: (message, ...data) => baseLogger.info(message, ...data),
+      warn: (message, ...data) => baseLogger.warn(message, ...data),
+      error: (message, ...data) => baseLogger.error(message, ...data),
+      silly: (message, ...data) => baseLogger.silly(message, ...data),
+    };
+  },
+
+  decorable: false,
+});

packages/logger/src/logger.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+
+export interface Logger {
+  info: (message: string, ...args: any) => void;
+  error: (message: string, ...args: any) => void;
+  debug: (message: string, ...args: any) => void;
+  warn: (message: string, ...args: any) => void;
+  silly: (message: string, ...args: any) => void;
+}

packages/logger/src/prefixed-logger.injectable.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
+import type { Logger } from "./logger";
+import { loggerInjectable } from "./logger.injectable";
+
+export const prefixedLoggerInjectable = getInjectable({
+  id: "prefixed-logger",
+  instantiate: (di, prefix): Logger => {
+    const logger = di.inject(loggerInjectable);
+
+    return {
+      debug: (message, ...args) => {
+        logger.debug(`[${prefix}]: ${message}`, ...args);
+      },
+      error: (message, ...args) => {
+        logger.error(`[${prefix}]: ${message}`, ...args);
+      },
+      info: (message, ...args) => {
+        logger.info(`[${prefix}]: ${message}`, ...args);
+      },
+      silly: (message, ...args) => {
+        logger.silly(`[${prefix}]: ${message}`, ...args);
+      },
+      warn: (message, ...args) => {
+        logger.warn(`[${prefix}]: ${message}`, ...args);
+      },
+    };
+  },
+  lifecycle: lifecycleEnum.keyedSingleton({
+    getInstanceKey: (di, prefix: string) => prefix,
+  }),
+});

packages/logger/src/transports.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import { getInjectionToken } from "@ogre-tools/injectable";
+import type TransportStream from "winston-transport";
+
+export const loggerTransportInjectionToken = getInjectionToken<TransportStream>({
+  id: "logger-transport",
+});

packages/logger/src/winston-logger.injectable.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import { getInjectable } from "@ogre-tools/injectable";
+import { createLogger, format } from "winston";
+import { loggerTransportInjectionToken } from "./transports";
+
+export const winstonLoggerInjectable = getInjectable({
+  id: "winston-logger",
+  instantiate: (di) =>
+    createLogger({
+      format: format.combine(format.splat(), format.simple()),
+      transports: di.injectMany(loggerTransportInjectionToken),
+    }),
+});