@oneuptime/common 12.0.23 → 12.0.25

package/Utils/StatusPage/ResourceExplorer.ts

@@ -154,6 +154,25 @@ export interface StatusPageResourceGridModel {
   orphanResources: Array<StatusPageResource>;
 }
 
+/*
+ * How a group's checkbox column stands at the moment: whether the box at the
+ * top of the list should be ticked, half ticked, or empty.
+ *
+ * Computed over whichever resources the list is actually drawing - a filtered
+ * list's "select all" means "everything the search matched", not "everything in
+ * the group", because those are the only rows the operator can see.
+ */
+export interface StatusPageResourceSelectionState {
+  /* Every resource on offer is selected, and there is at least one. */
+  isAllSelected: boolean;
+  /* Some but not all - the half-filled box. */
+  isIndeterminate: boolean;
+  /* How many of the resources on offer are selected. */
+  selectedCount: number;
+  /* How many resources were on offer at all. */
+  selectableCount: number;
+}
+
 export default class StatusPageResourceExplorerUtil {
   /*
    * How many navigator rows are drawn before the list stops and offers to draw
@@ -622,6 +641,245 @@ export default class StatusPageResourceExplorerUtil {
     );
   }
 
+  /* ------------------------------------------------------------------ */
+  /* Selecting resources                                                 */
+  /* ------------------------------------------------------------------ */
+
+  /*
+   * Removing monitors from a status page used to be a row at a time: open the
+   * row's menu, confirm, wait for the refetch, and do it again for the next of
+   * twenty seven (issue #3419). The list carries a checkbox column instead, and
+   * everything below is the model behind it.
+   *
+   * A selection is a set of id STRINGS rather than of resources. Resources are
+   * re-fetched constantly here - every create, delete, reorder and refresh
+   * replaces the whole array - so holding the objects would mean holding rows
+   * that no longer exist, compared by identity against their own replacements.
+   */
+
+  /*
+   * A resource's id as a selection holds it.
+   *
+   * Null when there is nothing to hold on to. The server never returns such a
+   * row, but a list drawn from local state briefly can, and a set containing
+   * `""` would silently make every id-less row the same row.
+   */
+  public static getResourceId(
+    statusPageResource: StatusPageResource,
+  ): string | null {
+    const id: string = statusPageResource._id?.toString() || "";
+
+    return id.length > 0 ? id : null;
+  }
+
+  /*
+   * The ids of everything in the list that can be selected at all, in the order
+   * the list draws them and without repeats.
+   */
+  public static getResourceIds(
+    statusPageResources: Array<StatusPageResource>,
+  ): Array<string> {
+    const ids: Array<string> = [];
+    const seen: Set<string> = new Set<string>();
+
+    for (const statusPageResource of statusPageResources) {
+      const id: string | null =
+        StatusPageResourceExplorerUtil.getResourceId(statusPageResource);
+
+      if (!id || seen.has(id)) {
+        continue;
+      }
+
+      seen.add(id);
+      ids.push(id);
+    }
+
+    return ids;
+  }
+
+  /*
+   * One row's box, ticked or unticked. Always a new set, because it always
+   * changes something.
+   */
+  public static toggleSelectedResourceId(data: {
+    selectedResourceIds: Set<string>;
+    resourceId: string;
+  }): Set<string> {
+    const next: Set<string> = new Set<string>(data.selectedResourceIds);
+
+    if (next.has(data.resourceId)) {
+      next.delete(data.resourceId);
+    } else {
+      next.add(data.resourceId);
+    }
+
+    return next;
+  }
+
+  /*
+   * The box at the top of the list: every resource handed in is selected, or
+   * none of them is.
+   *
+   * Only the resources handed in are touched. A search is on while this is
+   * pressed as often as not, and un-ticking "select all" over four matching
+   * rows must not quietly drop the twenty the operator selected before they
+   * started typing.
+   *
+   * Returns the set it was given when nothing would change, so a component
+   * holding it in state does not re-render itself for a no-op.
+   */
+  public static setResourcesSelected(data: {
+    selectedResourceIds: Set<string>;
+    statusPageResources: Array<StatusPageResource>;
+    isSelected: boolean;
+  }): Set<string> {
+    const ids: Array<string> = StatusPageResourceExplorerUtil.getResourceIds(
+      data.statusPageResources,
+    );
+
+    const next: Set<string> = new Set<string>(data.selectedResourceIds);
+
+    let hasChanged: boolean = false;
+
+    for (const id of ids) {
+      if (data.isSelected) {
+        if (!next.has(id)) {
+          next.add(id);
+          hasChanged = true;
+        }
+
+        continue;
+      }
+
+      if (next.delete(id)) {
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged ? next : data.selectedResourceIds;
+  }
+
+  /*
+   * What the box at the top of the list should look like, over whichever
+   * resources are being drawn.
+   *
+   * An empty list is never "all selected": a ticked box over nothing to tick
+   * reads as a selection that was lost.
+   */
+  public static getSelectionState(data: {
+    statusPageResources: Array<StatusPageResource>;
+    selectedResourceIds: Set<string>;
+  }): StatusPageResourceSelectionState {
+    const ids: Array<string> = StatusPageResourceExplorerUtil.getResourceIds(
+      data.statusPageResources,
+    );
+
+    let selectedCount: number = 0;
+
+    for (const id of ids) {
+      if (data.selectedResourceIds.has(id)) {
+        selectedCount++;
+      }
+    }
+
+    const isAllSelected: boolean =
+      ids.length > 0 && selectedCount === ids.length;
+
+    return {
+      isAllSelected: isAllSelected,
+      isIndeterminate: selectedCount > 0 && !isAllSelected,
+      selectedCount: selectedCount,
+      selectableCount: ids.length,
+    };
+  }
+
+  /*
+   * The selected resources themselves, in the order the list holds them, so a
+   * bulk action reports its progress in the order the operator is looking at.
+   *
+   * Ids in the selection that match nothing in the list are dropped rather than
+   * guessed at - see retainSelectedResourceIds for where they come from.
+   */
+  public static getSelectedResources(data: {
+    statusPageResources: Array<StatusPageResource>;
+    selectedResourceIds: Set<string>;
+  }): Array<StatusPageResource> {
+    const seen: Set<string> = new Set<string>();
+
+    return data.statusPageResources.filter(
+      (statusPageResource: StatusPageResource): boolean => {
+        const id: string | null =
+          StatusPageResourceExplorerUtil.getResourceId(statusPageResource);
+
+        if (!id || seen.has(id) || !data.selectedResourceIds.has(id)) {
+          return false;
+        }
+
+        seen.add(id);
+
+        return true;
+      },
+    );
+  }
+
+  /*
+   * The selection, minus anything the list no longer holds.
+   *
+   * Every write on this pane ends in a refetch, and a resource that was removed
+   * - by this operator's own bulk action, or by somebody else's - must not stay
+   * in the selection: the bulk bar would go on counting it, and the next action
+   * would try to delete a row that is already gone.
+   *
+   * Returns the set it was given when nothing was dropped, for the same reason
+   * setResourcesSelected does.
+   */
+  public static retainSelectedResourceIds(data: {
+    selectedResourceIds: Set<string>;
+    statusPageResources: Array<StatusPageResource>;
+  }): Set<string> {
+    if (data.selectedResourceIds.size === 0) {
+      return data.selectedResourceIds;
+    }
+
+    const present: Set<string> = new Set<string>(
+      StatusPageResourceExplorerUtil.getResourceIds(data.statusPageResources),
+    );
+
+    const next: Set<string> = new Set<string>();
+
+    for (const id of data.selectedResourceIds) {
+      if (present.has(id)) {
+        next.add(id);
+      }
+    }
+
+    return next.size === data.selectedResourceIds.size
+      ? data.selectedResourceIds
+      : next;
+  }
+
+  /*
+   * What the confirmation for a bulk removal is called, and what it says.
+   *
+   * It says the monitors survive, for the same reason the single-row confirm
+   * does: "remove" on a status page means "stop publishing this", and an
+   * operator clearing twenty seven rows deserves to be told that once, loudly,
+   * rather than to wonder afterwards.
+   */
+  public static getBulkRemoveConfirmTitle(data: { count: number }): string {
+    return `Remove ${data.count.toLocaleString()} ${
+      data.count === 1 ? "resource" : "resources"
+    }`;
+  }
+
+  public static getBulkRemoveConfirmMessage(data: { count: number }): string {
+    if (data.count === 1) {
+      return "Are you sure you want to remove 1 resource from this status page? The monitor itself is not deleted.";
+    }
+
+    return `Are you sure you want to remove ${data.count.toLocaleString()} resources from this status page? The monitors themselves are not deleted.`;
+  }
+
   /*
    * The `order` to write when a resource is dragged from one position to
    * another.

package/Utils/Telemetry/LlmMetricQuery.ts

@@ -0,0 +1,287 @@
+import Metric from "../../Models/AnalyticsModels/Metric";
+import AggregatedModel from "../../Types/BaseDatabase/AggregatedModel";
+import InBetween from "../../Types/BaseDatabase/InBetween";
+import Includes from "../../Types/BaseDatabase/Includes";
+import Query from "../../Types/BaseDatabase/Query";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import {
+  LlmRequestModelAttributeKeys,
+  LlmSystemAttributeKeys,
+} from "../../Types/Telemetry/LlmConventions";
+import {
+  LlmCostMetricNames,
+  LlmMetricTeamAttributeKeys,
+  LlmMetricUserAttributeKeys,
+  LlmMicroUsdCostMetricNames,
+  LlmTokenDirection,
+  LlmTokenTypeAttributeKeys,
+  LlmTokenUsageMetricNames,
+  MICRO_USD_TO_USD,
+  getLlmTokenDirection,
+} from "../../Types/Telemetry/LlmMetricConventions";
+
+/*
+ * Pure query construction and result folding for metric-sourced LLM token and
+ * cost totals. Isomorphic on purpose: the budget evaluator runs these on the
+ * server with root props, and the AI / LLM overview runs the same queries in
+ * the browser under the signed-in user's permissions. Keeping the shapes here
+ * means the two cannot drift into disagreeing about what "LLM cost" means.
+ *
+ * The server wrapper (Common/Server/Utils/Telemetry/LlmMetricSpend.ts) adds
+ * the AggregateBy envelope and executes them.
+ *
+ * Scoping caveat, deliberate: provider/model narrowing matches the PRIMARY
+ * semantic-convention attribute key only (gen_ai.system, gen_ai.request.model).
+ * The span extractor accepts several fallback spellings per field, but a
+ * ClickHouse map filter can only test one key at a time, and issuing one query
+ * per candidate key and summing would double-count any datapoint carrying two
+ * of them. Matching the semconv key alone can only ever UNDER-count a scoped
+ * query, never over-count it. Unscoped project-wide queries — the common case,
+ * and the one a metrics-only emitter usually needs — apply no attribute filter
+ * and see every datapoint.
+ */
+
+export interface LlmMetricScope {
+  projectId: ObjectID;
+  startTime: Date;
+  endTime: Date;
+  // Telemetry service to narrow to, matching Span.primaryEntityId scoping.
+  serviceId?: ObjectID | undefined;
+  // gen_ai.system value, e.g. "openai".
+  llmSystem?: string | undefined;
+  // gen_ai.request.model value.
+  llmModel?: string | undefined;
+  /*
+   * Employee / team narrowing, for "what did this person spend" and
+   * per-cost-centre rollups.
+   *
+   * Same one-key-only caveat as llmSystem/llmModel above, and for the same
+   * reason: several spellings are recognized, a ClickHouse map filter can
+   * test one key at a time, and issuing one query per candidate key and
+   * summing would double-count any datapoint carrying two of them. So each
+   * filter matches the PRIMARY key of its list only (user.email, team.id),
+   * which can under-count a scoped query but can never over-count it —
+   * exactly the direction a chargeback figure should err in.
+   */
+  llmUserId?: string | undefined;
+  llmUserEmail?: string | undefined;
+  llmTeam?: string | undefined;
+}
+
+export interface LlmMetricTokenTotals {
+  inputTokens: number;
+  outputTokens: number;
+}
+
+/*
+ * Both convention lists are ordered preferred-first, so element zero is the
+ * semantic-convention key.
+ */
+export const METRIC_SYSTEM_ATTRIBUTE_KEY: string = LlmSystemAttributeKeys[0]!;
+export const METRIC_MODEL_ATTRIBUTE_KEY: string =
+  LlmRequestModelAttributeKeys[0]!;
+
+/*
+ * The identity keys, likewise element zero of their lists. On the metric side
+ * that is "user.email" — the spelling the coding-agent CLIs emit natively and
+ * the one a manager can read without a lookup table.
+ */
+export const METRIC_USER_ATTRIBUTE_KEY: string = LlmMetricUserAttributeKeys[0]!;
+export const METRIC_TEAM_ATTRIBUTE_KEY: string = LlmMetricTeamAttributeKeys[0]!;
+
+export default class LlmMetricQuery {
+  /**
+   * Shared filter for both the cost and token queries: the project, the
+   * window, the candidate metric names, and the caller's optional scoping.
+   *
+   * The `time` predicate has to live in the query itself. AggregateBy's
+   * startTimestamp/endTimestamp only choose the bucket grid — without this the
+   * aggregate scans the metric's whole retention (the same trap the span query
+   * documents).
+   */
+  public static buildBaseQuery(data: {
+    scope: LlmMetricScope;
+    metricNames: Array<string>;
+  }): Query<Metric> {
+    const query: Record<string, unknown> = {
+      projectId: data.scope.projectId,
+      name: new Includes(data.metricNames),
+      time: new InBetween(data.scope.startTime, data.scope.endTime),
+    };
+
+    if (data.scope.serviceId) {
+      query["primaryEntityId"] = data.scope.serviceId;
+    }
+
+    const attributes: Record<string, string> = {};
+
+    if (data.scope.llmSystem) {
+      attributes[METRIC_SYSTEM_ATTRIBUTE_KEY] = data.scope.llmSystem;
+    }
+
+    if (data.scope.llmModel) {
+      attributes[METRIC_MODEL_ATTRIBUTE_KEY] = data.scope.llmModel;
+    }
+
+    /*
+     * llmUserId and llmUserEmail both narrow on METRIC_USER_ATTRIBUTE_KEY —
+     * the metric stream has ONE identity key ("user.email"), unlike the span
+     * side where the id and the email are separate columns. Email is the
+     * preferred spelling, so it wins if a caller somehow supplies both rather
+     * than the two silently overwriting each other in map order.
+     */
+    if (data.scope.llmUserEmail) {
+      attributes[METRIC_USER_ATTRIBUTE_KEY] = data.scope.llmUserEmail;
+    } else if (data.scope.llmUserId) {
+      attributes[METRIC_USER_ATTRIBUTE_KEY] = data.scope.llmUserId;
+    }
+
+    if (data.scope.llmTeam) {
+      attributes[METRIC_TEAM_ATTRIBUTE_KEY] = data.scope.llmTeam;
+    }
+
+    if (Object.keys(attributes).length > 0) {
+      query["attributes"] = attributes;
+    }
+
+    return query as Query<Metric>;
+  }
+
+  public static buildCostQuery(scope: LlmMetricScope): Query<Metric> {
+    return this.buildBaseQuery({
+      scope: scope,
+      metricNames: LlmCostMetricNames,
+    });
+  }
+
+  /**
+   * The micro-USD cost query — Codex-style emitters that report spend in
+   * MILLIONTHS of a dollar.
+   *
+   * Separate from buildCostQuery on purpose. A single query over both name
+   * lists would sum two different units into one number, and a $3 Codex turn
+   * would reach a cost budget as $3,000,000. The unit cannot be recovered
+   * after the sum, so it has to be applied per-list, before the addition —
+   * which is what combineCostTotals below is for.
+   */
+  public static buildMicroUsdCostQuery(scope: LlmMetricScope): Query<Metric> {
+    return this.buildBaseQuery({
+      scope: scope,
+      metricNames: LlmMicroUsdCostMetricNames,
+    });
+  }
+
+  public static buildTokenQuery(scope: LlmMetricScope): Query<Metric> {
+    return this.buildBaseQuery({
+      scope: scope,
+      metricNames: LlmTokenUsageMetricNames,
+    });
+  }
+
+  /**
+   * Combine a USD total with a micro-USD total into one USD figure.
+   *
+   * The ONLY place MICRO_USD_TO_USD is applied. Keeping the scale factor in a
+   * single pure function is the whole point: a million-fold unit error is
+   * invisible in a diff and catastrophic in a cost budget, so it lives
+   * somewhere a test can pin it exactly once.
+   *
+   * Non-finite inputs contribute 0 rather than poisoning the result, matching
+   * sumAggregatedRows: these figures gate alerting, and a NaN spend compares
+   * false against every threshold and would silently disable the monitor.
+   */
+  public static combineCostTotals(data: {
+    usd: number;
+    microUsd: number;
+  }): number {
+    const usd: number = isFinite(data.usd) ? data.usd : 0;
+    const microUsd: number = isFinite(data.microUsd) ? data.microUsd : 0;
+
+    return usd + microUsd * MICRO_USD_TO_USD;
+  }
+
+  /**
+   * Sum an aggregate result's buckets. Non-numeric, missing, NaN and infinite
+   * values contribute nothing rather than poisoning the total — these figures
+   * feed monitors, and one bad row must not turn a budget's spend into NaN.
+   */
+  public static sumAggregatedRows(
+    rows: Array<AggregatedModel> | undefined | null,
+  ): number {
+    if (!rows || !Array.isArray(rows)) {
+      return 0;
+    }
+
+    return rows.reduce((acc: number, row: AggregatedModel): number => {
+      const value: number = Number(row?.value ?? 0);
+
+      if (!isFinite(value)) {
+        return acc;
+      }
+
+      return acc + value;
+    }, 0);
+  }
+
+  /**
+   * Fold grouped token rows into input/output totals.
+   *
+   * A row is counted once, against the first recognized token-type attribute
+   * it carries (the keys are ordered preferred-first). Rows whose token type
+   * is absent, unrecognized, or one of the kinds we deliberately exclude
+   * (cache_read / cache_creation) are dropped rather than guessed at.
+   */
+  public static reduceTokenRows(
+    rows: Array<AggregatedModel> | undefined | null,
+  ): LlmMetricTokenTotals {
+    const totals: LlmMetricTokenTotals = {
+      inputTokens: 0,
+      outputTokens: 0,
+    };
+
+    if (!rows || !Array.isArray(rows)) {
+      return totals;
+    }
+
+    for (const row of rows) {
+      if (!row) {
+        continue;
+      }
+
+      const attributes: JSONObject =
+        (row["attributes"] as JSONObject | undefined) || {};
+
+      let direction: LlmTokenDirection | null = null;
+
+      for (const key of LlmTokenTypeAttributeKeys) {
+        const candidate: LlmTokenDirection | null = getLlmTokenDirection(
+          attributes[key] as string | undefined,
+        );
+
+        if (candidate) {
+          direction = candidate;
+          break;
+        }
+      }
+
+      if (!direction) {
+        continue;
+      }
+
+      const value: number = Number(row.value ?? 0);
+
+      if (!isFinite(value)) {
+        continue;
+      }
+
+      if (direction === "input") {
+        totals.inputTokens += value;
+      } else {
+        totals.outputTokens += value;
+      }
+    }
+
+    return totals;
+  }
+}

package/build/dist/Models/AnalyticsModels/Span.js

@@ -1060,6 +1060,74 @@ let Span = class Span extends AnalyticsBaseModel {
             },
             accessControl: llmColumnAccessControl,
         });
+        /*
+         * Employee identity columns. Denormalized at ingest from the OTel general
+         * semantic-convention identity attributes (user.id / user.email / team.id)
+         * and the gateway + coding-agent fallbacks — see
+         * LlmUserIdAttributeKeys in Common/Types/Telemetry/LlmConventions.ts.
+         *
+         * These answer the question the trace-only LLM feature could not: which
+         * PERSON, and which cost centre, does this spend belong to. They are
+         * populated only on LLM spans (the extractor gates them on isLlmSpan), so
+         * the RUM and HTTP fleet — which also carries user.id — pays nothing for
+         * them.
+         *
+         * They hold real identifying data, so TraceScrubRuleService.scrubSpan
+         * applies the project's Attributes-scoped scrub rules to them just as it
+         * does to the attribute they were derived from.
+         */
+        const llmUserIdColumn = new AnalyticsTableColumn({
+            key: "llmUserId",
+            isLowCardinality: true,
+            title: "LLM User ID",
+            description: "Id of the employee / internal actor who made this LLM call (user.id, enduser.id, or the gateway / coding-agent equivalent). NOT the caller's own downstream customer — that identity is deliberately never mapped here. '' when the instrumentation reports none.",
+            required: false,
+            type: TableColumnType.Text,
+            /*
+             * Set index sized like idx_llm_request_model: a project's employee
+             * roster is in the hundreds-to-low-thousands, so 1000 distinct values
+             * per granule keeps the index useful for the "one person's spend"
+             * query without degenerating into a per-granule scan.
+             */
+            skipIndex: {
+                name: "idx_llm_user_id",
+                type: SkipIndexType.Set,
+                params: [1000],
+                granularity: 4,
+            },
+            accessControl: llmColumnAccessControl,
+        });
+        const llmUserEmailColumn = new AnalyticsTableColumn({
+            key: "llmUserEmail",
+            isLowCardinality: true,
+            title: "LLM User Email",
+            description: "Email of the employee / internal actor who made this LLM call (user.email, emitted natively by Claude Code, Gemini CLI and Codex). Subject to the project's Attributes-scoped trace scrub rules. '' when the instrumentation reports none.",
+            required: false,
+            type: TableColumnType.Text,
+            // Same sizing rationale as idx_llm_user_id — one row per employee.
+            skipIndex: {
+                name: "idx_llm_user_email",
+                type: SkipIndexType.Set,
+                params: [1000],
+                granularity: 4,
+            },
+            accessControl: llmColumnAccessControl,
+        });
+        const llmTeamColumn = new AnalyticsTableColumn({
+            key: "llmTeam",
+            isLowCardinality: true,
+            title: "LLM Team",
+            description: "Team / cost centre the LLM spend charges to (team.id, cost_center, department — conventionally set via OTEL_RESOURCE_ATTRIBUTES). '' when none is reported.",
+            required: false,
+            type: TableColumnType.Text,
+            /*
+             * No skip index, mirroring llmResponseModel. Teams number in the tens:
+             * a Set index would match nearly every granule and cost more to read
+             * than the filter it saves, and the LowCardinality dictionary already
+             * makes the column cheap to scan.
+             */
+            accessControl: llmColumnAccessControl,
+        });
         const retentionDateColumn = new AnalyticsTableColumn({
             key: "retentionDate",
             codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
@@ -1152,6 +1220,9 @@ let Span = class Span extends AnalyticsBaseModel {
                 llmTotalTokensColumn,
                 llmCostColumn,
                 llmConversationIdColumn,
+                llmUserIdColumn,
+                llmUserEmailColumn,
+                llmTeamColumn,
                 retentionDateColumn,
             ],
             projections: [
@@ -1403,6 +1474,24 @@ let Span = class Span extends AnalyticsBaseModel {
     set llmConversationId(v) {
         this.setColumnValue("llmConversationId", v);
     }
+    get llmUserId() {
+        return this.getColumnValue("llmUserId");
+    }
+    set llmUserId(v) {
+        this.setColumnValue("llmUserId", v);
+    }
+    get llmUserEmail() {
+        return this.getColumnValue("llmUserEmail");
+    }
+    set llmUserEmail(v) {
+        this.setColumnValue("llmUserEmail", v);
+    }
+    get llmTeam() {
+        return this.getColumnValue("llmTeam");
+    }
+    set llmTeam(v) {
+        this.setColumnValue("llmTeam", v);
+    }
 };
 Span = __decorate([
     OperationalResource(),