@oneuptime/common 10.0.35 → 10.0.36

package/Types/Monitor/KubernetesAlertTemplates.ts

@@ -0,0 +1,703 @@
+import ObjectID from "../ObjectID";
+import MonitorStep from "./MonitorStep";
+import MonitorCriteria from "./MonitorCriteria";
+import MonitorCriteriaInstance from "./MonitorCriteriaInstance";
+import FilterCondition from "../Filter/FilterCondition";
+import { CheckOn, FilterType, EvaluateOverTimeType } from "./CriteriaFilter";
+import MonitorStepKubernetesMonitor, {
+  KubernetesResourceScope,
+} from "./MonitorStepKubernetesMonitor";
+import RollingTime from "../RollingTime/RollingTime";
+import MetricsAggregationType from "../Metrics/MetricsAggregationType";
+
+export type KubernetesAlertTemplateCategory =
+  | "Workload"
+  | "Node"
+  | "ControlPlane"
+  | "Storage"
+  | "Scheduling";
+
+export type KubernetesAlertTemplateSeverity = "Critical" | "Warning";
+
+export interface KubernetesAlertTemplateArgs {
+  clusterIdentifier: string;
+  onlineMonitorStatusId: ObjectID;
+  offlineMonitorStatusId: ObjectID;
+  defaultIncidentSeverityId: ObjectID;
+  defaultAlertSeverityId: ObjectID;
+  monitorName: string;
+}
+
+export interface KubernetesAlertTemplate {
+  id: string;
+  name: string;
+  description: string;
+  category: KubernetesAlertTemplateCategory;
+  severity: KubernetesAlertTemplateSeverity;
+  getMonitorStep: (args: KubernetesAlertTemplateArgs) => MonitorStep;
+}
+
+export function buildKubernetesMonitorStep(args: {
+  kubernetesMonitor: MonitorStepKubernetesMonitor;
+  offlineCriteriaInstance: MonitorCriteriaInstance;
+  onlineCriteriaInstance: MonitorCriteriaInstance;
+}): MonitorStep {
+  const monitorStep: MonitorStep = new MonitorStep();
+
+  const monitorCriteria: MonitorCriteria = new MonitorCriteria();
+
+  monitorCriteria.data = {
+    monitorCriteriaInstanceArray: [
+      args.offlineCriteriaInstance,
+      args.onlineCriteriaInstance,
+    ],
+  };
+
+  monitorStep.data = {
+    id: ObjectID.generate().toString(),
+    monitorDestination: undefined,
+    doNotFollowRedirects: undefined,
+    monitorDestinationPort: undefined,
+    monitorCriteria: monitorCriteria,
+    requestType: "GET" as any,
+    requestHeaders: undefined,
+    requestBody: undefined,
+    customCode: undefined,
+    screenSizeTypes: undefined,
+    browserTypes: undefined,
+    retryCountOnError: undefined,
+    logMonitor: undefined,
+    traceMonitor: undefined,
+    metricMonitor: undefined,
+    exceptionMonitor: undefined,
+    snmpMonitor: undefined,
+    dnsMonitor: undefined,
+    domainMonitor: undefined,
+    externalStatusPageMonitor: undefined,
+    kubernetesMonitor: args.kubernetesMonitor,
+  };
+
+  return monitorStep;
+}
+
+export function buildOfflineCriteriaInstance(args: {
+  offlineMonitorStatusId: ObjectID;
+  incidentSeverityId: ObjectID;
+  alertSeverityId: ObjectID;
+  monitorName: string;
+  metricAlias: string;
+  filterType: FilterType;
+  value: number;
+}): MonitorCriteriaInstance {
+  const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+
+  instance.data = {
+    id: ObjectID.generate().toString(),
+    monitorStatusId: args.offlineMonitorStatusId,
+    filterCondition: FilterCondition.Any,
+    filters: [
+      {
+        checkOn: CheckOn.MetricValue,
+        filterType: args.filterType,
+        metricMonitorOptions: {
+          metricAggregationType: EvaluateOverTimeType.AnyValue,
+          metricAlias: args.metricAlias,
+        },
+        value: args.value,
+      },
+    ],
+    incidents: [
+      {
+        title: `${args.monitorName} - Alert Triggered`,
+        description: `${args.monitorName} has triggered an alert condition.`,
+        incidentSeverityId: args.incidentSeverityId,
+        autoResolveIncident: true,
+        id: ObjectID.generate().toString(),
+        onCallPolicyIds: [],
+      },
+    ],
+    alerts: [
+      {
+        title: `${args.monitorName} - Alert`,
+        description: `${args.monitorName} has triggered an alert condition.`,
+        alertSeverityId: args.alertSeverityId,
+        autoResolveAlert: true,
+        id: ObjectID.generate().toString(),
+        onCallPolicyIds: [],
+      },
+    ],
+    changeMonitorStatus: true,
+    createIncidents: true,
+    createAlerts: true,
+    name: `${args.monitorName} - Unhealthy`,
+    description: `Criteria for detecting unhealthy state.`,
+  };
+
+  return instance;
+}
+
+export function buildOnlineCriteriaInstance(args: {
+  onlineMonitorStatusId: ObjectID;
+  metricAlias: string;
+  filterType: FilterType;
+  value: number;
+}): MonitorCriteriaInstance {
+  const instance: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+
+  instance.data = {
+    id: ObjectID.generate().toString(),
+    monitorStatusId: args.onlineMonitorStatusId,
+    filterCondition: FilterCondition.Any,
+    filters: [
+      {
+        checkOn: CheckOn.MetricValue,
+        filterType: args.filterType,
+        metricMonitorOptions: {
+          metricAggregationType: EvaluateOverTimeType.AnyValue,
+          metricAlias: args.metricAlias,
+        },
+        value: args.value,
+      },
+    ],
+    incidents: [],
+    alerts: [],
+    changeMonitorStatus: true,
+    createIncidents: false,
+    createAlerts: false,
+    name: "Healthy",
+    description: "Criteria for healthy state.",
+  };
+
+  return instance;
+}
+
+export function buildKubernetesMonitorConfig(args: {
+  clusterIdentifier: string;
+  metricName: string;
+  metricAlias: string;
+  resourceScope: KubernetesResourceScope;
+  rollingTime: RollingTime;
+  aggregationType: MetricsAggregationType;
+  attributes?: Record<string, string>;
+}): MonitorStepKubernetesMonitor {
+  return {
+    clusterIdentifier: args.clusterIdentifier,
+    resourceScope: args.resourceScope,
+    resourceFilters: {},
+    metricViewConfig: {
+      queryConfigs: [
+        {
+          metricAliasData: {
+            metricVariable: args.metricAlias,
+            title: args.metricAlias,
+            description: args.metricAlias,
+            legend: args.metricAlias,
+            legendUnit: undefined,
+          },
+          metricQueryData: {
+            filterData: {
+              metricName: args.metricName,
+              attributes: args.attributes || {},
+              aggegationType: args.aggregationType,
+              aggregateBy: {},
+            },
+          },
+        },
+      ],
+      formulaConfigs: [],
+    },
+    rollingTime: args.rollingTime,
+  };
+}
+
+// --- Template Definitions ---
+
+const crashLoopBackOffTemplate: KubernetesAlertTemplate = {
+  id: "k8s-crashloopbackoff",
+  name: "CrashLoopBackOff Detection",
+  description:
+    "Alert when container restart count exceeds threshold, indicating a CrashLoopBackOff condition.",
+  category: "Workload",
+  severity: "Critical",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "container_restarts";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.container.restarts",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Cluster,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Max,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 5,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 5,
+      }),
+    });
+  },
+};
+
+const podPendingTemplate: KubernetesAlertTemplate = {
+  id: "k8s-pod-pending",
+  name: "Pod Stuck in Pending",
+  description:
+    "Alert when pods remain in Pending phase, indicating scheduling or resource issues.",
+  category: "Scheduling",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "pending_pods";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.pod.phase",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Cluster,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Sum,
+        attributes: { "k8s.pod.phase": "Pending" },
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const nodeNotReadyTemplate: KubernetesAlertTemplate = {
+  id: "k8s-node-not-ready",
+  name: "Node Not Ready",
+  description:
+    "Alert when a node condition transitions to NotReady, indicating node health issues.",
+  category: "Node",
+  severity: "Critical",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "node_ready";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.node.condition_ready",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Node,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Min,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const highCpuTemplate: KubernetesAlertTemplate = {
+  id: "k8s-high-cpu",
+  name: "High Node CPU Utilization",
+  description: "Alert when node CPU utilization exceeds 90% sustained.",
+  category: "Node",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "node_cpu";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.node.cpu.utilization",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Node,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Avg,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 90,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 90,
+      }),
+    });
+  },
+};
+
+const highMemoryTemplate: KubernetesAlertTemplate = {
+  id: "k8s-high-memory",
+  name: "High Node Memory Utilization",
+  description: "Alert when node memory utilization exceeds 85% sustained.",
+  category: "Node",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "node_memory";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.node.memory.usage",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Node,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Avg,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 85,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 85,
+      }),
+    });
+  },
+};
+
+const deploymentReplicaMismatchTemplate: KubernetesAlertTemplate = {
+  id: "k8s-deployment-replica-mismatch",
+  name: "Deployment Replica Mismatch",
+  description:
+    "Alert when available replicas are less than desired replicas for a deployment.",
+  category: "Workload",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "unavailable_replicas";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.deployment.unavailable_replicas",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Workload,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Max,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const jobFailuresTemplate: KubernetesAlertTemplate = {
+  id: "k8s-job-failures",
+  name: "Job Failures",
+  description: "Alert when Kubernetes jobs fail.",
+  category: "Workload",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "failed_pods";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.job.failed_pods",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Workload,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Max,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const etcdNoLeaderTemplate: KubernetesAlertTemplate = {
+  id: "k8s-etcd-no-leader",
+  name: "etcd No Leader",
+  description:
+    "Alert immediately when etcd has no leader elected. This is a critical cluster health issue.",
+  category: "ControlPlane",
+  severity: "Critical",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "etcd_has_leader";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "etcd_server_has_leader",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Cluster,
+        rollingTime: RollingTime.Past1Minute,
+        aggregationType: MetricsAggregationType.Min,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const apiServerThrottlingTemplate: KubernetesAlertTemplate = {
+  id: "k8s-apiserver-throttling",
+  name: "API Server Throttling",
+  description:
+    "Alert when the Kubernetes API server is dropping requests due to throttling.",
+  category: "ControlPlane",
+  severity: "Critical",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "dropped_requests";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "apiserver_dropped_requests_total",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Cluster,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Sum,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const schedulerBacklogTemplate: KubernetesAlertTemplate = {
+  id: "k8s-scheduler-backlog",
+  name: "Scheduler Backlog",
+  description:
+    "Alert when there are pods waiting to be scheduled for more than 5 minutes.",
+  category: "Scheduling",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "pending_pods";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "scheduler_pending_pods",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Cluster,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Avg,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    });
+  },
+};
+
+const highDiskUsageTemplate: KubernetesAlertTemplate = {
+  id: "k8s-high-disk-usage",
+  name: "High Node Disk Usage",
+  description: "Alert when node filesystem usage exceeds 90% capacity.",
+  category: "Storage",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "disk_usage";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.node.filesystem.usage",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Node,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Avg,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 90,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.LessThanOrEqualTo,
+        value: 90,
+      }),
+    });
+  },
+};
+
+const daemonSetUnavailableTemplate: KubernetesAlertTemplate = {
+  id: "k8s-daemonset-unavailable",
+  name: "DaemonSet Unavailable Nodes",
+  description:
+    "Alert when a DaemonSet has unavailable nodes where the daemon pod should be running.",
+  category: "Workload",
+  severity: "Warning",
+  getMonitorStep: (args: KubernetesAlertTemplateArgs): MonitorStep => {
+    const metricAlias: string = "unavailable_nodes";
+
+    return buildKubernetesMonitorStep({
+      kubernetesMonitor: buildKubernetesMonitorConfig({
+        clusterIdentifier: args.clusterIdentifier,
+        metricName: "k8s.daemonset.misscheduled_nodes",
+        metricAlias,
+        resourceScope: KubernetesResourceScope.Workload,
+        rollingTime: RollingTime.Past5Minutes,
+        aggregationType: MetricsAggregationType.Max,
+      }),
+      offlineCriteriaInstance: buildOfflineCriteriaInstance({
+        offlineMonitorStatusId: args.offlineMonitorStatusId,
+        incidentSeverityId: args.defaultIncidentSeverityId,
+        alertSeverityId: args.defaultAlertSeverityId,
+        monitorName: args.monitorName,
+        metricAlias,
+        filterType: FilterType.GreaterThan,
+        value: 0,
+      }),
+      onlineCriteriaInstance: buildOnlineCriteriaInstance({
+        onlineMonitorStatusId: args.onlineMonitorStatusId,
+        metricAlias,
+        filterType: FilterType.EqualTo,
+        value: 0,
+      }),
+    });
+  },
+};
+
+export function getAllKubernetesAlertTemplates(): Array<KubernetesAlertTemplate> {
+  return [
+    crashLoopBackOffTemplate,
+    podPendingTemplate,
+    nodeNotReadyTemplate,
+    highCpuTemplate,
+    highMemoryTemplate,
+    deploymentReplicaMismatchTemplate,
+    jobFailuresTemplate,
+    etcdNoLeaderTemplate,
+    apiServerThrottlingTemplate,
+    schedulerBacklogTemplate,
+    highDiskUsageTemplate,
+    daemonSetUnavailableTemplate,
+  ];
+}
+
+export function getKubernetesAlertTemplatesByCategory(
+  category: KubernetesAlertTemplateCategory,
+): Array<KubernetesAlertTemplate> {
+  return getAllKubernetesAlertTemplates().filter(
+    (template: KubernetesAlertTemplate) => {
+      return template.category === category;
+    },
+  );
+}
+
+export function getKubernetesAlertTemplateById(
+  id: string,
+): KubernetesAlertTemplate | undefined {
+  return getAllKubernetesAlertTemplates().find(
+    (template: KubernetesAlertTemplate) => {
+      return template.id === id;
+    },
+  );
+}