@oneuptime/common 11.0.0 → 11.0.2

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/Telemetry/Telemetry.ts

@@ -8,14 +8,16 @@ import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
 import { XMLHttpRequestInstrumentation } from "@opentelemetry/instrumentation-xml-http-request";
-import { Resource } from "@opentelemetry/resources";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 import {
   BatchSpanProcessor,
   TracerConfig,
   WebTracerProvider,
 } from "@opentelemetry/sdk-trace-web";
-import type { SpanExporter } from "@opentelemetry/sdk-trace-base";
-import type { SpanExporter as WebSpanExporter } from "@opentelemetry/sdk-trace-web/node_modules/@opentelemetry/sdk-trace-base/build/src/export/SpanExporter";
+import type {
+  SpanExporter,
+  SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import URL from "../../../Types/API/URL";
 
@@ -87,14 +89,6 @@ export default class Telemetry {
       Object.keys(OpenTelemetryExporterOtlpHeaders).length > 0;
 
     if (OpenTelemetryExporterOtlpEndpoint && hasHeaders) {
-      const providerConfig: TracerConfig = {
-        resource: new Resource({
-          [ATTR_SERVICE_NAME]: data.serviceName,
-        }),
-      };
-
-      const provider: WebTracerProvider = new WebTracerProvider(providerConfig);
-
       const traceExporter: SpanExporter = new OTLPTraceExporter({
         url: URL.fromString(
           OpenTelemetryExporterOtlpEndpoint?.toString() + "/v1/traces",
@@ -102,17 +96,18 @@ export default class Telemetry {
         headers: OpenTelemetryExporterOtlpHeaders,
       }) as unknown as SpanExporter;
 
-      const webTraceExporter: WebSpanExporter =
-        traceExporter as unknown as WebSpanExporter;
-
-      provider.addSpanProcessor(new BatchSpanProcessor(webTraceExporter));
+      const providerConfig: TracerConfig = {
+        resource: resourceFromAttributes({
+          [ATTR_SERVICE_NAME]: data.serviceName,
+        }),
+        // Stamp global RUM attributes (userId, projectId, ...) onto every span.
+        spanProcessors: [
+          new BatchSpanProcessor(traceExporter),
+          new GlobalAttributeSpanProcessor() as unknown as SpanProcessor,
+        ],
+      };
 
-      // Stamp global RUM attributes (userId, projectId, ...) onto every span.
-      provider.addSpanProcessor(
-        new GlobalAttributeSpanProcessor() as unknown as Parameters<
-          WebTracerProvider["addSpanProcessor"]
-        >[0],
-      );
+      const provider: WebTracerProvider = new WebTracerProvider(providerConfig);
 
       provider.register({
         contextManager: new ZoneContextManager(),

package/UI/Utils/TelemetryService.ts

@@ -23,7 +23,8 @@ export const UNKNOWN_SERVICE_NAME: string = "Unknown Service";
  * 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.
+ * types (Host / DockerHost / KubernetesCluster / ProxmoxCluster /
+ * CephCluster) that have no Service row.
  */
 export interface ResolvedTelemetryResource {
   service?: Service;
@@ -66,8 +67,9 @@ export default class TelemetryServiceUtil {
    * old server-side `service` ORM relation on TelemetryException: a real
    * Service resolves from the loaded list, the unattributed bucket resolves
    * to the synthetic "Unknown Service", and Host / DockerHost /
-   * KubernetesCluster resolve to a type label (no Service row exists for
-   * them). Mirrors how the ClickHouse analytics rows are resolved.
+   * KubernetesCluster / ProxmoxCluster / CephCluster resolve to a type
+   * label (no Service row exists for them). Mirrors how the ClickHouse
+   * analytics rows are resolved.
    */
   public static resolveTelemetryResource(data: {
     primaryEntityId: ObjectID | string | null | undefined;
@@ -101,6 +103,8 @@ export default class TelemetryServiceUtil {
       [ServiceType.Host]: "Host telemetry",
       [ServiceType.DockerHost]: "Docker host telemetry",
       [ServiceType.KubernetesCluster]: "Kubernetes telemetry",
+      [ServiceType.ProxmoxCluster]: "Proxmox Cluster",
+      [ServiceType.CephCluster]: "Ceph Cluster",
     };
     const label: string | undefined = data.primaryEntityType
       ? typeLabels[data.primaryEntityType.toString()]

package/Utils/Dashboard/Components/DashboardCephOsdListComponent.ts

@@ -0,0 +1,63 @@
+import DashboardCephOsdListComponent from "../../../Types/Dashboard/DashboardComponents/DashboardCephOsdListComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import {
+  ComponentArgument,
+  ComponentInputType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import {
+  CephFiltersSection,
+  getCephCommonArguments,
+} from "./DashboardCephResourceListShared";
+
+export default class DashboardCephOsdListComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardCephOsdListComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.CephOsdList,
+      widthInDashboardUnits: 6,
+      heightInDashboardUnits: 4,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        maxRows: 25,
+        /*
+         * The classic "OSD wall" — a honeycomb where each cell is an
+         * OSD colored by up/in state — is the view operators expect
+         * for this widget, so honeycomb is the default. The list view
+         * stays one dropdown away.
+         */
+        viewMode: "honeycomb",
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardCephOsdListComponent>
+  > {
+    const args: Array<ComponentArgument<DashboardCephOsdListComponent>> =
+      getCephCommonArguments<DashboardCephOsdListComponent>();
+
+    args.push({
+      name: "State",
+      description: "Quick filter by OSD up/in state",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "stateFilter",
+      section: CephFiltersSection,
+      dropdownOptions: [
+        { label: "All", value: "" },
+        { label: "Up only", value: "up" },
+        { label: "Down only", value: "down" },
+        { label: "Out only", value: "out" },
+      ],
+    });
+
+    return args;
+  }
+}

package/Utils/Dashboard/Components/DashboardCephPoolListComponent.ts

@@ -0,0 +1,32 @@
+import DashboardCephPoolListComponent from "../../../Types/Dashboard/DashboardComponents/DashboardCephPoolListComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import { ComponentArgument } from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import { getCephCommonArguments } from "./DashboardCephResourceListShared";
+
+export default class DashboardCephPoolListComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardCephPoolListComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.CephPoolList,
+      widthInDashboardUnits: 6,
+      heightInDashboardUnits: 4,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        maxRows: 25,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardCephPoolListComponent>
+  > {
+    return getCephCommonArguments<DashboardCephPoolListComponent>();
+  }
+}

package/Utils/Dashboard/Components/DashboardCephResourceListShared.ts

@@ -0,0 +1,61 @@
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+  EntityFilterModelType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardBaseComponent from "../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import { getViewModeArgument } from "./DashboardListSharedArgs";
+
+export const CephDisplaySection: ComponentArgumentSection = {
+  name: "Display Options",
+  description: "Configure the widget title and row limit",
+  order: 1,
+};
+
+export const CephFiltersSection: ComponentArgumentSection = {
+  name: "Filters",
+  description: "Narrow down which resources are shown",
+  order: 2,
+  defaultCollapsed: true,
+};
+
+export function getCephCommonArguments<
+  T extends DashboardBaseComponent,
+>(): Array<ComponentArgument<T>> {
+  const args: Array<ComponentArgument<T>> = [];
+
+  args.push({
+    name: "Title",
+    description: "Header shown above the list",
+    required: false,
+    type: ComponentInputType.Text,
+    id: "title" as keyof T["arguments"],
+    section: CephDisplaySection,
+  });
+
+  args.push({
+    name: "Max Rows",
+    description: "Maximum number of rows to show",
+    required: false,
+    type: ComponentInputType.Number,
+    id: "maxRows" as keyof T["arguments"],
+    placeholder: "25",
+    section: CephDisplaySection,
+  });
+
+  args.push(getViewModeArgument<T>(CephDisplaySection));
+
+  args.push({
+    name: "Clusters",
+    description: "Show only resources from the selected Ceph clusters",
+    required: false,
+    type: ComponentInputType.EntityMultiSelectDropdown,
+    id: "cephClusterIds" as keyof T["arguments"],
+    placeholder: "All clusters",
+    section: CephFiltersSection,
+    entityFilterModelType: EntityFilterModelType.CephCluster,
+  });
+
+  return args;
+}

package/Utils/Dashboard/Components/DashboardProxmoxGuestListComponent.ts

@@ -0,0 +1,69 @@
+import DashboardProxmoxGuestListComponent from "../../../Types/Dashboard/DashboardComponents/DashboardProxmoxGuestListComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import {
+  ComponentArgument,
+  ComponentInputType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import {
+  ProxmoxFiltersSection,
+  getProxmoxCommonArguments,
+} from "./DashboardProxmoxResourceListShared";
+
+export default class DashboardProxmoxGuestListComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardProxmoxGuestListComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.ProxmoxGuestList,
+      widthInDashboardUnits: 6,
+      heightInDashboardUnits: 4,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        maxRows: 25,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardProxmoxGuestListComponent>
+  > {
+    const args: Array<ComponentArgument<DashboardProxmoxGuestListComponent>> =
+      getProxmoxCommonArguments<DashboardProxmoxGuestListComponent>();
+
+    args.push({
+      name: "Guest Type",
+      description: "Show only QEMU VMs or only LXC containers",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "guestTypeFilter",
+      section: ProxmoxFiltersSection,
+      dropdownOptions: [
+        { label: "All", value: "" },
+        { label: "QEMU VMs only", value: "qemu" },
+        { label: "LXC containers only", value: "lxc" },
+      ],
+    });
+
+    args.push({
+      name: "Status",
+      description: "Quick filter by guest run state",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "statusFilter",
+      section: ProxmoxFiltersSection,
+      dropdownOptions: [
+        { label: "All", value: "" },
+        { label: "Running only", value: "running" },
+        { label: "Stopped only", value: "stopped" },
+      ],
+    });
+
+    return args;
+  }
+}

package/Utils/Dashboard/Components/DashboardProxmoxNodeListComponent.ts

@@ -0,0 +1,55 @@
+import DashboardProxmoxNodeListComponent from "../../../Types/Dashboard/DashboardComponents/DashboardProxmoxNodeListComponent";
+import { ObjectType } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import DashboardBaseComponentUtil from "./DashboardBaseComponent";
+import {
+  ComponentArgument,
+  ComponentInputType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardComponentType from "../../../Types/Dashboard/DashboardComponentType";
+import {
+  ProxmoxFiltersSection,
+  getProxmoxCommonArguments,
+} from "./DashboardProxmoxResourceListShared";
+
+export default class DashboardProxmoxNodeListComponentUtil extends DashboardBaseComponentUtil {
+  public static override getDefaultComponent(): DashboardProxmoxNodeListComponent {
+    return {
+      _type: ObjectType.DashboardComponent,
+      componentType: DashboardComponentType.ProxmoxNodeList,
+      widthInDashboardUnits: 6,
+      heightInDashboardUnits: 4,
+      topInDashboardUnits: 0,
+      leftInDashboardUnits: 0,
+      componentId: ObjectID.generate(),
+      minHeightInDashboardUnits: 3,
+      minWidthInDashboardUnits: 6,
+      arguments: {
+        maxRows: 25,
+      },
+    };
+  }
+
+  public static override getComponentConfigArguments(): Array<
+    ComponentArgument<DashboardProxmoxNodeListComponent>
+  > {
+    const args: Array<ComponentArgument<DashboardProxmoxNodeListComponent>> =
+      getProxmoxCommonArguments<DashboardProxmoxNodeListComponent>();
+
+    args.push({
+      name: "Status",
+      description: "Quick filter by node availability",
+      required: false,
+      type: ComponentInputType.Dropdown,
+      id: "statusFilter",
+      section: ProxmoxFiltersSection,
+      dropdownOptions: [
+        { label: "All", value: "" },
+        { label: "Online only", value: "online" },
+        { label: "Offline only", value: "offline" },
+      ],
+    });
+
+    return args;
+  }
+}

package/Utils/Dashboard/Components/DashboardProxmoxResourceListShared.ts

@@ -0,0 +1,61 @@
+import {
+  ComponentArgument,
+  ComponentArgumentSection,
+  ComponentInputType,
+  EntityFilterModelType,
+} from "../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardBaseComponent from "../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import { getViewModeArgument } from "./DashboardListSharedArgs";
+
+export const ProxmoxDisplaySection: ComponentArgumentSection = {
+  name: "Display Options",
+  description: "Configure the widget title and row limit",
+  order: 1,
+};
+
+export const ProxmoxFiltersSection: ComponentArgumentSection = {
+  name: "Filters",
+  description: "Narrow down which resources are shown",
+  order: 2,
+  defaultCollapsed: true,
+};
+
+export function getProxmoxCommonArguments<
+  T extends DashboardBaseComponent,
+>(): Array<ComponentArgument<T>> {
+  const args: Array<ComponentArgument<T>> = [];
+
+  args.push({
+    name: "Title",
+    description: "Header shown above the list",
+    required: false,
+    type: ComponentInputType.Text,
+    id: "title" as keyof T["arguments"],
+    section: ProxmoxDisplaySection,
+  });
+
+  args.push({
+    name: "Max Rows",
+    description: "Maximum number of rows to show",
+    required: false,
+    type: ComponentInputType.Number,
+    id: "maxRows" as keyof T["arguments"],
+    placeholder: "25",
+    section: ProxmoxDisplaySection,
+  });
+
+  args.push(getViewModeArgument<T>(ProxmoxDisplaySection));
+
+  args.push({
+    name: "Clusters",
+    description: "Show only resources from the selected Proxmox clusters",
+    required: false,
+    type: ComponentInputType.EntityMultiSelectDropdown,
+    id: "proxmoxClusterIds" as keyof T["arguments"],
+    placeholder: "All clusters",
+    section: ProxmoxFiltersSection,
+    entityFilterModelType: EntityFilterModelType.ProxmoxCluster,
+  });
+
+  return args;
+}