@oneuptime/common 12.0.32 → 12.0.33

package/Types/Monitor/DatabaseMonitor/DatabaseMonitorResponse.ts

@@ -0,0 +1,83 @@
+import ProbeAttempt from "../../Probe/ProbeAttempt";
+import { DatabaseMetricGroup } from "../DatabaseMetricCatalog";
+import MonitorMetricType from "../MonitorMetricType";
+
+/*
+ * Why a metric group produced nothing. Kept as a closed set so the dashboard
+ * can render an actionable message (and, for MissingPermission, the exact
+ * GRANT to run) instead of echoing a driver error at the operator.
+ */
+export enum DatabaseMetricGroupUnavailableReason {
+  // The monitoring login lacks the grant this group's views need.
+  MissingPermission = "MissingPermission",
+  /*
+   * The engine does not expose this data at all: an older major version, a
+   * disabled extension, or a feature the engine simply does not have (there
+   * is no deadlock counter in stock MySQL, for instance).
+   */
+  NotSupportedByEngine = "NotSupportedByEngine",
+  // The group's query exceeded the statement timeout.
+  Timeout = "Timeout",
+  // Anything else. `message` carries the sanitized detail.
+  Error = "Error",
+}
+
+export interface DatabaseMetricGroupStatus {
+  group: DatabaseMetricGroup;
+  reason: DatabaseMetricGroupUnavailableReason;
+  /*
+   * Sanitized, operator-facing explanation. Never contains a DSN, a
+   * password, or a raw driver error - SqlMonitor.sanitizeError is applied
+   * before anything lands here.
+   */
+  message: string;
+  /*
+   * The grant that would fix it, when we know it (e.g.
+   * "GRANT pg_read_all_stats TO monitoring_user"). Rendered verbatim in the
+   * monitor's summary view so the fix is copy-pasteable.
+   */
+  remediation?: string | undefined;
+}
+
+/*
+ * What a probe reports back for one Database Health check.
+ *
+ * The central contract here is that COLLECTION IS PARTIAL BY DESIGN.
+ * `isOnline` answers exactly one question - could we connect and run the
+ * baseline probe query - and nothing else in this payload can change it. A
+ * login without VIEW SERVER STATE, a replica group that times out, or an
+ * engine that has no deadlock counter all produce entries in
+ * `unavailableGroups` while the monitor stays online, because the database
+ * being monitored is fine; it is our visibility into it that is reduced.
+ *
+ * No rows of customer data ever appear here. Values are numeric aggregates
+ * read from engine catalog views, keyed by the metric series they feed.
+ */
+export default interface DatabaseMonitorResponse {
+  isOnline: boolean;
+  // Time to connect and run the baseline probe query.
+  responseTimeInMs: number;
+  failureCause: string;
+  /*
+   * Collected values, keyed by the series each one writes. A metric absent
+   * from this map is simply not written - the engine did not report it,
+   * or its group was skipped. Never zero-fill: a missing replication lag
+   * and a replication lag of zero mean opposite things.
+   */
+  metrics: Partial<Record<MonitorMetricType, number>>;
+  // Groups that ran and produced values.
+  collectedGroups: Array<DatabaseMetricGroup>;
+  // Groups that could not be collected, with the reason and the fix.
+  unavailableGroups: Array<DatabaseMetricGroupStatus>;
+  /*
+   * Engine version string as the server reports it, for the summary view.
+   * Also what the collector version-gates on (PostgreSQL moved the
+   * checkpoint counters out of pg_stat_bgwriter in 17, for example).
+   */
+  engineVersion?: string | undefined;
+  // Sanitized connection error, present only when isOnline is false.
+  connectionError: string | null;
+  isTimeout?: boolean | undefined;
+  probeAttempts?: Array<ProbeAttempt> | undefined;
+  totalAttempts?: number | undefined;
+}

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;

package/Types/Monitor/MonitorType.ts

@@ -24,6 +24,18 @@ enum MonitorType {
   // Database monitoring — runs a read-only SQL query on a schedule from a probe.
   SQLQuery = "SQL Query",
 
+  /*
+   * Database health monitoring. Where SQLQuery runs the query the user
+   * wrote, this runs the queries we wrote: a probe connects to the engine
+   * and reads its own catalog views (pg_stat_*, performance_schema,
+   * sys.dm_*) to produce connection, throughput, lock, cache, storage and
+   * replication series without the user knowing a single system table.
+   * The two are deliberately separate types - a health check has no user
+   * query, needs different grants, and runs a different number of
+   * statements per interval.
+   */
+  Database = "Database",
+
   // These two monitor types are same but we are keeping them separate for now - this is for marketing purposes
   SyntheticMonitor = "Synthetic Monitor",
   CustomJavaScriptCode = "Custom JavaScript Code",
@@ -103,7 +115,7 @@ export class MonitorTypeHelper {
       },
       {
         label: "Database Monitoring",
-        monitorTypes: [MonitorType.SQLQuery],
+        monitorTypes: [MonitorType.Database, MonitorType.SQLQuery],
       },
       {
         label: "Synthetic Monitoring",
@@ -495,6 +507,37 @@ export class MonitorTypeHelper {
           "row count",
         ],
       },
+      {
+        monitorType: MonitorType.Database,
+        title: "Database Health",
+        description:
+          "Connections, locks, replication and cache health for PostgreSQL, MySQL and SQL Server.",
+        icon: IconProp.Database,
+        keywords: [
+          "database",
+          "db",
+          "health",
+          "performance",
+          "postgres",
+          "postgresql",
+          "mysql",
+          "mariadb",
+          "mssql",
+          "sql server",
+          "connections",
+          "replication",
+          "replica",
+          "lag",
+          "locks",
+          "deadlock",
+          "vacuum",
+          "bloat",
+          "buffer",
+          "cache hit",
+          "slow query",
+          "wraparound",
+        ],
+      },
       {
         monitorType: MonitorType.SyntheticMonitor,
         title: "Synthetic Monitor",
@@ -780,6 +823,7 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.DNSSEC ||
       monitorType === MonitorType.Domain ||
       monitorType === MonitorType.SQLQuery ||
+      monitorType === MonitorType.Database ||
       monitorType === MonitorType.ExternalStatusPage;
     return isProbeableMonitor;
   }
@@ -808,6 +852,7 @@ export class MonitorTypeHelper {
       MonitorType.DNSSEC,
       MonitorType.Domain,
       MonitorType.SQLQuery,
+      MonitorType.Database,
       MonitorType.ExternalStatusPage,
       MonitorType.Kubernetes,
       MonitorType.Docker,
@@ -855,6 +900,7 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.DNSSEC ||
       monitorType === MonitorType.Domain ||
       monitorType === MonitorType.SQLQuery ||
+      monitorType === MonitorType.Database ||
       monitorType === MonitorType.ExternalStatusPage
     ) {
       return true;