Extract feature package for logger

Signed-off-by: Sami Tiilikainen <97873007+samitiilikainen@users.noreply.github.com>

packages/logging/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: "@k8slens/eslint-config/eslint",
+  parserOptions: {
+    project: "./tsconfig.json",
+  },
+};

packages/logging/.prettierrc

@@ -0,0 +1 @@
+"@k8slens/eslint-config/prettier"

packages/logging/index.ts

@@ -0,0 +1,7 @@
+export { default as logErrorInjectable } from "./src/log-error.injectable";
+export { default as loggerInjectable } from "./src/logger.injectable";
+export type { Logger } from "./src/logger";
+export { default as winstonLoggerInjectable } from "./src/winston-logger.injectable";
+export { default as prefixedLoggerInjectable } from "./src/prefixed-logger.injectable";
+export { loggerTransportInjectionToken } from "./src/transports";
+export { default as loggingFeature } from "./src/feature";

packages/logging/jest.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/jest").monorepoPackageConfig(__dirname).configForReact;

packages/logging/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@k8slens/logging",
+  "private": false,
+  "version": "1.0.0-alpha.1",
+  "description": "Lens logging",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lensapp/lens.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": {
+    "name": "OpenLens Authors",
+    "email": "info@k8slens.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lensapp/lens",
+  "scripts": {
+    "build": "webpack",
+    "clean": "rimraf dist/",
+    "dev": "webpack --mode=development --watch",
+    "test": "jest --coverage --runInBand",
+    "lint": "lens-lint",
+    "lint:fix": "lens-lint --fix"
+  },
+  "peerDependencies": {
+    "@k8slens/feature-core": "^6.5.0-alpha.0",
+    "@k8slens/test-utils": "^1.0.0-alpha.0",
+    "@k8slens/utilities": "^1.0.0-alpha.0",
+    "@ogre-tools/injectable": "^15.1.2",
+    "react": "^17.0.2",
+    "winston": "^3.8.2"
+  },
+  "devDependencies": {
+    "@k8slens/eslint-config": "^6.5.0-alpha.2",
+    "@k8slens/jest": "^6.5.0-alpha.4",
+    "@k8slens/typescript": "^6.5.0-alpha.2"
+  }
+}

packages/logging/src/feature.ts

@@ -0,0 +1,18 @@
+import { getFeature } from "@k8slens/feature-core";
+import logErrorInjectable from "./log-error.injectable";
+import loggerInjectable from "./logger.injectable";
+import prefixedLoggerInjectable from "./prefixed-logger.injectable";
+import winstonLoggerInjectable from "./winston-logger.injectable";
+
+export const loggingFeature = getFeature({
+  id: "logging",
+
+  register: (di) => {
+    di.register(logErrorInjectable);
+    di.register(loggerInjectable);
+    di.register(prefixedLoggerInjectable);
+    di.register(winstonLoggerInjectable);
+  },
+});
+
+export default loggingFeature;

packages/logging/src/log-error.global-override-for-injectable.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 { getGlobalOverrideForFunction } from "@k8slens/test-utils";
+import logErrorInjectable from "./log-error.injectable";
+
+// Note: this should remain as it is, and throw if called. Logging error is something
+// that cannot happen without a unit test explicitly causing it. It cannot be allowed
+// to happen without author of unit test knowing it.
+export default getGlobalOverrideForFunction(logErrorInjectable);

packages/logging/src/log-error.injectable.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 loggerInjectable from "./logger.injectable";
+
+const logErrorInjectable = getInjectable({
+  id: "log-error",
+  instantiate: (di) => di.inject(loggerInjectable).error,
+  decorable: false,
+});
+
+export default logErrorInjectable;

packages/logging/src/logger.global-override-for-injectable.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import loggerInjectable from "./logger.injectable";
+import { getGlobalOverride } from "@k8slens/test-utils";
+
+export default getGlobalOverride(loggerInjectable, () => ({
+  warn: () => {},
+  debug: () => {},
+  error: () => {},
+  info: () => {},
+  silly: () => {},
+}));

packages/logging/src/logger.injectable.ts

@@ -0,0 +1,26 @@
+/**
+ * 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";
+
+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,
+});
+
+export default loggerInjectable;

packages/logging/src/logger.ts

@@ -0,0 +1,12 @@
+/**
+ * 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/logging/src/prefixed-logger.injectable.ts

@@ -0,0 +1,37 @@
+/**
+ * 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";
+
+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,
+  }),
+});
+
+export default prefixedLoggerInjectable;

packages/logging/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/logging/src/winston-logger.global-override-for-injectable.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+
+import type winston from "winston";
+import { getGlobalOverride } from "@k8slens/test-utils";
+import { noop } from "@k8slens/utilities";
+import winstonLoggerInjectable from "./winston-logger.injectable";
+
+export default getGlobalOverride(
+  winstonLoggerInjectable,
+  () =>
+    ({
+      log: noop,
+      add: noop,
+      remove: noop,
+      clear: noop,
+      close: noop,
+
+      warn: noop,
+      debug: noop,
+      error: noop,
+      info: noop,
+      silly: noop,
+    } as winston.Logger),
+);

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

@@ -0,0 +1,18 @@
+/**
+ * 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";
+
+const winstonLoggerInjectable = getInjectable({
+  id: "winston-logger",
+  instantiate: (di) =>
+    createLogger({
+      format: format.combine(format.splat(), format.simple()),
+      transports: di.injectMany(loggerTransportInjectionToken),
+    }),
+});
+
+export default winstonLoggerInjectable;

packages/logging/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@k8slens/typescript/config/base.json",
+  "include": ["**/*.ts"]
+}

packages/logging/webpack.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/webpack").configForReact;