Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { and, eq } from "@openstatus/db";
import {
type Incident,
type IncidentEvent,
type IncidentEventSource,
type IncidentEventType,
type IncidentStatus,
incident,
incidentEvent,
user,
} from "@openstatus/db/src/schema";
import { displayName } from "../attribution";
import { emitAudit } from "../audit";
import {
type Actor,
type DB,
type ServiceContext,
tryGetActorUserId,
} from "../context";
import { ConflictError, NotFoundError, ValidationError } from "../errors";
import { getMembership } from "../member/membership";
export const incidentUserColumns = {
id: true,
name: true,
firstName: true,
lastName: true,
email: true,
photoUrl: true,
deletedAt: true,
} as const;
export async function getIncidentInWorkspace(
tx: DB,
workspaceId: number,
id: number,
): Promise<Incident> {
const row = await tx
.select()
.from(incident)
.where(and(eq(incident.id, id), eq(incident.workspaceId, workspaceId)))
.get();
if (!row) throw new NotFoundError("incident", id);
return row;
}
export function assertNotClosed(row: Incident): void {
if (row.closedAt) {
throw new ConflictError(`Incident #${row.id} is closed`);
}
}
const TRANSITIONS: Record<IncidentStatus, ReadonlyArray<IncidentStatus>> = {
open: ["mitigated", "resolved", "canceled"],
mitigated: ["resolved", "open", "canceled"],
resolved: ["open"],
canceled: [],
};
export function allowedTransitions(
row: Pick<Incident, "status" | "closedAt">,
): ReadonlyArray<IncidentStatus> {
if (row.closedAt) return [];
return TRANSITIONS[row.status];
}
export function assertTransition(
row: Pick<Incident, "id" | "status" | "closedAt">,
to: IncidentStatus,
): void {
if (row.status === to) {
throw new ConflictError(`Incident #${row.id} is already ${to}`);
}
if (!allowedTransitions(row).includes(to)) {
throw new ConflictError(
`Incident #${row.id} cannot go from ${row.status} to ${to}`,
);
}
}
function actorSource(actor: Actor): IncidentEventSource {
switch (actor.type) {
case "user":
return "dashboard";
case "apiKey":
return "api";
case "mcp":
return "mcp";
case "slack":
return "slack";
case "system":
case "webhook":
case "subscriber":
return "system";
}
}
function actorSourceRef(actor: Actor): string | null {
switch (actor.type) {
case "apiKey":
case "mcp":
return actor.keyId;
case "slack":
return actor.permalink ?? null;
default:
return null;
}
}
/** The only way an event is written: the row and its audit entry together. */
export async function appendIncidentEvent(
tx: DB,
ctx: ServiceContext,
args: {
incidentId: number;
type: IncidentEventType;
message?: string | null;
createdAt?: Date;
createdBy?: number | null;
source?: IncidentEventSource;
sourceRef?: string | null;
},
): Promise<IncidentEvent> {
const event = await tx
.insert(incidentEvent)
.values({
incidentId: args.incidentId,
type: args.type,
message: args.message ?? null,
source: args.source ?? actorSource(ctx.actor),
sourceRef:
args.sourceRef !== undefined
? args.sourceRef
: actorSourceRef(ctx.actor),
createdBy: args.createdBy ?? tryGetActorUserId(ctx.actor),
createdAt: args.createdAt ?? new Date(),
})
.returning()
.get();
await emitAudit(tx, ctx, {
action: "incident_event.create",
entityType: "incident_event",
entityId: event.id,
after: event,
metadata: { incidentId: args.incidentId, type: args.type },
});
return event;
}
export async function assertMember(
tx: DB,
workspaceId: number,
userId: number,
): Promise<void> {
const membership = await getMembership(tx, userId, workspaceId);
if (!membership) {
throw new ValidationError(
`User ${userId} is not a member of this workspace`,
);
}
}
export async function userDisplayName(
tx: DB,
userId: number | null,
): Promise<string | null> {
if (userId === null) return null;
const row = await tx
.select({
name: user.name,
firstName: user.firstName,
lastName: user.lastName,
email: user.email,
})
.from(user)
.where(eq(user.id, userId))
.get();
if (!row) return null;
return displayName(row);
}