chore: loggerInjectionToken

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

packages/core/src/common/cluster/create-can-i.injectable.ts

@@ -5,7 +5,7 @@
 
 import type { AuthorizationV1Api, V1ResourceAttributes } from "@kubernetes/client-node";
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 /**
  * Requests the permissions for actions on the kube cluster
@@ -19,7 +19,7 @@ export type CreateCanI = (api: AuthorizationV1Api) => CanI;
 const createCanIInjectable = getInjectable({
   id: "create-can-i",
   instantiate: (di): CreateCanI => {
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return (api) => async (resourceAttributes: V1ResourceAttributes): Promise<boolean> => {
       try {

packages/core/src/common/cluster/create-request-namespace-list-permissions.injectable.ts

@@ -5,7 +5,7 @@
 
 import type { AuthorizationV1Api } from "@kubernetes/client-node";
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { KubeApiResource } from "../rbac";
 
 export type CanListResource = (resource: KubeApiResource) => boolean;
@@ -21,7 +21,7 @@ export type CreateRequestNamespaceListPermissions = (api: AuthorizationV1Api) =>
 const createRequestNamespaceListPermissionsInjectable = getInjectable({
   id: "create-request-namespace-list-permissions",
   instantiate: (di): CreateRequestNamespaceListPermissions => {
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return (api) => async (namespace) => {
       try {

packages/core/src/common/ipc/ipc.ts

@@ -12,7 +12,7 @@ import { toJS } from "../utils/toJS";
 import type { Disposer } from "@k8slens/utilities";
 import { getLegacyGlobalDiForExtensionApi } from "@k8slens/legacy-global-di";
 import ipcRendererInjectable from "../../renderer/utils/channel/ipc-renderer.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import ipcMainInjectionToken from "./ipc-main-injection-token";
 import clusterFramesInjectable from "../cluster-frames.injectable";
 
@@ -38,7 +38,7 @@ export async function broadcastMessage(channel: string, ...args: any[]): Promise
   }
 
   const di = getLegacyGlobalDiForExtensionApi();
-  const logger = di.inject(loggerInjectable);
+  const logger = di.inject(loggerInjectionToken);
   const clusterFrames = di.inject(clusterFramesInjectable);
 
   ipcMain.listeners(channel).forEach((func) => func({

packages/core/src/common/k8s-api/__tests__/api-manager.test.ts

@@ -11,7 +11,7 @@ import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
 import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
 import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable";
 import directoryForUserDataInjectable from "../../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { ApiManager } from "../api-manager";
 import apiManagerInjectable from "../api-manager/manager.injectable";
 import { KubeApi } from "../kube-api";
@@ -61,7 +61,7 @@ describe("ApiManager", () => {
       const apiBase = "apis/v1/foo";
       const fallbackApiBase = "/apis/extensions/v1beta1/foo";
       const kubeApi = new TestApi({
-        logger: di.inject(loggerInjectable),
+        logger: di.inject(loggerInjectionToken),
         maybeKubeApi: di.inject(maybeKubeApiInjectable),
       }, {
         objectConstructor: KubeObject,
@@ -72,7 +72,7 @@ describe("ApiManager", () => {
       });
       const kubeStore = new TestStore({
         context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
-        logger: di.inject(loggerInjectable),
+        logger: di.inject(loggerInjectionToken),
       }, kubeApi);
 
       apiManager.registerApi(kubeApi);
@@ -136,7 +136,7 @@ describe("ApiManager", () => {
 
             return Object.assign(
               new KubeApi({
-                logger: di.inject(loggerInjectable),
+                logger: di.inject(loggerInjectionToken),
                 maybeKubeApi: di.inject(maybeKubeApiInjectable),
               }, { objectConstructor }),
               {
@@ -189,7 +189,7 @@ describe("ApiManager", () => {
           apiManager.registerStore(Object.assign(
             new KubeObjectStore({
               context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
-              logger: di.inject(loggerInjectable),
+              logger: di.inject(loggerInjectionToken),
             }, api),
             {
               someField: 2,

packages/core/src/common/k8s-api/__tests__/kube-api-version-detection.test.ts

@@ -21,7 +21,7 @@ import directoryForKubeConfigsInjectable from "../../app-paths/directory-for-kub
 import apiManagerInjectable from "../api-manager/manager.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
 import ingressApiInjectable from "../endpoints/ingress.api.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 import { Cluster } from "../../cluster/cluster";
 
@@ -710,7 +710,7 @@ describe("KubeApi", () => {
 
     beforeEach(async () => {
       horizontalPodAutoscalerApi = new HorizontalPodAutoscalerApi({
-        logger: di.inject(loggerInjectable),
+        logger: di.inject(loggerInjectionToken),
         maybeKubeApi: di.inject(maybeKubeApiInjectable),
       }, {
         allowedUsableVersions: {

packages/core/src/common/k8s-api/api-manager/create-custom-resource-store.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { KubeApi } from "../kube-api";
 import type { KubeObject } from "@k8slens/kube-object";
 import type { KubeObjectStoreDependencies } from "../kube-object.store";
@@ -17,7 +17,7 @@ const createCustomResourceStoreInjectable = getInjectable({
   instantiate: (di): CreateCustomResourceStore => {
     const deps: KubeObjectStoreDependencies = {
       context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
     };
 
     return (api) => new CustomResourceStore(deps, api);

packages/core/src/common/k8s-api/create-json-api.injectable.ts

@@ -7,7 +7,7 @@ import { Agent } from "https";
 import type { RequestInit } from "@k8slens/node-fetch";
 import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
 import fetchInjectable from "../fetch/fetch.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { JsonApiConfig, JsonApiData, JsonApiDependencies, JsonApiParams } from "./json-api";
 import { JsonApi } from "./json-api";
 
@@ -18,7 +18,7 @@ const createJsonApiInjectable = getInjectable({
   instantiate: (di): CreateJsonApi => {
     const deps: JsonApiDependencies = {
       fetch: di.inject(fetchInjectable),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
     };
     const lensProxyCert = di.inject(lensProxyCertificateInjectable);
 

packages/core/src/common/k8s-api/create-kube-api-for-cluster.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { apiKubePrefix } from "../vars";
 import isDevelopmentInjectable from "../vars/is-development.injectable";
 import apiBaseInjectable from "./api-base.injectable";
@@ -37,7 +37,7 @@ const createKubeApiForClusterInjectable = getInjectable({
     const apiBase = di.inject(apiBaseInjectable);
     const isDevelopment = di.inject(isDevelopmentInjectable);
     const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return (
       cluster: CreateKubeApiForLocalClusterConfig,

packages/core/src/common/k8s-api/create-kube-api-for-remote-cluster.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import type { AgentOptions } from "https";
 import { Agent } from "https";
 import type { RequestInit } from "@k8slens/node-fetch";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import isDevelopmentInjectable from "../vars/is-development.injectable";
 import createKubeJsonApiInjectable from "./create-kube-json-api.injectable";
 import type { KubeApiOptions } from "./kube-api";
@@ -53,7 +53,7 @@ const createKubeApiForRemoteClusterInjectable = getInjectable({
   instantiate: (di): CreateKubeApiForRemoteCluster => {
     const isDevelopment = di.inject(isDevelopmentInjectable);
     const createKubeJsonApi = di.inject(createKubeJsonApiInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return (
       config: CreateKubeApiForRemoteClusterConfig,

packages/core/src/common/k8s-api/create-kube-api.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { DerivedKubeApiOptions, KubeApiDependencies } from "./kube-api";
 import maybeKubeApiInjectable from "./maybe-kube-api.injectable";
 
@@ -15,7 +15,7 @@ const createKubeApiInjectable = getInjectable({
   id: "create-kube-api",
   instantiate: (di): CreateKubeApi => {
     const deps: KubeApiDependencies = {
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     };
 

packages/core/src/common/k8s-api/create-kube-json-api.injectable.ts

@@ -7,7 +7,7 @@ import { Agent } from "https";
 import type { RequestInit } from "@k8slens/node-fetch";
 import lensProxyCertificateInjectable from "../certificate/lens-proxy-certificate.injectable";
 import fetchInjectable from "../fetch/fetch.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { JsonApiConfig, JsonApiDependencies } from "./json-api";
 import { KubeJsonApi } from "./kube-json-api";
 
@@ -18,7 +18,7 @@ const createKubeJsonApiInjectable = getInjectable({
   instantiate: (di): CreateKubeJsonApi => {
     const dependencies: JsonApiDependencies = {
       fetch: di.inject(fetchInjectable),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
     };
     const lensProxyCert = di.inject(lensProxyCertificateInjectable);
 

packages/core/src/common/k8s-api/endpoints/cluster-role-binding.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ClusterRoleBindingApi } from "./cluster-role-binding.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const clusterRoleBindingApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const clusterRoleBindingApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
 
     return new ClusterRoleBindingApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/cluster-role.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ClusterRoleApi } from "./cluster-role.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const clusterRoleApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const clusterRoleApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
 
     return new ClusterRoleApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/cluster.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ClusterApi } from "./cluster.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const clusterApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const clusterApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterApi is only available in certain environments");
 
     return new ClusterApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/component-status.api.injectable.ts

@@ -8,7 +8,7 @@ import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-c
 import { ComponentStatusApi } from "./component-status.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const componentStatusApiInjectable = getInjectable({
   id: "component-status-api",
@@ -16,7 +16,7 @@ const componentStatusApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
 
     return new ComponentStatusApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/config-map.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ConfigMapApi } from "./config-map.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const configMapApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const configMapApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
 
     return new ConfigMapApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/cron-job.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { CronJobApi } from "./cron-job.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const cronJobApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const cronJobApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
 
     return new CronJobApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     }, {
       checkPreferredVersion: true,

packages/core/src/common/k8s-api/endpoints/custom-resource-definition.api.injectable.ts

@@ -8,7 +8,7 @@ import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-c
 import { CustomResourceDefinitionApi } from "./custom-resource-definition.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const customResourceDefinitionApiInjectable = getInjectable({
   id: "custom-resource-definition-api",
@@ -16,7 +16,7 @@ const customResourceDefinitionApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
 
     return new CustomResourceDefinitionApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/daemon-set.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { DaemonSetApi } from "./daemon-set.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const daemonSetApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const daemonSetApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environments");
 
     return new DaemonSetApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/deployment.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { DeploymentApi } from "./deployment.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const deploymentApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const deploymentApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
 
     return new DeploymentApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/endpoint.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { EndpointsApi } from "./endpoint.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const endpointsApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const endpointsApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
 
     return new EndpointsApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/events.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { KubeEventApi } from "./events.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const kubeEventApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const kubeEventApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
 
     return new KubeEventApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { HorizontalPodAutoscalerApi } from "./horizontal-pod-autoscaler.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const horizontalPodAutoscalerApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const horizontalPodAutoscalerApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
 
     return new HorizontalPodAutoscalerApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/ingress-class.api.injectable.ts

@@ -5,13 +5,13 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import { IngressClassApi } from "./ingress-class.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const ingressClassApiInjectable = getInjectable({
   id: "ingress-class-api",
   instantiate: (di) => new IngressClassApi({
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     maybeKubeApi: di.inject(maybeKubeApiInjectable),
   }),
 

packages/core/src/common/k8s-api/endpoints/ingress.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { IngressApi } from "./ingress.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const ingressApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const ingressApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressApi is only available in certain environments");
 
     return new IngressApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/job.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { JobApi } from "./job.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const jobApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const jobApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
 
     return new JobApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     }, {
       checkPreferredVersion: true,

packages/core/src/common/k8s-api/endpoints/lease.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { LeaseApi } from "./lease.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const leaseApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const leaseApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "leaseApi is only available in certain environments");
 
     return new LeaseApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/limit-range.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { LimitRangeApi } from "./limit-range.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const limitRangeApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const limitRangeApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
 
     return new LimitRangeApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/mutating-webhook-configuration-api.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 import { MutatingWebhookConfigurationApi } from "./mutating-webhook-configuration.api";
 
@@ -16,7 +16,7 @@ const mutatingWebhookConfigurationApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "mutatingWebhookApi is only available in certain environments");
 
     return new MutatingWebhookConfigurationApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/namespace.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { NamespaceApi } from "./namespace.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const namespaceApiInjectable = getInjectable({
@@ -17,7 +17,7 @@ const namespaceApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
 
     return new NamespaceApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/network-policy.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { NetworkPolicyApi } from "./network-policy.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const networkPolicyApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const networkPolicyApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
 
     return new NetworkPolicyApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/node.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { NodeApi } from "./node.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const nodeApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const nodeApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeApi is only available in certain environments");
 
     return new NodeApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/persistent-volume-claim.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PersistentVolumeClaimApi } from "./persistent-volume-claim.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const persistentVolumeClaimApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const persistentVolumeClaimApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
 
     return new PersistentVolumeClaimApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/persistent-volume.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PersistentVolumeApi } from "./persistent-volume.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const persistentVolumeApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const persistentVolumeApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
 
     return new PersistentVolumeApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/pod-disruption-budget.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodDisruptionBudgetApi } from "./pod-disruption-budget.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const podDisruptionBudgetApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const podDisruptionBudgetApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
 
     return new PodDisruptionBudgetApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     }, {
       checkPreferredVersion: true,

packages/core/src/common/k8s-api/endpoints/pod-metrics.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodMetricsApi } from "./pod-metrics.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const podMetricsApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const podMetricsApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
 
     return new PodMetricsApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/pod-security-policy.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodSecurityPolicyApi } from "./pod-security-policy.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const podSecurityPolicyApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const podSecurityPolicyApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
 
     return new PodSecurityPolicyApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/pod.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PodApi } from "./pod.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const podApiInjectable = getInjectable({
@@ -17,7 +17,7 @@ const podApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podApi is only available in certain environments");
 
     return new PodApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/priority-class.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { PriorityClassApi } from "./priority-class.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const priorityClassApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const priorityClassApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "PriorityClassApi is only available in certain environments");
 
     return new PriorityClassApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/replica-set.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ReplicaSetApi } from "./replica-set.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const replicaSetApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const replicaSetApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
 
     return new ReplicaSetApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/replication-controller.api.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 import { ReplicationControllerApi } from "./replication-controller.api";
 
@@ -12,7 +12,7 @@ const replicationControllerApiInjectable = getInjectable({
   id: "replication-controller-api",
   instantiate: (di) => {
     return new ReplicationControllerApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/resource-quota.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ResourceQuotaApi } from "./resource-quota.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const resourceQuotaApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const resourceQuotaApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
 
     return new ResourceQuotaApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/role-binding.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { RoleBindingApi } from "./role-binding.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const roleBindingApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const roleBindingApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
 
     return new RoleBindingApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/role.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { RoleApi } from "./role.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const roleApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const roleApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleApi is only available in certain environments");
 
     return new RoleApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/runtime-class.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { RuntimeClassApi } from "./runtime-class.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const runtimeClassApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const runtimeClassApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "RuntimeClassApi is only available in certain environments");
 
     return new RuntimeClassApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/secret.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { SecretApi } from "./secret.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const secretApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const secretApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretApi is only available in certain environments");
 
     return new SecretApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/self-subject-rules-reviews.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { SelfSubjectRulesReviewApi } from "./self-subject-rules-reviews.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const selfSubjectRulesReviewApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const selfSubjectRulesReviewApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
 
     return new SelfSubjectRulesReviewApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/service-account.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ServiceAccountApi } from "./service-account.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const serviceAccountApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const serviceAccountApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
 
     return new ServiceAccountApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/service.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { ServiceApi } from "./service.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const serviceApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const serviceApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceApi is only available in certain environments");
 
     return new ServiceApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/stateful-set.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { StatefulSetApi } from "./stateful-set.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const statefulSetApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const statefulSetApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
 
     return new StatefulSetApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/storage-class.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { StorageClassApi } from "./storage-class.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const storageClassApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const storageClassApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
 
     return new StorageClassApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/validating-webhook-configuration-api.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 import { ValidatingWebhookConfigurationApi } from "./validating-webhook-configuration.api";
 
@@ -16,7 +16,7 @@ const validatingWebhookConfigurationApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "validatingWebhookApi is only available in certain environments");
 
     return new ValidatingWebhookConfigurationApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s-api/endpoints/vertical-pod-autoscaler.api.injectable.ts

@@ -7,7 +7,7 @@ import assert from "assert";
 import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
 import { VerticalPodAutoscalerApi } from "./vertical-pod-autoscaler.api";
 import { kubeApiInjectionToken } from "../kube-api/kube-api-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 
 const verticalPodAutoscalerApiInjectable = getInjectable({
@@ -16,7 +16,7 @@ const verticalPodAutoscalerApiInjectable = getInjectable({
     assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "verticalPodAutoscalerApi is only available in certain environments");
 
     return new VerticalPodAutoscalerApi({
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       maybeKubeApi: di.inject(maybeKubeApiInjectable),
     });
   },

packages/core/src/common/k8s/create-resource-stack.injectable.ts

@@ -7,7 +7,7 @@ import type { KubernetesCluster } from "../catalog-entities";
 import readDirectoryInjectable from "../fs/read-directory.injectable";
 import readFileInjectable from "../fs/read-file.injectable";
 import { kubectlApplyAllInjectionToken, kubectlDeleteAllInjectionToken } from "../kube-helpers/channels";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import joinPathsInjectable from "../path/join-paths.injectable";
 import type { ResourceApplyingStack, ResourceStackDependencies } from "./resource-stack";
 import { ResourceStack } from "./resource-stack";
@@ -21,7 +21,7 @@ const createResourceStackInjectable = getInjectable({
       joinPaths: di.inject(joinPathsInjectable),
       kubectlApplyAll: di.inject(kubectlApplyAllInjectionToken),
       kubectlDeleteAll: di.inject(kubectlDeleteAllInjectionToken),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       readDirectory: di.inject(readDirectoryInjectable),
       readFile: di.inject(readFileInjectable),
     };

packages/core/src/common/log-error.injectable.ts

@@ -3,11 +3,11 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const logErrorInjectable = getInjectable({
   id: "log-error",
-  instantiate: (di) => di.inject(loggerInjectable).error,
+  instantiate: (di) => di.inject(loggerInjectionToken).error,
   decorable: false,
 });
 

packages/core/src/common/logger.global-override-for-injectable.ts

@@ -3,10 +3,10 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { getGlobalOverride } from "@k8slens/test-utils";
 
-export default getGlobalOverride(loggerInjectable, () => ({
+export default getGlobalOverride(loggerInjectionToken, () => ({
   warn: () => {},
   debug: () => {},
   error: () => {},

packages/core/src/common/persistent-storage/create.injectable.ts

@@ -10,7 +10,7 @@ import type { IEqualsComparer } from "mobx";
 import { reaction } from "mobx";
 import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import getConfigurationFileModelInjectable from "../get-configuration-file-model/get-configuration-file-model.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import getBasenameOfPathInjectable from "../path/get-basename.injectable";
 import { enlistMessageChannelListenerInjectionToken, sendMessageToChannelInjectionToken } from "@k8slens/messaging";
 import type { MessageChannel } from "@k8slens/messaging";
@@ -63,7 +63,7 @@ const createPersistentStorageInjectable = getInjectable({
   instantiate: (di): CreatePersistentStorage => {
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
     const getConfigurationFileModel = di.inject(getConfigurationFileModelInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const getBasenameOfPath = di.inject(getBasenameOfPathInjectable);
     const ipcChannelPrefixes = di.inject(persistentStorageIpcChannelPrefixesInjectionToken);
     const persistStateToConfig = di.inject(persistStateToConfigInjectionToken);

packages/core/src/common/persistent-storage/migrations.injectable.ts

@@ -4,7 +4,7 @@
  */
 import type { InjectionToken } from "@ogre-tools/injectable";
 import { lifecycleEnum, getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { getOrInsert, iter, object } from "@k8slens/utilities";
 
 export type AllowedSetValue<T> = T extends (...args: any[]) => any
@@ -32,7 +32,7 @@ export interface MigrationDeclaration {
 const persistentStorageMigrationsInjectable = getInjectable({
   id: "persistent-storage-migrations",
   instantiate: (di, token) => {
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const declarations = di.injectMany(token);
     const migrations = new Map<string, MigrationDeclaration["run"][]>();
 

packages/core/src/extensions/as-legacy-globals-for-extension-api/as-legacy-global-singleton-object-for-extension-api.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) OpenLens Authors. All rights reserved.
+ * Licensed under MIT License. See LICENSE in root directory for more information.
+ */
+import type { Injectable } from "@ogre-tools/injectable";
+import { asLegacyGlobalForExtensionApi } from "./as-legacy-global-object-for-extension-api";
+import { getLegacyGlobalDiForExtensionApi } from "./legacy-global-di-for-extension-api";
+import { loggerInjectable } from "@k8slens/logger";
+
+export interface LegacySingleton<T> {
+  createInstance(): T;
+  getInstance(): T;
+  resetInstance(): void;
+}
+
+export function asLegacyGlobalSingletonForExtensionApi<Instance>(injectable: Injectable<Instance, unknown, void>): LegacySingleton<Instance>;
+export function asLegacyGlobalSingletonForExtensionApi<Instance, InstantiationParameter>(injectable: Injectable<Instance, unknown, InstantiationParameter>, param: InstantiationParameter): LegacySingleton<Instance>;
+
+export function asLegacyGlobalSingletonForExtensionApi<Instance, InstantiationParameter>(
+  injectable: Injectable<Instance, unknown, InstantiationParameter>,
+  instantiationParameter?: InstantiationParameter,
+): LegacySingleton<Instance> {
+  const instance = asLegacyGlobalForExtensionApi(
+    injectable as never,
+    instantiationParameter,
+  ) as Instance;
+
+  return {
+    createInstance: () => instance,
+
+    getInstance: () => instance,
+
+    resetInstance: () => {
+      const di = getLegacyGlobalDiForExtensionApi();
+      const logger = di.inject(loggerInjectable);
+
+      logger.warn(
+        `resetInstance() for a legacy global singleton of "${injectable.id}" does nothing.`,
+      );
+    },
+  };
+}

packages/core/src/extensions/common-api/index.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { asLegacyGlobalForExtensionApi } from "@k8slens/legacy-global-di";
 
 // APIs
@@ -20,4 +20,4 @@ export type { LensExtension } from "../lens-extension";
 export type { PackageJson } from "type-fest";
 export type { LensExtensionManifest, InstalledExtension } from "@k8slens/legacy-extensions";
 
-export const logger = asLegacyGlobalForExtensionApi(loggerInjectable);
+export const logger = asLegacyGlobalForExtensionApi(loggerInjectionToken);

packages/core/src/extensions/common-api/k8s-api.ts

@@ -21,7 +21,7 @@ import type { DerivedKubeApiOptions, KubeApiDependencies, KubeApiOptions } from
 import { KubeApi as InternalKubeApi } from "../../common/k8s-api/kube-api";
 import clusterFrameContextForNamespacedResourcesInjectable from "../../renderer/cluster-frame-context/for-namespaced-resources.injectable";
 import type { ClusterContext } from "../../renderer/cluster-frame-context/cluster-frame-context";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import maybeKubeApiInjectable from "../../common/k8s-api/maybe-kube-api.injectable";
 import { DeploymentApi as InternalDeploymentApi, IngressApi as InternalIngressApi, NodeApi, PersistentVolumeClaimApi, PodApi } from "../../common/k8s-api/endpoints";
 import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
@@ -42,7 +42,7 @@ const getKubeApiDeps = (): KubeApiDependencies => {
   const di = getLegacyGlobalDiForExtensionApi();
 
   return {
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     maybeKubeApi: di.inject(maybeKubeApiInjectable),
   };
 };
@@ -190,7 +190,7 @@ export abstract class KubeObjectStore<
     super(
       {
         context: di.inject(clusterFrameContextForNamespacedResourcesInjectable),
-        logger: di.inject(loggerInjectable),
+        logger: di.inject(loggerInjectionToken),
       },
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       api!,

packages/core/src/extensions/extension-discovery/extension-discovery.injectable.ts

@@ -10,7 +10,7 @@ import extensionInstallationStateStoreInjectable from "../extension-installation
 import installExtensionInjectable from "../install-extension/install-extension.injectable";
 import extensionPackageRootDirectoryInjectable from "../install-extension/extension-package-root-directory.injectable";
 import readJsonFileInjectable from "../../common/fs/read-json-file.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import pathExistsInjectable from "../../common/fs/path-exists.injectable";
 import watchInjectable from "../../common/fs/watch/watch.injectable";
 import accessPathInjectable from "../../common/fs/access-path.injectable";
@@ -43,7 +43,7 @@ const extensionDiscoveryInjectable = getInjectable({
     readJsonFile: di.inject(readJsonFileInjectable),
     pathExists: di.inject(pathExistsInjectable),
     watch: di.inject(watchInjectable),
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     accessPath: di.inject(accessPathInjectable),
     copy: di.inject(copyInjectable),
     removePath: di.inject(removePathInjectable),

packages/core/src/extensions/extension-installation-state-store/extension-installation-state-store.injectable.ts

@@ -3,13 +3,13 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { ExtensionInstallationStateStore } from "./extension-installation-state-store";
 
 const extensionInstallationStateStoreInjectable = getInjectable({
   id: "extension-installation-state-store",
   instantiate: (di) => new ExtensionInstallationStateStore({
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
   }),
 });
 

packages/core/src/extensions/extension-loader/extension-loader.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { ExtensionLoader } from "./extension-loader";
 import extensionInstancesInjectable from "./extension-instances.injectable";
 import extensionInjectable from "./extension/extension.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import joinPathsInjectable from "../../common/path/join-paths.injectable";
 import getDirnameOfPathInjectable from "../../common/path/get-dirname.injectable";
 import { bundledExtensionInjectionToken } from "@k8slens/legacy-extensions";
@@ -22,7 +22,7 @@ const extensionLoaderInjectable = getInjectable({
     getExtension: (instance) => di.inject(extensionInjectable, instance),
     bundledExtensions: di.injectMany(bundledExtensionInjectionToken),
     extensionEntryPointName: di.inject(extensionEntryPointNameInjectionToken),
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     joinPaths: di.inject(joinPathsInjectable),
     getDirnameOfPath: di.inject(getDirnameOfPathInjectable),
   }),

packages/core/src/extensions/ipc/ipc-main.ts

@@ -11,7 +11,7 @@ import { once } from "lodash";
 import { ipcMainHandle } from "../../common/ipc";
 import type { Logger } from "@k8slens/logger";
 import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "@k8slens/legacy-global-di";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 interface Dependencies {
   readonly logger: Logger;
@@ -26,7 +26,7 @@ export abstract class IpcMain extends IpcRegistrar {
     const di = getEnvironmentSpecificLegacyGlobalDiForExtensionApi("main");
 
     this.dependencies = {
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
     };
 
     // Call the static method on the bottom child class.

packages/core/src/extensions/lens-main-extension.ts

@@ -16,7 +16,7 @@ import type { InstalledExtension } from "./common-api";
 import type { CatalogEntityRegistry } from "../main/catalog";
 import type { NavigateForExtension } from "../main/start-main-application/lens-window/navigate-for-extension.injectable";
 import catalogEntityRegistryInjectable from "../main/catalog/entity-registry.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import navigateForExtensionInjectable from "../main/start-main-application/lens-window/navigate-for-extension.injectable";
 import ensureHashedDirectoryForExtensionInjectable from "./extension-loader/file-system-provisioner-store/ensure-hashed-directory-for-extension.injectable";
 
@@ -40,7 +40,7 @@ export class LensMainExtension extends LensExtension {
       ensureHashedDirectoryForExtension: di.inject(ensureHashedDirectoryForExtensionInjectable),
       navigate: di.inject(navigateForExtensionInjectable),
       entityRegistry: di.inject(catalogEntityRegistryInjectable),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
     };
 
     super(deps, extension);

packages/core/src/extensions/lens-renderer-extension.ts

@@ -39,7 +39,7 @@ import type { InstalledExtension } from "./common-api";
 import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "@k8slens/legacy-global-di";
 import catalogCategoryRegistryInjectable from "../common/catalog/category-registry.injectable";
 import catalogEntityRegistryInjectable from "../renderer/api/catalog/entity/registry.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import getExtensionPageParametersInjectable from "../renderer/routes/get-extension-page-parameters.injectable";
 import navigateToRouteInjectable from "../renderer/routes/navigate-to-route.injectable";
 import routesInjectable from "../renderer/routes/routes.injectable";
@@ -89,7 +89,7 @@ export class LensRendererExtension extends LensExtension {
       categoryRegistry: di.inject(catalogCategoryRegistryInjectable),
       entityRegistry: di.inject(catalogEntityRegistryInjectable),
       routes: di.inject(routesInjectable),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
     };
 
     super(deps, extension);

packages/core/src/features/application-menu/main/menu-items/help/open-documentation/open-documentation-menu-item.injectable.ts

@@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
 import applicationMenuItemInjectionToken from "../../application-menu-item-injection-token";
 import { docsUrl } from "../../../../../../common/vars";
 import openLinkInBrowserInjectable from "../../../../../../common/utils/open-link-in-browser.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const openDocumentationMenuItemInjectable = getInjectable({
   id: "open-documentation-menu-item",
 
   instantiate: (di) => {
     const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return {
       kind: "clickable-menu-item" as const,

packages/core/src/features/application-menu/main/menu-items/help/open-support/open-support-item.injectable.ts

@@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
 import applicationMenuItemInjectionToken from "../../application-menu-item-injection-token";
 import { supportUrl } from "../../../../../../common/vars";
 import openLinkInBrowserInjectable from "../../../../../../common/utils/open-link-in-browser.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const openSupportItemInjectable = getInjectable({
   id: "open-support-menu-item",
 
   instantiate: (di) => {
     const openLinkInBrowser = di.inject(openLinkInBrowserInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return {
       kind: "clickable-menu-item" as const,

packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
 import type { UpdateChannel } from "../../../common/update-channels";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { UpdateCheckResult } from "electron-updater";
 
 export type CheckForUpdatesResult = {
@@ -22,7 +22,7 @@ const checkForPlatformUpdatesInjectable = getInjectable({
 
   instantiate: (di): CheckForPlatformUpdates => {
     const electronUpdater = di.inject(electronUpdaterInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return async (updateChannel, { allowDowngrade }) => {
       electronUpdater.channel = updateChannel.id;

packages/core/src/features/application-update/main/check-for-updates/check-for-platform-updates/check-for-platform-updates.test.ts

@@ -11,7 +11,7 @@ import type { CheckForPlatformUpdates } from "./check-for-platform-updates.injec
 import checkForPlatformUpdatesInjectable from "./check-for-platform-updates.injectable";
 import type { UpdateChannel, ReleaseChannel } from "../../../common/update-channels";
 import { getPromiseStatus } from "@k8slens/test-utils";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { noop } from "@k8slens/utilities";
 
 describe("check-for-platform-updates", () => {
@@ -39,7 +39,7 @@ describe("check-for-platform-updates", () => {
 
     logErrorMock = jest.fn();
 
-    di.override(loggerInjectable, () => ({
+    di.override(loggerInjectionToken, () => ({
       error: logErrorMock,
       debug: noop,
       info: noop,

packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import electronUpdaterInjectable from "../../../../../main/electron-app/features/electron-updater.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { ProgressInfo } from "electron-updater";
 import type { ProgressOfDownload } from "../../../common/progress-of-update-download.injectable";
 
@@ -17,7 +17,7 @@ const downloadPlatformUpdateInjectable = getInjectable({
 
   instantiate: (di): DownloadPlatformUpdate => {
     const electronUpdater = di.inject(electronUpdaterInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return async (onDownloadProgress) => {
       onDownloadProgress({ percentage: 0 });

packages/core/src/features/application-update/main/download-update/download-platform-update/download-platform-update.test.ts

@@ -11,7 +11,7 @@ import type { AsyncFnMock } from "@async-fn/jest";
 import asyncFn from "@async-fn/jest";
 import { getPromiseStatus } from "@k8slens/test-utils";
 import type { DiContainer } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { noop } from "@k8slens/utilities";
 
 describe("download-platform-update", () => {
@@ -45,7 +45,7 @@ describe("download-platform-update", () => {
     di.override(electronUpdaterInjectable, () => electronUpdaterFake);
 
     logErrorMock = jest.fn();
-    di.override(loggerInjectable, () => ({
+    di.override(loggerInjectionToken, () => ({
       error: logErrorMock,
       debug: noop,
       info: noop,

packages/core/src/features/certificate-authorities/main/darwin-request-system-cas.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import execFileInjectable from "../../../common/fs/exec-file.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { AsyncResult } from "@k8slens/utilities";
 import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
 
@@ -17,7 +17,7 @@ const darwinRequestSystemCAsInjectable = getInjectable({
     platform: "darwin" as const,
     instantiate: () => {
       const execFile = di.inject(execFileInjectable);
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
 
       const execSecurity = async (...args: string[]): AsyncResult<string[]> => {
         const result = await execFile("/usr/bin/security", args);

packages/core/src/features/certificate-authorities/main/win32-request-system-cas.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import execFileInjectable from "../../../common/fs/exec-file.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { platformSpecificRequestSystemCAsInjectionToken } from "../common/request-system-cas-token";
 
 const pemEncoding = (hexEncodedCert: String) => {
@@ -27,7 +27,7 @@ const win32RequestSystemCAsInjectable = getInjectable({
     instantiate: () => {
       const winCARootsExePath: string = __non_webpack_require__.resolve("win-ca/lib/roots.exe");
       const execFile = di.inject(execFileInjectable);
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
 
       return async () => {
       /**

packages/core/src/features/cluster/storage/common/storage.injectable.ts

@@ -8,7 +8,7 @@ import { comparer, action } from "mobx";
 import { clusterStoreMigrationInjectionToken } from "./migration-token";
 import type { ClusterId, ClusterModel } from "../../../../common/cluster-types";
 import { Cluster } from "../../../../common/cluster/cluster";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import createPersistentStorageInjectable from "../../../../common/persistent-storage/create.injectable";
 import persistentStorageMigrationsInjectable from "../../../../common/persistent-storage/migrations.injectable";
 import storeMigrationVersionInjectable from "../../../../common/vars/store-migration-version.injectable";
@@ -23,7 +23,7 @@ const clustersPersistentStorageInjectable = getInjectable({
   instantiate: (di) => {
     const createPersistentStorage = di.inject(createPersistentStorageInjectable);
     const clustersState = di.inject(clustersStateInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return createPersistentStorage<ClusterStoreModel>({
       configName: "lens-cluster-store",

packages/core/src/features/helm-charts/child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/request-public-helm-repositories.injectable.ts

@@ -7,7 +7,7 @@ import { sortBy } from "lodash/fp";
 import proxyDownloadJsonInjectable from "../../../../../../../common/fetch/download-json/proxy.injectable";
 import { withTimeout } from "../../../../../../../common/fetch/timeout-controller";
 import type { HelmRepo } from "../../../../../../../common/helm/helm-repo";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const publicHelmReposUrl = "https://github.com/lensapp/artifact-hub-repositories/releases/download/latest/repositories.json";
 
@@ -16,7 +16,7 @@ const requestPublicHelmRepositoriesInjectable = getInjectable({
 
   instantiate: (di) => {
     const downloadJson = di.inject(proxyDownloadJsonInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return async (): Promise<HelmRepo[]> => {
       const controller = withTimeout(10_000);

packages/core/src/features/helm-charts/listing-active-helm-repositories-in-preferences.test.ts

@@ -12,7 +12,7 @@ import asyncFn from "@async-fn/jest";
 import type { HelmRepositoriesFromYaml } from "../../main/helm/repositories/get-active-helm-repositories/get-active-helm-repositories.injectable";
 import execFileInjectable, { type ExecFile } from "../../common/fs/exec-file.injectable";
 import helmBinaryPathInjectable from "../../main/helm/helm-binary-path.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { Logger } from "@k8slens/logger";
 import requestPublicHelmRepositoriesInjectable from "./child-features/preferences/renderer/adding-of-public-helm-repository/public-helm-repositories/request-public-helm-repositories.injectable";
 import showErrorNotificationInjectable from "../../renderer/components/notifications/show-error-notification.injectable";
@@ -45,7 +45,7 @@ describe("listing active helm repositories in preferences", () => {
       mainDi.override(readYamlFileInjectable, () => readYamlFileMock);
       mainDi.override(execFileInjectable, () => execFileMock);
       mainDi.override(helmBinaryPathInjectable, () => "some-helm-binary-path");
-      mainDi.override(loggerInjectable, () => loggerStub);
+      mainDi.override(loggerInjectionToken, () => loggerStub);
     });
 
     builder.beforeWindowStart(({ windowDi }) => {

packages/core/src/features/hotbar/storage/main/5.0.0-beta.10.injectable.ts

@@ -11,7 +11,7 @@ import joinPathsInjectable from "../../../../common/path/join-paths.injectable";
 import { getInjectable } from "@ogre-tools/injectable";
 import { hotbarStoreMigrationInjectionToken } from "../common/migrations-token";
 import readJsonSyncInjectable from "../../../../common/fs/read-json-sync.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { generateNewIdFor } from "../../../../common/utils/generate-new-id-for";
 import type { ClusterModel } from "../../../../common/cluster-types";
 import { defaultHotbarCells } from "../common/types";
@@ -43,7 +43,7 @@ const v500Beta10HotbarStoreMigrationInjectable = getInjectable({
       const joinPaths = di.inject(joinPathsInjectable);
       const readJsonSync = di.inject(readJsonSyncInjectable);
       const catalogCatalogEntity = di.inject(catalogCatalogEntityInjectable);
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
       const createHotbar = di.inject(createHotbarInjectable);
       const rawHotbars = store.get("hotbars");
       const hotbars: HotbarData[] = Array.isArray(rawHotbars) ? rawHotbars.filter(h => h && typeof h === "object") : [];

packages/core/src/features/hotbar/storage/storage-technical.test.ts

@@ -12,7 +12,7 @@ import type { IComputedValue } from "mobx";
 import { computed } from "mobx";
 import hasCategoryForEntityInjectable from "../../../common/catalog/has-category-for-entity.injectable";
 import catalogCatalogEntityInjectable from "../../../common/catalog-entities/general-catalog-entities/implementations/catalog-catalog-entity.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { Logger } from "@k8slens/logger";
 import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import storeMigrationVersionInjectable from "../../../common/vars/store-migration-version.injectable";
@@ -109,7 +109,7 @@ describe("Hotbars technical tests", () => {
       silly: jest.fn(),
     };
 
-    di.override(loggerInjectable, () => loggerMock);
+    di.override(loggerInjectionToken, () => loggerMock);
 
     di.override(directoryForUserDataInjectable, () => "/some-directory-for-user-data");
 

packages/core/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/discover-sync-kind.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import statInjectable from "../../../../../../common/fs/stat.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 export interface SyncKind {
   type: "file" | "folder" | "unknown";
@@ -16,7 +16,7 @@ const discoverKubeconfigSyncKindInjectable = getInjectable({
   id: "discover-kubeconfig-sync-kind",
   instantiate: (di): DiscoverKubeconfigSyncKind => {
     const stat = di.inject(statInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return async (path) => {
       try {

packages/core/src/features/preferences/renderer/preference-items/kubernetes/kubeconfig-sync/kubeconfig-sync.tsx

@@ -13,7 +13,7 @@ import { PathPicker } from "../../../../../../renderer/components/path-picker/pa
 import { Spinner } from "../../../../../../renderer/components/spinner";
 import { RemovableItem } from "../../../removable-item/removable-item";
 import isWindowsInjectable from "../../../../../../common/vars/is-windows.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { Logger } from "@k8slens/logger";
 import type { DiscoverAllKubeconfigSyncKinds } from "./discover-all-sync-kinds.injectable";
 import type { DiscoverKubeconfigSyncKind, SyncKind } from "./discover-sync-kind.injectable";
@@ -179,7 +179,7 @@ export const KubeconfigSync = withInjectables<Dependencies>(NonInjectedKubeconfi
   getProps: (di) => ({
     state: di.inject(userPreferencesStateInjectable),
     isWindows: di.inject(isWindowsInjectable),
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     discoverAllKubeconfigSyncKinds: di.inject(discoverAllKubeconfigSyncKindsInjectable),
     discoverKubeconfigSyncKind: di.inject(discoverKubeconfigSyncKindInjectable),
   }),

packages/core/src/features/shell-sync/main/compute-unix-shell-environment.injectable.ts

@@ -7,7 +7,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import getBasenameOfPathInjectable from "../../../common/path/get-basename.injectable";
 import spawnInjectable from "../../../main/child-process/spawn.injectable";
 import randomUUIDInjectable from "../../../main/crypto/random-uuid.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import processExecPathInjectable from "./execPath.injectable";
 import processEnvInjectable from "./env.injectable";
 import { object } from "@k8slens/utilities";
@@ -56,7 +56,7 @@ const computeUnixShellEnvironmentInjectable = getInjectable({
 
     const getBasenameOfPath = di.inject(getBasenameOfPathInjectable);
     const spawn = di.inject(spawnInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const randomUUID = di.inject(randomUUIDInjectable);
     const processExecPath = di.inject(processExecPathInjectable);
     const processEnv = di.inject(processEnvInjectable);

packages/core/src/features/shell-sync/main/setup-shell.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
 import isSnapPackageInjectable from "../../../common/vars/is-snap-package.injectable";
 import electronAppInjectable from "../../../main/electron-app/electron-app.injectable";
@@ -17,7 +17,7 @@ const setupShellInjectable = getInjectable({
 
   instantiate: (di) => ({
     run: async () => {
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
       const isSnapPackage = di.inject(isSnapPackageInjectable);
       const electronApp = di.inject(electronAppInjectable);
       const resolvedUserShellSetting = di.inject(userShellSettingInjectable);

packages/core/src/features/user-preferences/main/5.0.3-beta.1.injectable.ts

@@ -13,7 +13,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { userPreferencesMigrationInjectionToken } from "../../../features/user-preferences/common/migrations-token";
 import readJsonSyncInjectable from "../../../common/fs/read-json-sync.injectable";
 import homeDirectoryPathInjectable from "../../../common/os/home-directory-path.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import pathExistsSyncInjectable from "../../../common/fs/path-exists-sync.injectable";
 import type { ClusterStoreModel } from "../../../features/cluster/storage/common/storage.injectable";
 import type { UserPreferencesModel, KubeconfigSyncEntry } from "../common/preferences-helpers";
@@ -24,7 +24,7 @@ const v503Beta1UserPreferencesStorageMigrationInjectable = getInjectable({
     const userDataPath = di.inject(directoryForUserDataInjectable);
     const kubeConfigsPath = di.inject(directoryForKubeConfigsInjectable);
     const joinPaths = di.inject(joinPathsInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const isLogicalChildPath = di.inject(isLogicalChildPathInjectable);
     const getDirnameOfPath = di.inject(getDirnameOfPathInjectable);
     const readJsonSync = di.inject(readJsonSyncInjectable);

packages/core/src/main/__test__/kubeconfig-manager.test.ts

@@ -8,7 +8,7 @@ import { Cluster } from "../../common/cluster/cluster";
 import kubeconfigManagerInjectable from "../kubeconfig-manager/kubeconfig-manager.injectable";
 import directoryForTempInjectable from "../../common/app-paths/directory-for-temp/directory-for-temp.injectable";
 import type { DiContainer } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { Logger } from "@k8slens/logger";
 import directoryForUserDataInjectable from "../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
 import normalizedPlatformInjectable from "../../common/vars/normalized-platform.injectable";
@@ -73,7 +73,7 @@ describe("kubeconfig manager tests", () => {
       silly: jest.fn(),
     };
 
-    di.override(loggerInjectable, () => loggerMock);
+    di.override(loggerInjectionToken, () => loggerMock);
 
     ensureServerMock = asyncFn();
 

packages/core/src/main/base-store/persist-state-to-config.injectable.ts

@@ -4,12 +4,12 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { persistStateToConfigInjectionToken } from "../../common/persistent-storage/save-to-file";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 const persistStateToConfigInjectable = getInjectable({
   id: "persist-state-to-config",
   instantiate: (di) => {
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return (config, state) => {
       logger.info(`[BASE-STORE]: saving ${config.path}...`);

packages/core/src/main/cluster/broadcast-connection-update.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import type { KubeAuthUpdate } from "../../common/cluster-types";
 import type { Cluster } from "../../common/cluster/cluster";
 import broadcastMessageInjectable from "../../common/ipc/broadcast-message.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 
 export type BroadcastConnectionUpdate = (update: KubeAuthUpdate) => void;
 
@@ -14,7 +14,7 @@ const broadcastConnectionUpdateInjectable = getInjectable({
   id: "broadcast-connection-update",
   instantiate: (di, cluster): BroadcastConnectionUpdate => {
     const broadcastMessage = di.inject(broadcastMessageInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     return (update) => {
       logger.debug(`[CLUSTER]: broadcasting connection update`, { ...update, meta: cluster.getMeta() });

packages/core/src/main/cluster/cluster-connection.injectable.ts

@@ -25,7 +25,7 @@ import broadcastMessageInjectable from "../../common/ipc/broadcast-message.injec
 import createListNamespacesInjectable from "../../common/cluster/list-namespaces.injectable";
 import kubeAuthProxyServerInjectable from "./kube-auth-proxy-server.injectable";
 import loadProxyKubeconfigInjectable from "./load-proxy-kubeconfig.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import prometheusHandlerInjectable from "./prometheus-handler/prometheus-handler.injectable";
 import removeProxyKubeconfigInjectable from "./remove-proxy-kubeconfig.injectable";
 import requestApiResourcesInjectable from "./request-api-resources.injectable";
@@ -407,7 +407,7 @@ const clusterConnectionInjectable = getInjectable({
     {
       clusterVersionDetector: di.inject(clusterVersionDetectorInjectable),
       kubeAuthProxyServer: di.inject(kubeAuthProxyServerInjectable, cluster),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       prometheusHandler: di.inject(prometheusHandlerInjectable, cluster),
       broadcastConnectionUpdate: di.inject(broadcastConnectionUpdateInjectable, cluster),
       broadcastMessage: di.inject(broadcastMessageInjectable),

packages/core/src/main/cluster/manager.injectable.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import addClusterInjectable from "../../features/cluster/storage/common/add.injectable";
 import clustersInjectable from "../../features/cluster/storage/common/clusters.injectable";
 import getClusterByIdInjectable from "../../features/cluster/storage/common/get-by-id.injectable";
@@ -22,7 +22,7 @@ const clusterManagerInjectable = getInjectable({
     catalogEntityRegistry: di.inject(catalogEntityRegistryInjectable),
     clustersThatAreBeingDeleted: di.inject(clustersThatAreBeingDeletedInjectable),
     visibleCluster: di.inject(visibleClusterInjectable),
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     addCluster: di.inject(addClusterInjectable),
     clusters: di.inject(clustersInjectable),
     getClusterById: di.inject(getClusterByIdInjectable),

packages/core/src/main/cluster/prometheus-handler/prometheus-handler.injectable.ts

@@ -7,7 +7,7 @@ import type { Cluster } from "../../../common/cluster/cluster";
 import { createClusterPrometheusHandler } from "./prometheus-handler";
 import getPrometheusProviderByKindInjectable from "../../prometheus/get-by-kind.injectable";
 import prometheusProvidersInjectable from "../../prometheus/providers.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import loadProxyKubeconfigInjectable from "../load-proxy-kubeconfig.injectable";
 
 const prometheusHandlerInjectable = getInjectable({
@@ -17,7 +17,7 @@ const prometheusHandlerInjectable = getInjectable({
     {
       getPrometheusProviderByKind: di.inject(getPrometheusProviderByKindInjectable),
       prometheusProviders: di.inject(prometheusProvidersInjectable),
-      logger: di.inject(loggerInjectable),
+      logger: di.inject(loggerInjectionToken),
       loadProxyKubeconfig: di.inject(loadProxyKubeconfigInjectable, cluster),
     },
     cluster,

packages/core/src/main/cluster/request-api-resources.injectable.ts

@@ -4,7 +4,7 @@
  */
 
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import type { KubeApiResource } from "../../common/rbac";
 import type { Cluster } from "../../common/cluster/cluster";
 import { apiVersionsRequesterInjectionToken } from "./api-versions-requester";
@@ -24,7 +24,7 @@ export interface KubeResourceListGroup {
 const requestApiResourcesInjectable = getInjectable({
   id: "request-api-resources",
   instantiate: (di): RequestApiResources => {
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const apiVersionRequesters = di.injectMany(apiVersionsRequesterInjectionToken)
       .sort(byOrderNumber);
     const requestKubeApiResourcesFor = di.inject(requestKubeApiResourcesForInjectable);

packages/core/src/main/cluster/store-migrations/3.6.0-beta.1.injectable.ts

@@ -20,7 +20,7 @@ interface Pre360ClusterModel extends ClusterModel {
 import { getInjectable } from "@ogre-tools/injectable";
 import { clusterStoreMigrationInjectionToken } from "../../../features/cluster/storage/common/migration-token";
 import readFileBufferSyncInjectable from "../../../common/fs/read-file-buffer-sync.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import writeFileSyncInjectable from "../../../common/fs/write-file-sync.injectable";
 
 const v360Beta1ClusterStoreMigrationInjectable = getInjectable({
@@ -31,7 +31,7 @@ const v360Beta1ClusterStoreMigrationInjectable = getInjectable({
     const readFileSync = di.inject(readFileSyncInjectable);
     const readFileBufferSync = di.inject(readFileBufferSyncInjectable);
     const joinPaths = di.inject(joinPathsInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const writeFileSync = di.inject(writeFileSyncInjectable);
 
     return {

packages/core/src/main/cluster/store-migrations/5.0.0-beta.13.injectable.ts

@@ -9,7 +9,7 @@ import directoryForUserDataInjectable from "../../../common/app-paths/directory-
 import { isDefined } from "@k8slens/utilities";
 import joinPathsInjectable from "../../../common/path/join-paths.injectable";
 import { getInjectable } from "@ogre-tools/injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { clusterStoreMigrationInjectionToken } from "../../../features/cluster/storage/common/migration-token";
 import { generateNewIdFor } from "../../../common/utils/generate-new-id-for";
 
@@ -77,7 +77,7 @@ const v500Beta13ClusterStoreMigrationInjectable = getInjectable({
   instantiate: (di) => {
     const userDataPath = di.inject(directoryForUserDataInjectable);
     const joinPaths = di.inject(joinPathsInjectable);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
 
     const moveStorageFolder = ({ folder, newId, oldId }: { folder: string; newId: string; oldId: string }): void => {
       const oldPath = joinPaths(folder, `${oldId}.json`);

packages/core/src/main/cluster/store-migrations/snap.injectable.ts

@@ -7,7 +7,7 @@
 
 import { getInjectable } from "@ogre-tools/injectable";
 import { clusterStoreMigrationInjectionToken } from "../../../features/cluster/storage/common/migration-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import isSnapPackageInjectable from "../../../common/vars/is-snap-package.injectable";
 import type { ClusterModel } from "../../../common/cluster-types";
 import pathExistsSyncInjectable from "../../../common/fs/path-exists-sync.injectable";
@@ -17,7 +17,7 @@ const clusterStoreSnapMigrationInjectable = getInjectable({
   id: "cluster-store-snap-migration",
   instantiate: (di) => {
     const { version } = di.inject(applicationInformationToken);
-    const logger = di.inject(loggerInjectable);
+    const logger = di.inject(loggerInjectionToken);
     const isSnapPackage = di.inject(isSnapPackageInjectable);
     const pathExistsSync = di.inject(pathExistsSyncInjectable);
 

packages/core/src/main/electron-app/runnables/setup-deep-linking.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "../electron-app.injectable";
 import openDeepLinkInjectable from "../../protocol-handler/lens-protocol-router-main/open-deep-link-for-url/open-deep-link.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import commandLineArgumentsInjectable from "../../utils/command-line-arguments.injectable";
 import { startsWith, toLower } from "lodash/fp";
 import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
@@ -17,7 +17,7 @@ const setupDeepLinkingInjectable = getInjectable({
   instantiate: (di) => ({
     run: async () => {
       const app = di.inject(electronAppInjectable);
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
       const openDeepLinkForUrl = di.inject(openDeepLinkInjectable);
       const showApplicationWindow = di.inject(showApplicationWindowInjectable);
       const firstInstanceCommandLineArguments = di.inject(commandLineArgumentsInjectable);

packages/core/src/main/electron-app/runnables/setup-developer-tools-in-development-environment.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { nodeEnvInjectionToken } from "../../../common/vars/node-env-injection-token";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
 
 const setupDeveloperToolsInDevelopmentEnvironmentInjectable = getInjectable({
@@ -12,7 +12,7 @@ const setupDeveloperToolsInDevelopmentEnvironmentInjectable = getInjectable({
 
   instantiate: (di) => ({
     run: () => {
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
       const nodeEnv = di.inject(nodeEnvInjectionToken);
 
       if (nodeEnv !== "development") {

packages/core/src/main/electron-app/runnables/setup-ipc-main-handlers/setup-ipc-main-handlers.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { setupIpcMainHandlers } from "./setup-ipc-main-handlers";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
 import applicationMenuItemCompositeInjectable from "../../../../features/application-menu/main/application-menu-item-composite.injectable";
 import pushCatalogToRendererInjectable from "../../../catalog-sync-to-renderer/push-catalog-to-renderer.injectable";
@@ -17,7 +17,7 @@ const setupIpcMainHandlersInjectable = getInjectable({
 
   instantiate: (di) => ({
     run: () => {
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
 
       logger.debug("[APP-MAIN] initializing ipc main handlers");
 

packages/core/src/main/electron-app/runnables/setup-main-window-visibility-after-activation.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import electronAppInjectable from "../electron-app.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import { onLoadOfApplicationInjectionToken } from "@k8slens/application";
 import showApplicationWindowInjectable from "../../start-main-application/lens-window/show-application-window.injectable";
 
@@ -15,7 +15,7 @@ const setupMainWindowVisibilityAfterActivationInjectable = getInjectable({
     run: () => {
       const app = di.inject(electronAppInjectable);
       const showApplicationWindow = di.inject(showApplicationWindowInjectable);
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
 
       app.on("activate", (_, windowIsVisible) => {
         logger.info("APP:ACTIVATE", { hasVisibleWindows: windowIsVisible });

packages/core/src/main/helm/helm-chart-manager.injectable.ts

@@ -6,7 +6,7 @@ import { getInjectable, lifecycleEnum } from "@ogre-tools/injectable";
 import type { HelmRepo } from "../../common/helm/helm-repo";
 import { HelmChartManager } from "./helm-chart-manager";
 import helmChartManagerCacheInjectable from "./helm-chart-manager-cache.injectable";
-import { loggerInjectable } from "@k8slens/logger";
+import { loggerInjectionToken } from "@k8slens/logger";
 import execHelmInjectable from "./exec-helm/exec-helm.injectable";
 import readFileInjectable from "../../common/fs/read-file.injectable";
 import statInjectable from "../../common/fs/stat.injectable";
@@ -16,7 +16,7 @@ const helmChartManagerInjectable = getInjectable({
 
   instantiate: (di, repo: HelmRepo) => new HelmChartManager({
     cache: di.inject(helmChartManagerCacheInjectable),
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     execHelm: di.inject(execHelmInjectable),
     readFile: di.inject(readFileInjectable),
     stat: di.inject(statInjectable),