@oneuptime/common 13.0.3 → 13.0.5

package/Server/Services/TraceAggregationService.ts

@@ -12,10 +12,12 @@ import ObjectID from "../../Types/ObjectID";
 import BadDataException from "../../Types/Exception/BadDataException";
 import Includes from "../../Types/BaseDatabase/Includes";
 import AnalyticsTableName from "../../Types/AnalyticsDatabase/AnalyticsTableName";
+import { ExceptionSpanScope } from "../../Types/Telemetry/ExceptionSpanScope";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { DbJSONResponse, Results } from "./AnalyticsDatabaseService";
 import logger from "../Utils/Logger";
 import ServiceType from "../../Types/Telemetry/ServiceType";
+import { getResourceFacetServiceTypeMap } from "../../Types/Telemetry/ResourceFacetCatalog";
 import {
   appendResourceScopeFilters,
   ResourceEntityScope,
@@ -59,8 +61,9 @@ export interface TraceFilters {
   serviceIds?: Array<ObjectID> | undefined;
   entityKeys?: Array<string> | undefined;
   /*
-   * Resource-facet selections (Kubernetes cluster / host / docker host /
-   * podman host) already resolved to their entity keys. One scope per
+   * Resource-facet selections (host / Kubernetes cluster / Proxmox
+   * cluster / ... — any ResourceFacetCatalog type) already resolved to
+   * their entity keys and resource attributes. One scope per
    * facet: the branches inside a scope OR (a span proves membership either
    * by being primary-keyed on the resource or by carrying its entity key),
    * and the scopes AND with each other so two facets intersect. See
@@ -84,6 +87,12 @@ export interface TraceFilters {
   // Exact-match for multi-value statusMessage filters (list-side `Includes`).
   statusMessages?: Array<string> | undefined;
   hasException?: boolean | undefined;
+  /*
+   * Only the spans an exception group's occurrences were raised in. Compiled
+   * to a (traceId, spanId) IN subquery over the exception occurrences, pinned
+   * to the request's project — see Types/Telemetry/ExceptionSpanScope.
+   */
+  exceptionScope?: ExceptionSpanScope | undefined;
   /*
    * Strict bounds (`>` / `<`) — the list compiles duration:>N / duration:<N
    * to GreaterThan / LessThan, which are strict comparisons. `duration:N`
@@ -234,22 +243,13 @@ export class TraceAggregationService {
   ]);
   /*
    * Virtual facet keys — same scheme as LogAggregationService. The
-   * `primaryEntityId` slot is reused for host / docker host / k8s cluster
-   * ids, disambiguated by the `primaryEntityType` discriminator.
+   * `primaryEntityId` slot is reused for every non-Service resource id
+   * (host / docker host / k8s cluster / ... — one entry per
+   * ResourceFacetCatalog type), disambiguated by the `primaryEntityType`
+   * discriminator.
    */
   private static readonly RESOURCE_FACET_KEYS: Map<string, ServiceType> =
-    new Map([
-      ["hostId", ServiceType.Host],
-      ["dockerHostId", ServiceType.DockerHost],
-      ["podmanHostId", ServiceType.PodmanHost],
-      ["kubernetesClusterId", ServiceType.KubernetesCluster],
-      ["proxmoxClusterId", ServiceType.ProxmoxCluster],
-      ["vmwareVCenterId", ServiceType.VMwareVCenter],
-      ["cephClusterId", ServiceType.CephCluster],
-      ["serverlessFunctionId", ServiceType.ServerlessFunction],
-      ["cloudResourceId", ServiceType.CloudResource],
-      ["rumApplicationId", ServiceType.RealUserMonitor],
-    ]);
+    getResourceFacetServiceTypeMap();
   private static readonly ATTRIBUTE_KEY_PATTERN: RegExp = /^[a-zA-Z0-9._:/-]+$/;
   private static readonly MAX_FACET_KEY_LENGTH: number = 256;
   /*
@@ -558,8 +558,8 @@ export class TraceAggregationService {
    *
    * primaryEntityId is intentionally NOT disambiguated by primaryEntityType
    * here. Resource IDs are globally unique, so a single primaryEntityId ->
-   * count map correctly serves the service / host / docker host / k8s cluster
-   * facets once merged against each Postgres source-of-truth list (a host id
+   * count map correctly serves the service facet and every resource facet
+   * once merged against each Postgres source-of-truth list (a host id
    * never collides with a service id, so an unrelated entry is simply never
    * looked up). Omitting the primaryEntityType predicate keeps the query
    * projection-eligible.
@@ -1013,14 +1013,61 @@ export class TraceAggregationService {
     return statement;
   }
 
+  /*
+   * The spans behind one exception group's occurrences. The subquery is
+   * pinned to the request's project; without a project the filter matches
+   * nothing rather than widening to every span. GLOBAL IN because both tables
+   * are Distributed and shard on different keys: a plain IN is rejected on
+   * multi-shard clusters (Code 288) and would be wrong shard-locally.
+   */
+  public static appendExceptionScopeFilter(
+    statement: Statement,
+    request: {
+      exceptionScope?: ExceptionSpanScope | undefined;
+      projectId?: ObjectID | undefined;
+    },
+  ): void {
+    if (!request.exceptionScope) {
+      return;
+    }
+
+    if (!request.projectId) {
+      statement.append(" AND 0");
+      return;
+    }
+
+    statement.append(
+      SQL` AND (traceId, spanId) GLOBAL IN (SELECT traceId, spanId FROM ${AnalyticsTableName.ExceptionInstance} WHERE projectId = ${{
+        type: TableColumnType.ObjectID,
+        value: request.projectId,
+      }} AND fingerprint = ${{
+        type: TableColumnType.Text,
+        value: request.exceptionScope.fingerprint,
+      }}`,
+    );
+
+    if (request.exceptionScope.primaryEntityId) {
+      statement.append(
+        SQL` AND primaryEntityId = ${{
+          type: TableColumnType.ObjectID,
+          value: new ObjectID(request.exceptionScope.primaryEntityId),
+        }}`,
+      );
+    }
+
+    statement.append(")");
+  }
+
   private static appendCommonFilters(
     statement: Statement,
-    request: TraceFilters,
+    request: TraceFilters & { projectId?: ObjectID | undefined },
   ): void {
     if (request.rootOnly) {
       statement.append(" AND isRootSpan = 1");
     }
 
+    TraceAggregationService.appendExceptionScopeFilter(statement, request);
+
     if (request.serviceIds && request.serviceIds.length > 0) {
       statement.append(
         SQL` AND primaryEntityId IN (${{
@@ -1396,18 +1443,19 @@ export class TraceAggregationService {
     /*
      * Both memberships are required, and the two sets genuinely differ:
      *
-     * - `proxmoxClusterId` / `vmwareVCenterId` / `cephClusterId` are
-     *   resource dimensions here but have no branch in
-     *   ResourceFacetResolver.resolveOne, which returns [] for them. Asking
-     *   anyway would cost a round-trip and still leave the cell raw.
+     * - Every resource dimension here is a ResourceFacetCatalog type, and
+     *   the resolver lists every catalog type from Postgres, so all of them
+     *   (Proxmox / vCenter / Ceph / Docker Swarm / IoT fleet included) come
+     *   back with display names.
      * - `primaryEntityId` / `serviceId` are resolvable but are NOT resource
      *   dimensions here — they select the OpenTelemetry-service slot, and
      *   the traces explorer already resolves that split client-side
      *   (TracesAnalyticsView's serviceNameMap). Renaming their values
      *   server-side would change an existing surface for no gain.
      *
-     * Taking the intersection means a key becomes resolvable here the
-     * moment the resolver learns it, with no second list to update.
+     * Taking the intersection keeps a dimension this service learns before
+     * the resolver does from costing a round-trip that could only leave
+     * the cell raw.
      */
     const resourceKeys: Array<string> = groupByKeys.filter(
       (key: string): boolean => {
@@ -1885,9 +1933,10 @@ export class TraceAggregationService {
 
       if (key === "primaryEntityId") {
         /*
-         * Same restriction as the Service facet: keep host/docker/k8s
-         * entity ids out of the "Service" dimension (they reuse the
-         * primaryEntityId slot, disambiguated by primaryEntityType).
+         * Same restriction as the Service facet: keep resource entity ids
+         * (host / docker / k8s / ...) out of the "Service" dimension (they
+         * reuse the primaryEntityId slot, disambiguated by
+         * primaryEntityType).
          */
         statement.append(
           SQL` AND (primaryEntityType = '' OR primaryEntityType = ${{

package/Server/Types/AnalyticsDatabase/ModelPermission.ts

@@ -10,6 +10,7 @@ import BaseModel, {
   AnalyticsBaseModelType,
 } from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
+import { EXCEPTION_SPAN_SCOPE_QUERY_KEY } from "../../../Types/Telemetry/ExceptionSpanScope";
 import ColumnBillingAccessControl from "../../../Types/BaseDatabase/ColumnBillingAccessControl";
 import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import DatabaseCommonInteractionPropsUtil, {
@@ -375,6 +376,14 @@ export default class ModelPermission {
        * from the client-sent `resourceFilters` ids.
        */
       "resourceEntityScopes",
+      /*
+       * Synthetic query key compiled by StatementGenerator to
+       * (traceId, spanId) IN (SELECT ... FROM <exception occurrences> WHERE
+       * projectId = <the query's project> AND fingerprint = ...). Not a real
+       * column; it only narrows spans to those an exception group was raised
+       * in, and the subquery is pinned to the query's own project.
+       */
+      EXCEPTION_SPAN_SCOPE_QUERY_KEY,
     ];
 
     return returnArr;

package/Server/Utils/AI/Chat/ObservabilityAssistant.ts

@@ -2,7 +2,10 @@ import DatabaseCommonInteractionProps from "../../../../Types/BaseDatabase/Datab
 import OneUptimeDate from "../../../../Types/Date";
 import ObjectID from "../../../../Types/ObjectID";
 import { JSONObject } from "../../../../Types/JSON";
-import { AIChatCitation } from "../../../../Types/AI/AIChatTypes";
+import {
+  AIChatCitation,
+  AIChatCitationTarget,
+} from "../../../../Types/AI/AIChatTypes";
 import AIService, { AILogResponse } from "../../../Services/AIService";
 import logger from "../../Logger";
 import { LLMMessage, LLMToolDefinition } from "../../LLM/LLMService";
@@ -52,6 +55,12 @@ export interface ObservabilityAssistantStep {
   rowCount?: number | undefined;
   durationMs?: number | undefined;
   citationId?: string | undefined;
+  /*
+   * Set on tool_completed: the citation the call minted, as the tool labelled
+   * and targeted it, so a persisted trail can describe each [C#] on its own.
+   */
+  citationLabel?: string | undefined;
+  citationTarget?: AIChatCitationTarget | undefined;
   totalTokens?: number | undefined;
   errorMessage?: string | undefined;
 }
@@ -396,9 +405,12 @@ export default class ObservabilityAssistant {
           await emitStep({
             type: "tool_completed",
             toolName: toolCall.name,
+            toolArguments: toolCall.arguments,
             durationMs: Date.now() - toolStartedAtMs,
             rowCount: outcome.result.rowCount,
             citationId: citationId,
+            citationLabel: outcome.result.citationLabel,
+            citationTarget: outcome.result.citationTarget,
           });
 
           const escapedText: string = escapeToolResultContent(

package/Server/Utils/AI/SRE/AIInvestigationEngine.ts

@@ -273,14 +273,28 @@ export default class AIInvestigationEngine {
     const onStep: (step: ObservabilityAssistantStep) => Promise<void> = async (
       step: ObservabilityAssistantStep,
     ): Promise<void> => {
+      /*
+       * A completed tool call also records the citation it minted (label +
+       * deep-link target) and — via toolArguments below — the arguments it
+       * ran with, so the panel's evidence list can describe and re-run each
+       * [C#] from this event alone instead of re-parsing the report text.
+       */
       const resultSummary: AIRunEventResultSummary | undefined =
         step.rowCount !== undefined ||
         step.durationMs !== undefined ||
-        step.errorMessage !== undefined
+        step.errorMessage !== undefined ||
+        step.citationLabel !== undefined ||
+        step.citationTarget !== undefined
           ? {
               rowCount: step.rowCount,
               durationInMs: step.durationMs,
               errorMessage: step.errorMessage,
+              ...(step.citationLabel !== undefined
+                ? { citationLabel: step.citationLabel }
+                : {}),
+              ...(step.citationTarget !== undefined
+                ? { citationTarget: step.citationTarget }
+                : {}),
             }
           : undefined;