@oneuptime/common 11.5.1 → 11.5.3

package/Tests/Server/Services/AnalyticsDatabaseService.test.ts

@@ -11,6 +11,7 @@ import AnalyticsTableEngine from "../../../Types/AnalyticsDatabase/AnalyticsTabl
 import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import GenericObject from "../../../Types/GenericObject";
 import ObjectID from "../../../Types/ObjectID";
@@ -314,6 +315,89 @@ describe("AnalyticsDatabaseService", () => {
         ),
       ).rejects.toThrow("Invalid aggregationTimestampColumnName");
     });
+
+    test("should reject an unrecognized aggregationInterval", async () => {
+      await expect(
+        service.aggregateBy(
+          makeAggregateBy({ aggregationInterval: "NotAnInterval" }),
+        ),
+      ).rejects.toThrow("Invalid aggregationInterval");
+    });
+  });
+
+  /*
+   * The base AnalyticsDatabaseService.toAggregateStatement is what every
+   * analytics model that does NOT override aggregation (Log, AuditLog, …)
+   * uses. Exercise its aggregationInterval / Total GROUP BY assembly here,
+   * since MetricService's own builders bypass it.
+   */
+  describe("toAggregateStatement aggregationInterval (base path)", () => {
+    beforeEach(() => {
+      jest.spyOn(logger, "debug").mockImplementation(() => {
+        return undefined!;
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    const makeBaseAggregateBy: (overrides?: Record<string, unknown>) => any = (
+      overrides: Record<string, unknown> = {},
+    ): any => {
+      return {
+        aggregationType: AggregationType.Sum,
+        aggregateColumnName: "column_2",
+        aggregationTimestampColumnName: "column_ObjectID",
+        startTimestamp: new Date("2024-01-01"),
+        endTimestamp: new Date("2024-01-02"),
+        query: {},
+        sort: { column_ObjectID: SortOrder.Ascending },
+        limit: 10,
+        skip: 0,
+        props: { isRoot: true },
+        ...overrides,
+      };
+    };
+
+    test("derives the window bucket and groups by time when interval is omitted", () => {
+      const query: string = service.toAggregateStatement(makeBaseAggregateBy())
+        .statement.query;
+
+      // 1-day window derives an Hour bucket, grouped by the time column.
+      expect(query).toContain(
+        "date_trunc('hour', toStartOfInterval(column_ObjectID, INTERVAL 1 hour))",
+      );
+      expect(query).toContain("GROUP BY column_ObjectID");
+      expect(query).not.toContain("min(column_ObjectID)");
+    });
+
+    test("Total with no group-by drops the time bucket and guards empty windows", () => {
+      const query: string = service.toAggregateStatement(
+        makeBaseAggregateBy({ aggregationInterval: "Total" }),
+      ).statement.query;
+
+      expect(query).toContain("min(column_ObjectID) as column_ObjectID");
+      expect(query).not.toContain("date_trunc");
+      expect(query).not.toContain("GROUP BY");
+      expect(query).toContain("HAVING count() > 0");
+    });
+
+    test("Total with a model-column group-by keeps the column, drops the time bucket", () => {
+      const query: string = service.toAggregateStatement(
+        makeBaseAggregateBy({
+          aggregationInterval: "Total",
+          groupBy: { column_1: true },
+        }),
+      ).statement.query;
+
+      expect(query).toContain("min(column_ObjectID) as column_ObjectID");
+      expect(query).toContain("GROUP BY");
+      // The time column must not be a grouping key under Total.
+      expect(query).not.toContain("GROUP BY column_ObjectID");
+      // A grouped query never needs the empty-window guard.
+      expect(query).not.toContain("HAVING count() > 0");
+    });
   });
 
   describe("toDeleteStatement", () => {

package/Tests/Server/Services/MetricServiceAggregate.test.ts

@@ -3,6 +3,7 @@ import { MetricService } from "../../../Server/Services/MetricService";
 import Metric from "../../../Models/AnalyticsModels/Metric";
 import AggregateBy from "../../../Server/Types/AnalyticsDatabase/AggregateBy";
 import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -191,4 +192,170 @@ describe("MetricService aggregate statement generation", () => {
       expect(query).toContain("GROUP BY time");
     });
   });
+
+  /*
+   * The `aggregationInterval` override lets callers pin the time bucket
+   * independent of the query window (the two scenarios from the customer
+   * thread: "daily uptime per host over a week" and "one weekly average
+   * per host"). The buildAggregateBy window is 5 minutes, so its
+   * window-derived interval is Minute — every assertion below proves the
+   * override wins over that default.
+   */
+  describe("explicit aggregationInterval override", () => {
+    it("pins a Day bucket over the window-derived Minute (per-host daily)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Day,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain(
+        "date_trunc('day', toStartOfInterval(time, INTERVAL 1 day))",
+      );
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+      // The 5-minute window's default Minute bucket must NOT leak through.
+      expect(query).not.toContain("date_trunc('minute'");
+    });
+
+    it("honors an explicit Day interval on the minute MV fast path", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Day,
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("MetricItemAggMV1m");
+      expect(query).toContain("date_trunc('day'");
+    });
+
+    it("honors an explicit Day interval on the percentile path", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationType: AggregationType.P90,
+        aggregationInterval: AggregationInterval.Day,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("quantileExactWeighted(0.9)");
+      expect(query).toContain("date_trunc('day'");
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+    });
+
+    it("reproduces the window-derived bucket SQL when omitted (regression)", () => {
+      /*
+       * Distribution hint forces the base scalar builder (skips the MVs).
+       * The 5-minute window must still derive a Minute bucket, unchanged.
+       */
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy();
+      (
+        service as unknown as {
+          pointTypeHintByAggregate: WeakMap<AggregateBy<Metric>, string | null>;
+        }
+      ).pointTypeHintByAggregate.set(aggregateBy, "Histogram");
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain(
+        "date_trunc('minute', toStartOfInterval(time, INTERVAL 1 minute))",
+      );
+      expect(query).toContain("GROUP BY time");
+      expect(query).not.toContain("min(time) as time");
+      expect(query).not.toContain("HAVING count() > 0");
+    });
+  });
+
+  /*
+   * `Total` = no time bucketing: the entire window collapses into a single
+   * aggregate per group. The bucket timestamp becomes `min(time)` (an
+   * aggregate, not a group key), so `time` must drop out of GROUP BY —
+   * and the clause disappears entirely when nothing else is grouped.
+   */
+  describe("Total (whole-window) aggregation", () => {
+    it("collapses the window into one row per host (scalar Avg)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("min(time) as time");
+      expect(query).not.toContain("date_trunc");
+      expect(query).toContain("GROUP BY __attr_grp_0");
+      expect(query).not.toContain("GROUP BY time");
+    });
+
+    it("emits a single global aggregate with no GROUP BY when nothing is grouped", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+        /*
+         * An attribute filter (not a host filter) blocks every MV and
+         * routes to the base scalar builder without a group-by.
+         */
+        query: {
+          projectId: projectId,
+          name: "http.client.request.duration",
+          time: new InBetween(startDate, endDate),
+          attributes: { "oneuptime.service.name": "starship-web" },
+        } as unknown as AggregateBy<Metric>["query"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).not.toContain("MetricItemAggMV1m");
+      expect(query).toContain("min(time) as time");
+      expect(query).not.toContain("GROUP BY");
+      // The phantom row an empty window would return is suppressed.
+      expect(query).toContain("HAVING count() > 0");
+    });
+
+    it("falls back from the minute MV to the base table for Total", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      // The time-bucketed MV cannot serve a whole-window aggregation.
+      expect(query).not.toContain("MetricItemAggMV1m");
+      expect(query).toContain("min(time) as time");
+      expect(query).not.toContain("GROUP BY");
+      expect(query).toContain("HAVING count() > 0");
+    });
+
+    it("keeps a model-column groupBy while dropping the time bucket (Total)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+        groupBy: { metricPointType: true } as AggregateBy<Metric>["groupBy"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("min(time) as time");
+      // The model column survives as the sole grouping key...
+      expect(query).toContain("GROUP BY metricPointType");
+      // ...and the time bucket is gone (it is now an aggregate).
+      expect(query).not.toContain("GROUP BY time");
+      expect(query).not.toContain("date_trunc");
+      // A grouped query never emits the empty-window guard.
+      expect(query).not.toContain("HAVING count() > 0");
+    });
+
+    it("collapses the window into one row per host on the percentile path", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationType: AggregationType.P90,
+        aggregationInterval: AggregationInterval.Total,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("quantileExactWeighted(0.9)");
+      expect(query).toContain("min(time) as time");
+      expect(query).toContain("GROUP BY __attr_grp_0");
+      expect(query).not.toContain("date_trunc");
+    });
+  });
 });

package/Tests/Types/BaseDatabase/AggregationIntervalUtil.test.ts

@@ -53,6 +53,34 @@ describe("AggregationIntervalUtil", () => {
       },
     );
 
+    test("an explicit override wins over the window-derived interval", () => {
+      // A 2-hour window derives Minute, but the override pins Day.
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalForWindow({
+          ...windowOf(2 * HOUR),
+          aggregationInterval: AggregationInterval.Day,
+        }),
+      ).toBe(AggregationInterval.Day);
+    });
+
+    test("the Total override is returned verbatim (whole-window bucketing)", () => {
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalForWindow({
+          ...windowOf(14 * DAY),
+          aggregationInterval: AggregationInterval.Total,
+        }),
+      ).toBe(AggregationInterval.Total);
+    });
+
+    test("an invalid override falls through to the window-derived interval", () => {
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalForWindow({
+          ...windowOf(2 * HOUR),
+          aggregationInterval: "NotAnInterval" as AggregationInterval,
+        }),
+      ).toBe(AggregationInterval.Minute);
+    });
+
     test("returns the widest interval as the window grows", () => {
       const order: Array<AggregationInterval> = [
         AggregationInterval.Minute,
@@ -105,6 +133,18 @@ describe("AggregationIntervalUtil", () => {
       },
     );
 
+    test("Total has no fixed width, so it maps to a very large sentinel > Year", () => {
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalMs(
+          AggregationInterval.Total,
+        ),
+      ).toBeGreaterThan(
+        AggregationIntervalUtil.getAggregationIntervalMs(
+          AggregationInterval.Year,
+        ),
+      );
+    });
+
     test("intervals are strictly increasing in width", () => {
       const ordered: Array<AggregationInterval> = [
         AggregationInterval.Minute,

package/Types/BaseDatabase/AggregateBy.ts

@@ -1,5 +1,6 @@
 import GroupBy from "../../Server/Types/Database/GroupBy";
 import GenericObject from "../GenericObject";
+import AggregationInterval from "./AggregationInterval";
 import AggregationType from "./AggregationType";
 import Query from "./Query";
 import Sort from "./Sort";
@@ -7,7 +8,16 @@ import Sort from "./Sort";
 export default interface AggregateBy<TBaseModel extends GenericObject> {
   aggregateColumnName: keyof TBaseModel;
   aggregationType: AggregationType;
-  // aggregationInterval?: AggregationInterval;
+  /**
+   * Optional explicit time-bucket size. When omitted (the default), the
+   * bucket size is derived from the query window (≤3h → minute, ≤7d →
+   * hour, ≤6w → day, …) — see AggregationIntervalUtil. Set this to pin a
+   * granularity independent of the window (e.g. `Day` buckets over a
+   * one-week window), or to `Total` to aggregate the whole window into a
+   * single value per group (no time bucketing). Invalid values are
+   * rejected with a 400 in AnalyticsDatabaseService.aggregateBy.
+   */
+  aggregationInterval?: AggregationInterval | undefined;
   aggregationTimestampColumnName: keyof TBaseModel;
   startTimestamp: Date;
   endTimestamp: Date;

package/Types/BaseDatabase/AggregationInterval.ts

@@ -5,6 +5,16 @@ export enum AggregationInterval {
   Week = "Week",
   Month = "Month",
   Year = "Year",
+  /**
+   * No time bucketing: collapse the entire [startTimestamp, endTimestamp]
+   * window into a single aggregate per group (one total value over the
+   * whole range). Only meaningful as an explicit
+   * `AggregateBy.aggregationInterval` override — the window-derived
+   * interval picker never returns it. Builders emit one row per group with
+   * the earliest sample timestamp in the window as the bucket label (see
+   * AggregateUtil.buildBucketTimestampSelect).
+   */
+  Total = "Total",
 }
 
 export default AggregationInterval;

package/Types/BaseDatabase/AggregationIntervalUtil.ts

@@ -16,7 +16,21 @@ export class AggregationIntervalUtil {
   public static getAggregationIntervalForWindow(data: {
     startDate: Date;
     endDate: Date;
+    /**
+     * Explicit override. When set to a valid AggregationInterval it is
+     * returned verbatim (including `Total`), so callers can pin a bucket
+     * size independent of the window. Unknown/undefined falls through to
+     * the window-derived interval below.
+     */
+    aggregationInterval?: AggregationInterval | undefined;
   }): AggregationInterval {
+    if (
+      data.aggregationInterval &&
+      Object.values(AggregationInterval).includes(data.aggregationInterval)
+    ) {
+      return data.aggregationInterval;
+    }
+
     const startDate: Date = OneUptimeDate.fromString(data.startDate);
     const endDate: Date = OneUptimeDate.fromString(data.endDate);
 
@@ -65,6 +79,15 @@ export class AggregationIntervalUtil {
         return 1000 * 60 * 60 * 24 * 30;
       case AggregationInterval.Year:
         return 1000 * 60 * 60 * 24 * 365;
+      case AggregationInterval.Total:
+        /*
+         * `Total` is a single whole-window bucket with no fixed width. The
+         * window-derived picker never returns it, so grid-reconstruction
+         * callers (heartbeat charts, XAxis) never see it. Return a very
+         * large finite width (~1000 years) so any defensive fixed-step
+         * grid walk emits a single slot instead of looping forever.
+         */
+        return 1000 * 60 * 60 * 24 * 365 * 1000;
       default:
         return 1000 * 60;
     }

package/Types/Metrics/MetricFormulaConfigData.ts

@@ -8,4 +8,9 @@ export default interface MetricFormulaConfigData {
   chartType?: MetricChartType | undefined;
   warningThreshold?: number | undefined;
   criticalThreshold?: number | undefined;
+  /*
+   * Optional user-chosen color for the formula's series, stored as a hex
+   * string (e.g. "#6366f1"). Unset = auto-assigned from the chart palette.
+   */
+  color?: string | undefined;
 }

package/Types/Metrics/MetricQueryConfigData.ts

@@ -31,6 +31,25 @@ export default interface MetricQueryConfigData {
     | undefined;
   warningThreshold?: number | undefined;
   criticalThreshold?: number | undefined;
+  /*
+   * Optional user-chosen color for this query's series. Stored as a hex
+   * string (e.g. "#6366f1") — the preset swatches write their palette hex
+   * and the custom picker writes an arbitrary hex. When set, it becomes the
+   * lead color for this query's chart (single-series → the series color;
+   * grouped multi-series → the first series, with the default palette filling
+   * the rest). Unset = auto-assigned from the chart-type palette.
+   */
+  color?: string | undefined;
+  /*
+   * Per-group color pins for GROUP-BY queries. Keyed by the individual
+   * "key=value" segment that MetricCharts' series renderer emits for a
+   * grouped series — e.g. { "service.name=api": "#f59e0b" }. Use "(unset)"
+   * as the value for null/empty groups to match the series name. A series
+   * whose composed name contains a pinned segment renders in that color
+   * (first matching segment wins for multi-key group-bys); unpinned series
+   * fall back to `color` (lead) then the chart-type palette. Stored as hex.
+   */
+  colorsByGroup?: Record<string, string> | undefined;
   /*
    * When true, the post-aggregation series points are transformed into
    * a per-second rate of change: `(value - previousValue) / Δt`. This is

package/Types/Telemetry/LlmConventions.ts

@@ -0,0 +1,182 @@
+/*
+ * Single source of truth for the OpenTelemetry GenAI (gen_ai.*) semantic
+ * convention attribute keys OneUptime recognizes when it detects and
+ * denormalizes LLM / GenAI / agent telemetry, plus cheap fallbacks for the two
+ * dominant instrumentation libraries:
+ *   - OpenLLMetry / Traceloop  (gen_ai.* + traceloop.*)
+ *   - OpenInference / Arize    (llm.* + openinference.span.kind)
+ *
+ * Both the server-side ingest extractor
+ * (Common/Server/Utils/Telemetry/LlmSpan.ts) and the client-side display parser
+ * (App/FeatureSet/Dashboard/src/Utils/LlmSpanDisplay.ts) import these lists so
+ * the two cannot silently drift apart when a new attribute is added — add a
+ * newly recognized key HERE, once.
+ *
+ * Order matters: within each list the preferred convention comes first and the
+ * lookup helpers return the first key that is present.
+ */
+
+// Provider / system, e.g. "openai", "anthropic", "aws.bedrock".
+export const LlmSystemAttributeKeys: Array<string> = [
+  "gen_ai.system",
+  "gen_ai.provider.name",
+  "llm.system",
+  "llm.provider",
+];
+
+// Operation, e.g. "chat", "embeddings", "execute_tool", "invoke_agent".
+export const LlmOperationAttributeKeys: Array<string> = [
+  "gen_ai.operation.name",
+  "llm.request.type",
+  "openinference.span.kind",
+];
+
+// Model requested by the caller.
+export const LlmRequestModelAttributeKeys: Array<string> = [
+  "gen_ai.request.model",
+  "llm.model_name",
+  "llm.request.model",
+];
+
+// Model the provider actually served (often the resolved/pinned model).
+export const LlmResponseModelAttributeKeys: Array<string> = [
+  "gen_ai.response.model",
+  "llm.response.model",
+];
+
+export const LlmInputTokenAttributeKeys: Array<string> = [
+  "gen_ai.usage.input_tokens",
+  "gen_ai.usage.prompt_tokens",
+  "llm.token_count.prompt",
+  "llm.usage.prompt_tokens",
+];
+
+export const LlmOutputTokenAttributeKeys: Array<string> = [
+  "gen_ai.usage.output_tokens",
+  "gen_ai.usage.completion_tokens",
+  "llm.token_count.completion",
+  "llm.usage.completion_tokens",
+];
+
+export const LlmTotalTokenAttributeKeys: Array<string> = [
+  "gen_ai.usage.total_tokens",
+  "llm.token_count.total",
+  "llm.usage.total_tokens",
+];
+
+// Cost in USD. Only populated when the SDK reports it (no built-in pricing).
+export const LlmCostAttributeKeys: Array<string> = [
+  "gen_ai.usage.cost",
+  "gen_ai.usage.cost_usd",
+  "gen_ai.usage.total_cost",
+  "llm.usage.total_cost",
+];
+
+export const LlmAgentNameAttributeKeys: Array<string> = [
+  "gen_ai.agent.name",
+  "agent.name",
+];
+
+export const LlmToolNameAttributeKeys: Array<string> = [
+  "gen_ai.tool.name",
+  "tool.name",
+];
+
+/*
+ * Request-parameter keys — surfaced only in the display panel, never
+ * denormalized to DB columns.
+ */
+export const LlmTemperatureAttributeKeys: Array<string> = [
+  "gen_ai.request.temperature",
+  "llm.request.temperature",
+];
+
+export const LlmMaxTokensAttributeKeys: Array<string> = [
+  "gen_ai.request.max_tokens",
+  "llm.request.max_tokens",
+];
+
+export const LlmTopPAttributeKeys: Array<string> = [
+  "gen_ai.request.top_p",
+  "llm.request.top_p",
+];
+
+export const LlmFinishReasonAttributeKeys: Array<string> = [
+  "gen_ai.response.finish_reasons",
+  "gen_ai.response.finish_reason",
+  "llm.response.finish_reason",
+];
+
+/*
+ * Attribute-key namespace prefixes. Any span carrying an attribute in one of
+ * these namespaces is treated as an LLM/GenAI span as a last resort.
+ */
+export const LlmAttributeNamespacePrefixes: Array<string> = [
+  "gen_ai.",
+  "llm.",
+  "traceloop.",
+];
+
+/*
+ * Indexed prompt/completion message conventions of the shape
+ * `${prefix}.${i}.${contentSuffix}` / `${prefix}.${i}.${roleSuffix}`. Used only
+ * by the display parser to reconstruct message content for rendering.
+ */
+export interface LlmIndexedMessageConvention {
+  prefix: string;
+  contentSuffix: string;
+  roleSuffix: string;
+}
+
+export const LlmPromptIndexedMessageConventions: Array<LlmIndexedMessageConvention> =
+  [
+    // OpenLLMetry indexed prompts.
+    { prefix: "gen_ai.prompt", contentSuffix: "content", roleSuffix: "role" },
+    // OpenInference indexed input messages.
+    {
+      prefix: "llm.input_messages",
+      contentSuffix: "message.content",
+      roleSuffix: "message.role",
+    },
+  ];
+
+export const LlmCompletionIndexedMessageConventions: Array<LlmIndexedMessageConvention> =
+  [
+    // OpenLLMetry indexed completions.
+    {
+      prefix: "gen_ai.completion",
+      contentSuffix: "content",
+      roleSuffix: "role",
+    },
+    // OpenInference indexed output messages.
+    {
+      prefix: "llm.output_messages",
+      contentSuffix: "message.content",
+      roleSuffix: "message.role",
+    },
+  ];
+
+// JSON-encoded message-array attribute keys (checked in order).
+export const LlmPromptJsonAttributeKeys: Array<string> = [
+  "gen_ai.input.messages",
+  "gen_ai.prompt",
+  "input.value",
+];
+
+export const LlmCompletionJsonAttributeKeys: Array<string> = [
+  "gen_ai.output.messages",
+  "gen_ai.completion",
+  "output.value",
+];
+
+// Span-event names carrying prompt/completion content.
+export const LlmPromptEventNames: Array<string> = [
+  "gen_ai.system.message",
+  "gen_ai.user.message",
+  "gen_ai.tool.message",
+];
+
+export const LlmCompletionEventNames: Array<string> = [
+  "gen_ai.assistant.message",
+  "gen_ai.choice",
+];

package/UI/Components/Charts/Area/AreaChart.tsx

@@ -1,5 +1,8 @@
 import { AreaChart } from "../ChartLibrary/AreaChart/AreaChart";
-import { AvailableChartColorsKeys } from "../ChartLibrary/Utils/ChartColors";
+import {
+  AvailableChartColorsKeys,
+  ChartColorValue,
+} from "../ChartLibrary/Utils/ChartColors";
 import React, {
   FunctionComponent,
   ReactElement,
@@ -51,6 +54,12 @@ export interface ComponentProps {
    */
   anomalyBandLowerSeriesName?: string | undefined;
   anomalyBandUpperSeriesName?: string | undefined;
+  /*
+   * Optional per-series color override (named palette keys or hex strings).
+   * When provided, replaces the default AreaChartPalette. Indexed by series
+   * position (index % length).
+   */
+  colors?: Array<ChartColorValue> | undefined;
 }
 
 export interface AreaInternalProps extends ComponentProps {
@@ -138,7 +147,11 @@ const AreaChartElement: FunctionComponent<AreaInternalProps> = (
         tickGap={30}
         index={"Time"}
         categories={categories}
-        colors={AreaChartPalette}
+        colors={
+          props.colors && props.colors.length > 0
+            ? props.colors
+            : AreaChartPalette
+        }
         valueFormatter={props.yAxis.options.formatter || undefined}
         showTooltip={true}
         showLegend={props.showLegend !== false}