Export tokens instead of injectables

Signed-off-by: Sami Tiilikainen <97873007+samitiilikainen@users.noreply.github.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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 /**
  * 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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 "../../extensions/as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
 import ipcRendererInjectable from "../../renderer/utils/channel/ipc-renderer.injectable";
-import { loggerInjectable } from "@k8slens/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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

@@ -20,7 +20,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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import maybeKubeApiInjectable from "../maybe-kube-api.injectable";
 import { Cluster } from "../../cluster/cluster";
 
@@ -709,7 +709,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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import type { KubeApi } from "../kube-api";
 import type { KubeObject } from "../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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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 environements");
 
     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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/common/utils/with-error-logging/with-error-logging.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 { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 export type WithErrorLoggingFor = (
   getErrorMessage: (error: unknown) => string
@@ -15,7 +15,7 @@ const withErrorLoggingInjectable = getInjectable({
   id: "with-error-logging",
 
   instantiate: (di): WithErrorLoggingFor => {
-    const logError = di.inject(logErrorInjectable);
+    const logError = di.inject(logErrorInjectionToken);
 
     return (getErrorMessage) =>
       (toBeDecorated) =>

packages/core/src/common/utils/with-error-logging/with-error-logging.test.ts

@@ -9,7 +9,7 @@ import { pipeline } from "@ogre-tools/fp";
 import type { AsyncFnMock } from "@async-fn/jest";
 import asyncFn from "@async-fn/jest";
 import { getPromiseStatus } from "@k8slens/test-utils";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 describe("with-error-logging", () => {
   describe("given decorated sync function", () => {
@@ -22,7 +22,7 @@ describe("with-error-logging", () => {
 
       logErrorMock = jest.fn();
 
-      di.override(logErrorInjectable, () => logErrorMock);
+      di.override(logErrorInjectionToken, () => logErrorMock);
 
       const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
 
@@ -120,7 +120,7 @@ describe("with-error-logging", () => {
 
       logErrorMock = jest.fn();
 
-      di.override(logErrorInjectable, () => logErrorMock);
+      di.override(logErrorInjectionToken, () => logErrorMock);
 
       const withErrorLoggingFor = di.inject(withErrorLoggingInjectable);
 

packages/core/src/common/utils/with-orphan-promise/with-orphan-promise.test.ts

@@ -6,7 +6,7 @@ import type { AsyncFnMock } from "@async-fn/jest";
 import asyncFn from "@async-fn/jest";
 import { getDiForUnitTesting } from "../../../main/getDiForUnitTesting";
 import withOrphanPromiseInjectable from "./with-orphan-promise.injectable";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 describe("with orphan promise, when called", () => {
   let toBeDecorated: AsyncFnMock<(arg1: string, arg2: string) => Promise<string>>;
@@ -18,7 +18,7 @@ describe("with orphan promise, when called", () => {
 
     logErrorMock = jest.fn();
 
-    di.override(logErrorInjectable, () => logErrorMock);
+    di.override(logErrorInjectionToken, () => logErrorMock);
 
     const withOrphanPromise = di.inject(withOrphanPromiseInjectable);
 

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

@@ -5,7 +5,7 @@
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 export interface LegacySingleton<T> {
   createInstance(): T;
@@ -32,7 +32,7 @@ export function asLegacyGlobalSingletonForExtensionApi<Instance, InstantiationPa
 
     resetInstance: () => {
       const di = getLegacyGlobalDiForExtensionApi();
-      const logger = di.inject(loggerInjectable);
+      const logger = di.inject(loggerInjectionToken);
 
       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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import { asLegacyGlobalForExtensionApi } from "../as-legacy-globals-for-extension-api/as-legacy-global-object-for-extension-api";
 
 // 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

@@ -22,7 +22,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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import { getLegacyGlobalDiForExtensionApi } from "../as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
 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";
@@ -44,7 +44,7 @@ const getKubeApiDeps = (): KubeApiDependencies => {
   const di = getLegacyGlobalDiForExtensionApi();
 
   return {
-    logger: di.inject(loggerInjectable),
+    logger: di.inject(loggerInjectionToken),
     maybeKubeApi: di.inject(maybeKubeApiInjectable),
   };
 };
@@ -185,7 +185,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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/install-extension/install-extension.injectable.ts

@@ -7,7 +7,7 @@ import { fork } from "child_process";
 import AwaitLock from "await-lock";
 import pathToNpmCliInjectable from "../../common/app-paths/path-to-npm-cli.injectable";
 import extensionPackageRootDirectoryInjectable from "./extension-package-root-directory.injectable";
-import { prefixedLoggerInjectable } from "@k8slens/logging";
+import { prefixedLoggerInjectionToken } from "@k8slens/logging";
 import readJsonFileInjectable from "../../common/fs/read-json-file.injectable";
 import joinPathsInjectable from "../../common/path/join-paths.injectable";
 import type { PackageJson } from "../common-api";
@@ -36,7 +36,7 @@ const installExtensionInjectable = getInjectable({
     const readJsonFile = di.inject(readJsonFileInjectable);
     const writeJsonFile = di.inject(writeJsonFileInjectable);
     const joinPaths = di.inject(joinPathsInjectable);
-    const logger = di.inject(prefixedLoggerInjectable, "EXTENSION-INSTALLER");
+    const logger = di.inject(prefixedLoggerInjectionToken, "EXTENSION-INSTALLER");
 
     const forkNpm = (...args: string[]) => new Promise<void>((resolve, reject) => {
       const child = fork(pathToNpmCli, args, {

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 "../common-api";
 import { getEnvironmentSpecificLegacyGlobalDiForExtensionApi } from "../as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
-import { loggerInjectable } from "@k8slens/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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 "./as-legacy-globals-for-extension-api/legacy-global-di-for-extension-api";
 import catalogCategoryRegistryInjectable from "../common/catalog/category-registry.injectable";
 import catalogEntityRegistryInjectable from "../renderer/api/catalog/entity/registry.injectable";
-import { loggerInjectable } from "@k8slens/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/application-menu-in-legacy-extension-api.test.ts

@@ -9,7 +9,7 @@ import type { ApplicationBuilder } from "../../renderer/components/test-utils/ge
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
 import applicationMenuItemInjectionToken from "./main/menu-items/application-menu-item-injection-token";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 describe("application-menu-in-legacy-extension-api", () => {
   let builder: ApplicationBuilder;
@@ -28,7 +28,7 @@ describe("application-menu-in-legacy-extension-api", () => {
 
       logErrorMock = jest.fn();
 
-      mainDi.override(logErrorInjectable, () => logErrorMock);
+      mainDi.override(logErrorInjectionToken, () => logErrorMock);
     });
 
     await builder.startHidden();

packages/core/src/features/application-menu/handling-of-orphan-application-menu-items.test.ts

@@ -10,7 +10,7 @@ import { getCompositePaths } from "../../common/utils/composite/get-composite-pa
 import { getInjectable } from "@ogre-tools/injectable";
 import applicationMenuItemInjectionToken from "./main/menu-items/application-menu-item-injection-token";
 import { runInAction } from "mobx";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 describe("handling-of-orphan-application-menu-items, given orphan menu item", () => {
   let builder: ApplicationBuilder;
@@ -44,7 +44,7 @@ describe("handling-of-orphan-application-menu-items, given orphan menu item", ()
         mainDi.register(someOrphanMenuItemInjectable);
       });
 
-      mainDi.override(logErrorInjectable, () => logErrorMock);
+      mainDi.override(logErrorInjectionToken, () => logErrorMock);
 
       mainDi.override(
         populateApplicationMenuInjectable,

packages/core/src/features/application-menu/main/application-menu-item-composite.injectable.ts

@@ -12,7 +12,7 @@ import type { ApplicationMenuItemTypes } from "./menu-items/application-menu-ite
 import type { RootComposite } from "../../../common/utils/composite/interfaces";
 import type { Discriminable } from "../../../common/utils/composable-responsibilities/discriminable/discriminable";
 import { orderByOrderNumber } from "../../../common/utils/composable-responsibilities/orderable/orderable";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 import { isShown } from "../../../common/utils/composable-responsibilities/showable/showable";
 
 export type MenuItemRoot = Discriminable<"root"> & RootComposite<"root">;
@@ -22,7 +22,7 @@ const applicationMenuItemCompositeInjectable = getInjectable({
 
   instantiate: (di) => {
     const menuItems = di.inject(applicationMenuItemsInjectable);
-    const logError = di.inject(logErrorInjectable);
+    const logError = di.inject(logErrorInjectionToken);
 
     return computed((): Composite<ApplicationMenuItemTypes | MenuItemRoot> => {
       const items = menuItems.get();

packages/core/src/features/application-menu/main/application-menu-item-registrator.injectable.ts

@@ -15,13 +15,13 @@ import type {
 } from "./menu-items/application-menu-item-injection-token";
 import applicationMenuItemInjectionToken from "./menu-items/application-menu-item-injection-token";
 import type { MenuRegistration } from "./menu-registration";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 const applicationMenuItemRegistratorInjectable = getInjectable({
   id: "application-menu-item-registrator",
 
   instantiate: (di) => {
-    const logError = di.inject(logErrorInjectable);
+    const logError = di.inject(logErrorInjectionToken);
     const toRecursedInjectables = toRecursedInjectablesFor(logError);
 
     return (ext) => {

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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import type { ProgressInfo } from "electron-updater";
 import type { ProgressOfDownload } from "../../../common/progress-of-update-download/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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import type { Logger } from "@k8slens/logging";
 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/common/create-hotbar.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import type { CreateHotbarData } from "./types";
-import { prefixedLoggerInjectable } from "@k8slens/logging";
+import { prefixedLoggerInjectionToken } from "@k8slens/logging";
 import type { HotbarDependencies } from "./hotbar";
 import { Hotbar } from "./hotbar";
 
@@ -14,7 +14,7 @@ const createHotbarInjectable = getInjectable({
   id: "create-hotbar",
   instantiate: (di): CreateHotbar => {
     const deps: HotbarDependencies = {
-      logger: di.inject(prefixedLoggerInjectable, "HOTBAR"),
+      logger: di.inject(prefixedLoggerInjectionToken, "HOTBAR"),
     };
 
     return (data) => new Hotbar(deps, data);

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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import type { Logger } from "@k8slens/logging";
 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/population-of-logs-to-a-file/population-of-logs-to-a-file.test.ts

@@ -3,7 +3,7 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import type { DiContainer } from "@ogre-tools/injectable";
-import { winstonLoggerInjectable } from "@k8slens/logging";
+import { winstonLoggerInjectionToken } from "@k8slens/logging";
 import type { ApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import type winston from "winston";
@@ -52,7 +52,7 @@ describe("Population of logs to a file", () => {
     });
 
     builder.beforeWindowStart(({ windowDi }) => {
-      windowDi.unoverride(winstonLoggerInjectable);
+      windowDi.unoverride(winstonLoggerInjectionToken);
 
       // Now that we have the actual winston logger in use, let's not be noisy and deregister console transport
       runInAction(() => {
@@ -69,7 +69,7 @@ describe("Population of logs to a file", () => {
 
     await builder.render();
     windowDi = builder.applicationWindow.only.di;
-    const winstonLogger = windowDi.inject(winstonLoggerInjectable);
+    const winstonLogger = windowDi.inject(winstonLoggerInjectionToken);
 
     logWarningInRenderer = winstonLogger.warn;
   }

packages/core/src/features/population-of-logs-to-a-file/renderer/close-renderer-log-file-id.test.ts

@@ -6,7 +6,7 @@ import type winston from "winston";
 import type { SendMessageToChannel } from "@k8slens/messaging";
 import { sendMessageToChannelInjectionToken } from "@k8slens/messaging";
 import type { DiContainer } from "@ogre-tools/injectable";
-import { winstonLoggerInjectable } from "@k8slens/logging";
+import { winstonLoggerInjectionToken } from "@k8slens/logging";
 import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
 import closeRendererLogFileInjectable from "./close-renderer-log-file.injectable";
 import rendererLogFileIdInjectable from "./renderer-log-file-id.injectable";
@@ -27,7 +27,7 @@ describe("close renderer file logging", () => {
     } as any as winston.Logger;
     ipcTransportMock = { name: "ipc-renderer-transport" } as IpcLogTransport;
 
-    di.override(winstonLoggerInjectable, () => winstonMock);
+    di.override(winstonLoggerInjectionToken, () => winstonMock);
     di.override(sendMessageToChannelInjectionToken, () => sendIpcMock);
     di.override(rendererLogFileIdInjectable, () => "some-log-id");
     di.override(ipcLogTransportInjectable, () => ipcTransportMock);

packages/core/src/features/population-of-logs-to-a-file/renderer/close-renderer-log-file.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { sendMessageToChannelInjectionToken } from "@k8slens/messaging";
 import { getInjectable } from "@ogre-tools/injectable";
-import { winstonLoggerInjectable } from "@k8slens/logging";
+import { winstonLoggerInjectionToken } from "@k8slens/logging";
 import { closeIpcFileLoggerChannel } from "../common/ipc-file-logger-channel";
 import rendererLogFileIdInjectable from "./renderer-log-file-id.injectable";
 import ipcLogTransportInjectable from "./ipc-transport.injectable";
@@ -12,7 +12,7 @@ import ipcLogTransportInjectable from "./ipc-transport.injectable";
 const closeRendererLogFileInjectable = getInjectable({
   id: "close-renderer-log-file",
   instantiate: (di) => {
-    const winstonLogger = di.inject(winstonLoggerInjectable);
+    const winstonLogger = di.inject(winstonLoggerInjectionToken);
     const ipcLogTransport = di.inject(ipcLogTransportInjectable);
     const messageToChannel = di.inject(sendMessageToChannelInjectionToken);
     const fileId = di.inject(rendererLogFileIdInjectable);

packages/core/src/features/preferences/navigation-to-extension-specific-preferences.test.tsx

@@ -10,7 +10,7 @@ import "@testing-library/jest-dom/extend-expect";
 import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
 import type { Discover } from "@k8slens/react-testing-library-discovery";
 import { discoverFor } from "@k8slens/react-testing-library-discovery";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 describe("preferences - navigation to extension specific preferences", () => {
   let builder: ApplicationBuilder;
@@ -28,7 +28,7 @@ describe("preferences - navigation to extension specific preferences", () => {
       logErrorMock = jest.fn();
 
       builder.beforeWindowStart(({ windowDi }) => {
-        windowDi.override(logErrorInjectable, () => logErrorMock);
+        windowDi.override(logErrorInjectionToken, () => logErrorMock);
 
         builder.preferences.navigate();
       });

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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 import type { Logger } from "@k8slens/logging";
 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/preferences/renderer/preference-items/preferences-composite.injectable.ts

@@ -10,7 +10,7 @@ import { preferenceItemInjectionToken } from "./preference-item-injection-token"
 import { pipeline } from "@ogre-tools/fp";
 import type { PreferenceTabsRoot } from "./preference-tab-root";
 import { preferenceTabsRoot } from "./preference-tab-root";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 import { isShown } from "../../../../common/utils/composable-responsibilities/showable/showable";
 import { orderByOrderNumber } from "../../../../common/utils/composable-responsibilities/orderable/orderable";
 import { getCompositeFor } from "../../../../common/utils/composite/get-composite/get-composite";
@@ -21,7 +21,7 @@ const preferencesCompositeInjectable = getInjectable({
   instantiate: (di) => {
     const computedInjectMany = di.inject(computedInjectManyInjectable);
     const preferenceItems = computedInjectMany(preferenceItemInjectionToken);
-    const logError = di.inject(logErrorInjectable);
+    const logError = di.inject(logErrorInjectionToken);
 
     const getComposite = getCompositeFor<PreferenceItemTypes | PreferenceTabsRoot>({
       getId: (x) => x.id,

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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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/telemetry/emit-telemetry-from-specific-function-calls.test.ts

@@ -8,7 +8,7 @@ import { getInjectable } from "@ogre-tools/injectable";
 import { getDiForUnitTesting } from "../../renderer/getDiForUnitTesting";
 import telemetryWhiteListForParameterlessFunctionsInjectable from "./renderer/telemetry-white-list-for-parameterless-functions.injectable";
 import emitEventInjectable from "../../common/app-event-bus/emit-event.injectable";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 import telemetryDecoratorInjectable from "./renderer/telemetry-decorator.injectable";
 
 describe("emit-telemetry-from-specific-function-calls", () => {
@@ -57,7 +57,7 @@ describe("emit-telemetry-from-specific-function-calls", () => {
           );
         });
 
-        di.override(logErrorInjectable, () => logErrorMock);
+        di.override(logErrorInjectionToken, () => logErrorMock);
 
         whiteListedFunction = di.inject(whiteListedInjectable);
         nonWhiteListedFunction = di.inject(nonWhiteListedInjectable);

packages/core/src/features/tray/clicking-tray-menu-item-originating-from-extension.test.ts

@@ -6,7 +6,7 @@ import type { ApplicationBuilder } from "../../renderer/components/test-utils/ge
 import { getApplicationBuilder } from "../../renderer/components/test-utils/get-application-builder";
 import type { FakeExtensionOptions } from "../../renderer/components/test-utils/get-extension-fake";
 import getRandomIdInjectable from "../../common/utils/get-random-id.injectable";
-import { logErrorInjectable } from "@k8slens/logging";
+import { logErrorInjectionToken } from "@k8slens/logging";
 
 describe("clicking tray menu item originating from extension", () => {
   let builder: ApplicationBuilder;
@@ -18,7 +18,7 @@ describe("clicking tray menu item originating from extension", () => {
     builder.beforeApplicationStart(({ mainDi }) => {
       logErrorMock = jest.fn();
 
-      mainDi.override(logErrorInjectable, () => logErrorMock);
+      mainDi.override(logErrorInjectionToken, () => logErrorMock);
       mainDi.override(getRandomIdInjectable, () => () => "some-random-id");
     });
 

packages/core/src/features/user-preferences/common/storage.injectable.ts

@@ -4,7 +4,7 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { action } from "mobx";
-import { prefixedLoggerInjectable } from "@k8slens/logging";
+import { prefixedLoggerInjectionToken } from "@k8slens/logging";
 import createPersistentStorageInjectable from "../../../common/persistent-storage/create.injectable";
 import persistentStorageMigrationsInjectable from "../../../common/persistent-storage/migrations.injectable";
 import { userPreferencesMigrationInjectionToken } from "./migrations-token";
@@ -24,7 +24,7 @@ const userPreferencesPersistentStorageInjectable = getInjectable({
   id: "user-preferences-persistent-storage",
   instantiate: (di) => {
     const createPersistentStorage = di.inject(createPersistentStorageInjectable);
-    const logger = di.inject(prefixedLoggerInjectable, "USER-PREFERENCES");
+    const logger = di.inject(prefixedLoggerInjectionToken, "USER-PREFERENCES");
     const descriptors = di.inject(userPreferenceDescriptorsInjectable);
     const selectedUpdateChannel = di.inject(selectedUpdateChannelInjectable);
     const state = di.inject(userPreferencesStateInjectable);

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/logging";
+import { loggerInjectionToken } from "@k8slens/logging";
 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);