@oneuptime/common 13.0.5 → 13.0.7

package/build/dist/Server/API/StatusPageAPI.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import UserMiddleware from "../Middleware/UserAuthorization";
+import PublicDashboardRateLimit, { PublicDashboardRateLimitBucket, } from "../Middleware/PublicDashboardRateLimit";
 import InMemoryTTLCache from "../Infrastructure/InMemoryTTLCache";
 import AcmeChallengeService from "../Services/AcmeChallengeService";
 import IncidentEpisodeService from "../Services/IncidentEpisodeService";
@@ -92,11 +93,18 @@ import CookieUtil from "../Utils/Cookie";
 import { StatusPageApiRoute } from "../../ServiceRoute";
 import ProjectSmtpConfigService from "../Services/ProjectSmtpConfigService";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
+import MicrosoftTeamsUtil from "../Utils/Workspace/MicrosoftTeams/MicrosoftTeams";
 import { MASTER_PASSWORD_INVALID_MESSAGE } from "../../Types/StatusPage/MasterPassword";
 import StatusPageSubscriberNotificationEventType from "../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
 import StatusPageSubscriberNotificationMethod from "../../Types/StatusPage/StatusPageSubscriberNotificationMethod";
 import StatusPageSubscriberNotificationTemplateService, { Service as StatusPageSubscriberNotificationTemplateServiceClass, } from "../Services/StatusPageSubscriberNotificationTemplateService";
 import { canServeStatusPageCustomizations } from "../Utils/StatusPageCustomizationAccess";
+/*
+ * A manage-subscription request is unauthenticated, and one Slack or Microsoft
+ * Teams workspace name can match several subscriptions. Cap how many of them a
+ * single request sends a link to.
+ */
+export const MAX_SUBSCRIBERS_PER_MANAGE_SUBSCRIPTION_REQUEST = 20;
 /*
  * The status badge is hand-built SVG served as image/svg+xml, and SVG is a
  * document - anything interpolated into it is markup, not text. A monitor
@@ -713,8 +721,15 @@ class StatusPageAPI extends BaseAPI {
                 next(err);
             }
         });
+        /*
+         * Every request here runs a scrypt verify, so the route carries a
+         * password attempt limit, the same one the dashboard master password
+         * route uses but with its own counters. It runs ahead of UserMiddleware so
+         * a refused attempt costs neither a session lookup nor a hash. See
+         * PublicDashboardRateLimit for the budget and why it fails closed.
+         */
         this.router.post(`${(_s = new this.entityType()
-            .getCrudApiPath()) === null || _s === void 0 ? void 0 : _s.toString()}/master-password/:statusPageId`, UserMiddleware.getUserMiddleware, async (req, res, next) => {
+            .getCrudApiPath()) === null || _s === void 0 ? void 0 : _s.toString()}/master-password/:statusPageId`, PublicDashboardRateLimit.getMiddleware(PublicDashboardRateLimitBucket.StatusPageMasterPassword), UserMiddleware.getUserMiddleware, async (req, res, next) => {
             try {
                 if (!req.params["statusPageId"]) {
                     throw new BadDataException("Status Page ID not found");
@@ -1669,7 +1684,6 @@ class StatusPageAPI extends BaseAPI {
         return response;
     }
     async manageExistingSubscription(req) {
-        var _a, _b;
         const statusPageId = new ObjectID(req.params["statusPageId"]);
         logger.debug(`Managing Existing Subscription for Status Page: ${statusPageId}`, getLogAttributesFromRequest(req));
         await this.checkHasReadAccess({
@@ -1710,21 +1724,45 @@ class StatusPageAPI extends BaseAPI {
             logger.debug(`Email subscribers not enabled for status page with ID: ${statusPageId}`, getLogAttributesFromRequest(req));
             throw new BadDataException("Email subscribers not enabled for this status page.");
         }
-        if (req.body.data["slackIncomingWebhookUrl"] &&
+        if ((req.body.data["slackIncomingWebhookUrl"] ||
+            req.body.data["slackWorkspaceName"]) &&
             !statusPage.enableSlackSubscribers) {
             logger.debug(`Slack subscribers not enabled for status page with ID: ${statusPageId}`, getLogAttributesFromRequest(req));
             throw new BadDataException("Slack subscribers not enabled for this status page.");
         }
+        if ((req.body.data["microsoftTeamsIncomingWebhookUrl"] ||
+            req.body.data["microsoftTeamsWorkspaceName"]) &&
+            !statusPage.enableMicrosoftTeamsSubscribers) {
+            logger.debug(`Microsoft Teams subscribers not enabled for status page with ID: ${statusPageId}`, getLogAttributesFromRequest(req));
+            throw new BadDataException("Microsoft Teams subscribers not enabled for this status page.");
+        }
         if (req.body.data["subscriberPhone"] && !statusPage.enableSmsSubscribers) {
             logger.debug(`SMS subscribers not enabled for status page with ID: ${statusPageId}`, getLogAttributesFromRequest(req));
             throw new BadDataException("SMS subscribers not enabled for this status page.");
         }
-        // if no email or phone, throw error.
-        if (!req.body.data["subscriberEmail"] &&
-            !req.body.data["subscriberPhone"] &&
-            !req.body.data["slackWorkspaceName"]) {
-            logger.debug(`No email, slack workspace name or phone provided for subscription to status page with ID: ${statusPageId}`, getLogAttributesFromRequest(req));
-            throw new BadDataException("Email, phone or slack workspace name is required to subscribe to this status page.");
+        const identifiers = [
+            req.body.data["subscriberEmail"],
+            req.body.data["subscriberPhone"],
+            req.body.data["slackWorkspaceName"],
+            req.body.data["microsoftTeamsWorkspaceName"],
+        ].filter(Boolean);
+        const identifierCount = identifiers.length;
+        if (identifierCount === 0) {
+            logger.debug(`No email, phone, Slack workspace name or Microsoft Teams workspace name provided to manage a subscription on status page with ID: ${statusPageId}`, getLogAttributesFromRequest(req));
+            throw new BadDataException("Email, phone, Slack workspace name or Microsoft Teams workspace name is required to manage your subscription.");
+        }
+        /*
+         * The manage link opens the subscription it belongs to, so it may only go
+         * to the contact stored on that subscriber. One identifier per request
+         * keeps the subscribers that are looked up and the channel the link is
+         * sent on the same.
+         */
+        if (identifierCount > 1) {
+            throw new BadDataException("Please provide only one of email, phone, Slack workspace name or Microsoft Teams workspace name.");
+        }
+        // The identifier goes straight into the subscriber query, so only plain text is accepted.
+        if (typeof identifiers[0] !== "string") {
+            throw new BadDataException("Email, phone, Slack workspace name or Microsoft Teams workspace name must be text.");
         }
         const email = req.body.data["subscriberEmail"]
             ? new Email(req.body.data["subscriberEmail"])
@@ -1735,77 +1773,87 @@ class StatusPageAPI extends BaseAPI {
         const slackWorkspaceName = req.body.data["slackWorkspaceName"]
             ? req.body.data["slackWorkspaceName"]
             : undefined;
-        let statusPageSubscriber = null;
+        const microsoftTeamsWorkspaceName = req.body.data["microsoftTeamsWorkspaceName"]
+            ? req.body.data["microsoftTeamsWorkspaceName"]
+            : undefined;
+        /*
+         * Each lookup selects only the contact for its own channel, so a link can
+         * only be delivered where that subscriber signed up.
+         */
+        let lookupQuery;
+        let lookupSelect;
         if (email) {
-            logger.debug(`Setting subscriber email: ${email}`, getLogAttributesFromRequest(req));
-            statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
-                query: {
-                    subscriberEmail: email,
-                    statusPageId: statusPageId,
-                },
-                select: {
-                    _id: true,
-                    subscriberEmail: true,
-                },
-                props: {
-                    isRoot: true,
-                },
-            });
+            lookupQuery = { subscriberEmail: email };
+            lookupSelect = { _id: true, subscriberEmail: true };
         }
-        if (phone) {
-            logger.debug(`Setting subscriber phone: ${phone}`, getLogAttributesFromRequest(req));
-            statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
-                query: {
-                    subscriberPhone: phone,
-                    statusPageId: statusPageId,
-                },
-                select: {
-                    _id: true,
-                    subscriberPhone: true,
-                },
-                props: {
-                    isRoot: true,
-                },
-            });
+        else if (phone) {
+            lookupQuery = { subscriberPhone: phone };
+            lookupSelect = { _id: true, subscriberPhone: true };
         }
-        if (slackWorkspaceName) {
-            logger.debug(`Setting subscriber slack workspace: ${slackWorkspaceName}`, getLogAttributesFromRequest(req));
-            statusPageSubscriber = await StatusPageSubscriberService.findOneBy({
-                query: {
-                    slackWorkspaceName: slackWorkspaceName,
-                    statusPageId: statusPageId,
-                },
-                select: {
-                    _id: true,
-                    slackWorkspaceName: true,
-                    slackIncomingWebhookUrl: true,
-                },
-                props: {
-                    isRoot: true,
-                },
-            });
+        else if (slackWorkspaceName) {
+            lookupQuery = { slackWorkspaceName: slackWorkspaceName };
+            lookupSelect = { _id: true, slackIncomingWebhookUrl: true };
         }
-        if (!statusPageSubscriber) {
-            // not found, return bad data
-            logger.debug(`Subscriber not found for email: ${email}, phone: ${phone}, or slack workspace: ${slackWorkspaceName}`, getLogAttributesFromRequest(req));
-            let identifierType = "email";
-            if (phone) {
-                identifierType = "phone";
-            }
-            else if (slackWorkspaceName) {
-                identifierType = "slack workspace name";
-            }
-            throw new BadDataException(`Subscription not found for this status page. Please make sure your ${identifierType} is correct.`);
+        else {
+            lookupQuery = {
+                microsoftTeamsWorkspaceName: microsoftTeamsWorkspaceName,
+            };
+            lookupSelect = { _id: true, microsoftTeamsIncomingWebhookUrl: true };
         }
+        logger.debug(`Looking up subscribers by email: ${email}, phone: ${phone}, Slack workspace: ${slackWorkspaceName}, or Microsoft Teams workspace: ${microsoftTeamsWorkspaceName}`, getLogAttributesFromRequest(req));
+        /*
+         * An email or phone number is subscribed at most once per status page,
+         * but several channels of one Slack or Teams workspace can be subscribed
+         * under the same workspace name, so every match gets its own link on its
+         * own webhook. Oldest first, so subscriptions added later under the same
+         * name cannot push an existing one past the limit.
+         */
+        const statusPageSubscribers = await StatusPageSubscriberService.findBy({
+            query: Object.assign(Object.assign({}, lookupQuery), { statusPageId: statusPageId }),
+            select: lookupSelect,
+            sort: {
+                createdAt: SortOrder.Ascending,
+            },
+            limit: MAX_SUBSCRIBERS_PER_MANAGE_SUBSCRIPTION_REQUEST,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        if (statusPageSubscribers.length === 0) {
+            /*
+             * Answer exactly as when a subscriber matched, so this endpoint cannot
+             * be used to find out who is subscribed.
+             */
+            logger.debug(`Subscriber not found for email: ${email}, phone: ${phone}, Slack workspace: ${slackWorkspaceName}, or Microsoft Teams workspace: ${microsoftTeamsWorkspaceName}`, getLogAttributesFromRequest(req));
+            return;
+        }
+        /*
+         * Send in the background so that neither the response time nor an error
+         * while sending reveals that a subscriber matched.
+         */
+        this.sendManageSubscriptionLinks({
+            statusPageId: statusPageId,
+            subscribers: statusPageSubscribers,
+            req: req,
+        }).catch((err) => {
+            logger.error(err, getLogAttributesFromRequest(req));
+        });
+    }
+    async sendManageSubscriptionLinks(data) {
+        var _a, _b;
+        const { statusPageId, subscribers, req } = data;
         const statusPageURL = await StatusPageService.getStatusPageURL(statusPageId);
-        const manageUrlink = StatusPageSubscriberService.getUnsubscribeLink(URL.fromString(statusPageURL), statusPageSubscriber.id).toString();
         const statusPages = await StatusPageSubscriberService.getStatusPagesToSendNotification([
             statusPageId,
         ]);
         for (const statusPage of statusPages) {
-            // send email to subscriber or sms if phone is provided.
-            const statusPageNameStr = statusPage.name || "Status Page";
-            const [manageEmailTemplate, manageSmsTemplate, manageSlackTemplate,] = await Promise.all([
+            /*
+             * The page is named the way every other subscriber message names it:
+             * its public title first, then its internal name.
+             */
+            const statusPageNameStr = statusPage.pageTitle || statusPage.name || "Status Page";
+            const [manageEmailTemplate, manageSmsTemplate, manageSlackTemplate, manageMicrosoftTeamsTemplate,] = await Promise.all([
                 StatusPageSubscriberNotificationTemplateService.getTemplateForStatusPage({
                     statusPageId: statusPage.id,
                     eventType: StatusPageSubscriberNotificationEventType.SubscriberManageSubscription,
@@ -1821,100 +1869,136 @@ class StatusPageAPI extends BaseAPI {
                     eventType: StatusPageSubscriberNotificationEventType.SubscriberManageSubscription,
                     notificationMethod: StatusPageSubscriberNotificationMethod.Slack,
                 }),
+                StatusPageSubscriberNotificationTemplateService.getTemplateForStatusPage({
+                    statusPageId: statusPage.id,
+                    eventType: StatusPageSubscriberNotificationEventType.SubscriberManageSubscription,
+                    notificationMethod: StatusPageSubscriberNotificationMethod.MicrosoftTeams,
+                }),
             ]);
-            const manageTemplateVariables = {
-                statusPageName: statusPageNameStr,
-                statusPageUrl: statusPageURL,
-                manageSubscriptionUrl: manageUrlink,
-            };
-            if (email) {
-                const host = await DatabaseConfig.getHost();
-                const httpProtocol = await DatabaseConfig.getHttpProtocol();
-                const statusPageIdString = ((_a = statusPage.id) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = statusPage._id) === null || _b === void 0 ? void 0 : _b.toString()) || null;
-                if ((manageEmailTemplate === null || manageEmailTemplate === void 0 ? void 0 : manageEmailTemplate.templateBody) && statusPage.smtpConfig) {
-                    const compiledBody = StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageEmailTemplate.templateBody, manageTemplateVariables);
-                    const compiledSubject = manageEmailTemplate.emailSubject
-                        ? StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageEmailTemplate.emailSubject, manageTemplateVariables)
-                        : "Manage your Subscription for " + statusPageNameStr;
-                    MailService.sendMail({
-                        toEmail: email,
-                        templateType: EmailTemplateType.BlankTemplate,
-                        vars: {
-                            body: compiledBody,
-                        },
-                        subject: compiledSubject,
-                    }, {
-                        mailServer: ProjectSmtpConfigService.toEmailServer(statusPage.smtpConfig),
-                        projectId: statusPage.projectId,
-                        statusPageId: statusPage.id,
-                    });
+            for (const statusPageSubscriber of subscribers) {
+                // Only ever the contacts stored on the subscriber, never ones from the request.
+                const subscriberEmail = statusPageSubscriber.subscriberEmail;
+                const subscriberPhone = statusPageSubscriber.subscriberPhone;
+                const slackIncomingWebhookUrl = statusPageSubscriber.slackIncomingWebhookUrl;
+                const microsoftTeamsIncomingWebhookUrl = statusPageSubscriber.microsoftTeamsIncomingWebhookUrl;
+                const manageUrlink = StatusPageSubscriberService.getUnsubscribeLink(URL.fromString(statusPageURL), statusPageSubscriber.id).toString();
+                /*
+                 * The manage link is the subscriber's update-subscription page, which
+                 * is the same URL every other sender passes as unsubscribeUrl, so a
+                 * template may use either name for it.
+                 */
+                const manageTemplateVariables = {
+                    statusPageName: statusPageNameStr,
+                    statusPageUrl: statusPageURL,
+                    unsubscribeUrl: manageUrlink,
+                    manageSubscriptionUrl: manageUrlink,
+                };
+                const defaultChatMessage = `You have selected to manage your subscription for the status page: ${statusPageNameStr}. You can manage your subscription here: ${manageUrlink}`;
+                if (subscriberEmail) {
+                    const host = await DatabaseConfig.getHost();
+                    const httpProtocol = await DatabaseConfig.getHttpProtocol();
+                    const statusPageIdString = ((_a = statusPage.id) === null || _a === void 0 ? void 0 : _a.toString()) || ((_b = statusPage._id) === null || _b === void 0 ? void 0 : _b.toString()) || null;
+                    if ((manageEmailTemplate === null || manageEmailTemplate === void 0 ? void 0 : manageEmailTemplate.templateBody) && statusPage.smtpConfig) {
+                        const compiledBody = StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageEmailTemplate.templateBody, manageTemplateVariables);
+                        const compiledSubject = manageEmailTemplate.emailSubject
+                            ? StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageEmailTemplate.emailSubject, manageTemplateVariables)
+                            : "Manage your Subscription for " + statusPageNameStr;
+                        MailService.sendMail({
+                            toEmail: subscriberEmail,
+                            templateType: EmailTemplateType.BlankTemplate,
+                            vars: {
+                                body: compiledBody,
+                            },
+                            subject: compiledSubject,
+                        }, {
+                            mailServer: ProjectSmtpConfigService.toEmailServer(statusPage.smtpConfig),
+                            projectId: statusPage.projectId,
+                            statusPageId: statusPage.id,
+                        });
+                    }
+                    else {
+                        MailService.sendMail({
+                            toEmail: subscriberEmail,
+                            templateType: EmailTemplateType.ManageExistingStatusPageSubscriberSubscription,
+                            vars: {
+                                statusPageName: statusPageNameStr,
+                                statusPageUrl: statusPageURL,
+                                logoUrl: statusPage.logoFileId && statusPageIdString
+                                    ? new URL(httpProtocol, host)
+                                        .addRoute(StatusPageApiRoute)
+                                        .addRoute(`/logo/${statusPageIdString}`)
+                                        .toString()
+                                    : "",
+                                isPublicStatusPage: statusPage.isPublicStatusPage
+                                    ? "true"
+                                    : "false",
+                                subscriberEmailNotificationFooterText: StatusPageServiceType.getSubscriberEmailFooterText(statusPage),
+                                manageSubscriptionUrl: manageUrlink,
+                            },
+                            subject: "Manage your Subscription for " + statusPageNameStr,
+                        }, {
+                            mailServer: ProjectSmtpConfigService.toEmailServer(statusPage.smtpConfig),
+                            projectId: statusPage.projectId,
+                            statusPageId: statusPage.id,
+                        });
+                    }
                 }
-                else {
-                    MailService.sendMail({
-                        toEmail: email,
-                        templateType: EmailTemplateType.ManageExistingStatusPageSubscriberSubscription,
-                        vars: {
-                            statusPageName: statusPageNameStr,
-                            statusPageUrl: statusPageURL,
-                            logoUrl: statusPage.logoFileId && statusPageIdString
-                                ? new URL(httpProtocol, host)
-                                    .addRoute(StatusPageApiRoute)
-                                    .addRoute(`/logo/${statusPageIdString}`)
-                                    .toString()
-                                : "",
-                            isPublicStatusPage: statusPage.isPublicStatusPage
-                                ? "true"
-                                : "false",
-                            subscriberEmailNotificationFooterText: StatusPageServiceType.getSubscriberEmailFooterText(statusPage),
-                            manageSubscriptionUrl: manageUrlink,
-                        },
-                        subject: "Manage your Subscription for " + statusPageNameStr,
-                    }, {
-                        mailServer: ProjectSmtpConfigService.toEmailServer(statusPage.smtpConfig),
+                if (subscriberPhone) {
+                    let smsMessage;
+                    if ((manageSmsTemplate === null || manageSmsTemplate === void 0 ? void 0 : manageSmsTemplate.templateBody) && statusPage.callSmsConfig) {
+                        smsMessage =
+                            StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageSmsTemplate.templateBody, manageTemplateVariables);
+                    }
+                    else {
+                        smsMessage = defaultChatMessage;
+                    }
+                    const sms = {
+                        message: smsMessage,
+                        to: subscriberPhone,
+                    };
+                    // send sms here.
+                    SmsService.sendSms(sms, {
                         projectId: statusPage.projectId,
+                        customTwilioConfig: ProjectCallSMSConfigService.toTwilioConfig(statusPage.callSmsConfig),
                         statusPageId: statusPage.id,
+                    }).catch((err) => {
+                        logger.error(err, getLogAttributesFromRequest(req));
                     });
                 }
-            }
-            if (phone) {
-                let smsMessage;
-                if ((manageSmsTemplate === null || manageSmsTemplate === void 0 ? void 0 : manageSmsTemplate.templateBody) && statusPage.callSmsConfig) {
-                    smsMessage =
-                        StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageSmsTemplate.templateBody, manageTemplateVariables);
-                }
-                else {
-                    smsMessage = `You have selected to manage your subscription for the status page: ${statusPageNameStr}. You can manage your subscription here: ${manageUrlink}`;
-                }
-                const sms = {
-                    message: smsMessage,
-                    to: phone,
-                };
-                // send sms here.
-                SmsService.sendSms(sms, {
-                    projectId: statusPage.projectId,
-                    customTwilioConfig: ProjectCallSMSConfigService.toTwilioConfig(statusPage.callSmsConfig),
-                    statusPageId: statusPage.id,
-                }).catch((err) => {
-                    logger.error(err, getLogAttributesFromRequest(req));
-                });
-            }
-            if (statusPageSubscriber.slackIncomingWebhookUrl) {
-                let slackMessage;
-                if (manageSlackTemplate === null || manageSlackTemplate === void 0 ? void 0 : manageSlackTemplate.templateBody) {
-                    slackMessage =
-                        StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageSlackTemplate.templateBody, manageTemplateVariables);
+                if (slackIncomingWebhookUrl) {
+                    let slackMessage;
+                    if (manageSlackTemplate === null || manageSlackTemplate === void 0 ? void 0 : manageSlackTemplate.templateBody) {
+                        slackMessage =
+                            StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageSlackTemplate.templateBody, manageTemplateVariables);
+                    }
+                    else {
+                        slackMessage = defaultChatMessage;
+                    }
+                    SlackUtil.sendMessageToChannelViaIncomingWebhook({
+                        url: slackIncomingWebhookUrl,
+                        text: SlackUtil.convertMarkdownToSlackRichText(slackMessage),
+                    }).catch((err) => {
+                        logger.error(err, getLogAttributesFromRequest(req));
+                    });
                 }
-                else {
-                    slackMessage = `You have selected to manage your subscription for the status page: ${statusPageNameStr}. You can manage your subscription here: ${manageUrlink}`;
+                if (microsoftTeamsIncomingWebhookUrl) {
+                    let microsoftTeamsMessage;
+                    if (manageMicrosoftTeamsTemplate === null || manageMicrosoftTeamsTemplate === void 0 ? void 0 : manageMicrosoftTeamsTemplate.templateBody) {
+                        microsoftTeamsMessage =
+                            StatusPageSubscriberNotificationTemplateServiceClass.compileTemplate(manageMicrosoftTeamsTemplate.templateBody, manageTemplateVariables);
+                    }
+                    else {
+                        microsoftTeamsMessage = defaultChatMessage;
+                    }
+                    MicrosoftTeamsUtil.sendMessageToChannelViaIncomingWebhook({
+                        url: microsoftTeamsIncomingWebhookUrl,
+                        text: microsoftTeamsMessage,
+                    }).catch((err) => {
+                        logger.error(err, getLogAttributesFromRequest(req));
+                    });
                 }
-                SlackUtil.sendMessageToChannelViaIncomingWebhook({
-                    url: statusPageSubscriber.slackIncomingWebhookUrl,
-                    text: SlackUtil.convertMarkdownToSlackRichText(slackMessage),
-                }).catch((err) => {
-                    logger.error(err, getLogAttributesFromRequest(req));
-                });
+                logger.debug(`Subscription management link sent to subscriber with ID: ${statusPageSubscriber.id}`, getLogAttributesFromRequest(req));
             }
-            logger.debug(`Subscription management link sent to subscriber with ID: ${statusPageSubscriber.id}`, getLogAttributesFromRequest(req));
         }
     }
     async subscribeToStatusPage(req) {
@@ -4236,6 +4320,12 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], StatusPageAPI.prototype, "manageExistingSubscription", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], StatusPageAPI.prototype, "sendManageSubscriptionLinks", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),