Skip to content

Open-source status page, incident response and uptime monitoring

feat(status-timeline): compute bar days in a time zone (#2944)

Takaaki Abe1417edf0a5e5
diff --git a/packages/api/src/router/statusPage.utils.timezone.test.ts b/packages/api/src/router/statusPage.utils.timezone.test.ts
new file mode 100644
index 000000000..59c5a9e6a
--- /dev/null
+++ b/packages/api/src/router/statusPage.utils.timezone.test.ts
@@ -0,0 +1,96 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ type Event,
+ getUptime,
+ setDataByType,
+ type StatusData,
+} from "./statusPage.utils";
+
+function bucket(date: string, ok = 100): StatusData {
+ return {
+ day: `${date}T00:00:00.000Z`,
+ count: ok,
+ ok,
+ degraded: 0,
+ error: 0,
+ monitorId: "1",
+ };
+}
+
+function incident(from: string, to: string): Event {
+ return {
+ id: 1,
+ name: "incident",
+ from: new Date(from),
+ to: new Date(to),
+ type: "incident",
+ status: "error",
+ };
+}
+
+describe("setDataByType in a time zone", () => {
+ // 01:00-01:30 in Tokyo on 2026-10-16, still 2026-10-15 in UTC
+ const early = incident(
+ "2026-10-15T16:00:00.000Z",
+ "2026-10-15T16:30:00.000Z",
+ );
+
+ it("colors the bar of the zone's date", () => {
+ const [tokyo] = setDataByType({
+ events: [early],
+ data: [bucket("2026-10-16")],
+ cardType: "requests",
+ barType: "dominant",
+ timeZone: "Asia/Tokyo",
+ });
+ expect(tokyo.bar[0].status).toBe("error");
+
+ const [utc] = setDataByType({
+ events: [early],
+ data: [bucket("2026-10-16")],
+ cardType: "requests",
+ barType: "dominant",
+ });
+ expect(utc.bar[0].status).toBe("success");
+ });
+
+ it("measures downtime against the 25 hours of the day summer time ends", () => {
+ // 23:30-23:45 in Berlin on 2026-10-25, the day summer time ends
+ const late = incident(
+ "2026-10-25T22:30:00.000Z",
+ "2026-10-25T22:45:00.000Z",
+ );
+ const [day] = setDataByType({
+ events: [late],
+ data: [bucket("2026-10-25")],
+ cardType: "requests",
+ barType: "absolute",
+ timeZone: "Europe/Berlin",
+ });
+ const error = day.bar.find((segment) => segment.status === "error");
+ expect(error?.height).toBeCloseTo((15 / (25 * 60)) * 100);
+ });
+});
+
+describe("getUptime in a time zone", () => {
+ // 00:00-02:24 in Tokyo on 2026-10-14: 10% of that day, still 2026-10-13 in UTC
+ const morning = incident(
+ "2026-10-13T15:00:00.000Z",
+ "2026-10-13T17:24:00.000Z",
+ );
+
+ it("counts downtime inside the zone's days", () => {
+ const uptime = (timeZone?: string) =>
+ getUptime({
+ data: [bucket("2026-10-14")],
+ events: [morning],
+ barType: "absolute",
+ cardType: "duration",
+ timeZone,
+ });
+ expect(uptime("Asia/Tokyo")).toBe("90%");
+ expect(uptime()).toBe("100%");
+ });
+});
diff --git a/packages/api/src/router/statusPage.utils.ts b/packages/api/src/router/statusPage.utils.ts
index b43b144b7..dc709bb10 100644
--- a/packages/api/src/router/statusPage.utils.ts
+++ b/packages/api/src/router/statusPage.utils.ts
@@ -8,14 +8,15 @@ import {
import {
clipToCoverage,
type CoverageSegment,
+ type DayWindow,
downtimeIntervals,
type Event,
- MS_PER_DAY,
probeDowntimeIntervals,
type StatusData,
type UptimeWindow,
type WeightedInterval,
dayCoverage,
+ dayWindow,
durationDowntimeMs,
floorPct,
getHighestPriorityStatus,
@@ -91,14 +92,9 @@ function formatNumber(num: number): string {
return num.toString();
}
-// Helper to check if date is today
-function isToday(date: Date): boolean {
- const today = new Date();
- return (
- date.getUTCDate() === today.getUTCDate() &&
- date.getUTCMonth() === today.getUTCMonth() &&
- date.getUTCFullYear() === today.getUTCFullYear()
- );
+function isToday({ start, end }: DayWindow): boolean {
+ const now = Date.now();
+ return start <= now && now < end;
}
// Helper to format duration from minutes
@@ -111,52 +107,44 @@ function formatDuration(minutes: number): string {
}
// Helper to calculate total minutes in a day (handles today vs past days)
-function getTotalMinutesInDay(date: Date): number {
- const now = new Date();
- const startOfDay = new Date(date);
- startOfDay.setUTCHours(0, 0, 0, 0);
-
- if (isToday(date)) {
- const minutesElapsed = Math.floor(
- (now.getTime() - startOfDay.getTime()) / MILLISECONDS_PER_MINUTE,
- );
- return minutesElapsed;
- }
- return 24 * 60;
+function getTotalMinutesInDay(day: DayWindow): number {
+ const until = isToday(day) ? Date.now() : day.end;
+ return Math.floor((until - day.start) / MILLISECONDS_PER_MINUTE);
}
// Helper to calculate duration in minutes for a specific event type
-function calculateEventDurationMinutes(events: Event[], date: Date): number {
- const totalDuration = getTotalEventsDurationMs(events, date);
+function calculateEventDurationMinutes(
+ events: Event[],
+ day: DayWindow,
+): number {
+ const totalDuration = getTotalEventsDurationMs(events, day);
return Math.round(totalDuration / MILLISECONDS_PER_MINUTE);
}
// Helper to calculate maintenance duration in minutes for a specific day
function getMaintenanceDurationMinutes(
maintenances: Event[],
- date: Date,
+ day: DayWindow,
): number {
- return calculateEventDurationMinutes(maintenances, date);
+ return calculateEventDurationMinutes(maintenances, day);
}
// Helper to get adjusted total minutes accounting for maintenance
function getAdjustedTotalMinutesInDay(
- date: Date,
+ day: DayWindow,
maintenances: Event[],
): number {
- const totalMinutes = getTotalMinutesInDay(date);
- const maintenanceMinutes = getMaintenanceDurationMinutes(maintenances, date);
+ const totalMinutes = getTotalMinutesInDay(day);
+ const maintenanceMinutes = getMaintenanceDurationMinutes(maintenances, day);
return Math.max(0, totalMinutes - maintenanceMinutes);
}
-function getTotalEventsDurationMs(events: Event[], date: Date): number {
+function getTotalEventsDurationMs(events: Event[], day: DayWindow): number {
if (events.length === 0) return 0;
- const startOfDay = new Date(date);
- startOfDay.setUTCHours(0, 0, 0, 0);
-
- const endOfDay = new Date(date);
- endOfDay.setUTCHours(23, 59, 59, 999);
+ const { start: startOfDay, end } = day;
+ // the overlap math below treats `endOfDay` as an inclusive bound
+ const endOfDay = end - 1;
const total = events.reduce((acc, curr) => {
if (!curr.from) return acc;
@@ -165,23 +153,19 @@ function getTotalEventsDurationMs(events: Event[], date: Date): number {
const eventEnd = curr.to ? new Date(curr.to) : new Date();
// Only count events that overlap with this date
- if (
- eventEnd.getTime() < startOfDay.getTime() ||
- eventStart.getTime() > endOfDay.getTime()
- ) {
+ if (eventEnd.getTime() < startOfDay || eventStart.getTime() > endOfDay) {
return acc;
}
// Calculate the overlapping duration within the date boundaries
- const overlapStart = Math.max(eventStart.getTime(), startOfDay.getTime());
- const overlapEnd = Math.min(eventEnd.getTime(), endOfDay.getTime());
+ const overlapStart = Math.max(eventStart.getTime(), startOfDay);
+ const overlapEnd = Math.min(eventEnd.getTime(), endOfDay);
const duration = overlapEnd - overlapStart;
return acc + Math.max(0, duration);
}, 0);
- // Cap at 24 hours per day
- return Math.min(total, MS_PER_DAY);
+ return Math.min(total, end - startOfDay);
}
export function setDataByType({
@@ -189,18 +173,21 @@ export function setDataByType({
data,
cardType,
barType,
+ timeZone = "UTC",
}: {
events: Event[];
data: StatusData[];
cardType: "requests" | "duration" | "dominant" | "manual";
barType: "absolute" | "dominant" | "manual";
+ /** IANA zone whose calendar days the bars stand for */
+ timeZone?: string;
}): UptimeData[] {
// Helper functions moved inside to share inputs and avoid parameter passing
function createEventSegments(
incidents: Event[],
reports: Event[],
maintenances: Event[],
- date: Date,
+ day: DayWindow,
): Array<{ status: "info" | "degraded" | "error"; count: number }> {
// impact reports contribute per-interval slices to each color bucket, so a
// 1h major_outage inside a 24h report only paints 1h red; legacy reports
@@ -216,7 +203,7 @@ export function setDataByType({
const color = impactToStatusType(iv.impact);
if (color === "success") continue;
const slice = { ...report, from: iv.from, to: iv.to };
- if (!isDateWithinEvent(date, slice)) continue;
+ if (!isDateWithinEvent(day, slice)) continue;
(color === "error" ? errorSlices : degradedSlices).push(slice);
}
}
@@ -234,34 +221,36 @@ export function setDataByType({
.filter(({ events }) => events.length > 0)
.map(({ status, events }) => ({
status,
- count: getTotalEventsDurationMs(events, date),
+ count: getTotalEventsDurationMs(events, day),
}));
}
function createErrorOnlyBarData(
errorSegmentCount: number,
+ dayMs: number,
): UptimeData["bar"] {
return [
{
status: "success" as const,
- height: ((MS_PER_DAY - errorSegmentCount) / MS_PER_DAY) * 100,
+ height: ((dayMs - errorSegmentCount) / dayMs) * 100,
},
{
status: "error" as const,
- height: (errorSegmentCount / MS_PER_DAY) * 100,
+ height: (errorSegmentCount / dayMs) * 100,
},
];
}
function createProportionalBarData(
segments: Array<{ status: "info" | "degraded" | "error"; count: number }>,
+ dayMs: number,
): UptimeData["bar"] {
// Downtime keeps its true proportion of the day; maintenance/reports are
// highlight events that fill the remaining space (no uptime shown).
const errorMs = segments
.filter((segment) => segment.status === "error")
.reduce((sum, segment) => sum + segment.count, 0);
- const errorHeight = (Math.min(errorMs, MS_PER_DAY) / MS_PER_DAY) * 100;
+ const errorHeight = (Math.min(errorMs, dayMs) / dayMs) * 100;
const remainingHeight = Math.max(0, 100 - errorHeight);
const highlightSegments = segments.filter(
@@ -375,8 +364,11 @@ export function setDataByType({
}
// Helper to calculate duration in minutes for a specific event type
- function calculateEventDurationMinutes(events: Event[], date: Date): number {
- const totalDuration = getTotalEventsDurationMs(events, date);
+ function calculateEventDurationMinutes(
+ events: Event[],
+ day: DayWindow,
+ ): number {
+ const totalDuration = getTotalEventsDurationMs(events, day);
return Math.round(totalDuration / MILLISECONDS_PER_MINUTE);
}
@@ -384,7 +376,7 @@ export function setDataByType({
function createDurationCardEntry(
status: "error" | "degraded" | "info" | "success",
events: Event[],
- date: Date,
+ day: DayWindow,
durationMap: Map<string, number>,
maintenances: Event[] = [],
): {
@@ -397,10 +389,7 @@ export function setDataByType({
durationMap.forEach((minutes) => (totalEventMinutes += minutes));
// Use adjusted total minutes accounting for maintenance
- const totalMinutesInDay = getAdjustedTotalMinutesInDay(
- date,
- maintenances,
- );
+ const totalMinutesInDay = getAdjustedTotalMinutesInDay(day, maintenances);
const successMinutes = Math.max(totalMinutesInDay - totalEventMinutes, 0);
if (successMinutes === 0) return null;
@@ -411,7 +400,7 @@ export function setDataByType({
}
// For error, degraded, info - calculate from events
- const minutes = calculateEventDurationMinutes(events, date);
+ const minutes = calculateEventDurationMinutes(events, day);
durationMap.set(status, minutes);
if (minutes === 0) return null;
@@ -422,10 +411,11 @@ export function setDataByType({
}
return data.map((dayData) => {
- const date = new Date(dayData.day);
+ const day = dayWindow(dayData.day, timeZone);
+ const dayMs = day.end - day.start;
// Find events for this day
- const dayEvents = events.filter((event) => isDateWithinEvent(date, event));
+ const dayEvents = events.filter((event) => isDateWithinEvent(day, event));
// Determine status override based on events
const incidents = dayEvents.filter((e) => e.type === "incident");
@@ -438,7 +428,7 @@ export function setDataByType({
// worst impact color across the day's reports; "success" (operational all
// day) means reports don't color the day
const reportsDayStatus = reports.length
- ? getWorstVariant(reports.map((e) => reportEventDayStatus(e, date)))
+ ? getWorstVariant(reports.map((e) => reportEventDayStatus(e, day)))
: undefined;
const activeReportsDayStatus =
reportsDayStatus === "success" ? undefined : reportsDayStatus;
@@ -463,7 +453,7 @@ export function setDataByType({
incidents,
reports,
maintenances,
- date,
+ day,
);
// Special case: if only errors exist, show uptime vs downtime
@@ -471,10 +461,10 @@ export function setDataByType({
eventSegments.length === 1 &&
eventSegments[0].status === "error"
) {
- barData = createErrorOnlyBarData(eventSegments[0].count);
+ barData = createErrorOnlyBarData(eventSegments[0].count, dayMs);
} else {
// Multiple segments: show proportional distribution
- barData = createProportionalBarData(eventSegments);
+ barData = createProportionalBarData(eventSegments, dayMs);
}
} else if (total === 0) {
// Empty day - no data available
@@ -560,7 +550,7 @@ export function setDataByType({
entry.count > 0
) {
const totalMinutes = getAdjustedTotalMinutesInDay(
- date,
+ day,
maintenances,
);
const statusMinutes = Math.round(
@@ -577,7 +567,7 @@ export function setDataByType({
return createDurationCardEntry(
entry.status,
events,
- date,
+ day,
durationMap,
maintenances,
);
@@ -599,7 +589,7 @@ export function setDataByType({
const manualCardStatus =
activeReportsDayStatus ?? (hasMaintenances ? "info" : undefined);
const dayImpacts = reports
- .map((e) => reportEventDayImpact(e, date))
+ .map((e) => reportEventDayImpact(e, day))
.filter((i): i is PageComponentImpact => i !== null);
const worstDayImpact =
dayImpacts.length > 0 ? worstImpact(dayImpacts) : null;
@@ -659,7 +649,7 @@ export function setDataByType({
...reports.map((e) => ({
...e,
status:
- reportEventDayStatus(e, date) === "error"
+ reportEventDayStatus(e, day) === "error"
? ("error" as const)
: ("degraded" as const),
})),
@@ -678,6 +668,7 @@ export function getUptime({
barType,
cardType,
privateLocationOnly = false,
+ timeZone = "UTC",
}: {
data: StatusData[];
events: Event[];
@@ -685,18 +676,18 @@ export function getUptime({
cardType: "requests" | "duration" | "dominant" | "manual";
/** no public regions and ≥1 private location: include probe errors in duration uptime */
privateLocationOnly?: boolean;
+ /** IANA zone whose calendar days `data` is keyed by */
+ timeZone?: string;
}): string {
if (barType === "manual" || cardType === "duration") {
// Clamp event durations to the data lookback window to avoid
// events outside the window producing negative uptime values.
- const timestamps = data.map((d) => new Date(d.day).getTime());
- const { segments: coverage, totalMs: total } = dayCoverage(timestamps);
+ const days = data.map((d) => dayWindow(d.day, timeZone));
+ const { segments: coverage, totalMs: total } = dayCoverage(days);
if (total === 0) return "100%";
- const windowEndDate = new Date(Math.max(...timestamps));
- windowEndDate.setUTCHours(23, 59, 59, 999);
const window: UptimeWindow = {
- start: Math.min(...timestamps),
- end: windowEndDate.getTime(),
+ start: Math.min(...days.map((d) => d.start)),
+ end: Math.max(...days.map((d) => d.end)) - 1,
now: Date.now(),
};
@@ -711,7 +702,7 @@ export function getUptime({
// of the incident covering the same outage and nearly double it (#2481).
const eventIntervals = downtimeIntervals(events, window, false);
const probeIntervals = privateLocationOnly
- ? probeDowntimeIntervals(data, window)
+ ? probeDowntimeIntervals(data, window, timeZone)
: [];
const allIntervals = [...eventIntervals, ...probeIntervals];
duration = mergedDowntimeMs(
diff --git a/packages/services/package.json b/packages/services/package.json
index 85583de2c..90a2141a3 100644
--- a/packages/services/package.json
+++ b/packages/services/package.json
@@ -160,6 +160,7 @@
"tsc": "tsc --noEmit"
},
"dependencies": {
+ "@date-fns/tz": "catalog:",
"@openstatus/assertions": "workspace:*",
"@openstatus/db": "workspace:*",
"@openstatus/importers": "workspace:*",
diff --git a/packages/services/src/frozen-uptime/get-history.ts b/packages/services/src/frozen-uptime/get-history.ts
index 7584a0c17..24be46e6e 100644
--- a/packages/services/src/frozen-uptime/get-history.ts
+++ b/packages/services/src/frozen-uptime/get-history.ts
@@ -8,6 +8,7 @@ import { defaultTb, getReadDb, type ServiceContext } from "../context";
import { ForbiddenError, NotFoundError } from "../errors";
import {
dayCoverage,
+ dayWindow,
durationDowntimeMs,
type Event,
floorPct,
@@ -104,8 +105,8 @@ function durationMonth(
// downtime is clipped to the checked days (a paused stretch can't exceed
// the denominator) and the in-progress day is clamped to elapsed time so
// 2h down on the 2nd isn't diluted by the rest of today
- const dayStarts = withChecks.map((d) => Date.parse(`${d.day}T00:00:00.000Z`));
- const { segments, totalMs } = dayCoverage(dayStarts, nowMs);
+ const windows = withChecks.map((d) => dayWindow(d.day));
+ const { segments, totalMs } = dayCoverage(windows, nowMs);
if (segments.length === 0 || totalMs <= 0) return null;
const window = {
start: segments[0].start,
diff --git a/packages/services/src/status-timeline/__tests__/day-window.test.ts b/packages/services/src/status-timeline/__tests__/day-window.test.ts
new file mode 100644
index 000000000..53cc213f8
--- /dev/null
+++ b/packages/services/src/status-timeline/__tests__/day-window.test.ts
@@ -0,0 +1,46 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import { dayWindow } from "../day-window";
+
+const ms = (iso: string) => new Date(iso).getTime();
+
+describe("dayWindow", () => {
+ test("runs from local midnight to the next local midnight", () => {
+ expect(dayWindow("2026-10-16")).toEqual({
+ start: ms("2026-10-16T00:00:00.000Z"),
+ end: ms("2026-10-17T00:00:00.000Z"),
+ });
+ expect(dayWindow("2026-10-16T00:00:00.000Z", "Asia/Tokyo")).toEqual({
+ start: ms("2026-10-15T15:00:00.000Z"),
+ end: ms("2026-10-16T15:00:00.000Z"),
+ });
+ });
+
+ test("handles offsets that are not whole hours", () => {
+ expect(dayWindow("2026-10-16", "Asia/Kolkata").start).toBe(
+ ms("2026-10-15T18:30:00.000Z"),
+ );
+ expect(dayWindow("2026-10-16", "America/St_Johns").start).toBe(
+ ms("2026-10-16T02:30:00.000Z"),
+ );
+ });
+
+ test("follows the offset change on the days summer time starts and ends", () => {
+ // Berlin leaves summer time on 2026-10-25 and enters it on 2026-03-29
+ const fallBack = dayWindow("2026-10-25", "Europe/Berlin");
+ expect(fallBack).toEqual({
+ start: ms("2026-10-24T22:00:00.000Z"),
+ end: ms("2026-10-25T23:00:00.000Z"),
+ });
+ const springForward = dayWindow("2026-03-29", "Europe/Berlin");
+ expect(springForward.end - springForward.start).toBe(23 * 3_600_000);
+ });
+
+ test("starts at the first wall-clock time when midnight is skipped", () => {
+ // Santiago jumps from 00:00 to 01:00 on 2026-09-06
+ expect(dayWindow("2026-09-06", "America/Santiago").start).toBe(
+ ms("2026-09-06T04:00:00.000Z"),
+ );
+ });
+});
diff --git a/packages/services/src/status-timeline/__tests__/events.test.ts b/packages/services/src/status-timeline/__tests__/events.test.ts
index c7814f115..b91797aa5 100644
--- a/packages/services/src/status-timeline/__tests__/events.test.ts
+++ b/packages/services/src/status-timeline/__tests__/events.test.ts
@@ -1,5 +1,6 @@
import { describe, expect, test, vi } from "vitest";
+import { dayWindow } from "../day-window";
import {
activeReportStatus,
type Event,
@@ -226,20 +227,20 @@ describe("isDateWithinEvent", () => {
const event = makeEvent({ from: day("2026-01-10"), to: day("2026-01-12") });
test("a day inside the window matches, including both boundaries", () => {
- expect(isDateWithinEvent(day("2026-01-11"), event)).toBe(true);
- expect(isDateWithinEvent(day("2026-01-10"), event)).toBe(true);
- expect(isDateWithinEvent(day("2026-01-12"), event)).toBe(true);
+ expect(isDateWithinEvent(dayWindow("2026-01-11"), event)).toBe(true);
+ expect(isDateWithinEvent(dayWindow("2026-01-10"), event)).toBe(true);
+ expect(isDateWithinEvent(dayWindow("2026-01-12"), event)).toBe(true);
});
test("days outside the window do not match", () => {
- expect(isDateWithinEvent(day("2026-01-09"), event)).toBe(false);
- expect(isDateWithinEvent(day("2026-01-13"), event)).toBe(false);
+ expect(isDateWithinEvent(dayWindow("2026-01-09"), event)).toBe(false);
+ expect(isDateWithinEvent(dayWindow("2026-01-13"), event)).toBe(false);
});
test("an open-ended event runs up to now", () => {
const open = makeEvent({ from: day("2020-01-01"), to: null });
- expect(isDateWithinEvent(day("2021-01-01"), open)).toBe(true);
- expect(isDateWithinEvent(day("2019-01-01"), open)).toBe(false);
+ expect(isDateWithinEvent(dayWindow("2021-01-01"), open)).toBe(true);
+ expect(isDateWithinEvent(dayWindow("2019-01-01"), open)).toBe(false);
});
});
@@ -335,14 +336,16 @@ describe("reportEventDayImpact", () => {
},
],
});
- expect(reportEventDayImpact(event, day("2026-01-11"))).toBe("major_outage");
+ expect(reportEventDayImpact(event, dayWindow("2026-01-11"))).toBe(
+ "major_outage",
+ );
});
test("null when the event has no impact rows (legacy)", () => {
expect(
reportEventDayImpact(
makeEvent({ impactIntervals: undefined }),
- day("2026-01-11"),
+ dayWindow("2026-01-11"),
),
).toBeNull();
});
@@ -357,7 +360,9 @@ describe("reportEventDayImpact", () => {
},
],
});
- expect(reportEventDayImpact(event, day("2026-01-20"))).toBe("operational");
+ expect(reportEventDayImpact(event, dayWindow("2026-01-20"))).toBe(
+ "operational",
+ );
});
});
@@ -366,7 +371,7 @@ describe("reportEventDayStatus", () => {
expect(
reportEventDayStatus(
makeEvent({ impactIntervals: undefined }),
- day("2026-01-11"),
+ dayWindow("2026-01-11"),
),
).toBe("degraded");
});
@@ -381,7 +386,7 @@ describe("reportEventDayStatus", () => {
},
],
});
- expect(reportEventDayStatus(major, day("2026-01-11"))).toBe("error");
+ expect(reportEventDayStatus(major, dayWindow("2026-01-11"))).toBe("error");
const noOverlap = makeEvent({
impactIntervals: [
@@ -392,7 +397,9 @@ describe("reportEventDayStatus", () => {
},
],
});
- expect(reportEventDayStatus(noOverlap, day("2026-01-20"))).toBe("success");
+ expect(reportEventDayStatus(noOverlap, dayWindow("2026-01-20"))).toBe(
+ "success",
+ );
});
});
diff --git a/packages/services/src/status-timeline/__tests__/time-zone.test.ts b/packages/services/src/status-timeline/__tests__/time-zone.test.ts
new file mode 100644
index 000000000..cf2876db8
--- /dev/null
+++ b/packages/services/src/status-timeline/__tests__/time-zone.test.ts
@@ -0,0 +1,157 @@
+import { expect } from "@std/expect";
+import { afterEach, beforeEach, describe, test } from "@std/testing/bdd";
+import { FakeTime } from "@std/testing/time";
+
+import { dayWindow } from "../day-window";
+import {
+ type Event,
+ fillStatusDataFor45Days,
+ fillStatusDataFor45DaysNoop,
+ isDateWithinEvent,
+ reportEventDayImpact,
+ resolveDayStatus,
+ type StatusData,
+} from "../events";
+import { probeDowntimeIntervals } from "../uptime";
+
+const at = (iso: string) => new Date(iso);
+const ms = (iso: string) => at(iso).getTime();
+
+function incident(from: string, to: string): Event {
+ return {
+ id: 1,
+ name: "incident",
+ from: at(from),
+ to: at(to),
+ type: "incident",
+ status: "error",
+ };
+}
+
+function bucket(date: string, overrides: Partial<StatusData> = {}): StatusData {
+ return {
+ day: `${date}T00:00:00.000Z`,
+ count: 1,
+ ok: 1,
+ degraded: 0,
+ error: 0,
+ monitorId: "1",
+ ...overrides,
+ };
+}
+
+describe("fillStatusDataFor45Days in a time zone", () => {
+ let time: FakeTime;
+ // 2026-10-16 05:00 in Tokyo, still 2026-10-15 in UTC
+ beforeEach(() => {
+ time = new FakeTime(at("2026-10-15T20:00:00.000Z"));
+ });
+ afterEach(() => time.restore());
+
+ test("ends on today's date in the zone", () => {
+ expect(fillStatusDataFor45Days([], "1", 45, "Asia/Tokyo").at(-1)?.day).toBe(
+ "2026-10-16T00:00:00.000Z",
+ );
+ expect(fillStatusDataFor45Days([], "1", 45).at(-1)?.day).toBe(
+ "2026-10-15T00:00:00.000Z",
+ );
+ });
+
+ // the 15m endpoints return 45 days back from local midnight, so every
+ // past day listed is complete
+ test("starts 44 days before today's date in the zone", () => {
+ const filled = fillStatusDataFor45Days([], "1", 45, "Asia/Tokyo");
+ expect(filled).toHaveLength(45);
+ expect(filled[0].day).toBe("2026-09-02T00:00:00.000Z");
+ });
+
+ test("keeps the rows of the zone's dates", () => {
+ const filled = fillStatusDataFor45Days(
+ [bucket("2026-10-16", { error: 3 })],
+ "1",
+ 45,
+ "Asia/Tokyo",
+ );
+ expect(filled.at(-1)?.error).toBe(3);
+ });
+
+ test("lines the synthetic days up with the zone's dates", () => {
+ const filled = fillStatusDataFor45DaysNoop({
+ errorDays: [0],
+ degradedDays: [],
+ timeZone: "Asia/Tokyo",
+ });
+ expect(filled.at(-1)).toMatchObject({
+ day: "2026-10-16T00:00:00.000Z",
+ error: 1,
+ });
+ });
+});
+
+describe("matching events to a day in a time zone", () => {
+ // 01:00-01:30 in Tokyo on 2026-10-16, still 2026-10-15 in UTC
+ const early = incident(
+ "2026-10-15T16:00:00.000Z",
+ "2026-10-15T16:30:00.000Z",
+ );
+ const tokyo = (date: string) => dayWindow(date, "Asia/Tokyo");
+
+ test("puts an event on the zone's date", () => {
+ expect(isDateWithinEvent(tokyo("2026-10-16"), early)).toBe(true);
+ expect(isDateWithinEvent(tokyo("2026-10-15"), early)).toBe(false);
+ expect(isDateWithinEvent(dayWindow("2026-10-15"), early)).toBe(true);
+ });
+
+ test("keeps the 25th hour of the day summer time ends on that day", () => {
+ // 23:30-23:45 in Berlin on 2026-10-25
+ const late = incident(
+ "2026-10-25T22:30:00.000Z",
+ "2026-10-25T22:45:00.000Z",
+ );
+ const berlin = (date: string) => dayWindow(date, "Europe/Berlin");
+ expect(isDateWithinEvent(berlin("2026-10-25"), late)).toBe(true);
+ expect(isDateWithinEvent(berlin("2026-10-26"), late)).toBe(false);
+ });
+
+ test("reads report impacts on the zone's date", () => {
+ const report: Event = {
+ ...early,
+ type: "report",
+ impactIntervals: [
+ { from: early.from, to: early.to, impact: "major_outage" },
+ ],
+ };
+ expect(reportEventDayImpact(report, tokyo("2026-10-16"))).toBe(
+ "major_outage",
+ );
+ expect(reportEventDayImpact(report, tokyo("2026-10-15"))).toBe(
+ "operational",
+ );
+ });
+
+ test("resolves the day status on the zone's date", () => {
+ expect(
+ resolveDayStatus(bucket("2026-10-16"), [early], "Asia/Tokyo").status,
+ ).toBe("down");
+ expect(resolveDayStatus(bucket("2026-10-16"), [early]).status).toBe(
+ "operational",
+ );
+ });
+});
+
+describe("probeDowntimeIntervals in a time zone", () => {
+ test("spans the zone's day", () => {
+ const intervals = probeDowntimeIntervals(
+ [bucket("2026-10-16", { ok: 0, error: 1 })],
+ { start: 0, end: Number.MAX_SAFE_INTEGER, now: 0 },
+ "Asia/Tokyo",
+ );
+ expect(intervals).toEqual([
+ {
+ from: ms("2026-10-15T15:00:00.000Z"),
+ to: ms("2026-10-16T15:00:00.000Z"),
+ weight: 1,
+ },
+ ]);
+ });
+});
diff --git a/packages/services/src/status-timeline/day-window.ts b/packages/services/src/status-timeline/day-window.ts
new file mode 100644
index 000000000..2a4ec3f33
--- /dev/null
+++ b/packages/services/src/status-timeline/day-window.ts
@@ -0,0 +1,29 @@
+import { TZDate } from "@date-fns/tz";
+
+export const MS_PER_DAY = 86_400_000;
+
+/** Half-open `[start, end)` in epoch ms. */
+export type DayWindow = { start: number; end: number };
+
+/**
+ * The window of the calendar day a bar's `day` key names, in `timeZone`. Built
+ * with TZDate directly: date-fns 3.6 helpers work in the machine's zone.
+ */
+export function dayWindow(day: string, timeZone = "UTC"): DayWindow {
+ const [year, month, date] = day.slice(0, 10).split("-").map(Number);
+ // UTC days are always 24h, so no zone lookup is needed
+ if (timeZone === "UTC") {
+ const start = Date.UTC(year, month - 1, date);
+ return { start, end: start + MS_PER_DAY };
+ }
+ return {
+ start: new TZDate(year, month - 1, date, timeZone).getTime(),
+ end: new TZDate(year, month - 1, date + 1, timeZone).getTime(),
+ };
+}
+
+/** Today's date in `timeZone`, keyed as UTC midnight like `StatusData.day`. */
+export function todayIn(timeZone: string): Date {
+ const date = new TZDate(Date.now(), timeZone).toISOString().slice(0, 10);
+ return new Date(`${date}T00:00:00.000Z`);
+}
diff --git a/packages/services/src/status-timeline/events.ts b/packages/services/src/status-timeline/events.ts
index 2519d8795..4f4471066 100644
--- a/packages/services/src/status-timeline/events.ts
+++ b/packages/services/src/status-timeline/events.ts
@@ -14,6 +14,8 @@ import {
worstImpact,
} from "@openstatus/db/src/schema";
+import { type DayWindow, dayWindow, todayIn } from "./day-window";
+
export type MonitorComponentWithNonNullMonitor =
PageComponentWithMonitorRelation & {
type: "monitor";
@@ -46,6 +48,7 @@ export function fillStatusDataFor45Days(
data: Array<StatusData>,
monitorId: string,
lookbackPeriod = 45,
+ timeZone = "UTC",
): Array<StatusData> {
const result = [];
const dataByDay = new Map();
@@ -57,11 +60,10 @@ export function fillStatusDataFor45Days(
});
// Generate all days from today backwards
- const now = new Date();
+ const today = todayIn(timeZone);
for (let i = 0; i < lookbackPeriod; i++) {
- const date = new Date(now);
+ const date = new Date(today);
date.setUTCDate(date.getUTCDate() - i);
- date.setUTCHours(0, 0, 0, 0); // Set to start of day in UTC
const dayKey = date.toISOString().split("T")[0]; // YYYY-MM-DD format
const isoString = date.toISOString();
@@ -96,17 +98,19 @@ export function fillStatusDataFor45DaysNoop({
errorDays,
degradedDays,
lookbackPeriod = 45,
+ timeZone = "UTC",
}: {
errorDays: number[];
degradedDays: number[];
lookbackPeriod?: number;
+ timeZone?: string;
}): Array<StatusData> {
const issueDays = [...errorDays, ...degradedDays];
- // UTC day grid, matching fillStatusDataFor45Days, so synthetic days line up
+ // same day grid as fillStatusDataFor45Days, so synthetic days line up
+ const today = todayIn(timeZone);
const data: StatusData[] = Array.from({ length: lookbackPeriod }, (_, i) => {
- const date = new Date();
+ const date = new Date(today);
date.setUTCDate(date.getUTCDate() - i);
- date.setUTCHours(0, 0, 0, 0);
return {
day: date.toISOString(),
count: 1,
@@ -116,7 +120,7 @@ export function fillStatusDataFor45DaysNoop({
monitorId: "1",
};
});
- return fillStatusDataFor45Days(data, "1", lookbackPeriod);
+ return fillStatusDataFor45Days(data, "1", lookbackPeriod, timeZone);
}
export type ImpactInterval = {
@@ -456,21 +460,13 @@ export function getHighestPriorityStatus(
// worst report impact for one day; null = legacy event (no impact rows)
export function reportEventDayImpact(
event: Event,
- date: Date,
+ { start, end }: DayWindow,
): PageComponentImpact | null {
if (!event.impactIntervals) return null;
- const startOfDay = new Date(date);
- startOfDay.setUTCHours(0, 0, 0, 0);
- const endOfDay = new Date(date);
- endOfDay.setUTCHours(23, 59, 59, 999);
-
const overlapping = event.impactIntervals.filter((iv) => {
- const end = iv.to ?? new Date();
- return (
- iv.from.getTime() <= endOfDay.getTime() &&
- end.getTime() >= startOfDay.getTime()
- );
+ const ivEnd = iv.to ?? new Date();
+ return iv.from.getTime() < end && ivEnd.getTime() >= start;
});
return worstImpact(overlapping.map((iv) => iv.impact));
}
@@ -478,27 +474,20 @@ export function reportEventDayImpact(
// worst projected report color for one day; legacy events stay orange
export function reportEventDayStatus(
event: Event,
- date: Date,
+ day: DayWindow,
): "success" | "degraded" | "error" {
- const impact = reportEventDayImpact(event, date);
+ const impact = reportEventDayImpact(event, day);
return impact === null ? "degraded" : impactToStatusType(impact);
}
-// Helper to check if date is within event range
-export function isDateWithinEvent(date: Date, event: Event): boolean {
- const startOfDay = new Date(date);
- startOfDay.setUTCHours(0, 0, 0, 0);
-
- const endOfDay = new Date(date);
- endOfDay.setUTCHours(23, 59, 59, 999);
-
+export function isDateWithinEvent(
+ { start, end }: DayWindow,
+ event: Event,
+): boolean {
const eventStart = new Date(event.from);
const eventEnd = event.to ? new Date(event.to) : new Date();
- return (
- eventStart.getTime() <= endOfDay.getTime() &&
- eventEnd.getTime() >= startOfDay.getTime()
- );
+ return eventStart.getTime() < end && eventEnd.getTime() >= start;
}
export type DayStatus =
@@ -513,13 +502,14 @@ export type DayStatus =
export function resolveDayStatus(
bucket: StatusData,
events: Event[],
+ timeZone = "UTC",
): { status: DayStatus; impact?: PageComponentImpact } {
- const date = new Date(bucket.day);
- const dayEvents = events.filter((e) => isDateWithinEvent(date, e));
+ const day = dayWindow(bucket.day, timeZone);
+ const dayEvents = events.filter((e) => isDateWithinEvent(day, e));
const reports = dayEvents.filter((e) => e.type === "report");
const dayImpacts = reports
- .map((e) => reportEventDayImpact(e, date))
+ .map((e) => reportEventDayImpact(e, day))
.filter((i): i is PageComponentImpact => i !== null);
const impact = dayImpacts.length > 0 ? worstImpact(dayImpacts) : undefined;
@@ -528,7 +518,7 @@ export function resolveDayStatus(
}
const reportsDayStatus = reports.length
- ? getWorstVariant(reports.map((e) => reportEventDayStatus(e, date)))
+ ? getWorstVariant(reports.map((e) => reportEventDayStatus(e, day)))
: undefined;
if (reportsDayStatus && reportsDayStatus !== "success") {
return {
diff --git a/packages/services/src/status-timeline/index.ts b/packages/services/src/status-timeline/index.ts
index 46a245c6e..d1f35f16f 100644
--- a/packages/services/src/status-timeline/index.ts
+++ b/packages/services/src/status-timeline/index.ts
@@ -1,3 +1,4 @@
+export * from "./day-window";
export * from "./downtime";
export * from "./events";
export * from "./uptime";
diff --git a/packages/services/src/status-timeline/uptime.ts b/packages/services/src/status-timeline/uptime.ts
index 9e62d8726..0d84755b3 100644
--- a/packages/services/src/status-timeline/uptime.ts
+++ b/packages/services/src/status-timeline/uptime.ts
@@ -3,11 +3,10 @@ import {
impactUptimeWeight,
} from "@openstatus/db/src/schema";
+import { type DayWindow, dayWindow } from "./day-window";
import { type WeightedInterval, mergedDowntimeMs } from "./downtime";
import type { Event, StatusData } from "./events";
-export const MS_PER_DAY = 86_400_000;
-
export type CheckCounts = { ok: number; degraded: number; error: number };
/** Downtime is clamped to [start, end]; `now` closes still-open events. */
@@ -22,16 +21,14 @@ export type CoverageSegment = { start: number; end: number };
* base. `clampEndMs` cuts the in-progress day to elapsed time.
*/
export function dayCoverage(
- dayStartsMs: number[],
+ days: DayWindow[],
clampEndMs?: number,
): { segments: CoverageSegment[]; totalMs: number } {
let totalMs = 0;
const segments: CoverageSegment[] = [];
- for (const start of dayStartsMs) {
+ for (const { start, end: dayEnd } of days) {
const end =
- clampEndMs === undefined
- ? start + MS_PER_DAY
- : Math.min(start + MS_PER_DAY, clampEndMs);
+ clampEndMs === undefined ? dayEnd : Math.min(dayEnd, clampEndMs);
if (end <= start) continue;
totalMs += end - start;
segments.push({ start, end });
@@ -160,12 +157,12 @@ export function reportsOnlyDowntimeMs(
export function probeDowntimeIntervals(
data: StatusData[],
window: UptimeWindow,
+ timeZone = "UTC",
): WeightedInterval[] {
const intervals: WeightedInterval[] = [];
for (const item of data) {
- const dayStart = new Date(item.day).getTime();
- const dayEnd = dayStart + MS_PER_DAY;
+ const { start: dayStart, end: dayEnd } = dayWindow(item.day, timeZone);
// Clamp to window
const start = Math.max(dayStart, window.start);
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6f8e09754..13a24b963 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2962,6 +2962,9 @@ importers:
packages/services:
dependencies:
+ '@date-fns/tz':
+ specifier: 'catalog:'
+ version: 1.5.0
'@openstatus/assertions':
specifier: workspace:*
version: link:../assertions