Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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)