feat: add incident model, module and service with StatusService integration

- Create Incident model with resolution tracking fields
- Implement IncidentModule for data access
- Implement IncidentService with business logic
- Integrate with StatusService to auto-create/resolve incidents on status change
This commit is contained in:
karenvicent committed 2025-11-06 17:06:33 -05:00
1 parent eb70c9f5f0
commit 0c3fdbc539
7 files changed
+748 -4

No files matched your search

+83
View File
@@ -0,0 +1,83 @@
import { Typography, Select } from "@mui/material";
import MenuItem from "@mui/material/MenuItem";
import type { SelectProps } from "@mui/material/Select";
import { useTheme } from "@mui/material/styles";
import KeyboardArrowDownIcon from "@mui/icons-material/KeyboardArrowDown";
export const SelectInput: React.FC<SelectProps> = ({ ...props }) => {
const theme = useTheme();
return (
<Select
{...props}
sx={{
height: "34px",
"& .MuiOutlinedInput-notchedOutline": {
borderRadius: theme.shape.borderRadius,
borderColor: theme.palette.primary.lowContrast,
},
"&:hover .MuiOutlinedInput-notchedOutline": {
borderColor: theme.palette.primary.lowContrast,
},
}}
/>
);
};
type ItemTypes = string | number;
interface SelectItem {
_id: ItemTypes;
name: string;
}
export type CustomSelectProps = SelectProps & {
items: SelectItem[];
placeholder?: string;
isHidden?: boolean;
hasError?: boolean;
};
export const SelectFromItems: React.FC<CustomSelectProps> = (
{ items, placeholder, isHidden = false, hasError = false, ...props }
) => {
return (
<SelectInput
error={hasError}
IconComponent={KeyboardArrowDownIcon}
displayEmpty
MenuProps={{ disableScrollLock: true }}
renderValue={(selected) => {
if (!selected) {
return (
<Typography
noWrap
color="text.secondary"
>
{placeholder ?? ""}
</Typography>
);
}
const selectedItem = items.find((item) => item._id === selected);
const displayName = selectedItem ? selectedItem.name : placeholder;
return (
<Typography
noWrap
title={displayName}
>
{displayName}
</Typography>
);
}}
{...props}
>
{items.map((item) => (
<MenuItem
key={item._id}
value={item._id}
>
{item.name}
</MenuItem>
))}
</SelectInput>
);
}
SelectInput.displayName = "SelectInput";
@@ -0,0 +1,277 @@
const SERVICE_NAME = "incidentService";
class IncidentService {
static SERVICE_NAME = SERVICE_NAME;
constructor({ db, logger, errorService, stringService }) {
this.db = db;
this.logger = logger;
this.errorService = errorService;
this.stringService = stringService;
}
get serviceName() {
return IncidentService.SERVICE_NAME;
}
createIncident = async (monitor, check) => {
try {
if (!monitor || !monitor._id) {
throw this.errorService.createBadRequestError("Monitor is required");
}
if (!check || !check._id) {
throw this.errorService.createBadRequestError("Check is required");
}
const activeIncident = await this.db.incidentModule.getActiveIncidentByMonitor(monitor._id);
if (activeIncident) {
await this.db.incidentModule.addCheckToIncident(activeIncident._id, check._id);
this.logger.info({
service: this.SERVICE_NAME,
method: "createIncident",
message: `Check added to existing active incident for monitor ${monitor.name}`,
incidentId: activeIncident._id,
monitorId: monitor._id,
});
return activeIncident;
}
const incidentData = {
monitorId: monitor._id,
teamId: monitor.teamId,
type: monitor.type,
startTime: new Date(),
status: "active",
message: check.message || null,
statusCode: check.statusCode || null,
checks: [check._id],
};
const incident = await this.db.incidentModule.createIncident(incidentData);
this.logger.info({
service: this.SERVICE_NAME,
method: "createIncident",
message: `New incident created for monitor ${monitor.name}`,
incidentId: incident._id,
monitorId: monitor._id,
});
return incident;
} catch (error) {
this.logger.error({
service: this.SERVICE_NAME,
method: "createIncident",
message: error.message,
monitorId: monitor?._id,
error: error.stack,
});
throw error;
}
};
resolveIncident = async (monitor, check) => {
try {
if (!monitor || !monitor._id) {
throw this.errorService.createBadRequestError("Monitor is required");
}
const activeIncident = await this.db.incidentModule.getActiveIncidentByMonitor(monitor._id);
if (!activeIncident) {
this.logger.info({
service: this.SERVICE_NAME,
method: "resolveIncident",
message: `No active incident found for monitor ${monitor.name}`,
monitorId: monitor._id,
});
return null;
}
await this.db.incidentModule.addCheckToIncident(activeIncident._id, check._id);
const resolvedIncident = await this.db.incidentModule.resolveIncident(activeIncident._id, {
resolutionType: "automatic",
resolvedBy: null,
endTime: new Date(),
});
this.logger.info({
service: this.SERVICE_NAME,
method: "resolveIncident",
message: `Incident automatically resolved for monitor ${monitor.name}`,
incidentId: resolvedIncident._id,
monitorId: monitor._id,
});
return resolvedIncident;
} catch (error) {
this.logger.error({
service: this.SERVICE_NAME,
method: "resolveIncident",
message: error.message,
monitorId: monitor?._id,
error: error.stack,
});
throw error;
}
};
resolveIncidentManually = async ({ incidentId, userId, teamId, comment }) => {
try {
if (!incidentId) {
throw this.errorService.createBadRequestError("No incident ID in request");
}
if (!userId) {
throw this.errorService.createBadRequestError("No user ID in request");
}
if (!teamId) {
throw this.errorService.createBadRequestError("No team ID in request");
}
const incident = await this.db.incidentModule.getIncidentById(incidentId);
if (!incident) {
throw this.errorService.createNotFoundError("Incident not found");
}
if (!incident.teamId.equals(teamId)) {
throw this.errorService.createAuthorizationError();
}
if (incident.status === "resolved") {
throw this.errorService.createBadRequestError("Incident is already resolved");
}
const resolvedIncident = await this.db.incidentModule.resolveIncident(incidentId, {
resolutionType: "manual",
resolvedBy: userId,
comment: comment || null,
endTime: new Date(),
});
this.logger.info({
service: this.SERVICE_NAME,
method: "resolveIncidentManually",
message: `Incident manually resolved by user`,
incidentId: resolvedIncident._id,
userId,
});
return resolvedIncident;
} catch (error) {
this.logger.error({
service: this.SERVICE_NAME,
method: "resolveIncidentManually",
message: error.message,
incidentId,
error: error.stack,
});
throw error;
}
};
getIncidentsByTeam = async ({ teamId, query }) => {
try {
if (!teamId) {
throw this.errorService.createBadRequestError("No team ID in request");
}
const { sortOrder, dateRange, filter, page, rowsPerPage, status, monitorId, resolutionType } = query || {};
const result = await this.db.incidentModule.getIncidentsByTeam({
teamId,
sortOrder,
dateRange,
filter,
page,
rowsPerPage,
status,
monitorId,
resolutionType,
});
return result;
} catch (error) {
this.logger.error({
service: this.SERVICE_NAME,
method: "getIncidentsByTeam",
message: error.message,
teamId,
error: error.stack,
});
throw error;
}
};
getIncidentSummary = async ({ teamId, query }) => {
try {
if (!teamId) {
throw this.errorService.createBadRequestError("No team ID in request");
}
const { dateRange } = query || {};
const summary = await this.db.incidentModule.getIncidentSummary({
teamId,
dateRange,
});
return summary;
} catch (error) {
this.logger.error({
service: this.SERVICE_NAME,
method: "getIncidentSummary",
message: error.message,
teamId,
error: error.stack,
});
throw error;
}
};
getIncidentById = async ({ incidentId, teamId }) => {
try {
if (!incidentId) {
throw this.errorService.createBadRequestError("No incident ID in request");
}
if (!teamId) {
throw this.errorService.createBadRequestError("No team ID in request");
}
const incident = await this.db.incidentModule.getIncidentById(incidentId);
if (!incident) {
throw this.errorService.createNotFoundError("Incident not found");
}
if (!incident.teamId.equals(teamId)) {
throw this.errorService.createAuthorizationError();
}
return incident;
} catch (error) {
this.logger.error({
service: this.SERVICE_NAME,
method: "getIncidentById",
message: error.message,
incidentId,
error: error.stack,
});
throw error;
}
};
}
export default IncidentService;
@@ -1,4 +1,5 @@
import MonitorStats from "../../../db/v1/models/MonitorStats.js";
import Check from "../../../db/v1/models/Check.js";
const SERVICE_NAME = "StatusService";
class StatusService {
@@ -7,11 +8,13 @@ class StatusService {
/**
* @param {{
* buffer: import("./bufferService.js").BufferService
* incidentService: import("../business/incidentService.js").IncidentService
* }}
*/ constructor({ db, logger, buffer }) {
*/ constructor({ db, logger, buffer, incidentService }) {
this.db = db;
this.logger = logger;
this.buffer = buffer;
this.incidentService = incidentService;
}
get serviceName() {
@@ -170,6 +173,41 @@ class StatusService {
prevStatus,
newStatus,
});
let savedCheck = check;
if (!check._id) {
try {
const checkModel = new Check(check);
savedCheck = await checkModel.save();
} catch (checkError) {
this.logger.error({
service: this.SERVICE_NAME,
method: "updateStatus",
message: `Failed to save check immediately: ${checkError.message}`,
monitorId: monitor._id,
stack: checkError.stack,
});
}
}
try {
if (newStatus === false) {
await this.incidentService.createIncident(monitor, savedCheck);
} else if (prevStatus === false) {
await this.incidentService.resolveIncident(monitor, savedCheck);
}
} catch (incidentError) {
this.logger.error({
service: this.SERVICE_NAME,
method: "updateStatus",
message: `Failed to handle incident: ${incidentError.message}`,
monitorId: monitor._id,
statusChanged,
prevStatus,
newStatus,
stack: incidentError.stack,
});
}
}
monitor.status = newStatus;