@oneuptime/common 11.3.5 → 11.3.6

package/Server/Infrastructure/Queue.ts

@@ -88,8 +88,8 @@ export default class Queue {
       // Keep BullMQ data under control to avoid Redis bloat
       defaultJobOptions: {
         // keep only recent completed/failed jobs
-        removeOnComplete: { count: 500 }, // keep last 1000 completed jobs
-        removeOnFail: { count: 100 }, // keep last 500 failed jobs
+        removeOnComplete: { count: 500 }, // keep last 500 completed jobs
+        removeOnFail: { count: 100 }, // keep last 100 failed jobs
       },
       /*
        * Optionally cap the event stream length (supported in BullMQ >= v5)
@@ -112,24 +112,111 @@ export default class Queue {
       logger.error(err);
     });
 
-    // Fire-and-forget initial cleanup for legacy/old data if not done before
-    if (!this.cleanedQueueNames.has(queueName)) {
-      this.cleanedQueueNames.add(queueName);
-      // Clean jobs older than 1 days to reclaim memory from historic runs
-      const oneDaysMs: number = 1 * 24 * 60 * 60 * 1000;
-      void (async () => {
-        try {
-          await queue.clean(oneDaysMs, 1000, "completed");
-          await queue.clean(oneDaysMs, 1000, "failed");
-        } catch {
-          // ignore cleanup errors to not impact normal flow
-        }
-      })();
-    }
+    /*
+     * Lazy fallback for the startup sweep: the first time a queue is created in
+     * this process, kick off its once-per-process terminal-job cleanup. The
+     * eager path (cleanAllQueuesOnStartup, called at service boot) normally
+     * wins; whichever runs first is the only one to sweep, via the gate inside
+     * cleanQueueOnStartup(). Fire and forget so it never blocks enqueue.
+     */
+    void this.cleanQueueOnStartup(queueName);
 
     return queue;
   }
 
+  /**
+   * Eagerly sweeps every queue's terminal (completed/failed) jobs at process
+   * startup, so the Completed/Failed counts on the admin Health page reset on a
+   * pod (re)start regardless of when — or whether — each queue next produces a
+   * job. Call once during service boot (see App/Index.ts). Each queue is swept
+   * at most once per process via the cleanedQueueNames gate, so this is safe to
+   * call alongside the lazy getQueue() path and from any service role.
+   */
+  @CaptureSpan()
+  public static async cleanAllQueuesOnStartup(): Promise<void> {
+    await Promise.all(
+      Object.values(QueueName).map((queueName: QueueName) => {
+        return this.cleanQueueOnStartup(queueName);
+      }),
+    );
+  }
+
+  /*
+   * How old (in ms) a completed/failed job must be before the startup sweep
+   * removes it. 0 means "remove all terminal jobs on every restart", which
+   * resets the Completed/Failed counts on the admin Health page so operators
+   * stop seeing stale failures after a deploy/restart. Raise this (e.g. to
+   * 24 * 60 * 60 * 1000) if you'd rather keep recent failures around for
+   * crash-loop debugging.
+   */
+  private static readonly STARTUP_CLEANUP_GRACE_MS: number = 0;
+  // Number of jobs removed per clean() call; we loop until the state is drained.
+  private static readonly STARTUP_CLEANUP_BATCH_SIZE: number = 1000;
+  // Safety cap so a pathologically large backlog can't loop forever.
+  private static readonly STARTUP_CLEANUP_MAX_BATCHES: number = 1000;
+
+  /**
+   * Removes terminal (completed/failed) jobs for a single queue, at most once
+   * per process (gated by cleanedQueueNames). Drains in batches because
+   * BullMQ's clean() caps each call at `limit` removals. Leaves live states
+   * (waiting/active/delayed) untouched. Best-effort: any error is logged and
+   * swallowed so a transient Redis hiccup at boot never breaks queue setup.
+   */
+  private static async cleanQueueOnStartup(
+    queueName: QueueName,
+  ): Promise<void> {
+    /*
+     * Gate synchronously, before any await, so the lazy getQueue() trigger and
+     * the eager cleanAllQueuesOnStartup() call can't both sweep the same queue.
+     */
+    if (this.cleanedQueueNames.has(queueName)) {
+      return;
+    }
+    this.cleanedQueueNames.add(queueName);
+
+    const queue: BullQueue = this.getQueue(queueName);
+
+    const terminalStates: Array<"completed" | "failed"> = [
+      "completed",
+      "failed",
+    ];
+
+    for (const state of terminalStates) {
+      try {
+        let removedTotal: number = 0;
+
+        for (
+          let batch: number = 0;
+          batch < this.STARTUP_CLEANUP_MAX_BATCHES;
+          batch++
+        ) {
+          const removed: string[] = await queue.clean(
+            this.STARTUP_CLEANUP_GRACE_MS,
+            this.STARTUP_CLEANUP_BATCH_SIZE,
+            state,
+          );
+
+          removedTotal += removed.length;
+
+          // A short batch means the state is drained; stop looping.
+          if (removed.length < this.STARTUP_CLEANUP_BATCH_SIZE) {
+            break;
+          }
+        }
+
+        if (removedTotal > 0) {
+          logger.debug(
+            `Queue ${queueName}: removed ${removedTotal} ${state} job(s) on startup`,
+          );
+        }
+      } catch (err) {
+        // Ignore cleanup errors to not impact normal flow.
+        logger.debug(`Queue ${queueName}: startup ${state} cleanup failed`);
+        logger.debug(err);
+      }
+    }
+  }
+
   @CaptureSpan()
   public static async removeJob(
     queueName: QueueName,

package/Server/Services/AnalyticsDatabaseService.ts

@@ -126,8 +126,10 @@ export const MigrationExecuteOptions: ClickhouseExecuteOptions = {
   useMigrationConnection: true,
   clickhouseSettings: {
     send_progress_in_http_headers: 1,
-    // Emit a progress header every 10s — well under the App pool's 58s and the
-    // migration pool's 30-minute idle ceiling.
+    /*
+     * Emit a progress header every 10s — well under the App pool's 58s and the
+     * migration pool's 30-minute idle ceiling.
+     */
     http_headers_progress_interval_ms: "10000",
   },
 };
@@ -487,9 +489,11 @@ export default class AnalyticsDatabaseService<
   ): Promise<void> {
     const statement: Statement =
       this.statementGenerator.toAddColumnStatement(column);
-    // Schema-sync / migration-only path: route through the migration pool so a
-    // column add that backfills a DEFAULT/MATERIALIZED expression on a large
-    // table is not destroyed at the App pool's 58s socket-idle timeout.
+    /*
+     * Schema-sync / migration-only path: route through the migration pool so a
+     * column add that backfills a DEFAULT/MATERIALIZED expression on a large
+     * table is not destroyed at the App pool's 58s socket-idle timeout.
+     */
     await this.execute(statement, MigrationExecuteOptions);
 
     // Add skip index separately (ClickHouse requires ADD INDEX as a separate ALTER statement)

package/Server/Services/TeamMemberService.ts

@@ -28,6 +28,7 @@ import SubscriptionPlan, {
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import Email from "../../Types/Email";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import Name from "../../Types/Name";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
@@ -125,6 +126,15 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
     if (createBy.miscDataProps && createBy.miscDataProps["email"]) {
       const email: Email = new Email(createBy.miscDataProps["email"] as string);
 
+      /*
+       * Optional name supplied on the invite form. Used only to set the name on
+       * a brand-new user, or to backfill an existing user who has no name yet —
+       * we never overwrite a name the user has already set.
+       */
+      const nameValue: string | undefined = createBy.miscDataProps["name"]
+        ? (createBy.miscDataProps["name"] as string).trim()
+        : undefined;
+
       let user: User | null = await UserService.findByEmail(email, {
         isRoot: true,
       });
@@ -133,13 +143,40 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
 
       if (!user) {
         isNewUser = true;
+
         user = await UserService.createByEmail({
           email,
-          name: undefined, // name is not required for now.
+          name: nameValue ? new Name(nameValue) : undefined,
           props: {
             isRoot: true,
           },
         });
+      } else if (nameValue) {
+        /*
+         * User already exists. Backfill their name only if they don't have one
+         * yet; if they already have a name, leave it untouched.
+         */
+        const existingUser: User | null = await UserService.findOneById({
+          id: user.id!,
+          select: {
+            name: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (existingUser && !existingUser.name?.toString()) {
+          await UserService.updateOneById({
+            id: user.id!,
+            data: {
+              name: new Name(nameValue),
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        }
       }
 
       createBy.data.userId = user.id!;

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -29,6 +29,7 @@ import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
 import ObjectID from "../../../Types/ObjectID";
 import IsNull from "../../../Types/BaseDatabase/IsNull";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
@@ -887,6 +888,36 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             continue;
           }
 
+          /*
+           * Multi-value exclusion (IncludesNone / "is none of"):
+           * `attributes['k'] NOT IN (...)`. Map subscript returns '' for a
+           * missing key, so (like NotEqual above) rows lacking the attribute
+           * pass the NOT IN test, which matches "the value is none of these".
+           * An empty IncludesNone is treated as "All" — skip the predicate
+           * rather than emit `NOT IN ()`. Values bind via a fresh `Includes`
+           * since Statement only types `Includes` as Array(String).
+           */
+          if (mapEntry instanceof IncludesNone) {
+            const excludeValues: Array<string> = (
+              (mapEntry as IncludesNone).values || []
+            ).map((v: string | ObjectID | number) => {
+              return String(v);
+            });
+            if (excludeValues.length === 0) {
+              continue;
+            }
+            whereStatement.append(
+              SQL`AND ${key}[${{
+                value: mapKey,
+                type: TableColumnType.Text,
+              }}] NOT IN ${{
+                value: new Includes(excludeValues),
+                type: TableColumnType.Text,
+              }}`,
+            );
+            continue;
+          }
+
           // Bare string/number/boolean — direct Map subscript.
           whereStatement.append(
             SQL`AND ${key}[${{