@oneuptime/common 11.2.3 → 11.3.0

package/Server/Utils/Telemetry.ts

@@ -524,17 +524,108 @@ export default class Telemetry {
   }): void {
     const { span, exception } = data;
 
+    const exceptionAttributes: Attributes =
+      this.getExceptionAttributes(exception);
+
     // log the exception as well
     logger.error(exception);
 
+    /*
+     * Span *events* (from recordException) are not reliably surfaced when the
+     * span is read back, and setStatus on its own only records the error CODE,
+     * not the message. So we also attach the exception details as queryable
+     * span attributes — including DB driver fields like the failing constraint
+     * and table — so the actual cause is visible in the trace UI instead of an
+     * empty "Error" status.
+     */
+    span.setAttributes(exceptionAttributes);
     span.recordException(exception as SpanException);
     span.setStatus({
       code: SpanStatusCode.ERROR,
+      message:
+        (exceptionAttributes["exception.message"] as string | undefined) ||
+        "Error",
     });
 
     this.endSpan(span);
   }
 
+  /*
+   * Pulls every useful field off an unknown thrown value into OpenTelemetry
+   * span attributes. Error message/stack are non-enumerable, so they are read
+   * explicitly. For database failures (TypeORM QueryFailedError / pg errors),
+   * the Postgres fields (SQLSTATE code, detail, constraint, table, column) live
+   * either on the error itself or on `driverError`; these are what tell us which
+   * constraint failed during e.g. a cascade delete.
+   */
+  private static getExceptionAttributes(exception: unknown): Attributes {
+    const attributes: Attributes = {};
+
+    if (exception === null || exception === undefined) {
+      attributes["exception.message"] =
+        "Unknown error: null or undefined was thrown";
+      return attributes;
+    }
+
+    if (exception instanceof Error) {
+      attributes["exception.type"] =
+        exception.name || exception.constructor?.name || "Error";
+      attributes["exception.message"] = exception.message || "";
+      if (exception.stack) {
+        attributes["exception.stacktrace"] = exception.stack.substring(0, 8000);
+      }
+    } else if (typeof exception === "string") {
+      attributes["exception.message"] = exception;
+    } else {
+      attributes["exception.message"] = this.safeStringify(exception);
+    }
+
+    type PotentialDatabaseError = {
+      code?: unknown;
+      detail?: unknown;
+      constraint?: unknown;
+      table?: unknown;
+      column?: unknown;
+      schema?: unknown;
+      query?: unknown;
+      driverError?: PotentialDatabaseError;
+    };
+
+    const error: PotentialDatabaseError = exception as PotentialDatabaseError;
+    const databaseError: PotentialDatabaseError = error.driverError || error;
+
+    const setStringAttribute: (key: string, value: unknown) => void = (
+      key: string,
+      value: unknown,
+    ): void => {
+      if (value !== undefined && value !== null && value !== "") {
+        attributes[key] = String(value);
+      }
+    };
+
+    // SQLSTATE (e.g. "23503" = foreign key violation) or a Node error code.
+    setStringAttribute("exception.code", error.code ?? databaseError.code);
+    setStringAttribute("db.error.detail", databaseError.detail);
+    setStringAttribute("db.error.constraint", databaseError.constraint);
+    setStringAttribute("db.error.table", databaseError.table);
+    setStringAttribute("db.error.column", databaseError.column);
+    setStringAttribute("db.error.schema", databaseError.schema);
+
+    if (typeof error.query === "string" && error.query.length > 0) {
+      attributes["db.statement"] = error.query.substring(0, 2000);
+    }
+
+    return attributes;
+  }
+
+  private static safeStringify(value: unknown): string {
+    try {
+      return JSON.stringify(value) || String(value);
+    } catch {
+      return String(value);
+    }
+  }
+
   public static endSpan(span: Span): void {
     span.end();
   }

package/Tests/Server/Utils/Telemetry/LlmSpan.test.ts

@@ -0,0 +1,164 @@
+import LlmSpanUtil, {
+  LlmSpanFields,
+} from "../../../../Server/Utils/Telemetry/LlmSpan";
+import { AttributeType } from "../../../../Server/Utils/Telemetry/Telemetry";
+import Dictionary from "../../../../Types/Dictionary";
+import { describe, expect, test } from "@jest/globals";
+
+type Attrs = Dictionary<AttributeType | Array<AttributeType>>;
+
+describe("LlmSpanUtil.extract", () => {
+  test("non-LLM span returns empty/default fields", () => {
+    const attrs: Attrs = {
+      "http.method": "GET",
+      "http.route": "/api/users",
+      "db.system": "postgresql",
+    };
+
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+
+    expect(fields.isLlmSpan).toBe(false);
+    expect(fields.llmSystem).toBe("");
+    expect(fields.llmTotalTokens).toBe(0);
+    expect(fields.llmCost).toBe(0);
+  });
+
+  test("empty attributes returns defaults", () => {
+    const fields: LlmSpanFields = LlmSpanUtil.extract({});
+    expect(fields).toEqual(LlmSpanUtil.empty());
+  });
+
+  test("OTel GenAI conventions (chat completion)", () => {
+    const attrs: Attrs = {
+      "gen_ai.system": "openai",
+      "gen_ai.operation.name": "chat",
+      "gen_ai.request.model": "gpt-4o",
+      "gen_ai.response.model": "gpt-4o-2024-08-06",
+      "gen_ai.usage.input_tokens": 1200,
+      "gen_ai.usage.output_tokens": 350,
+      "gen_ai.usage.cost": 0.0185,
+    };
+
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+
+    expect(fields.isLlmSpan).toBe(true);
+    expect(fields.llmSystem).toBe("openai");
+    expect(fields.llmOperation).toBe("chat");
+    expect(fields.llmRequestModel).toBe("gpt-4o");
+    expect(fields.llmResponseModel).toBe("gpt-4o-2024-08-06");
+    expect(fields.llmInputTokens).toBe(1200);
+    expect(fields.llmOutputTokens).toBe(350);
+    // total derived from input + output when not reported.
+    expect(fields.llmTotalTokens).toBe(1550);
+    expect(fields.llmCost).toBe(0.0185);
+  });
+
+  test("explicit total_tokens is preferred over derived sum", () => {
+    const attrs: Attrs = {
+      "gen_ai.system": "anthropic",
+      "gen_ai.request.model": "claude-opus-4-8",
+      "gen_ai.usage.input_tokens": 100,
+      "gen_ai.usage.output_tokens": 50,
+      "gen_ai.usage.total_tokens": 999,
+    };
+
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.llmTotalTokens).toBe(999);
+  });
+
+  test("OpenLLMetry legacy prompt/completion token aliases", () => {
+    const attrs: Attrs = {
+      "gen_ai.system": "anthropic",
+      "gen_ai.request.model": "claude-sonnet-4-6",
+      "gen_ai.usage.prompt_tokens": 80,
+      "gen_ai.usage.completion_tokens": 20,
+    };
+
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.isLlmSpan).toBe(true);
+    expect(fields.llmInputTokens).toBe(80);
+    expect(fields.llmOutputTokens).toBe(20);
+    expect(fields.llmTotalTokens).toBe(100);
+  });
+
+  test("OpenInference (llm.* + llm.token_count.*) conventions", () => {
+    const attrs: Attrs = {
+      "openinference.span.kind": "LLM",
+      "llm.system": "openai",
+      "llm.model_name": "gpt-4o-mini",
+      "llm.token_count.prompt": 500,
+      "llm.token_count.completion": 120,
+      "llm.token_count.total": 620,
+    };
+
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.isLlmSpan).toBe(true);
+    expect(fields.llmSystem).toBe("openai");
+    expect(fields.llmOperation).toBe("LLM");
+    expect(fields.llmRequestModel).toBe("gpt-4o-mini");
+    expect(fields.llmInputTokens).toBe(500);
+    expect(fields.llmOutputTokens).toBe(120);
+    expect(fields.llmTotalTokens).toBe(620);
+  });
+
+  test("numeric token values reported as strings are coerced", () => {
+    const attrs: Attrs = {
+      "gen_ai.system": "openai",
+      "gen_ai.usage.input_tokens": "42",
+      "gen_ai.usage.output_tokens": "8",
+    };
+
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.llmInputTokens).toBe(42);
+    expect(fields.llmOutputTokens).toBe(8);
+    expect(fields.llmTotalTokens).toBe(50);
+  });
+
+  test("agent + tool spans are detected", () => {
+    const agentAttrs: Attrs = {
+      "gen_ai.operation.name": "invoke_agent",
+      "gen_ai.agent.name": "research-agent",
+    };
+    const agentFields: LlmSpanFields = LlmSpanUtil.extract(agentAttrs);
+    expect(agentFields.isLlmSpan).toBe(true);
+    expect(agentFields.llmAgentName).toBe("research-agent");
+    expect(agentFields.llmOperation).toBe("invoke_agent");
+
+    const toolAttrs: Attrs = {
+      "gen_ai.operation.name": "execute_tool",
+      "gen_ai.tool.name": "web_search",
+    };
+    const toolFields: LlmSpanFields = LlmSpanUtil.extract(toolAttrs);
+    expect(toolFields.isLlmSpan).toBe(true);
+    expect(toolFields.llmToolName).toBe("web_search");
+  });
+
+  test("response model is used as request model fallback", () => {
+    const attrs: Attrs = {
+      "gen_ai.system": "openai",
+      "gen_ai.response.model": "gpt-4o-2024-08-06",
+    };
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.llmRequestModel).toBe("gpt-4o-2024-08-06");
+    expect(fields.llmResponseModel).toBe("gpt-4o-2024-08-06");
+  });
+
+  test("bare gen_ai-namespaced attribute still flags as LLM span", () => {
+    const attrs: Attrs = {
+      "gen_ai.request.temperature": 0.7,
+    };
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.isLlmSpan).toBe(true);
+  });
+
+  test("array-valued attributes do not break string/number extraction", () => {
+    const attrs: Attrs = {
+      "gen_ai.system": "openai",
+      "gen_ai.response.finish_reasons": ["stop"],
+      "gen_ai.usage.input_tokens": 10,
+    };
+    const fields: LlmSpanFields = LlmSpanUtil.extract(attrs);
+    expect(fields.isLlmSpan).toBe(true);
+    expect(fields.llmInputTokens).toBe(10);
+  });
+});

package/Types/Dashboard/DashboardComponents/DashboardTraceChartComponent.ts

@@ -16,10 +16,15 @@ export default interface DashboardTraceChartComponent extends BaseComponent {
     // 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").
+     * Attribute equality filters, ANDed. The structured editor stores a
+     * key/value record (e.g. { "url.host": "torginol.starship.online" }).
+     * A legacy "key=value; key2=value2" string is still read for widgets
+     * saved before the structured editor existed.
      */
-    attributeFilters?: string | undefined;
+    attributeFilters?:
+      | string
+      | Record<string, string | number | boolean>
+      | undefined;
     /*
      * Optional split dimension: a span attribute key (e.g. url.host,
      * resource.service.instance.id) or a top-level column (name,

package/UI/Components/Navbar/NavBar.tsx

@@ -4,6 +4,7 @@ import React, {
   useState,
   useEffect,
 } from "react";
+import { createPortal } from "react-dom";
 import Route from "../../../Types/API/Route";
 import URL from "../../../Types/API/URL";
 import IconProp from "../../../Types/Icon/IconProp";
@@ -368,9 +369,18 @@ const Navbar: FunctionComponent<ComponentProps> = (
         </div>
       )}
 
+      {/*
+       * Render the full-screen products modal in a portal on document.body so it
+       * is not a flex child of this `justify-between` nav. Otherwise it counts as
+       * a third flex item and shifts the right-side user/settings menu toward the
+       * middle whenever the modal opens. The modal is `fixed inset-0`, so its
+       * visual position is identical when portaled.
+       */}
       {isMoreMenuVisible &&
         props.moreMenuItems &&
-        props.moreMenuItems.length > 0 && (
+        props.moreMenuItems.length > 0 &&
+        typeof document !== "undefined" &&
+        createPortal(
           <NavBarMenuModal
             items={props.moreMenuItems}
             footer={props.moreMenuFooter}
@@ -379,7 +389,8 @@ const Navbar: FunctionComponent<ComponentProps> = (
             keyboardHint={props.moreMenuKeyboardHint}
             recentLabel={props.moreMenuRecentLabel}
             onClose={closeMoreMenu}
-          />
+          />,
+          document.body,
         )}
     </nav>
   );

package/Utils/Dashboard/Components/DashboardTraceChartComponent.ts

@@ -15,11 +15,12 @@ const DisplaySection: ComponentArgumentSection = {
   order: 1,
 };
 
-const QuerySection: ComponentArgumentSection = {
-  name: "Query",
-  description: "Which spans to aggregate and how to split them",
-  order: 2,
-};
+/*
+ * The "Query" section (span-name filter, attribute filters, split-by, max
+ * series, include-child-spans) is rendered by a bespoke, structured editor —
+ * TraceChartQueryEditor — rather than these declarative free-text fields, so
+ * those arguments are deliberately not listed here. See ArgumentsForm.tsx.
+ */
 
 export default class DashboardTraceChartComponentUtil extends DashboardBaseComponentUtil {
   public static override getDefaultComponent(): DashboardTraceChartComponent {
@@ -76,59 +77,6 @@ export default class DashboardTraceChartComponentUtil extends DashboardBaseCompo
       ],
     });
 
-    componentArguments.push({
-      name: "Span Name Contains",
-      description:
-        "Only include spans whose name contains this text (e.g. /Shipment/ShipShipment)",
-      required: false,
-      type: ComponentInputType.Text,
-      id: "spanNameContains",
-      placeholder: "/Shipment/ShipShipment",
-      section: QuerySection,
-    });
-
-    componentArguments.push({
-      name: "Attribute Filters",
-      description:
-        "Attribute equality filters, ANDed — key=value pairs separated by semicolons (e.g. url.host=torginol.starship.online; http.method=POST)",
-      required: false,
-      type: ComponentInputType.Text,
-      id: "attributeFilters",
-      placeholder: "url.host=torginol.starship.online",
-      section: QuerySection,
-    });
-
-    componentArguments.push({
-      name: "Split By",
-      description:
-        "Optional dimension — a span attribute key (e.g. url.host, resource.service.instance.id) or one of: name, primaryEntityId, statusCode, kind. One series per value.",
-      required: false,
-      type: ComponentInputType.Text,
-      id: "groupByAttribute",
-      placeholder: "url.host",
-      section: QuerySection,
-    });
-
-    componentArguments.push({
-      name: "Top Series",
-      description: "Cap on the number of series when split (default 10)",
-      required: false,
-      type: ComponentInputType.Number,
-      id: "topLimit",
-      placeholder: "10",
-      section: QuerySection,
-    });
-
-    componentArguments.push({
-      name: "Include Child Spans",
-      description:
-        "Count every span instead of root spans only (the traces explorer defaults to root spans)",
-      required: false,
-      type: ComponentInputType.Boolean,
-      id: "includeChildSpans",
-      section: QuerySection,
-    });
-
     return componentArguments;
   }
 }

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

@@ -840,6 +840,160 @@ let Span = class Span extends AnalyticsBaseModel {
                 update: [],
             },
         });
+        /*
+         * First-class LLM / GenAI / AI-agent columns. Denormalized at ingest from
+         * gen_ai.* (and OpenLLMetry/OpenInference) span attributes so LLM calls can
+         * be listed, filtered, and aggregated (tokens/cost/latency) cheaply without
+         * scanning the attributes map. See Common/Server/Utils/Telemetry/LlmSpan.ts.
+         */
+        const llmColumnAccessControl = {
+            read: [
+                Permission.ProjectOwner,
+                Permission.ProjectAdmin,
+                Permission.ProjectMember,
+                Permission.Viewer,
+                Permission.TelemetryAdmin,
+                Permission.TelemetryMember,
+                Permission.TelemetryViewer,
+                Permission.ReadTelemetryServiceTraces,
+            ],
+            create: [
+                Permission.ProjectOwner,
+                Permission.ProjectAdmin,
+                Permission.ProjectMember,
+                Permission.TelemetryAdmin,
+                Permission.TelemetryMember,
+                Permission.CreateTelemetryServiceTraces,
+            ],
+            update: [],
+        };
+        const isLlmSpanColumn = new AnalyticsTableColumn({
+            key: "isLlmSpan",
+            title: "Is LLM Span",
+            description: "Whether this span is an LLM / GenAI / AI-agent operation, populated at ingest time for fast filtering of AI calls",
+            required: true,
+            defaultValue: false,
+            type: TableColumnType.Boolean,
+            skipIndex: {
+                name: "idx_is_llm_span",
+                type: SkipIndexType.Set,
+                params: [2],
+                granularity: 4,
+            },
+            accessControl: llmColumnAccessControl,
+        });
+        const llmSystemColumn = new AnalyticsTableColumn({
+            key: "llmSystem",
+            isLowCardinality: true,
+            title: "LLM System",
+            description: "GenAI provider / system, e.g. openai, anthropic, aws.bedrock (gen_ai.system)",
+            required: false,
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_llm_system",
+                type: SkipIndexType.Set,
+                params: [100],
+                granularity: 4,
+            },
+            accessControl: llmColumnAccessControl,
+        });
+        const llmOperationColumn = new AnalyticsTableColumn({
+            key: "llmOperation",
+            isLowCardinality: true,
+            title: "LLM Operation",
+            description: "GenAI operation, e.g. chat, embeddings, execute_tool, invoke_agent (gen_ai.operation.name)",
+            required: false,
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_llm_operation",
+                type: SkipIndexType.Set,
+                params: [100],
+                granularity: 4,
+            },
+            accessControl: llmColumnAccessControl,
+        });
+        const llmRequestModelColumn = new AnalyticsTableColumn({
+            key: "llmRequestModel",
+            isLowCardinality: true,
+            title: "LLM Request Model",
+            description: "Model requested by the caller (gen_ai.request.model)",
+            required: false,
+            type: TableColumnType.Text,
+            skipIndex: {
+                name: "idx_llm_request_model",
+                type: SkipIndexType.Set,
+                params: [1000],
+                granularity: 4,
+            },
+            accessControl: llmColumnAccessControl,
+        });
+        const llmResponseModelColumn = new AnalyticsTableColumn({
+            key: "llmResponseModel",
+            isLowCardinality: true,
+            title: "LLM Response Model",
+            description: "Model the provider actually served (gen_ai.response.model)",
+            required: false,
+            type: TableColumnType.Text,
+            accessControl: llmColumnAccessControl,
+        });
+        const llmAgentNameColumn = new AnalyticsTableColumn({
+            key: "llmAgentName",
+            codec: { codec: "ZSTD", level: 1 },
+            title: "LLM Agent Name",
+            description: "Name of the agent for agent-framework spans (gen_ai.agent.name)",
+            required: false,
+            type: TableColumnType.Text,
+            accessControl: llmColumnAccessControl,
+        });
+        const llmToolNameColumn = new AnalyticsTableColumn({
+            key: "llmToolName",
+            codec: { codec: "ZSTD", level: 1 },
+            title: "LLM Tool Name",
+            description: "Name of the tool invoked for tool-call spans (gen_ai.tool.name)",
+            required: false,
+            type: TableColumnType.Text,
+            accessControl: llmColumnAccessControl,
+        });
+        const llmInputTokensColumn = new AnalyticsTableColumn({
+            key: "llmInputTokens",
+            title: "LLM Input Tokens",
+            description: "Input/prompt token count (gen_ai.usage.input_tokens)",
+            required: true,
+            defaultValue: 0,
+            type: TableColumnType.Number,
+            accessControl: llmColumnAccessControl,
+        });
+        const llmOutputTokensColumn = new AnalyticsTableColumn({
+            key: "llmOutputTokens",
+            title: "LLM Output Tokens",
+            description: "Output/completion token count (gen_ai.usage.output_tokens)",
+            required: true,
+            defaultValue: 0,
+            type: TableColumnType.Number,
+            accessControl: llmColumnAccessControl,
+        });
+        const llmTotalTokensColumn = new AnalyticsTableColumn({
+            key: "llmTotalTokens",
+            title: "LLM Total Tokens",
+            description: "Total token count (gen_ai.usage.total_tokens, or input + output)",
+            required: true,
+            defaultValue: 0,
+            type: TableColumnType.Number,
+            accessControl: llmColumnAccessControl,
+        });
+        const llmCostColumn = new AnalyticsTableColumn({
+            key: "llmCost",
+            title: "LLM Cost (USD)",
+            description: "Cost of this LLM call in USD. Only populated when the instrumentation reports it (gen_ai.usage.cost); OneUptime does not compute pricing.",
+            required: true,
+            defaultValue: 0,
+            /*
+             * Decimal (ClickHouse Double) — cost is fractional; an Int column would
+             * reject the fractional JSONEachRow value and poison the whole batch.
+             */
+            type: TableColumnType.Decimal,
+            accessControl: llmColumnAccessControl,
+        });
         const retentionDateColumn = new AnalyticsTableColumn({
             key: "retentionDate",
             codec: [{ codec: "DoubleDelta" }, { codec: "ZSTD", level: 1 }],
@@ -918,6 +1072,17 @@ let Span = class Span extends AnalyticsBaseModel {
                 kindColumn,
                 hasExceptionColumn,
                 isRootSpanColumn,
+                isLlmSpanColumn,
+                llmSystemColumn,
+                llmOperationColumn,
+                llmRequestModelColumn,
+                llmResponseModelColumn,
+                llmAgentNameColumn,
+                llmToolNameColumn,
+                llmInputTokensColumn,
+                llmOutputTokensColumn,
+                llmTotalTokensColumn,
+                llmCostColumn,
                 retentionDateColumn,
             ],
             projections: [
@@ -1091,6 +1256,72 @@ let Span = class Span extends AnalyticsBaseModel {
     set retentionDate(v) {
         this.setColumnValue("retentionDate", v);
     }
+    get isLlmSpan() {
+        return this.getColumnValue("isLlmSpan");
+    }
+    set isLlmSpan(v) {
+        this.setColumnValue("isLlmSpan", v);
+    }
+    get llmSystem() {
+        return this.getColumnValue("llmSystem");
+    }
+    set llmSystem(v) {
+        this.setColumnValue("llmSystem", v);
+    }
+    get llmOperation() {
+        return this.getColumnValue("llmOperation");
+    }
+    set llmOperation(v) {
+        this.setColumnValue("llmOperation", v);
+    }
+    get llmRequestModel() {
+        return this.getColumnValue("llmRequestModel");
+    }
+    set llmRequestModel(v) {
+        this.setColumnValue("llmRequestModel", v);
+    }
+    get llmResponseModel() {
+        return this.getColumnValue("llmResponseModel");
+    }
+    set llmResponseModel(v) {
+        this.setColumnValue("llmResponseModel", v);
+    }
+    get llmAgentName() {
+        return this.getColumnValue("llmAgentName");
+    }
+    set llmAgentName(v) {
+        this.setColumnValue("llmAgentName", v);
+    }
+    get llmToolName() {
+        return this.getColumnValue("llmToolName");
+    }
+    set llmToolName(v) {
+        this.setColumnValue("llmToolName", v);
+    }
+    get llmInputTokens() {
+        return this.getColumnValue("llmInputTokens");
+    }
+    set llmInputTokens(v) {
+        this.setColumnValue("llmInputTokens", v);
+    }
+    get llmOutputTokens() {
+        return this.getColumnValue("llmOutputTokens");
+    }
+    set llmOutputTokens(v) {
+        this.setColumnValue("llmOutputTokens", v);
+    }
+    get llmTotalTokens() {
+        return this.getColumnValue("llmTotalTokens");
+    }
+    set llmTotalTokens(v) {
+        this.setColumnValue("llmTotalTokens", v);
+    }
+    get llmCost() {
+        return this.getColumnValue("llmCost");
+    }
+    set llmCost(v) {
+        this.setColumnValue("llmCost", v);
+    }
 };
 Span = __decorate([
     OperationalResource(),