@oneuptime/common 11.0.10 → 11.0.13

package/Server/Utils/Workspace/Slack/app-manifest.json

@@ -1,97 +1,91 @@
 {
-    "display_information": {
-        "name": "OneUptime",
-        "description": "The Complete Open-Source Observability Platform",
-        "background_color": "#000000",
-        "long_description": "OneUptime is a comprehensive solution for monitoring and managing your online services. Whether you need to check the availability of your website, dashboard, API, or any other online resource, OneUptime can alert your team when downtime happens and keep your customers informed with a status page. OneUptime also helps you handle incidents, set up on-call rotations, run tests, secure your services, analyze logs, track performance, and debug errors."
-    },
+  "display_information": {
+    "name": "OneUptime",
+    "description": "The Complete Open-Source Observability Platform",
+    "background_color": "#000000",
+    "long_description": "OneUptime is a comprehensive solution for monitoring and managing your online services. Whether you need to check the availability of your website, dashboard, API, or any other online resource, OneUptime can alert your team when downtime happens and keep your customers informed with a status page. OneUptime also helps you handle incidents, set up on-call rotations, run tests, secure your services, analyze logs, track performance, and debug errors."
+  },
 
-    "features": {
-        "app_home": {
-            "home_tab_enabled": false,
-            "messages_tab_enabled": true,
-            "messages_tab_read_only_enabled": false
-        },
-        "bot_user": {
-            "display_name": "OneUptime",
-            "always_online": true
-        },
-        "shortcuts": [
-            {
-                "name": "Create Scheduled Event",
-                "type": "global",
-                "callback_id": "/maintenance",
-                "description": "Create a new scheduled event in OneUptime"
-            },
-            {
-                "name": "Create New Incident",
-                "type": "global",
-                "callback_id": "/incident",
-                "description": "Creates a new incident in OneUptime"
-            }
-        ],
-        "slash_commands": [
-            {
-                "command": "/incident",
-                "url": "{{SERVER_URL}}/api/slack/interactive",
-                "description": "Create a new Incident in OneUptime",
-                "usage_hint": "[incident title]",
-                "should_escape": false
-            },
-            {
-                "command": "/maintenance",
-                "url": "{{SERVER_URL}}/api/slack/interactive",
-                "description": "Create a new Scheduled Maintenance in OneUptime",
-                "usage_hint": "[maintenance title]",
-                "should_escape": false
-            }
-        ]
+  "features": {
+    "app_home": {
+      "home_tab_enabled": false,
+      "messages_tab_enabled": true,
+      "messages_tab_read_only_enabled": false
+    },
+    "bot_user": {
+      "display_name": "OneUptime",
+      "always_online": true
     },
-    "oauth_config": {
-        "redirect_urls": [
-            "{{SERVER_URL}}/api/slack/auth"
-        ],
-        "scopes": {
-            "user": [
-                "users:read"
-            ],
-            "bot": [
-                "commands",
-                "channels:history",
-                "channels:join",
-                "channels:manage",
-                "channels:read",
-                "channels:write.invites",
-                "channels:write.topic",
-                "chat:write",
-                "users:read",
-                "groups:read",
-                "groups:write",
-                "groups:history",
-                "im:read",
-                "im:write",
-                "im:history",
-                "mpim:read",
-                "mpim:write",
-                "mpim:history",
-                "reactions:read"
-            ]
-        }
+    "shortcuts": [
+      {
+        "name": "Create Scheduled Event",
+        "type": "global",
+        "callback_id": "/maintenance",
+        "description": "Create a new scheduled event in OneUptime"
+      },
+      {
+        "name": "Create New Incident",
+        "type": "global",
+        "callback_id": "/incident",
+        "description": "Creates a new incident in OneUptime"
+      }
+    ],
+    "slash_commands": [
+      {
+        "command": "/incident",
+        "url": "{{SERVER_URL}}/api/slack/interactive",
+        "description": "Create a new Incident in OneUptime",
+        "usage_hint": "[incident title]",
+        "should_escape": false
+      },
+      {
+        "command": "/maintenance",
+        "url": "{{SERVER_URL}}/api/slack/interactive",
+        "description": "Create a new Scheduled Maintenance in OneUptime",
+        "usage_hint": "[maintenance title]",
+        "should_escape": false
+      }
+    ]
+  },
+  "oauth_config": {
+    "redirect_urls": ["{{SERVER_URL}}/api/slack/auth"],
+    "scopes": {
+      "user": ["users:read"],
+      "bot": [
+        "commands",
+        "channels:history",
+        "channels:join",
+        "channels:manage",
+        "channels:read",
+        "channels:write.invites",
+        "channels:write.topic",
+        "chat:write",
+        "users:read",
+        "groups:read",
+        "groups:write",
+        "groups:history",
+        "im:read",
+        "im:write",
+        "im:history",
+        "mpim:read",
+        "mpim:write",
+        "mpim:history",
+        "reactions:read"
+      ]
+    }
+  },
+  "settings": {
+    "interactivity": {
+      "is_enabled": true,
+      "request_url": "{{SERVER_URL}}/api/slack/interactive",
+      "message_menu_options_url": "{{SERVER_URL}}/api/slack/options-load"
     },
-    "settings": {
-        "interactivity": {
-            "is_enabled": true,
-            "request_url": "{{SERVER_URL}}/api/slack/interactive",
-            "message_menu_options_url": "{{SERVER_URL}}/api/slack/options-load"
-        },
-        "org_deploy_enabled": true,
-        "socket_mode_enabled": false,
-        "token_rotation_enabled": false,
-        "event_subscriptions": {
-            "request_url": "{{SERVER_URL}}/api/slack/events",
-            "bot_events": [
-                "reaction_added"
-            ]
-        }
+    "org_deploy_enabled": true,
+    "socket_mode_enabled": false,
+    "token_rotation_enabled": false,
+    "event_subscriptions": {
+      "request_url": "{{SERVER_URL}}/api/slack/events",
+      "bot_events": ["reaction_added"]
     }
-}
+  }
+}

package/Tests/Server/Services/UpdateColumnsByIdWithoutHooks.test.ts

@@ -0,0 +1,154 @@
+import ServiceService from "../../../Server/Services/ServiceService";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, afterEach } from "@jest/globals";
+
+/*
+ * DatabaseService.updateColumnsByIdWithoutHooks is the fast heartbeat write
+ * path behind ServiceService.updateLastSeen. It exists to keep the single
+ * hottest UPDATE in the system (lastSeenAt, bumped on every telemetry batch)
+ * out of the full updateOneById pipeline, which holds the row's write lock
+ * across several round trips and was observed heading a Postgres lock convoy
+ * that starved the connection pool.
+ *
+ * These tests mock the TypeORM manager (no Postgres) and lock in the two
+ * invariants that make the fix work:
+ *   - it emits exactly ONE parameterized UPDATE, and
+ *   - it NEVER rewrites the optimistic-lock `version` column (a regression
+ *     here would re-introduce the contention the fix removed).
+ */
+
+type QueryCall = [string, Array<unknown>];
+
+const SERVICE_COLUMNS: Record<string, string> = {
+  lastSeenAt: "lastSeenAt",
+  serviceVersion: "serviceVersion",
+  deploymentEnvironment: "deploymentEnvironment",
+};
+
+/*
+ * Stand-in for the TypeORM driver's persist path. The real method applies
+ * column transformers (ObjectID -> uuid string, JSON.stringify, etc.); we
+ * model that here by wrapping a string value in `prepared(...)` so a test
+ * can assert the column value was routed through it rather than bound raw.
+ */
+function fakePreparePersistentValue(value: unknown): unknown {
+  return typeof value === "string" ? `prepared(${value})` : value;
+}
+
+function mockRepository(result: unknown = []): jest.Mock {
+  const query: jest.Mock = jest.fn().mockResolvedValue(result);
+  jest.spyOn(ServiceService, "getRepository").mockReturnValue({
+    manager: {
+      query,
+      connection: {
+        driver: { preparePersistentValue: fakePreparePersistentValue },
+      },
+    },
+    metadata: {
+      tableName: "Service",
+      primaryColumns: [{ databaseName: "_id" }],
+      updateDateColumn: { databaseName: "updatedAt" },
+      findColumnWithPropertyName: (propertyName: string) => {
+        return SERVICE_COLUMNS[propertyName]
+          ? { databaseName: SERVICE_COLUMNS[propertyName] }
+          : undefined;
+      },
+    },
+  } as any);
+  return query;
+}
+
+describe("DatabaseService.updateColumnsByIdWithoutHooks", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("emits a single UPDATE and never bumps the version column", async () => {
+    const query: jest.Mock = mockRepository();
+    const id: ObjectID = ObjectID.generate();
+    const lastSeenAt: Date = new Date();
+
+    await ServiceService.updateColumnsByIdWithoutHooks({
+      id,
+      data: { lastSeenAt } as never,
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    const [sql, params] = query.mock.calls[0] as QueryCall;
+
+    // The whole point of the fix: no optimistic-lock churn on the hot row.
+    expect(sql).not.toContain("version");
+    // updatedAt is still refreshed, exactly as the normal update path does.
+    expect(sql).toContain(`"updatedAt" = CURRENT_TIMESTAMP`);
+    expect(sql).toBe(
+      `UPDATE "Service" SET "lastSeenAt" = $1, "updatedAt" = CURRENT_TIMESTAMP WHERE "_id" = $2`,
+    );
+    expect(params).toEqual([lastSeenAt, id.toString()]);
+  });
+
+  test("maps multiple entity properties to columns in stable param order", async () => {
+    const query: jest.Mock = mockRepository();
+    const id: ObjectID = ObjectID.generate();
+    const lastSeenAt: Date = new Date();
+
+    await ServiceService.updateColumnsByIdWithoutHooks({
+      id,
+      data: {
+        lastSeenAt,
+        serviceVersion: "1.2.3",
+        deploymentEnvironment: "production",
+      } as never,
+    });
+
+    const [sql, params] = query.mock.calls[0] as QueryCall;
+    expect(sql).toBe(
+      `UPDATE "Service" SET "lastSeenAt" = $1, "serviceVersion" = $2, ` +
+        `"deploymentEnvironment" = $3, "updatedAt" = CURRENT_TIMESTAMP WHERE "_id" = $4`,
+    );
+    /*
+     * Column values are routed through the driver's persist path (here the
+     * `prepared(...)` stand-in), so transformers/JSON/coercion apply exactly
+     * as save() would. The `_id` in the WHERE clause is bound raw.
+     */
+    expect(params).toEqual([
+      lastSeenAt,
+      "prepared(1.2.3)",
+      "prepared(production)",
+      id.toString(),
+    ]);
+  });
+
+  test("throws on an unknown column instead of silently writing nothing", async () => {
+    mockRepository();
+    await expect(
+      ServiceService.updateColumnsByIdWithoutHooks({
+        id: ObjectID.generate(),
+        data: { notAColumn: "x" } as never,
+      }),
+    ).rejects.toThrow(/unknown column "notAColumn"/);
+  });
+
+  test("rejects SQL-expression (function) values it cannot bind", async () => {
+    const query: jest.Mock = mockRepository();
+    await expect(
+      ServiceService.updateColumnsByIdWithoutHooks({
+        id: ObjectID.generate(),
+        data: {
+          lastSeenAt: (() => {
+            return "NOW()";
+          }) as never,
+        } as never,
+      }),
+    ).rejects.toThrow(/SQL-expression values are not supported/);
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  test("does not issue a query when there are no columns to update", async () => {
+    const query: jest.Mock = mockRepository();
+    await ServiceService.updateColumnsByIdWithoutHooks({
+      id: ObjectID.generate(),
+      data: {} as never,
+    });
+    expect(query).not.toHaveBeenCalled();
+  });
+});

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -111,12 +111,15 @@ describe("StatementGenerator", () => {
       expect(jest.mocked(logger.debug)).toHaveBeenNthCalledWith(2, statement);
 
       /* eslint-disable prettier/prettier */
-            expectStatement(statement, SQL`
-                ALTER TABLE ${'oneuptime'}.${'<table-name>'}
+      expectStatement(
+        statement,
+        SQL`
+                ALTER TABLE ${"oneuptime"}.${"<table-name>"}
                 UPDATE <set-statement>
                 WHERE TRUE <where-statement>
-            `);
-            /* eslint-enable prettier/prettier */
+            `,
+      );
+      /* eslint-enable prettier/prettier */
     });
   });
 
@@ -633,6 +636,81 @@ describe("StatementGenerator", () => {
     });
   });
 
+  describe("toCreateStatement", () => {
+    /*
+     * Regression test for the escapeStringLiteral undefined/null guard.
+     * An ArrayText (Array(String)) column whose value array carried
+     * undefined/null members at runtime used to throw
+     * "TypeError: Cannot read properties of undefined (reading 'replace')"
+     * inside escapeStringLiteral while building the INSERT. The member is
+     * now rendered as the empty string literal '' so the statement still
+     * serializes to a valid ClickHouse Array(String).
+     */
+    class ArrayTextModel extends AnalyticsBaseModel {
+      public constructor() {
+        super({
+          tableName: "<array-create-table>",
+          singularName: "<singular>",
+          pluralName: "<plural>",
+          tableColumns: [
+            new AnalyticsTableColumn({
+              key: "_id",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              type: TableColumnType.ObjectID,
+            }),
+            new AnalyticsTableColumn({
+              key: "entityKeys",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              defaultValue: [],
+              type: TableColumnType.ArrayText,
+            }),
+          ],
+          crudApiPath: new Route("route"),
+          primaryKeys: ["_id"],
+          sortKeys: ["_id"],
+          partitionKey: "_id",
+          tableEngine: AnalyticsTableEngine.MergeTree,
+        });
+      }
+    }
+
+    let arrayTextGenerator: StatementGenerator<ArrayTextModel>;
+    beforeEach(() => {
+      arrayTextGenerator = new StatementGenerator<ArrayTextModel>({
+        modelType: ArrayTextModel,
+        database: ClickhouseAppInstance,
+      });
+    });
+
+    test("renders undefined/null ArrayText elements as '' instead of throwing", () => {
+      const item: ArrayTextModel = new ArrayTextModel();
+      item.setColumnValue("_id", "210dac24142f1baa");
+      /*
+       * Simulate runtime data where the Array(String) column carries
+       * undefined/null members. The type system models the column as
+       * string[], hence the cast — this is exactly what crashed before
+       * the guard was added.
+       */
+      item.setColumnValue("entityKeys", [
+        "alpha",
+        undefined,
+        null,
+        "beta",
+      ] as unknown as Array<string>);
+
+      let statement: string = "";
+      expect(() => {
+        statement = arrayTextGenerator.toCreateStatement({ item: [item] });
+      }).not.toThrow();
+
+      expect(statement).toContain("['alpha', '', '', 'beta']");
+    });
+  });
+
   describe("toSelectStatement", () => {
     test("should return the contents of a SELECT statement", () => {
       const { statement, columns } = generator.toSelectStatement({
@@ -790,18 +868,18 @@ describe("StatementGenerator", () => {
       expect(jest.mocked(logger.debug)).toHaveBeenNthCalledWith(2, statement);
 
       /* eslint-disable prettier/prettier */
-            const expectedStatement: Statement = SQL`
-            CREATE TABLE IF NOT EXISTS ${'oneuptime'}.${'<table-name>'}
+      const expectedStatement: Statement = SQL`
+            CREATE TABLE IF NOT EXISTS ${"oneuptime"}.${"<table-name>"}
     (
         <columns-create-statement>
     )
     ENGINE = MergeTree
 PARTITION BY (column_ObjectID)
 
-    PRIMARY KEY (${'column_ObjectID'})
-    ORDER BY (${'column_ObjectID'})
+    PRIMARY KEY (${"column_ObjectID"})
+    ORDER BY (${"column_ObjectID"})
     `;
-            /* eslint-enable prettier/prettier */
+      /* eslint-enable prettier/prettier */
 
       // Normalize whitespace for comparison to avoid formatting issues
       const normalizeWhitespace: (s: string) => string = (

package/Tests/Types/DiskSize.test.ts

@@ -0,0 +1,49 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import DiskSize from "../../Types/DiskSize";
+
+describe("DiskSize", () => {
+  describe("convertToDecimalPlaces", () => {
+    test("rounds to 2 decimal places by default", () => {
+      expect(DiskSize.convertToDecimalPlaces(3.14159)).toBe(3.14);
+    });
+
+    test("rounds to the requested number of decimal places", () => {
+      expect(DiskSize.convertToDecimalPlaces(3.14159, 3)).toBe(3.142);
+    });
+
+    test("returns the ceiling when decimalPlaces is 0", () => {
+      expect(DiskSize.convertToDecimalPlaces(4.2, 0)).toBe(5);
+      expect(DiskSize.convertToDecimalPlaces(4, 0)).toBe(4);
+    });
+
+    test("parses a string value before rounding", () => {
+      expect(
+        DiskSize.convertToDecimalPlaces("2.71828" as unknown as number),
+      ).toBe(2.72);
+    });
+
+    test("throws a BadDataException when decimalPlaces is negative", () => {
+      expect(() => {
+        return DiskSize.convertToDecimalPlaces(1.5, -1);
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("byteSizeToGB", () => {
+    test("converts bytes to gigabytes", () => {
+      expect(DiskSize.byteSizeToGB(1024 * 1024 * 1024)).toBe(1);
+    });
+  });
+
+  describe("byteSizeToMB", () => {
+    test("converts bytes to megabytes", () => {
+      expect(DiskSize.byteSizeToMB(1024 * 1024)).toBe(1);
+    });
+  });
+
+  describe("byteSizeToKB", () => {
+    test("converts bytes to kilobytes", () => {
+      expect(DiskSize.byteSizeToKB(1024)).toBe(1);
+    });
+  });
+});

package/Types/Dashboard/DashboardComponents/DashboardTableComponent.ts

@@ -2,6 +2,8 @@ import MetricFormulaConfigData from "../../Metrics/MetricFormulaConfigData";
 import MetricQueryConfigData from "../../Metrics/MetricQueryConfigData";
 import MetricsAggregationType from "../../Metrics/MetricsAggregationType";
 import ObjectID from "../../ObjectID";
+import Dictionary from "../../Dictionary";
+import { DictionaryEntryValue } from "../../../UI/Components/Dictionary/DictionaryFilterOperator";
 import DashboardComponentType from "../DashboardComponentType";
 import BaseComponent from "./DashboardBaseComponent";
 
@@ -76,6 +78,15 @@ export default interface DashboardTableComponent extends BaseComponent {
     maxRows?: number | undefined;
     reduce?: TableReduce | undefined;
     decimals?: number | undefined;
+    /*
+     * Widget-level attribute filter applied to EVERY metric column's query
+     * (e.g. deployment.environment = production, so the table only shows
+     * hosts/services in that environment). Stored in the same operator-aware
+     * shape the chart widget writes into filterData.attributes, so it flows
+     * straight through MetricUtil.fetchResults' sanitizeAttributeFilters with
+     * no backend changes. Empty/undefined = no filter (every series shown).
+     */
+    attributeFilters?: Dictionary<DictionaryEntryValue> | undefined;
     /*
      * Legacy widget shape from before the columns/groupByAttributes
      * redesign — read-only at render time, never written by the editor.

package/Types/Icon/IconProp.ts

@@ -324,6 +324,7 @@ enum IconProp {
   XCircle = "XCircle",
   Kubernetes = "Kubernetes",
   Docker = "Docker",
+  DockerSwarm = "DockerSwarm",
   Podman = "Podman",
   Proxmox = "Proxmox",
   Ceph = "Ceph",

package/Types/Monitor/MonitorType.ts

@@ -93,36 +93,20 @@ export class MonitorTypeHelper {
         monitorTypes: [MonitorType.IncomingRequest, MonitorType.IncomingEmail],
       },
       {
-        label: "Infrastructure",
+        label: "Network",
         monitorTypes: [MonitorType.SNMP],
       },
       {
-        label: "Kubernetes",
-        monitorTypes: [MonitorType.Kubernetes],
-      },
-      {
-        label: "Docker",
-        monitorTypes: [MonitorType.Docker],
-      },
-      {
-        label: "Host",
-        monitorTypes: [MonitorType.Host],
-      },
-      {
-        label: "Podman",
-        monitorTypes: [MonitorType.Podman],
-      },
-      {
-        label: "Docker Swarm",
-        monitorTypes: [MonitorType.DockerSwarm],
-      },
-      {
-        label: "Proxmox",
-        monitorTypes: [MonitorType.Proxmox],
-      },
-      {
-        label: "Ceph",
-        monitorTypes: [MonitorType.Ceph],
+        label: "Infrastructure",
+        monitorTypes: [
+          MonitorType.Host,
+          MonitorType.Kubernetes,
+          MonitorType.Docker,
+          MonitorType.Podman,
+          MonitorType.DockerSwarm,
+          MonitorType.Proxmox,
+          MonitorType.Ceph,
+        ],
       },
       {
         label: "Telemetry",
@@ -225,28 +209,28 @@ export class MonitorTypeHelper {
         title: "Podman Container",
         description:
           "This monitor type lets you monitor Podman containers — CPU, memory, network, restarts, and lifecycle events.",
-        icon: IconProp.Cube,
+        icon: IconProp.Podman,
       },
       {
         monitorType: MonitorType.DockerSwarm,
         title: "Docker Swarm",
         description:
           "This monitor type lets you monitor Docker Swarm clusters — per-task container CPU, memory, network, process count, and uptime across the cluster's services and nodes.",
-        icon: IconProp.Cube,
+        icon: IconProp.DockerSwarm,
       },
       {
         monitorType: MonitorType.Proxmox,
         title: "Proxmox",
         description:
           "This monitor type lets you monitor Proxmox VE clusters — node availability, VM and container (guest) health, CPU, memory, storage, and HA state.",
-        icon: IconProp.ServerStack,
+        icon: IconProp.Proxmox,
       },
       {
         monitorType: MonitorType.Ceph,
         title: "Ceph",
         description:
           "This monitor type lets you monitor Ceph storage clusters — cluster health, monitor quorum, OSD availability, pool capacity, and placement group states.",
-        icon: IconProp.Database,
+        icon: IconProp.Ceph,
       },
       {
         monitorType: MonitorType.IP,