Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { Events } from "@openstatus/analytics";
import {
headerAssertion,
jsonBodyAssertion,
recordAssertion,
statusAssertion,
textBodyAssertion,
} from "@openstatus/assertions";
import { NotFoundError } from "@openstatus/services";
import {
type CreateMonitorInput,
type UpdateMonitorGeneralInput,
bulkUpdateMonitors,
cloneMonitor,
createMonitor,
deleteMonitor,
deleteMonitors,
getMonitor,
grpcTlsModes,
listMonitors,
monitorJobTypes,
monitorMethods,
monitorPeriodicity,
updateMonitorFollowRedirects,
updateMonitorGeneral,
updateMonitorNotifiers,
updateMonitorOtel,
updateMonitorPublic,
updateMonitorResponseTime,
updateMonitorRetry,
updateMonitorSchedulingRegions,
updateMonitorTags,
} from "@openstatus/services/monitor";
import { headerPairSchema } from "@openstatus/utils";
import { z } from "zod";
import { env } from "../env";
import { toServiceCtx, toTRPCError } from "../service-adapter";
import { createTRPCRouter, protectedProcedure } from "../trpc";
import { testDns, testGrpc, testHttp, testIcmp, testTcp } from "./checker";
// self-host has no access to the openstatus checker fleet, so the pre-save
// endpoint test can never succeed — skip it entirely.
const isSelfHost = env.SELF_HOST;
// tRPC-side input schemas. These preserve the existing wire contract exactly.
const headerPair = headerPairSchema;
const assertionUnion = z.discriminatedUnion("type", [
statusAssertion,
headerAssertion,
textBodyAssertion,
jsonBodyAssertion,
recordAssertion,
]);
const newMonitorTRPCInput = z.object({
name: z.string(),
jobType: z.enum(monitorJobTypes),
url: z.string(),
method: z.enum(monitorMethods),
headers: z.array(headerPair),
body: z.string().optional(),
assertions: z.array(assertionUnion),
active: z.boolean().prefault(false),
saveCheck: z.boolean().prefault(false),
skipCheck: z.boolean().prefault(false),
grpcService: z.string().optional(),
grpcTls: z.enum(grpcTlsModes).optional(),
});
const updateGeneralTRPCInput = z.object({
id: z.number(),
jobType: z.enum(monitorJobTypes),
url: z.string(),
method: z.enum(monitorMethods),
headers: z.array(headerPair),
body: z.string().optional(),
name: z.string(),
assertions: z.array(assertionUnion),
active: z.boolean().prefault(true),
skipCheck: z.boolean().prefault(true),
saveCheck: z.boolean().prefault(false),
grpcService: z.string().optional(),
grpcTls: z.enum(grpcTlsModes).optional(),
});
export const monitorRouter = createTRPCRouter({
delete: protectedProcedure
.meta({ track: Events.DeleteMonitor })
.input(z.object({ id: z.number() }))
.mutation(async ({ ctx, input }) => {
try {
await deleteMonitor({
ctx: toServiceCtx(ctx),
input: { id: input.id },
});
} catch (err) {
// Preserve the pre-migration idempotent behaviour — old code
// silently returned when the row was already gone.
if (err instanceof NotFoundError) return;
toTRPCError(err);
}
}),
deleteMonitors: protectedProcedure
.input(z.object({ ids: z.number().array() }))
.mutation(async ({ ctx, input }) => {
try {
await deleteMonitors({
ctx: toServiceCtx(ctx),
input: { ids: input.ids },
});
} catch (err) {
toTRPCError(err);
}
}),
updateMonitors: protectedProcedure
.input(
z.object({
ids: z.number().array(),
public: z.boolean().optional(),
active: z.boolean().optional(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await bulkUpdateMonitors({
ctx: toServiceCtx(ctx),
input: {
ids: input.ids,
public: input.public,
active: input.active,
},
});
} catch (err) {
toTRPCError(err);
}
}),
list: protectedProcedure
.input(z.object({ order: z.enum(["asc", "desc"]).optional() }).optional())
.query(async ({ ctx, input }) => {
try {
const { items } = await listMonitors({
ctx: toServiceCtx(ctx),
input: {
// tRPC consumers (dashboard) want the full set; no paging UI.
limit: 10_000,
offset: 0,
order: input?.order ?? "desc",
},
});
return items;
} catch (err) {
toTRPCError(err);
}
}),
get: protectedProcedure
.input(z.object({ id: z.coerce.number() }))
.query(async ({ ctx, input }) => {
try {
return await getMonitor({
ctx: toServiceCtx(ctx),
input: { id: input.id },
});
} catch (err) {
toTRPCError(err);
}
}),
clone: protectedProcedure
.meta({ track: Events.CloneMonitor })
.input(z.object({ id: z.number() }))
.mutation(async ({ ctx, input }) => {
try {
return await cloneMonitor({
ctx: toServiceCtx(ctx),
input: { id: input.id },
});
} catch (err) {
toTRPCError(err);
}
}),
updateRetry: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(z.object({ id: z.number(), retry: z.number() }))
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorRetry({
ctx: toServiceCtx(ctx),
input: { id: input.id, retry: input.retry },
});
} catch (err) {
toTRPCError(err);
}
}),
updateFollowRedirects: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(z.object({ id: z.number(), followRedirects: z.boolean() }))
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorFollowRedirects({
ctx: toServiceCtx(ctx),
input: {
id: input.id,
followRedirects: input.followRedirects,
},
});
} catch (err) {
toTRPCError(err);
}
}),
updateOtel: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(
z.object({
id: z.number(),
otelEndpoint: z.string(),
otelHeaders: z.array(headerPair).optional(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorOtel({
ctx: toServiceCtx(ctx),
input: {
id: input.id,
otelEndpoint: input.otelEndpoint,
otelHeaders: input.otelHeaders,
},
});
} catch (err) {
toTRPCError(err);
}
}),
updatePublic: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(z.object({ id: z.number(), public: z.boolean() }))
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorPublic({
ctx: toServiceCtx(ctx),
input: { id: input.id, public: input.public },
});
} catch (err) {
toTRPCError(err);
}
}),
updateSchedulingRegions: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(
z.object({
id: z.number(),
regions: z.array(z.string()),
periodicity: z.enum(monitorPeriodicity),
privateLocations: z.array(z.number()),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorSchedulingRegions({
ctx: toServiceCtx(ctx),
input: {
id: input.id,
regions: input.regions,
periodicity: input.periodicity,
privateLocations: input.privateLocations,
},
});
} catch (err) {
toTRPCError(err);
}
}),
updateResponseTime: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(
z.object({
id: z.number(),
timeout: z.number(),
degradedAfter: z.number().nullish(),
}),
)
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorResponseTime({
ctx: toServiceCtx(ctx),
input: {
id: input.id,
timeout: input.timeout,
degradedAfter: input.degradedAfter,
},
});
} catch (err) {
toTRPCError(err);
}
}),
updateTags: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(z.object({ id: z.number(), tags: z.array(z.number()) }))
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorTags({
ctx: toServiceCtx(ctx),
input: { id: input.id, tags: input.tags },
});
} catch (err) {
toTRPCError(err);
}
}),
updateGeneral: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(updateGeneralTRPCInput)
.mutation(async ({ ctx, input }) => {
try {
// Pre-save endpoint check — kept at the tRPC layer because the
// `testHttp` / `testTcp` / `testDns` helpers hit external URLs and
// are tRPC-specific UX; services unconditionally save.
if (!isSelfHost && !input.skipCheck && input.active) {
if (input.jobType === "http") {
await testHttp({
url: input.url,
method: input.method,
headers: input.headers,
body: input.body,
assertions: input.assertions.filter(
(a) => a.type !== "dnsRecord",
),
region: "ams",
});
} else if (input.jobType === "tcp") {
await testTcp({ url: input.url, region: "ams" });
} else if (input.jobType === "dns") {
await testDns({
url: input.url,
region: "ams",
assertions: input.assertions.filter(
(a) => a.type === "dnsRecord",
),
});
} else if (input.jobType === "icmp") {
await testIcmp({ url: input.url, region: "ams" });
} else if (input.jobType === "grpc") {
await testGrpc({
url: input.url,
service: input.grpcService,
tls: input.grpcTls ?? "tls",
headers: input.headers,
region: "ams",
});
}
}
const serviceInput: UpdateMonitorGeneralInput = {
id: input.id,
name: input.name,
jobType: input.jobType,
url: input.url,
method: input.method,
headers: input.headers,
body: input.body,
assertions: input.assertions,
active: input.active,
grpcService: input.grpcService,
grpcTls: input.grpcTls,
};
await updateMonitorGeneral({
ctx: toServiceCtx(ctx),
input: serviceInput,
});
} catch (err) {
toTRPCError(err);
}
}),
updateNotifiers: protectedProcedure
.meta({ track: Events.UpdateMonitor })
.input(z.object({ id: z.number(), notifiers: z.array(z.number()) }))
.mutation(async ({ ctx, input }) => {
try {
await updateMonitorNotifiers({
ctx: toServiceCtx(ctx),
input: { id: input.id, notifiers: input.notifiers },
});
} catch (err) {
toTRPCError(err);
}
}),
new: protectedProcedure
.meta({ track: Events.CreateMonitor, trackProps: ["url", "jobType"] })
.input(newMonitorTRPCInput)
.mutation(async ({ ctx, input }) => {
try {
if (!isSelfHost && !input.skipCheck) {
if (input.jobType === "http") {
await testHttp({
url: input.url,
method: input.method,
headers: input.headers,
body: input.body,
assertions: input.assertions.filter(
(a) => a.type !== "dnsRecord",
),
region: "ams",
});
} else if (input.jobType === "tcp") {
await testTcp({ url: input.url, region: "ams" });
} else if (input.jobType === "dns") {
await testDns({
url: input.url,
region: "ams",
assertions: input.assertions.filter(
(a) => a.type === "dnsRecord",
),
});
} else if (input.jobType === "icmp") {
await testIcmp({ url: input.url, region: "ams" });
} else if (input.jobType === "grpc") {
await testGrpc({
url: input.url,
service: input.grpcService,
tls: input.grpcTls ?? "tls",
headers: input.headers,
region: "ams",
});
}
}
const serviceInput: CreateMonitorInput = {
name: input.name,
jobType: input.jobType,
url: input.url,
method: input.method,
headers: input.headers,
body: input.body,
assertions: input.assertions,
active: input.active,
grpcService: input.grpcService,
grpcTls: input.grpcTls,
};
return await createMonitor({
ctx: toServiceCtx(ctx),
input: serviceInput,
});
} catch (err) {
toTRPCError(err);
}
}),
});