@oneuptime/common 12.0.33 → 13.0.0

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

@@ -199,6 +199,20 @@ export default class IncomingRequestCriteria {
       }
     }
 
+    /*
+     * Header names and values are compared case-insensitively, and BOTH
+     * sides are lower-cased for it.
+     *
+     * Only the observed side used to be: a filter typed as "X-Api-Key" (the
+     * spelling every HTTP client and every piece of documentation uses) was
+     * matched against a list that had already been lower-cased, so Contains
+     * could never fire and NotContains fired on every single request. The
+     * lower-casing of the observed side is what says the intent was
+     * case-insensitive; this is the other half of it.
+     */
+    const criteriaValueLowerCase: string | null =
+      typeof value === Typeof.String ? (value as string).toLowerCase() : null;
+
     if (input.criteriaFilter.checkOn === CheckOn.RequestHeader) {
       const headerKeys: Array<string> = Object.keys(
         (input.dataToProcess as IncomingMonitorRequest).requestHeaders || {},
@@ -208,14 +222,20 @@ export default class IncomingRequestCriteria {
 
       // contains
       if (input.criteriaFilter.filterType === FilterType.Contains) {
-        if (value && headerKeys && headerKeys.includes(value as string)) {
+        if (
+          criteriaValueLowerCase &&
+          headerKeys.includes(criteriaValueLowerCase)
+        ) {
           return `Request header contains ${value}.`;
         }
         return null;
       }
 
       if (input.criteriaFilter.filterType === FilterType.NotContains) {
-        if (value && headerKeys && !headerKeys.includes(value as string)) {
+        if (
+          criteriaValueLowerCase &&
+          !headerKeys.includes(criteriaValueLowerCase)
+        ) {
           return `Request header does not contain ${value}.`;
         }
         return null;
@@ -231,14 +251,20 @@ export default class IncomingRequestCriteria {
 
       // contains
       if (input.criteriaFilter.filterType === FilterType.Contains) {
-        if (value && headerValues && headerValues.includes(value as string)) {
+        if (
+          criteriaValueLowerCase &&
+          headerValues.includes(criteriaValueLowerCase)
+        ) {
           return `Request header value contains ${value}.`;
         }
         return null;
       }
 
       if (input.criteriaFilter.filterType === FilterType.NotContains) {
-        if (value && headerValues && !headerValues.includes(value as string)) {
+        if (
+          criteriaValueLowerCase &&
+          !headerValues.includes(criteriaValueLowerCase)
+        ) {
           return `Request header value does not contain ${value}.`;
         }
         return null;

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

@@ -26,6 +26,7 @@ import {
 } from "../../../../Types/Monitor/CriteriaFilter";
 import CaptureSpan from "../../Telemetry/CaptureSpan";
 import MetricUnitUtil from "../../../../Utils/MetricUnitUtil";
+import MetricValueFormatter from "../../../../Utils/Monitor/MetricValueFormatter";
 import MetricFormulaEvaluator from "../../../../Utils/Metrics/MetricFormulaEvaluator";
 import MetricBaselineService, {
   BaselineSummary,
@@ -369,6 +370,15 @@ export default class MetricMonitorCriteria {
         criteriaFilter: input.criteriaFilter,
         metricDisplayName: metricContext.metricName,
         unit: displayUnit,
+        /*
+         * Only a plain metric criteria has a real metric NAME —
+         * metricContext.metricName is the formula expression when the
+         * criteria targets a formula, and a formula ending in `_ratio`
+         * would trip the fraction heuristic into a 100× render.
+         */
+        metricName: metricContext.isFormula
+          ? undefined
+          : metricContext.metricName,
       });
 
     if (!comparisonMessage) {
@@ -989,13 +999,29 @@ export default class MetricMonitorCriteria {
             : "below";
 
     const sigmaAbs: number = Math.abs(firstBreach.sigma);
-    const unitSuffix: string = metricContext.unit
-      ? ` ${metricContext.unit}`
-      : "";
+
+    /*
+     * Same rendering as the breaching-samples table and the comparison
+     * sentence — an anomaly on a memory metric reads "1.07 GB", not
+     * "1073741824.000 By". σ is a count of standard deviations, not a
+     * quantity in the metric's unit, so it stays a bare number; the
+     * standard deviation itself is in the metric's unit and does not.
+     */
+    const inMetricUnit: (value: number) => string = (value: number): string => {
+      return MetricValueFormatter.format({
+        value: value,
+        unit: metricContext.unit,
+        // Formula expressions are not metric names — see the guard above.
+        metricName: metricContext.isFormula
+          ? undefined
+          : metricContext.metricName,
+      });
+    };
+
     const rootCause: string =
-      `${metricContext.metricName} value ${firstBreach.sample.value.toFixed(3)}${unitSuffix} ` +
+      `${metricContext.metricName} value ${inMetricUnit(firstBreach.sample.value)} ` +
       `is ${sigmaAbs.toFixed(2)}σ ${direction} the same-hour baseline ` +
-      `(mean ${baseline.mean.toFixed(3)}${unitSuffix}, σ ${baseline.stddev.toFixed(3)}${unitSuffix}, ` +
+      `(mean ${inMetricUnit(baseline.mean)}, σ ${inMetricUnit(baseline.stddev)}, ` +
       `${baseline.sampleCount} samples over ${baseline.windowDays} days, sensitivity ${sensitivity}).`;
 
     return {

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -26,6 +26,7 @@ import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
 import MonitorResourceContextUtil from "./MonitorResourceContext";
 import MonitorTemplateUtil from "./MonitorTemplateUtil";
+import SeriesContextEnricher from "./SeriesContextEnricher";
 import SeriesResourceLinker, {
   SeriesResolvedResourceIds,
 } from "./SeriesResourceLinker";
@@ -534,13 +535,35 @@ export default class MonitorAlert {
               seriesLabels,
             });
 
-          alert.title = MonitorTemplateUtil.processTemplateString({
-            value: criteriaAlert.title,
-            storageMap,
+          /*
+           * Render the criteria's template, then make it say WHICH
+           * series it is about.
+           *
+           * The criteria title is one fixed string shared by every
+           * series on the monitor, so without the enricher a cluster
+           * with fifty saturated pods produced fifty alerts whose
+           * titles were character-for-character identical - and the
+           * alert list, the Slack message and the phone notification
+           * all showed the same undifferentiated line. The enricher is
+           * a no-op when the monitor is not grouped, and when the
+           * rendered text already names the series (because the user
+           * put `{{seriesResourceSuffix}}` or the raw label variables
+           * in their own template).
+           */
+          alert.title = SeriesContextEnricher.enrichTitle({
+            title: MonitorTemplateUtil.processTemplateString({
+              value: criteriaAlert.title,
+              storageMap,
+            }),
+            seriesLabels,
           });
-          alert.description = MonitorTemplateUtil.processTemplateString({
-            value: criteriaAlert.description,
-            storageMap,
+          alert.description = SeriesContextEnricher.enrichDescription({
+            description: MonitorTemplateUtil.processTemplateString({
+              value: criteriaAlert.description,
+              storageMap,
+            }),
+            seriesLabels,
+            monitorType: input.monitor.monitorType,
           });
 
           /*