@oneuptime/common 11.2.2 → 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/Tests/Types/Currency.test.ts

@@ -0,0 +1,44 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import Currency from "../../Types/Currency";
+
+describe("Currency", () => {
+  describe("convertToDecimalPlaces", () => {
+    test("rounds to two decimal places by default", () => {
+      expect(Currency.convertToDecimalPlaces(1.236)).toBe(1.24);
+      expect(Currency.convertToDecimalPlaces(1.231)).toBe(1.23);
+      expect(Currency.convertToDecimalPlaces(3.14159)).toBe(3.14);
+      expect(Currency.convertToDecimalPlaces(99.994)).toBe(99.99);
+    });
+
+    test("leaves values without fractional digits unchanged", () => {
+      expect(Currency.convertToDecimalPlaces(0)).toBe(0);
+      expect(Currency.convertToDecimalPlaces(100)).toBe(100);
+    });
+
+    test("rounds negative values", () => {
+      expect(Currency.convertToDecimalPlaces(-1.236)).toBe(-1.24);
+    });
+
+    test("honours a custom number of decimal places", () => {
+      expect(Currency.convertToDecimalPlaces(1.23456, 3)).toBe(1.235);
+      expect(Currency.convertToDecimalPlaces(1.26, 1)).toBe(1.3);
+    });
+
+    test("ceils the value when decimalPlaces is 0", () => {
+      expect(Currency.convertToDecimalPlaces(1.1, 0)).toBe(2);
+      expect(Currency.convertToDecimalPlaces(5, 0)).toBe(5);
+      expect(Currency.convertToDecimalPlaces(4.0001, 0)).toBe(5);
+      expect(Currency.convertToDecimalPlaces(-2.5, 0)).toBe(-2);
+    });
+
+    test("throws BadDataException when decimalPlaces is negative", () => {
+      expect(() => {
+        Currency.convertToDecimalPlaces(1.5, -1);
+      }).toThrowError(BadDataException);
+    });
+
+    test("returns a number", () => {
+      expect(typeof Currency.convertToDecimalPlaces(1.236)).toBe("number");
+    });
+  });
+});

package/Tests/Types/Monitor/MonitorType.test.ts

@@ -0,0 +1,214 @@
+import BadDataException from "../../../Types/Exception/BadDataException";
+import MonitorType, {
+  MonitorTypeCategory,
+  MonitorTypeHelper,
+  MonitorTypeProps,
+} from "../../../Types/Monitor/MonitorType";
+
+describe("MonitorTypeHelper", () => {
+  describe("getMonitorTypeCategories", () => {
+    test("returns a non-empty list of categories with labels and types", () => {
+      const categories: Array<MonitorTypeCategory> =
+        MonitorTypeHelper.getMonitorTypeCategories();
+
+      expect(Array.isArray(categories)).toBe(true);
+      expect(categories.length).toBeGreaterThan(0);
+
+      for (const category of categories) {
+        expect(typeof category.label).toBe("string");
+        expect(category.label.length).toBeGreaterThan(0);
+        expect(Array.isArray(category.monitorTypes)).toBe(true);
+        expect(category.monitorTypes.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe("getAllMonitorTypeProps", () => {
+    test("returns props with a unique monitorType, title and description each", () => {
+      const props: Array<MonitorTypeProps> =
+        MonitorTypeHelper.getAllMonitorTypeProps();
+
+      expect(props.length).toBeGreaterThan(0);
+
+      const seen: Set<MonitorType> = new Set<MonitorType>();
+      for (const prop of props) {
+        expect(typeof prop.title).toBe("string");
+        expect(prop.title.length).toBeGreaterThan(0);
+        expect(typeof prop.description).toBe("string");
+        expect(prop.description.length).toBeGreaterThan(0);
+        expect(seen.has(prop.monitorType)).toBe(false);
+        seen.add(prop.monitorType);
+      }
+    });
+  });
+
+  describe("isTelemetryMonitor", () => {
+    test.each([
+      MonitorType.Logs,
+      MonitorType.Metrics,
+      MonitorType.Traces,
+      MonitorType.Exceptions,
+      MonitorType.Profiles,
+      MonitorType.Kubernetes,
+      MonitorType.Docker,
+      MonitorType.Host,
+      MonitorType.Podman,
+      MonitorType.DockerSwarm,
+      MonitorType.Proxmox,
+      MonitorType.Ceph,
+    ])("returns true for %s", (monitorType: MonitorType) => {
+      expect(MonitorTypeHelper.isTelemetryMonitor(monitorType)).toBe(true);
+    });
+
+    test.each([MonitorType.Manual, MonitorType.Website, MonitorType.API])(
+      "returns false for %s",
+      (monitorType: MonitorType) => {
+        expect(MonitorTypeHelper.isTelemetryMonitor(monitorType)).toBe(false);
+      },
+    );
+  });
+
+  describe("isManualMonitor", () => {
+    test("returns true only for Manual", () => {
+      expect(MonitorTypeHelper.isManualMonitor(MonitorType.Manual)).toBe(true);
+      expect(MonitorTypeHelper.isManualMonitor(MonitorType.Website)).toBe(
+        false,
+      );
+      expect(MonitorTypeHelper.isManualMonitor(MonitorType.API)).toBe(false);
+    });
+  });
+
+  describe("getTitle", () => {
+    test("returns the configured title", () => {
+      expect(MonitorTypeHelper.getTitle(MonitorType.API)).toBe("API");
+      expect(MonitorTypeHelper.getTitle(MonitorType.Docker)).toBe(
+        "Docker Container",
+      );
+      expect(MonitorTypeHelper.getTitle(MonitorType.Server)).toBe(
+        "Server / VM",
+      );
+    });
+
+    test("throws BadDataException for a type without props", () => {
+      expect(() => {
+        MonitorTypeHelper.getTitle("NonExistent" as MonitorType);
+      }).toThrowError(BadDataException);
+    });
+  });
+
+  describe("getDescription", () => {
+    test("returns a non-empty description for a known type", () => {
+      expect(
+        MonitorTypeHelper.getDescription(MonitorType.Ping).length,
+      ).toBeGreaterThan(0);
+    });
+
+    test("throws BadDataException for a type without props", () => {
+      expect(() => {
+        MonitorTypeHelper.getDescription("NonExistent" as MonitorType);
+      }).toThrowError(BadDataException);
+    });
+  });
+
+  describe("isProbableMonitor", () => {
+    test.each([
+      MonitorType.API,
+      MonitorType.Website,
+      MonitorType.IP,
+      MonitorType.Ping,
+      MonitorType.Port,
+      MonitorType.SSLCertificate,
+      MonitorType.SyntheticMonitor,
+      MonitorType.CustomJavaScriptCode,
+      MonitorType.SNMP,
+      MonitorType.DNS,
+      MonitorType.DNSSEC,
+      MonitorType.Domain,
+      MonitorType.ExternalStatusPage,
+    ])("returns true for %s", (monitorType: MonitorType) => {
+      expect(MonitorTypeHelper.isProbableMonitor(monitorType)).toBe(true);
+    });
+
+    test.each([
+      MonitorType.Manual,
+      MonitorType.Logs,
+      MonitorType.Server,
+      MonitorType.IncomingRequest,
+    ])("returns false for %s", (monitorType: MonitorType) => {
+      expect(MonitorTypeHelper.isProbableMonitor(monitorType)).toBe(false);
+    });
+  });
+
+  describe("doesMonitorTypeHaveInterval", () => {
+    test("mirrors isProbableMonitor", () => {
+      const types: Array<MonitorType> = [
+        MonitorType.API,
+        MonitorType.Manual,
+        MonitorType.Logs,
+        MonitorType.DNS,
+      ];
+
+      for (const monitorType of types) {
+        expect(MonitorTypeHelper.doesMonitorTypeHaveInterval(monitorType)).toBe(
+          MonitorTypeHelper.isProbableMonitor(monitorType),
+        );
+      }
+    });
+  });
+
+  describe("getActiveMonitorTypes", () => {
+    test("includes Server and excludes Manual", () => {
+      const active: Array<MonitorType> =
+        MonitorTypeHelper.getActiveMonitorTypes();
+
+      expect(active).toContain(MonitorType.Server);
+      expect(active).not.toContain(MonitorType.Manual);
+    });
+  });
+
+  describe("doesMonitorTypeHaveDocumentation", () => {
+    test.each([
+      MonitorType.IncomingRequest,
+      MonitorType.IncomingEmail,
+      MonitorType.Server,
+    ])("returns true for %s", (monitorType: MonitorType) => {
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveDocumentation(monitorType),
+      ).toBe(true);
+    });
+
+    test("returns false for other types", () => {
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveDocumentation(MonitorType.API),
+      ).toBe(false);
+    });
+  });
+
+  describe("doesMonitorTypeHaveCriteria", () => {
+    test("returns false only for Manual", () => {
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveCriteria(MonitorType.Manual),
+      ).toBe(false);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveCriteria(MonitorType.API),
+      ).toBe(true);
+    });
+  });
+
+  describe("doesMonitorTypeHaveGraphs", () => {
+    test("returns true for graphable types and false otherwise", () => {
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveGraphs(MonitorType.Website),
+      ).toBe(true);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveGraphs(MonitorType.Server),
+      ).toBe(true);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveGraphs(MonitorType.Manual),
+      ).toBe(false);
+      expect(
+        MonitorTypeHelper.doesMonitorTypeHaveGraphs(MonitorType.Logs),
+      ).toBe(false);
+    });
+  });
+});

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