@oneuptime/common 10.0.63 → 10.0.66

package/Types/Trace/TraceAggregationType.ts

@@ -0,0 +1,17 @@
+/*
+ * Span aggregation options for Trace Recording Rules.
+ * Duration-based aggregations return seconds (durationUnixNano / 1e9) so rule
+ * expressions stay in human-friendly units.
+ */
+enum TraceAggregationType {
+  Count = "Count",
+  ErrorCount = "ErrorCount",
+  AvgDurationSeconds = "AvgDurationSeconds",
+  P50DurationSeconds = "P50DurationSeconds",
+  P95DurationSeconds = "P95DurationSeconds",
+  P99DurationSeconds = "P99DurationSeconds",
+  MaxDurationSeconds = "MaxDurationSeconds",
+  MinDurationSeconds = "MinDurationSeconds",
+}
+
+export default TraceAggregationType;

package/Types/Trace/TraceDropFilterAction.ts

@@ -0,0 +1,6 @@
+enum TraceDropFilterAction {
+  Drop = "drop",
+  Sample = "sample",
+}
+
+export default TraceDropFilterAction;

package/Types/Trace/TracePipelineProcessorType.ts

@@ -0,0 +1,56 @@
+enum TracePipelineProcessorType {
+  AttributeRemapper = "AttributeRemapper",
+  SpanNameRemapper = "SpanNameRemapper",
+  StatusRemapper = "StatusRemapper",
+  SpanKindRemapper = "SpanKindRemapper",
+  CategoryProcessor = "CategoryProcessor",
+}
+
+export interface AttributeRemapperConfig {
+  sourceKey: string;
+  targetKey: string;
+  preserveSource?: boolean;
+  overrideOnConflict?: boolean;
+}
+
+export interface SpanNameRemapperConfig {
+  sourceKey: string;
+  mappings: Array<{
+    matchValue: string;
+    newName: string;
+  }>;
+}
+
+export interface StatusRemapperConfig {
+  sourceKey: string;
+  mappings: Array<{
+    matchValue: string;
+    statusCode: number;
+    statusMessage?: string;
+  }>;
+}
+
+export interface SpanKindRemapperConfig {
+  sourceKey: string;
+  mappings: Array<{
+    matchValue: string;
+    kind: string;
+  }>;
+}
+
+export interface CategoryProcessorConfig {
+  targetKey: string;
+  categories: Array<{
+    name: string;
+    filterQuery: string;
+  }>;
+}
+
+export type TracePipelineProcessorConfig =
+  | AttributeRemapperConfig
+  | SpanNameRemapperConfig
+  | StatusRemapperConfig
+  | SpanKindRemapperConfig
+  | CategoryProcessorConfig;
+
+export default TracePipelineProcessorType;

package/Types/Trace/TraceRecordingRuleDefinition.ts

@@ -0,0 +1,218 @@
+import TraceAggregationType from "./TraceAggregationType";
+
+/*
+ * A single source for a Trace Recording Rule — queries the Span table with
+ * the given aggregation, filtered by optional span-name regex and attribute
+ * match. Each source is aliased (A, B, C, ...) and referenced from the rule's
+ * expression string.
+ */
+export interface TraceRecordingRuleSource {
+  alias: string;
+  aggregationType: TraceAggregationType;
+  // Optional filters — ANDed together.
+  spanNameRegex?: string;
+  spanKind?: string;
+  onlyErrors?: boolean;
+  filterAttributeKey?: string;
+  filterAttributeValue?: string;
+}
+
+/*
+ * Full stored definition of a Trace Recording Rule. Persisted as JSONB so new
+ * fields can be added without migrating Postgres.
+ */
+export default interface TraceRecordingRuleDefinition {
+  sources: Array<TraceRecordingRuleSource>;
+  /*
+   * Arithmetic expression using aliases. Operators: + - * /, parentheses,
+   * numeric literals. Example: "A / B * 100" for error rate.
+   */
+  expression: string;
+  /*
+   * Optional attribute key (e.g. "service.name") to group by — one derived
+   * data point per group per evaluation bucket.
+   */
+  groupByAttribute?: string;
+}
+
+// Maximum number of sources per rule — bounds per-cron workload.
+export const TRACE_RECORDING_RULE_MAX_SOURCES: number = 4;
+
+// Maximum expression length — prevents pathological parser input.
+export const TRACE_RECORDING_RULE_MAX_EXPRESSION_LENGTH: number = 500;
+
+/*
+ * Alphabet used to generate source aliases. v1 caps at TRACE_RECORDING_RULE_MAX_SOURCES
+ * so we never exceed the first few letters in practice.
+ */
+const ALIAS_ALPHABET: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+const ALIAS_REGEX: RegExp = /^[A-Z]$/;
+
+const EXPRESSION_REGEX: RegExp = /^[A-Z0-9+\-*/().\s]+$/;
+
+export class TraceRecordingRuleDefinitionUtil {
+  public static getAggregationOptions(): Array<{
+    value: TraceAggregationType;
+    label: string;
+    description: string;
+  }> {
+    return [
+      {
+        value: TraceAggregationType.Count,
+        label: "Count",
+        description: "Number of matching spans.",
+      },
+      {
+        value: TraceAggregationType.ErrorCount,
+        label: "Error Count",
+        description: "Spans with status = error.",
+      },
+      {
+        value: TraceAggregationType.AvgDurationSeconds,
+        label: "Avg Duration (s)",
+        description: "Average span duration in seconds.",
+      },
+      {
+        value: TraceAggregationType.P50DurationSeconds,
+        label: "p50 Duration (s)",
+        description: "Median span duration.",
+      },
+      {
+        value: TraceAggregationType.P95DurationSeconds,
+        label: "p95 Duration (s)",
+        description: "95th percentile span duration.",
+      },
+      {
+        value: TraceAggregationType.P99DurationSeconds,
+        label: "p99 Duration (s)",
+        description: "99th percentile span duration.",
+      },
+      {
+        value: TraceAggregationType.MaxDurationSeconds,
+        label: "Max Duration (s)",
+        description: "Longest span in the bucket.",
+      },
+      {
+        value: TraceAggregationType.MinDurationSeconds,
+        label: "Min Duration (s)",
+        description: "Shortest span in the bucket.",
+      },
+    ];
+  }
+
+  public static getSpanKindOptions(): Array<{ value: string; label: string }> {
+    return [
+      { value: "", label: "Any" },
+      { value: "SPAN_KIND_SERVER", label: "Server" },
+      { value: "SPAN_KIND_CLIENT", label: "Client" },
+      { value: "SPAN_KIND_PRODUCER", label: "Producer" },
+      { value: "SPAN_KIND_CONSUMER", label: "Consumer" },
+      { value: "SPAN_KIND_INTERNAL", label: "Internal" },
+    ];
+  }
+
+  public static getNextAlias(
+    sources: Array<TraceRecordingRuleSource> | undefined,
+  ): string {
+    const used: Set<string> = new Set<string>(
+      (sources || []).map((s: TraceRecordingRuleSource) => {
+        return s.alias;
+      }),
+    );
+    for (const letter of ALIAS_ALPHABET) {
+      if (!used.has(letter)) {
+        return letter;
+      }
+    }
+    return "A";
+  }
+
+  public static getEmptyDefinition(): TraceRecordingRuleDefinition {
+    return {
+      sources: [
+        {
+          alias: "A",
+          aggregationType: TraceAggregationType.Count,
+        },
+      ],
+      expression: "A",
+      groupByAttribute: "",
+    };
+  }
+
+  public static getValidationError(
+    definition: TraceRecordingRuleDefinition | undefined,
+  ): string | null {
+    if (!definition) {
+      return "Definition is required.";
+    }
+
+    const sources: Array<TraceRecordingRuleSource> = definition.sources || [];
+
+    if (sources.length === 0) {
+      return "Add at least one source.";
+    }
+
+    if (sources.length > TRACE_RECORDING_RULE_MAX_SOURCES) {
+      return `A rule can reference at most ${TRACE_RECORDING_RULE_MAX_SOURCES} sources.`;
+    }
+
+    const aliases: Set<string> = new Set<string>();
+    for (let i: number = 0; i < sources.length; i++) {
+      const source: TraceRecordingRuleSource = sources[i]!;
+      const prefix: string = `Source ${source.alias || `#${i + 1}`}: `;
+
+      if (!source.alias || !ALIAS_REGEX.test(source.alias)) {
+        return `${prefix}Alias must be a single uppercase letter A-Z.`;
+      }
+
+      if (aliases.has(source.alias)) {
+        return `${prefix}Duplicate alias. Each source must have a unique letter.`;
+      }
+      aliases.add(source.alias);
+
+      if (!source.aggregationType) {
+        return `${prefix}Aggregation type is required.`;
+      }
+
+      const hasFilterKey: boolean = Boolean(source.filterAttributeKey?.trim());
+      const hasFilterValue: boolean = Boolean(
+        source.filterAttributeValue?.trim(),
+      );
+
+      if (hasFilterKey !== hasFilterValue) {
+        return `${prefix}Attribute filter needs both a key and a value (or leave both empty).`;
+      }
+    }
+
+    const expression: string = (definition.expression || "").trim();
+
+    if (!expression) {
+      return "Expression is required.";
+    }
+
+    if (expression.length > TRACE_RECORDING_RULE_MAX_EXPRESSION_LENGTH) {
+      return `Expression must be ${TRACE_RECORDING_RULE_MAX_EXPRESSION_LENGTH} characters or fewer.`;
+    }
+
+    const referencedAliases: Set<string> = new Set<string>(
+      expression.match(/[A-Z]/g) || [],
+    );
+    for (const alias of referencedAliases) {
+      if (!aliases.has(alias)) {
+        return `Expression references alias '${alias}' which is not defined in sources.`;
+      }
+    }
+
+    if (referencedAliases.size === 0) {
+      return "Expression must reference at least one source alias (e.g. A, B).";
+    }
+
+    if (!EXPRESSION_REGEX.test(expression)) {
+      return "Expression may only contain aliases (A-Z), numbers, operators (+ - * /), parentheses, and spaces.";
+    }
+
+    return null;
+  }
+}

package/Types/Trace/TraceScrubAction.ts

@@ -0,0 +1,7 @@
+enum TraceScrubAction {
+  Mask = "mask",
+  Hash = "hash",
+  Redact = "redact",
+}
+
+export default TraceScrubAction;

package/Types/Trace/TraceScrubField.ts

@@ -0,0 +1,8 @@
+enum TraceScrubField {
+  Name = "name",
+  Attributes = "attributes",
+  Events = "events",
+  All = "all",
+}
+
+export default TraceScrubField;

package/Types/Trace/TraceScrubPatternType.ts

@@ -0,0 +1,10 @@
+enum TraceScrubPatternType {
+  Email = "email",
+  CreditCard = "creditCard",
+  SSN = "ssn",
+  PhoneNumber = "phoneNumber",
+  IPAddress = "ipAddress",
+  Custom = "custom",
+}
+
+export default TraceScrubPatternType;

package/UI/Components/BulkUpdate/BulkLabelActions.tsx

@@ -0,0 +1,288 @@
+import React, { ReactElement, useEffect, useState } from "react";
+
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Label from "../../../Models/DatabaseModels/Label";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import IconProp from "../../../Types/Icon/IconProp";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import ListResult from "../../../Types/BaseDatabase/ListResult";
+import ObjectID from "../../../Types/ObjectID";
+import API from "../../Utils/API/API";
+import ModelAPI from "../../Utils/ModelAPI/ModelAPI";
+import ProjectUtil from "../../Utils/Project";
+import { ButtonStyleType } from "../Button/Button";
+import BasicFormModal from "../FormModal/BasicFormModal";
+import FormFieldSchemaType from "../Forms/Types/FormFieldSchemaType";
+import {
+  BulkActionButtonSchema,
+  BulkActionFailed,
+  BulkActionOnClickProps,
+} from "./BulkUpdateForm";
+
+export interface BulkLabelActionsConfig<T extends BaseModel> {
+  modelType: { new (): T };
+}
+
+export interface BulkLabelActionsResult<T extends BaseModel> {
+  bulkActions: Array<BulkActionButtonSchema<T>>;
+  modals: ReactElement;
+}
+
+type BulkLabelMode = "add" | "remove";
+
+/**
+ * Reusable hook that provides "Add Labels" and "Remove Labels" bulk actions
+ * for any ModelTable whose model has a `labels` many-to-many relationship
+ * to the Label entity.
+ *
+ * Usage:
+ *   const { bulkActions, modals } = useBulkLabelActions({ modelType: Monitor });
+ *   <ModelTable bulkActions={{ buttons: [...bulkActions, ...] }} />
+ *   {modals}
+ */
+function useBulkLabelActions<T extends BaseModel>(
+  config: BulkLabelActionsConfig<T>,
+): BulkLabelActionsResult<T> {
+  const [labels, setLabels] = useState<Array<Label>>([]);
+  const [showAddModal, setShowAddModal] = useState<boolean>(false);
+  const [showRemoveModal, setShowRemoveModal] = useState<boolean>(false);
+  const [bulkActionProps, setBulkActionProps] =
+    useState<BulkActionOnClickProps<T> | null>(null);
+
+  useEffect(() => {
+    const fetchLabels: () => Promise<void> = async (): Promise<void> => {
+      try {
+        const result: ListResult<Label> = await ModelAPI.getList<Label>({
+          modelType: Label,
+          query: {
+            projectId: ProjectUtil.getCurrentProjectId()!,
+          },
+          limit: LIMIT_PER_PROJECT,
+          skip: 0,
+          select: {
+            _id: true,
+            name: true,
+            color: true,
+          },
+          sort: {
+            name: SortOrder.Ascending,
+          },
+        });
+        setLabels(result.data);
+      } catch {
+        // labels will remain empty; modal will show no options
+      }
+    };
+
+    fetchLabels();
+  }, []);
+
+  const applyLabels: (
+    labelIds: Array<string>,
+    mode: BulkLabelMode,
+  ) => Promise<void> = async (
+    labelIds: Array<string>,
+    mode: BulkLabelMode,
+  ): Promise<void> => {
+    if (!bulkActionProps) {
+      return;
+    }
+
+    const { items, onProgressInfo, onBulkActionStart, onBulkActionEnd } =
+      bulkActionProps;
+
+    // Close the form modal first so the progress modal is visible
+    setShowAddModal(false);
+    setShowRemoveModal(false);
+
+    onBulkActionStart();
+
+    const totalItems: Array<T> = [...items];
+    const inProgressItems: Array<T> = [...items];
+    const successItems: Array<T> = [];
+    const failedItems: Array<BulkActionFailed<T>> = [];
+
+    for (const item of totalItems) {
+      inProgressItems.splice(inProgressItems.indexOf(item), 1);
+
+      try {
+        if (!item.id) {
+          throw new BadDataException("Item ID not found");
+        }
+
+        /*
+         * Fetch current labels for this item so we can merge/subtract
+         * the selected label ids and avoid clobbering existing ones.
+         */
+        const currentItem: T | null = await ModelAPI.getItem<T>({
+          modelType: config.modelType,
+          id: item.id,
+          select: {
+            labels: {
+              _id: true,
+            },
+          } as any,
+        });
+
+        const existingLabelIds: Array<string> = (
+          ((currentItem as any)?.labels as Array<Label> | undefined) || []
+        )
+          .map((label: Label) => {
+            return label._id?.toString() || "";
+          })
+          .filter((id: string) => {
+            return id.length > 0;
+          });
+
+        let newLabelIds: Array<string>;
+
+        if (mode === "add") {
+          newLabelIds = Array.from(
+            new Set<string>([...existingLabelIds, ...labelIds]),
+          );
+        } else {
+          newLabelIds = existingLabelIds.filter((id: string) => {
+            return !labelIds.includes(id);
+          });
+        }
+
+        /*
+         * No-op short-circuit: if nothing changed, still report as success
+         * so the user sees the item as processed.
+         */
+        if (
+          newLabelIds.length === existingLabelIds.length &&
+          newLabelIds.every((id: string) => {
+            return existingLabelIds.includes(id);
+          })
+        ) {
+          successItems.push(item);
+        } else {
+          await ModelAPI.updateById<T>({
+            id: item.id as ObjectID,
+            modelType: config.modelType,
+            data: {
+              labels: newLabelIds,
+            } as any,
+          });
+          successItems.push(item);
+        }
+      } catch (err) {
+        failedItems.push({
+          item: item,
+          failedMessage: API.getFriendlyMessage(err),
+        });
+      }
+
+      onProgressInfo({
+        totalItems: totalItems,
+        failed: failedItems,
+        successItems: successItems,
+        inProgressItems: inProgressItems,
+      });
+    }
+
+    onBulkActionEnd();
+    setBulkActionProps(null);
+  };
+
+  const labelDropdownOptions: Array<{ label: string; value: string }> =
+    labels.map((label: Label) => {
+      return {
+        label: label.name || "",
+        value: label._id?.toString() || "",
+      };
+    });
+
+  const addLabelsAction: BulkActionButtonSchema<T> = {
+    title: "Add Labels",
+    buttonStyleType: ButtonStyleType.NORMAL,
+    icon: IconProp.Label,
+    onClick: async (actionProps: BulkActionOnClickProps<T>): Promise<void> => {
+      setBulkActionProps(actionProps);
+      setShowAddModal(true);
+    },
+  };
+
+  const removeLabelsAction: BulkActionButtonSchema<T> = {
+    title: "Remove Labels",
+    buttonStyleType: ButtonStyleType.NORMAL,
+    icon: IconProp.Close,
+    onClick: async (actionProps: BulkActionOnClickProps<T>): Promise<void> => {
+      setBulkActionProps(actionProps);
+      setShowRemoveModal(true);
+    },
+  };
+
+  const modals: ReactElement = (
+    <>
+      {showAddModal && (
+        <BasicFormModal
+          title="Add Labels"
+          description="Select labels to add to the selected items. Labels already attached to an item will be preserved."
+          onClose={() => {
+            setShowAddModal(false);
+            setBulkActionProps(null);
+          }}
+          submitButtonText="Add Labels"
+          onSubmit={async (formData: { labelIds: Array<string> }) => {
+            await applyLabels(formData.labelIds || [], "add");
+          }}
+          formProps={{
+            fields: [
+              {
+                field: {
+                  labelIds: true,
+                },
+                title: "Select Labels",
+                description:
+                  "These labels will be added to each selected item.",
+                fieldType: FormFieldSchemaType.MultiSelectDropdown,
+                required: true,
+                dropdownOptions: labelDropdownOptions,
+              },
+            ],
+          }}
+        />
+      )}
+
+      {showRemoveModal && (
+        <BasicFormModal
+          title="Remove Labels"
+          description="Select labels to remove from the selected items. Items that do not have any of these labels will be skipped."
+          onClose={() => {
+            setShowRemoveModal(false);
+            setBulkActionProps(null);
+          }}
+          submitButtonText="Remove Labels"
+          onSubmit={async (formData: { labelIds: Array<string> }) => {
+            await applyLabels(formData.labelIds || [], "remove");
+          }}
+          formProps={{
+            fields: [
+              {
+                field: {
+                  labelIds: true,
+                },
+                title: "Select Labels",
+                description:
+                  "These labels will be removed from each selected item.",
+                fieldType: FormFieldSchemaType.MultiSelectDropdown,
+                required: true,
+                dropdownOptions: labelDropdownOptions,
+              },
+            ],
+          }}
+        />
+      )}
+    </>
+  );
+
+  return {
+    bulkActions: [addLabelsAction, removeLabelsAction],
+    modals: modals,
+  };
+}
+
+export default useBulkLabelActions;

package/UI/Components/BulkUpdate/BulkUpdateForm.tsx

@@ -89,12 +89,20 @@ const BulkUpdateForm: <T extends GenericObject>(
   const showProgressInfo: GetReactElementFunction = (): ReactElement => {
     if (actionInProgress && progressInfo) {
       return (
-        <ProgressBar
-          count={progressInfo.successItems.length + progressInfo.failed.length}
-          totalCount={progressInfo.totalItems.length}
-          suffix={props.pluralLabel}
-          size={ProgressBarSize.Small}
-        />
+        <div className="space-y-4">
+          <p className="text-sm text-gray-500">
+            Please wait while the bulk action is being performed. This may take
+            a moment.
+          </p>
+          <ProgressBar
+            count={
+              progressInfo.successItems.length + progressInfo.failed.length
+            }
+            totalCount={progressInfo.totalItems.length}
+            suffix={props.pluralLabel}
+            size={ProgressBarSize.Small}
+          />
+        </div>
       );
     }