@oneuptime/common 12.0.24 → 12.0.26

package/Types/Workspace/NotificationRules/NotificationRuleCondition.ts

@@ -195,6 +195,7 @@ export class NotificationRuleConditionUtil {
       case NotificationRuleConditionCheckOn.AlertEpisodeLabels:
       case NotificationRuleConditionCheckOn.IncidentEpisodeLabels:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels:
+      case NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels:
       case NotificationRuleConditionCheckOn.Monitors:
         return true;
       default:
@@ -287,7 +288,8 @@ export class NotificationRuleConditionUtil {
       data.checkOn === NotificationRuleConditionCheckOn.AlertEpisodeLabels ||
       data.checkOn === NotificationRuleConditionCheckOn.IncidentEpisodeLabels ||
       data.checkOn ===
-        NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels
+        NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels ||
+      data.checkOn === NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels
     ) {
       return data.labels.map((label: Label) => {
         return {
@@ -386,6 +388,12 @@ export class NotificationRuleConditionUtil {
           NotificationRuleConditionCheckOn.MonitorLabels,
           NotificationRuleConditionCheckOn.Monitors,
         ];
+      case NotificationRuleEventType.OnCallDutyPolicy:
+        return [
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyName,
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription,
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+        ];
       default:
         return [];
     }
@@ -406,6 +414,8 @@ export class NotificationRuleConditionUtil {
       case NotificationRuleConditionCheckOn.IncidentEpisodeDescription:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceTitle:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceDescription:
+      case NotificationRuleConditionCheckOn.OnCallDutyPolicyName:
+      case NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription:
         return [
           ConditionType.EqualTo,
           ConditionType.NotEqualTo,
@@ -434,6 +444,7 @@ export class NotificationRuleConditionUtil {
       case NotificationRuleConditionCheckOn.IncidentLabels:
       case NotificationRuleConditionCheckOn.MonitorLabels:
       case NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels:
+      case NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels:
         return [
           ConditionType.ContainsAny,
           ConditionType.NotContains,

package/UI/Components/Dictionary/DictionaryFilterOperator.ts

@@ -4,6 +4,8 @@ import Search from "../../../Types/BaseDatabase/Search";
 import NotContains from "../../../Types/BaseDatabase/NotContains";
 import StartsWith from "../../../Types/BaseDatabase/StartsWith";
 import EndsWith from "../../../Types/BaseDatabase/EndsWith";
+import Wildcard from "../../../Types/BaseDatabase/Wildcard";
+import NotWildcard from "../../../Types/BaseDatabase/NotWildcard";
 import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
@@ -28,6 +30,8 @@ export enum DictionaryFilterOperator {
   NotContains = "NotContains",
   StartsWith = "StartsWith",
   EndsWith = "EndsWith",
+  Matches = "Matches",
+  NotMatches = "NotMatches",
   GreaterThan = "GreaterThan",
   LessThan = "LessThan",
   GreaterThanOrEqual = "GreaterThanOrEqual",
@@ -95,6 +99,16 @@ export const DICTIONARY_FILTER_OPERATOR_OPTIONS: ReadonlyArray<DictionaryFilterO
       label: "ends with",
       symbol: "ends with",
     },
+    {
+      operator: DictionaryFilterOperator.Matches,
+      label: "matches",
+      symbol: "matches",
+    },
+    {
+      operator: DictionaryFilterOperator.NotMatches,
+      label: "does not match",
+      symbol: "does not match",
+    },
     {
       operator: DictionaryFilterOperator.GreaterThan,
       label: "greater than",
@@ -143,6 +157,8 @@ export type DictionaryEntryValue =
   | NotContains<string>
   | StartsWith<string>
   | EndsWith<string>
+  | Wildcard<string>
+  | NotWildcard<string>
   | GreaterThan<number>
   | GreaterThanOrEqual<number>
   | LessThan<number>
@@ -152,6 +168,40 @@ export type DictionaryEntryValue =
   | Includes
   | IncludesNone;
 
+const GLOB_SEPARATOR: string = " OR ";
+
+type JoinGlobsFunction = (value: unknown) => string;
+
+const joinGlobs: JoinGlobsFunction = (value: unknown): string => {
+  const raw: unknown =
+    value instanceof Wildcard || value instanceof NotWildcard
+      ? value.values
+      : (value as { value?: unknown }).value;
+
+  if (Array.isArray(raw)) {
+    return raw
+      .map((glob: unknown) => {
+        return String(glob ?? "");
+      })
+      .join(GLOB_SEPARATOR);
+  }
+
+  return String(raw ?? "");
+};
+
+type SplitGlobsFunction = (value: string) => Array<string>;
+
+const splitGlobs: SplitGlobsFunction = (value: string): Array<string> => {
+  return value
+    .split(GLOB_SEPARATOR)
+    .map((glob: string) => {
+      return glob.trim();
+    })
+    .filter((glob: string) => {
+      return glob.length > 0;
+    });
+};
+
 export const getOperatorOption: (
   operator: DictionaryFilterOperator,
 ) => DictionaryFilterOperatorOption = (
@@ -331,6 +381,30 @@ export const detectOperatorFromValue: (
       rawValue: wrapperValue,
     };
   }
+  /*
+   * A wildcard carries an ARRAY of globs (one operator can express an OR),
+   * so its payload is joined for the single-value input the form renders.
+   * Round-tripping through that input keeps the disjunction: the builder
+   * splits on the same separator.
+   */
+  if (
+    value instanceof Wildcard ||
+    matchesObjectType(value, ObjectType.Wildcard)
+  ) {
+    return {
+      operator: DictionaryFilterOperator.Matches,
+      rawValue: joinGlobs(value),
+    };
+  }
+  if (
+    value instanceof NotWildcard ||
+    matchesObjectType(value, ObjectType.NotWildcard)
+  ) {
+    return {
+      operator: DictionaryFilterOperator.NotMatches,
+      rawValue: joinGlobs(value),
+    };
+  }
   if (
     value instanceof GreaterThan ||
     matchesObjectType(value, ObjectType.GreaterThan)
@@ -434,6 +508,15 @@ export const buildDictionaryValue: (input: {
       return new StartsWith<string>(trimmed);
     case DictionaryFilterOperator.EndsWith:
       return new EndsWith<string>(trimmed);
+    /*
+     * A glob, e.g. `api-*`. The pattern translation happens at compile time
+     * (Wildcard.toPatterns), so what is stored stays readable and can be
+     * re-rendered into this same input.
+     */
+    case DictionaryFilterOperator.Matches:
+      return new Wildcard<string>(splitGlobs(trimmed));
+    case DictionaryFilterOperator.NotMatches:
+      return new NotWildcard<string>(splitGlobs(trimmed));
     case DictionaryFilterOperator.GreaterThan:
       return new GreaterThan<number>(Number(trimmed));
     case DictionaryFilterOperator.GreaterThanOrEqual:

package/UI/Components/Icon/Icon.tsx

@@ -397,12 +397,39 @@ const Icon: FunctionComponent<ComponentProps> = ({
      * alone is what everybody already reads as edit, and it survives being
      * small. IconProp.PencilSquare still draws the composite for the handful of
      * places that want it.
+     *
+     * DRAWN AT 80% OF THE UPSTREAM HEROICON, and that is the whole point of
+     * this path existing rather than the stock one.
+     *
+     * Every icon here shares a 24x24 box, but the eye does not measure the
+     * box - it measures the ink. Heroicons' pencil is one unbroken diagonal
+     * from corner to corner, so its ink ran 26.8 units end to end: the
+     * longest stroke of any icon in this file, against a median of 21 and
+     * against the 20.5 of the Trash and the 19.9 of the List it sits beside
+     * in a table row. At the 20px a Button renders it at, that is a 22px
+     * stroke inside a 20px box - it overshot the cap height of its own label
+     * and read as a size larger than every button next to it.
+     *
+     * (Those figures are the longest distance across each glyph's drawn ink,
+     * with arcs and curves sampled. Common/Tests/UI/Components/
+     * IconOpticalSize.test.tsx measures the same quantity from the path
+     * VERTICES alone, which under-reads every icon by a fraction of a unit -
+     * so its numbers are smaller than these and its comparison is relative
+     * rather than absolute.)
+     *
+     * Scaling by 0.8 about the centre of the box brings the ink to 21.4 -
+     * between Trash and Copy, at the median - while keeping the glyph
+     * itself untouched: a uniform scale preserves the arc flags, the 45
+     * degree barrel, and the tangency of the nib and eraser arcs. The
+     * numbers stay exact (radii 1.5 and 3.6, tip at 4.2 19.8), and the
+     * stroke width deliberately does NOT scale, so the pencil keeps the same
+     * weight as its neighbours instead of thinning out.
      */
     return getSvgWrapper(
       <path
         strokeLinecap="round"
         strokeLinejoin="round"
-        d="M16.862 4.487l1.687-1.688a1.875 1.875 0 112.652 2.652L6.832 19.82a4.5 4.5 0 01-1.897 1.13l-2.685.8.8-2.685a4.5 4.5 0 011.13-1.897L16.863 4.487zm0 0L19.5 7.125"
+        d="M15.89 5.99l1.35-1.35a1.5 1.5 0 112.122 2.122L7.866 18.256a3.6 3.6 0 01-1.518.904l-2.148.64.64-2.148a3.6 3.6 0 01.904-1.518L15.89 5.99zm0 0L18 8.1"
       />,
     );
   } else if (icon === IconProp.Equals) {

package/UI/Components/LogsViewer/components/LogSearchBar.tsx

@@ -58,12 +58,23 @@ const LogSearchBar: React.ForwardRefExoticComponent<
 
     const currentWord: string = extractCurrentWord(props.value);
 
-    // Strip leading "@" — treat it as a trigger character for suggestions
-    const hasAtPrefix: boolean = currentWord.startsWith("@");
-    const normalizedWord: string = hasAtPrefix
+    /*
+     * A leading `-` negates the whole term. It is stripped before the `@`
+     * check so `-@http.method:GET` still reads as an attribute for the
+     * suggestion dropdown, and remembered so Enter can decline to build a
+     * chip out of it.
+     */
+    const isNegatedWord: boolean = currentWord.startsWith("-");
+    const unnegatedWord: string = isNegatedWord
       ? currentWord.substring(1)
       : currentWord;
 
+    // Strip leading "@" — treat it as a trigger character for suggestions
+    const hasAtPrefix: boolean = unnegatedWord.startsWith("@");
+    const normalizedWord: string = hasAtPrefix
+      ? unnegatedWord.substring(1)
+      : unnegatedWord;
+
     // Determine if we're in "field:value" mode or "field name" mode
     const colonIndex: number = normalizedWord.indexOf(":");
     const isValueMode: boolean = colonIndex > 0;
@@ -150,9 +161,19 @@ const LogSearchBar: React.ForwardRefExoticComponent<
               return;
             }
 
-            // If in value mode with a typed value, apply as a chip
+            /*
+             * In value mode with a typed value, apply it as a chip — the
+             * chip is compiled with the same search grammar as the raw
+             * query string, so `@platform.team:a*` stays a prefix match.
+             *
+             * A negated token (`-severity:debug`) is the one shape a chip
+             * cannot carry: the chip's key would be the literal
+             * "-severity". Those fall through to a plain submit, where the
+             * parser reads the `-` as the negation it is.
+             */
             if (
               isValueMode &&
+              !isNegatedWord &&
               partialValue.length > 0 &&
               props.onFieldValueSelect
             ) {
@@ -225,6 +246,7 @@ const LogSearchBar: React.ForwardRefExoticComponent<
           selectedSuggestionIndex,
           filteredSuggestions,
           isValueMode,
+          isNegatedWord,
           fieldPrefix,
           partialValue,
           props,

package/UI/Components/LogsViewer/components/LogSearchHelp.tsx

@@ -10,6 +10,12 @@ interface HelpRow {
   example: string;
 }
 
+/*
+ * The syntax table. Every row here is honoured by the shared search grammar
+ * in Common/Types/Telemetry/TelemetrySearchQuery — the help used to advertise
+ * a wildcard row whose own example ("service:api-*") matched nothing, so the
+ * rule is that a row is only listed once its behaviour is pinned by a test.
+ */
 const HELP_ROWS: Array<HelpRow> = [
   {
     syntax: "free text",
@@ -18,7 +24,7 @@ const HELP_ROWS: Array<HelpRow> = [
   },
   {
     syntax: '"quoted phrase"',
-    description: "Exact phrase match",
+    description: "Keep spaces together",
     example: '"out of memory"',
   },
   {
@@ -36,29 +42,39 @@ const HELP_ROWS: Array<HelpRow> = [
     description: "Filter by trace ID",
     example: "trace:abc123def456",
   },
-  {
-    syntax: "span:<id>",
-    description: "Filter by span ID",
-    example: "span:e1f7f671fe78",
-  },
   {
     syntax: "@<attr>:<value>",
     description: "Filter by attribute",
     example: "@http.status_code:500",
   },
   {
-    syntax: "-field:value",
-    description: "Exclude matching logs",
-    example: "-severity:debug",
+    syntax: "@<attr>:<value>*",
+    description: "Wildcard — * is any text, ? is one character",
+    example: "@platform.team:a*",
+  },
+  {
+    syntax: "@<attr>:*",
+    description: "Attribute is present",
+    example: "@user.id:*",
+  },
+  {
+    syntax: "@<attr>:~<text>",
+    description: "Attribute contains",
+    example: "@url.host:~internal",
+  },
+  {
+    syntax: "-<filter>",
+    description: "Exclude — works with every filter above",
+    example: "-@platform.team:a*",
   },
   {
-    syntax: "field:value*",
-    description: "Wildcard match",
-    example: "service:api-*",
+    syntax: "@<attr>:(a OR b)",
+    description: "Any of these values",
+    example: "@http.method:(GET OR POST)",
   },
   {
-    syntax: "@attr:>N",
-    description: "Numeric comparison",
+    syntax: "@<attr>:>N",
+    description: "Numeric comparison (also >=, <, <=)",
     example: "@duration:>1000",
   },
 ];
@@ -115,10 +131,12 @@ const LogSearchHelp: FunctionComponent<LogSearchHelpProps> = (
           <kbd className="rounded border border-gray-200 bg-gray-50 px-1 py-0.5 font-mono text-[10px]">
             Enter
           </kbd>{" "}
-          to search · Combine filters:{" "}
+          to search · Filters combine with AND ·{" "}
           <code className="font-mono text-[10px] text-gray-500">
             severity:error service:api &quot;timeout&quot;
-          </code>
+          </code>{" "}
+          · Use <code className="font-mono text-[10px]">\*</code> for a literal
+          asterisk
         </span>
       </div>
     </div>

package/UI/Components/TelemetryViewer/components/TelemetrySearchBar.tsx

@@ -88,11 +88,22 @@ const TelemetrySearchBar: React.ForwardRefExoticComponent<
 
     const currentWord: string = extractCurrentWord(props.value);
 
-    const hasAtPrefix: boolean = currentWord.startsWith("@");
-    const normalizedWord: string = hasAtPrefix
+    /*
+     * A leading `-` negates the whole term. It is stripped before the `@`
+     * check so `-@http.method:GET` still reads as an attribute for the
+     * suggestion dropdown, and remembered so Enter can decline to build a
+     * chip out of it — a chip's key would be the literal "-http.method".
+     */
+    const isNegatedWord: boolean = currentWord.startsWith("-");
+    const unnegatedWord: string = isNegatedWord
       ? currentWord.substring(1)
       : currentWord;
 
+    const hasAtPrefix: boolean = unnegatedWord.startsWith("@");
+    const normalizedWord: string = hasAtPrefix
+      ? unnegatedWord.substring(1)
+      : unnegatedWord;
+
     const colonIndex: number = normalizedWord.indexOf(":");
     const isValueMode: boolean = colonIndex > 0;
     /*
@@ -183,6 +194,7 @@ const TelemetrySearchBar: React.ForwardRefExoticComponent<
 
             if (
               isValueMode &&
+              !isNegatedWord &&
               partialValue.length > 0 &&
               props.onFieldValueSelect
             ) {
@@ -272,6 +284,7 @@ const TelemetrySearchBar: React.ForwardRefExoticComponent<
           selectedSuggestionIndex,
           filteredSuggestions,
           isValueMode,
+          isNegatedWord,
           fieldPrefix,
           partialValue,
           props,

package/Utils/Metrics/MetricExplorerUrl.ts

@@ -1,6 +1,9 @@
 import Dictionary from "../../Types/Dictionary";
 import Includes from "../../Types/BaseDatabase/Includes";
 import JSONFunctions from "../../Types/JSONFunctions";
+import QueryOperator from "../../Types/BaseDatabase/QueryOperator";
+import SerializableObjectDictionary from "../../Types/SerializableObjectDictionary";
+import { JSONObject } from "../../Types/JSON";
 import OneUptimeDate from "../../Types/Date";
 import MetricFormulaConfigData from "../../Types/Metrics/MetricFormulaConfigData";
 import MetricQueryConfigData, {
@@ -102,17 +105,22 @@ export interface SerializedMetricFormula {
 
 /*
  * One attribute filter value inside the serialized `metricQueries` param.
- * Scalars are equality filters; Includes is the "any of" membership the
- * UI's operator layer and the query layer both understand. It JSON-
- * serializes to {_type: "Includes", value: [...]} (its toJSON), which the
- * parse side rebuilds into a real instance — that round trip is how a
- * multi-service scope survives Copy Link and saved views.
+ * Scalars are equality filters; every other operator (Includes, Search,
+ * Wildcard, NotEqual, GreaterThan, ...) travels as its own
+ * {_type, value} JSON and is rebuilt into a real instance on the way back —
+ * that round trip is how a multi-service scope, or a `matches api-*` filter,
+ * survives Copy Link and saved views.
+ *
+ * This used to keep ONLY scalars and Includes, so every other operator was
+ * silently dropped from a copied link: the chart the recipient opened had
+ * fewer filters than the one that was shared, with nothing to say so.
  */
 export type SerializedMetricAttributeValue =
   | string
   | number
   | boolean
-  | Includes;
+  | Includes
+  | QueryOperator<string>;
 
 const MAX_SERVICES_PARAM_ENTRIES: number = 20;
 
@@ -654,25 +662,79 @@ export default class MetricExplorerUrl {
       }
 
       /*
-       * "Any of" membership filters. Live view state holds Includes
-       * INSTANCES; parsed URLs hold the plain {_type, value} JSON shape.
-       * Both normalize to a fresh instance so multi-value filters (e.g.
-       * a multi-service scope) survive Copy Link / saved views instead
-       * of being silently dropped — and downstream consumers (the query
-       * layer, the operator detector, the monitor evaluator's deep-link
-       * builder) all already speak Includes.
+       * Operator filters. Live view state holds INSTANCES; a parsed URL holds
+       * the plain {_type, value} JSON shape. Both normalize to a fresh
+       * instance, so the filter means the same thing on both sides of a Copy
+       * Link — and the downstream consumers (the query layer, the operator
+       * detector, the monitor evaluator's deep-link builder) all speak
+       * operator instances already.
+       *
+       * An empty membership list is the one shape that is dropped: it means
+       * "All", and carrying it would only add a no-op predicate.
+       */
+      /*
+       * Membership keeps its own branch because it also CLEANS: blank and
+       * non-scalar entries are dropped, and a list left empty by that means
+       * "All" and carries no predicate at all.
        */
       const membershipValues: Array<string> | null =
         MetricExplorerUrl.getIncludesShapeValues(attributeValue);
 
-      if (membershipValues !== null && membershipValues.length > 0) {
-        attributes[key] = new Includes(membershipValues);
+      if (membershipValues !== null) {
+        if (membershipValues.length > 0) {
+          attributes[key] = new Includes(membershipValues);
+        }
+
+        continue;
+      }
+
+      if (attributeValue instanceof QueryOperator) {
+        attributes[key] = attributeValue as QueryOperator<string>;
+        continue;
+      }
+
+      const rebuilt: QueryOperator<string> | null =
+        MetricExplorerUrl.rebuildOperator(attributeValue);
+
+      if (rebuilt) {
+        attributes[key] = rebuilt;
       }
     }
 
     return attributes;
   }
 
+  /*
+   * Rebuild a `{_type, value}` JSON blob into its operator instance, using the
+   * same registry `JSONFunctions.deserialize` uses. An unknown `_type` yields
+   * null rather than a half-hydrated object — a plain object reaching the
+   * query layer is a silently wrong filter, not an error.
+   */
+  private static rebuildOperator(value: unknown): QueryOperator<string> | null {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+
+    const type: unknown = (value as Record<string, unknown>)["_type"];
+
+    if (typeof type !== "string" || !SerializableObjectDictionary[type]) {
+      return null;
+    }
+
+    try {
+      const hydrated: unknown = SerializableObjectDictionary[type].fromJSON(
+        value as JSONObject,
+      );
+
+      return hydrated instanceof QueryOperator
+        ? (hydrated as QueryOperator<string>)
+        : null;
+    } catch {
+      // Malformed payload in a hand-edited URL. Drop the filter, not the page.
+      return null;
+    }
+  }
+
   private static getIncludesShapeValues(value: unknown): Array<string> | null {
     let rawValues: unknown = null;