@oneuptime/common 10.0.53 → 10.0.54

package/Server/Utils/Logger.ts

@@ -7,6 +7,47 @@ import ConfigLogLevel from "../Types/ConfigLogLevel";
 
 export type LogBody = string | JSONObject | Exception | Error | unknown;
 
+export interface LogAttributes {
+  userId?: string | undefined;
+  projectId?: string | undefined;
+  requestId?: string | undefined;
+  [key: string]: string | number | boolean | undefined;
+}
+
+export interface RequestLike {
+  requestId?: string;
+  tenantId?: { toString(): string };
+  userAuthorization?: { userId?: { toString(): string } };
+}
+
+export function getLogAttributesFromRequest(
+  req?: RequestLike | null,
+): LogAttributes {
+  if (!req) {
+    return {};
+  }
+
+  try {
+    const attributes: LogAttributes = {};
+
+    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;
+  } catch {
+    return {};
+  }
+}
+
 export default class logger {
   public static getLogLevel(): ConfigLogLevel {
     if (!LogLevel) {
@@ -25,7 +66,31 @@ export default class logger {
     return JSON.stringify(body);
   }
 
-  public static info(message: LogBody): void {
+  private static sanitizeAttributes(
+    attributes?: LogAttributes,
+  ): Record<string, string | number | boolean> | undefined {
+    if (!attributes) {
+      return undefined;
+    }
+
+    try {
+      const sanitized: Record<string, string | number | boolean> = {};
+
+      for (const key in attributes) {
+        const value: string | number | boolean | undefined = attributes[key];
+
+        if (value !== undefined && value !== null) {
+          sanitized[key] = value;
+        }
+      }
+
+      return Object.keys(sanitized).length > 0 ? sanitized : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  public static info(message: LogBody, attributes?: LogAttributes): void {
     const logLevel: ConfigLogLevel = this.getLogLevel();
 
     if (logLevel === ConfigLogLevel.DEBUG || logLevel === ConfigLogLevel.INFO) {
@@ -35,11 +100,12 @@ export default class logger {
       this.emit({
         body: message,
         severityNumber: SeverityNumber.INFO,
+        attributes,
       });
     }
   }
 
-  public static error(message: LogBody): void {
+  public static error(message: LogBody, attributes?: LogAttributes): void {
     const logLevel: ConfigLogLevel = this.getLogLevel();
 
     if (
@@ -54,11 +120,12 @@ export default class logger {
       this.emit({
         body: message,
         severityNumber: SeverityNumber.ERROR,
+        attributes,
       });
     }
   }
 
-  public static warn(message: LogBody): void {
+  public static warn(message: LogBody, attributes?: LogAttributes): void {
     const logLevel: ConfigLogLevel = this.getLogLevel();
 
     if (
@@ -72,11 +139,12 @@ export default class logger {
       this.emit({
         body: message,
         severityNumber: SeverityNumber.WARN,
+        attributes,
       });
     }
   }
 
-  public static debug(message: LogBody): void {
+  public static debug(message: LogBody, attributes?: LogAttributes): void {
     const logLevel: ConfigLogLevel = this.getLogLevel();
 
     if (logLevel === ConfigLogLevel.DEBUG) {
@@ -86,6 +154,7 @@ export default class logger {
       this.emit({
         body: message,
         severityNumber: SeverityNumber.DEBUG,
+        attributes,
       });
     }
   }
@@ -93,20 +162,30 @@ export default class logger {
   public static emit(data: {
     body: LogBody;
     severityNumber: SeverityNumber;
+    attributes?: LogAttributes | undefined;
   }): void {
-    const logger: TelemetryLogger | null = OneUptimeTelemetry.getLogger();
+    try {
+      const logger: TelemetryLogger | null = OneUptimeTelemetry.getLogger();
 
-    if (logger === null) {
-      return;
-    }
+      if (logger === null) {
+        return;
+      }
 
-    logger.emit({
-      body: this.serializeLogBody(data.body),
-      severityNumber: data.severityNumber,
-    });
+      const sanitizedAttributes:
+        | Record<string, string | number | boolean>
+        | undefined = this.sanitizeAttributes(data.attributes);
+
+      logger.emit({
+        body: this.serializeLogBody(data.body),
+        severityNumber: data.severityNumber,
+        ...(sanitizedAttributes ? { attributes: sanitizedAttributes } : {}),
+      });
+    } catch {
+      // Never let logging errors propagate
+    }
   }
 
-  public static trace(message: LogBody): void {
+  public static trace(message: LogBody, attributes?: LogAttributes): void {
     const logLevel: ConfigLogLevel = this.getLogLevel();
 
     if (logLevel === ConfigLogLevel.DEBUG) {
@@ -116,6 +195,7 @@ export default class logger {
       this.emit({
         body: message,
         severityNumber: SeverityNumber.DEBUG,
+        attributes,
       });
     }
   }

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -17,7 +17,7 @@ import { DisableAutomaticAlertCreation } from "../../EnvironmentConfig";
 import AlertService from "../../Services/AlertService";
 import AlertSeverityService from "../../Services/AlertSeverityService";
 import AlertStateTimelineService from "../../Services/AlertStateTimelineService";
-import logger from "../Logger";
+import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
 import MonitorTemplateUtil from "./MonitorTemplateUtil";
@@ -104,8 +104,15 @@ export default class MonitorAlert {
       telemetryQuery?: TelemetryQuery | undefined;
     };
   }): Promise<void> {
+    const alertLogAttributes: LogAttributes = {
+      projectId: input.monitor.projectId?.toString(),
+    };
+
     // check open alerts
-    logger.debug(`${input.monitor.id?.toString()} - Check open alerts.`);
+    logger.debug(
+      `${input.monitor.id?.toString()} - Check open alerts.`,
+      alertLogAttributes,
+    );
     // check active alerts and if there are open alerts, do not cretae anothr alert.
     const openAlerts: Array<Alert> =
       await this.checkOpenAlertsAndCloseIfResolved({
@@ -137,10 +144,12 @@ export default class MonitorAlert {
 
         logger.debug(
           `${input.monitor.id?.toString()} - Open Alert ${alreadyOpenAlert?.id?.toString()}`,
+          alertLogAttributes,
         );
 
         logger.debug(
           `${input.monitor.id?.toString()} - Has open alert ${hasAlreadyOpenAlert}`,
+          alertLogAttributes,
         );
 
         if (hasAlreadyOpenAlert) {
@@ -161,7 +170,10 @@ export default class MonitorAlert {
 
         // create alert here.
 
-        logger.debug(`${input.monitor.id?.toString()} - Create alert.`);
+        logger.debug(
+          `${input.monitor.id?.toString()} - Create alert.`,
+          alertLogAttributes,
+        );
 
         const alert: Alert = new Alert();
         const storageMap: JSONObject =

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -1,4 +1,4 @@
-import logger from "../Logger";
+import logger, { LogAttributes } from "../Logger";
 import LogAggregationService from "../../Services/LogAggregationService";
 import VMUtil from "../VM/VMAPI";
 import APIRequestCriteria from "./Criteria/APIRequestCriteria";
@@ -284,7 +284,9 @@ ${contextBlock}
               .responseBody as string) || "{}",
           );
         } catch (err) {
-          logger.error(err);
+          logger.error(err, {
+            projectId: input.monitor.projectId?.toString(),
+          });
           responseBody = (input.dataToProcess as ProbeMonitorResponse)
             .responseBody as JSONObject;
         }
@@ -331,7 +333,9 @@ ${contextBlock}
           },
         });
       } catch (err) {
-        logger.error(err);
+        logger.error(err, {
+          projectId: input.monitor.projectId?.toString(),
+        });
         return null;
       }
 
@@ -903,8 +907,14 @@ ${contextBlock}
             );
           }
         } catch (err) {
-          logger.error("Failed to fetch container logs for root cause context");
-          logger.error(err);
+          const k8sLogAttributes: LogAttributes = {
+            projectId: input.monitor.projectId?.toString(),
+          };
+          logger.error(
+            "Failed to fetch container logs for root cause context",
+            k8sLogAttributes,
+          );
+          logger.error(err, k8sLogAttributes);
         }
       }
     }

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -19,7 +19,7 @@ import IncidentService from "../../Services/IncidentService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
 import IncidentMemberService from "../../Services/IncidentMemberService";
-import logger from "../Logger";
+import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
 import MonitorTemplateUtil from "./MonitorTemplateUtil";
@@ -113,8 +113,15 @@ export default class MonitorIncident {
       telemetryQuery?: TelemetryQuery | undefined;
     };
   }): Promise<void> {
+    const incidentLogAttributes: LogAttributes = {
+      projectId: input.monitor.projectId?.toString(),
+    };
+
     // check open incidents
-    logger.debug(`${input.monitor.id?.toString()} - Check open incidents.`);
+    logger.debug(
+      `${input.monitor.id?.toString()} - Check open incidents.`,
+      incidentLogAttributes,
+    );
     // check active incidents and if there are open incidents, do not cretae anothr incident.
     const openIncidents: Array<Incident> =
       await this.checkOpenIncidentsAndCloseIfResolved({
@@ -149,10 +156,12 @@ export default class MonitorIncident {
 
         logger.debug(
           `${input.monitor.id?.toString()} - Open Incident ${alreadyOpenIncident?.id?.toString()}`,
+          incidentLogAttributes,
         );
 
         logger.debug(
           `${input.monitor.id?.toString()} - Has open incident ${hasAlreadyOpenIncident}`,
+          incidentLogAttributes,
         );
 
         if (hasAlreadyOpenIncident) {
@@ -171,7 +180,10 @@ export default class MonitorIncident {
           continue;
         }
 
-        logger.debug(`${input.monitor.id?.toString()} - Create incident.`);
+        logger.debug(
+          `${input.monitor.id?.toString()} - Create incident.`,
+          incidentLogAttributes,
+        );
 
         const incident: Incident = new Incident();
         const storageMap: JSONObject =
@@ -341,11 +353,13 @@ export default class MonitorIncident {
 
                 logger.debug(
                   `${input.monitor.id?.toString()} - Assigned incident member role ${assignment.roleId.toString()} to user ${assignment.userId.toString()}`,
+                  incidentLogAttributes,
                 );
               }
             } catch (memberError) {
               logger.error(
                 `${input.monitor.id?.toString()} - Failed to assign incident member role: ${memberError}`,
+                incidentLogAttributes,
               );
             }
           }

package/Server/Utils/Monitor/MonitorStatusTimeline.ts

@@ -6,7 +6,7 @@ import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInsta
 import ObjectID from "../../../Types/ObjectID";
 import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import MonitorStatusTimelineService from "../../Services/MonitorStatusTimelineService";
-import logger from "../Logger";
+import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
 
@@ -71,8 +71,13 @@ export default class MonitorStatusTimelineUtil {
     }
 
     if (shouldUpdateStatus) {
+      const monitorLogAttributes: LogAttributes = {
+        projectId: input.monitor.projectId?.toString(),
+      };
+
       logger.debug(
         `${input.monitor.id?.toString()} - Change monitor status to ${input.criteriaInstance.data?.monitorStatusId?.toString()}`,
+        monitorLogAttributes,
       );
       // change monitor status
 

package/Server/Utils/Profiling.ts

@@ -1,6 +1,6 @@
 import Pyroscope from "@pyroscope/nodejs";
 import { EnableProfiling } from "../EnvironmentConfig";
-import logger from "./Logger";
+import logger, { LogAttributes } from "./Logger";
 
 export default class Profiling {
   public static init(data: { serviceName: string }): void {
@@ -11,9 +11,14 @@ export default class Profiling {
     const serverAddress: string | undefined = this.getServerAddress();
     const authToken: string | undefined = this.getAuthToken();
 
+    const profilingLogAttributes: LogAttributes = {
+      serviceName: data.serviceName,
+    };
+
     if (!serverAddress) {
       logger.warn(
         "Profiling enabled but OPENTELEMETRY_EXPORTER_OTLP_ENDPOINT not configured. Skipping profiling initialization.",
+        profilingLogAttributes,
       );
       return;
     }
@@ -32,16 +37,17 @@ export default class Profiling {
 
       logger.info(
         `Profiling initialized for service: ${data.serviceName} -> ${serverAddress}`,
+        profilingLogAttributes,
       );
     } catch (err) {
-      logger.error("Failed to initialize profiling:");
-      logger.error(err);
+      logger.error("Failed to initialize profiling:", profilingLogAttributes);
+      logger.error(err, profilingLogAttributes);
     }
 
     process.on("SIGTERM", () => {
       Pyroscope.stop().catch((err: unknown) => {
-        logger.error("Error stopping profiler:");
-        logger.error(err);
+        logger.error("Error stopping profiler:", profilingLogAttributes);
+        logger.error(err, profilingLogAttributes);
       });
     });
   }

package/Server/Utils/Realtime.ts

@@ -1,5 +1,5 @@
 import IO, { Socket, SocketServer } from "../Infrastructure/SocketIO";
-import logger from "./Logger";
+import logger, { LogAttributes } from "./Logger";
 import AnalyticsBaseModel from "../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import DatabaseType from "../../Types/BaseDatabase/DatabaseType";
@@ -49,20 +49,24 @@ export default abstract class Realtime {
           logger.debug("Received ListenToModalEvent with data:");
           logger.debug(data);
 
+          const socketLogAttributes: LogAttributes = {
+            projectId: data["tenantId"]?.toString(),
+          };
+
           if (typeof data["eventType"] !== "string") {
-            logger.error("eventType is not a string");
+            logger.error("eventType is not a string", socketLogAttributes);
             throw new BadDataException("eventType is not a string");
           }
           if (typeof data["modelType"] !== "string") {
-            logger.error("modelType is not a string");
+            logger.error("modelType is not a string", socketLogAttributes);
             throw new BadDataException("modelType is not a string");
           }
           if (typeof data["modelName"] !== "string") {
-            logger.error("modelName is not a string");
+            logger.error("modelName is not a string", socketLogAttributes);
             throw new BadDataException("modelName is not a string");
           }
           if (typeof data["tenantId"] !== "string") {
-            logger.error("tenantId is not a string");
+            logger.error("tenantId is not a string", socketLogAttributes);
             throw new BadDataException("tenantId is not a string");
           }
 
@@ -84,11 +88,18 @@ export default abstract class Realtime {
     socket: Socket,
     data: ListenToModelEventJSON,
   ): Promise<void> {
-    logger.debug("Listening to model event with data:");
-    logger.debug(data);
+    const listenLogAttributes: LogAttributes = {
+      projectId: data.tenantId?.toString(),
+    };
+
+    logger.debug("Listening to model event with data:", listenLogAttributes);
+    logger.debug(data, listenLogAttributes);
 
     if (!this.socketServer) {
-      logger.debug("Socket server not initialized, initializing now");
+      logger.debug(
+        "Socket server not initialized, initializing now",
+        listenLogAttributes,
+      );
       await this.init();
     }
 
@@ -97,42 +108,56 @@ export default abstract class Realtime {
      * and to this model and to this event type
      */
 
-    logger.debug("Extracting user access token from socket");
+    logger.debug(
+      "Extracting user access token from socket",
+      listenLogAttributes,
+    );
     const userAccessToken: string | undefined =
       this.getAccessTokenFromSocket(socket);
 
     if (!userAccessToken) {
       logger.debug(
         "User access token not found in socket, aborting joining room",
+        listenLogAttributes,
       );
       return;
     }
 
-    logger.debug("Decoding user access token");
+    logger.debug("Decoding user access token", listenLogAttributes);
     const userAuthorizationData: JSONWebTokenData =
       JSONWebToken.decode(userAccessToken);
 
     if (!userAuthorizationData) {
       logger.debug(
         "User authorization data not found in socket, aborting joining room",
+        listenLogAttributes,
       );
       return;
     }
 
     if (!userAuthorizationData.userId) {
-      logger.debug("User ID not found in socket, aborting joining room");
+      logger.debug(
+        "User ID not found in socket, aborting joining room",
+        listenLogAttributes,
+      );
       return;
     }
 
-    logger.debug("Checking user access permissions");
+    logger.debug("Checking user access permissions", listenLogAttributes);
     let hasAccess: boolean = false;
 
     if (userAuthorizationData.isMasterAdmin) {
-      logger.debug("User is a master admin, granting access");
+      logger.debug(
+        "User is a master admin, granting access",
+        listenLogAttributes,
+      );
       hasAccess = true;
     }
 
-    logger.debug("Fetching user global access permissions");
+    logger.debug(
+      "Fetching user global access permissions",
+      listenLogAttributes,
+    );
     const userGlobalAccessPermission: UserGlobalAccessPermission | null =
       await UserPermissionUtil.getUserGlobalAccessPermissionFromCache(
         userAuthorizationData.userId,
@@ -140,7 +165,10 @@ export default abstract class Realtime {
 
     // check if the user has access to this tenant
     if (userGlobalAccessPermission && !hasAccess) {
-      logger.debug("Checking if user has access to the tenant");
+      logger.debug(
+        "Checking if user has access to the tenant",
+        listenLogAttributes,
+      );
       const hasAccessToProjectId: boolean =
         userGlobalAccessPermission.projectIds.some((projectId: ObjectID) => {
           return projectId.toString() === data.tenantId.toString();
@@ -149,11 +177,15 @@ export default abstract class Realtime {
       if (!hasAccessToProjectId) {
         logger.debug(
           "User does not have access to this tenant, aborting joining room",
+          listenLogAttributes,
         );
         return;
       }
 
-      logger.debug("User has access to the tenant, checking model access");
+      logger.debug(
+        "User has access to the tenant, checking model access",
+        listenLogAttributes,
+      );
       const userId: ObjectID = new ObjectID(
         userAuthorizationData.userId.toString(),
       );
@@ -174,7 +206,10 @@ export default abstract class Realtime {
           data.modelName,
         )
       ) {
-        logger.debug("User has access to the model, granting access");
+        logger.debug(
+          "User has access to the model, granting access",
+          listenLogAttributes,
+        );
         hasAccess = true;
       }
     }
@@ -182,6 +217,7 @@ export default abstract class Realtime {
     if (!hasAccess) {
       logger.debug(
         "User does not have access to this tenant, aborting joining room",
+        listenLogAttributes,
       );
       return;
     }
@@ -194,7 +230,7 @@ export default abstract class Realtime {
         data.modelId,
       );
 
-      logger.debug(`Joining room with ID: ${modelRoomId}`);
+      logger.debug(`Joining room with ID: ${modelRoomId}`, listenLogAttributes);
       // join the room.
       await socket.join(modelRoomId);
     } else {
@@ -204,7 +240,7 @@ export default abstract class Realtime {
         data.eventType,
       );
 
-      logger.debug(`Joining room with ID: ${roomId}`);
+      logger.debug(`Joining room with ID: ${roomId}`, listenLogAttributes);
       // join the room.
       await socket.join(roomId);
     }
@@ -215,11 +251,21 @@ export default abstract class Realtime {
     socket: Socket,
     data: ListenToModelEventJSON,
   ): Promise<void> {
-    logger.debug("Stopping listening to model event with data:");
-    logger.debug(data);
+    const stopLogAttributes: LogAttributes = {
+      projectId: data.tenantId?.toString(),
+    };
+
+    logger.debug(
+      "Stopping listening to model event with data:",
+      stopLogAttributes,
+    );
+    logger.debug(data, stopLogAttributes);
 
     if (!this.socketServer) {
-      logger.debug("Socket server not initialized, initializing now");
+      logger.debug(
+        "Socket server not initialized, initializing now",
+        stopLogAttributes,
+      );
       await this.init();
     }
 
@@ -230,7 +276,7 @@ export default abstract class Realtime {
       data.modelId,
     );
 
-    logger.debug(`Leaving room with ID: ${roomId}`);
+    logger.debug(`Leaving room with ID: ${roomId}`, stopLogAttributes);
     // leave this room.
     await socket.leave(roomId);
   }
@@ -242,13 +288,20 @@ export default abstract class Realtime {
     modelId: ObjectID;
     modelType: { new (): BaseModel | AnalyticsBaseModel };
   }): Promise<void> {
-    logger.debug("Emitting model event with data:");
-    logger.debug(`Tenant ID: ${data.tenantId}`);
-    logger.debug(`Event Type: ${data.eventType}`);
-    logger.debug(`Model ID: ${data.modelId}`);
+    const emitLogAttributes: LogAttributes = {
+      projectId: data.tenantId?.toString(),
+    };
+
+    logger.debug("Emitting model event with data:", emitLogAttributes);
+    logger.debug(`Tenant ID: ${data.tenantId}`, emitLogAttributes);
+    logger.debug(`Event Type: ${data.eventType}`, emitLogAttributes);
+    logger.debug(`Model ID: ${data.modelId}`, emitLogAttributes);
 
     if (!this.socketServer) {
-      logger.debug("Socket server not initialized, initializing now");
+      logger.debug(
+        "Socket server not initialized, initializing now",
+        emitLogAttributes,
+      );
       await this.init();
     }
 
@@ -259,7 +312,10 @@ export default abstract class Realtime {
     const model: BaseModel | AnalyticsBaseModel = new data.modelType();
 
     if (!model.tableName) {
-      logger.warn("Model does not have a tableName, aborting emit");
+      logger.warn(
+        "Model does not have a tableName, aborting emit",
+        emitLogAttributes,
+      );
       return;
     }
 
@@ -276,8 +332,11 @@ export default abstract class Realtime {
       data.modelId,
     );
 
-    logger.debug(`Emitting event to room with ID: ${roomId}`);
-    logger.debug(jsonObject);
+    logger.debug(
+      `Emitting event to room with ID: ${roomId}`,
+      emitLogAttributes,
+    );
+    logger.debug(jsonObject, emitLogAttributes);
 
     this.socketServer!.to(roomId).emit(roomId, jsonObject);
     this.socketServer!.to(modelRoomId).emit(modelRoomId, jsonObject);

package/Server/Utils/Response.ts

@@ -5,7 +5,7 @@ import {
   OneUptimeResponse,
 } from "./Express";
 import JsonToCsv from "./JsonToCsv";
-import logger from "./Logger";
+import logger, { getLogAttributesFromRequest } from "./Logger";
 import AnalyticsDataModel, {
   AnalyticsBaseModelType,
 } from "../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
@@ -109,7 +109,7 @@ export default class Response {
     const status: number = error.code || 500;
     const message: string = error.message || "Server Error";
 
-    logger.error(error);
+    logger.error(error, getLogAttributesFromRequest(_req as any));
 
     oneUptimeResponse.status(status).send({ message });
   }