feat: Health Monitoring widget unification with graphs

packages/api/src/router/widgets/health-monitoring.ts

@@ -1,42 +1,51 @@
 import { observable } from "@trpc/server/observable";
 
+import type { Modify } from "@homarr/common/types";
+import type { Integration } from "@homarr/db/schema/sqlite";
+import type { IntegrationKindByCategory } from "@homarr/definitions";
 import type { HealthMonitoring } from "@homarr/integrations";
-import type { ProxmoxClusterInfo } from "@homarr/integrations/types";
-import { clusterInfoRequestHandler, systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
+import { systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
 
-import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
+import { createManyIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
+import { z } from "zod";
 
 export const healthMonitoringRouter = createTRPCRouter({
-  getSystemHealthStatus: publicProcedure
-    .unstable_concat(createManyIntegrationMiddleware("query", "openmediavault", "dashDot"))
-    .query(async ({ ctx }) => {
+  getHealthStatus: publicProcedure
+    .input(z.object({ pointCount: z.number().optional(), maxElements: z.number().optional() }))
+    .unstable_concat(createManyIntegrationMiddleware("query", "openmediavault", "dashDot", "proxmox"))
+    .query(async ({ input: { pointCount = 1, maxElements = 32 }, ctx }) => {
       return await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = systemInfoRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        ctx.integrations.map(async (integrationWithSecrets) => {
+          const innerHandler = systemInfoRequestHandler.handler(integrationWithSecrets, { maxElements, pointCount });
+          const healthInfo = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+
+          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
 
           return {
-            integrationId: integration.id,
-            integrationName: integration.name,
-            healthInfo: data,
-            updatedAt: timestamp,
+            integration,
+            healthInfo,
           };
         }),
       );
     }),
-  subscribeSystemHealthStatus: publicProcedure
-    .unstable_concat(createManyIntegrationMiddleware("query", "openmediavault", "dashDot"))
-    .subscription(({ ctx }) => {
-      return observable<{ integrationId: string; healthInfo: HealthMonitoring; timestamp: Date }>((emit) => {
+
+  subscribeHealthStatus: publicProcedure
+    .input(z.object({ maxElements: z.number().optional() }))
+    .unstable_concat(createManyIntegrationMiddleware("query", "openmediavault", "dashDot", "proxmox"))
+    .subscription(({ ctx, input: { maxElements = 32 } }) => {
+      return observable<{
+        integration: Modify<Integration, { kind: IntegrationKindByCategory<"healthMonitoring"> }>;
+        healthInfo: { data: HealthMonitoring; timestamp: Date };
+      }>((emit) => {
         const unsubscribes: (() => void)[] = [];
-        for (const integration of ctx.integrations) {
-          const innerHandler = systemInfoRequestHandler.handler(integration, {});
-          const unsubscribe = innerHandler.subscribe((healthInfo) => {
+        for (const integrationWithSecrets of ctx.integrations) {
+          const innerHandler = systemInfoRequestHandler.handler(integrationWithSecrets, { maxElements, pointCount: 1 });
+          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
+          const unsubscribe = innerHandler.subscribe((data) => {
             emit.next({
-              integrationId: integration.id,
-              healthInfo,
-              timestamp: new Date(),
+              integration,
+              healthInfo: { data, timestamp: new Date() },
             });
           });
           unsubscribes.push(unsubscribe);
@@ -48,26 +57,4 @@ export const healthMonitoringRouter = createTRPCRouter({
         };
       });
     }),
-  getClusterHealthStatus: publicProcedure
-    .unstable_concat(createOneIntegrationMiddleware("query", "proxmox"))
-    .query(async ({ ctx }) => {
-      const innerHandler = clusterInfoRequestHandler.handler(ctx.integration, {});
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-      return data;
-    }),
-  subscribeClusterHealthStatus: publicProcedure
-    .unstable_concat(createOneIntegrationMiddleware("query", "proxmox"))
-    .subscription(({ ctx }) => {
-      return observable<ProxmoxClusterInfo>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        const innerHandler = clusterInfoRequestHandler.handler(ctx.integration, {});
-        const unsubscribe = innerHandler.subscribe((healthInfo) => {
-          emit.next(healthInfo);
-        });
-        unsubscribes.push(unsubscribe);
-        return () => {
-          unsubscribe();
-        };
-      });
-    }),
 });

packages/cron-jobs/src/jobs/integrations/health-monitoring.ts

@@ -1,23 +1,14 @@
 import { EVERY_5_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { clusterInfoRequestHandler, systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
+import { systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
 import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
 
 import { createCronJob } from "../../lib";
 
 export const healthMonitoringJob = createCronJob("healthMonitoring", EVERY_5_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(
-    (integration, itemOptions: Record<string, never>) => {
-      const { kind } = integration;
-      if (kind !== "proxmox") {
-        return systemInfoRequestHandler.handler({ ...integration, kind }, itemOptions);
-      }
-      return clusterInfoRequestHandler.handler({ ...integration, kind }, itemOptions);
+  createRequestIntegrationJobHandler(systemInfoRequestHandler.handler, {
+    widgetKinds: ["healthMonitoring"],
+    getInput: {
+      healthMonitoring: (options) => ({ maxElements: Number(options.pointDensity), pointCount: 1 }),
     },
-    {
-      widgetKinds: ["healthMonitoring"],
-      getInput: {
-        healthMonitoring: () => ({}),
-      },
-    },
-  ),
+  }),
 );

packages/definitions/src/integration.ts

@@ -220,7 +220,8 @@ export type IntegrationCategory =
   | "miscellaneous"
   | "smartHomeServer"
   | "indexerManager"
-  | "healthMonitoring"
   | "search"
   | "mediaTranscoding"
-  | "networkController";
+  | "networkController"
+  | "healthMonitoring"
+  | "tempNone";

packages/integrations/src/base/creator.ts

@@ -12,6 +12,7 @@
 import { SabnzbdIntegration } from "../download-client/sabnzbd/sabnzbd-integration";
 import { TransmissionIntegration } from "../download-client/transmission/transmission-integration";
 import { EmbyIntegration } from "../emby/emby-integration";
+import { DashDotIntegration } from "../health-monitoring/dashdot/dashdot-integration";
 import { HomeAssistantIntegration } from "../homeassistant/homeassistant-integration";
 import { JellyfinIntegration } from "../jellyfin/jellyfin-integration";
 import { JellyseerrIntegration } from "../jellyseerr/jellyseerr-integration";
@@ -43,10 +44,10 @@
 
   // factories are an array, to differentiate in js between class constructors and functions
   if (Array.isArray(creator)) {
     return (await creator[0](integration)) as IntegrationInstanceOfKind<TKind>;
   }
 
   return new creator(integration) as IntegrationInstanceOfKind<TKind>;
 };
 
 export const createIntegrationAsyncFromSecrets = <TKind extends keyof typeof integrationCreators>(
@@ -86,7 +87,7 @@
   openmediavault: OpenMediaVaultIntegration,
   lidarr: LidarrIntegration,
   readarr: ReadarrIntegration,
   dashDot: DashDotIntegration,
   tdarr: TdarrIntegration,
   proxmox: ProxmoxIntegration,
   emby: EmbyIntegration,

packages/integrations/src/health-monitoring/dashdot/dashdot-integration.ts

@@ -0,0 +1,80 @@
+import type { z, ZodType } from "zod";
+
+import type { HealthMonitoring } from "../../interfaces/health-monitoring/healt-monitoring-data";
+import { HealthMonitoringIntegration } from "../../interfaces/health-monitoring/health-monitoring-interface";
+import {
+  configSchema,
+  cpuLoadSchema,
+  memoryLoadSchema,
+  networkLoadSchema,
+  serverInfoSchema,
+  storageLoadSchema,
+} from "./dashdot-schema";
+import { fetchWithTrustedCertificatesAsync } from "@homarr/certificates/server";
+
+export class DashDotIntegration extends HealthMonitoringIntegration {
+  public async testConnectionAsync(): Promise<void> {
+    const response = await fetchWithTrustedCertificatesAsync(this.url("/info"));
+    await response.json();
+  }
+
+  public async getSystemInfoAsync(): Promise<HealthMonitoring> {
+    const { config } = await this.dashDotApiCallAsync("/config", configSchema);
+    const info = await this.dashDotApiCallAsync("/info", serverInfoSchema);
+    const cpuLoad = await this.dashDotApiCallAsync("/load/cpu", cpuLoadSchema);
+    const memoryLoad = await this.dashDotApiCallAsync("/load/ram", memoryLoadSchema);
+    const storageLoad = await this.dashDotApiCallAsync("/load/storage", storageLoadSchema);
+    const networkLoad = await this.dashDotApiCallAsync("/load/network", networkLoadSchema);
+    return {
+      system: {
+        name: config.override.os ?? info.os.distro,
+        type: "single",
+        version: info.os.release,
+        uptime: info.os.uptime * 1000,
+      },
+      cpu: cpuLoad.map((cpu) => {
+        return {
+          id: `${cpu.core}`,
+          name: `${cpu.core}`,
+          temp: cpu.temp ? (config.use_imperial ? (cpu.temp - 32) / 1.8 : cpu.temp) : undefined,
+          maxValue: 100,
+        };
+      }),
+      memory: [
+        {
+          id: "unique",
+          name: `${config.override.ram_brand ?? info.ram.layout[0].brand} - ${config.override.ram_type ?? info.ram.layout[0].type}`,
+          maxValue: config.override.ram_size ?? info.ram.size,
+        },
+      ],
+      storage: info.storage.map((storage, index) => {
+        return {
+          name: storage.disks.map((disk) => config.override.storage_brands?.[disk.brand] ?? disk.brand).join(", "),
+          used: storageLoad[index] ?? -1,
+          size: storage.size,
+        };
+      }),
+      network: [
+        {
+          id: "unique",
+          name: config.use_network_interface,
+          maxValue: ((config.override.network_interface_speed ?? info.network.interfaceSpeed) * 1000 ** 3) / 8,
+        },
+      ],
+      history: [
+        {
+          timestamp: Date.now(),
+          cpu: cpuLoad.map(({ core, load }) => ({ id: `${core}`, value: load })),
+          memory: [{ id: "unique", value: memoryLoad.load }],
+          networkUp: [{ id: "unique", value: Math.round(networkLoad.up) }],
+          networkDown: [{ id: "unique", value: Math.round(networkLoad.down) }],
+        },
+      ],
+    };
+  }
+
+  private async dashDotApiCallAsync<T extends ZodType>(path: `/${string}`, schema: T): Promise<z.infer<T>> {
+    const response = await fetchWithTrustedCertificatesAsync(this.url(path));
+    return await schema.parseAsync(await response.json()) as Promise<z.infer<T>>;
+  }
+}