Skip to content

Open-source status page, incident response and uptime monitoring

feat: rpc tracking interceptor (#2048)

Maximilian Kaskeb1778f76cc8b
diff --git a/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts b/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts
new file mode 100644
index 000000000..4a2541826
--- /dev/null
+++ b/apps/server/src/routes/rpc/interceptors/__tests__/tracking.test.ts
@@ -0,0 +1,248 @@
+// @ts-nocheck — ConnectRPC's deep generic types (AnyFn, UnaryResponse, etc.)
+// are incompatible with bun:test mocks. All runtime behavior is correct.
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { Interceptor } from "@connectrpc/connect";
+import { Events } from "@openstatus/analytics";
+
+import { RPC_CONTEXT_KEY } from "../auth";
+import { RPC_EVENT_MAP, trackingInterceptor } from "../tracking";
+
+// Mock analytics
+const mockTrack = mock(() => Promise.resolve());
+const mockSetupAnalytics = mock((_props: unknown) =>
+ Promise.resolve({ track: mockTrack }),
+);
+
+mock.module("@openstatus/analytics", () => ({
+ Events,
+ parseInputToProps: (json: unknown, props?: string[]) => {
+ if (typeof json !== "object" || json === null || !props) return {};
+ return props.reduce(
+ (acc, prop) => {
+ if (prop in json) {
+ acc[prop] = (json as Record<string, unknown>)[prop];
+ }
+ return acc;
+ },
+ {} as Record<string, unknown>,
+ );
+ },
+ setupAnalytics: (props: unknown) => mockSetupAnalytics(props),
+}));
+
+type NextFn = Parameters<ReturnType<Interceptor>>[0];
+
+/** Create a mock `next` that resolves with the given value. */
+function mockNext(response: unknown): NextFn {
+ return mock(() => Promise.resolve(response)) as unknown as NextFn;
+}
+
+/** Create a mock `next` that rejects with the given error. */
+function mockNextReject(error: Error): NextFn {
+ return mock(() => Promise.reject(error)) as unknown as NextFn;
+}
+
+const TEST_WORKSPACE = {
+ id: 42,
+ slug: "test-ws",
+ plan: "free" as const,
+ stripeId: null,
+ name: "",
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ endsAt: null,
+ paidUntil: null,
+ subscriptionId: null,
+ dsn: "",
+};
+
+function createMockRequest(
+ serviceTypeName: string,
+ methodName: string,
+ message: Record<string, unknown> = {},
+ opts?: { withAuth?: boolean },
+) {
+ const contextValues = new Map<unknown, unknown>();
+
+ if (opts?.withAuth !== false) {
+ contextValues.set(RPC_CONTEXT_KEY, {
+ workspace: TEST_WORKSPACE,
+ requestId: "test-req-id",
+ });
+ }
+
+ return {
+ service: { typeName: serviceTypeName },
+ method: { name: methodName },
+ message,
+ header: new Headers({
+ "x-forwarded-for": "1.2.3.4",
+ "user-agent": "test-agent",
+ }),
+ contextValues: {
+ get: (key: unknown) => contextValues.get(key),
+ set: (key: unknown, value: unknown) => contextValues.set(key, value),
+ },
+ } as unknown;
+}
+
+describe("trackingInterceptor", () => {
+ beforeEach(() => {
+ mockSetupAnalytics.mockClear();
+ mockTrack.mockClear();
+ });
+
+ test("tracks mapped event on success", async () => {
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.monitor.v1.MonitorService",
+ "DeleteMonitor",
+ );
+ const mockResponse = { id: "1" };
+ const next = mockNext(mockResponse);
+
+ const result = await interceptor(next)(req as never);
+
+ expect(result).toEqual(mockResponse);
+ expect(mockSetupAnalytics).toHaveBeenCalledTimes(1);
+ expect(mockSetupAnalytics).toHaveBeenCalledWith({
+ userId: "api_42",
+ workspaceId: "42",
+ plan: "free",
+ location: "1.2.3.4",
+ userAgent: "test-agent",
+ });
+
+ // Flush the .then() chain
+ await Promise.resolve();
+
+ expect(mockTrack).toHaveBeenCalledTimes(1);
+ expect(mockTrack).toHaveBeenCalledWith({
+ ...Events.DeleteMonitor,
+ additionalProps: {},
+ });
+ });
+
+ test("extracts additional props from message", async () => {
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.monitor.v1.MonitorService",
+ "CreateHTTPMonitor",
+ { url: "https://example.com", jobType: "http", name: "my-monitor" },
+ );
+ const next = mockNext({});
+
+ await interceptor(next)(req as never);
+ await Promise.resolve();
+
+ expect(mockTrack).toHaveBeenCalledWith({
+ ...Events.CreateMonitor,
+ additionalProps: { url: "https://example.com", jobType: "http" },
+ });
+ });
+
+ test("silently skips unmapped methods", async () => {
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.health.v1.HealthService",
+ "Check",
+ );
+ const mockResponse = { status: "ok" };
+ const next = mockNext(mockResponse);
+
+ const result = await interceptor(next)(req as never);
+
+ expect(result).toEqual(mockResponse);
+ expect(mockSetupAnalytics).not.toHaveBeenCalled();
+ });
+
+ test("does not track on error", async () => {
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.monitor.v1.MonitorService",
+ "DeleteMonitor",
+ );
+ const next = mockNextReject(new Error("not found"));
+
+ await expect(interceptor(next)(req as never)).rejects.toThrow("not found");
+ expect(mockSetupAnalytics).not.toHaveBeenCalled();
+ });
+
+ test("skips tracking when no RPC context", async () => {
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.monitor.v1.MonitorService",
+ "DeleteMonitor",
+ {},
+ { withAuth: false },
+ );
+ const next = mockNext({});
+
+ await interceptor(next)(req as never);
+
+ expect(mockSetupAnalytics).not.toHaveBeenCalled();
+ });
+
+ test("still returns response when analytics fails", async () => {
+ mockSetupAnalytics.mockImplementationOnce(() =>
+ Promise.reject(new Error("analytics down")),
+ );
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.monitor.v1.MonitorService",
+ "DeleteMonitor",
+ );
+ const mockResponse = { id: "1" };
+ const next = mockNext(mockResponse);
+
+ const result = await interceptor(next)(req as never);
+
+ expect(result).toEqual(mockResponse);
+
+ // Flush the .catch() chain — should not throw
+ await Promise.resolve();
+
+ expect(mockTrack).not.toHaveBeenCalled();
+ });
+
+ test("passes correct workspace context", async () => {
+ const interceptor = trackingInterceptor();
+ const req = createMockRequest(
+ "openstatus.notification.v1.NotificationService",
+ "CreateNotification",
+ { provider: "slack" },
+ );
+ const next = mockNext({});
+
+ await interceptor(next)(req as never);
+
+ expect(mockSetupAnalytics).toHaveBeenCalledWith({
+ userId: "api_42",
+ workspaceId: "42",
+ plan: "free",
+ location: "1.2.3.4",
+ userAgent: "test-agent",
+ });
+
+ // Flush the .then() chain
+ await Promise.resolve();
+
+ expect(mockTrack).toHaveBeenCalledWith({
+ ...Events.CreateNotification,
+ additionalProps: { provider: "slack" },
+ });
+ });
+});
+
+describe("RPC_EVENT_MAP", () => {
+ test("all mapped events reference valid Events entries", () => {
+ const validEventNames = new Set(
+ Object.values(Events).map((e) => e.name),
+ ) as Set<string>;
+
+ for (const [_key, mapping] of Object.entries(RPC_EVENT_MAP)) {
+ expect(validEventNames.has(mapping.event.name)).toBe(true);
+ expect(mapping.event.channel).toBeDefined();
+ }
+ });
+});
diff --git a/apps/server/src/routes/rpc/interceptors/index.ts b/apps/server/src/routes/rpc/interceptors/index.ts
index 0ed3efc3d..b770a85ee 100644
--- a/apps/server/src/routes/rpc/interceptors/index.ts
+++ b/apps/server/src/routes/rpc/interceptors/index.ts
@@ -3,3 +3,4 @@ export type { RpcContext } from "./auth";
export { loggingInterceptor } from "./logging";
export { errorInterceptor } from "./error";
export { validationInterceptor } from "./validation";
+export { trackingInterceptor } from "./tracking";
diff --git a/apps/server/src/routes/rpc/interceptors/tracking.ts b/apps/server/src/routes/rpc/interceptors/tracking.ts
new file mode 100644
index 000000000..b49a50551
--- /dev/null
+++ b/apps/server/src/routes/rpc/interceptors/tracking.ts
@@ -0,0 +1,151 @@
+import type { Interceptor } from "@connectrpc/connect";
+import { getLogger } from "@logtape/logtape";
+import {
+ type EventProps,
+ Events,
+ parseInputToProps,
+ setupAnalytics,
+} from "@openstatus/analytics";
+
+import { RPC_CONTEXT_KEY } from "./auth";
+
+const logger = getLogger("api-server");
+
+type RpcEventMapping = {
+ event: EventProps;
+ eventProps?: string[];
+};
+
+/**
+ * Mapping from "ServiceTypeName/MethodName" to OpenPanel event + optional props.
+ * Keys use PascalCase method names matching DescMethod.name (the proto source name).
+ * Matches the same Events used by v1 REST trackMiddleware for parity.
+ */
+export const RPC_EVENT_MAP: Record<string, RpcEventMapping> = {
+ // MonitorService
+ "openstatus.monitor.v1.MonitorService/CreateHTTPMonitor": {
+ event: Events.CreateMonitor,
+ eventProps: ["url", "jobType"],
+ },
+ "openstatus.monitor.v1.MonitorService/CreateTCPMonitor": {
+ event: Events.CreateMonitor,
+ eventProps: ["url", "jobType"],
+ },
+ "openstatus.monitor.v1.MonitorService/CreateDNSMonitor": {
+ event: Events.CreateMonitor,
+ eventProps: ["url", "jobType"],
+ },
+ "openstatus.monitor.v1.MonitorService/UpdateHTTPMonitor": {
+ event: Events.UpdateMonitor,
+ },
+ "openstatus.monitor.v1.MonitorService/UpdateTCPMonitor": {
+ event: Events.UpdateMonitor,
+ },
+ "openstatus.monitor.v1.MonitorService/UpdateDNSMonitor": {
+ event: Events.UpdateMonitor,
+ },
+ "openstatus.monitor.v1.MonitorService/DeleteMonitor": {
+ event: Events.DeleteMonitor,
+ },
+
+ // StatusReportService
+ "openstatus.status_report.v1.StatusReportService/CreateStatusReport": {
+ event: Events.CreateReport,
+ },
+ "openstatus.status_report.v1.StatusReportService/UpdateStatusReport": {
+ event: Events.UpdateReport,
+ },
+ "openstatus.status_report.v1.StatusReportService/DeleteStatusReport": {
+ event: Events.DeleteReport,
+ },
+ "openstatus.status_report.v1.StatusReportService/AddStatusReportUpdate": {
+ event: Events.CreateReportUpdate,
+ },
+
+ // StatusPageService
+ "openstatus.status_page.v1.StatusPageService/CreateStatusPage": {
+ event: Events.CreatePage,
+ eventProps: ["slug"],
+ },
+ "openstatus.status_page.v1.StatusPageService/UpdateStatusPage": {
+ event: Events.UpdatePage,
+ },
+ "openstatus.status_page.v1.StatusPageService/DeleteStatusPage": {
+ event: Events.DeletePage,
+ },
+ "openstatus.status_page.v1.StatusPageService/SubscribeToPage": {
+ event: Events.SubscribePage,
+ },
+
+ // MaintenanceService
+ "openstatus.maintenance.v1.MaintenanceService/CreateMaintenance": {
+ event: Events.CreateMaintenance,
+ },
+ "openstatus.maintenance.v1.MaintenanceService/UpdateMaintenance": {
+ event: Events.UpdateMaintenance,
+ },
+ "openstatus.maintenance.v1.MaintenanceService/DeleteMaintenance": {
+ event: Events.DeleteMaintenance,
+ },
+
+ // NotificationService
+ "openstatus.notification.v1.NotificationService/CreateNotification": {
+ event: Events.CreateNotification,
+ eventProps: ["provider"],
+ },
+ "openstatus.notification.v1.NotificationService/UpdateNotification": {
+ event: Events.UpdateNotification,
+ },
+ "openstatus.notification.v1.NotificationService/DeleteNotification": {
+ event: Events.DeleteNotification,
+ },
+};
+
+/**
+ * Tracking interceptor for ConnectRPC.
+ * Fires OpenPanel analytics events on successful RPC calls.
+ * Must be placed after authInterceptor (needs workspace context)
+ * and validationInterceptor (only track valid requests).
+ */
+export function trackingInterceptor(): Interceptor {
+ return (next) => async (req) => {
+ const response = await next(req);
+
+ const key = `${req.service.typeName}/${req.method.name}`;
+ const mapping = RPC_EVENT_MAP[key];
+
+ if (!mapping) {
+ return response;
+ }
+
+ const rpcCtx = req.contextValues.get(RPC_CONTEXT_KEY);
+
+ if (!rpcCtx) {
+ return response;
+ }
+
+ const additionalProps = parseInputToProps(req.message, mapping.eventProps);
+
+ setupAnalytics({
+ userId: `api_${rpcCtx.workspace.id}`,
+ workspaceId: `${rpcCtx.workspace.id}`,
+ plan: rpcCtx.workspace.plan,
+ location: req.header.get("x-forwarded-for") ?? undefined,
+ userAgent: req.header.get("user-agent") ?? undefined,
+ })
+ .then((analytics) =>
+ analytics.track({ ...mapping.event, additionalProps }),
+ )
+ .catch(() => {
+ logger.warn(
+ "Failed to send analytics event {event} for workspace {workspaceId}",
+ {
+ event: mapping.event.name,
+ workspaceId: rpcCtx.workspace.id,
+ },
+ );
+ });
+
+ return response;
+ };
+}
diff --git a/apps/server/src/routes/rpc/router.ts b/apps/server/src/routes/rpc/router.ts
index d77712c42..9776e1f70 100644
--- a/apps/server/src/routes/rpc/router.ts
+++ b/apps/server/src/routes/rpc/router.ts
@@ -10,6 +10,7 @@ import {
authInterceptor,
errorInterceptor,
loggingInterceptor,
+ trackingInterceptor,
validationInterceptor,
} from "./interceptors";
import { healthServiceImpl } from "./services/health";
@@ -26,6 +27,7 @@ import { statusReportServiceImpl } from "./services/status-report";
* 2. loggingInterceptor - Logs requests/responses with duration
* 3. authInterceptor - Validates API key and sets workspace context
* 4. validationInterceptor - Validates request messages using protovalidate
+ * 5. trackingInterceptor - Fires OpenPanel events on success
*/
export const routes = createConnectRouter({
interceptors: [
@@ -33,6 +35,7 @@ export const routes = createConnectRouter({
loggingInterceptor(),
authInterceptor(),
validationInterceptor(),
+ trackingInterceptor(),
],
})
.service(MonitorService, monitorServiceImpl)