@oneuptime/common 8.0.5579 → 8.0.5580

package/Server/Utils/Monitor/Criteria/CompareCriteria.ts

@@ -636,7 +636,15 @@ export default class CompareCriteria {
     }
 
     if (typeof value === Typeof.Number) {
-      return (value as number).toFixed(2);
+      const numericValue: number = value as number;
+
+      if (Number.isInteger(numericValue)) {
+        return numericValue.toString();
+      }
+
+      const roundedValue: number = Number(numericValue.toFixed(2));
+
+      return roundedValue.toString();
     }
 
     if (typeof value === Typeof.Boolean) {

package/Server/Utils/Monitor/Criteria/ExceptionMonitorCriteria.ts

@@ -0,0 +1,34 @@
+import ExceptionMonitorResponse from "../../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+import DataToProcess from "../DataToProcess";
+import CompareCriteria from "./CompareCriteria";
+import {
+  CheckOn,
+  CriteriaFilter,
+} from "../../../../Types/Monitor/CriteriaFilter";
+
+export default class ExceptionMonitorCriteria {
+  @CaptureSpan()
+  public static async isMonitorInstanceCriteriaFilterMet(input: {
+    dataToProcess: DataToProcess;
+    criteriaFilter: CriteriaFilter;
+  }): Promise<string | null> {
+    let threshold: number | string | undefined | null =
+      input.criteriaFilter.value;
+
+    if (input.criteriaFilter.checkOn === CheckOn.ExceptionCount) {
+      threshold = CompareCriteria.convertToNumber(threshold);
+
+      const currentExceptionCount: number =
+        (input.dataToProcess as ExceptionMonitorResponse).exceptionCount || 0;
+
+      return CompareCriteria.compareCriteriaNumbers({
+        value: currentExceptionCount,
+        threshold: threshold as number,
+        criteriaFilter: input.criteriaFilter,
+      });
+    }
+
+    return null;
+  }
+}

package/Server/Utils/Monitor/DataToProcess.ts

@@ -4,6 +4,7 @@ import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
 import LogMonitorResponse from "../../../Types/Monitor/LogMonitor/LogMonitorResponse";
 import TraceMonitorResponse from "../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
+import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
 
 type DataToProcess =
   | ProbeMonitorResponse
@@ -11,6 +12,7 @@ type DataToProcess =
   | ServerMonitorResponse
   | LogMonitorResponse
   | TraceMonitorResponse
-  | MetricMonitorResponse;
+  | MetricMonitorResponse
+  | ExceptionMonitorResponse;
 
 export default DataToProcess;

package/Server/Utils/Monitor/MonitorCriteriaDataExtractor.ts

@@ -14,6 +14,7 @@ import AggregatedResult from "../../../Types/BaseDatabase/AggregatedResult";
 import AggregateModel from "../../../Types/BaseDatabase/AggregatedModel";
 import MetricQueryConfigData from "../../../Types/Metrics/MetricQueryConfigData";
 import MetricFormulaConfigData from "../../../Types/Metrics/MetricFormulaConfigData";
+import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
 
 export default class MonitorCriteriaDataExtractor {
   public static getProbeMonitorResponse(
@@ -79,6 +80,18 @@ export default class MonitorCriteriaDataExtractor {
     return null;
   }
 
+  public static getExceptionMonitorResponse(
+    dataToProcess: DataToProcess,
+  ): ExceptionMonitorResponse | null {
+    if (
+      (dataToProcess as ExceptionMonitorResponse).exceptionCount !== undefined
+    ) {
+      return dataToProcess as ExceptionMonitorResponse;
+    }
+
+    return null;
+  }
+
   public static getCustomCodeMonitorResponse(
     dataToProcess: DataToProcess,
   ): CustomCodeMonitorResponse | null {

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -9,6 +9,7 @@ import SyntheticMonitoringCriteria from "./Criteria/SyntheticMonitor";
 import LogMonitorCriteria from "./Criteria/LogMonitorCriteria";
 import MetricMonitorCriteria from "./Criteria/MetricMonitorCriteria";
 import TraceMonitorCriteria from "./Criteria/TraceMonitorCriteria";
+import ExceptionMonitorCriteria from "./Criteria/ExceptionMonitorCriteria";
 import MonitorCriteriaMessageBuilder from "./MonitorCriteriaMessageBuilder";
 import DataToProcess from "./DataToProcess";
 import Monitor from "../../../Models/DatabaseModels/Monitor";
@@ -434,6 +435,18 @@ export default class MonitorCriteriaEvaluator {
       }
     }
 
+    if (input.monitor.monitorType === MonitorType.Exceptions) {
+      const exceptionMonitorResult: string | null =
+        await ExceptionMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess: input.dataToProcess,
+          criteriaFilter: input.criteriaFilter,
+        });
+
+      if (exceptionMonitorResult) {
+        return exceptionMonitorResult;
+      }
+    }
+
     return null;
   }
 }

package/Server/Utils/Monitor/MonitorCriteriaObservationBuilder.ts

@@ -19,6 +19,7 @@ import SyntheticMonitorResponse from "../../../Types/Monitor/SyntheticMonitors/S
 import CustomCodeMonitorResponse from "../../../Types/Monitor/CustomCodeMonitor/CustomCodeMonitorResponse";
 import LogMonitorResponse from "../../../Types/Monitor/LogMonitor/LogMonitorResponse";
 import TraceMonitorResponse from "../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
+import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
 import MonitorCriteriaMessageFormatter from "./MonitorCriteriaMessageFormatter";
 import MonitorCriteriaDataExtractor from "./MonitorCriteriaDataExtractor";
 import MonitorCriteriaExpectationBuilder from "./MonitorCriteriaExpectationBuilder";
@@ -161,6 +162,10 @@ export default class MonitorCriteriaObservationBuilder {
         return MonitorCriteriaObservationBuilder.describeMetricValueObservation(
           input,
         );
+      case CheckOn.ExceptionCount:
+        return MonitorCriteriaObservationBuilder.describeExceptionCountObservation(
+          input,
+        );
       default:
         return null;
     }
@@ -1083,6 +1088,21 @@ export default class MonitorCriteriaObservationBuilder {
     return `Span count was ${traceResponse.spanCount}.`;
   }
 
+  private static describeExceptionCountObservation(input: {
+    dataToProcess: DataToProcess;
+  }): string | null {
+    const exceptionResponse: ExceptionMonitorResponse | null =
+      MonitorCriteriaDataExtractor.getExceptionMonitorResponse(
+        input.dataToProcess,
+      );
+
+    if (!exceptionResponse) {
+      return null;
+    }
+
+    return `Exception count was ${exceptionResponse.exceptionCount}.`;
+  }
+
   private static describeMetricValueObservation(input: {
     criteriaFilter: CriteriaFilter;
     dataToProcess: DataToProcess;

package/Server/Utils/Monitor/MonitorResource.ts

@@ -31,6 +31,7 @@ import LogMonitorResponse from "../../../Types/Monitor/LogMonitor/LogMonitorResp
 import MetricMonitorResponse from "../../../Types/Monitor/MetricMonitor/MetricMonitorResponse";
 import TelemetryType from "../../../Types/Telemetry/TelemetryType";
 import TraceMonitorResponse from "../../../Types/Monitor/TraceMonitor/TraceMonitorResponse";
+import ExceptionMonitorResponse from "../../../Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse";
 import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import MonitorIncident from "./MonitorIncident";
 import MonitorAlert from "./MonitorAlert";
@@ -557,6 +558,23 @@ export default class MonitorResourceUtil {
         );
       }
 
+      if (
+        dataToProcess &&
+        (dataToProcess as ExceptionMonitorResponse).exceptionQuery
+      ) {
+        const exceptionResponse: ExceptionMonitorResponse =
+          dataToProcess as ExceptionMonitorResponse;
+        telemetryQuery = {
+          telemetryQuery: exceptionResponse.exceptionQuery,
+          telemetryType: TelemetryType.Exception,
+          metricViewData: null,
+        };
+
+        logger.debug(
+          `${dataToProcess.monitorId.toString()} - Exception query found.`,
+        );
+      }
+
       const matchedCriteriaInstance: MonitorCriteriaInstance =
         criteriaInstanceMap[response.criteriaMetId!]!;
 

package/Server/Utils/Telemetry.ts

@@ -27,6 +27,7 @@ import {
 } from "@opentelemetry/sdk-logs";
 import type { Resource as LogsResource } from "@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/Resource";
 import {
+  Aggregation,
   MeterProvider,
   PeriodicExportingMetricReader,
 } from "@opentelemetry/sdk-metrics";
@@ -174,6 +175,20 @@ export default class Telemetry {
           compression: CompressionAlgorithm.GZIP,
         }) as unknown as PushMetricExporter;
 
+        // Force an SDK-side aggregation selector that matches the modern metrics API.
+        if (
+          typeof (metricExporter as { selectAggregation?: unknown })
+            .selectAggregation === "function"
+        ) {
+          (
+            metricExporter as unknown as {
+              selectAggregation: (..._args: Array<unknown>) => Aggregation;
+            }
+          ).selectAggregation = () => {
+            return Aggregation.Default();
+          };
+        }
+
         this.metricReader = new PeriodicExportingMetricReader({
           exporter: metricExporter,
         });

package/Types/Monitor/CriteriaFilter.ts

@@ -42,6 +42,9 @@ export enum CheckOn {
   // Trace monitors.
   SpanCount = "Span Count",
 
+  // Exception monitors.
+  ExceptionCount = "Exception Count",
+
   // Metric Monitors.
   MetricValue = "Metric Value",
 }

package/Types/Monitor/ExceptionMonitor/ExceptionMonitorResponse.ts

@@ -0,0 +1,12 @@
+import Query from "../../BaseDatabase/Query";
+import ObjectID from "../../ObjectID";
+import ExceptionInstance from "../../../Models/AnalyticsModels/ExceptionInstance";
+import MonitorEvaluationSummary from "../MonitorEvaluationSummary";
+
+export default interface ExceptionMonitorResponse {
+  projectId: ObjectID;
+  exceptionCount: number;
+  exceptionQuery: Query<ExceptionInstance>;
+  monitorId: ObjectID;
+  evaluationSummary?: MonitorEvaluationSummary | undefined;
+}

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -121,6 +121,33 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       return monitorCriteriaInstance;
     }
 
+    if (arg.monitorType === MonitorType.Exceptions) {
+      const monitorCriteriaInstance: MonitorCriteriaInstance =
+        new MonitorCriteriaInstance();
+
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.ExceptionCount,
+            filterType: FilterType.EqualTo,
+            value: 0,
+          },
+        ],
+        incidents: [],
+        alerts: [],
+        changeMonitorStatus: true,
+        createIncidents: false,
+        createAlerts: false,
+        name: `Check if ${arg.monitorName} has no exceptions`,
+        description: `This criteria checks if the ${arg.monitorName} has no exceptions.`,
+      };
+
+      return monitorCriteriaInstance;
+    }
+
     if (arg.monitorType === MonitorType.Metrics) {
       const monitorCriteriaInstance: MonitorCriteriaInstance =
         new MonitorCriteriaInstance();
@@ -462,6 +489,46 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       };
     }
 
+    if (arg.monitorType === MonitorType.Exceptions) {
+      monitorCriteriaInstance.data = {
+        id: ObjectID.generate().toString(),
+        monitorStatusId: arg.monitorStatusId,
+        filterCondition: FilterCondition.Any,
+        filters: [
+          {
+            checkOn: CheckOn.ExceptionCount,
+            filterType: FilterType.GreaterThan,
+            value: 0,
+          },
+        ],
+        incidents: [
+          {
+            title: `${arg.monitorName} has exceptions`,
+            description: `${arg.monitorName} has active exceptions.`,
+            incidentSeverityId: arg.incidentSeverityId,
+            autoResolveIncident: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        alerts: [
+          {
+            title: `${arg.monitorName} has exceptions`,
+            description: `${arg.monitorName} has active exceptions.`,
+            alertSeverityId: arg.alertSeverityId,
+            autoResolveAlert: true,
+            id: ObjectID.generate().toString(),
+            onCallPolicyIds: [],
+          },
+        ],
+        createAlerts: false,
+        changeMonitorStatus: true,
+        createIncidents: true,
+        name: `Check if ${arg.monitorName} has exceptions`,
+        description: `This criteria checks if the ${arg.monitorName} has exceptions.`,
+      };
+    }
+
     if (arg.monitorType === MonitorType.Metrics) {
       monitorCriteriaInstance.data = {
         id: ObjectID.generate().toString(),

package/Types/Monitor/MonitorStep.ts

@@ -23,6 +23,9 @@ import MonitorStepTraceMonitor, {
 import MonitorStepMetricMonitor, {
   MonitorStepMetricMonitorUtil,
 } from "./MonitorStepMetricMonitor";
+import MonitorStepExceptionMonitor, {
+  MonitorStepExceptionMonitorUtil,
+} from "./MonitorStepExceptionMonitor";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
 
 export interface MonitorStepType {
@@ -57,6 +60,9 @@ export interface MonitorStepType {
 
   // Metric Monitor
   metricMonitor: MonitorStepMetricMonitor | undefined;
+
+  // Exception monitor
+  exceptionMonitor?: MonitorStepExceptionMonitor | undefined;
 }
 
 export default class MonitorStep extends DatabaseProperty {
@@ -80,6 +86,7 @@ export default class MonitorStep extends DatabaseProperty {
       logMonitor: undefined,
       traceMonitor: undefined,
       metricMonitor: undefined,
+      exceptionMonitor: undefined,
     };
   }
 
@@ -108,6 +115,7 @@ export default class MonitorStep extends DatabaseProperty {
       logMonitor: undefined,
       traceMonitor: undefined,
       metricMonitor: undefined,
+      exceptionMonitor: undefined,
     };
 
     return monitorStep;
@@ -186,6 +194,13 @@ export default class MonitorStep extends DatabaseProperty {
     return this;
   }
 
+  public setExceptionMonitor(
+    exceptionMonitor: MonitorStepExceptionMonitor,
+  ): MonitorStep {
+    this.data!.exceptionMonitor = exceptionMonitor;
+    return this;
+  }
+
   public setCustomCode(customCode: string): MonitorStep {
     this.data!.customCode = customCode;
     return this;
@@ -212,6 +227,7 @@ export default class MonitorStep extends DatabaseProperty {
         screenSizeTypes: undefined,
         browserTypes: undefined,
         lgoMonitor: undefined,
+        exceptionMonitor: undefined,
       },
     };
   }
@@ -310,6 +326,12 @@ export default class MonitorStep extends DatabaseProperty {
                   MonitorStepTraceMonitorUtil.getDefault(),
               )
             : undefined,
+          exceptionMonitor: this.data.exceptionMonitor
+            ? MonitorStepExceptionMonitorUtil.toJSON(
+                this.data.exceptionMonitor ||
+                  MonitorStepExceptionMonitorUtil.getDefault(),
+              )
+            : undefined,
         },
       });
     }
@@ -408,6 +430,9 @@ export default class MonitorStep extends DatabaseProperty {
       traceMonitor: json["traceMonitor"]
         ? (json["traceMonitor"] as JSONObject)
         : undefined,
+      exceptionMonitor: json["exceptionMonitor"]
+        ? (json["exceptionMonitor"] as JSONObject)
+        : undefined,
     }) as any;
 
     if (monitorStep.data && !monitorStep.data?.logMonitor) {
@@ -423,6 +448,11 @@ export default class MonitorStep extends DatabaseProperty {
         MonitorStepMetricMonitorUtil.getDefault();
     }
 
+    if (monitorStep.data && !monitorStep.data?.exceptionMonitor) {
+      monitorStep.data.exceptionMonitor =
+        MonitorStepExceptionMonitorUtil.getDefault();
+    }
+
     return monitorStep;
   }
 

package/Types/Monitor/MonitorStepExceptionMonitor.ts

@@ -0,0 +1,94 @@
+import ExceptionInstance from "../../Models/AnalyticsModels/ExceptionInstance";
+import InBetween from "../BaseDatabase/InBetween";
+import Includes from "../BaseDatabase/Includes";
+import Query from "../BaseDatabase/Query";
+import Search from "../BaseDatabase/Search";
+import OneUptimeDate from "../Date";
+import { JSONObject } from "../JSON";
+import ObjectID from "../ObjectID";
+
+export default interface MonitorStepExceptionMonitor {
+  telemetryServiceIds: Array<ObjectID>;
+  exceptionTypes: Array<string>;
+  message: string;
+  includeResolved: boolean;
+  includeArchived: boolean;
+  lastXSecondsOfExceptions: number;
+}
+
+export class MonitorStepExceptionMonitorUtil {
+  public static toAnalyticsQuery(
+    monitorStepExceptionMonitor: MonitorStepExceptionMonitor,
+  ): Query<ExceptionInstance> {
+    const query: Query<ExceptionInstance> = {};
+
+    if (
+      monitorStepExceptionMonitor.telemetryServiceIds &&
+      monitorStepExceptionMonitor.telemetryServiceIds.length > 0
+    ) {
+      query.serviceId = new Includes(
+        monitorStepExceptionMonitor.telemetryServiceIds,
+      );
+    }
+
+    if (
+      monitorStepExceptionMonitor.exceptionTypes &&
+      monitorStepExceptionMonitor.exceptionTypes.length > 0
+    ) {
+      query.exceptionType = new Includes(
+        monitorStepExceptionMonitor.exceptionTypes,
+      );
+    }
+
+    if (monitorStepExceptionMonitor.message) {
+      query.message = new Search(monitorStepExceptionMonitor.message);
+    }
+
+    if (monitorStepExceptionMonitor.lastXSecondsOfExceptions) {
+      const endDate: Date = OneUptimeDate.getCurrentDate();
+      const startDate: Date = OneUptimeDate.addRemoveSeconds(
+        endDate,
+        monitorStepExceptionMonitor.lastXSecondsOfExceptions * -1,
+      );
+      query.time = new InBetween(startDate, endDate);
+    }
+
+    return query;
+  }
+
+  public static getDefault(): MonitorStepExceptionMonitor {
+    return {
+      telemetryServiceIds: [],
+      exceptionTypes: [],
+      message: "",
+      includeResolved: false,
+      includeArchived: false,
+      lastXSecondsOfExceptions: 60,
+    };
+  }
+
+  public static fromJSON(json: JSONObject): MonitorStepExceptionMonitor {
+    return {
+      telemetryServiceIds: ObjectID.fromJSONArray(
+        (json["telemetryServiceIds"] as Array<JSONObject>) || [],
+      ),
+      exceptionTypes: (json["exceptionTypes"] as Array<string>) || [],
+      message: (json["message"] as string) || "",
+      includeResolved: Boolean(json["includeResolved"]) || false,
+      includeArchived: Boolean(json["includeArchived"]) || false,
+      lastXSecondsOfExceptions:
+        (json["lastXSecondsOfExceptions"] as number | undefined) || 60,
+    };
+  }
+
+  public static toJSON(monitor: MonitorStepExceptionMonitor): JSONObject {
+    return {
+      telemetryServiceIds: ObjectID.toJSONArray(monitor.telemetryServiceIds),
+      exceptionTypes: monitor.exceptionTypes,
+      message: monitor.message,
+      includeResolved: monitor.includeResolved,
+      includeArchived: monitor.includeArchived,
+      lastXSecondsOfExceptions: monitor.lastXSecondsOfExceptions,
+    };
+  }
+}

package/Types/Monitor/MonitorType.ts

@@ -20,6 +20,7 @@ enum MonitorType {
   Logs = "Logs",
   Metrics = "Metrics",
   Traces = "Traces",
+  Exceptions = "Exceptions",
 }
 
 export default MonitorType;
@@ -35,7 +36,8 @@ export class MonitorTypeHelper {
     return (
       monitorType === MonitorType.Logs ||
       monitorType === MonitorType.Metrics ||
-      monitorType === MonitorType.Traces
+      monitorType === MonitorType.Traces ||
+      monitorType === MonitorType.Exceptions
     );
   }
 
@@ -123,6 +125,12 @@ export class MonitorTypeHelper {
         title: "Logs",
         description: "This monitor type lets you monitor logs from any source.",
       },
+      {
+        monitorType: MonitorType.Exceptions,
+        title: "Exceptions",
+        description:
+          "This monitor type lets you monitor exceptions and error groups from any source.",
+      },
       {
         monitorType: MonitorType.Traces,
         title: "Traces",
@@ -198,6 +206,7 @@ export class MonitorTypeHelper {
       MonitorType.Logs,
       MonitorType.Metrics,
       MonitorType.Traces,
+      MonitorType.Exceptions,
     ];
   }
 

package/Types/Telemetry/TelemetryQuery.ts

@@ -3,9 +3,10 @@ import Span from "../../Models/AnalyticsModels/Span";
 import Query from "../BaseDatabase/Query";
 import MetricViewData from "../Metrics/MetricViewData";
 import TelemetryType from "./TelemetryType";
+import ExceptionInstance from "../../Models/AnalyticsModels/ExceptionInstance";
 
 export interface TelemetryQuery {
   telemetryType: TelemetryType;
-  telemetryQuery: Query<Log> | Query<Span> | null;
+  telemetryQuery: Query<Log> | Query<Span> | Query<ExceptionInstance> | null;
   metricViewData: MetricViewData | null;
 }

package/Types/Telemetry/TelemetryType.ts

@@ -2,6 +2,7 @@ enum TelemetryType {
   Metric = "Metric",
   Trace = "Trace",
   Log = "Log",
+  Exception = "Exception",
 }
 
 export default TelemetryType;

package/build/dist/Server/Utils/Monitor/Criteria/CompareCriteria.js

@@ -451,7 +451,12 @@ export default class CompareCriteria {
             return "unknown";
         }
         if (typeof value === Typeof.Number) {
-            return value.toFixed(2);
+            const numericValue = value;
+            if (Number.isInteger(numericValue)) {
+                return numericValue.toString();
+            }
+            const roundedValue = Number(numericValue.toFixed(2));
+            return roundedValue.toString();
         }
         if (typeof value === Typeof.Boolean) {
             return value ? "true" : "false";