@oneuptime/common 10.8.2 → 11.0.1

package/Types/Monitor/MonitorStepMetricMonitor.ts

@@ -1,3 +1,6 @@
+import Metric from "../../Models/AnalyticsModels/Metric";
+import Includes from "../BaseDatabase/Includes";
+import Query from "../BaseDatabase/Query";
 import { JSONObject } from "../JSON";
 import MetricsViewConfig from "../Metrics/MetricsViewConfig";
 import RollingTime from "../RollingTime/RollingTime";
@@ -5,6 +8,13 @@ import RollingTime from "../RollingTime/RollingTime";
 export default interface MonitorStepMetricMonitor {
   metricViewConfig: MetricsViewConfig;
   rollingTime: RollingTime;
+  /*
+   * Stable telemetry entity keys (host / pod / container / ...) — scopes
+   * every metric query in this step to rows carrying any of these in their
+   * entityKeys column. Optional: monitors saved before this field existed
+   * have it undefined.
+   */
+  entityKeys?: Array<string> | undefined;
 }
 
 export class MonitorStepMetricMonitorUtil {
@@ -15,9 +25,26 @@ export class MonitorStepMetricMonitorUtil {
         formulaConfigs: [],
       },
       rollingTime: RollingTime.Past1Minute,
+      entityKeys: [],
     };
   }
 
+  /*
+   * Stamps the step's entity scope onto a per-queryConfig Query<Metric>.
+   * Compiles to hasAny(entityKeys, [...]) server-side. Undefined/empty is
+   * a no-op so monitors saved before the field existed are unaffected.
+   */
+  public static applyEntityScopeToQuery(
+    query: Query<Metric>,
+    monitor: MonitorStepMetricMonitor,
+  ): Query<Metric> {
+    if (monitor.entityKeys && monitor.entityKeys.length > 0) {
+      query.entityKeys = new Includes(monitor.entityKeys);
+    }
+
+    return query;
+  }
+
   public static fromJSON(json: JSONObject): MonitorStepMetricMonitor {
     return json as any as MonitorStepMetricMonitor;
   }

package/Types/Monitor/MonitorStepProfileMonitor.ts

@@ -12,6 +12,13 @@ export default interface MonitorStepProfileMonitor {
   attributes: Dictionary<string | number | boolean>;
   profileTypes: Array<string>;
   telemetryServiceIds: Array<ObjectID>;
+  /*
+   * Stable telemetry entity keys (host / pod / container / ...) — scopes
+   * the monitor to profiles carrying any of these in their entityKeys
+   * column. Optional: monitors saved before this field existed have it
+   * undefined.
+   */
+  entityKeys?: Array<string> | undefined;
   lastXSecondsOfProfiles: number;
   profileType: string;
 }
@@ -26,11 +33,19 @@ export class MonitorStepProfileMonitorUtil {
       monitorStepProfileMonitor.telemetryServiceIds &&
       monitorStepProfileMonitor.telemetryServiceIds.length > 0
     ) {
-      query.serviceId = new Includes(
+      query.primaryEntityId = new Includes(
         monitorStepProfileMonitor.telemetryServiceIds,
       );
     }
 
+    // Compiles to hasAny(entityKeys, [...]) server-side. Undefined/empty is a no-op.
+    if (
+      monitorStepProfileMonitor.entityKeys &&
+      monitorStepProfileMonitor.entityKeys.length > 0
+    ) {
+      query.entityKeys = new Includes(monitorStepProfileMonitor.entityKeys);
+    }
+
     if (
       monitorStepProfileMonitor.attributes &&
       Object.keys(monitorStepProfileMonitor.attributes).length > 0
@@ -67,6 +82,7 @@ export class MonitorStepProfileMonitorUtil {
       profileType: "",
       profileTypes: [],
       telemetryServiceIds: [],
+      entityKeys: [],
       lastXSecondsOfProfiles: 60,
     };
   }
@@ -80,6 +96,7 @@ export class MonitorStepProfileMonitorUtil {
       telemetryServiceIds: ObjectID.fromJSONArray(
         json["telemetryServiceIds"] as Array<JSONObject>,
       ),
+      entityKeys: (json["entityKeys"] as Array<string>) || [],
       lastXSecondsOfProfiles: json["lastXSecondsOfProfiles"] as number,
     };
   }
@@ -90,6 +107,7 @@ export class MonitorStepProfileMonitorUtil {
       profileType: monitor.profileType,
       profileTypes: monitor.profileTypes,
       telemetryServiceIds: ObjectID.toJSONArray(monitor.telemetryServiceIds),
+      entityKeys: monitor.entityKeys || [],
       lastXSecondsOfProfiles: monitor.lastXSecondsOfProfiles,
     };
   }

package/Types/Monitor/MonitorStepTraceMonitor.ts

@@ -12,6 +12,12 @@ export default interface MonitorStepTraceMonitor {
   attributes: Dictionary<string | number | boolean>;
   spanStatuses: Array<SpanStatus>;
   telemetryServiceIds: Array<ObjectID>;
+  /*
+   * Stable telemetry entity keys (host / pod / container / ...) — scopes
+   * the monitor to spans carrying any of these in their entityKeys column.
+   * Optional: monitors saved before this field existed have it undefined.
+   */
+  entityKeys?: Array<string> | undefined;
   lastXSecondsOfSpans: number;
   spanName: string;
 }
@@ -26,11 +32,19 @@ export class MonitorStepTraceMonitorUtil {
       monitorStepTraceMonitor.telemetryServiceIds &&
       monitorStepTraceMonitor.telemetryServiceIds.length > 0
     ) {
-      query.serviceId = new Includes(
+      query.primaryEntityId = new Includes(
         monitorStepTraceMonitor.telemetryServiceIds,
       );
     }
 
+    // Compiles to hasAny(entityKeys, [...]) server-side. Undefined/empty is a no-op.
+    if (
+      monitorStepTraceMonitor.entityKeys &&
+      monitorStepTraceMonitor.entityKeys.length > 0
+    ) {
+      query.entityKeys = new Includes(monitorStepTraceMonitor.entityKeys);
+    }
+
     if (
       monitorStepTraceMonitor.attributes &&
       Object.keys(monitorStepTraceMonitor.attributes).length > 0
@@ -67,6 +81,7 @@ export class MonitorStepTraceMonitorUtil {
       spanName: "",
       spanStatuses: [],
       telemetryServiceIds: [],
+      entityKeys: [],
       lastXSecondsOfSpans: 60,
     };
   }
@@ -80,6 +95,7 @@ export class MonitorStepTraceMonitorUtil {
       telemetryServiceIds: ObjectID.fromJSONArray(
         json["telemetryServiceIds"] as Array<JSONObject>,
       ),
+      entityKeys: (json["entityKeys"] as Array<string>) || [],
       lastXSecondsOfSpans: json["lastXSecondsOfSpans"] as number,
     };
   }
@@ -90,6 +106,7 @@ export class MonitorStepTraceMonitorUtil {
       spanName: monitor.spanName,
       spanStatuses: monitor.spanStatuses,
       telemetryServiceIds: ObjectID.toJSONArray(monitor.telemetryServiceIds),
+      entityKeys: monitor.entityKeys || [],
       lastXSecondsOfSpans: monitor.lastXSecondsOfSpans,
     };
   }

package/Types/Monitor/MonitorType.ts

@@ -106,7 +106,14 @@ export class MonitorTypeHelper {
           MonitorType.Metrics,
           MonitorType.Traces,
           MonitorType.Exceptions,
-          MonitorType.Profiles,
+          /*
+           * MonitorType.Profiles is intentionally not offered here: the
+           * dashboard has no configuration form for the profile monitor
+           * step, so a Profiles monitor created from this picker would have
+           * no profileMonitor config and could never evaluate. Existing
+           * Profiles monitors keep working — the enum value, its props in
+           * getAllMonitorTypeProps, and worker-side evaluation all remain.
+           */
         ],
       },
       {

package/Types/ObjectID.ts

@@ -52,6 +52,16 @@ export default class ObjectID extends DatabaseProperty {
     return new this(UUID.generate());
   }
 
+  /**
+   * Time-ordered id (RFC 9562 UUIDv7: 48-bit unix-ms prefix + random).
+   * Use for analytics-row `_id`s — time-ordered ids cluster ClickHouse
+   * inserts and compress dramatically better than random v4 UUIDs.
+   * Postgres entity ids keep using `generate()` (random v4).
+   */
+  public static generateTimeOrdered(): ObjectID {
+    return new this(UUID.generateTimeOrdered());
+  }
+
   public static toJSONArray(ids: Array<ObjectID>): Array<JSONObject> {
     if (!ids || ids.length === 0) {
       return [];

package/Types/Telemetry/EntityRelationshipType.ts

@@ -0,0 +1,31 @@
+/*
+ * The relationship taxonomy between OpenTelemetry entities. The upstream
+ * OTel spec deliberately leaves entity relationships unstandardized
+ * ("refined in future specification work"), so OneUptime infers a small,
+ * durable set of directed relationships from resource co-occurrence — the
+ * entities that appear together in one resource are, by construction,
+ * related. See Internal/Docs/OpenTelemetryEntities.md §4.
+ */
+enum EntityRelationshipType {
+  /** e.g. a pod runs on a node; a process runs on a host. */
+  RunsOn = "runs-on",
+  /** e.g. a pod / node / namespace is a member of a cluster. */
+  MemberOf = "member-of",
+  /** e.g. a service is hosted on a host. */
+  HostedOn = "hosted-on",
+  /** e.g. a container is part of a pod; a process is part of a container. */
+  PartOf = "part-of",
+  /** e.g. a service.instance is an instance of a service. */
+  InstanceOf = "instance-of",
+  /**
+   * Service → service dependency (the service map; the resurrected
+   * ServiceDependency capability). Unlike the co-occurrence types above,
+   * this is NOT inferred from one resource's entity set — caller and
+   * callee never share a resource. It is derived from parent/child span
+   * pairs that cross a service boundary (see the
+   * TelemetryEntity:ComputeServiceDependencies worker cron).
+   */
+  DependsOn = "depends-on",
+}
+
+export default EntityRelationshipType;

package/Types/Telemetry/EntityType.ts

@@ -0,0 +1,33 @@
+/*
+ * The vocabulary of OpenTelemetry-aligned entity types OneUptime can
+ * derive from a resource. One OTLP resource is a *composition* of many
+ * entities — a span can simultaneously belong to a `service`, a `host`,
+ * a `k8s.pod`, a `k8s.node`, a `k8s.cluster`, a `container` and a
+ * `process`. Each value is the entity's immutable `type` per the OTel
+ * entity data model (https://opentelemetry.io/docs/specs/otel/entities/).
+ *
+ * This is the broader *membership* vocabulary used by the `entityKeys`
+ * column on signals and by the `TelemetryEntity` registry. It is distinct
+ * from `ServiceType`, which is the narrower discriminator for a signal's
+ * single *primary* entity (`primaryEntityType`) and additionally covers
+ * OneUptime-specific primary owners (Monitor, RealUserMonitor, Unknown,
+ * ...) that are not OTel resource entities.
+ *
+ * The string values are the semconv-style dotted type names so they read
+ * naturally in stored identity sets and in the registry.
+ */
+enum EntityType {
+  Service = "service",
+  ServiceInstance = "service.instance",
+  Host = "host",
+  Container = "container",
+  Process = "process",
+  KubernetesCluster = "k8s.cluster",
+  KubernetesNamespace = "k8s.namespace",
+  KubernetesNode = "k8s.node",
+  KubernetesPod = "k8s.pod",
+  KubernetesDeployment = "k8s.deployment",
+  TelemetrySdk = "telemetry.sdk",
+}
+
+export default EntityType;

package/Types/Telemetry/TelemetrySavedViewState.ts

@@ -23,4 +23,6 @@ export default interface TelemetrySavedViewState {
   timeRange?: TelemetrySavedViewTimeRange | undefined;
   // Rows per page.
   pageSize?: number | undefined;
+  // Traces explorer: root-spans-only toggle (defaults to true when absent).
+  rootOnly?: boolean | undefined;
 }

package/Types/Text.ts

@@ -12,6 +12,40 @@ export default class Text {
     return hex;
   }
 
+  /**
+   * Matches an OTLP id already in hex form: 16 chars (8-byte span id)
+   * or 32 chars (16-byte trace/profile id).
+   */
+  private static readonly OTLP_HEX_ID_REGEX: RegExp =
+    /^(?:[0-9a-fA-F]{16}|[0-9a-fA-F]{32})$/;
+
+  /**
+   * Convert an OTLP wire id (trace / span / profile id) to lowercase hex.
+   *
+   * OTLP/protobuf carries ids as bytes, which protobuf decoders render
+   * as base64 strings — but OTLP/JSON carries the SAME fields as hex
+   * strings (32 chars for trace ids, 16 for span ids). Hex strings also
+   * satisfy the base64 alphabet, so feeding them to convertBase64ToHex
+   * would silently decode them into garbage bytes. Length disambiguates
+   * safely: the base64 form of an 8/16-byte id is always 12/24 chars,
+   * so a 16- or 32-char hex-only string can never be a base64 id.
+   */
+  public static convertOtlpIdToHex(value: string | undefined): string {
+    if (!value) {
+      return "";
+    }
+
+    if (Text.OTLP_HEX_ID_REGEX.test(value)) {
+      return value.toLowerCase();
+    }
+
+    try {
+      return Text.convertBase64ToHex(value);
+    } catch {
+      return "";
+    }
+  }
+
   public static getLetterFromAByNumber(number: number): string {
     return String.fromCharCode("a".charCodeAt(0) + number);
   }

package/Types/Trace/TraceAggregationType.ts

@@ -8,6 +8,7 @@ enum TraceAggregationType {
   ErrorCount = "ErrorCount",
   AvgDurationSeconds = "AvgDurationSeconds",
   P50DurationSeconds = "P50DurationSeconds",
+  P90DurationSeconds = "P90DurationSeconds",
   P95DurationSeconds = "P95DurationSeconds",
   P99DurationSeconds = "P99DurationSeconds",
   MaxDurationSeconds = "MaxDurationSeconds",

package/Types/Trace/TraceRecordingRuleDefinition.ts

@@ -6,6 +6,11 @@ import TraceAggregationType from "./TraceAggregationType";
  * match. Each source is aliased (A, B, C, ...) and referenced from the rule's
  * expression string.
  */
+export interface TraceRecordingRuleAttributeFilter {
+  key: string;
+  value: string;
+}
+
 export interface TraceRecordingRuleSource {
   alias: string;
   aggregationType: TraceAggregationType;
@@ -13,8 +18,16 @@ export interface TraceRecordingRuleSource {
   spanNameRegex?: string;
   spanKind?: string;
   onlyErrors?: boolean;
+  /*
+   * Legacy single attribute filter — superseded by `filterAttributes` but
+   * still honored for rules saved before multi-filter support. Use
+   * TraceRecordingRuleDefinitionUtil.getSourceAttributeFilters to read the
+   * combined set.
+   */
   filterAttributeKey?: string;
   filterAttributeValue?: string;
+  // Multiple attribute equality filters — ANDed (e.g. http.route AND url.host).
+  filterAttributes?: Array<TraceRecordingRuleAttributeFilter>;
 }
 
 /*
@@ -78,6 +91,11 @@ export class TraceRecordingRuleDefinitionUtil {
         label: "p50 Duration (s)",
         description: "Median span duration.",
       },
+      {
+        value: TraceAggregationType.P90DurationSeconds,
+        label: "p90 Duration (s)",
+        description: "90th percentile span duration.",
+      },
       {
         value: TraceAggregationType.P95DurationSeconds,
         label: "p95 Duration (s)",
@@ -112,6 +130,38 @@ export class TraceRecordingRuleDefinitionUtil {
     ];
   }
 
+  /*
+   * Combined attribute filters for a source: the multi-filter array plus the
+   * legacy single pair (deduplicated by key, array entries win).
+   */
+  public static getSourceAttributeFilters(
+    source: TraceRecordingRuleSource,
+  ): Array<TraceRecordingRuleAttributeFilter> {
+    const filters: Array<TraceRecordingRuleAttributeFilter> = [];
+    const seenKeys: Set<string> = new Set<string>();
+
+    for (const filter of source.filterAttributes || []) {
+      if (!filter || typeof filter !== "object") {
+        continue;
+      }
+      const key: string = (filter.key || "").trim();
+      const value: string = (filter.value || "").trim();
+      if (!key || !value || seenKeys.has(key)) {
+        continue;
+      }
+      seenKeys.add(key);
+      filters.push({ key, value });
+    }
+
+    const legacyKey: string = (source.filterAttributeKey || "").trim();
+    const legacyValue: string = (source.filterAttributeValue || "").trim();
+    if (legacyKey && legacyValue && !seenKeys.has(legacyKey)) {
+      filters.push({ key: legacyKey, value: legacyValue });
+    }
+
+    return filters;
+  }
+
   public static getNextAlias(
     sources: Array<TraceRecordingRuleSource> | undefined,
   ): string {
@@ -161,6 +211,12 @@ export class TraceRecordingRuleDefinitionUtil {
     const aliases: Set<string> = new Set<string>();
     for (let i: number = 0; i < sources.length; i++) {
       const source: TraceRecordingRuleSource = sources[i]!;
+
+      // Definitions arrive as JSON (deep links, API writes) — never throw.
+      if (!source || typeof source !== "object") {
+        return `Source #${i + 1}: Invalid source.`;
+      }
+
       const prefix: string = `Source ${source.alias || `#${i + 1}`}: `;
 
       if (!source.alias || !ALIAS_REGEX.test(source.alias)) {
@@ -184,6 +240,24 @@ export class TraceRecordingRuleDefinitionUtil {
       if (hasFilterKey !== hasFilterValue) {
         return `${prefix}Attribute filter needs both a key and a value (or leave both empty).`;
       }
+
+      if (
+        source.filterAttributes !== undefined &&
+        !Array.isArray(source.filterAttributes)
+      ) {
+        return `${prefix}Invalid attribute filters.`;
+      }
+
+      for (const filter of source.filterAttributes || []) {
+        if (!filter || typeof filter !== "object") {
+          return `${prefix}Invalid attribute filter row.`;
+        }
+        const hasKey: boolean = Boolean(filter.key?.trim());
+        const hasValue: boolean = Boolean(filter.value?.trim());
+        if (hasKey !== hasValue) {
+          return `${prefix}Attribute filter needs both a key and a value (or remove the row).`;
+        }
+      }
     }
 
     const expression: string = (definition.expression || "").trim();

package/UI/Components/ImportExport/ExportModelCard.tsx

@@ -0,0 +1,90 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import IconProp from "../../../Types/Icon/IconProp";
+import ObjectID from "../../../Types/ObjectID";
+import API from "../../Utils/API/API";
+import ModelAPI from "../../Utils/ModelAPI/ModelAPI";
+import ModelImportExportUtil from "../../Utils/ModelImportExport";
+import { ButtonStyleType } from "../Button/Button";
+import Card from "../Card/Card";
+import ConfirmModal from "../Modal/ConfirmModal";
+import React, { ReactElement, useState } from "react";
+
+export interface ComponentProps<TBaseModel extends BaseModel> {
+  modelType: { new (): TBaseModel };
+  modelId: ObjectID;
+  modelAPI?: typeof ModelAPI | undefined;
+}
+
+const ExportModelCard: <TBaseModel extends BaseModel>(
+  props: ComponentProps<TBaseModel>,
+) => ReactElement = <TBaseModel extends BaseModel>(
+  props: ComponentProps<TBaseModel>,
+): ReactElement => {
+  const model: TBaseModel = new props.modelType();
+  const singularName: string = model.singularName || "Resource";
+
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [error, setError] = useState<string>("");
+
+  type ExportItemFunction = () => Promise<void>;
+
+  const exportItem: ExportItemFunction = async (): Promise<void> => {
+    setIsLoading(true);
+
+    try {
+      const item: TBaseModel =
+        await ModelImportExportUtil.fetchItemForExport<TBaseModel>({
+          modelType: props.modelType,
+          modelId: props.modelId,
+          modelAPI: props.modelAPI,
+        });
+
+      ModelImportExportUtil.downloadExportFile({
+        modelType: props.modelType,
+        items: [item],
+      });
+    } catch (err) {
+      setError(API.getFriendlyMessage(err));
+    }
+
+    setIsLoading(false);
+  };
+
+  return (
+    <>
+      <Card
+        title={`Export ${singularName} as JSON`}
+        description={`Download this ${singularName.toLowerCase()} as a JSON file. You can import it later to re-create this ${singularName.toLowerCase()}. Only this ${singularName.toLowerCase()}'s own settings are included - related resources (like owners, labels, or other linked resources) are not exported, and references to resources from this project may need to be re-selected after importing into another project.`}
+        buttons={[
+          {
+            title: `Export ${singularName}`,
+            buttonStyle: ButtonStyleType.NORMAL,
+            onClick: () => {
+              exportItem().catch((err: Error) => {
+                setError(API.getFriendlyMessage(err));
+              });
+            },
+            isLoading: isLoading,
+            icon: IconProp.Download,
+          },
+        ]}
+      />
+
+      {error ? (
+        <ConfirmModal
+          description={error}
+          title={`Export Error`}
+          onSubmit={() => {
+            setError("");
+          }}
+          submitButtonText={`Close`}
+          submitButtonType={ButtonStyleType.NORMAL}
+        />
+      ) : (
+        <></>
+      )}
+    </>
+  );
+};
+
+export default ExportModelCard;