@oneuptime/common 10.8.2 → 11.0.1

package/UI/Utils/ModelImportExport.ts

@@ -0,0 +1,207 @@
+import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ModelImportExport from "../../Utils/ModelImportExport";
+import API from "./API/API";
+import ModelAPI from "./ModelAPI/ModelAPI";
+
+export interface ImportFailure {
+  itemName: string;
+  errorMessage: string;
+}
+
+export interface ImportResult {
+  successCount: number;
+  failures: Array<ImportFailure>;
+}
+
+export default class ModelImportExportUtil {
+  public static async fetchItemForExport<TBaseModel extends BaseModel>(data: {
+    modelType: { new (): TBaseModel };
+    modelId: ObjectID;
+    modelAPI?: typeof ModelAPI | undefined;
+  }): Promise<TBaseModel> {
+    const modelAPI: typeof ModelAPI = data.modelAPI || ModelAPI;
+
+    const item: TBaseModel | null = await modelAPI.getItem<TBaseModel>({
+      modelType: data.modelType,
+      id: data.modelId,
+      select: ModelImportExport.getImportExportSelect(data.modelType),
+    });
+
+    if (!item || !item.id) {
+      const model: BaseModel = new data.modelType();
+      throw new BadDataException(
+        `${model.singularName || "Item"} not found. It may have been deleted.`,
+      );
+    }
+
+    return item;
+  }
+
+  public static downloadExportFile<TBaseModel extends BaseModel>(data: {
+    modelType: { new (): TBaseModel };
+    items: Array<TBaseModel>;
+  }): void {
+    const model: BaseModel = new data.modelType();
+
+    const envelope: JSONObject = ModelImportExport.buildExportEnvelope({
+      modelType: data.modelType,
+      items: data.items,
+      exportedAt: new Date(),
+    });
+
+    const resourceName: string = (model.tableName || "resources")
+      .replace(/[^a-zA-Z0-9-]/g, "-")
+      .toLowerCase();
+
+    const timestamp: string = new Date()
+      .toISOString()
+      .replace(/[:.]/g, "-")
+      .slice(0, 19);
+
+    this.downloadJSONFile({
+      content: JSON.stringify(envelope, null, 2),
+      filename: `${resourceName}-export-${timestamp}.json`,
+    });
+  }
+
+  public static downloadJSONFile(data: {
+    content: string;
+    filename: string;
+  }): void {
+    const blob: Blob = new Blob([data.content], {
+      type: "application/json;charset=utf-8;",
+    });
+    const url: string = window.URL.createObjectURL(blob);
+    const anchor: HTMLAnchorElement = document.createElement("a");
+    anchor.href = url;
+    anchor.download = data.filename;
+    document.body.appendChild(anchor);
+    anchor.click();
+    document.body.removeChild(anchor);
+    window.URL.revokeObjectURL(url);
+  }
+
+  public static parseImportFileText(data: {
+    modelType: { new (): BaseModel };
+    fileText: string;
+  }): Array<JSONObject> {
+    let payload: unknown = null;
+
+    try {
+      payload = JSON.parse(data.fileText);
+    } catch {
+      throw new BadDataException(
+        "This file is not valid JSON. Please select a JSON export file.",
+      );
+    }
+
+    return ModelImportExport.parseImportPayload({
+      modelType: data.modelType,
+      payload: payload as JSONObject,
+    });
+  }
+
+  /*
+   * Creates each item through the regular create API so all server-side
+   * validation, permission checks and hooks apply. When an item fails only
+   * because a resource with the same name already exists, it is retried once
+   * with an "(Imported)" suffix so re-importing into the same project works.
+   */
+  public static async importItems<TBaseModel extends BaseModel>(data: {
+    modelType: { new (): TBaseModel };
+    itemJsons: Array<JSONObject>;
+    modelAPI?: typeof ModelAPI | undefined;
+    onProgress?:
+      | ((completedCount: number, totalCount: number) => void)
+      | undefined;
+  }): Promise<ImportResult> {
+    const modelAPI: typeof ModelAPI = data.modelAPI || ModelAPI;
+
+    const result: ImportResult = {
+      successCount: 0,
+      failures: [],
+    };
+
+    /*
+     * The column that holds the human-readable name of the resource - used
+     * to label failures and to rename on duplicate-name conflicts. Most
+     * models use "name"; template models use "templateName".
+     */
+    const displayNameColumn: string | undefined = [
+      "name",
+      "templateName",
+      "title",
+    ].find((columnName: string) => {
+      return new data.modelType().getTableColumns().hasColumn(columnName);
+    });
+
+    let completedCount: number = 0;
+
+    for (const itemJson of data.itemJsons) {
+      const itemName: string =
+        (displayNameColumn &&
+          typeof itemJson[displayNameColumn] === "string" &&
+          (itemJson[displayNameColumn] as string)) ||
+        `Item ${completedCount + 1}`;
+
+      try {
+        const item: TBaseModel = ModelImportExport.fromImportJSON({
+          json: itemJson,
+          modelType: data.modelType,
+        });
+
+        try {
+          await modelAPI.create<TBaseModel>({
+            model: item,
+            modelType: data.modelType,
+          });
+
+          result.successCount += 1;
+        } catch (err) {
+          const errorMessage: string = API.getFriendlyMessage(err);
+
+          const canRetryWithNewName: boolean = Boolean(
+            errorMessage.toLowerCase().includes("already exists") &&
+              displayNameColumn &&
+              typeof item.getValue(displayNameColumn) === "string",
+          );
+
+          if (canRetryWithNewName) {
+            item.setValue(
+              displayNameColumn!,
+              `${item.getValue(displayNameColumn!)?.toString()} (Imported)`,
+            );
+
+            await modelAPI.create<TBaseModel>({
+              model: item,
+              modelType: data.modelType,
+            });
+
+            result.successCount += 1;
+          } else {
+            result.failures.push({
+              itemName: itemName,
+              errorMessage: errorMessage,
+            });
+          }
+        }
+      } catch (err) {
+        result.failures.push({
+          itemName: itemName,
+          errorMessage: API.getFriendlyMessage(err),
+        });
+      }
+
+      completedCount += 1;
+
+      if (data.onProgress) {
+        data.onProgress(completedCount, data.itemJsons.length);
+      }
+    }
+
+    return result;
+  }
+}

package/UI/Utils/TelemetryService.ts

@@ -7,11 +7,11 @@ import ServiceType from "../../Types/Telemetry/ServiceType";
  * Telemetry that arrives without an OTel service.name (and with no
  * host / docker / k8s resource signal) is not backed by a Service row.
  * The ingest path tags those analytics rows with the projectId in the
- * `serviceId` column under ServiceType.Unknown (see
+ * `primaryEntityId` column under ServiceType.Unknown (see
  * OtelIngestBaseService.resolveTelemetryResource). The read side has no
  * Service to resolve, so we represent that telemetry with a synthetic,
  * non-persisted Service whose id is the projectId — that way the
- * existing serviceId -> Service lookups in the telemetry views resolve
+ * existing primaryEntityId -> Service lookups in the telemetry views resolve
  * it to a labelled "Unknown Service" entry without any per-view special
  * casing. A real Service._id is never equal to a projectId, so this
  * never collides with a genuine service.
@@ -19,8 +19,8 @@ import ServiceType from "../../Types/Telemetry/ServiceType";
 export const UNKNOWN_SERVICE_NAME: string = "Unknown Service";
 
 /*
- * Result of resolving a telemetry row's polymorphic (serviceId,
- * serviceType) to something renderable. Either a Service (a real
+ * Result of resolving a telemetry row's polymorphic (primaryEntityId,
+ * primaryEntityType) to something renderable. Either a Service (a real
  * OpenTelemetry service, or the synthetic "Unknown Service" for the
  * unattributed bucket) — or a plain `label` for infrastructure resource
  * types (Host / DockerHost / KubernetesCluster) that have no Service row.
@@ -32,25 +32,25 @@ export interface ResolvedTelemetryResource {
 
 export default class TelemetryServiceUtil {
   /*
-   * True when a telemetry row's serviceId is the synthetic "Unknown
+   * True when a telemetry row's primaryEntityId is the synthetic "Unknown
    * Service" — i.e. it equals the projectId (ServiceType.Unknown). Used
    * to suppress navigation to a per-service detail page that does not
    * exist for unattributed telemetry.
    */
   public static isUnknownServiceId(
-    serviceId: ObjectID | string | null | undefined,
+    primaryEntityId: ObjectID | string | null | undefined,
     projectId: ObjectID | null | undefined,
   ): boolean {
-    if (!serviceId || !projectId) {
+    if (!primaryEntityId || !projectId) {
       return false;
     }
-    return serviceId.toString() === projectId.toString();
+    return primaryEntityId.toString() === projectId.toString();
   }
 
   /*
    * Build the synthetic Service used to render unattributed telemetry.
-   * Not persisted — id is the projectId so that serviceId -> Service
-   * lookups (which key on the analytics row's serviceId) resolve to it.
+   * Not persisted — id is the projectId so that primaryEntityId -> Service
+   * lookups (which key on the analytics row's primaryEntityId) resolve to it.
    */
   public static getUnknownService(projectId: ObjectID): Service {
     const service: Service = new Service();
@@ -61,7 +61,7 @@ export default class TelemetryServiceUtil {
   }
 
   /*
-   * Resolve a telemetry row's polymorphic (serviceId, serviceType) to a
+   * Resolve a telemetry row's polymorphic (primaryEntityId, primaryEntityType) to a
    * renderable resource, given the project's loaded Services. Replaces the
    * old server-side `service` ORM relation on TelemetryException: a real
    * Service resolves from the loaded list, the unattributed bucket resolves
@@ -70,12 +70,12 @@ export default class TelemetryServiceUtil {
    * them). Mirrors how the ClickHouse analytics rows are resolved.
    */
   public static resolveTelemetryResource(data: {
-    serviceId: ObjectID | string | null | undefined;
-    serviceType: ServiceType | string | null | undefined;
+    primaryEntityId: ObjectID | string | null | undefined;
+    primaryEntityType: ServiceType | string | null | undefined;
     services: Array<Service>;
     projectId: ObjectID | null | undefined;
   }): ResolvedTelemetryResource {
-    const serviceIdStr: string | undefined = data.serviceId?.toString();
+    const serviceIdStr: string | undefined = data.primaryEntityId?.toString();
 
     // Real Service (OpenTelemetry) — resolve from the loaded list.
     if (serviceIdStr) {
@@ -87,11 +87,11 @@ export default class TelemetryServiceUtil {
       }
     }
 
-    // Unattributed (Unknown) bucket — serviceId is the projectId.
+    // Unattributed (Unknown) bucket — primaryEntityId is the projectId.
     if (
       data.projectId &&
-      (data.serviceType === ServiceType.Unknown ||
-        this.isUnknownServiceId(data.serviceId, data.projectId))
+      (data.primaryEntityType === ServiceType.Unknown ||
+        this.isUnknownServiceId(data.primaryEntityId, data.projectId))
     ) {
       return { service: this.getUnknownService(data.projectId) };
     }
@@ -102,8 +102,8 @@ export default class TelemetryServiceUtil {
       [ServiceType.DockerHost]: "Docker host telemetry",
       [ServiceType.KubernetesCluster]: "Kubernetes telemetry",
     };
-    const label: string | undefined = data.serviceType
-      ? typeLabels[data.serviceType.toString()]
+    const label: string | undefined = data.primaryEntityType
+      ? typeLabels[data.primaryEntityType.toString()]
       : undefined;
     if (label) {
       return { label: label };
@@ -115,7 +115,7 @@ export default class TelemetryServiceUtil {
   /*
    * Append the synthetic "Unknown Service" to a loaded service list, but
    * only when the telemetry in view actually references it (some
-   * serviceId equals the projectId). Avoids showing an empty "Unknown
+   * primaryEntityId equals the projectId). Avoids showing an empty "Unknown
    * Service" entry for projects that always set service.name. Idempotent.
    */
   public static withUnknownServiceIfReferenced(data: {

package/Utils/Dashboard/Components/DashboardTraceChartComponent.ts

@@ -0,0 +1,134 @@
+import DashboardTraceChartComponent from "../../../Types/Dashboard/DashboardComponents/DashboardTraceChartComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+
+const DisplaySection: ComponentArgumentSection = {
+  name: "Display Options",
+  description: "Configure the widget title and metric",
+  order: 1,
+};
+
+const QuerySection: ComponentArgumentSection = {
+  name: "Query",
+  description: "Which spans to aggregate and how to split them",
+  order: 2,
+};
+
+export default class DashboardTraceChartComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardTraceChartComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.TraceChart,
+      widthInDashboardUnits: 8,
+      heightInDashboardUnits: 5,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        metric: "count",
+        topLimit: 10,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardTraceChartComponent>
+  > {
+    const componentArguments: Array<
+      ComponentArgument<DashboardTraceChartComponent>
+    > = [];
+
+    componentArguments.push({
+      name: "Title",
+      description: "Header shown above the chart",
+      required: false,
+      type: ComponentInputType.Text,
+      id: "title",
+      section: DisplaySection,
+    });
+
+    componentArguments.push({
+      name: "Metric",
+      description: "Span aggregation to chart over time",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "metric",
+      section: DisplaySection,
+      dropdownOptions: [
+        { label: "Request Count", value: "count" },
+        { label: "Error Count", value: "errorCount" },
+        { label: "Avg Response Time", value: "avgDuration" },
+        { label: "Median Response Time (P50)", value: "p50Duration" },
+        { label: "P90 Response Time", value: "p90Duration" },
+        { label: "P95 Response Time", value: "p95Duration" },
+        { label: "P99 Response Time", value: "p99Duration" },
+        { label: "Min Response Time", value: "minDuration" },
+        { label: "Max Response Time", value: "maxDuration" },
+      ],
+    });
+
+    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/Utils/Dashboard/Components/Index.ts

@@ -24,6 +24,7 @@ import DashboardLogStreamComponentUtil from "./DashboardLogStreamComponent";
 import DashboardMonitorListComponentUtil from "./DashboardMonitorListComponent";
 import DashboardTableComponentUtil from "./DashboardTableComponent";
 import DashboardTextComponentUtil from "./DashboardTextComponent";
+import DashboardTraceChartComponentUtil from "./DashboardTraceChartComponent";
 import DashboardTraceListComponentUtil from "./DashboardTraceListComponent";
 import DashboardValueComponentUtil from "./DashboardValueComponent";
 
@@ -73,6 +74,12 @@ export default class DashboardComponentsUtil {
       >;
     }
 
+    if (dashboardComponentType === DashboardComponentType.TraceChart) {
+      return DashboardTraceChartComponentUtil.getComponentConfigArguments() as Array<
+        ComponentArgument<DashboardBaseComponent>
+      >;
+    }
+
     if (dashboardComponentType === DashboardComponentType.IncidentList) {
       return DashboardIncidentListComponentUtil.getComponentConfigArguments() as Array<
         ComponentArgument<DashboardBaseComponent>