Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import type { ComponentImpact, UpdateComponentImpact } from "../../types";
import type {
BetterstackIncident,
BetterstackMonitor,
BetterstackMonitorGroup,
BetterstackStatusPage,
BetterstackStatusPageResource,
BetterstackStatusPageSection,
BetterstackStatusReport,
BetterstackStatusUpdate,
} from "./api-types";
export type StatusReportStatus =
| "investigating"
| "identified"
| "monitoring"
| "resolved";
const FREQUENCY_MAP: Record<number, string> = {
30: "30s",
60: "1m",
120: "1m",
180: "1m",
300: "5m",
600: "10m",
1800: "30m",
3600: "1h",
};
// Imports write regions unvalidated, so every target must be non-deprecated.
export const REGION_MAP: Record<string, string> = {
us: "iad",
eu: "fra",
as: "sin",
au: "syd",
};
const MONITOR_TYPE_MAP: Record<string, string> = {
status: "http",
keyword: "http",
expected_status_code: "http",
tcp: "tcp",
udp: "udp",
ping: "icmp",
ping_icmp: "icmp",
dns: "dns",
smtp: "http",
pop: "http",
imap: "http",
};
const INCIDENT_STATUS_MAP: Record<string, StatusReportStatus> = {
started: "investigating",
acknowledged: "identified",
resolved: "resolved",
};
export function mapFrequency(seconds: number): string {
if (FREQUENCY_MAP[seconds]) return FREQUENCY_MAP[seconds];
// Snap to nearest supported value
const supported = [30, 60, 300, 600, 1800, 3600];
let closest = supported[0];
for (const s of supported) {
if (Math.abs(s - seconds) < Math.abs(closest - seconds)) {
closest = s;
}
}
return FREQUENCY_MAP[closest] ?? "10m";
}
export function mapRegions(regions: string[]): string {
const mapped = regions
.map((r) => REGION_MAP[r])
.filter((r): r is string => r != null);
return mapped.length > 0 ? mapped.join(",") : "iad";
}
export function mapMonitorType(type: string): string {
return MONITOR_TYPE_MAP[type] ?? "http";
}
export function mapMethod(method: string): string {
return method.toUpperCase();
}
export function mapMonitor(monitor: BetterstackMonitor, workspaceId: number) {
const attrs = monitor.attributes;
const headers =
attrs.request_headers.length > 0
? JSON.stringify(
attrs.request_headers.map((h) => ({
key: h.name,
value: h.value,
})),
)
: "";
return {
workspaceId,
jobType: mapMonitorType(attrs.monitor_type),
periodicity: mapFrequency(attrs.check_frequency),
status: "active" as const,
active: attrs.status !== "paused",
regions: mapRegions(attrs.regions),
url: attrs.url,
name: attrs.pronounceable_name,
description: "",
headers,
body: attrs.request_body,
method: mapMethod(attrs.http_method),
followRedirects: attrs.follow_redirects,
timeout: attrs.request_timeout * 1000,
};
}
export function mapMonitorGroup(
group: BetterstackMonitorGroup,
workspaceId: number,
pageId?: number,
) {
return {
workspaceId,
pageId,
name: group.attributes.name,
};
}
export function mapStatusPage(
page: BetterstackStatusPage,
workspaceId: number,
) {
return {
workspaceId,
title: page.attributes.company_name,
description: "",
slug: page.attributes.subdomain,
customDomain: page.attributes.custom_domain ?? "",
published: true,
icon: "",
};
}
export function mapSection(
section: BetterstackStatusPageSection,
workspaceId: number,
pageId?: number,
) {
return {
workspaceId,
pageId,
name: section.attributes.name,
};
}
export function mapResource(
resource: BetterstackStatusPageResource,
workspaceId: number,
pageId?: number,
resourceIdToMonitorSourceId?: Map<string, string>,
) {
const isMonitor = resource.attributes.resource_type === "Monitor";
const resourceId = resource.attributes.resource_id;
// Resolve sourceMonitorId via the lookup map (resource_id → monitor sourceId)
let sourceMonitorId: string | null = null;
if (isMonitor && resourceId != null) {
sourceMonitorId =
resourceIdToMonitorSourceId?.get(String(resourceId)) ?? null;
}
return {
workspaceId,
pageId,
type: isMonitor ? ("monitor" as const) : ("static" as const),
monitorId: null as number | null,
sourceMonitorId,
name: resource.attributes.public_name,
description: resource.attributes.explanation ?? null,
order: resource.attributes.position,
sourceGroupId: resource.attributes.status_page_section_id
? String(resource.attributes.status_page_section_id)
: null,
};
}
const REPORT_STATUS_MAP: Record<string, StatusReportStatus> = {
operational: "resolved",
resolved: "resolved",
downtime: "investigating",
degraded: "identified",
maintenance: "monitoring",
};
// maintenance counts as available; unknown values are dropped, not guessed
const COMPONENT_IMPACT_MAP: Record<string, ComponentImpact> = {
operational: "operational",
resolved: "operational",
downtime: "major_outage",
degraded: "degraded_performance",
maintenance: "operational",
};
function mapAffectedResourcesToImpacts(
resources: { status_page_resource_id: string; status: string }[],
): UpdateComponentImpact[] {
return resources.flatMap((r) => {
const impact = COMPONENT_IMPACT_MAP[r.status.toLowerCase()];
return impact
? [{ sourceComponentId: r.status_page_resource_id, impact }]
: [];
});
}
export function mapReportAggregateState(
state: string | null,
): StatusReportStatus {
if (!state) return "investigating";
return REPORT_STATUS_MAP[state.toLowerCase()] ?? "investigating";
}
export function mapReportToStatusReport(
report: BetterstackStatusReport,
updates: BetterstackStatusUpdate[],
workspaceId: number,
pageId?: number,
) {
const sortedUpdates = [...updates].sort(
(a, b) =>
new Date(a.attributes.published_at).getTime() -
new Date(b.attributes.published_at).getTime(),
);
const mappedUpdates = sortedUpdates.map((u) => {
const aggregateStatus =
u.attributes.affected_resources.length > 0
? mapReportAggregateState(u.attributes.affected_resources[0].status)
: "investigating";
return {
status: aggregateStatus,
message: u.attributes.message ?? "",
date: new Date(u.attributes.published_at),
componentImpacts: mapAffectedResourcesToImpacts(
u.attributes.affected_resources,
),
};
});
// If no updates, create a synthetic one from the report itself
if (mappedUpdates.length === 0 && report.attributes.starts_at) {
mappedUpdates.push({
status: mapReportAggregateState(report.attributes.aggregate_state),
message: report.attributes.title,
date: new Date(report.attributes.starts_at),
componentImpacts: mapAffectedResourcesToImpacts(
report.attributes.affected_resources,
),
});
}
const lastUpdate = mappedUpdates[mappedUpdates.length - 1];
const reportStatus = lastUpdate?.status ?? "investigating";
const sourceComponentIds = report.attributes.affected_resources.map(
(r) => r.status_page_resource_id,
);
return {
report: {
title: report.attributes.title,
status: reportStatus,
workspaceId,
pageId,
},
updates: mappedUpdates,
sourceComponentIds,
};
}
export function mapReportToMaintenance(
report: BetterstackStatusReport,
updates: BetterstackStatusUpdate[],
workspaceId: number,
pageId?: number,
) {
const from = report.attributes.starts_at
? new Date(report.attributes.starts_at)
: new Date();
const to = report.attributes.ends_at
? new Date(report.attributes.ends_at)
: from;
const sortedUpdates = [...updates].sort(
(a, b) =>
new Date(a.attributes.published_at).getTime() -
new Date(b.attributes.published_at).getTime(),
);
const message = sortedUpdates
.map((u) => u.attributes.message ?? "")
.filter(Boolean)
.join("\n");
const sourceComponentIds = report.attributes.affected_resources.map(
(r) => r.status_page_resource_id,
);
return {
title: report.attributes.title,
message: message || report.attributes.title,
from,
to,
workspaceId,
pageId,
sourceComponentIds,
};
}
export function mapIncidentStatus(status: string): StatusReportStatus {
return INCIDENT_STATUS_MAP[status] ?? "investigating";
}
export function mapIncidentToStatusReport(
incident: BetterstackIncident,
workspaceId: number,
pageId?: number,
) {
const attrs = incident.attributes;
const updates: Array<{
status: StatusReportStatus;
message: string;
date: Date;
}> = [];
// Create synthetic updates from timestamps
updates.push({
status: "investigating",
message: attrs.cause ?? `Incident detected on ${attrs.url ?? "monitor"}`,
date: new Date(attrs.started_at),
});
if (attrs.acknowledged_at) {
updates.push({
status: "identified",
message: "Incident acknowledged",
date: new Date(attrs.acknowledged_at),
});
}
if (attrs.resolved_at) {
updates.push({
status: "resolved",
message: "Incident resolved",
date: new Date(attrs.resolved_at),
});
}
const lastUpdate = updates[updates.length - 1];
const reportStatus = lastUpdate?.status ?? "investigating";
return {
report: {
title: attrs.name ?? `Incident on ${attrs.url ?? "monitor"}`,
status: reportStatus,
workspaceId,
pageId,
},
updates,
sourceComponentIds: [] as string[],
};
}