@oneuptime/common 14.0.9 → 14.0.10

package/Server/Utils/SessionReplay/SessionReplayUsage.ts

@@ -18,6 +18,13 @@ import ObjectID from "../../../Types/ObjectID";
 const DAILY_PROJECT_BYTE_KEY_PREFIX: string = "replay:rate:bytes:";
 const MONTHLY_APP_BYTE_KEY_PREFIX: string = "replay:rate:bytes-month:";
 
+/*
+ * Keys per MGET in readByteCounters. A sweep over every replay-enabled
+ * application reads a key or two per application; chunking keeps any one
+ * command (and its reply) small no matter how many there are.
+ */
+export const BYTE_COUNTER_MGET_CHUNK_SIZE: number = 500;
+
 export default class SessionReplayUsage {
   /*
    * UTC rather than local, so the budget window is the same for every pod
@@ -64,23 +71,83 @@ export default class SessionReplayUsage {
     return this.readCounter(this.getMonthlyApplicationByteKey(data));
   }
 
-  private static async readCounter(key: string): Promise<number | null> {
+  /*
+   * Many counters in as few round trips as possible, for the sweep that
+   * publishes every replay-enabled application's budget as metrics
+   * (SessionReplayBudgetMetrics). The answer is positional: values[i] is
+   * keys[i], read with the same per-key rules as the single-key readers
+   * (absent or non-numeric is 0).
+   *
+   * All or nothing: null when Redis is unavailable or any chunk fails. A
+   * caller that got half the counters could not tell which half is real,
+   * and a counter it failed to read must never be published as 0 - that
+   * reads as "no usage" to every monitor watching the series.
+   *
+   * Values are returned as stored, not clamped: a refund that straddles
+   * 00:00 UTC can leave a negative daily key (see
+   * SessionReplayRateLimiter.refundByteBudget), and what a negative count
+   * should mean is the caller's decision.
+   */
+  public static async readByteCounters(
+    keys: Array<string>,
+  ): Promise<Array<number> | null> {
+    if (keys.length === 0) {
+      return [];
+    }
+
     const client: ClientType | null = Redis.getClient();
 
     if (!client || !Redis.isConnected()) {
       return null;
     }
 
+    const values: Array<number> = [];
+
     try {
-      const value: string | null = await client.get(key);
+      for (
+        let start: number = 0;
+        start < keys.length;
+        start += BYTE_COUNTER_MGET_CHUNK_SIZE
+      ) {
+        const chunk: Array<string> = keys.slice(
+          start,
+          start + BYTE_COUNTER_MGET_CHUNK_SIZE,
+        );
+
+        const stored: Array<string | null> = await client.mget(chunk);
+
+        if (!Array.isArray(stored) || stored.length !== chunk.length) {
+          throw new Error(
+            `MGET answered ${Array.isArray(stored) ? stored.length : "no"} values for ${chunk.length} keys`,
+          );
+        }
 
-      if (value === null) {
-        return 0;
+        for (const value of stored) {
+          values.push(this.parseCounterValue(value));
+        }
       }
+    } catch (err) {
+      logger.warn(
+        `SessionReplayUsage: could not read ${keys.length} byte counters`,
+      );
+      logger.warn(err);
+      return null;
+    }
+
+    return values;
+  }
+
+  private static async readCounter(key: string): Promise<number | null> {
+    const client: ClientType | null = Redis.getClient();
+
+    if (!client || !Redis.isConnected()) {
+      return null;
+    }
 
-      const parsed: number = parseInt(value, 10);
+    try {
+      const value: string | null = await client.get(key);
 
-      return isNaN(parsed) ? 0 : parsed;
+      return this.parseCounterValue(value);
     } catch (err) {
       logger.warn(
         `SessionReplayUsage: could not read the byte counter at ${key}`,
@@ -89,4 +156,15 @@ export default class SessionReplayUsage {
       return null;
     }
   }
+
+  // An absent key has counted nothing yet; a non-numeric one counts as 0 too.
+  private static parseCounterValue(value: string | null): number {
+    if (value === null) {
+      return 0;
+    }
+
+    const parsed: number = parseInt(value, 10);
+
+    return isNaN(parsed) ? 0 : parsed;
+  }
 }

package/Server/Utils/Workspace/MicrosoftTeams/Actions/Alert.ts

@@ -24,6 +24,7 @@ import WorkspaceActionAuthorization from "../../WorkspaceActionAuthorization";
 import AlertStateTimeline from "../../../../../Models/DatabaseModels/AlertStateTimeline";
 import AlertInternalNote from "../../../../../Models/DatabaseModels/AlertInternalNote";
 import OnCallDutyPolicyExecutionLog from "../../../../../Models/DatabaseModels/OnCallDutyPolicyExecutionLog";
+import MicrosoftTeamsReplies from "../MicrosoftTeamsReplies";
 
 export default class MicrosoftTeamsAlertActions {
   @CaptureSpan()
@@ -415,12 +416,19 @@ export default class MicrosoftTeamsAlertActions {
           userId: oneUptimeUserId,
         });
 
-        await turnContext.sendActivity("✅ Note added successfully.");
+        await MicrosoftTeamsReplies.sendBestEffort(
+          turnContext,
+          "✅ Note added successfully.",
+        );
 
-        // Hide the form card by deleting it
-        if (turnContext.activity.replyToId) {
-          await turnContext.deleteActivity(turnContext.activity.replyToId);
-        }
+        /*
+         * The action is done: a refused reply or a failed delete of the
+         * form must not read as a failed action, which invites a repeat.
+         */
+        await MicrosoftTeamsReplies.deleteBestEffort(
+          turnContext,
+          turnContext.activity.replyToId,
+        );
 
         return;
       }
@@ -492,14 +500,19 @@ export default class MicrosoftTeamsAlertActions {
           userNotificationEventType: UserNotificationEventType.AlertCreated,
         });
 
-        await turnContext.sendActivity(
+        await MicrosoftTeamsReplies.sendBestEffort(
+          turnContext,
           "✅ On-call policy executed successfully.",
         );
 
-        // Hide the form card by deleting it
-        if (turnContext.activity.replyToId) {
-          await turnContext.deleteActivity(turnContext.activity.replyToId);
-        }
+        /*
+         * The action is done: a refused reply or a failed delete of the
+         * form must not read as a failed action, which invites a repeat.
+         */
+        await MicrosoftTeamsReplies.deleteBestEffort(
+          turnContext,
+          turnContext.activity.replyToId,
+        );
 
         return;
       }
@@ -563,12 +576,19 @@ export default class MicrosoftTeamsAlertActions {
           props: databaseProps,
         });
 
-        await turnContext.sendActivity("✅ Alert state changed successfully.");
+        await MicrosoftTeamsReplies.sendBestEffort(
+          turnContext,
+          "✅ Alert state changed successfully.",
+        );
 
-        // Hide the form card by deleting it
-        if (turnContext.activity.replyToId) {
-          await turnContext.deleteActivity(turnContext.activity.replyToId);
-        }
+        /*
+         * The action is done: a refused reply or a failed delete of the
+         * form must not read as a failed action, which invites a repeat.
+         */
+        await MicrosoftTeamsReplies.deleteBestEffort(
+          turnContext,
+          turnContext.activity.replyToId,
+        );
 
         return;
       }

package/Server/Utils/Workspace/MicrosoftTeams/Actions/AlertEpisode.ts

@@ -23,6 +23,7 @@ import AlertStateService from "../../../../Services/AlertStateService";
 import UserNotificationEventType from "../../../../../Types/UserNotification/UserNotificationEventType";
 import OnCallDutyPolicy from "../../../../../Models/DatabaseModels/OnCallDutyPolicy";
 import AlertState from "../../../../../Models/DatabaseModels/AlertState";
+import MicrosoftTeamsReplies from "../MicrosoftTeamsReplies";
 
 export default class MicrosoftTeamsAlertEpisodeActions {
   @CaptureSpan()
@@ -428,12 +429,19 @@ export default class MicrosoftTeamsAlertEpisodeActions {
           userId: oneUptimeUserId,
         });
 
-        await turnContext.sendActivity("✅ Note added successfully.");
+        await MicrosoftTeamsReplies.sendBestEffort(
+          turnContext,
+          "✅ Note added successfully.",
+        );
 
-        // Hide the form card by deleting it
-        if (turnContext.activity.replyToId) {
-          await turnContext.deleteActivity(turnContext.activity.replyToId);
-        }
+        /*
+         * The action is done: a refused reply or a failed delete of the
+         * form must not read as a failed action, which invites a repeat.
+         */
+        await MicrosoftTeamsReplies.deleteBestEffort(
+          turnContext,
+          turnContext.activity.replyToId,
+        );
 
         return;
       }
@@ -510,14 +518,19 @@ export default class MicrosoftTeamsAlertEpisodeActions {
             UserNotificationEventType.AlertEpisodeCreated,
         });
 
-        await turnContext.sendActivity(
+        await MicrosoftTeamsReplies.sendBestEffort(
+          turnContext,
           "✅ On-call policy executed successfully.",
         );
 
-        // Hide the form card by deleting it
-        if (turnContext.activity.replyToId) {
-          await turnContext.deleteActivity(turnContext.activity.replyToId);
-        }
+        /*
+         * The action is done: a refused reply or a failed delete of the
+         * form must not read as a failed action, which invites a repeat.
+         */
+        await MicrosoftTeamsReplies.deleteBestEffort(
+          turnContext,
+          turnContext.activity.replyToId,
+        );
 
         return;
       }
@@ -590,14 +603,19 @@ export default class MicrosoftTeamsAlertEpisodeActions {
           },
         });
 
-        await turnContext.sendActivity(
+        await MicrosoftTeamsReplies.sendBestEffort(
+          turnContext,
           "✅ Alert episode state changed successfully.",
         );
 
-        // Hide the form card by deleting it
-        if (turnContext.activity.replyToId) {
-          await turnContext.deleteActivity(turnContext.activity.replyToId);
-        }
+        /*
+         * The action is done: a refused reply or a failed delete of the
+         * form must not read as a failed action, which invites a repeat.
+         */
+        await MicrosoftTeamsReplies.deleteBestEffort(
+          turnContext,
+          turnContext.activity.replyToId,
+        );
 
         return;
       }

package/Server/Utils/Workspace/MicrosoftTeams/Actions/Auth.ts

@@ -26,6 +26,14 @@ export interface MicrosoftTeamsRequest {
   payload?: JSONObject;
 }
 
+/*
+ * The Teams user has not connected their Microsoft Teams account to a
+ * OneUptime user in this project. Still a BadDataException, as before, but a
+ * type of its own, so the bot can tell the user where to connect the account
+ * instead of answering with a generic failure.
+ */
+export class MicrosoftTeamsAccountNotLinkedException extends BadDataException {}
+
 export default class MicrosoftTeamsAuthAction {
   @CaptureSpan()
   public static async getOneUptimeUserIdFromTeamsUserId(data: {
@@ -65,10 +73,22 @@ export default class MicrosoftTeamsAuthAction {
         return workspaceUserAuthToken.userId;
       }
 
-      throw new BadDataException(
+      throw new MicrosoftTeamsAccountNotLinkedException(
         "No OneUptime user linked to this Microsoft Teams user. Please authenticate with Microsoft Teams.",
       );
     } catch (error) {
+      // An account nobody has connected yet is expected, not a server error.
+      if (error instanceof MicrosoftTeamsAccountNotLinkedException) {
+        logger.debug(
+          "No OneUptime user linked to Teams user: " + data.teamsUserId,
+          {
+            projectId: data.projectId.toString(),
+            workspaceUserId: data.teamsUserId,
+          },
+        );
+        throw error;
+      }
+
       logger.error(
         "Error finding OneUptime user for Teams user: " + data.teamsUserId,
         {