@oneuptime/common 14.0.5 → 14.0.6

package/Server/Services/MetricService.ts

@@ -952,7 +952,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
    *
    * For non-percentile aggregations (Sum/Avg/Min/Max/Count) we delegate
    * to the base implementation. For percentile aggregations
-   * (P50/P90/P95/P99) we build a subquery that fans each metric row out
+   * (P50/P75/P90/P95/P99) we build a subquery that fans each metric row out
    * into one or more `(midpoint, weight)` samples — derived from
    * histogram buckets when present — and then runs
    * `quantileExactWeighted` over the fanned-out distribution. This means

package/Server/Types/Database/QueryHelper.ts

@@ -9,7 +9,10 @@ import { FindOperator, Raw } from "typeorm";
 import { FindWhereProperty } from "../../../Types/BaseDatabase/Query";
 import { toLikePattern } from "../../../Types/BaseDatabase/WildcardPattern";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
-import buildJSONColumnQuery, { JSONColumnQuery } from "./JSONColumnQuery";
+import buildJSONColumnQuery, {
+  JSONColumnQuery,
+  escapeLikePattern,
+} from "./JSONColumnQuery";
 
 export type { FindOperator };
 
@@ -229,6 +232,56 @@ export default class QueryHelper {
     );
   }
 
+  /*
+   * Every word has to appear somewhere in the column, in any order.
+   *
+   * `search` is one substring, so "michigan 104822" misses a row called
+   * "Unit 104822 - Michigan Ave" even though both words are in it. Here each
+   * word gets its own ILIKE, AND-joined, which is how people recall a name
+   * they half remember.
+   *
+   * A word is matched literally: a `%` or `_` somebody typed is escaped
+   * rather than read as a wildcard.
+   *
+   * No words matches NOTHING. An AND over zero predicates is vacuously true,
+   * and "every row in the table" is never what an empty search box meant.
+   */
+  @CaptureSpan()
+  public static searchAllWords(words: Array<string>): FindWhereProperty<any> {
+    const rids: Array<string> = [];
+    const valuesObj: Dictionary<string> = {};
+
+    for (const word of words) {
+      const trimmed: string = (word || "").trim();
+      if (!trimmed) {
+        continue;
+      }
+      const rid: string = Text.generateRandomText(10);
+      rids.push(rid);
+      valuesObj[rid] = `%${escapeLikePattern(trimmed)}%`;
+    }
+
+    if (rids.length === 0) {
+      return Raw(() => {
+        return `TRUE = FALSE`; // this will always return false
+      }, {});
+    }
+
+    return Raw(
+      (alias: string) => {
+        const conditions: string = rids
+          .map((rid: string) => {
+            return `CAST(${alias} AS TEXT) ILIKE :${rid}`;
+          })
+          .join(" AND ");
+        return `(${conditions})`;
+      },
+      {
+        ...valuesObj,
+      },
+    );
+  }
+
   /**
    * Searches the provided entity property names with a single OR-joined ILIKE.
    *

package/Server/Utils/AI/Toolbox/MetricTools.ts

@@ -49,7 +49,7 @@ const METRIC_READ_PERMISSIONS: Array<Permission> = [
 export const QueryMetricsTool: ObservabilityTool = {
   name: "query_metrics",
   description:
-    "Aggregate a metric over time: Avg, Max, Min, Sum, Count or P50/P90/P95/P99 percentiles (histogram-aware). Requires the exact metric name — discover names via lookup_context. Monitor metrics use reserved names like oneuptime.monitor.response.time with the monitor's ID as entityId.",
+    "Aggregate a metric over time: Avg, Max, Min, Sum, Count or P50/P75/P90/P95/P99 percentiles (histogram-aware). Requires the exact metric name — discover names via lookup_context. Monitor metrics use reserved names like oneuptime.monitor.response.time with the monitor's ID as entityId.",
   inputSchema: {
     type: "object",
     properties: {
@@ -60,7 +60,18 @@ export const QueryMetricsTool: ObservabilityTool = {
       },
       aggregationType: {
         type: "string",
-        enum: ["Avg", "Max", "Min", "Sum", "Count", "P50", "P90", "P95", "P99"],
+        enum: [
+          "Avg",
+          "Max",
+          "Min",
+          "Sum",
+          "Count",
+          "P50",
+          "P75",
+          "P90",
+          "P95",
+          "P99",
+        ],
         description: "How to aggregate (default Avg).",
       },
       entityId: {

package/Server/Utils/AI/Toolbox/ResourceTools.ts

@@ -673,7 +673,18 @@ export const QueryResourceTelemetryTool: ObservabilityTool = {
       },
       aggregationType: {
         type: "string",
-        enum: ["Avg", "Min", "Max", "Sum", "Count", "P50", "P90", "P95", "P99"],
+        enum: [
+          "Avg",
+          "Min",
+          "Max",
+          "Sum",
+          "Count",
+          "P50",
+          "P75",
+          "P90",
+          "P95",
+          "P99",
+        ],
         description:
           "Metric aggregation (defaultAvg); counter sums are exported values, not derived rates.",
       },

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -1938,7 +1938,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
      * EXAMPLE:
      * SELECT sum(Metric.value) as avg_value, date_trunc('hour', toStartOfInterval(createdAt, INTERVAL 1 hour)) as createdAt
      *
-     * Percentile aggregations (P50/P90/P95/P99) compile to ClickHouse's
+     * Percentile aggregations (P50/P75/P90/P95/P99) compile to ClickHouse's
      * `quantile(level)(column)`. This is the right thing for scalar
      * columns (Span.duration, Metric.value when the metric is a Sum or
      * Gauge, etc.). MetricService overrides this method when it has

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

@@ -280,6 +280,39 @@ export default class CompareCriteria {
     return threshold as number;
   }
 
+  /*
+   * A metric-value threshold as a number, fraction included.
+   *
+   * The criteria form saves what the user typed as a STRING, and
+   * convertToNumber's parseInt truncated it: "0.9" on a ratio metric was
+   * compared as 0 and fired on every non-zero sample, and "85.5" was
+   * compared as 85. Metric values are where a fractional threshold is the
+   * natural one to type (ratios, seconds, load averages), so they are
+   * parsed with parseFloat. Every other checkOn keeps convertToNumber.
+   *
+   * Anything that does not parse to a finite number is treated as missing,
+   * so the caller ignores the filter instead of comparing against NaN.
+   */
+  @CaptureSpan()
+  public static convertMetricThresholdToNumber(
+    threshold: string | number | undefined,
+  ): number | null {
+    if (threshold === undefined || threshold === null) {
+      return null;
+    }
+
+    const parsed: number =
+      typeof threshold === Typeof.String
+        ? parseFloat(threshold as string)
+        : (threshold as number);
+
+    if (typeof parsed !== Typeof.Number || !Number.isFinite(parsed)) {
+      return null;
+    }
+
+    return parsed;
+  }
+
   @CaptureSpan()
   public static checkEqualToOrNotEqualTo(data: {
     value: string | number;

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

@@ -180,9 +180,10 @@ export default class MetricMonitorCriteria {
     projectId: { toString(): string } | undefined;
     nativeUnitsByMetricName?: { [key: string]: string } | undefined;
   }): Promise<MetricSeriesEvaluationResult> {
-    const rawThreshold: number | null = CompareCriteria.convertToNumber(
-      input.criteriaFilter.value,
-    );
+    const rawThreshold: number | null =
+      CompareCriteria.convertMetricThresholdToNumber(
+        input.criteriaFilter.value,
+      );
 
     const metricAlias: string =
       input.criteriaFilter.metricMonitorOptions?.metricAlias || "";

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -4659,7 +4659,9 @@ ${contextBlock}
         .map((f: CriteriaFilter) => {
           return {
             filter: f,
-            threshold: CompareCriteria.convertToNumber(f.value) as number,
+            threshold: CompareCriteria.convertMetricThresholdToNumber(
+              f.value,
+            ) as number,
           };
         })
         .filter((f: { filter: CriteriaFilter; threshold: number | null }) => {