@oneuptime/common 12.0.32 → 12.0.34

package/Types/Monitor/KubernetesMetricCatalog.ts

@@ -23,13 +23,14 @@ const kubernetesMetricCatalog: Array<KubernetesMetricDefinition> = [
   // Pod Metrics
   {
     id: "pod-cpu-utilization",
-    friendlyName: "Pod CPU Utilization",
-    description: "CPU usage percentage for pods",
+    friendlyName: "Pod CPU Usage",
+    description:
+      "CPU cores in use by the pod. kubeletstats reports this as a cores gauge despite the .utilization name - 0.18 means 0.18 of a core, not 18%. For a percentage, divide by the container CPU limit (k8s.container.cpu_limit) or the node allocatable CPU (k8s.node.allocatable_cpu).",
     metricName: "k8s.pod.cpu.utilization",
     category: "Pod",
     defaultAggregation: MetricsAggregationType.Avg,
     defaultResourceScope: KubernetesResourceScope.Pod,
-    unit: "%",
+    unit: "cores",
   },
   {
     id: "pod-memory-usage",
@@ -43,14 +44,14 @@ const kubernetesMetricCatalog: Array<KubernetesMetricDefinition> = [
   },
   {
     id: "pod-phase",
-    friendlyName: "Pod Phase",
+    friendlyName: "Pod Phase (Code)",
     description:
-      "Current phase of the pod (Pending, Running, Succeeded, Failed, Unknown)",
+      "The pod's phase as a numeric code (1 = Pending, 2 = Running, 3 = Succeeded, 4 = Failed, 5 = Unknown). This is a categorical value, not a quantity, so it must never be summed: the gauge re-emits on every scrape and a Sum totals (pods x scrapes). Use Max to catch the worst phase seen, or Min with 'equal to 1' to catch a stuck Pending pod. For a cluster-wide count of pods in a phase, filter by phase and count series instead.",
     metricName: "k8s.pod.phase",
     category: "Pod",
-    defaultAggregation: MetricsAggregationType.Sum,
-    defaultResourceScope: KubernetesResourceScope.Cluster,
-    unit: "count",
+    defaultAggregation: MetricsAggregationType.Max,
+    defaultResourceScope: KubernetesResourceScope.Pod,
+    unit: "",
   },
   {
     id: "pod-filesystem-usage",
@@ -63,12 +64,13 @@ const kubernetesMetricCatalog: Array<KubernetesMetricDefinition> = [
     unit: "bytes",
   },
   {
-    id: "pod-network-io-receive",
-    friendlyName: "Pod Network Receive",
-    description: "Network bytes received by pods",
+    id: "pod-network-io",
+    friendlyName: "Pod Network I/O (Cumulative, Both Directions)",
+    description:
+      "Cumulative network bytes for pods. kubeletstats emits one series per (pod, interface, direction) with a `direction` datapoint attribute of receive|transmit, and this entry filters none of them - the value covers BOTH directions. It is a monotonically increasing counter, not a rate, so it is a poor alerting target; for throughput, chart it on the cluster page, which deltas it client-side.",
     metricName: "k8s.pod.network.io",
     category: "Pod",
-    defaultAggregation: MetricsAggregationType.Sum,
+    defaultAggregation: MetricsAggregationType.Max,
     defaultResourceScope: KubernetesResourceScope.Pod,
     unit: "bytes",
   },
@@ -76,13 +78,14 @@ const kubernetesMetricCatalog: Array<KubernetesMetricDefinition> = [
   // Node Metrics
   {
     id: "node-cpu-utilization",
-    friendlyName: "Node CPU Utilization",
-    description: "CPU usage percentage for nodes",
+    friendlyName: "Node CPU Usage",
+    description:
+      "CPU cores in use by the node. kubeletstats reports this as a cores gauge despite the .utilization name - 1.4 means 1.4 cores, not 1.4%. For a percentage, divide by the node allocatable CPU (k8s.node.allocatable_cpu).",
     metricName: "k8s.node.cpu.utilization",
     category: "Node",
     defaultAggregation: MetricsAggregationType.Avg,
     defaultResourceScope: KubernetesResourceScope.Node,
-    unit: "%",
+    unit: "cores",
   },
   {
     id: "node-memory-usage",
@@ -116,12 +119,13 @@ const kubernetesMetricCatalog: Array<KubernetesMetricDefinition> = [
     unit: "count",
   },
   {
-    id: "node-disk-io",
-    friendlyName: "Node Disk I/O",
-    description: "Disk I/O operations on nodes",
+    id: "node-filesystem-available",
+    friendlyName: "Node Filesystem Available",
+    description:
+      "Free filesystem bytes remaining on the node. Falling is bad, so alert with a 'less than' threshold, not 'greater than'. For consumption instead, use Node Filesystem Usage.",
     metricName: "k8s.node.filesystem.available",
     category: "Node",
-    defaultAggregation: MetricsAggregationType.Avg,
+    defaultAggregation: MetricsAggregationType.Min,
     defaultResourceScope: KubernetesResourceScope.Node,
     unit: "bytes",
   },

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -568,6 +568,40 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       return monitorCriteriaInstance;
     }
 
+    if (arg.monitorType === MonitorType.Database) {
+      const monitorCriteriaInstance: MonitorCriteriaInstance =
+        new MonitorCriteriaInstance();
+
+      /*
+       * Online means one thing only: the probe connected and collected. It
+       * deliberately does NOT assert anything about the metrics. A database
+       * with a 97% cache hit ratio is not "down", and a monitor that treats
+       * every threshold as an outage teaches its operators to ignore it.
+       * Metric thresholds ship as templates the user opts into instead.
+       */
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.All,
+        filters: [
+          {
+            checkOn: CheckOn.DatabaseIsOnline,
+            filterType: FilterType.True,
+            value: undefined,
+          },
+        ],
+        incidents: [],
+        alerts: [],
+        createAlerts: false,
+        changeMonitorStatus: true,
+        createIncidents: false,
+        name: `Check if ${arg.monitorName} is online`,
+        description: `This criteria checks if ${arg.monitorName} is reachable and its health metrics were collected`,
+      };
+
+      return monitorCriteriaInstance;
+    }
+
     if (arg.monitorType === MonitorType.Domain) {
       const monitorCriteriaInstance: MonitorCriteriaInstance =
         new MonitorCriteriaInstance();
@@ -801,6 +835,48 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       };
     }
 
+    if (arg.monitorType === MonitorType.Database) {
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.DatabaseIsOnline,
+            filterType: FilterType.False,
+            value: undefined,
+          },
+        ],
+        incidents: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} is not reachable, or the health check could not connect.`,
+            incidentSeverityId: arg.incidentSeverityId,
+            autoResolveIncident: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        changeMonitorStatus: true,
+        createIncidents: true,
+        createAlerts: false,
+        alerts: [
+          {
+            title: `${arg.monitorName} is offline`,
+            description: `${arg.monitorName} is not reachable, or the health check could not connect.`,
+            alertSeverityId: arg.alertSeverityId,
+            autoResolveAlert: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        name: `Check if ${arg.monitorName} is offline`,
+        description: `This criteria checks if ${arg.monitorName} is offline`,
+      };
+
+      return monitorCriteriaInstance;
+    }
+
     if (arg.monitorType === MonitorType.SQLQuery) {
       monitorCriteriaInstance.data = {
         id: ObjectID.generate().toString(),

package/Types/Monitor/MonitorMetricType.ts

@@ -83,6 +83,77 @@ enum MonitorMetricType {
 
   HostUptimeSeconds = "oneuptime.monitor.host.uptime.seconds",
   ProcessCountTotal = "oneuptime.monitor.process.count.total",
+
+  /*
+   * Database Health monitor series. A probe connects to PostgreSQL / MySQL /
+   * Microsoft SQL Server on a schedule and runs built-in read-only catalog
+   * queries; each value below is one normalized series.
+   *
+   * Not every engine can produce every series - MySQL has no deadlock
+   * counter, SQL Server has no fixed connection ceiling by default, and
+   * PostgreSQL's I/O timings need track_io_timing on. The authoritative
+   * per-engine support matrix lives in DatabaseMetricCatalog.ts, which is
+   * also the single source of truth for each series' title, unit,
+   * aggregation and display category. Add a member here and an entry there
+   * together - a member without a catalog entry is invisible to the UI and
+   * fails the metric-invariant tests.
+   */
+  DatabaseUptimeSeconds = "oneuptime.monitor.database.uptime.seconds",
+
+  DatabaseConnectionsTotal = "oneuptime.monitor.database.connections.total",
+  DatabaseConnectionsActive = "oneuptime.monitor.database.connections.active",
+  DatabaseConnectionsMax = "oneuptime.monitor.database.connections.max",
+  DatabaseConnectionsUsedPercent = "oneuptime.monitor.database.connections.used.percent",
+  DatabaseConnectionsIdleInTransaction = "oneuptime.monitor.database.connections.idle.in.transaction",
+  DatabaseConnectionsAbortedTotal = "oneuptime.monitor.database.connections.aborted.total",
+
+  DatabaseLongestQuerySeconds = "oneuptime.monitor.database.query.longest.seconds",
+  DatabaseLongestTransactionSeconds = "oneuptime.monitor.database.transaction.longest.seconds",
+  DatabaseOpenTransactions = "oneuptime.monitor.database.transaction.open.count",
+
+  DatabaseSessionsBlocked = "oneuptime.monitor.database.sessions.blocked",
+  DatabaseLocksWaiting = "oneuptime.monitor.database.locks.waiting",
+  DatabaseDeadlocksTotal = "oneuptime.monitor.database.deadlocks.total",
+  DatabaseTableLocksWaitedTotal = "oneuptime.monitor.database.table.locks.waited.total",
+
+  DatabaseTransactionsTotal = "oneuptime.monitor.database.transactions.total",
+  DatabaseQueriesTotal = "oneuptime.monitor.database.queries.total",
+  DatabaseSlowQueriesTotal = "oneuptime.monitor.database.queries.slow.total",
+  DatabaseRollbackPercent = "oneuptime.monitor.database.rollback.percent",
+
+  DatabaseCacheHitPercent = "oneuptime.monitor.database.cache.hit.percent",
+  DatabaseDiskReadsTotal = "oneuptime.monitor.database.disk.reads.total",
+  DatabaseDiskWritesTotal = "oneuptime.monitor.database.disk.writes.total",
+  DatabaseIoReadTimeMs = "oneuptime.monitor.database.io.read.time.ms",
+  DatabaseIoWriteTimeMs = "oneuptime.monitor.database.io.write.time.ms",
+  DatabasePageLifeExpectancySeconds = "oneuptime.monitor.database.page.life.expectancy.seconds",
+  DatabaseMemoryGrantsPending = "oneuptime.monitor.database.memory.grants.pending",
+
+  DatabaseSizeBytes = "oneuptime.monitor.database.size.bytes",
+  DatabaseTempBytesTotal = "oneuptime.monitor.database.temp.bytes.total",
+  DatabaseTempDiskTablesTotal = "oneuptime.monitor.database.temp.disk.tables.total",
+  DatabaseLogSpaceUsedPercent = "oneuptime.monitor.database.log.space.used.percent",
+  DatabaseTempDbFreeBytes = "oneuptime.monitor.database.tempdb.free.bytes",
+
+  DatabaseReplicaCount = "oneuptime.monitor.database.replica.count",
+  DatabaseReplicationLagSeconds = "oneuptime.monitor.database.replication.lag.seconds",
+  DatabaseReplicationLagBytes = "oneuptime.monitor.database.replication.lag.bytes",
+  DatabaseIsInRecovery = "oneuptime.monitor.database.is.in.recovery",
+  DatabaseReplicationSlotsInactive = "oneuptime.monitor.database.replication.slots.inactive",
+
+  DatabaseTransactionIdUsedPercent = "oneuptime.monitor.database.transaction.id.used.percent",
+  DatabaseDeadTuples = "oneuptime.monitor.database.dead.tuples",
+  DatabaseTablesNeverAutovacuumed = "oneuptime.monitor.database.tables.never.autovacuumed",
+  DatabaseCheckpointsRequestedTotal = "oneuptime.monitor.database.checkpoints.requested.total",
+  DatabaseCheckpointsTimedTotal = "oneuptime.monitor.database.checkpoints.timed.total",
+
+  /*
+   * Meta-series: how many collection groups failed on this check (a missing
+   * grant, a disabled extension, a per-group timeout). Lets an operator
+   * alert on "I have lost visibility" without the monitor itself going
+   * offline, which is what a partial failure must never do.
+   */
+  DatabaseMetricGroupsFailed = "oneuptime.monitor.database.metric.groups.failed",
 }
 
 export default MonitorMetricType;

package/Types/Monitor/MonitorStep.ts

@@ -50,6 +50,9 @@ import MonitorStepDnssecMonitor, {
 import MonitorStepSqlMonitor, {
   MonitorStepSqlMonitorUtil,
 } from "./MonitorStepSqlMonitor";
+import MonitorStepDatabaseMonitor, {
+  MonitorStepDatabaseMonitorUtil,
+} from "./MonitorStepDatabaseMonitor";
 import SqlDatabaseType from "./SqlDatabaseType";
 import MonitorStepExternalStatusPageMonitor, {
   MonitorStepExternalStatusPageMonitorUtil,
@@ -204,6 +207,9 @@ export interface MonitorStepType {
   // SQL Query monitor
   sqlMonitor?: MonitorStepSqlMonitor | undefined;
 
+  // Database Health monitor (built-in catalog metrics, no user query)
+  databaseMonitor?: MonitorStepDatabaseMonitor | undefined;
+
   // External Status Page monitor
   externalStatusPageMonitor?: MonitorStepExternalStatusPageMonitor | undefined;
 
@@ -269,6 +275,7 @@ export default class MonitorStep extends DatabaseProperty {
       domainMonitor: undefined,
       dnssecMonitor: undefined,
       sqlMonitor: undefined,
+      databaseMonitor: undefined,
       externalStatusPageMonitor: undefined,
       kubernetesMonitor: undefined,
       dockerMonitor: undefined,
@@ -345,6 +352,16 @@ export default class MonitorStep extends DatabaseProperty {
       domainMonitor: undefined,
       dnssecMonitor: undefined,
       sqlMonitor: undefined,
+      /*
+       * Seeded, unlike sqlMonitor. The SQL form always writes its config
+       * because the query field is required; a Database Health step has no
+       * required field, so an untouched step would reach the probe with no
+       * connection details at all and the monitor would never run.
+       */
+      databaseMonitor:
+        arg.monitorType === MonitorType.Database
+          ? MonitorStepDatabaseMonitorUtil.getDefault()
+          : undefined,
       externalStatusPageMonitor: undefined,
       kubernetesMonitor: undefined,
       dockerMonitor: undefined,
@@ -620,6 +637,13 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setDatabaseMonitor(
+    databaseMonitor: MonitorStepDatabaseMonitor,
+  ): MonitorStep {
+    this.data!.databaseMonitor = databaseMonitor;
+    return this;
+  }
+
   public setExternalStatusPageMonitor(
     externalStatusPageMonitor: MonitorStepExternalStatusPageMonitor,
   ): MonitorStep {
@@ -876,6 +900,42 @@ export default class MonitorStep extends DatabaseProperty {
       }
     }
 
+    if (monitorType === MonitorType.Database) {
+      if (!value.data.databaseMonitor) {
+        return "Database monitor configuration is required";
+      }
+
+      if (!value.data.databaseMonitor.host) {
+        return "Database host is required";
+      }
+
+      if (!value.data.databaseMonitor.databaseName) {
+        return "Database name is required";
+      }
+
+      /*
+       * Deliberately no query check - that is the difference between this
+       * monitor and the SQL Query monitor. Nor is a metric group required:
+       * an empty list is normalized back to every group rather than
+       * rejected, so a step can never be saved in a state that silently
+       * collects nothing.
+       */
+      if (
+        value.data.databaseMonitor.useWindowsIntegratedAuthentication &&
+        value.data.databaseMonitor.databaseType !==
+          SqlDatabaseType.MicrosoftSqlServer
+      ) {
+        return "Windows Integrated Authentication is only supported for Microsoft SQL Server";
+      }
+
+      if (
+        !value.data.databaseMonitor.useWindowsIntegratedAuthentication &&
+        !value.data.databaseMonitor.username
+      ) {
+        return "Database username is required";
+      }
+    }
+
     if (monitorType === MonitorType.ExternalStatusPage) {
       if (!value.data.externalStatusPageMonitor) {
         return "External status page configuration is required";
@@ -1049,6 +1109,9 @@ export default class MonitorStep extends DatabaseProperty {
           sqlMonitor: this.data.sqlMonitor
             ? MonitorStepSqlMonitorUtil.toJSON(this.data.sqlMonitor)
             : undefined,
+          databaseMonitor: this.data.databaseMonitor
+            ? MonitorStepDatabaseMonitorUtil.toJSON(this.data.databaseMonitor)
+            : undefined,
           externalStatusPageMonitor: this.data.externalStatusPageMonitor
             ? MonitorStepExternalStatusPageMonitorUtil.toJSON(
                 this.data.externalStatusPageMonitor,
@@ -1250,6 +1313,18 @@ export default class MonitorStep extends DatabaseProperty {
       sqlMonitor: json["sqlMonitor"]
         ? (json["sqlMonitor"] as JSONObject)
         : undefined,
+      /*
+       * Normalized on the way in, like metricMonitor above: the group list
+       * and the timeouts are clamped here so no consumer downstream has to
+       * defend against a step written by an older build or by hand.
+       */
+      databaseMonitor: json["databaseMonitor"]
+        ? MonitorStepDatabaseMonitorUtil.toJSON(
+            MonitorStepDatabaseMonitorUtil.fromJSON(
+              json["databaseMonitor"] as JSONObject,
+            ),
+          )
+        : undefined,
       externalStatusPageMonitor: json["externalStatusPageMonitor"]
         ? (json["externalStatusPageMonitor"] as JSONObject)
         : undefined,
@@ -1315,6 +1390,7 @@ export default class MonitorStep extends DatabaseProperty {
         domainMonitor: Zod.any().optional(),
         dnssecMonitor: Zod.any().optional(),
         sqlMonitor: Zod.any().optional(),
+        databaseMonitor: Zod.any().optional(),
         externalStatusPageMonitor: Zod.any().optional(),
         kubernetesMonitor: Zod.any().optional(),
         dockerMonitor: Zod.any().optional(),

package/Types/Monitor/MonitorStepDatabaseMonitor.ts

@@ -0,0 +1,171 @@
+import { JSONObject } from "../JSON";
+import { DatabaseMetricGroup } from "./DatabaseMetricCatalog";
+import {
+  clampSqlConnectionTimeoutInMs,
+  clampSqlStatementTimeoutInMs,
+} from "./MonitorStepSqlMonitor";
+import SqlConnectionConfig from "./SqlConnectionConfig";
+import SqlDatabaseType from "./SqlDatabaseType";
+
+/*
+ * Connection + collection configuration for a Database Health monitor.
+ *
+ * The connection block deliberately mirrors MonitorStepSqlMonitor field for
+ * field: the two monitor types point at the same kind of server, and an
+ * operator who has configured one should not have to learn a second form.
+ * What differs is everything after the connection - there is no user query
+ * here. The probe runs built-in read-only catalog queries chosen by engine,
+ * grouped so a missing grant degrades one group instead of the monitor.
+ *
+ * As with the SQL Query monitor, `password` (or any other field) may hold a
+ * {{monitorSecrets.name}} reference that the server resolves before the
+ * config is handed to a probe. OneUptime never creates those secrets itself.
+ */
+
+/*
+ * Health queries are introspection, not user workload: they should return in
+ * milliseconds against a healthy server. A tighter default than the SQL Query
+ * monitor's is deliberate - if pg_stat_activity takes ten seconds, the useful
+ * signal is "this server is in trouble", and we want the check to say so
+ * rather than to sit and wait.
+ */
+export const DEFAULT_DATABASE_STATEMENT_TIMEOUT_IN_MS: number = 10000;
+export const DEFAULT_DATABASE_CONNECTION_TIMEOUT_IN_MS: number = 10000;
+
+/*
+ * Every group is on by default. A group whose grant is missing reports itself
+ * as unavailable rather than failing the check, so a default-on configuration
+ * degrades into "the metrics you are entitled to" instead of an error.
+ */
+export const DEFAULT_DATABASE_METRIC_GROUPS: Array<DatabaseMetricGroup> = [
+  DatabaseMetricGroup.Connections,
+  DatabaseMetricGroup.Activity,
+  DatabaseMetricGroup.Throughput,
+  DatabaseMetricGroup.Locks,
+  DatabaseMetricGroup.Storage,
+  DatabaseMetricGroup.Replication,
+  DatabaseMetricGroup.Maintenance,
+];
+
+export default interface MonitorStepDatabaseMonitor
+  extends SqlConnectionConfig {
+  connectionTimeoutInMs: number;
+  statementTimeoutInMs: number;
+  /*
+   * Which collection groups to run. Trimming this list is how an operator
+   * opts out of a group they cannot grant, or one whose queries they would
+   * rather not pay for on a busy server (Storage is the usual candidate -
+   * summing information_schema.TABLES is not free on a large MySQL server).
+   */
+  enabledMetricGroups: Array<DatabaseMetricGroup>;
+}
+
+export class MonitorStepDatabaseMonitorUtil {
+  public static getDefault(): MonitorStepDatabaseMonitor {
+    return {
+      databaseType: SqlDatabaseType.PostgreSQL,
+      host: "",
+      port: 5432,
+      databaseName: "",
+      username: "",
+      password: "",
+      useWindowsIntegratedAuthentication: false,
+      useSsl: false,
+      rejectUnauthorizedSsl: true,
+      connectionTimeoutInMs: DEFAULT_DATABASE_CONNECTION_TIMEOUT_IN_MS,
+      statementTimeoutInMs: DEFAULT_DATABASE_STATEMENT_TIMEOUT_IN_MS,
+      enabledMetricGroups: [...DEFAULT_DATABASE_METRIC_GROUPS],
+    };
+  }
+
+  /**
+   * Keep only recognized groups. An unknown string (an older or newer
+   * dashboard, a hand-written API call) is dropped rather than passed to the
+   * probe, which would otherwise have to defend against it at collection
+   * time. An empty or absent list falls back to every group, because a
+   * monitor that silently collects nothing is worse than one that collects
+   * what it can.
+   */
+  public static sanitizeMetricGroups(
+    groups: unknown,
+  ): Array<DatabaseMetricGroup> {
+    if (!Array.isArray(groups)) {
+      return [...DEFAULT_DATABASE_METRIC_GROUPS];
+    }
+
+    const validGroups: Array<DatabaseMetricGroup> =
+      Object.values(DatabaseMetricGroup);
+
+    const sanitized: Array<DatabaseMetricGroup> = groups.filter(
+      (group: unknown) => {
+        return validGroups.includes(group as DatabaseMetricGroup);
+      },
+    ) as Array<DatabaseMetricGroup>;
+
+    // De-duplicate while preserving the canonical group order.
+    const seen: Set<DatabaseMetricGroup> = new Set<DatabaseMetricGroup>(
+      sanitized,
+    );
+
+    const ordered: Array<DatabaseMetricGroup> =
+      DEFAULT_DATABASE_METRIC_GROUPS.filter((group: DatabaseMetricGroup) => {
+        return seen.has(group);
+      });
+
+    if (ordered.length === 0) {
+      return [...DEFAULT_DATABASE_METRIC_GROUPS];
+    }
+
+    return ordered;
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepDatabaseMonitor {
+    return {
+      databaseType:
+        (json["databaseType"] as SqlDatabaseType) || SqlDatabaseType.PostgreSQL,
+      host: (json["host"] as string) || "",
+      port: (json["port"] as number) || 5432,
+      databaseName: (json["databaseName"] as string) || "",
+      username: (json["username"] as string) || "",
+      password: (json["password"] as string) || "",
+      useWindowsIntegratedAuthentication: Boolean(
+        json["useWindowsIntegratedAuthentication"],
+      ),
+      useSsl: Boolean(json["useSsl"]),
+      rejectUnauthorizedSsl:
+        json["rejectUnauthorizedSsl"] === undefined ||
+        json["rejectUnauthorizedSsl"] === null
+          ? true
+          : Boolean(json["rejectUnauthorizedSsl"]),
+      connectionTimeoutInMs: clampSqlConnectionTimeoutInMs(
+        (json["connectionTimeoutInMs"] as number) ||
+          DEFAULT_DATABASE_CONNECTION_TIMEOUT_IN_MS,
+      ),
+      statementTimeoutInMs: clampSqlStatementTimeoutInMs(
+        (json["statementTimeoutInMs"] as number) ||
+          DEFAULT_DATABASE_STATEMENT_TIMEOUT_IN_MS,
+      ),
+      enabledMetricGroups: this.sanitizeMetricGroups(
+        json["enabledMetricGroups"],
+      ),
+    };
+  }
+
+  public static toJSON(monitor: MonitorStepDatabaseMonitor): JSONObject {
+    return {
+      databaseType: monitor.databaseType,
+      host: monitor.host,
+      port: monitor.port,
+      databaseName: monitor.databaseName,
+      username: monitor.username,
+      password: monitor.password,
+      useWindowsIntegratedAuthentication:
+        monitor.useWindowsIntegratedAuthentication,
+      useSsl: monitor.useSsl,
+      rejectUnauthorizedSsl: monitor.rejectUnauthorizedSsl,
+      connectionTimeoutInMs: monitor.connectionTimeoutInMs,
+      statementTimeoutInMs: monitor.statementTimeoutInMs,
+      enabledMetricGroups: [...monitor.enabledMetricGroups],
+    };
+  }
+}

package/Types/Monitor/MonitorStepSqlMonitor.ts

@@ -1,4 +1,5 @@
 import { JSONObject } from "../JSON";
+import SqlConnectionConfig from "./SqlConnectionConfig";
 import SqlDatabaseType from "./SqlDatabaseType";
 
 /*
@@ -56,26 +57,7 @@ export const clampSqlMaxRows: (value: number) => number = (
  * the config is handed to a probe. OneUptime never creates these secrets for
  * the user; referencing one is the user's choice.
  */
-export default interface MonitorStepSqlMonitor {
-  databaseType: SqlDatabaseType;
-  host: string;
-  port: number;
-  databaseName: string;
-  username: string;
-  // Raw password OR a {{monitorSecrets.name}} reference resolved server-side.
-  password: string;
-  /*
-   * Microsoft SQL Server only: authenticate with the identity under which the
-   * probe is running (SSPI on Windows, Kerberos on Linux/macOS). Username and
-   * password are ignored when this is enabled.
-   */
-  useWindowsIntegratedAuthentication: boolean;
-  useSsl: boolean;
-  /*
-   * When SSL is on, whether the server certificate chain must validate. Users
-   * connecting to a DB with a self-signed cert set this to false.
-   */
-  rejectUnauthorizedSsl: boolean;
+export default interface MonitorStepSqlMonitor extends SqlConnectionConfig {
   // The read-only SQL query to run. A single statement is expected.
   query: string;
   connectionTimeoutInMs: number;