@oneuptime/common 10.0.53 → 10.0.54

package/Server/Utils/StartServer.ts

@@ -21,9 +21,13 @@ import Express, {
   RequestHandler,
   headerValueToString,
 } from "./Express";
-import logger from "./Logger";
+import logger, {
+  getLogAttributesFromRequest,
+  type LogAttributes,
+} from "./Logger";
 import "./Process";
 import Response from "./Response";
+import SpanUtil from "./Telemetry/SpanUtil";
 import { api } from "@opentelemetry/sdk-node";
 import StatusCode from "../../Types/API/StatusCode";
 import HTTPErrorResponse from "../../Types/API/HTTPErrorResponse";
@@ -38,6 +42,7 @@ import Typeof from "../../Types/Typeof";
 import CookieParser from "cookie-parser";
 import cors from "cors";
 import zlib from "zlib";
+import crypto from "crypto";
 import path from "path";
 import "ejs";
 // Make sure we have stack trace for debugging.
@@ -60,7 +65,10 @@ const jsonBodyParserMiddleware: RequestHandler = ExpressJson({
   extended: true,
   verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer) => {
     (req as OneUptimeRequest).rawBody = buf.toString();
-    logger.debug(`Raw JSON Body for signature verification captured`);
+    logger.debug(
+      `Raw JSON Body for signature verification captured`,
+      getLogAttributesFromRequest(req as OneUptimeRequest),
+    );
   },
 }); // 50 MB limit.
 
@@ -72,6 +80,7 @@ const urlEncodedMiddleware: RequestHandler = ExpressUrlEncoded({
     (req as OneUptimeRequest).rawBody = buf.toString(); // Also set rawBody for consistency
     logger.debug(
       `Raw Form Url Encoded Body: ${(req as OneUptimeRequest).rawFormUrlEncodedBody}`,
+      getLogAttributesFromRequest(req as OneUptimeRequest),
     );
   },
 }); // 50 MB limit.
@@ -150,7 +159,10 @@ app.use((req: OneUptimeRequest, res: ExpressResponse, next: NextFunction) => {
       const buffer: Buffer = Buffer.concat(buffers);
       zlib.gunzip(buffer as Uint8Array, (err: unknown, decoded: Buffer) => {
         if (err) {
-          logger.error(err);
+          logger.error(
+            err,
+            getLogAttributesFromRequest(req as OneUptimeRequest),
+          );
           return Response.sendErrorResponse(
             req,
             res,
@@ -195,6 +207,18 @@ app.use((_req: ExpressRequest, _res: ExpressResponse, next: NextFunction) => {
   next();
 });
 
+app.use((req: ExpressRequest, _res: ExpressResponse, next: NextFunction) => {
+  const requestId: string = crypto.randomUUID();
+  (req as OneUptimeRequest).requestId = requestId;
+
+  // Tag the current span with requestId so all downstream spans inherit context
+  SpanUtil.addAttributesToCurrentSpan({
+    requestId: requestId,
+  });
+
+  next();
+});
+
 export interface InitFuctionOptions {
   appName: string;
   port?: Port | undefined;
@@ -286,12 +310,18 @@ const init: InitFunction = async (
         next: NextFunction,
       ) => {
         try {
-          logger.debug("Rendering index page");
+          const renderLogAttributes: LogAttributes =
+            getLogAttributesFromRequest(_req as OneUptimeRequest);
+
+          logger.debug("Rendering index page", renderLogAttributes);
 
           let variables: JSONObject = {};
 
           if (data.getVariablesToRenderIndexPage) {
-            logger.debug("Getting variables to render index page");
+            logger.debug(
+              "Getting variables to render index page",
+              renderLogAttributes,
+            );
             try {
               const variablesToRenderIndexPage: JSONObject =
                 await data.getVariablesToRenderIndexPage(_req, res);
@@ -300,16 +330,20 @@ const init: InitFunction = async (
                 ...variablesToRenderIndexPage,
               };
             } catch (error) {
-              logger.error(error);
+              logger.error(error, renderLogAttributes);
             }
           }
 
-          logger.debug("Rendering index page with variables: ");
-          logger.debug(variables);
+          logger.debug(
+            "Rendering index page with variables: ",
+            renderLogAttributes,
+          );
+          logger.debug(variables, renderLogAttributes);
 
           if (res.headersSent) {
             logger.debug(
               "Response already sent while preparing index page. Skipping render.",
+              renderLogAttributes,
             );
             return;
           }
@@ -369,7 +403,7 @@ const addDefaultRoutes: PromiseVoidFunction = async (): Promise<void> => {
       res: ExpressResponse,
       next: NextFunction,
     ) => {
-      logger.error(err);
+      logger.error(err, getLogAttributesFromRequest(_req as OneUptimeRequest));
 
       // Mark span as error.
       if (err) {

package/Server/Utils/Telemetry/SpanUtil.ts

@@ -0,0 +1,90 @@
+import OpenTelemetryAPI, { Span } from "@opentelemetry/api";
+import { DisableTelemetry } from "../../EnvironmentConfig";
+
+export interface SpanAttributes {
+  userId?: string | undefined;
+  projectId?: string | undefined;
+  requestId?: string | undefined;
+  incidentId?: string | undefined;
+  alertId?: string | undefined;
+  monitorId?: string | undefined;
+  statusPageId?: string | undefined;
+  scheduledMaintenanceId?: string | undefined;
+  onCallDutyPolicyId?: string | undefined;
+  onCallDutyPolicyScheduleId?: string | undefined;
+  incidentEpisodeId?: string | undefined;
+  alertEpisodeId?: string | undefined;
+  workspaceType?: string | undefined;
+  channelId?: string | undefined;
+  [key: string]: string | number | boolean | undefined;
+}
+
+export default class SpanUtil {
+  /**
+   * Add attributes to the currently active span.
+   * Safe to call even when there is no active span or telemetry is disabled.
+   */
+  public static addAttributesToCurrentSpan(attributes: SpanAttributes): void {
+    if (DisableTelemetry) {
+      return;
+    }
+
+    const span: Span | undefined = OpenTelemetryAPI.trace.getActiveSpan();
+
+    if (!span) {
+      return;
+    }
+
+    this.addAttributesToSpan({ span, attributes });
+  }
+
+  /**
+   * Add attributes to a specific span.
+   */
+  public static addAttributesToSpan(data: {
+    span: Span;
+    attributes: SpanAttributes;
+  }): void {
+    const { span, attributes } = data;
+
+    for (const key in attributes) {
+      const value: string | number | boolean | undefined = attributes[key];
+
+      if (value !== undefined && value !== null) {
+        span.setAttribute(key, value);
+      }
+    }
+  }
+
+  /**
+   * Build span attributes from a request-like object.
+   * Similar to getLogAttributesFromRequest in Logger but for spans.
+   */
+  public static getSpanAttributesFromRequest(
+    req?: {
+      requestId?: string;
+      tenantId?: { toString(): string };
+      userAuthorization?: { userId?: { toString(): string } };
+    } | null,
+  ): SpanAttributes {
+    if (!req) {
+      return {};
+    }
+
+    const attributes: SpanAttributes = {};
+
+    if (req.requestId) {
+      attributes["requestId"] = req.requestId;
+    }
+
+    if (req.tenantId) {
+      attributes["projectId"] = req.tenantId.toString();
+    }
+
+    if (req.userAuthorization?.userId) {
+      attributes["userId"] = req.userAuthorization.userId.toString();
+    }
+
+    return attributes;
+  }
+}

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

@@ -49,7 +49,10 @@ export default class MicrosoftTeamsAlertActions {
   }): Promise<void> {
     const { teamsRequest, action } = data;
 
-    logger.debug("Handling Microsoft Teams alert action:");
+    logger.debug("Handling Microsoft Teams alert action:", {
+      projectId: teamsRequest.projectId.toString(),
+      actionType: action.actionType,
+    });
     logger.debug(action);
 
     try {
@@ -73,11 +76,17 @@ export default class MicrosoftTeamsAlertActions {
           break;
 
         default:
-          logger.debug("Unhandled alert action: " + action.actionType);
+          logger.debug("Unhandled alert action: " + action.actionType, {
+            projectId: teamsRequest.projectId.toString(),
+            actionType: action.actionType,
+          });
           break;
       }
     } catch (error) {
-      logger.error("Error handling Microsoft Teams alert action:");
+      logger.error("Error handling Microsoft Teams alert action:", {
+        projectId: teamsRequest.projectId.toString(),
+        actionType: action.actionType,
+      });
       logger.error(error);
     }
 
@@ -92,11 +101,16 @@ export default class MicrosoftTeamsAlertActions {
     const alertId: string = data.action.actionValue || "";
 
     if (!alertId) {
-      logger.error("No alert ID provided for acknowledge action");
+      logger.error("No alert ID provided for acknowledge action", {
+        projectId: data.teamsRequest.projectId.toString(),
+      });
       return;
     }
 
-    logger.debug("Acknowledging alert: " + alertId);
+    logger.debug("Acknowledging alert: " + alertId, {
+      projectId: data.teamsRequest.projectId.toString(),
+      alertId: alertId,
+    });
 
     try {
       const alert: Alert | null = await AlertService.findOneBy({
@@ -119,12 +133,18 @@ export default class MicrosoftTeamsAlertActions {
       });
 
       if (!alert) {
-        logger.error("Alert not found: " + alertId);
+        logger.error("Alert not found: " + alertId, {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertId: alertId,
+        });
         return;
       }
 
       if (alert.currentAlertState?.isAcknowledgedState) {
-        logger.debug("Alert is already acknowledged");
+        logger.debug("Alert is already acknowledged", {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertId: alertId,
+        });
         return;
       }
 
@@ -139,9 +159,15 @@ export default class MicrosoftTeamsAlertActions {
         oneUptimeUserId,
       );
 
-      logger.debug("Alert acknowledged successfully");
+      logger.debug("Alert acknowledged successfully", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertId: alertId,
+      });
     } catch (error) {
-      logger.error("Error acknowledging alert:");
+      logger.error("Error acknowledging alert:", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertId: alertId,
+      });
       logger.error(error);
     }
   }
@@ -154,11 +180,16 @@ export default class MicrosoftTeamsAlertActions {
     const alertId: string = data.action.actionValue || "";
 
     if (!alertId) {
-      logger.error("No alert ID provided for resolve action");
+      logger.error("No alert ID provided for resolve action", {
+        projectId: data.teamsRequest.projectId.toString(),
+      });
       return;
     }
 
-    logger.debug("Resolving alert: " + alertId);
+    logger.debug("Resolving alert: " + alertId, {
+      projectId: data.teamsRequest.projectId.toString(),
+      alertId: alertId,
+    });
 
     try {
       const alert: Alert | null = await AlertService.findOneBy({
@@ -181,12 +212,18 @@ export default class MicrosoftTeamsAlertActions {
       });
 
       if (!alert) {
-        logger.error("Alert not found: " + alertId);
+        logger.error("Alert not found: " + alertId, {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertId: alertId,
+        });
         return;
       }
 
       if (alert.currentAlertState?.isResolvedState) {
-        logger.debug("Alert is already resolved");
+        logger.debug("Alert is already resolved", {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertId: alertId,
+        });
         return;
       }
 
@@ -198,9 +235,15 @@ export default class MicrosoftTeamsAlertActions {
 
       await AlertService.resolveAlert(new ObjectID(alertId), oneUptimeUserId);
 
-      logger.debug("Alert resolved successfully");
+      logger.debug("Alert resolved successfully", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertId: alertId,
+      });
     } catch (error) {
-      logger.error("Error resolving alert:");
+      logger.error("Error resolving alert:", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertId: alertId,
+      });
       logger.error(error);
     }
   }

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

@@ -58,7 +58,10 @@ export default class MicrosoftTeamsAlertEpisodeActions {
   }): Promise<void> {
     const { teamsRequest, action } = data;
 
-    logger.debug("Handling Microsoft Teams alert episode action:");
+    logger.debug("Handling Microsoft Teams alert episode action:", {
+      projectId: teamsRequest.projectId.toString(),
+      actionType: action.actionType,
+    });
     logger.debug(action);
 
     try {
@@ -82,11 +85,17 @@ export default class MicrosoftTeamsAlertEpisodeActions {
           break;
 
         default:
-          logger.debug("Unhandled alert episode action: " + action.actionType);
+          logger.debug("Unhandled alert episode action: " + action.actionType, {
+            projectId: teamsRequest.projectId.toString(),
+            actionType: action.actionType,
+          });
           break;
       }
     } catch (error) {
-      logger.error("Error handling Microsoft Teams alert episode action:");
+      logger.error("Error handling Microsoft Teams alert episode action:", {
+        projectId: teamsRequest.projectId.toString(),
+        actionType: action.actionType,
+      });
       logger.error(error);
     }
 
@@ -101,11 +110,16 @@ export default class MicrosoftTeamsAlertEpisodeActions {
     const episodeId: string = data.action.actionValue || "";
 
     if (!episodeId) {
-      logger.error("No episode ID provided for acknowledge action");
+      logger.error("No episode ID provided for acknowledge action", {
+        projectId: data.teamsRequest.projectId.toString(),
+      });
       return;
     }
 
-    logger.debug("Acknowledging alert episode: " + episodeId);
+    logger.debug("Acknowledging alert episode: " + episodeId, {
+      projectId: data.teamsRequest.projectId.toString(),
+      alertEpisodeId: episodeId,
+    });
 
     try {
       const episode: AlertEpisode | null = await AlertEpisodeService.findOneBy({
@@ -128,12 +142,18 @@ export default class MicrosoftTeamsAlertEpisodeActions {
       });
 
       if (!episode) {
-        logger.error("Alert episode not found: " + episodeId);
+        logger.error("Alert episode not found: " + episodeId, {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertEpisodeId: episodeId,
+        });
         return;
       }
 
       if (episode.currentAlertState?.isAcknowledgedState) {
-        logger.debug("Alert episode is already acknowledged");
+        logger.debug("Alert episode is already acknowledged", {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertEpisodeId: episodeId,
+        });
         return;
       }
 
@@ -148,9 +168,15 @@ export default class MicrosoftTeamsAlertEpisodeActions {
         oneUptimeUserId,
       );
 
-      logger.debug("Alert episode acknowledged successfully");
+      logger.debug("Alert episode acknowledged successfully", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertEpisodeId: episodeId,
+      });
     } catch (error) {
-      logger.error("Error acknowledging alert episode:");
+      logger.error("Error acknowledging alert episode:", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertEpisodeId: episodeId,
+      });
       logger.error(error);
     }
   }
@@ -163,11 +189,16 @@ export default class MicrosoftTeamsAlertEpisodeActions {
     const episodeId: string = data.action.actionValue || "";
 
     if (!episodeId) {
-      logger.error("No episode ID provided for resolve action");
+      logger.error("No episode ID provided for resolve action", {
+        projectId: data.teamsRequest.projectId.toString(),
+      });
       return;
     }
 
-    logger.debug("Resolving alert episode: " + episodeId);
+    logger.debug("Resolving alert episode: " + episodeId, {
+      projectId: data.teamsRequest.projectId.toString(),
+      alertEpisodeId: episodeId,
+    });
 
     try {
       const episode: AlertEpisode | null = await AlertEpisodeService.findOneBy({
@@ -190,12 +221,18 @@ export default class MicrosoftTeamsAlertEpisodeActions {
       });
 
       if (!episode) {
-        logger.error("Alert episode not found: " + episodeId);
+        logger.error("Alert episode not found: " + episodeId, {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertEpisodeId: episodeId,
+        });
         return;
       }
 
       if (episode.currentAlertState?.isResolvedState) {
-        logger.debug("Alert episode is already resolved");
+        logger.debug("Alert episode is already resolved", {
+          projectId: data.teamsRequest.projectId.toString(),
+          alertEpisodeId: episodeId,
+        });
         return;
       }
 
@@ -210,9 +247,15 @@ export default class MicrosoftTeamsAlertEpisodeActions {
         oneUptimeUserId,
       );
 
-      logger.debug("Alert episode resolved successfully");
+      logger.debug("Alert episode resolved successfully", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertEpisodeId: episodeId,
+      });
     } catch (error) {
-      logger.error("Error resolving alert episode:");
+      logger.error("Error resolving alert episode:", {
+        projectId: data.teamsRequest.projectId.toString(),
+        alertEpisodeId: episodeId,
+      });
       logger.error(error);
     }
   }

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

@@ -100,7 +100,9 @@ export default class MicrosoftTeamsAuthAction {
 
     // Find the project associated with this team
     if (!teamId) {
-      logger.debug("No team ID found in payload");
+      logger.debug("No team ID found in payload", {
+        tenantId: tenantId,
+      });
       return {
         isAuthorized: false,
         projectId: new ObjectID(""),
@@ -130,7 +132,10 @@ export default class MicrosoftTeamsAuthAction {
         },
       });
     } catch (error) {
-      logger.debug("Error finding project auth token:");
+      logger.debug("Error finding project auth token:", {
+        teamId: teamId,
+        tenantId: tenantId,
+      });
       logger.debug(error);
       return {
         isAuthorized: false,
@@ -142,7 +147,10 @@ export default class MicrosoftTeamsAuthAction {
     }
 
     if (!projectAuthToken) {
-      logger.debug(`No project auth token found for team: ${teamId}`);
+      logger.debug(`No project auth token found for team: ${teamId}`, {
+        teamId: teamId,
+        tenantId: tenantId,
+      });
       return {
         isAuthorized: false,
         projectId: new ObjectID(""),
@@ -219,6 +227,10 @@ export default class MicrosoftTeamsAuthAction {
       if (workspaceUserAuthToken && workspaceUserAuthToken.userId) {
         logger.debug(
           "Found OneUptime user for Teams user: " + data.teamsUserId,
+          {
+            projectId: data.projectId.toString(),
+            workspaceUserId: data.teamsUserId,
+          },
         );
         return workspaceUserAuthToken.userId;
       }
@@ -229,6 +241,10 @@ export default class MicrosoftTeamsAuthAction {
     } catch (error) {
       logger.error(
         "Error finding OneUptime user for Teams user: " + data.teamsUserId,
+        {
+          projectId: data.projectId.toString(),
+          workspaceUserId: data.teamsUserId,
+        },
       );
       logger.error(error);
       throw error;