Remove uses of legacy global logger from injectables (#6660)

- Clean up some of them to use more injectables

Signed-off-by: Sebastian Malton <sebastian@malton.name>

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/main/routes/metrics/add-metrics-route.injectable.ts

@@ -7,13 +7,13 @@ import { apiPrefix } from "../../../common/vars";
 import { getRouteInjectable } from "../../router/router.injectable";
 import type { ClusterPrometheusMetadata } from "../../../common/cluster-types";
 import { ClusterMetadataKey } from "../../../common/cluster-types";
-import logger from "../../logger";
 import type { Cluster } from "../../../common/cluster/cluster";
 import { clusterRoute } from "../../router/route";
 import { isObject } from "lodash";
-import { isRequestError } from "../../../common/utils";
+import { isRequestError, object } from "../../../common/utils";
 import type { GetMetrics } from "../../get-metrics.injectable";
 import getMetricsInjectable from "../../get-metrics.injectable";
+import loggerInjectable from "../../../common/logger.injectable";
 
 // This is used for backoff retry tracking.
 const ATTEMPTS = [false, false, false, false, true];
@@ -55,66 +55,70 @@ const loadMetricsFor = (getMetrics: GetMetrics) => async (promQueries: string[],
 const addMetricsRouteInjectable = getRouteInjectable({
   id: "add-metrics-route",
 
-  instantiate: (di) => clusterRoute({
-    method: "post",
-    path: `${apiPrefix}/metrics`,
-  })(async ({ cluster, payload, query }) => {
+  instantiate: (di) => {
     const getMetrics = di.inject(getMetricsInjectable);
     const loadMetrics = loadMetricsFor(getMetrics);
+    const logger = di.inject(loggerInjectable);
 
-    const queryParams: Partial<Record<string, string>> = Object.fromEntries(query.entries());
-    const prometheusMetadata: ClusterPrometheusMetadata = {};
+    return clusterRoute({
+      method: "post",
+      path: `${apiPrefix}/metrics`,
+    })(async ({ cluster, payload, query }) => {
+      const queryParams: Partial<Record<string, string>> = Object.fromEntries(query.entries());
+      const prometheusMetadata: ClusterPrometheusMetadata = {};
 
-    try {
-      const { prometheusPath, provider } = await cluster.contextHandler.getPrometheusDetails();
+      try {
+        const { prometheusPath, provider } = await cluster.contextHandler.getPrometheusDetails();
 
-      prometheusMetadata.provider = provider?.kind;
-      prometheusMetadata.autoDetected = !cluster.preferences.prometheusProvider?.type;
+        prometheusMetadata.provider = provider?.kind;
+        prometheusMetadata.autoDetected = !cluster.preferences.prometheusProvider?.type;
 
-      if (!prometheusPath) {
-        prometheusMetadata.success = false;
+        if (!prometheusPath) {
+          prometheusMetadata.success = false;
+
+          return { response: {}};
+        }
+
+        // return data in same structure as query
+        if (typeof payload === "string") {
+          const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams);
+
+          return { response: data };
+        }
+
+        if (Array.isArray(payload)) {
+          const data = await loadMetrics(payload, cluster, prometheusPath, queryParams);
+
+          return { response: data };
+        }
+
+        if (isObject(payload)) {
+          const data = payload as Record<string, Record<string, string>>;
+          const queries = object.entries(data)
+            .map(([queryName, queryOpts]) => (
+              provider.getQuery(queryOpts, queryName)
+            ));
+
+          const result = await loadMetrics(queries, cluster, prometheusPath, queryParams);
+          const response = object.fromEntries(object.keys(data).map((metricName, i) => [metricName, result[i]]));
+
+          prometheusMetadata.success = true;
+
+          return { response };
+        }
 
         return { response: {}};
+      } catch (error) {
+        prometheusMetadata.success = false;
+
+        logger.warn(`[METRICS-ROUTE]: failed to get metrics for clusterId=${cluster.id}:`, error);
+
+        return { response: {}};
+      } finally {
+        cluster.metadata[ClusterMetadataKey.PROMETHEUS] = prometheusMetadata;
       }
-
-      // return data in same structure as query
-      if (typeof payload === "string") {
-        const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams);
-
-        return { response: data };
-      }
-
-      if (Array.isArray(payload)) {
-        const data = await loadMetrics(payload, cluster, prometheusPath, queryParams);
-
-        return { response: data };
-      }
-
-      if (isObject(payload)) {
-        const queries = Object.entries(payload as Record<string, Record<string, string>>)
-          .map(([queryName, queryOpts]) => (
-            provider.getQuery(queryOpts, queryName)
-          ));
-
-        const result = await loadMetrics(queries, cluster, prometheusPath, queryParams);
-        const data = Object.fromEntries(Object.keys(payload).map((metricName, i) => [metricName, result[i]]));
-
-        prometheusMetadata.success = true;
-
-        return { response: data };
-      }
-
-      return { response: {}};
-    } catch (error) {
-      prometheusMetadata.success = false;
-
-      logger.warn(`[METRICS-ROUTE]: failed to get metrics for clusterId=${cluster.id}:`, error);
-
-      return { response: {}};
-    } finally {
-      cluster.metadata[ClusterMetadataKey.PROMETHEUS] = prometheusMetadata;
-    }
-  }),
+    });
+  },
 });
 
 export default addMetricsRouteInjectable;

src/main/routes/port-forward/start-port-forward-route.injectable.ts

@@ -5,15 +5,16 @@
 import { getRouteInjectable } from "../../router/router.injectable";
 import { apiPrefix } from "../../../common/vars";
 import { PortForward } from "./functionality/port-forward";
-import logger from "../../logger";
 import createPortForwardInjectable from "./functionality/create-port-forward.injectable";
 import { clusterRoute } from "../../router/route";
+import loggerInjectable from "../../../common/logger.injectable";
 
 const startPortForwardRouteInjectable = getRouteInjectable({
   id: "start-current-port-forward-route",
 
   instantiate: (di) => {
     const createPortForward = di.inject(createPortForwardInjectable);
+    const logger = di.inject(loggerInjectable);
 
     return clusterRoute({
       method: "post",

src/main/routes/port-forward/stop-current-port-forward-route.injectable.ts

@@ -5,39 +5,42 @@
 import { getRouteInjectable } from "../../router/router.injectable";
 import { apiPrefix } from "../../../common/vars";
 import { PortForward } from "./functionality/port-forward";
-import logger from "../../logger";
 import { clusterRoute } from "../../router/route";
+import loggerInjectable from "../../../common/logger.injectable";
 
 const stopCurrentPortForwardRouteInjectable = getRouteInjectable({
   id: "stop-current-port-forward-route",
 
-  instantiate: () => clusterRoute({
-    method: "delete",
-    path: `${apiPrefix}/pods/port-forward/{namespace}/{resourceType}/{resourceName}`,
-  })(async ({ params, query, cluster }) => {
-    const { namespace, resourceType, resourceName } = params;
-    const port = Number(query.get("port"));
-    const forwardPort = Number(query.get("forwardPort"));
-    const portForward = PortForward.getPortforward({
-      clusterId: cluster.id, kind: resourceType, name: resourceName,
-      namespace, port, forwardPort,
+  instantiate: (di) => {
+    const logger = di.inject(loggerInjectable);
+
+    return clusterRoute({
+      method: "delete",
+      path: `${apiPrefix}/pods/port-forward/{namespace}/{resourceType}/{resourceName}`,
+    })(async ({ params, query, cluster }) => {
+      const { namespace, resourceType, resourceName } = params;
+      const port = Number(query.get("port"));
+      const forwardPort = Number(query.get("forwardPort"));
+      const portForward = PortForward.getPortforward({
+        clusterId: cluster.id, kind: resourceType, name: resourceName,
+        namespace, port, forwardPort,
+      });
+
+      try {
+        await portForward?.stop();
+
+        return { response: { status: true }};
+      } catch (error) {
+        logger.error("[PORT-FORWARD-ROUTE]: error stopping a port-forward", { namespace, port, forwardPort, resourceType, resourceName });
+
+        return {
+          error: {
+            message: `error stopping a forward port ${port}`,
+          },
+        };
+      }
     });
-
-    try {
-      await portForward?.stop();
-
-      return { response: { status: true }};
-    } catch (error) {
-      logger.error("[PORT-FORWARD-ROUTE]: error stopping a port-forward", { namespace, port, forwardPort, resourceType, resourceName });
-
-      return {
-        error: {
-          message: `error stopping a forward port ${port}`,
-        },
-      };
-
-    }
-  }),
+  },
 });
 
 export default stopCurrentPortForwardRouteInjectable;