@oneuptime/common 12.0.31 → 12.0.33

package/Types/Exception/NotAuthenticatedException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class NotAuthenticatedException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.NotAuthenticatedException, message);
   }
+
+  /*
+   * A check we deliberately wrote, doing exactly its job. Denying this
+   * request IS the correct behaviour, so it is not an Issue. Promoted back to
+   * CodeFault outside an HTTP request — see ErrorClassResolver.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.ExpectedDenial;
+  }
 }

package/Types/Exception/NotAuthorizedException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class NotAuthorizedException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.NotAuthorizedException, message);
   }
+
+  /*
+   * A check we deliberately wrote, doing exactly its job. Denying this
+   * request IS the correct behaviour, so it is not an Issue. Promoted back to
+   * CodeFault outside an HTTP request — see ErrorClassResolver.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.ExpectedDenial;
+  }
 }

package/Types/Exception/NotFoundException.ts

@@ -1,8 +1,19 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class NotFoundException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.NotFoundException, message);
   }
+
+  /*
+   * The caller sent something we cannot accept. Nothing is broken; the
+   * request was. Promoted back to CodeFault by ErrorClassResolver when it is
+   * raised outside an HTTP request, because a background job has no client to
+   * blame — see Common/Server/Utils/Telemetry/ErrorClassResolver.ts.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.UserError;
+  }
 }

package/Types/Exception/PayloadTooLargeException.ts

@@ -1,8 +1,19 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class PayloadTooLargeException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.PayloadTooLargeException, message);
   }
+
+  /*
+   * The caller sent something we cannot accept. Nothing is broken; the
+   * request was. Promoted back to CodeFault by ErrorClassResolver when it is
+   * raised outside an HTTP request, because a background job has no client to
+   * blame — see Common/Server/Utils/Telemetry/ErrorClassResolver.ts.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.UserError;
+  }
 }

package/Types/Exception/PaymentRequiredException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class PaymentRequiredException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.PaymentRequiredException, message);
   }
+
+  /*
+   * A check we deliberately wrote, doing exactly its job. Denying this
+   * request IS the correct behaviour, so it is not an Issue. Promoted back to
+   * CodeFault outside an HTTP request — see ErrorClassResolver.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.ExpectedDenial;
+  }
 }

package/Types/Exception/ServiceUnavailableException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class ServiceUnavailableException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.ServiceUnavailableException, message);
   }
+
+  /*
+   * The environment failed, not our code and not the caller. Stays an
+   * Issue: it is a real failure worth a human, it is just never something the
+   * automatic fix lane should open a pull request for.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.Infrastructure;
+  }
 }

package/Types/Exception/SsoAuthorizationException.ts

@@ -1,5 +1,6 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class SSOAuthorizationException extends Exception {
   private static message: string = "SSO Authorization Required";
@@ -14,4 +15,13 @@ export default class SSOAuthorizationException extends Exception {
   public static isException(errorMessage: string): boolean {
     return errorMessage === SSOAuthorizationException.message;
   }
+
+  /*
+   * A check we deliberately wrote, doing exactly its job. Denying this
+   * request IS the correct behaviour, so it is not an Issue. Promoted back to
+   * CodeFault outside an HTTP request — see ErrorClassResolver.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.ExpectedDenial;
+  }
 }

package/Types/Exception/TenantNotFoundException.ts

@@ -1,8 +1,19 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class TenantNotFoundException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.TenantNotFoundException, message);
   }
+
+  /*
+   * The caller sent something we cannot accept. Nothing is broken; the
+   * request was. Promoted back to CodeFault by ErrorClassResolver when it is
+   * raised outside an HTTP request, because a background job has no client to
+   * blame — see Common/Server/Utils/Telemetry/ErrorClassResolver.ts.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.UserError;
+  }
 }

package/Types/Exception/TimeoutException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class TimeoutException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.TimeoutException, message);
   }
+
+  /*
+   * The environment failed, not our code and not the caller. Stays an
+   * Issue: it is a real failure worth a human, it is just never something the
+   * automatic fix lane should open a pull request for.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.Infrastructure;
+  }
 }

package/Types/Exception/TooManyRequestsException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class TooManyRequestsException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.TooManyRequestsException, message);
   }
+
+  /*
+   * A check we deliberately wrote, doing exactly its job. Denying this
+   * request IS the correct behaviour, so it is not an Issue. Promoted back to
+   * CodeFault outside an HTTP request — see ErrorClassResolver.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.ExpectedDenial;
+  }
 }

package/Types/Exception/UnableToReachServer.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class UnableToReachServer extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.UnabletoReachServerException, message);
   }
+
+  /*
+   * The environment failed, not our code and not the caller. Stays an
+   * Issue: it is a real failure worth a human, it is just never something the
+   * automatic fix lane should open a pull request for.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.Infrastructure;
+  }
 }

package/Types/Exception/WebsiteRequestException.ts

@@ -1,8 +1,18 @@
 import Exception from "./Exception";
 import ExceptionCode from "./ExceptionCode";
+import ErrorClass from "../Telemetry/ErrorClass";
 
 export default class WebsiteRequestException extends Exception {
   public constructor(message: string) {
     super(ExceptionCode.WebRequestException, message);
   }
+
+  /*
+   * The environment failed, not our code and not the caller. Stays an
+   * Issue: it is a real failure worth a human, it is just never something the
+   * automatic fix lane should open a pull request for.
+   */
+  protected override getErrorClass(): ErrorClass {
+    return ErrorClass.Infrastructure;
+  }
 }

package/Types/Monitor/CriteriaFilter.ts

@@ -1,5 +1,6 @@
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 import MetricCriteriaContext from "./MetricMonitor/MetricCriteriaContext";
+import MonitorMetricType from "./MonitorMetricType";
 
 export enum CheckOn {
   ResponseTime = "Response Time (in ms)",
@@ -75,7 +76,19 @@ export enum CheckOn {
   SnmpOidValue = "SNMP OID Value",
   SnmpOidExists = "SNMP OID Exists",
   SnmpResponseTime = "SNMP Response Time (in ms)",
+  /*
+   * Device reachability: true when the device answered ping OR its SNMP
+   * walk succeeded. The label predates ping-first polling; the value is
+   * load-bearing (stored in monitor criteria) so it stays as it is.
+   */
   SnmpIsOnline = "SNMP Device Is Online",
+  /*
+   * The SNMP walk itself. Not evaluated at all on a poll that ran no walk
+   * (a device without credentials), so "is False" means "the walk was
+   * attempted and failed" - credentials, agent, or an ACL - never "there
+   * was nothing to walk".
+   */
+  SnmpWalkIsSucceeding = "SNMP Walk Is Succeeding",
   SnmpInterfaceIsDown = "SNMP Interface Is Down",
   SnmpTrapReceived = "SNMP Trap Received (Trap OID)",
   SnmpInterfaceUtilizationPercent = "SNMP Interface Utilization (in %)",
@@ -110,6 +123,21 @@ export enum CheckOn {
   SqlQueryExecutionTime = "SQL Query Execution Time (in ms)",
   SqlQueryError = "SQL Query Error",
 
+  /*
+   * Database Health monitors.
+   *
+   * Deliberately three CheckOns rather than one per metric. The catalog
+   * carries ~40 series and grows with every engine we add; putting each in
+   * this enum would flood a dropdown shared with every other monitor type
+   * and force a new case in five switch statements per metric. Instead
+   * DatabaseMetric names the series in databaseMonitorOptions.metricType,
+   * the same way Server monitors name a disk in serverMonitorOptions and
+   * SNMP monitors name an OID in snmpMonitorOptions.
+   */
+  DatabaseIsOnline = "Database Is Online",
+  DatabaseMetric = "Database Metric",
+  DatabaseCollectionError = "Database Collection Error",
+
   // External Status Page monitors.
   ExternalStatusPageIsOnline = "External Status Page Is Online",
   ExternalStatusPageOverallStatus = "External Status Page Overall Status",
@@ -134,6 +162,16 @@ export interface SnmpMonitorOptions {
   interfaceName?: string | undefined;
 }
 
+export interface DatabaseMonitorOptions {
+  /*
+   * Which collected series this filter compares against, e.g.
+   * MonitorMetricType.DatabaseConnectionsUsedPercent. Required whenever
+   * checkOn is CheckOn.DatabaseMetric; a filter without it can never be
+   * met and is reported as misconfigured rather than silently ignored.
+   */
+  metricType?: MonitorMetricType | undefined;
+}
+
 export enum EvaluateOverTimeType {
   Average = "Average",
   Sum = "Sum",
@@ -242,6 +280,7 @@ export interface CriteriaFilter {
   serverMonitorOptions?: ServerMonitorOptions | undefined;
   metricMonitorOptions?: MetricMonitorOptions | undefined;
   snmpMonitorOptions?: SnmpMonitorOptions | undefined;
+  databaseMonitorOptions?: DatabaseMonitorOptions | undefined;
   filterType: FilterType | undefined;
   value: string | number | undefined;
   evaluateOverTime?: boolean | undefined;
@@ -319,6 +358,7 @@ export class CriteriaFilterUtil {
     if (
       checkOn === CheckOn.IsOnline ||
       checkOn === CheckOn.SnmpIsOnline ||
+      checkOn === CheckOn.SnmpWalkIsSucceeding ||
       checkOn === CheckOn.SnmpInterfaceIsDown ||
       checkOn === CheckOn.DnsIsOnline ||
       checkOn === CheckOn.DomainIsExpired ||
@@ -328,6 +368,7 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.DnssecResolverConsensus ||
       checkOn === CheckOn.DnssecNameserverConsistent ||
       checkOn === CheckOn.SqlIsOnline ||
+      checkOn === CheckOn.DatabaseIsOnline ||
       checkOn === CheckOn.ExternalStatusPageIsOnline
     ) {
       return false;
@@ -373,7 +414,14 @@ export class CriteriaFilterUtil {
       return [];
     }
 
-    if (criteriaFilter.checkOn === CheckOn.IsOnline) {
+    /*
+     * Boolean series. Averaging or summing an up/down series is meaningless,
+     * so these offer only the two set-shaped choices.
+     */
+    if (
+      criteriaFilter.checkOn === CheckOn.IsOnline ||
+      criteriaFilter.checkOn === CheckOn.DatabaseIsOnline
+    ) {
       return [EvaluateOverTimeType.AllValues, EvaluateOverTimeType.AnyValue];
     }
 
@@ -428,7 +476,14 @@ export class CriteriaFilterUtil {
       checkOn === CheckOn.DnsResponseTime ||
       checkOn === CheckOn.DnsIsOnline ||
       checkOn === CheckOn.ExternalStatusPageResponseTime ||
-      checkOn === CheckOn.ExternalStatusPageIsOnline
+      checkOn === CheckOn.ExternalStatusPageIsOnline ||
+      /*
+       * Over time is the most useful shape for database thresholds: a single
+       * sample of "connections above 90%" is a spike, five minutes of it is
+       * an incident.
+       */
+      checkOn === CheckOn.DatabaseIsOnline ||
+      checkOn === CheckOn.DatabaseMetric
     );
   }
 }
@@ -454,6 +509,9 @@ export const CriteriaFilterSchema: ZodSchema = Zod.object({
     oid: Zod.string().optional(),
     interfaceName: Zod.string().optional(),
   }).optional(),
+  databaseMonitorOptions: Zod.object({
+    metricType: Zod.string().optional(),
+  }).optional(),
   filterType: Zod.string().optional(),
   value: Zod.union([Zod.string(), Zod.number()]).optional(),
   evaluateOverTime: Zod.boolean().optional(),