@oneuptime/common 11.0.9 → 11.0.12

package/Server/Services/KubernetesClusterService.ts

@@ -193,12 +193,14 @@ export class Service extends DatabaseService<Model> {
       data.agentVersion = extra.agentVersion;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: clusterId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/PodmanHostService.ts

@@ -236,12 +236,14 @@ export class Service extends DatabaseService<Model> {
       data.agentVersion = extra.agentVersion;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: hostId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ProbeService.ts

@@ -120,14 +120,20 @@ export class Service extends DatabaseService<Model> {
 
     const now: Date = OneUptimeDate.getCurrentDate();
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump. This fires from the probe-auth middleware on every
+     * authenticated probe request, so it must not head the hot-row Postgres
+     * lock convoy the full updateOneById pipeline causes. A lastAlive-only
+     * write never sets connectionStatus, so the connection-status-change
+     * hooks (onBeforeUpdate/onUpdateSuccess) are inert here. See
+     * ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: probeId,
       data: {
         lastAlive: now,
       },
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ProxmoxClusterService.ts

@@ -250,12 +250,14 @@ export class Service extends DatabaseService<Model> {
       data.guestsWithoutBackupCount = extra.guestsWithoutBackupCount;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: clusterId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/RumApplicationService.ts

@@ -185,12 +185,14 @@ export class Service extends DatabaseService<Model> {
       data.sdkLanguage = extra.sdkLanguage;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: rumApplicationId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ServerlessFunctionService.ts

@@ -229,12 +229,14 @@ export class Service extends DatabaseService<Model> {
       data.runtimeVersion = extra.runtimeVersion;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: serverlessFunctionId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ServiceService.ts

@@ -198,12 +198,25 @@ export class Service extends DatabaseService<Model> {
       data.cloudAccountId = extra.cloudAccountId;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write. This is the single hottest UPDATE in the system —
+     * every telemetry batch for a service re-resolves the same serviceId —
+     * so it must NOT go through the full updateOneById pipeline (permission
+     * SELECT -> _findBy SELECT -> save() with `version = version + 1` ->
+     * workflow/realtime/audit hooks). That pipeline holds the Service row's
+     * write lock across several round trips and, when an event loop stalls
+     * mid-`save()` transaction, leaves it open as the head of a lock convoy
+     * that starves the Postgres connection pool. lastSeenAt is an internal
+     * liveness timestamp with no onBeforeUpdate/onUpdateSuccess hooks on this
+     * model (connected / disconnected status is derived from it at read
+     * time), so a bare single-statement UPDATE is both correct and far
+     * cheaper. This also intentionally drops the per-update workflow trigger
+     * Service's @EnableWorkflow({ update: true }) fired on every heartbeat —
+     * a liveness ping should not trigger user workflows.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: serviceId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -87,7 +87,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       .append(setStatement)
       .append(
         SQL`
-            WHERE TRUE `
+            WHERE TRUE `,
       )
       .append(whereStatement);
     /* eslint-enable prettier/prettier */

package/Server/Utils/Monitor/MonitorResource.ts

@@ -316,17 +316,27 @@ export default class MonitorResourceUtil {
            * the monitor to flap between Online and Offline every minute.
            */
           if (!serverMonitorResponse.onlyCheckRequestReceivedAt) {
-            await MonitorService.updateOneById({
+            /*
+             * Heartbeat write: single-statement UPDATE, no hooks and no
+             * `version` bump. This DELIBERATELY drops the per-update workflow
+             * trigger and audit-log entry that Monitor's @EnableWorkflow /
+             * @EnableAuditLog fire on every changed update — the old
+             * `ignoreHooks: true` did NOT suppress those (they are gated on
+             * the model flag, not on ignoreHooks), so a heartbeat used to
+             * spam an on-update workflow + an audit row every ingest. A
+             * liveness ping should do neither. onUpdateSuccess is inert here
+             * regardless (gated on status/interval/steps/name/etc., none of
+             * which are written). Also skips the pre-SELECT that would reload
+             * the large serverMonitorResponse jsonb row. See
+             * ServiceService.updateLastSeen.
+             */
+            await MonitorService.updateColumnsByIdWithoutHooks({
               id: monitor.id!,
               data: {
                 serverMonitorRequestReceivedAt:
                   serverMonitorResponse.requestReceivedAt!,
                 serverMonitorResponse,
               },
-              props: {
-                isRoot: true,
-                ignoreHooks: true,
-              },
             });
 
             logger.debug(
@@ -344,7 +354,15 @@ export default class MonitorResourceUtil {
             `${dataToProcess.monitorId.toString()} - Incoming request received at ${incomingMonitorRequest.incomingRequestReceivedAt}`,
           );
 
-          await MonitorService.updateOneById({
+          /*
+           * Heartbeat write: single-statement UPDATE, no hooks and no
+           * `version` bump. As with the server-monitor branch above, this
+           * deliberately drops the per-update workflow trigger + audit-log
+           * entry Monitor would otherwise fire on every heartbeat, and skips
+           * the pre-SELECT of the large incomingMonitorRequest jsonb row. See
+           * ServiceService.updateLastSeen.
+           */
+          await MonitorService.updateColumnsByIdWithoutHooks({
             id: monitor.id!,
             data: {
               incomingRequestMonitorHeartbeatCheckedAt:
@@ -353,10 +371,6 @@ export default class MonitorResourceUtil {
                 JSON.stringify(incomingMonitorRequest),
               ) as IncomingMonitorRequest,
             } as any,
-            props: {
-              isRoot: true,
-              ignoreHooks: true,
-            },
           });
 
           logger.debug(

package/Server/Utils/Telemetry/EntityRegistry.ts

@@ -271,11 +271,17 @@ export async function reconcileByNaturalKey<
   });
 
   if (existing) {
-    // Throttled bump of lastSeenAt (+ any caller-supplied merge fields).
-    await data.service.updateOneById({
+    /*
+     * Throttled bump of lastSeenAt (+ any caller-supplied merge fields).
+     * Heartbeat write: single-statement UPDATE, no hooks and no `version`
+     * bump (TelemetryEntity/Relationship enable no update workflow/realtime/
+     * audit). buildBump returns only plain values — lastSeenAt plus, at most,
+     * the descriptiveAttributes / labels JSON columns — which the primitive
+     * persists via the driver transformer path. See ServiceService.updateLastSeen.
+     */
+    await data.service.updateColumnsByIdWithoutHooks({
       id: existing.id!,
       data: buildBump(existing),
-      props: { isRoot: true },
     });
     return;
   }
@@ -306,10 +312,9 @@ export async function reconcileByNaturalKey<
       logger.debug(
         `EntityRegistry: create raced for ${data.describe} (concurrent insert); bumping lastSeenAt on the winning row.`,
       );
-      await data.service.updateOneById({
+      await data.service.updateColumnsByIdWithoutHooks({
         id: winner.id!,
         data: buildBump(winner),
-        props: { isRoot: true },
       });
       return;
     }

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 */
     });
   });
 
@@ -790,18 +793,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 = (