@oneuptime/common 11.5.1 → 11.5.3

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -433,6 +433,7 @@ import { AddTelemetryEntityRelationshipMetrics1783762505482 } from "./1783762505
 import { AddIoTDeviceCredentialTable1783780000000 } from "./1783780000000-AddIoTDeviceCredentialTable";
 import { AddSnmpV3AuthColumnsToNetworkDevice1783790000000 } from "./1783790000000-AddSnmpV3AuthColumnsToNetworkDevice";
 import { AddAdditionalParamsToLlmProvider1783650000000 } from "./1783650000000-AddAdditionalParamsToLlmProvider";
+import { MigrationName1783937343400 } from "./1783937343400-MigrationName";
 
 export default [
   InitialMigration,
@@ -869,5 +870,6 @@ export default [
   AddTelemetryEntityRelationshipMetrics1783762505482,
   AddIoTDeviceCredentialTable1783780000000,
   AddSnmpV3AuthColumnsToNetworkDevice1783790000000,
-  AddAdditionalParamsToLlmProvider1783650000000
+  AddAdditionalParamsToLlmProvider1783650000000,
+  MigrationName1783937343400,
 ];

package/Server/Services/AnalyticsDatabaseService.ts

@@ -64,7 +64,10 @@ import Text from "../../Types/Text";
 import Typeof from "../../Types/Typeof";
 import API from "../../Utils/API";
 import { Stream } from "node:stream";
-import AggregateBy from "../Types/AnalyticsDatabase/AggregateBy";
+import AggregateBy, {
+  AggregateUtil,
+} from "../Types/AnalyticsDatabase/AggregateBy";
+import AggregationInterval from "../../Types/BaseDatabase/AggregationInterval";
 import AggregatedResult from "../../Types/BaseDatabase/AggregatedResult";
 import AggregationType from "../../Types/BaseDatabase/AggregationType";
 import Sort from "../Types/AnalyticsDatabase/Sort";
@@ -744,6 +747,17 @@ export default class AnalyticsDatabaseService<
         );
       }
 
+      if (
+        aggregateBy.aggregationInterval !== undefined &&
+        !Object.values(AggregationInterval).includes(
+          aggregateBy.aggregationInterval,
+        )
+      ) {
+        throw new BadDataException(
+          `Invalid aggregationInterval: ${aggregateBy.aggregationInterval}. Allowed values: ${Object.values(AggregationInterval).join(", ")}`,
+        );
+      }
+
       if (!aggregateBy.aggregationTimestampColumnName) {
         throw new BadDataException(
           "aggregationTimestampColumnName is required",
@@ -1224,18 +1238,56 @@ export default class AnalyticsDatabaseService<
       .append(whereStatement)
       .append(this.getRetentionReadFilter());
 
-    statement
-      .append(SQL` GROUP BY `)
-      .append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+    /*
+     * The time bucket is a grouping key only when we ARE bucketing by
+     * time. For a `Total` (whole-window) aggregation the timestamp is
+     * emitted as `min(...)` — an aggregate, not a group key — so it must
+     * be left out of GROUP BY. When there is no group-by column either,
+     * the GROUP BY clause is omitted entirely (a single global row).
+     */
+    const resolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const bucketByTime: boolean =
+      !AggregateUtil.isTotalAggregation(resolvedInterval);
+    const hasGroupBy: boolean = Boolean(
+      aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0,
+    );
 
-    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+    if (bucketByTime) {
+      statement
+        .append(SQL` GROUP BY `)
+        .append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+      if (hasGroupBy) {
+        statement
+          .append(SQL` , `)
+          .append(
+            this.statementGenerator.toGroupByStatement(aggregateBy.groupBy!),
+          );
+      }
+    } else if (hasGroupBy) {
       statement
-        .append(SQL` , `)
+        .append(SQL` GROUP BY `)
         .append(
-          this.statementGenerator.toGroupByStatement(aggregateBy.groupBy),
+          this.statementGenerator.toGroupByStatement(aggregateBy.groupBy!),
         );
     }
 
+    /*
+     * A group-less Total aggregation (`SELECT agg(...), min(ts) ...` with no
+     * GROUP BY) returns exactly one row even over an empty window —
+     * ClickHouse fills the aggregates with type defaults, so min(ts)
+     * surfaces as a 1970 epoch point. Suppress that phantom row. This is a
+     * no-op for every bucketed/grouped query (they only ever emit rows for
+     * groups that actually have data).
+     */
+    if (!bucketByTime && !hasGroupBy) {
+      statement.append(SQL` HAVING count() > 0`);
+    }
+
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
     statement.append(

package/Server/Services/MetricService.ts

@@ -560,10 +560,14 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       aggregateBy.aggregateColumnName.toString();
     const aggregationTimestampColumn: string =
       aggregateBy.aggregationTimestampColumnName.toString();
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp!,
-      endDate: aggregateBy.endTimestamp!,
-    }).toLowerCase();
+    const resolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const bucketByTime: boolean =
+      !AggregateUtil.isTotalAggregation(resolvedInterval);
 
     /*
      * Group-by columns from the caller need to be carried through the
@@ -671,7 +675,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
      * always whole numbers in practice).
      */
     statement.append(
-      `SELECT quantileExactWeighted(${percentileLevel})(__pcl_pair.1, toUInt64(greatest(0, round(__pcl_pair.2)))) as ${aggregationColumn}, date_trunc('${aggregationInterval}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval})) as ${aggregationTimestampColumn}`,
+      `SELECT quantileExactWeighted(${percentileLevel})(__pcl_pair.1, toUInt64(greatest(0, round(__pcl_pair.2)))) as ${aggregationColumn}, ${AggregateUtil.buildBucketTimestampSelect(resolvedInterval, aggregationTimestampColumn)}`,
     );
 
     for (const key of groupByKeys) {
@@ -699,13 +703,33 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     statement.append(this.getRetentionReadFilter());
     statement.append(SQL`) `);
 
-    statement.append(SQL` GROUP BY `).append(`${aggregationTimestampColumn}`);
+    /*
+     * `Total` collapses the window into one row per group: the timestamp
+     * becomes an aggregate (`min(...)`) and drops out of GROUP BY, and
+     * when nothing else is grouped the clause is omitted entirely.
+     */
+    const percentileGroupByTerms: Array<string> = [];
+    if (bucketByTime) {
+      percentileGroupByTerms.push(aggregationTimestampColumn);
+    }
     for (const key of groupByKeys) {
-      statement.append(`, ${key}`);
+      percentileGroupByTerms.push(key);
     }
     attributeGroupKeys.forEach((_key: string, index: number) => {
-      statement.append(`, __attr_grp_${index}`);
+      percentileGroupByTerms.push(`__attr_grp_${index}`);
     });
+    if (percentileGroupByTerms.length > 0) {
+      statement
+        .append(SQL` GROUP BY `)
+        .append(percentileGroupByTerms.join(", "));
+    } else {
+      /*
+       * Group-less Total: suppress the single phantom row an empty window
+       * would otherwise return (min(time) → 1970 epoch). Only reachable
+       * under Total — a bucketed query always groups by the time column.
+       */
+      statement.append(SQL` HAVING count() > 0`);
+    }
 
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
@@ -832,10 +856,14 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       aggregateBy.aggregateColumnName.toString();
     const aggregationTimestampColumn: string =
       aggregateBy.aggregationTimestampColumnName.toString();
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp!,
-      endDate: aggregateBy.endTimestamp!,
-    }).toLowerCase();
+    const resolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const bucketByTime: boolean =
+      !AggregateUtil.isTotalAggregation(resolvedInterval);
 
     const groupByKeys: Array<string> = [];
     if (aggregateBy.groupBy) {
@@ -871,7 +899,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     const statement: Statement = SQL``;
 
     statement.append(
-      `SELECT ${aggregationExpression} as ${aggregationColumn}, date_trunc('${aggregationInterval}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval})) as ${aggregationTimestampColumn}`,
+      `SELECT ${aggregationExpression} as ${aggregationColumn}, ${AggregateUtil.buildBucketTimestampSelect(resolvedInterval, aggregationTimestampColumn)}`,
     );
     for (const key of groupByKeys) {
       statement.append(`, ${key}`);
@@ -916,13 +944,32 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       statement.append(this.getRetentionReadFilter());
     }
 
-    statement.append(SQL` GROUP BY `).append(`${aggregationTimestampColumn}`);
+    /*
+     * `Total` drops the time bucket from GROUP BY (it becomes an
+     * aggregate `min(...)`), leaving one row per group — or a single
+     * global row when nothing else is grouped, in which case the GROUP
+     * BY clause is omitted entirely.
+     */
+    const scalarGroupByTerms: Array<string> = [];
+    if (bucketByTime) {
+      scalarGroupByTerms.push(aggregationTimestampColumn);
+    }
     for (const key of groupByKeys) {
-      statement.append(`, ${key}`);
+      scalarGroupByTerms.push(key);
     }
     attributeGroupKeys.forEach((_key: string, index: number) => {
-      statement.append(`, __attr_grp_${index}`);
+      scalarGroupByTerms.push(`__attr_grp_${index}`);
     });
+    if (scalarGroupByTerms.length > 0) {
+      statement.append(SQL` GROUP BY `).append(scalarGroupByTerms.join(", "));
+    } else {
+      /*
+       * Group-less Total: suppress the single phantom row an empty window
+       * would otherwise return (min(time) → 1970 epoch). Only reachable
+       * under Total — a bucketed query always groups by the time column.
+       */
+      statement.append(SQL` HAVING count() > 0`);
+    }
 
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
@@ -1044,18 +1091,54 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       .append(outerWhereStatement)
       .append(SQL` AND retentionDate >= now()`);
 
-    statement
-      .append(SQL` GROUP BY `)
-      .append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+    /*
+     * Mirror the base builder's Total handling: the SELECT above (shared
+     * toAggregateSelectStatement) already emits `min(time)` for a `Total`
+     * interval, so the time column must NOT appear in GROUP BY — grouping
+     * by an aggregate alias is a ClickHouse error. Omit the clause
+     * entirely when nothing else is grouped.
+     */
+    const mutableResolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const mutableBucketByTime: boolean = !AggregateUtil.isTotalAggregation(
+      mutableResolvedInterval,
+    );
+    const mutableHasGroupBy: boolean = Boolean(
+      aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0,
+    );
 
-    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+    if (mutableBucketByTime) {
+      statement
+        .append(SQL` GROUP BY `)
+        .append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+      if (mutableHasGroupBy) {
+        statement
+          .append(SQL` , `)
+          .append(
+            this.statementGenerator.toGroupByStatement(aggregateBy.groupBy!),
+          );
+      }
+    } else if (mutableHasGroupBy) {
       statement
-        .append(SQL` , `)
+        .append(SQL` GROUP BY `)
         .append(
-          this.statementGenerator.toGroupByStatement(aggregateBy.groupBy),
+          this.statementGenerator.toGroupByStatement(aggregateBy.groupBy!),
         );
     }
 
+    /*
+     * Group-less Total: suppress the single phantom row an empty window
+     * would otherwise return (min(time) → 1970 epoch). No-op for bucketed
+     * or grouped queries.
+     */
+    if (!mutableBucketByTime && !mutableHasGroupBy) {
+      statement.append(SQL` HAVING count() > 0`);
+    }
+
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
     statement.append(
@@ -1236,14 +1319,18 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     const interval: AggregationInterval = AggregateUtil.getAggregationInterval({
       startDate: aggregateBy.startTimestamp!,
       endDate: aggregateBy.endTimestamp!,
+      aggregationInterval: aggregateBy.aggregationInterval,
     });
     /*
-     * The MV is bucketed at 1 minute, so all values of AggregationInterval
-     * (Minute / Hour / Day / Week / Month / Year) are >= MV resolution
-     * and acceptable. Kept as a no-op read so the dependency on
-     * AggregateUtil makes the intent obvious.
+     * The MV is bucketed at 1 minute, so every time-bucketed interval
+     * (Minute / Hour / Day / Week / Month / Year) is >= MV resolution and
+     * acceptable — the honored interval flows into the date_trunc below.
+     * `Total` (whole-window, no bucketing) is the one exception: fall back
+     * to the raw-table builder, which knows how to collapse the window.
      */
-    void interval;
+    if (AggregateUtil.isTotalAggregation(interval)) {
+      return null;
+    }
 
     const queryRecord: Record<string, unknown> =
       (aggregateBy.query as unknown as Record<string, unknown>) || {};
@@ -1510,8 +1597,17 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     const interval: AggregationInterval = AggregateUtil.getAggregationInterval({
       startDate: aggregateBy.startTimestamp!,
       endDate: aggregateBy.endTimestamp!,
+      aggregationInterval: aggregateBy.aggregationInterval,
     });
-    void interval;
+    /*
+     * `Total` (whole-window, no bucketing) is not served by this
+     * time-bucketed per-host MV — fall back to the raw-table builder.
+     * Every other interval is >= the MV's 1-minute resolution and flows
+     * into the date_trunc below.
+     */
+    if (AggregateUtil.isTotalAggregation(interval)) {
+      return null;
+    }
 
     if (!this.database) {
       this.useDefaultDatabase();

package/Server/Services/SpanService.ts

@@ -245,6 +245,17 @@ export class SpanService extends AnalyticsDatabaseService<Span> {
       return null;
     }
 
+    /*
+     * This projection path derives its bucket interval from the window
+     * and buckets by minute; it does not implement the explicit
+     * `aggregationInterval` override (nor the `Total` whole-window mode).
+     * When a caller pins an interval, fall back to the generic base
+     * builder, which honors it.
+     */
+    if (aggregateBy.aggregationInterval !== undefined) {
+      return null;
+    }
+
     /*
      * Only the aggregates whose states the projection stores. P95 etc.
      * must fall back: the projection has no quantile(0.95) state and

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -16,12 +16,51 @@ export class AggregateUtil {
    * code reconstructing the server's bucket grid (heartbeat
    * availability charts) always agrees with the interval the
    * statement generator compiles into `toStartOfInterval(...)`.
+   *
+   * `aggregationInterval`, when provided, pins the bucket size
+   * independent of the window (including `Total` for a single
+   * whole-window bucket per group).
    */
   @CaptureSpan()
   public static getAggregationInterval(data: {
     startDate: Date;
     endDate: Date;
+    aggregationInterval?: AggregationInterval | undefined;
   }): AggregationInterval {
     return AggregationIntervalUtil.getAggregationIntervalForWindow(data);
   }
+
+  /**
+   * True when the resolved interval means "no time bucketing" — the
+   * entire window collapses into one aggregate per group.
+   */
+  public static isTotalAggregation(interval: AggregationInterval): boolean {
+    return interval === AggregationInterval.Total;
+  }
+
+  /**
+   * The SELECT fragment that produces the bucket timestamp column,
+   * already aliased to `timestampColumn`. Shared by every aggregate SQL
+   * builder so the `Total` (whole-window) shape stays identical across
+   * paths:
+   *
+   *   - normal interval → `date_trunc('<i>', toStartOfInterval(col, INTERVAL 1 <i>)) as col`
+   *   - Total           → `min(col) as col` (one row per group; the
+   *     earliest sample timestamp in the window is the bucket label)
+   *
+   * `timestampColumn` is a model-validated identifier (see
+   * AnalyticsDatabaseService._aggregateBy), so raw interpolation here is
+   * consistent with the surrounding builders.
+   */
+  public static buildBucketTimestampSelect(
+    resolvedInterval: AggregationInterval,
+    timestampColumn: string,
+  ): string {
+    if (AggregateUtil.isTotalAggregation(resolvedInterval)) {
+      return `min(${timestampColumn}) as ${timestampColumn}`;
+    }
+
+    const interval: string = resolvedInterval.toLowerCase();
+    return `date_trunc('${interval}', toStartOfInterval(${timestampColumn}, INTERVAL 1 ${interval})) as ${timestampColumn}`;
+  }
 }

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -51,6 +51,7 @@ import JSONFunctions from "../../../Types/JSONFunctions";
 import AggregateBy, {
   AggregateUtil,
 } from "../../Types/AnalyticsDatabase/AggregateBy";
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import { getPercentileLevel } from "../../../Types/BaseDatabase/AggregationType";
 
@@ -1194,10 +1195,12 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
     const selectStatement: Statement = new Statement();
 
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp!,
-      endDate: aggregateBy.endTimestamp!,
-    });
+    const aggregationInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
     const aggregationColumn: string =
       aggregateBy.aggregateColumnName.toString();
     const aggregationTimestampColumn: string =
@@ -1212,7 +1215,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
         : `${aggregateBy.aggregationType.toLocaleLowerCase()}(${aggregationColumn})`;
 
     selectStatement.append(
-      `${aggregationExpression} as ${aggregationColumn}, date_trunc('${aggregationInterval.toLowerCase()}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval.toLowerCase()})) as ${aggregationTimestampColumn}`,
+      `${aggregationExpression} as ${aggregationColumn}, ${AggregateUtil.buildBucketTimestampSelect(aggregationInterval, aggregationTimestampColumn)}`,
     );
 
     const columns: Array<string> = [

package/Server/Utils/Telemetry/LlmSpan.ts

@@ -1,4 +1,17 @@
 import Dictionary from "../../../Types/Dictionary";
+import {
+  LlmAgentNameAttributeKeys,
+  LlmAttributeNamespacePrefixes,
+  LlmCostAttributeKeys,
+  LlmInputTokenAttributeKeys,
+  LlmOperationAttributeKeys,
+  LlmOutputTokenAttributeKeys,
+  LlmRequestModelAttributeKeys,
+  LlmResponseModelAttributeKeys,
+  LlmSystemAttributeKeys,
+  LlmToolNameAttributeKeys,
+  LlmTotalTokenAttributeKeys,
+} from "../../../Types/Telemetry/LlmConventions";
 import { AttributeType } from "./Telemetry";
 
 /*
@@ -7,11 +20,9 @@ import { AttributeType } from "./Telemetry";
  * OneUptime ingests OpenTelemetry spans generically. To make LLM and agent
  * telemetry a first-class signal (filterable lists, token/cost/latency
  * rollups) we denormalize a small set of values out of the span attributes at
- * ingest time. We recognize the OpenTelemetry GenAI semantic conventions
- * (gen_ai.*) as primary, with cheap fallbacks for the two dominant
- * instrumentation libraries:
- *   - OpenLLMetry / Traceloop  (gen_ai.* + traceloop.*)
- *   - OpenInference / Arize    (llm.* + openinference.span.kind)
+ * ingest time. The set of recognized attribute keys lives in the shared
+ * Common/Types/Telemetry/LlmConventions module so this server-side extractor
+ * and the client-side display parser cannot drift out of sync.
  *
  * Prompt/completion CONTENT is intentionally NOT denormalized here — it stays
  * in the span's attributes/events map (already captured + scrubbed) and is
@@ -79,29 +90,19 @@ export default class LlmSpanUtil {
       return fields;
     }
 
-    fields.llmSystem = this.getString(attributes, [
-      "gen_ai.system",
-      "gen_ai.provider.name",
-      "llm.system",
-      "llm.provider",
-    ]);
-
-    fields.llmOperation = this.getString(attributes, [
-      "gen_ai.operation.name",
-      "llm.request.type",
-      "openinference.span.kind",
-    ]);
-
-    fields.llmRequestModel = this.getString(attributes, [
-      "gen_ai.request.model",
-      "llm.model_name",
-      "llm.request.model",
-    ]);
-
-    fields.llmResponseModel = this.getString(attributes, [
-      "gen_ai.response.model",
-      "llm.response.model",
-    ]);
+    fields.llmSystem = this.getString(attributes, LlmSystemAttributeKeys);
+
+    fields.llmOperation = this.getString(attributes, LlmOperationAttributeKeys);
+
+    fields.llmRequestModel = this.getString(
+      attributes,
+      LlmRequestModelAttributeKeys,
+    );
+
+    fields.llmResponseModel = this.getString(
+      attributes,
+      LlmResponseModelAttributeKeys,
+    );
 
     // Fall back to the response model when no request model was reported.
     if (!fields.llmRequestModel && fields.llmResponseModel) {
@@ -114,29 +115,15 @@ export default class LlmSpanUtil {
      * reject the row and fail the whole span batch.
      */
     fields.llmInputTokens = Math.trunc(
-      this.getNumber(attributes, [
-        "gen_ai.usage.input_tokens",
-        "gen_ai.usage.prompt_tokens",
-        "llm.token_count.prompt",
-        "llm.usage.prompt_tokens",
-      ]),
+      this.getNumber(attributes, LlmInputTokenAttributeKeys),
     );
 
     fields.llmOutputTokens = Math.trunc(
-      this.getNumber(attributes, [
-        "gen_ai.usage.output_tokens",
-        "gen_ai.usage.completion_tokens",
-        "llm.token_count.completion",
-        "llm.usage.completion_tokens",
-      ]),
+      this.getNumber(attributes, LlmOutputTokenAttributeKeys),
     );
 
     fields.llmTotalTokens = Math.trunc(
-      this.getNumber(attributes, [
-        "gen_ai.usage.total_tokens",
-        "llm.token_count.total",
-        "llm.usage.total_tokens",
-      ]),
+      this.getNumber(attributes, LlmTotalTokenAttributeKeys),
     );
 
     // Derive total when only the parts were reported.
@@ -147,22 +134,11 @@ export default class LlmSpanUtil {
       fields.llmTotalTokens = fields.llmInputTokens + fields.llmOutputTokens;
     }
 
-    fields.llmCost = this.getNumber(attributes, [
-      "gen_ai.usage.cost",
-      "gen_ai.usage.cost_usd",
-      "gen_ai.usage.total_cost",
-      "llm.usage.total_cost",
-    ]);
+    fields.llmCost = this.getNumber(attributes, LlmCostAttributeKeys);
 
-    fields.llmAgentName = this.getString(attributes, [
-      "gen_ai.agent.name",
-      "agent.name",
-    ]);
+    fields.llmAgentName = this.getString(attributes, LlmAgentNameAttributeKeys);
 
-    fields.llmToolName = this.getString(attributes, [
-      "gen_ai.tool.name",
-      "tool.name",
-    ]);
+    fields.llmToolName = this.getString(attributes, LlmToolNameAttributeKeys);
 
     fields.isLlmSpan = this.detectIsLlmSpan(keys, fields);
 
@@ -187,11 +163,9 @@ export default class LlmSpanUtil {
 
     // Last-resort: any GenAI/LLM-namespaced attribute at all.
     return keys.some((key: string) => {
-      return (
-        key.startsWith("gen_ai.") ||
-        key.startsWith("llm.") ||
-        key.startsWith("traceloop.")
-      );
+      return LlmAttributeNamespacePrefixes.some((prefix: string) => {
+        return key.startsWith(prefix);
+      });
     });
   }