@oneuptime/common 10.8.2 → 11.0.0

package/Tests/Utils/UUID.test.ts

@@ -3,6 +3,14 @@ import UUID from "../../Utils/UUID";
 const UUID_V4_REGEX: RegExp =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 
+const UUID_V7_REGEX: RegExp =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+// First 12 hex chars (hyphen removed) = the 48-bit unix-ms timestamp prefix.
+function timestampPrefixOf(uuid: string): number {
+  return parseInt(uuid.replace(/-/g, "").slice(0, 12), 16);
+}
+
 describe("UUID", () => {
   test("UUID.generate() should generate a valid UUID", () => {
     const uuid: string = UUID.generate();
@@ -11,6 +19,45 @@ describe("UUID", () => {
     expect(uuid.length).toBe(36);
   });
 
+  test("UUID.generateTimeOrdered() should generate a valid UUIDv7", () => {
+    const uuid: string = UUID.generateTimeOrdered();
+    expect(uuid).toMatch(UUID_V7_REGEX);
+    expect(uuid.length).toBe(36);
+  });
+
+  test("UUID.generateTimeOrdered() prefix should encode the current unix-ms time", () => {
+    const before: number = Date.now();
+    const uuid: string = UUID.generateTimeOrdered();
+    const after: number = Date.now();
+
+    const prefix: number = timestampPrefixOf(uuid);
+    expect(prefix).toBeGreaterThanOrEqual(before);
+    expect(prefix).toBeLessThanOrEqual(after);
+  });
+
+  test("UUID.generateTimeOrdered() prefixes should be monotonically non-decreasing", async () => {
+    const first: string = UUID.generateTimeOrdered();
+
+    // Cross a millisecond boundary so the prefix strictly advances.
+    await new Promise((resolve: (value: unknown) => void) => {
+      setTimeout(resolve, 5);
+    });
+
+    const second: string = UUID.generateTimeOrdered();
+
+    expect(timestampPrefixOf(second)).toBeGreaterThan(timestampPrefixOf(first));
+    // Time-ordered ids sort lexicographically by generation time.
+    expect(second > first).toBe(true);
+
+    // Same burst: prefixes never go backwards.
+    let previous: number = timestampPrefixOf(UUID.generateTimeOrdered());
+    for (let i: number = 0; i < 100; i++) {
+      const current: number = timestampPrefixOf(UUID.generateTimeOrdered());
+      expect(current).toBeGreaterThanOrEqual(previous);
+      previous = current;
+    }
+  });
+
   test("UUID.generate() should fall back to getRandomValues when randomUUID is unavailable", () => {
     const cryptoObj: Crypto = globalThis.crypto;
     const originalRandomUUID: typeof cryptoObj.randomUUID =

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -1,12 +1,12 @@
 enum AnalyticsTableName {
-  Log = "LogItemV2",
-  Metric = "MetricItemV2",
-  ExceptionInstance = "ExceptionItemV2",
-  Span = "SpanItemV2",
-  MonitorLog = "MonitorLogV2",
-  Profile = "ProfileItemV2",
-  ProfileSample = "ProfileSampleItemV2",
-  AuditLog = "AuditLogV1",
+  Log = "LogItemV3",
+  Metric = "MetricItemV3",
+  ExceptionInstance = "ExceptionItemV3",
+  Span = "SpanItemV3",
+  MonitorLog = "MonitorLogV3",
+  Profile = "ProfileItemV3",
+  ProfileSample = "ProfileSampleItemV3",
+  AuditLog = "AuditLogV2",
   /*
    * Materialized-view target tables. These hold AggregateFunction
    * states populated by attached MVs on the source `Metric` table.
@@ -14,7 +14,12 @@ enum AnalyticsTableName {
    * named here (they aren't queried directly).
    */
   MetricItemAggMV1m = "MetricItemAggMV1m",
-  MetricItemAggMV1mByHost = "MetricItemAggMV1mByHost",
+  /*
+   * Successor of MetricItemAggMV1mByHost (dropped by the
+   * RekeyMetricHostRollupToEntityKey migration), keyed by the stable
+   * hostEntityKey instead of the raw host.name spelling.
+   */
+  MetricItemAggMV1mByHostV2 = "MetricItemAggMV1mByHostV2",
   MetricBaselineHourly = "MetricBaselineHourly",
 }
 

package/Types/AnalyticsDatabase/TableColumnType.ts

@@ -38,6 +38,7 @@ enum ColumnType {
    * UInt sizes can be added if there's a reason.
    */
   UInt8 = "UInt8",
+  UInt64 = "UInt64",
 }
 
 export default ColumnType;

package/Types/Dashboard/DashboardComponentType.ts

@@ -6,6 +6,7 @@ enum DashboardComponentType {
   Gauge = `Gauge`,
   LogStream = `LogStream`,
   TraceList = `TraceList`,
+  TraceChart = `TraceChart`,
   IncidentList = `IncidentList`,
   AlertList = `AlertList`,
   MonitorList = `MonitorList`,

package/Types/Dashboard/DashboardComponents/DashboardTraceChartComponent.ts

@@ -0,0 +1,37 @@
+import ObjectID from "../../ObjectID";
+import DashboardComponentType from "../DashboardComponentType";
+import BaseComponent from "./DashboardBaseComponent";
+
+export default interface DashboardTraceChartComponent extends BaseComponent {
+  componentType: DashboardComponentType.TraceChart;
+  componentId: ObjectID;
+  arguments: {
+    title?: string | undefined;
+    /*
+     * Span aggregation to chart — one of the trace analytics metrics:
+     * count, errorCount, avgDuration, p50Duration, p90Duration,
+     * p95Duration, p99Duration, minDuration, maxDuration.
+     */
+    metric?: string | undefined;
+    // Substring filter on span name (e.g. "/Shipment/ShipShipment").
+    spanNameContains?: string | undefined;
+    /*
+     * Attribute equality filters, ANDed — "key=value; key2=value2"
+     * (e.g. "url.host=torginol.starship.online").
+     */
+    attributeFilters?: string | undefined;
+    /*
+     * Optional split dimension: a span attribute key (e.g. url.host,
+     * resource.service.instance.id) or a top-level column (name,
+     * primaryEntityId, statusCode, kind). One series per value.
+     */
+    groupByAttribute?: string | undefined;
+    // Cap on the number of series when split (default 10).
+    topLimit?: number | undefined;
+    /*
+     * Include non-root spans. Off by default so "Request Count" matches the
+     * traces explorer, which is root-spans-only.
+     */
+    includeChildSpans?: boolean | undefined;
+  };
+}

package/Types/Dashboard/DashboardTemplates.ts

@@ -15,11 +15,10 @@ import { DashboardValueTrendDirection } from "./DashboardComponents/DashboardVal
 
 /*
  * Trace / Exception / Profiles entries are intentionally not in this
- * enum: their metric catalogs (SpanMetricType, ExceptionMetricType,
- * ProfileMetricType) define names that are not emitted anywhere in the
- * codebase, so the templates only ever rendered empty widgets. Reach
- * for the Logs / Traces / Exceptions pages directly until those metrics
- * exist.
+ * enum: their metric catalogs (e.g. SpanMetricType, ExceptionMetricType)
+ * define names that are not emitted anywhere in the codebase, so the
+ * templates only ever rendered empty widgets. Reach for the Logs /
+ * Traces / Exceptions pages directly until those metrics exist.
  */
 export enum DashboardTemplateType {
   Blank = "Blank",

package/Types/Log/LogQueryParser.ts

@@ -9,7 +9,7 @@
  *   - Field-specific:      `severity:error`           → severityText = 'error'
  *   - Attribute access:    `@http.status_code:500`    → attributes.http.status_code = '500'
  *   - Negation (prefix):   `-severity:debug`          → severityText != 'debug'
- *   - Wildcard:            `service:api-*`            → serviceId ILIKE 'api-%'
+ *   - Wildcard:            `service:api-*`            → primaryEntityId ILIKE 'api-%'
  *   - Numeric range:       `@duration:>1000`          → attributes.duration > 1000
  *   - Boolean:             `severity:error AND service:api` (AND is default between tokens)
  *
@@ -46,7 +46,7 @@ export interface ParsedToken {
 const FIELD_ALIASES: Record<string, string> = {
   severity: "severityText",
   level: "severityText",
-  service: "serviceId",
+  service: "primaryEntityId",
   trace: "traceId",
   span: "spanId",
   message: "body",

package/Types/Log/LogQueryToFilter.ts

@@ -19,7 +19,7 @@ import LessThanOrEqual from "../BaseDatabase/LessThanOrEqual";
 export interface LogFilter {
   body?: string | Search<string>;
   severityText?: string;
-  serviceId?: string;
+  primaryEntityId?: string;
   traceId?: string;
   spanId?: string;
   attributes?: Record<string, unknown>;
@@ -28,7 +28,7 @@ export interface LogFilter {
 
 const TOP_LEVEL_FIELDS: Set<string> = new Set([
   "severityText",
-  "serviceId",
+  "primaryEntityId",
   "traceId",
   "spanId",
   "body",

package/Types/Monitor/MonitorStepExceptionMonitor.ts

@@ -9,6 +9,13 @@ import ObjectID from "../ObjectID";
 
 export default interface MonitorStepExceptionMonitor {
   telemetryServiceIds: Array<ObjectID>;
+  /*
+   * Stable telemetry entity keys (host / pod / container / ...) — scopes
+   * the monitor to exceptions carrying any of these in their entityKeys
+   * column. Optional: monitors saved before this field existed have it
+   * undefined.
+   */
+  entityKeys?: Array<string> | undefined;
   exceptionTypes: Array<string>;
   message: string;
   includeResolved: boolean;
@@ -26,11 +33,19 @@ export class MonitorStepExceptionMonitorUtil {
       monitorStepExceptionMonitor.telemetryServiceIds &&
       monitorStepExceptionMonitor.telemetryServiceIds.length > 0
     ) {
-      query.serviceId = new Includes(
+      query.primaryEntityId = new Includes(
         monitorStepExceptionMonitor.telemetryServiceIds,
       );
     }
 
+    // Compiles to hasAny(entityKeys, [...]) server-side. Undefined/empty is a no-op.
+    if (
+      monitorStepExceptionMonitor.entityKeys &&
+      monitorStepExceptionMonitor.entityKeys.length > 0
+    ) {
+      query.entityKeys = new Includes(monitorStepExceptionMonitor.entityKeys);
+    }
+
     if (
       monitorStepExceptionMonitor.exceptionTypes &&
       monitorStepExceptionMonitor.exceptionTypes.length > 0
@@ -59,6 +74,7 @@ export class MonitorStepExceptionMonitorUtil {
   public static getDefault(): MonitorStepExceptionMonitor {
     return {
       telemetryServiceIds: [],
+      entityKeys: [],
       exceptionTypes: [],
       message: "",
       includeResolved: false,
@@ -72,6 +88,7 @@ export class MonitorStepExceptionMonitorUtil {
       telemetryServiceIds: ObjectID.fromJSONArray(
         (json["telemetryServiceIds"] as Array<JSONObject>) || [],
       ),
+      entityKeys: (json["entityKeys"] as Array<string>) || [],
       exceptionTypes: (json["exceptionTypes"] as Array<string>) || [],
       message: (json["message"] as string) || "",
       includeResolved: Boolean(json["includeResolved"]) || false,
@@ -84,6 +101,7 @@ export class MonitorStepExceptionMonitorUtil {
   public static toJSON(monitor: MonitorStepExceptionMonitor): JSONObject {
     return {
       telemetryServiceIds: ObjectID.toJSONArray(monitor.telemetryServiceIds),
+      entityKeys: monitor.entityKeys || [],
       exceptionTypes: monitor.exceptionTypes,
       message: monitor.message,
       includeResolved: monitor.includeResolved,

package/Types/Monitor/MonitorStepLogMonitor.ts

@@ -14,6 +14,12 @@ export default interface MonitorStepLogMonitor {
   body: string;
   severityTexts: Array<LogSeverity>;
   telemetryServiceIds: Array<ObjectID>;
+  /*
+   * Stable telemetry entity keys (host / pod / container / ...) — scopes
+   * the monitor to logs carrying any of these in their entityKeys column.
+   * Optional: monitors saved before this field existed have it undefined.
+   */
+  entityKeys?: Array<string> | undefined;
   lastXSecondsOfLogs: number;
 }
 
@@ -27,7 +33,17 @@ export class MonitorStepLogMonitorUtil {
       monitorStepLogMonitor.telemetryServiceIds &&
       monitorStepLogMonitor.telemetryServiceIds.length > 0
     ) {
-      query.serviceId = new Includes(monitorStepLogMonitor.telemetryServiceIds);
+      query.primaryEntityId = new Includes(
+        monitorStepLogMonitor.telemetryServiceIds,
+      );
+    }
+
+    // Compiles to hasAny(entityKeys, [...]) server-side. Undefined/empty is a no-op.
+    if (
+      monitorStepLogMonitor.entityKeys &&
+      monitorStepLogMonitor.entityKeys.length > 0
+    ) {
+      query.entityKeys = new Includes(monitorStepLogMonitor.entityKeys);
     }
 
     if (
@@ -66,6 +82,7 @@ export class MonitorStepLogMonitorUtil {
       body: "",
       severityTexts: [],
       telemetryServiceIds: [],
+      entityKeys: [],
       lastXSecondsOfLogs: 60,
     };
   }
@@ -79,6 +96,7 @@ export class MonitorStepLogMonitorUtil {
       telemetryServiceIds: ObjectID.fromJSONArray(
         json["telemetryServiceIds"] as Array<JSONObject>,
       ),
+      entityKeys: (json["entityKeys"] as Array<string>) || [],
       lastXSecondsOfLogs: json["lastXSecondsOfLogs"] as number,
     };
   }
@@ -89,6 +107,7 @@ export class MonitorStepLogMonitorUtil {
       body: monitor.body,
       severityTexts: monitor.severityTexts,
       telemetryServiceIds: ObjectID.toJSONArray(monitor.telemetryServiceIds),
+      entityKeys: monitor.entityKeys || [],
       lastXSecondsOfLogs: monitor.lastXSecondsOfLogs,
     };
   }

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",