pepr 0.40.1 → 0.42.1

package/src/lib/storage.ts

@@ -12,15 +12,20 @@ export type Unsubscribe = () => void;
 const MAX_WAIT_TIME = 15000;
 const STORE_VERSION_PREFIX = "v2";
 
-export function v2StoreKey(key: string) {
+interface WaitRecord {
+  timeout?: ReturnType<typeof setTimeout>;
+  unsubscribe?: () => void;
+}
+
+export function v2StoreKey(key: string): string {
   return `${STORE_VERSION_PREFIX}-${pointer.escape(key)}`;
 }
 
-export function v2UnescapedStoreKey(key: string) {
+export function v2UnescapedStoreKey(key: string): string {
   return `${STORE_VERSION_PREFIX}-${key}`;
 }
 
-export function stripV2Prefix(key: string) {
+export function stripV2Prefix(key: string): string {
   return key.replace(/^v2-/, "");
 }
 export interface PeprStore {
@@ -58,13 +63,13 @@ export interface PeprStore {
    * Sets the value of the pair identified by key to value, creating a new key/value pair if none existed for key previously.
    * Resolves when the key/value show up in the store.
    */
-  setItemAndWait(key: string, value: string): Promise<void>;
+  setItemAndWait(key: string, value: string): Promise<string>;
 
   /**
    * Remove the value of the key.
    * Resolves when the key does not show up in the store.
    */
-  removeItemAndWait(key: string): Promise<void>;
+  removeItemAndWait(key: string): Promise<string>;
 }
 
 /**
@@ -80,11 +85,11 @@ export class Storage implements PeprStore {
   #subscriberId = 0;
   #readyHandlers: DataReceiver[] = [];
 
-  registerSender = (send: DataSender) => {
+  registerSender = (send: DataSender): void => {
     this.#send = send;
   };
 
-  receive = (data: DataStore) => {
+  receive = (data: DataStore): void => {
     this.#store = data || {};
 
     this.#onReady();
@@ -96,7 +101,7 @@ export class Storage implements PeprStore {
     }
   };
 
-  getItem = (key: string) => {
+  getItem = (key: string): string | null => {
     const result = this.#store[v2UnescapedStoreKey(key)] || null;
     if (result !== null && typeof result !== "function" && typeof result !== "object") {
       return result;
@@ -104,7 +109,7 @@ export class Storage implements PeprStore {
     return null;
   };
 
-  clear = () => {
+  clear = (): void => {
     Object.keys(this.#store).length > 0 &&
       this.#dispatchUpdate(
         "remove",
@@ -112,11 +117,11 @@ export class Storage implements PeprStore {
       );
   };
 
-  removeItem = (key: string) => {
+  removeItem = (key: string): void => {
     this.#dispatchUpdate("remove", [v2StoreKey(key)]);
   };
 
-  setItem = (key: string, value: string) => {
+  setItem = (key: string, value: string): void => {
     this.#dispatchUpdate("add", [v2StoreKey(key)], value);
   };
 
@@ -128,22 +133,24 @@ export class Storage implements PeprStore {
    * @param value - The value of the key
    * @returns
    */
-  setItemAndWait = (key: string, value: string) => {
+  setItemAndWait = (key: string, value: string): Promise<string> => {
     this.#dispatchUpdate("add", [v2StoreKey(key)], value);
+    const record: WaitRecord = {};
 
-    return new Promise<void>((resolve, reject) => {
-      const unsubscribe = this.subscribe(data => {
+    return new Promise<string>((resolve, reject) => {
+      // If promise has not resolved before MAX_WAIT_TIME reject
+      record.timeout = setTimeout(() => {
+        record.unsubscribe!();
+        return reject(`MAX_WAIT_TIME elapsed: Key ${key} not seen in ${MAX_WAIT_TIME / 1000}s`);
+      }, MAX_WAIT_TIME);
+
+      record.unsubscribe = this.subscribe(data => {
         if (data[`${v2UnescapedStoreKey(key)}`] === value) {
-          unsubscribe();
-          resolve();
+          record.unsubscribe!();
+          clearTimeout(record.timeout);
+          resolve("ok");
         }
       });
-
-      // If promise has not resolved before MAX_WAIT_TIME reject
-      setTimeout(() => {
-        unsubscribe();
-        return reject();
-      }, MAX_WAIT_TIME);
     });
   };
 
@@ -154,31 +161,33 @@ export class Storage implements PeprStore {
    * @param key - The key to add into the store
    * @returns
    */
-  removeItemAndWait = (key: string) => {
+  removeItemAndWait = (key: string): Promise<string> => {
     this.#dispatchUpdate("remove", [v2StoreKey(key)]);
-    return new Promise<void>((resolve, reject) => {
-      const unsubscribe = this.subscribe(data => {
+    const record: WaitRecord = {};
+    return new Promise<string>((resolve, reject) => {
+      // If promise has not resolved before MAX_WAIT_TIME reject
+      record.timeout = setTimeout(() => {
+        record.unsubscribe!();
+        return reject(`MAX_WAIT_TIME elapsed: Key ${key} still seen after ${MAX_WAIT_TIME / 1000}s`);
+      }, MAX_WAIT_TIME);
+
+      record.unsubscribe = this.subscribe(data => {
         if (!Object.hasOwn(data, `${v2UnescapedStoreKey(key)}`)) {
-          unsubscribe();
-          resolve();
+          record.unsubscribe!();
+          clearTimeout(record.timeout);
+          resolve("ok");
         }
       });
-
-      // If promise has not resolved before MAX_WAIT_TIME reject
-      setTimeout(() => {
-        unsubscribe();
-        return reject();
-      }, MAX_WAIT_TIME);
     });
   };
 
-  subscribe = (subscriber: DataReceiver) => {
+  subscribe = (subscriber: DataReceiver): (() => void) => {
     const idx = this.#subscriberId++;
     this.#subscribers[idx] = subscriber;
     return () => this.unsubscribe(idx);
   };
 
-  onReady = (callback: DataReceiver) => {
+  onReady = (callback: DataReceiver): void => {
     this.#readyHandlers.push(callback);
   };
 
@@ -186,18 +195,18 @@ export class Storage implements PeprStore {
    * Remove a subscriber from the list of subscribers.
    * @param idx - The index of the subscriber to remove.
    */
-  unsubscribe = (idx: number) => {
+  unsubscribe = (idx: number): void => {
     delete this.#subscribers[idx];
   };
 
-  #onReady = () => {
+  #onReady = (): void => {
     // Notify all ready handlers with a clone of the store
     for (const handler of this.#readyHandlers) {
       handler(clone(this.#store));
     }
 
     // Make this a noop so that it can't be called again
-    this.#onReady = () => {};
+    this.#onReady = (): void => {};
   };
 
   /**
@@ -206,7 +215,7 @@ export class Storage implements PeprStore {
    * @param  keys - The keys to update.
    * @param  [value] - The new value.
    */
-  #dispatchUpdate = (op: DataOp, keys: string[], value?: string) => {
+  #dispatchUpdate = (op: DataOp, keys: string[], value?: string): void => {
     this.#send(op, keys, value);
   };
 }

package/src/lib/{logger.ts → telemetry/logger.ts}

@@ -3,7 +3,7 @@
 
 import { Operation } from "fast-json-patch";
 import { pino, stdTimeFunctions } from "pino";
-import { Store } from "./k8s";
+import { Store } from "../k8s";
 
 const isPrettyLog = process.env.PEPR_PRETTY_LOGS === "true";
 const redactedValue = "**redacted**";

package/src/lib/{metrics.ts → telemetry/metrics.ts}

@@ -9,6 +9,7 @@ import Log from "./logger";
 
 const loggingPrefix = "MetricsCollector";
 
+type MetricsCollectorInstance = InstanceType<typeof MetricsCollector>;
 interface MetricNames {
   errors: string;
   alerts: string;
@@ -60,7 +61,7 @@ export class MetricsCollector {
     this.addGauge(this.#metricNames.resyncFailureCount, "Number of failures per resync operation", ["count"]);
   }
 
-  #getMetricName = (name: string) => `${this.#prefix}_${name}`;
+  #getMetricName = (name: string): string => `${this.#prefix}_${name}`;
 
   #addMetric = <T extends Counter<string> | Gauge<string> | Summary<string>>(
     collection: Map<string, T>,
@@ -68,7 +69,7 @@ export class MetricsCollector {
     name: string,
     help: string,
     labelNames?: string[],
-  ) => {
+  ): void => {
     if (collection.has(this.#getMetricName(name))) {
       Log.debug(`Metric for ${name} already exists`, loggingPrefix);
       return;
@@ -84,42 +85,42 @@ export class MetricsCollector {
     collection.set(this.#getMetricName(name), metric);
   };
 
-  addCounter = (name: string, help: string) => {
+  addCounter = (name: string, help: string): void => {
     this.#addMetric(this.#counters, promClient.Counter, name, help, []);
   };
 
-  addSummary = (name: string, help: string) => {
+  addSummary = (name: string, help: string): void => {
     this.#addMetric(this.#summaries, promClient.Summary, name, help, []);
   };
 
-  addGauge = (name: string, help: string, labelNames?: string[]) => {
+  addGauge = (name: string, help: string, labelNames?: string[]): void => {
     this.#addMetric(this.#gauges, promClient.Gauge, name, help, labelNames);
   };
 
-  incCounter = (name: string) => {
+  incCounter = (name: string): void => {
     this.#counters.get(this.#getMetricName(name))?.inc();
   };
 
-  incGauge = (name: string, labels?: Record<string, string>, value: number = 1) => {
+  incGauge = (name: string, labels?: Record<string, string>, value: number = 1): void => {
     this.#gauges.get(this.#getMetricName(name))?.inc(labels || {}, value);
   };
 
   /**
    * Increments the error counter.
    */
-  error = () => this.incCounter(this.#metricNames.errors);
+  error = (): void => this.incCounter(this.#metricNames.errors);
 
   /**
    * Increments the alerts counter.
    */
-  alert = () => this.incCounter(this.#metricNames.alerts);
+  alert = (): void => this.incCounter(this.#metricNames.alerts);
 
   /**
    * Observes the duration since the provided start time and updates the summary.
    * @param startTime - The start time.
    * @param name - The metrics summary to increment.
    */
-  observeEnd = (startTime: number, name: string = this.#metricNames.mutate) => {
+  observeEnd = (startTime: number, name: string = this.#metricNames.mutate): void => {
     this.#summaries.get(this.#getMetricName(name))?.observe(performance.now() - startTime);
   };
 
@@ -127,13 +128,13 @@ export class MetricsCollector {
    * Fetches the current metrics from the registry.
    * @returns The metrics.
    */
-  getMetrics = () => this.#registry.metrics();
+  getMetrics = (): Promise<string> => this.#registry.metrics();
 
   /**
    * Returns the current timestamp from performance.now() method. Useful for start timing an operation.
    * @returns The timestamp.
    */
-  static observeStart() {
+  static observeStart(): number {
     return performance.now();
   }
 
@@ -141,7 +142,7 @@ export class MetricsCollector {
    * Increments the cache miss gauge for a given label.
    * @param label - The label for the cache miss.
    */
-  incCacheMiss = (window: string) => {
+  incCacheMiss = (window: string): void => {
     this.incGauge(this.#metricNames.cacheMiss, { window });
   };
 
@@ -149,7 +150,7 @@ export class MetricsCollector {
    * Increments the retry count gauge.
    * @param count - The count to increment by.
    */
-  incRetryCount = (count: string) => {
+  incRetryCount = (count: string): void => {
     this.incGauge(this.#metricNames.resyncFailureCount, { count });
   };
 
@@ -157,7 +158,7 @@ export class MetricsCollector {
    * Initializes the cache miss gauge for a given label.
    * @param label - The label for the cache miss.
    */
-  initCacheMissWindow = (window: string) => {
+  initCacheMissWindow = (window: string): void => {
     this.#rollCacheMissWindows();
     this.#gauges.get(this.#getMetricName(this.#metricNames.cacheMiss))?.set({ window }, 0);
     this.#cacheMissWindows.set(window, 0);
@@ -166,7 +167,7 @@ export class MetricsCollector {
   /**
    * Manages the size of the cache miss gauge map.
    */
-  #rollCacheMissWindows = () => {
+  #rollCacheMissWindows = (): void => {
     const maxCacheMissWindows = process.env.PEPR_MAX_CACHE_MISS_WINDOWS
       ? parseInt(process.env.PEPR_MAX_CACHE_MISS_WINDOWS, 10)
       : undefined;
@@ -181,4 +182,4 @@ export class MetricsCollector {
   };
 }
 
-export const metricsCollector = new MetricsCollector("pepr");
+export const metricsCollector: MetricsCollectorInstance = new MetricsCollector("pepr");

package/src/lib/types.ts

@@ -70,6 +70,17 @@ export interface RegExpFilter {
   obj: RegExp;
   source: string;
 }
+
+export type Filters = {
+  annotations: Record<string, string>;
+  deletionTimestamp: boolean;
+  labels: Record<string, string>;
+  name: string;
+  namespaces: string[];
+  regexName: string;
+  regexNamespaces: string[];
+};
+
 export type Binding = {
   event: Event;
   isMutate?: boolean;
@@ -79,15 +90,7 @@ export type Binding = {
   isFinalize?: boolean;
   readonly model: GenericClass;
   readonly kind: GroupVersionKind;
-  readonly filters: {
-    name: string;
-    regexName: string;
-    namespaces: string[];
-    regexNamespaces: string[];
-    labels: Record<string, string>;
-    annotations: Record<string, string>;
-    deletionTimestamp: boolean;
-  };
+  readonly filters: Filters;
   alias?: string;
   readonly mutateCallback?: MutateAction<GenericClass, InstanceType<GenericClass>>;
   readonly validateCallback?: ValidateAction<GenericClass, InstanceType<GenericClass>>;

package/src/lib/utils.ts

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 
-import Log from "./logger";
+import Log from "./telemetry/logger";
 
 /** Test if a string is ascii or not */
-export const isAscii = /^[\s\x20-\x7E]*$/;
+export const isAscii: RegExp = /^[\s\x20-\x7E]*$/;
 
 /**
  * Encode all ascii values in a map to base64
  * @param obj The object to encode
  * @param skip A list of keys to skip encoding
  */
-export function convertToBase64Map(obj: { data?: Record<string, string> }, skip: string[]) {
+export function convertToBase64Map(obj: { data?: Record<string, string> }, skip: string[]): void {
   obj.data = obj.data ?? {};
   for (const key in obj.data) {
     const value = obj.data[key];
@@ -25,7 +25,7 @@ export function convertToBase64Map(obj: { data?: Record<string, string> }, skip:
  * @param obj The object to decode
  * @returns A list of keys that were skipped
  */
-export function convertFromBase64Map(obj: { data?: Record<string, string> }) {
+export function convertFromBase64Map(obj: { data?: Record<string, string> }): string[] {
   const skip: string[] = [];
 
   obj.data = obj.data ?? {};
@@ -47,11 +47,11 @@ export function convertFromBase64Map(obj: { data?: Record<string, string> }) {
 }
 
 /** Decode a base64 string */
-export function base64Decode(data: string) {
+export function base64Decode(data: string): string {
   return Buffer.from(data, "base64").toString("utf-8");
 }
 
 /** Encode a string to base64 */
-export function base64Encode(data: string) {
+export function base64Encode(data: string): string {
   return Buffer.from(data).toString("base64");
 }

package/src/lib/validate-processor.ts

@@ -1,17 +1,56 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Pepr Authors
 
-import { kind } from "kubernetes-fluent-client";
-
+import { kind, KubernetesObject } from "kubernetes-fluent-client";
 import { Capability } from "./capability";
 import { shouldSkipRequest } from "./filter/filter";
 import { ValidateResponse } from "./k8s";
-import { AdmissionRequest } from "./types";
-import Log from "./logger";
+import { AdmissionRequest, Binding } from "./types";
+import Log from "./telemetry/logger";
 import { convertFromBase64Map } from "./utils";
 import { PeprValidateRequest } from "./validate-request";
 import { ModuleConfig } from "./module";
 
+export async function processRequest(
+  binding: Binding,
+  actionMetadata: Record<string, string>,
+  peprValidateRequest: PeprValidateRequest<KubernetesObject>,
+): Promise<ValidateResponse> {
+  const label = binding.validateCallback!.name;
+  Log.info(actionMetadata, `Processing validation action (${label})`);
+
+  const valResp: ValidateResponse = {
+    uid: peprValidateRequest.Request.uid,
+    allowed: true, // Assume it's allowed until a validation check fails
+  };
+
+  try {
+    // Run the validation callback, if it fails set allowed to false
+    const callbackResp = await binding.validateCallback!(peprValidateRequest);
+    valResp.allowed = callbackResp.allowed;
+
+    // If the validation callback returned a status code or message, set it in the Response
+    if (callbackResp.statusCode || callbackResp.statusMessage) {
+      valResp.status = {
+        code: callbackResp.statusCode || 400,
+        message: callbackResp.statusMessage || `Validation failed for ${name}`,
+      };
+    }
+
+    Log.info(actionMetadata, `Validation action complete (${label}): ${callbackResp.allowed ? "allowed" : "denied"}`);
+    return valResp;
+  } catch (e) {
+    // If any validation throws an error, note the failure in the Response
+    Log.error(actionMetadata, `Action failed: ${JSON.stringify(e)}`);
+    valResp.allowed = false;
+    valResp.status = {
+      code: 500,
+      message: `Action failed with error: ${JSON.stringify(e)}`,
+    };
+    return valResp;
+  }
+}
+
 export async function validateProcessor(
   config: ModuleConfig,
   capabilities: Capability[],
@@ -32,52 +71,21 @@ export async function validateProcessor(
   for (const { name, bindings, namespaces } of capabilities) {
     const actionMetadata = { ...reqMetadata, name };
 
-    for (const action of bindings) {
+    for (const binding of bindings) {
       // Skip this action if it's not a validation action
-      if (!action.validateCallback) {
+      if (!binding.validateCallback) {
         continue;
       }
 
-      const localResponse: ValidateResponse = {
-        uid: req.uid,
-        allowed: true, // Assume it's allowed until a validation check fails
-      };
-
       // Continue to the next action without doing anything if this one should be skipped
-      const shouldSkip = shouldSkipRequest(action, req, namespaces, config?.alwaysIgnore?.namespaces);
+      const shouldSkip = shouldSkipRequest(binding, req, namespaces, config?.alwaysIgnore?.namespaces);
       if (shouldSkip !== "") {
         Log.debug(shouldSkip);
         continue;
       }
 
-      const label = action.validateCallback.name;
-      Log.info(actionMetadata, `Processing validation action (${label})`);
-
-      try {
-        // Run the validation callback, if it fails set allowed to false
-        const resp = await action.validateCallback(wrapped);
-        localResponse.allowed = resp.allowed;
-
-        // If the validation callback returned a status code or message, set it in the Response
-        if (resp.statusCode || resp.statusMessage) {
-          localResponse.status = {
-            code: resp.statusCode || 400,
-            message: resp.statusMessage || `Validation failed for ${name}`,
-          };
-        }
-
-        Log.info(actionMetadata, `Validation action complete (${label}): ${resp.allowed ? "allowed" : "denied"}`);
-      } catch (e) {
-        // If any validation throws an error, note the failure in the Response
-        Log.error(actionMetadata, `Action failed: ${JSON.stringify(e)}`);
-        localResponse.allowed = false;
-        localResponse.status = {
-          code: 500,
-          message: `Action failed with error: ${JSON.stringify(e)}`,
-        };
-        return [localResponse];
-      }
-      response.push(localResponse);
+      const resp = await processRequest(binding, actionMetadata, wrapped);
+      response.push(resp);
     }
   }
 

package/src/lib/watch-processor.ts

@@ -5,11 +5,11 @@ import { WatchPhase } from "kubernetes-fluent-client/dist/fluent/types";
 import { Capability } from "./capability";
 import { filterNoMatchReason } from "./helpers";
 import { removeFinalizer } from "./finalizer";
-import Log from "./logger";
+import Log from "./telemetry/logger";
 import { Queue } from "./queue";
 import { Binding } from "./types";
 import { Event } from "./enums";
-import { metricsCollector } from "./metrics";
+import { metricsCollector } from "./telemetry/metrics";
 
 // stores Queue instances
 const queues: Record<string, Queue<KubernetesObject>> = {};
@@ -20,7 +20,7 @@ const queues: Record<string, Queue<KubernetesObject>> = {};
  * @param obj The object to derive a key from
  * @returns The key to a Queue in the list of queues
  */
-export function queueKey(obj: KubernetesObject) {
+export function queueKey(obj: KubernetesObject): string {
   const options = ["kind", "kindNs", "kindNsName", "global"];
   const d3fault = "kind";
 
@@ -40,7 +40,7 @@ export function queueKey(obj: KubernetesObject) {
   return lookup[strat];
 }
 
-export function getOrCreateQueue(obj: KubernetesObject) {
+export function getOrCreateQueue(obj: KubernetesObject): Queue<KubernetesObject> {
   const key = queueKey(obj);
   if (!queues[key]) {
     queues[key] = new Queue<KubernetesObject>(key);
@@ -62,11 +62,11 @@ const watchCfg: WatchCfg = {
 
 // Map the event to the watch phase
 const eventToPhaseMap = {
-  [Event.Create]: [WatchPhase.Added],
-  [Event.Update]: [WatchPhase.Modified],
-  [Event.CreateOrUpdate]: [WatchPhase.Added, WatchPhase.Modified],
-  [Event.Delete]: [WatchPhase.Deleted],
-  [Event.Any]: [WatchPhase.Added, WatchPhase.Modified, WatchPhase.Deleted],
+  [Event.CREATE]: [WatchPhase.Added],
+  [Event.UPDATE]: [WatchPhase.Modified],
+  [Event.CREATE_OR_UPDATE]: [WatchPhase.Added, WatchPhase.Modified],
+  [Event.DELETE]: [WatchPhase.Deleted],
+  [Event.ANY]: [WatchPhase.Added, WatchPhase.Modified, WatchPhase.Deleted],
 };
 
 /**
@@ -74,7 +74,7 @@ const eventToPhaseMap = {
  *
  * @param capabilities The capabilities to load watches for
  */
-export function setupWatch(capabilities: Capability[], ignoredNamespaces?: string[]) {
+export function setupWatch(capabilities: Capability[], ignoredNamespaces?: string[]): void {
   capabilities.map(capability =>
     capability.bindings
       .filter(binding => binding.isWatch)
@@ -88,14 +88,18 @@ export function setupWatch(capabilities: Capability[], ignoredNamespaces?: strin
  * @param binding the binding to watch
  * @param capabilityNamespaces list of namespaces to filter on
  */
-async function runBinding(binding: Binding, capabilityNamespaces: string[], ignoredNamespaces?: string[]) {
+async function runBinding(
+  binding: Binding,
+  capabilityNamespaces: string[],
+  ignoredNamespaces?: string[],
+): Promise<void> {
   // Get the phases to match, fallback to any
-  const phaseMatch: WatchPhase[] = eventToPhaseMap[binding.event] || eventToPhaseMap[Event.Any];
+  const phaseMatch: WatchPhase[] = eventToPhaseMap[binding.event] || eventToPhaseMap[Event.ANY];
 
   // The watch callback is run when an object is received or dequeued
   Log.debug({ watchCfg }, "Effective WatchConfig");
 
-  const watchCallback = async (kubernetesObject: KubernetesObject, phase: WatchPhase) => {
+  const watchCallback = async (kubernetesObject: KubernetesObject, phase: WatchPhase): Promise<void> => {
     // First, filter the object based on the phase
     if (phaseMatch.includes(phase)) {
       try {
@@ -117,7 +121,7 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[], igno
     }
   };
 
-  const handleFinalizerRemoval = async (kubernetesObject: KubernetesObject) => {
+  const handleFinalizerRemoval = async (kubernetesObject: KubernetesObject): Promise<void> => {
     if (!kubernetesObject.metadata?.deletionTimestamp) {
       return;
     }
@@ -191,7 +195,7 @@ async function runBinding(binding: Binding, capabilityNamespaces: string[], igno
   }
 }
 
-export function logEvent(event: WatchEvent, message: string = "", obj?: KubernetesObject) {
+export function logEvent(event: WatchEvent, message: string = "", obj?: KubernetesObject): void {
   const logMessage = `Watch event ${event} received${message ? `. ${message}.` : "."}`;
   if (obj) {
     Log.debug(obj, logMessage);

package/src/lib.ts

@@ -2,7 +2,7 @@ import { K8s, RegisterKind, kind as a, fetch, fetchStatus, kind } from "kubernet
 import * as R from "ramda";
 
 import { Capability } from "./lib/capability";
-import Log from "./lib/logger";
+import Log from "./lib/telemetry/logger";
 import { PeprModule } from "./lib/module";
 import { PeprMutateRequest } from "./lib/mutate-request";
 import * as PeprUtils from "./lib/utils";

package/src/runtime/controller.ts

@@ -8,7 +8,7 @@ import crypto from "crypto";
 import fs from "fs";
 import { gunzipSync } from "zlib";
 import { K8s, kind } from "kubernetes-fluent-client";
-import Log from "../lib/logger";
+import Log from "../lib/telemetry/logger";
 import { packageJSON } from "../templates/data.json";
 import { peprStoreCRD } from "../lib/assets/store";
 import { validateHash } from "../lib/helpers";