@oneuptime/common 11.2.3 → 11.3.1

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/Tests/Server/Utils/Telemetry.test.ts

@@ -0,0 +1,251 @@
+import Telemetry, {
+  Span,
+  SpanStatusCode,
+} from "../../../Server/Utils/Telemetry";
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+type ExceptionAttributes = Record<string, string | undefined>;
+
+// getExceptionAttributes is a private static; reach it through a narrow cast.
+function getAttributes(exception: unknown): ExceptionAttributes {
+  return (
+    Telemetry as unknown as {
+      getExceptionAttributes: (e: unknown) => ExceptionAttributes;
+    }
+  ).getExceptionAttributes(exception);
+}
+
+describe("Telemetry.getExceptionAttributes", () => {
+  test("extracts Postgres fields from a TypeORM QueryFailedError-shaped error", () => {
+    const error: Error = Object.assign(
+      new Error('delete on "Project" violates foreign key constraint'),
+      {
+        driverError: {
+          code: "23503",
+          detail: 'Key (id)=(abc) is still referenced from table "Monitor".',
+          constraint: "FK_monitor_project",
+          table: "Monitor",
+          column: "projectId",
+          schema: "public",
+        },
+        query: 'DELETE FROM "Project" WHERE "_id" IN ($1)',
+      },
+    );
+
+    const attributes: ExceptionAttributes = getAttributes(error);
+
+    expect(attributes["exception.code"]).toBe("23503");
+    expect(attributes["db.error.constraint"]).toBe("FK_monitor_project");
+    expect(attributes["db.error.table"]).toBe("Monitor");
+    expect(attributes["db.error.column"]).toBe("projectId");
+    expect(attributes["db.error.schema"]).toBe("public");
+    expect(attributes["db.error.detail"]).toContain("still referenced");
+    expect(attributes["db.statement"]).toBe(
+      'DELETE FROM "Project" WHERE "_id" IN ($1)',
+    );
+    expect(attributes["exception.type"]).toBe("Error");
+    expect(attributes["exception.message"]).toContain("violates foreign key");
+  });
+
+  test("reads a top-level pg error code when there is no driverError", () => {
+    const error: Error = Object.assign(
+      new Error("duplicate key value violates unique constraint"),
+      { code: "23505", constraint: "uniq_email" },
+    );
+
+    const attributes: ExceptionAttributes = getAttributes(error);
+
+    expect(attributes["exception.code"]).toBe("23505");
+    expect(attributes["db.error.constraint"]).toBe("uniq_email");
+  });
+
+  test("captures type, message and stacktrace for a plain Error", () => {
+    const attributes: ExceptionAttributes = getAttributes(new Error("boom"));
+
+    expect(attributes["exception.type"]).toBe("Error");
+    expect(attributes["exception.message"]).toBe("boom");
+    expect(typeof attributes["exception.stacktrace"]).toBe("string");
+  });
+
+  test("handles a thrown string", () => {
+    const attributes: ExceptionAttributes = getAttributes("kaboom");
+
+    expect(attributes["exception.message"]).toBe("kaboom");
+    expect(attributes["exception.type"]).toBeUndefined();
+    expect(attributes["db.error.constraint"]).toBeUndefined();
+  });
+
+  test("handles null and undefined throws", () => {
+    expect(getAttributes(null)["exception.message"]).toBe(
+      "Unknown error: null or undefined was thrown",
+    );
+    expect(getAttributes(undefined)["exception.message"]).toBe(
+      "Unknown error: null or undefined was thrown",
+    );
+  });
+
+  test("serializes a non-Error object throw into the message", () => {
+    const attributes: ExceptionAttributes = getAttributes({ a: 1, b: "x" });
+
+    expect(attributes["exception.message"]).toBe('{"a":1,"b":"x"}');
+  });
+
+  test("truncates an oversized message and SQL statement", () => {
+    const error: Error = Object.assign(new Error("x".repeat(9000)), {
+      query: `SELECT ${"a".repeat(9000)}`,
+    });
+
+    const attributes: ExceptionAttributes = getAttributes(error);
+
+    expect(attributes["exception.message"]?.length).toBe(4000);
+    expect(attributes["db.statement"]?.length).toBe(2000);
+  });
+
+  // --- crash-safety: hostile thrown values must never make this throw. ---
+
+  test("does not throw on an object with throwing getters", () => {
+    const hostile: Record<string, unknown> = {};
+    Object.defineProperty(hostile, "code", {
+      enumerable: true,
+      get: (): never => {
+        throw new Error("getter blew up");
+      },
+    });
+    Object.defineProperty(hostile, "driverError", {
+      enumerable: true,
+      get: (): never => {
+        throw new Error("driverError blew up");
+      },
+    });
+
+    let attributes: ExceptionAttributes = {};
+    expect((): void => {
+      attributes = getAttributes(hostile);
+    }).not.toThrow();
+    expect(typeof attributes["exception.message"]).toBe("string");
+  });
+
+  test("does not throw on a field whose toString throws (good fields survive)", () => {
+    const error: Error = Object.assign(new Error("db fail"), {
+      driverError: {
+        detail: {
+          toString: (): never => {
+            throw new Error("toString blew up");
+          },
+        },
+      },
+    });
+
+    expect((): ExceptionAttributes => {
+      return getAttributes(error);
+    }).not.toThrow();
+    expect(getAttributes(error)["exception.message"]).toBe("db fail");
+  });
+
+  test("does not throw on a Proxy that traps every property read", () => {
+    const hostile: unknown = new Proxy(
+      {},
+      {
+        get: (): never => {
+          throw new Error("proxy trap");
+        },
+      },
+    );
+
+    expect((): ExceptionAttributes => {
+      return getAttributes(hostile);
+    }).not.toThrow();
+  });
+});
+
+describe("Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan", () => {
+  type FakeSpanState = {
+    attributes: Record<string, unknown> | null;
+    status: { code: number; message?: string } | null;
+    recorded: unknown;
+    ended: number;
+  };
+
+  // Silence the logger.error console output these tests intentionally trigger.
+  beforeAll((): void => {
+    jest.spyOn(console, "error").mockImplementation((): void => {
+      return undefined;
+    });
+  });
+
+  afterAll((): void => {
+    jest.restoreAllMocks();
+  });
+
+  function makeFakeSpan(
+    state: FakeSpanState,
+    opts?: { throwOnSetAttributes?: boolean },
+  ): Span {
+    return {
+      setAttributes: (a: Record<string, unknown>): unknown => {
+        if (opts?.throwOnSetAttributes) {
+          throw new Error("setAttributes blew up");
+        }
+        state.attributes = a;
+        return undefined;
+      },
+      recordException: (e: unknown): unknown => {
+        state.recorded = e;
+        return undefined;
+      },
+      setStatus: (s: { code: number; message?: string }): unknown => {
+        state.status = s;
+        return undefined;
+      },
+      end: (): void => {
+        state.ended += 1;
+      },
+    } as unknown as Span;
+  }
+
+  test("marks the span as error with a message and ends it", () => {
+    const state: FakeSpanState = {
+      attributes: null,
+      status: null,
+      recorded: null,
+      ended: 0,
+    };
+
+    Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+      span: makeFakeSpan(state),
+      exception: new Error("kaboom"),
+    });
+
+    expect(state.ended).toBe(1);
+    expect(state.status?.code).toBe(SpanStatusCode.ERROR);
+    expect(state.status?.message).toBe("kaboom");
+    expect((state.attributes || {})["exception.message"]).toBe("kaboom");
+  });
+
+  test("still ends and flags the span even if a span write throws", () => {
+    const state: FakeSpanState = {
+      attributes: null,
+      status: null,
+      recorded: null,
+      ended: 0,
+    };
+    const span: Span = makeFakeSpan(state, { throwOnSetAttributes: true });
+
+    expect((): void => {
+      Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+        span,
+        exception: new Error("kaboom"),
+      });
+    }).not.toThrow();
+
+    expect(state.ended).toBe(1);
+    expect(state.status?.code).toBe(SpanStatusCode.ERROR);
+  });
+});

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;
   }
 }