@oneuptime/common 10.0.35 → 10.0.37

package/Types/Monitor/KubernetesMetricCatalog.ts

@@ -0,0 +1,347 @@
+import { KubernetesResourceScope } from "./MonitorStepKubernetesMonitor";
+import MetricsAggregationType from "../Metrics/MetricsAggregationType";
+
+export type KubernetesMetricCategory =
+  | "Pod"
+  | "Node"
+  | "Container"
+  | "Workload"
+  | "HPA";
+
+export interface KubernetesMetricDefinition {
+  id: string;
+  friendlyName: string;
+  description: string;
+  metricName: string;
+  category: KubernetesMetricCategory;
+  defaultAggregation: MetricsAggregationType;
+  defaultResourceScope: KubernetesResourceScope;
+  unit?: string;
+}
+
+const kubernetesMetricCatalog: Array<KubernetesMetricDefinition> = [
+  // Pod Metrics
+  {
+    id: "pod-cpu-utilization",
+    friendlyName: "Pod CPU Utilization",
+    description: "CPU usage percentage for pods",
+    metricName: "k8s.pod.cpu.utilization",
+    category: "Pod",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "%",
+  },
+  {
+    id: "pod-memory-usage",
+    friendlyName: "Pod Memory Usage",
+    description: "Memory usage in bytes for pods",
+    metricName: "k8s.pod.memory.usage",
+    category: "Pod",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "bytes",
+  },
+  {
+    id: "pod-phase",
+    friendlyName: "Pod Phase",
+    description:
+      "Current phase of the pod (Pending, Running, Succeeded, Failed, Unknown)",
+    metricName: "k8s.pod.phase",
+    category: "Pod",
+    defaultAggregation: MetricsAggregationType.Sum,
+    defaultResourceScope: KubernetesResourceScope.Cluster,
+    unit: "count",
+  },
+  {
+    id: "pod-filesystem-usage",
+    friendlyName: "Pod Filesystem Usage",
+    description: "Filesystem usage in bytes for pods",
+    metricName: "k8s.pod.filesystem.usage",
+    category: "Pod",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "bytes",
+  },
+  {
+    id: "pod-network-io-receive",
+    friendlyName: "Pod Network Receive",
+    description: "Network bytes received by pods",
+    metricName: "k8s.pod.network.io",
+    category: "Pod",
+    defaultAggregation: MetricsAggregationType.Sum,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "bytes",
+  },
+
+  // Node Metrics
+  {
+    id: "node-cpu-utilization",
+    friendlyName: "Node CPU Utilization",
+    description: "CPU usage percentage for nodes",
+    metricName: "k8s.node.cpu.utilization",
+    category: "Node",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Node,
+    unit: "%",
+  },
+  {
+    id: "node-memory-usage",
+    friendlyName: "Node Memory Usage",
+    description: "Memory usage in bytes for nodes",
+    metricName: "k8s.node.memory.usage",
+    category: "Node",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Node,
+    unit: "bytes",
+  },
+  {
+    id: "node-filesystem-usage",
+    friendlyName: "Node Filesystem Usage",
+    description: "Filesystem usage in bytes for nodes",
+    metricName: "k8s.node.filesystem.usage",
+    category: "Node",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Node,
+    unit: "bytes",
+  },
+  {
+    id: "node-condition-ready",
+    friendlyName: "Node Ready Condition",
+    description:
+      "Whether the node is in Ready condition (1 = ready, 0 = not ready)",
+    metricName: "k8s.node.condition_ready",
+    category: "Node",
+    defaultAggregation: MetricsAggregationType.Min,
+    defaultResourceScope: KubernetesResourceScope.Node,
+    unit: "count",
+  },
+  {
+    id: "node-disk-io",
+    friendlyName: "Node Disk I/O",
+    description: "Disk I/O operations on nodes",
+    metricName: "k8s.node.filesystem.available",
+    category: "Node",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Node,
+    unit: "bytes",
+  },
+
+  // Container Metrics
+  {
+    id: "container-restarts",
+    friendlyName: "Container Restarts",
+    description: "Number of times a container has restarted",
+    metricName: "k8s.container.restarts",
+    category: "Container",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Cluster,
+    unit: "count",
+  },
+  {
+    id: "container-cpu-limit",
+    friendlyName: "Container CPU Limit",
+    description: "CPU limit set for containers",
+    metricName: "k8s.container.cpu_limit",
+    category: "Container",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "cores",
+  },
+  {
+    id: "container-cpu-request",
+    friendlyName: "Container CPU Request",
+    description: "CPU request set for containers",
+    metricName: "k8s.container.cpu_request",
+    category: "Container",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "cores",
+  },
+  {
+    id: "container-memory-limit",
+    friendlyName: "Container Memory Limit",
+    description: "Memory limit set for containers",
+    metricName: "k8s.container.memory_limit",
+    category: "Container",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "bytes",
+  },
+  {
+    id: "container-memory-request",
+    friendlyName: "Container Memory Request",
+    description: "Memory request set for containers",
+    metricName: "k8s.container.memory_request",
+    category: "Container",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "bytes",
+  },
+  {
+    id: "container-ready",
+    friendlyName: "Container Ready",
+    description: "Whether the container is in Ready state",
+    metricName: "k8s.container.ready",
+    category: "Container",
+    defaultAggregation: MetricsAggregationType.Min,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "count",
+  },
+
+  // Workload Metrics
+  {
+    id: "deployment-available-replicas",
+    friendlyName: "Deployment Available Replicas",
+    description: "Number of available replicas in a deployment",
+    metricName: "k8s.deployment.available_replicas",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Min,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "deployment-desired-replicas",
+    friendlyName: "Deployment Desired Replicas",
+    description: "Number of desired replicas in a deployment",
+    metricName: "k8s.deployment.desired_replicas",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "deployment-unavailable-replicas",
+    friendlyName: "Deployment Unavailable Replicas",
+    description: "Number of unavailable replicas in a deployment",
+    metricName: "k8s.deployment.unavailable_replicas",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "daemonset-misscheduled-nodes",
+    friendlyName: "DaemonSet Misscheduled Nodes",
+    description:
+      "Number of nodes running a daemon pod that should not be running one",
+    metricName: "k8s.daemonset.misscheduled_nodes",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "daemonset-ready-nodes",
+    friendlyName: "DaemonSet Ready Nodes",
+    description: "Number of nodes with a ready daemon pod",
+    metricName: "k8s.daemonset.ready_nodes",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Min,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "statefulset-ready-replicas",
+    friendlyName: "StatefulSet Ready Replicas",
+    description: "Number of ready replicas in a StatefulSet",
+    metricName: "k8s.statefulset.ready_replicas",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Min,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "job-failed-pods",
+    friendlyName: "Job Failed Pods",
+    description: "Number of failed pods in a Job",
+    metricName: "k8s.job.failed_pods",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "job-successful-pods",
+    friendlyName: "Job Successful Pods",
+    description: "Number of successful pods in a Job",
+    metricName: "k8s.job.successful_pods",
+    category: "Workload",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+
+  // HPA Metrics
+  {
+    id: "hpa-current-replicas",
+    friendlyName: "HPA Current Replicas",
+    description: "Current number of replicas managed by the HPA",
+    metricName: "k8s.hpa.current_replicas",
+    category: "HPA",
+    defaultAggregation: MetricsAggregationType.Avg,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "hpa-desired-replicas",
+    friendlyName: "HPA Desired Replicas",
+    description: "Desired number of replicas as determined by the HPA",
+    metricName: "k8s.hpa.desired_replicas",
+    category: "HPA",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "hpa-max-replicas",
+    friendlyName: "HPA Max Replicas",
+    description: "Maximum number of replicas the HPA can scale to",
+    metricName: "k8s.hpa.max_replicas",
+    category: "HPA",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+  {
+    id: "hpa-min-replicas",
+    friendlyName: "HPA Min Replicas",
+    description: "Minimum number of replicas the HPA maintains",
+    metricName: "k8s.hpa.min_replicas",
+    category: "HPA",
+    defaultAggregation: MetricsAggregationType.Min,
+    defaultResourceScope: KubernetesResourceScope.Workload,
+    unit: "count",
+  },
+];
+
+export function getAllKubernetesMetrics(): Array<KubernetesMetricDefinition> {
+  return kubernetesMetricCatalog;
+}
+
+export function getKubernetesMetricsByCategory(
+  category: KubernetesMetricCategory,
+): Array<KubernetesMetricDefinition> {
+  return kubernetesMetricCatalog.filter((m: KubernetesMetricDefinition) => {
+    return m.category === category;
+  });
+}
+
+export function getKubernetesMetricById(
+  id: string,
+): KubernetesMetricDefinition | undefined {
+  return kubernetesMetricCatalog.find((m: KubernetesMetricDefinition) => {
+    return m.id === id;
+  });
+}
+
+export function getKubernetesMetricByMetricName(
+  metricName: string,
+): KubernetesMetricDefinition | undefined {
+  return kubernetesMetricCatalog.find((m: KubernetesMetricDefinition) => {
+    return m.metricName === metricName;
+  });
+}
+
+export function getAllKubernetesMetricCategories(): Array<KubernetesMetricCategory> {
+  return ["Pod", "Node", "Container", "Workload", "HPA"];
+}

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -212,6 +212,43 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       return monitorCriteriaInstance;
     }
 
+    if (arg.monitorType === MonitorType.Kubernetes) {
+      const monitorCriteriaInstance: MonitorCriteriaInstance =
+        new MonitorCriteriaInstance();
+
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.MetricValue,
+            filterType: FilterType.GreaterThan,
+
+            metricMonitorOptions: {
+              metricAggregationType: EvaluateOverTimeType.AnyValue,
+              metricAlias:
+                arg.metricOptions &&
+                arg.metricOptions.metricAliases &&
+                arg.metricOptions.metricAliases.length > 0
+                  ? arg.metricOptions.metricAliases[0]
+                  : undefined,
+            },
+            value: 0,
+          },
+        ],
+        incidents: [],
+        alerts: [],
+        changeMonitorStatus: true,
+        createIncidents: false,
+        createAlerts: false,
+        name: `Check if ${arg.monitorName} is online`,
+        description: `This criteria checks if the ${arg.monitorName} is online`,
+      };
+
+      return monitorCriteriaInstance;
+    }
+
     if (arg.monitorType === MonitorType.Traces) {
       const monitorCriteriaInstance: MonitorCriteriaInstance =
         new MonitorCriteriaInstance();
@@ -873,6 +910,55 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       };
     }
 
+    if (arg.monitorType === MonitorType.Kubernetes) {
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.MetricValue,
+            filterType: FilterType.EqualTo,
+            metricMonitorOptions: {
+              metricAggregationType: EvaluateOverTimeType.AnyValue,
+              metricAlias:
+                arg.metricOptions &&
+                arg.metricOptions.metricAliases &&
+                arg.metricOptions.metricAliases.length > 0
+                  ? arg.metricOptions.metricAliases[0]
+                  : undefined,
+            },
+            value: 0,
+          },
+        ],
+        incidents: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} is currently offline.`,
+            incidentSeverityId: arg.incidentSeverityId,
+            autoResolveIncident: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        alerts: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} is currently offline.`,
+            alertSeverityId: arg.alertSeverityId,
+            autoResolveAlert: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        createAlerts: false,
+        changeMonitorStatus: true,
+        createIncidents: true,
+        name: `Check if ${arg.monitorName} is offline`,
+        description: `This criteria checks if the ${arg.monitorName} is offline`,
+      };
+    }
+
     if (arg.monitorType === MonitorType.Traces) {
       monitorCriteriaInstance.data = {
         id: ObjectID.generate().toString(),

package/Types/Monitor/MonitorStep.ts

@@ -38,6 +38,9 @@ import MonitorStepDomainMonitor, {
 import MonitorStepExternalStatusPageMonitor, {
   MonitorStepExternalStatusPageMonitorUtil,
 } from "./MonitorStepExternalStatusPageMonitor";
+import MonitorStepKubernetesMonitor, {
+  MonitorStepKubernetesMonitorUtil,
+} from "./MonitorStepKubernetesMonitor";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface MonitorStepType {
@@ -90,6 +93,9 @@ export interface MonitorStepType {
 
   // External Status Page monitor
   externalStatusPageMonitor?: MonitorStepExternalStatusPageMonitor | undefined;
+
+  // Kubernetes monitor
+  kubernetesMonitor?: MonitorStepKubernetesMonitor | undefined;
 }
 
 export default class MonitorStep extends DatabaseProperty {
@@ -119,6 +125,7 @@ export default class MonitorStep extends DatabaseProperty {
       dnsMonitor: undefined,
       domainMonitor: undefined,
       externalStatusPageMonitor: undefined,
+      kubernetesMonitor: undefined,
     };
   }
 
@@ -153,6 +160,7 @@ export default class MonitorStep extends DatabaseProperty {
       dnsMonitor: undefined,
       domainMonitor: undefined,
       externalStatusPageMonitor: undefined,
+      kubernetesMonitor: undefined,
     };
 
     return monitorStep;
@@ -267,6 +275,13 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setKubernetesMonitor(
+    kubernetesMonitor: MonitorStepKubernetesMonitor,
+  ): MonitorStep {
+    this.data!.kubernetesMonitor = kubernetesMonitor;
+    return this;
+  }
+
   public setCustomCode(customCode: string): MonitorStep {
     this.data!.customCode = customCode;
     return this;
@@ -293,8 +308,9 @@ export default class MonitorStep extends DatabaseProperty {
         screenSizeTypes: undefined,
         browserTypes: undefined,
         retryCountOnError: undefined,
-        lgoMonitor: undefined,
+        logMonitor: undefined,
         exceptionMonitor: undefined,
+        kubernetesMonitor: undefined,
       },
     };
   }
@@ -405,6 +421,16 @@ export default class MonitorStep extends DatabaseProperty {
       }
     }
 
+    if (monitorType === MonitorType.Kubernetes) {
+      if (!value.data.kubernetesMonitor) {
+        return "Kubernetes monitor configuration is required";
+      }
+
+      if (!value.data.kubernetesMonitor.clusterIdentifier) {
+        return "Kubernetes cluster is required";
+      }
+    }
+
     return null;
   }
 
@@ -461,6 +487,11 @@ export default class MonitorStep extends DatabaseProperty {
                 this.data.externalStatusPageMonitor,
               )
             : undefined,
+          kubernetesMonitor: this.data.kubernetesMonitor
+            ? MonitorStepKubernetesMonitorUtil.toJSON(
+                this.data.kubernetesMonitor,
+              )
+            : undefined,
         },
       });
     }
@@ -575,6 +606,9 @@ export default class MonitorStep extends DatabaseProperty {
       externalStatusPageMonitor: json["externalStatusPageMonitor"]
         ? (json["externalStatusPageMonitor"] as JSONObject)
         : undefined,
+      kubernetesMonitor: json["kubernetesMonitor"]
+        ? (json["kubernetesMonitor"] as JSONObject)
+        : undefined,
     }) as any;
 
     return monitorStep;
@@ -603,6 +637,7 @@ export default class MonitorStep extends DatabaseProperty {
         dnsMonitor: Zod.any().optional(),
         domainMonitor: Zod.any().optional(),
         externalStatusPageMonitor: Zod.any().optional(),
+        kubernetesMonitor: Zod.any().optional(),
       }).openapi({
         type: "object",
         example: {

package/Types/Monitor/MonitorStepKubernetesMonitor.ts

@@ -0,0 +1,50 @@
+import { JSONObject } from "../JSON";
+import MetricsViewConfig from "../Metrics/MetricsViewConfig";
+import RollingTime from "../RollingTime/RollingTime";
+
+export enum KubernetesResourceScope {
+  Cluster = "Cluster",
+  Namespace = "Namespace",
+  Workload = "Workload",
+  Node = "Node",
+  Pod = "Pod",
+}
+
+export interface KubernetesResourceFilters {
+  namespace?: string | undefined;
+  workloadType?: string | undefined; // deployment, statefulset, daemonset, job, cronjob
+  workloadName?: string | undefined;
+  nodeName?: string | undefined;
+  podName?: string | undefined;
+}
+
+export default interface MonitorStepKubernetesMonitor {
+  clusterIdentifier: string;
+  resourceScope: KubernetesResourceScope;
+  resourceFilters: KubernetesResourceFilters;
+  metricViewConfig: MetricsViewConfig;
+  rollingTime: RollingTime;
+}
+
+export class MonitorStepKubernetesMonitorUtil {
+  public static getDefault(): MonitorStepKubernetesMonitor {
+    return {
+      clusterIdentifier: "",
+      resourceScope: KubernetesResourceScope.Cluster,
+      resourceFilters: {},
+      metricViewConfig: {
+        queryConfigs: [],
+        formulaConfigs: [],
+      },
+      rollingTime: RollingTime.Past1Minute,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepKubernetesMonitor {
+    return json as any as MonitorStepKubernetesMonitor;
+  }
+
+  public static toJSON(monitor: MonitorStepKubernetesMonitor): JSONObject {
+    return monitor as any as JSONObject;
+  }
+}

package/Types/Monitor/MonitorType.ts

@@ -83,6 +83,10 @@ export class MonitorTypeHelper {
         label: "Infrastructure",
         monitorTypes: [MonitorType.Server, MonitorType.SNMP],
       },
+      {
+        label: "Kubernetes",
+        monitorTypes: [MonitorType.Kubernetes],
+      },
       {
         label: "Telemetry",
         monitorTypes: [
@@ -104,7 +108,8 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.Logs ||
       monitorType === MonitorType.Metrics ||
       monitorType === MonitorType.Traces ||
-      monitorType === MonitorType.Exceptions
+      monitorType === MonitorType.Exceptions ||
+      monitorType === MonitorType.Kubernetes
     );
   }
 
@@ -142,15 +147,13 @@ export class MonitorTypeHelper {
           "This monitor type does the basic ping test of an endpoint.",
         icon: IconProp.Signal,
       },
-      /*
-       * {
-       *     monitorType: MonitorType.Kubernetes,
-       *     title: 'Kubernetes',
-       *     description:
-       *         'This monitor types lets you monitor Kubernetes clusters.',
-       *     icon: IconProp.Cube,
-       * },
-       */
+      {
+        monitorType: MonitorType.Kubernetes,
+        title: "Kubernetes",
+        description:
+          "This monitor type lets you monitor Kubernetes clusters, workloads, nodes, and pods.",
+        icon: IconProp.Cube,
+      },
       {
         monitorType: MonitorType.IP,
         title: "IP",
@@ -334,6 +337,7 @@ export class MonitorTypeHelper {
       MonitorType.DNS,
       MonitorType.Domain,
       MonitorType.ExternalStatusPage,
+      MonitorType.Kubernetes,
     ];
   }