Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

feat(web-vitals): implement comprehensive web vitals tracking and per… (#343)

Bill Yang2c026d5c18f1
diff --git a/client/package.json b/client/package.json
index f3777a786..502028a77 100644
--- a/client/package.json
+++ b/client/package.json
@@ -1,6 +1,6 @@
{
"name": "client",
- "version": "1.0.0",
+ "version": "1.1.0",
"private": true,
"scripts": {
"dev": "next dev -p 3002 --turbopack",
diff --git a/client/src/api/analytics/useGetPerformanceByDimension.ts b/client/src/api/analytics/useGetPerformanceByDimension.ts
new file mode 100644
index 000000000..2089607bf
--- /dev/null
+++ b/client/src/api/analytics/useGetPerformanceByDimension.ts
@@ -0,0 +1,152 @@
+import { authedFetch, getStartAndEndDate } from "../utils";
+import { BACKEND_URL } from "../../lib/const";
+import { timeZone } from "../../lib/dateTimeUtils";
+import { Filter, useStore } from "../../lib/store";
+import { usePerformanceStore } from "../../app/[site]/performance/performanceStore";
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+
+type UseGetPerformanceByDimensionOptions = {
+ site: number | string;
+ dimension: string;
+ limit?: number;
+ page?: number;
+ useFilters?: boolean;
+ enabled?: boolean;
+ additionalFilters?: Filter[];
+ sortBy?: string;
+ sortOrder?: "asc" | "desc";
+};
+
+// Generic type that can represent any dimension
+export type PerformanceByDimensionItem = {
+ [key: string]: any; // The dimension field (pathname, country, etc.)
+ event_count: number;
+ lcp_avg: number | null;
+ lcp_p50: number | null;
+ lcp_p75: number | null;
+ lcp_p90: number | null;
+ lcp_p99: number | null;
+ cls_avg: number | null;
+ cls_p50: number | null;
+ cls_p75: number | null;
+ cls_p90: number | null;
+ cls_p99: number | null;
+ inp_avg: number | null;
+ inp_p50: number | null;
+ inp_p75: number | null;
+ inp_p90: number | null;
+ inp_p99: number | null;
+ fcp_avg: number | null;
+ fcp_p50: number | null;
+ fcp_p75: number | null;
+ fcp_p90: number | null;
+ fcp_p99: number | null;
+ ttfb_avg: number | null;
+ ttfb_p50: number | null;
+ ttfb_p75: number | null;
+ ttfb_p90: number | null;
+ ttfb_p99: number | null;
+};
+
+// Keep the old type for backward compatibility
+export type PerformanceByPathItem = PerformanceByDimensionItem & {
+ pathname: string;
+};
+
+type PaginatedPerformanceResponse = {
+ data: PerformanceByDimensionItem[];
+ totalCount: number;
+};
+
+export function useGetPerformanceByDimension({
+ site,
+ dimension,
+ limit = 10,
+ page = 1,
+ useFilters = true,
+ enabled = true,
+ additionalFilters = [],
+ sortBy,
+ sortOrder,
+}: UseGetPerformanceByDimensionOptions): UseQueryResult<PaginatedPerformanceResponse> {
+ const { time, filters } = useStore();
+ const { selectedPercentile } = usePerformanceStore();
+
+ // Check if we're using last-24-hours mode
+ const isPast24HoursMode = time.mode === "last-24-hours";
+
+ // Determine the query parameters based on mode
+ const queryParams = isPast24HoursMode
+ ? {
+ // Past minutes approach for last-24-hours mode
+ timeZone: timeZone,
+ pastMinutesStart: 24 * 60, // 24 hours ago
+ pastMinutesEnd: 0, // now
+ limit,
+ page,
+ percentile: selectedPercentile,
+ filters: useFilters ? [...filters, ...additionalFilters] : undefined,
+ sortBy,
+ sortOrder,
+ dimension,
+ }
+ : {
+ // Regular date-based approach
+ ...getStartAndEndDate(time),
+ timeZone: timeZone,
+ limit,
+ page,
+ percentile: selectedPercentile,
+ filters: useFilters ? [...filters, ...additionalFilters] : undefined,
+ sortBy,
+ sortOrder,
+ dimension,
+ };
+
+ return useQuery({
+ queryKey: [
+ "performance-by-dimension",
+ dimension,
+ time,
+ site,
+ filters,
+ selectedPercentile,
+ limit,
+ page,
+ isPast24HoursMode ? "past-minutes" : "date-range",
+ additionalFilters,
+ sortBy,
+ sortOrder,
+ ],
+ queryFn: () => {
+ return authedFetch(
+ `${BACKEND_URL}/performance/by-dimension/${site}`,
+ queryParams
+ )
+ .then((res) => res.json())
+ .then(({ data }) => data);
+ },
+ staleTime: Infinity,
+ placeholderData: (_, query: any) => {
+ if (!query?.queryKey) return undefined;
+ const prevQueryKey = query.queryKey;
+ const [, , , prevSite] = prevQueryKey;
+
+ if (prevSite === site) {
+ return query.state.data;
+ }
+ return undefined;
+ },
+ enabled,
+ });
+}
+
+// Keep the old hook for backward compatibility
+export function useGetPerformanceByPath(
+ options: Omit<UseGetPerformanceByDimensionOptions, "dimension">
+) {
+ return useGetPerformanceByDimension({
+ ...options,
+ dimension: "pathname",
+ });
+}
diff --git a/client/src/api/analytics/useGetPerformanceByPath.ts b/client/src/api/analytics/useGetPerformanceByPath.ts
new file mode 100644
index 000000000..18deb2ff6
--- /dev/null
+++ b/client/src/api/analytics/useGetPerformanceByPath.ts
@@ -0,0 +1,144 @@
+import { authedFetch, getStartAndEndDate } from "../utils";
+import { BACKEND_URL } from "../../lib/const";
+import { timeZone } from "../../lib/dateTimeUtils";
+import { Filter, useStore } from "../../lib/store";
+import { usePerformanceStore } from "../../app/[site]/performance/performanceStore";
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+
+type UseGetPerformanceByPathOptions = {
+ site: number | string;
+ limit?: number;
+ page?: number;
+ useFilters?: boolean;
+ enabled?: boolean;
+ additionalFilters?: Filter[];
+ sortBy?: string;
+ sortOrder?: "asc" | "desc";
+};
+
+// Import the correct type from backend
+export type PerformanceByPathItem = {
+ pathname: string;
+ event_count: number;
+ lcp_avg: number | null;
+ lcp_p50: number | null;
+ lcp_p75: number | null;
+ lcp_p90: number | null;
+ lcp_p99: number | null;
+ cls_avg: number | null;
+ cls_p50: number | null;
+ cls_p75: number | null;
+ cls_p90: number | null;
+ cls_p99: number | null;
+ inp_avg: number | null;
+ inp_p50: number | null;
+ inp_p75: number | null;
+ inp_p90: number | null;
+ inp_p99: number | null;
+ fcp_avg: number | null;
+ fcp_p50: number | null;
+ fcp_p75: number | null;
+ fcp_p90: number | null;
+ fcp_p99: number | null;
+ ttfb_avg: number | null;
+ ttfb_p50: number | null;
+ ttfb_p75: number | null;
+ ttfb_p90: number | null;
+ ttfb_p99: number | null;
+};
+
+type PaginatedPerformanceResponse = {
+ data: PerformanceByPathItem[];
+ totalCount: number;
+};
+
+// Keep the old type for backward compatibility, but mark as deprecated
+/** @deprecated Use PerformanceByPathItem instead */
+export type PerformanceByPathResponse = {
+ path: string;
+ lcp: number;
+ cls: number;
+ inp: number;
+ fcp: number;
+ ttfb: number;
+ pageviews: number;
+};
+
+export function useGetPerformanceByPath({
+ site,
+ limit = 10,
+ page = 1,
+ useFilters = true,
+ enabled = true,
+ additionalFilters = [],
+ sortBy,
+ sortOrder,
+}: UseGetPerformanceByPathOptions): UseQueryResult<PaginatedPerformanceResponse> {
+ const { time, filters } = useStore();
+ const { selectedPercentile } = usePerformanceStore();
+
+ // Check if we're using last-24-hours mode
+ const isPast24HoursMode = time.mode === "last-24-hours";
+
+ // Determine the query parameters based on mode
+ const queryParams = isPast24HoursMode
+ ? {
+ // Past minutes approach for last-24-hours mode
+ timeZone: timeZone,
+ pastMinutesStart: 24 * 60, // 24 hours ago
+ pastMinutesEnd: 0, // now
+ limit,
+ page,
+ percentile: selectedPercentile,
+ filters: useFilters ? [...filters, ...additionalFilters] : undefined,
+ sortBy,
+ sortOrder,
+ }
+ : {
+ // Regular date-based approach
+ ...getStartAndEndDate(time),
+ timeZone: timeZone,
+ limit,
+ page,
+ percentile: selectedPercentile,
+ filters: useFilters ? [...filters, ...additionalFilters] : undefined,
+ sortBy,
+ sortOrder,
+ };
+
+ return useQuery({
+ queryKey: [
+ "performance-by-path",
+ time,
+ site,
+ filters,
+ selectedPercentile,
+ limit,
+ page,
+ isPast24HoursMode ? "past-minutes" : "date-range",
+ additionalFilters,
+ sortBy,
+ sortOrder,
+ ],
+ queryFn: () => {
+ return authedFetch(
+ `${BACKEND_URL}/performance/by-path/${site}`,
+ queryParams
+ )
+ .then((res) => res.json())
+ .then(({ data }) => data);
+ },
+ staleTime: Infinity,
+ placeholderData: (_, query: any) => {
+ if (!query?.queryKey) return undefined;
+ const prevQueryKey = query.queryKey;
+ const [, , prevSite] = prevQueryKey;
+
+ if (prevSite === site) {
+ return query.state.data;
+ }
+ return undefined;
+ },
+ enabled,
+ });
+}
diff --git a/client/src/api/analytics/useGetPerformanceOverview.ts b/client/src/api/analytics/useGetPerformanceOverview.ts
new file mode 100644
index 000000000..88710cd7b
--- /dev/null
+++ b/client/src/api/analytics/useGetPerformanceOverview.ts
@@ -0,0 +1,68 @@
+import { useQuery } from "@tanstack/react-query";
+import { useStore } from "../../lib/store";
+import { usePerformanceStore } from "../../app/[site]/performance/performanceStore";
+import { authedFetch, getStartAndEndDate } from "../utils";
+import { BACKEND_URL } from "../../lib/const";
+import { timeZone } from "../../lib/dateTimeUtils";
+
+export type GetPerformanceOverviewResponse = {
+ current: {
+ lcp: number;
+ cls: number;
+ inp: number;
+ fcp: number;
+ ttfb: number;
+ };
+ previous: {
+ lcp: number;
+ cls: number;
+ inp: number;
+ fcp: number;
+ ttfb: number;
+ };
+};
+
+type PeriodTime = "current" | "previous";
+
+export function useGetPerformanceOverview({
+ periodTime,
+ site,
+}: {
+ periodTime?: PeriodTime;
+ site?: number | string;
+}) {
+ const { time, previousTime, filters } = useStore();
+ const { selectedPercentile } = usePerformanceStore();
+ const timeToUse = periodTime === "previous" ? previousTime : time;
+ const { startDate, endDate } = getStartAndEndDate(timeToUse);
+
+ return useQuery({
+ queryKey: [
+ "performance-overview",
+ timeToUse,
+ site,
+ filters,
+ selectedPercentile,
+ ],
+ queryFn: () => {
+ return authedFetch(`${BACKEND_URL}/performance/overview/${site}`, {
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ percentile: selectedPercentile,
+ }).then((res) => res.json());
+ },
+ staleTime: Infinity,
+ placeholderData: (_, query: any) => {
+ if (!query?.queryKey) return undefined;
+ const prevQueryKey = query.queryKey as [string, string, string];
+ const [, , prevSite] = prevQueryKey;
+
+ if (prevSite === site) {
+ return query.state.data;
+ }
+ return undefined;
+ },
+ });
+}
diff --git a/client/src/api/analytics/useGetPerformanceTimeSeries.ts b/client/src/api/analytics/useGetPerformanceTimeSeries.ts
new file mode 100644
index 000000000..c247a9d33
--- /dev/null
+++ b/client/src/api/analytics/useGetPerformanceTimeSeries.ts
@@ -0,0 +1,107 @@
+import {
+ UseQueryOptions,
+ UseQueryResult,
+ useQuery,
+} from "@tanstack/react-query";
+import { BACKEND_URL } from "../../lib/const";
+import { Filter, TimeBucket, useStore } from "../../lib/store";
+import { usePerformanceStore } from "../../app/[site]/performance/performanceStore";
+import { timeZone } from "../../lib/dateTimeUtils";
+import { APIResponse } from "../types";
+import { authedFetch, getStartAndEndDate } from "../utils";
+
+type PeriodTime = "current" | "previous";
+
+export type GetPerformanceTimeSeriesResponse = {
+ time: string;
+ event_count: number;
+ lcp_p50: number | null;
+ lcp_p75: number | null;
+ lcp_p90: number | null;
+ lcp_p99: number | null;
+ cls_p50: number | null;
+ cls_p75: number | null;
+ cls_p90: number | null;
+ cls_p99: number | null;
+ inp_p50: number | null;
+ inp_p75: number | null;
+ inp_p90: number | null;
+ inp_p99: number | null;
+ fcp_p50: number | null;
+ fcp_p75: number | null;
+ fcp_p90: number | null;
+ fcp_p99: number | null;
+ ttfb_p50: number | null;
+ ttfb_p75: number | null;
+ ttfb_p90: number | null;
+ ttfb_p99: number | null;
+}[];
+
+export function useGetPerformanceTimeSeries({
+ periodTime,
+ site,
+ bucket,
+ dynamicFilters = [],
+ props,
+}: {
+ periodTime?: PeriodTime;
+ site: number | string;
+ bucket?: TimeBucket;
+ dynamicFilters?: Filter[];
+ props?: Partial<
+ UseQueryOptions<APIResponse<GetPerformanceTimeSeriesResponse>>
+ >;
+}): UseQueryResult<APIResponse<GetPerformanceTimeSeriesResponse>> {
+ const {
+ time,
+ previousTime,
+ filters: globalFilters,
+ bucket: storeBucket,
+ } = useStore();
+ const { selectedPerformanceMetric } = usePerformanceStore();
+
+ const timeToUse = periodTime === "previous" ? previousTime : time;
+ const bucketToUse = bucket || storeBucket;
+
+ const { startDate, endDate } = getStartAndEndDate(timeToUse);
+
+ const combinedFilters = [...globalFilters, ...dynamicFilters];
+
+ return useQuery({
+ queryKey: [
+ "performance-time-series",
+ timeToUse,
+ bucketToUse,
+ site,
+ combinedFilters,
+ selectedPerformanceMetric,
+ ],
+ queryFn: () => {
+ return authedFetch(`${BACKEND_URL}/performance/time-series/${site}`, {
+ startDate,
+ endDate,
+ timeZone,
+ bucket: bucketToUse,
+ filters: combinedFilters,
+ }).then((res) => res.json());
+ },
+ placeholderData: (_, query: any) => {
+ if (!query?.queryKey) return undefined;
+ const [, , , prevSite] = query.queryKey as [
+ string,
+ any,
+ TimeBucket,
+ string | number,
+ Filter[],
+ string
+ ];
+
+ if (prevSite === site) {
+ return query.state.data;
+ }
+ return undefined;
+ },
+ staleTime: Infinity,
+ ...props,
+ });
+}
diff --git a/client/src/app/[site]/components/Sidebar/Sidebar.tsx b/client/src/app/[site]/components/Sidebar/Sidebar.tsx
index 3941d1a9f..1355a3faa 100644
--- a/client/src/app/[site]/components/Sidebar/Sidebar.tsx
+++ b/client/src/app/[site]/components/Sidebar/Sidebar.tsx
@@ -2,6 +2,7 @@
import { Funnel, Target } from "@phosphor-icons/react/dist/ssr";
import {
Earth,
+ Gauge,
LayoutDashboard,
LayoutGrid,
Map,
@@ -20,6 +21,7 @@ import { authClient } from "../../../../lib/auth";
import { cn } from "../../../../lib/utils";
import LiveUserCount from "./LiveUserCount";
import { SiteSelector } from "./SiteSelector";
+import { IS_CLOUD } from "../../../../lib/const";
export function Sidebar() {
const session = authClient.useSession();
@@ -66,6 +68,14 @@ export function Sidebar() {
href={getTabPath("realtime")}
icon={<Earth className="w-4 h-4" />}
/>
+ {IS_CLOUD && (
+ <SidebarLink
+ label="Performance"
+ active={isActiveTab("performance")}
+ href={getTabPath("performance")}
+ icon={<Gauge className="w-4 h-4" />}
+ />
+ )}
<SidebarLink
label="Map"
active={isActiveTab("map")}
diff --git a/client/src/app/[site]/main/components/MainSection/Chart.tsx b/client/src/app/[site]/main/components/MainSection/Chart.tsx
index ccd8a8857..fd596d65c 100644
--- a/client/src/app/[site]/main/components/MainSection/Chart.tsx
+++ b/client/src/app/[site]/main/components/MainSection/Chart.tsx
@@ -1,7 +1,12 @@
"use client";
import { nivoTheme } from "@/lib/nivo";
import { StatType, TimeBucket, useStore } from "@/lib/store";
-import { LineCustomSvgLayer, LineCustomSvgLayerProps, LineSeries, ResponsiveLine } from "@nivo/line";
+import {
+ LineCustomSvgLayer,
+ LineCustomSvgLayerProps,
+ LineSeries,
+ ResponsiveLine,
+} from "@nivo/line";
import { useWindowSize } from "@uidotdev/usehooks";
import { DateTime } from "luxon";
import { GetOverviewBucketedResponse } from "../../../../../api/analytics/useGetOverviewBucketed";
@@ -177,8 +182,10 @@ export function Chart({
(time.mode === "month" && time.month !== currentMonthStr) || // do not display in month mode if month is not current
(time.mode === "day" && time.day !== currentDayStr) || // do not display in day mode if day is not current
(time.mode === "range" && time.endDate !== currentDayStr) || // do not display in range mode if end date is not current day
- (time.mode === "day" && (bucket === "minute" || bucket === "five_minutes")) || // do not display in day mode if bucket is minute or five_minutes
- (time.mode === "last-24-hours" && (bucket === "minute" || bucket === "five_minutes")); // do not display in last-24-hours mode if bucket is minute or five_minutes
+ (time.mode === "day" &&
+ (bucket === "minute" || bucket === "five_minutes")) || // do not display in day mode if bucket is minute or five_minutes
+ (time.mode === "last-24-hours" &&
+ (bucket === "minute" || bucket === "five_minutes")); // do not display in last-24-hours mode if bucket is minute or five_minutes
const displayDashed = formattedData.length >= 2 && !shouldNotDisplay;
const baseGradient = {
@@ -245,13 +252,21 @@ export function Chart({
return series.map(({ id, data, color }) => (
<path
key={id}
- d={lineGenerator(data.map(d => ({ x: xScale(d.data.x), y: yScale(d.data.y) })))!}
+ d={
+ lineGenerator(
+ data.map((d) => ({ x: xScale(d.data.x), y: yScale(d.data.y) }))
+ )!
+ }
fill="none"
stroke={color}
- style={id === "dashedData" ? { strokeDasharray: "3, 6", strokeWidth: 3 } : { strokeWidth: 2 }}
+ style={
+ id === "dashedData"
+ ? { strokeDasharray: "3, 6", strokeWidth: 3 }
+ : { strokeWidth: 2 }
+ }
/>
- ))
- }
+ ));
+ };
return (
<ResponsiveLine
@@ -292,7 +307,7 @@ export function Chart({
),
format: (value) => {
const dt = DateTime.fromJSDate(value).setLocale(userLocale);
- if (time.mode === "day" || time.mode === "last-24-hours" ) {
+ if (time.mode === "day" || time.mode === "last-24-hours") {
return dt.toFormat(hour12 ? "ha" : "HH:mm");
}
return dt.toFormat(hour12 ? "MMM d" : "dd MMM");
@@ -374,7 +389,13 @@ export function Chart({
}
const formatDateTime = (dt: DateTime, bucket: TimeBucket) => {
- const showMinutes = ["minute", "five_minutes", "ten_minutes", "fifteen_minutes", "hour"].includes(bucket);
+ const showMinutes = [
+ "minute",
+ "five_minutes",
+ "ten_minutes",
+ "fifteen_minutes",
+ "hour",
+ ].includes(bucket);
const options: Intl.DateTimeFormatOptions = {
month: "short",
day: "numeric",
diff --git a/client/src/app/[site]/main/components/MainSection/MainSection.tsx b/client/src/app/[site]/main/components/MainSection/MainSection.tsx
index 3c3cae6cd..412758cae 100644
--- a/client/src/app/[site]/main/components/MainSection/MainSection.tsx
+++ b/client/src/app/[site]/main/components/MainSection/MainSection.tsx
@@ -12,7 +12,7 @@ import {
import { authClient } from "../../../../../lib/auth";
import { useStore } from "../../../../../lib/store";
import { cn } from "../../../../../lib/utils";
-import { BucketSelection } from "./BucketSelection";
+import { BucketSelection } from "../../../../../components/BucketSelection";
import { Chart } from "./Chart";
import { Overview } from "./Overview";
import { PreviousChart } from "./PreviousChart";
diff --git a/client/src/app/[site]/performance/components/PercentileSelector.tsx b/client/src/app/[site]/performance/components/PercentileSelector.tsx
new file mode 100644
index 000000000..cd6a80153
--- /dev/null
+++ b/client/src/app/[site]/performance/components/PercentileSelector.tsx
@@ -0,0 +1,49 @@
+"use client";
+
+import { cn } from "@/lib/utils";
+import { PercentileLevel, usePerformanceStore } from "../performanceStore";
+
+const PERCENTILE_OPTIONS: {
+ value: PercentileLevel;
+ label: string;
+ color: string;
+}[] = [
+ { value: "p50", label: "P50", color: "hsl(var(--indigo-100))" },
+ { value: "p75", label: "P75", color: "hsl(var(--indigo-300))" },
+ { value: "p90", label: "P90", color: "hsl(var(--indigo-400))" },
+ { value: "p99", label: "P99", color: "hsl(var(--indigo-500))" },
+];
+
+export function PercentileSelector() {
+ const { selectedPercentile, setSelectedPercentile } = usePerformanceStore();
+
+ return (
+ <div className="flex items-center space-x-2">
+ {PERCENTILE_OPTIONS.map((option) => {
+ const isSelected = selectedPercentile === option.value;
+
+ return (
+ <button
+ key={option.value}
+ onClick={() => setSelectedPercentile(option.value)}
+ className={cn(
+ "flex items-center space-x-1.5 px-2 py-1 rounded text-xs font-medium transition-all",
+ isSelected
+ ? "bg-neutral-800 text-white"
+ : "bg-neutral-900 text-neutral-500 hover:text-neutral-400"
+ )}
+ >
+ <div
+ className={cn(
+ "w-3 h-3 rounded-sm transition-opacity",
+ isSelected ? "opacity-100" : "opacity-30"
+ )}
+ style={{ backgroundColor: option.color }}
+ />
+ <span>{option.label}</span>
+ </button>
+ );
+ })}
+ </div>
+ );
+}
diff --git a/client/src/app/[site]/performance/components/PerformanceByDimensions.tsx b/client/src/app/[site]/performance/components/PerformanceByDimensions.tsx
new file mode 100644
index 000000000..bfbffd377
--- /dev/null
+++ b/client/src/app/[site]/performance/components/PerformanceByDimensions.tsx
@@ -0,0 +1,86 @@
+"use client";
+
+import { useState } from "react";
+import {
+ Tabs,
+ TabsContent,
+ TabsList,
+ TabsTrigger,
+} from "../../../../components/ui/basic-tabs";
+import { Card, CardContent } from "../../../../components/ui/card";
+import { PerformanceTable } from "./PerformanceTable";
+import { PerformanceMap } from "./PerformanceMap";
+
+type Tab =
+ | "pathname"
+ | "country"
+ | "map"
+ | "device_type"
+ | "browser"
+ | "operating_system";
+
+export function PerformanceByDimensions() {
+ const [tab, setTab] = useState<Tab>("pathname");
+
+ return (
+ <Card>
+ <CardContent className="mt-2">
+ <Tabs
+ defaultValue="pathname"
+ value={tab}
+ onValueChange={(value) => setTab(value as Tab)}
+ >
+ <TabsList>
+ <TabsTrigger value="pathname">Pages</TabsTrigger>
+ <TabsTrigger value="country">Countries</TabsTrigger>
+ <TabsTrigger value="map">Map</TabsTrigger>
+ <TabsTrigger value="device_type">Devices</TabsTrigger>
+ <TabsTrigger value="browser">Browsers</TabsTrigger>
+ <TabsTrigger value="operating_system">
+ Operating Systems
+ </TabsTrigger>
+ </TabsList>
+
+ <TabsContent value="pathname">
+ <PerformanceTable
+ dimension="pathname"
+ title="Performance by Page"
+ />
+ </TabsContent>
+
+ <TabsContent value="country">
+ <PerformanceTable
+ dimension="country"
+ title="Performance by Country"
+ />
+ </TabsContent>
+
+ <TabsContent value="map">
+ <PerformanceMap height="600px" />
+ </TabsContent>
+
+ <TabsContent value="device_type">
+ <PerformanceTable
+ dimension="device_type"
+ title="Performance by Device Type"
+ />
+ </TabsContent>
+
+ <TabsContent value="browser">
+ <PerformanceTable
+ dimension="browser"
+ title="Performance by Browser"
+ />
+ </TabsContent>
+
+ <TabsContent value="operating_system">
+ <PerformanceTable
+ dimension="operating_system"
+ title="Performance by Operating System"
+ />
+ </TabsContent>
+ </Tabs>
+ </CardContent>
+ </Card>
+ );
+}
diff --git a/client/src/app/[site]/performance/components/PerformanceChart.tsx b/client/src/app/[site]/performance/components/PerformanceChart.tsx
new file mode 100644
index 000000000..ca51c6222
--- /dev/null
+++ b/client/src/app/[site]/performance/components/PerformanceChart.tsx
@@ -0,0 +1,469 @@
+"use client";
+
+import { Card, CardContent, CardLoader } from "@/components/ui/card";
+import { Skeleton } from "@/components/ui/skeleton";
+import { nivoTheme } from "@/lib/nivo";
+import { ResponsiveLine } from "@nivo/line";
+import { DateTime } from "luxon";
+import { Tilt_Warp } from "next/font/google";
+import Image from "next/image";
+import Link from "next/link";
+import { useState } from "react";
+import { useGetPerformanceTimeSeries } from "../../../../api/analytics/useGetPerformanceTimeSeries";
+import { BucketSelection } from "../../../../components/BucketSelection";
+import { authClient } from "../../../../lib/auth";
+import { hour12, userLocale } from "../../../../lib/dateTimeUtils";
+import { useStore } from "../../../../lib/store";
+import { cn } from "../../../../lib/utils";
+import { usePerformanceStore } from "../performanceStore";
+import {
+ formatMetricValue,
+ getMetricUnit,
+ getPerformanceThresholds,
+ METRIC_LABELS,
+} from "../utils/performanceUtils";
+
+const tilt_wrap = Tilt_Warp({
+ subsets: ["latin"],
+ weight: "400",
+});
+
+export function PerformanceChart() {
+ const session = authClient.useSession();
+ const { site, bucket } = useStore();
+ const { selectedPerformanceMetric, selectedPercentile } =
+ usePerformanceStore();
+
+ // State for toggling percentile visibility
+ const [visiblePercentiles, setVisiblePercentiles] = useState<Set<string>>(
+ new Set(["P50", "P75", "P90", "P99"])
+ );
+
+ const togglePercentile = (percentile: string) => {
+ setVisiblePercentiles((prev) => {
+ const newSet = new Set(prev);
+ if (newSet.has(percentile)) {
+ newSet.delete(percentile);
+ } else {
+ newSet.add(percentile);
+ }
+ return newSet;
+ });
+ };
+
+ const {
+ data: timeSeriesData,
+ isLoading,
+ isFetching,
+ } = useGetPerformanceTimeSeries({
+ site,
+ });
+
+ // Transform data to show all percentiles as separate lines
+ const processedData =
+ timeSeriesData?.data
+ ?.map((item: any) => {
+ // Parse timestamp properly using luxon (same as Chart.tsx)
+ const timestamp = DateTime.fromSQL(item.time).toUTC();
+
+ // Filter out dates from the future
+ if (timestamp > DateTime.now()) {
+ return null;
+ }
+
+ return {
+ time: timestamp.toFormat("yyyy-MM-dd HH:mm:ss"),
+ p50: item[`${selectedPerformanceMetric}_p50`] ?? null,
+ p75: item[`${selectedPerformanceMetric}_p75`] ?? null,
+ p90: item[`${selectedPerformanceMetric}_p90`] ?? null,
+ p99: item[`${selectedPerformanceMetric}_p99`] ?? null,
+ };
+ })
+ .filter((e) => e !== null) ?? [];
+
+ // Create separate data series for each percentile - using shades of blue
+ const percentileColors = {
+ p50: "hsl(var(--indigo-100))", // light blue
+ p75: "hsl(var(--indigo-300))", // medium blue
+ p90: "hsl(var(--indigo-400))", // blue
+ p99: "hsl(var(--indigo-500))", // dark blue
+ };
+
+ const data = [
+ {
+ id: "P50",
+ color: percentileColors.p50,
+ data: processedData
+ .map((item) => ({
+ x: item.time,
+ y: item.p50,
+ }))
+ .filter((point) => point.y !== null),
+ },
+ {
+ id: "P75",
+ color: percentileColors.p75,
+ data: processedData
+ .map((item) => ({
+ x: item.time,
+ y: item.p75,
+ }))
+ .filter((point) => point.y !== null),
+ },
+ {
+ id: "P90",
+ color: percentileColors.p90,
+ data: processedData
+ .map((item) => ({
+ x: item.time,
+ y: item.p90,
+ }))
+ .filter((point) => point.y !== null),
+ },
+ {
+ id: "P99",
+ color: percentileColors.p99,
+ data: processedData
+ .map((item) => ({
+ x: item.time,
+ y: item.p99,
+ }))
+ .filter((point) => point.y !== null),
+ },
+ ].filter(
+ (series) => series.data.length > 0 && visiblePercentiles.has(series.id)
+ );
+
+ // Gradient definitions for each percentile line
+ const chartPropsDefs = [
+ {
+ id: "P50",
+ type: "linearGradient",
+ colors: [
+ {
+ offset: 0,
+ color: percentileColors.p50,
+ opacity: 0.3,
+ },
+ {
+ offset: 100,
+ color: percentileColors.p50,
+ opacity: 0,
+ },
+ ],
+ },
+ {
+ id: "P75",
+ type: "linearGradient",
+ colors: [
+ {
+ offset: 0,
+ color: percentileColors.p75,
+ opacity: 0.3,
+ },
+ {
+ offset: 100,
+ color: percentileColors.p75,
+ opacity: 0,
+ },
+ ],
+ },
+ {
+ id: "P90",
+ type: "linearGradient",
+ colors: [
+ {
+ offset: 0,
+ color: percentileColors.p90,
+ opacity: 0.3,
+ },
+ {
+ offset: 100,
+ color: percentileColors.p90,
+ opacity: 0,
+ },
+ ],
+ },
+ {
+ id: "P99",
+ type: "linearGradient",
+ colors: [
+ {
+ offset: 0,
+ color: percentileColors.p99,
+ opacity: 0.3,
+ },
+ {
+ offset: 100,
+ color: percentileColors.p99,
+ opacity: 0,
+ },
+ ],
+ },
+ ];
+
+ // Fill configuration to apply gradients
+ const chartPropsFill = [
+ { id: "P50", match: { id: "P50" } },
+ { id: "P75", match: { id: "P75" } },
+ { id: "P90", match: { id: "P90" } },
+ { id: "P99", match: { id: "P99" } },
+ ];
+
+ const formatXAxisValue = (value: any) => {
+ const dt = DateTime.fromJSDate(value).setLocale(userLocale);
+ if (
+ bucket === "hour" ||
+ bucket === "minute" ||
+ bucket === "five_minutes" ||
+ bucket === "ten_minutes" ||
+ bucket === "fifteen_minutes"
+ ) {
+ return dt.toFormat(hour12 ? "ha" : "HH:mm");
+ }
+ return dt.toFormat(hour12 ? "MMM d" : "dd MMM");
+ };
+
+ const formatTooltipValue = (value: number) => {
+ return `${formatMetricValue(
+ selectedPerformanceMetric,
+ value
+ )}${getMetricUnit(selectedPerformanceMetric, value)}`;
+ };
+
+ // Get performance thresholds for the current metric
+ const thresholds = getPerformanceThresholds(selectedPerformanceMetric);
+
+ // Create markers for performance thresholds
+ const markers = thresholds
+ ? [
+ {
+ axis: "y" as const,
+ value: thresholds.good,
+ lineStyle: {
+ stroke: "hsl(var(--green-400))", // green
+ strokeWidth: 1,
+ strokeDasharray: "8 8",
+ },
+ legend: `Good (≤${formatMetricValue(
+ selectedPerformanceMetric,
+ thresholds.good
+ )}${getMetricUnit(selectedPerformanceMetric, thresholds.good)})`,
+ legendPosition: "top-left" as const,
+ legendOrientation: "horizontal" as const,
+ textStyle: {
+ fill: "hsl(var(--green-400))",
+ fontSize: 11,
+ },
+ },
+ {
+ axis: "y" as const,
+ value: thresholds.needs_improvement,
+ lineStyle: {
+ stroke: "hsl(var(--amber-400))", // yellow/amber
+ strokeWidth: 1,
+ strokeDasharray: "8 8",
+ },
+ legend: `Needs Improvement (≤${formatMetricValue(
+ selectedPerformanceMetric,
+ thresholds.needs_improvement
+ )}${getMetricUnit(
+ selectedPerformanceMetric,
+ thresholds.needs_improvement
+ )})`,
+ legendPosition: "top-left" as const,
+ legendOrientation: "horizontal" as const,
+ textStyle: {
+ fill: "hsl(var(--amber-400))",
+ fontSize: 11,
+ },
+ },
+ ]
+ : [];
+
+ return (
+ <Card>
+ {isFetching && <CardLoader />}
+ <CardContent className="p-2 md:p-4 py-3 w-full">
+ <div className="flex items-center justify-between px-2 md:px-0">
+ <div className="flex items-center space-x-4">
+ <Link
+ href={session.data ? "/" : "https://rybbit.io"}
+ className={cn(
+ "text-lg font-semibold flex items-center gap-1.5 opacity-75",
+ tilt_wrap.className
+ )}
+ >
+ <Image src="/rybbit.png" alt="Rybbit" width={20} height={20} />
+ rybbit.io
+ </Link>
+ </div>
+ <div className="flex items-center space-x-4">
+ <span className="text-sm text-neutral-200">
+ {METRIC_LABELS[selectedPerformanceMetric]}
+ </span>
+ <div className="flex items-center space-x-2">
+ {(["P50", "P75", "P90", "P99"] as const).map((percentile) => {
+ const colors = {
+ P50: "hsl(var(--indigo-100))", // light blue
+ P75: "hsl(var(--indigo-300))", // medium blue
+ P90: "hsl(var(--indigo-400))", // blue
+ P99: "hsl(var(--indigo-500))", // dark blue
+ };
+ const isVisible = visiblePercentiles.has(percentile);
+
+ return (
+ <button
+ key={percentile}
+ onClick={() => togglePercentile(percentile)}
+ className={cn(
+ "flex items-center space-x-1.5 px-2 py-1 rounded text-xs font-medium transition-all",
+ isVisible
+ ? "bg-neutral-800 text-white"
+ : "bg-neutral-900 text-neutral-500 hover:text-neutral-400"
+ )}
+ >
+ <div
+ className={cn(
+ "w-3 h-3 rounded-sm transition-opacity",
+ isVisible ? "opacity-100" : "opacity-30"
+ )}
+ style={{ backgroundColor: colors[percentile] }}
+ />
+ <span>{percentile}</span>
+ </button>
+ );
+ })}
+ </div>
+ </div>
+ <BucketSelection />
+ </div>
+ {isLoading ? (
+ <div className="space-y-3">
+ <Skeleton className="w-full h-[300px] rounded-md" />
+ </div>
+ ) : data.length === 0 ? (
+ <div className="h-[300px] w-full flex items-center justify-center">
+ <div className="text-center text-neutral-500">
+ <p className="text-lg font-medium">
+ No performance data available
+ </p>
+ <p className="text-sm">
+ Try adjusting your date range or filters
+ </p>
+ </div>
+ </div>
+ ) : (
+ <div className="h-[300px] w-full">
+ <ResponsiveLine
+ data={data}
+ theme={nivoTheme}
+ margin={{ top: 10, right: 20, bottom: 25, left: 40 }}
+ xScale={{
+ type: "time",
+ format: "%Y-%m-%d %H:%M:%S",
+ precision: "second",
+ useUTC: true,
+ }}
+ yScale={{
+ type: "linear",
+ min: 0,
+ stacked: false,
+ reverse: false,
+ }}
+ enableGridX={false}
+ enableGridY={true}
+ gridYValues={5}
+ axisTop={null}
+ axisRight={null}
+ axisBottom={{
+ tickSize: 0,
+ tickPadding: 10,
+ tickRotation: 0,
+ truncateTickAt: 0,
+ format: formatXAxisValue,
+ }}
+ axisLeft={{
+ tickSize: 0,
+ tickPadding: 10,
+ tickRotation: 0,
+ truncateTickAt: 0,
+ tickValues: 5,
+ format: (value) =>
+ formatMetricValue(selectedPerformanceMetric, value),
+ }}
+ colors={(d) => d.color}
+ enableTouchCrosshair={true}
+ enablePoints={false}
+ useMesh={true}
+ animate={false}
+ enableSlices="x"
+ enableArea={false}
+ markers={markers}
+ sliceTooltip={({ slice }: any) => {
+ const currentTime = DateTime.fromJSDate(
+ new Date(slice.points[0].data.x)
+ );
+
+ const formatDateTime = (dt: DateTime) => {
+ const options: Intl.DateTimeFormatOptions = {
+ month: "short",
+ day: "numeric",
+ hour: "numeric",
+ hour12: hour12,
+ };
+ if (
+ bucket === "hour" ||
+ bucket === "minute" ||
+ bucket === "five_minutes" ||
+ bucket === "ten_minutes" ||
+ bucket === "fifteen_minutes"
+ ) {
+ if (!hour12) {
+ options.minute = "numeric";
+ }
+ }
+ return new Intl.DateTimeFormat(userLocale, options).format(
+ dt.toJSDate()
+ );
+ };
+
+ return (
+ <div className="text-sm bg-neutral-900 p-3 rounded-md min-w-[150px] border border-neutral-750">
+ {formatDateTime(currentTime)}
+ <div className="space-y-2 mt-2">
+ {slice.points.map((point: any) => {
+ return (
+ <div
+ key={point.seriesId}
+ className="flex justify-between items-center"
+ >
+ <div className="flex items-center gap-2">
+ <div
+ className="w-3 h-3 rounded-full"
+ style={{ backgroundColor: point.seriesColor }}
+ />
+ <span className="text-neutral-200 font-medium">
+ {point.seriesId}
+ </span>
+ </div>
+ <span className="text-white">
+ {point.serieId}
+ {formatTooltipValue(
+ Number(point.data.yFormatted)
+ )}
+ </span>
+ </div>
+ );
+ })}
+ </div>
+ </div>
+ );
+ }}
+ />
+ </div>
+ )}
+ </CardContent>
+ </Card>
+ );
+}
diff --git a/client/src/app/[site]/performance/components/PerformanceMap.tsx b/client/src/app/[site]/performance/components/PerformanceMap.tsx
new file mode 100644
index 000000000..dbbd8600c
--- /dev/null
+++ b/client/src/app/[site]/performance/components/PerformanceMap.tsx
@@ -0,0 +1,302 @@
+"use client";
+
+import { useGetPerformanceByDimension } from "@/api/analytics/useGetPerformanceByDimension";
+import { useMeasure } from "@uidotdev/usehooks";
+import { scalePow } from "d3-scale";
+import { Feature, GeoJsonObject } from "geojson";
+import { Layer } from "leaflet";
+import "leaflet/dist/leaflet.css";
+import { useEffect, useMemo, useState } from "react";
+import { GeoJSON, MapContainer } from "react-leaflet";
+import { useCountries } from "../../../../lib/geo";
+import { addFilter } from "../../../../lib/store";
+import { CountryFlag } from "../../components/shared/icons/CountryFlag";
+import { useParams } from "next/navigation";
+import { usePerformanceStore } from "../performanceStore";
+import {
+ getPerformanceThresholds,
+ formatMetricValue,
+ getMetricUnit,
+ METRIC_LABELS_SHORT,
+} from "../utils/performanceUtils";
+
+interface TooltipContent {
+ name: string;
+ code: string;
+ eventCount: number;
+ metricValue: number | null;
+ metricName: string;
+}
+
+interface TooltipPosition {
+ x: number;
+ y: number;
+}
+
+export function PerformanceMap({ height }: { height: string }) {
+ const params = useParams();
+ const site = params.site as string;
+ const { selectedPercentile, selectedPerformanceMetric } =
+ usePerformanceStore();
+
+ const {
+ data: performanceData,
+ isLoading,
+ isFetching,
+ } = useGetPerformanceByDimension({
+ site,
+ dimension: "country",
+ limit: 1000, // Get all countries
+ useFilters: true,
+ });
+
+ const [dataVersion, setDataVersion] = useState<number>(0);
+
+ useEffect(() => {
+ if (performanceData) {
+ setDataVersion((prev) => prev + 1);
+ }
+ }, [performanceData]);
+
+ const [tooltipContent, setTooltipContent] = useState<TooltipContent | null>(
+ null
+ );
+ const [tooltipPosition, setTooltipPosition] = useState<TooltipPosition>({
+ x: 0,
+ y: 0,
+ });
+
+ // Track which feature is currently hovered to control opacity without conflicts
+ const [hoveredId, setHoveredId] = useState<string | null>(null);
+
+ // Process performance data to get the selected metric values
+ const processedPerformanceData = useMemo(() => {
+ if (!performanceData?.data) return null;
+
+ return performanceData.data.map((item: any) => {
+ // Get the metric value for the selected metric and percentile
+ const metricKey = `${selectedPerformanceMetric}_${selectedPercentile.toLowerCase()}`;
+ const metricValue = item[metricKey];
+
+ return {
+ ...item,
+ metricValue,
+ };
+ });
+ }, [performanceData?.data, selectedPercentile, selectedPerformanceMetric]);
+
+ // Create color scale from green (good) to red (poor) based on Web Vitals thresholds
+ const colorScale = useMemo(() => {
+ if (!processedPerformanceData) return () => "#eee";
+
+ const thresholds = getPerformanceThresholds(selectedPerformanceMetric);
+ if (!thresholds) return () => "#eee";
+
+ // Create a function that returns colors based on thresholds
+ // This prevents d3 from interpolating beyond our intended colors
+ return (value: number) => {
+ // Clamp the value to prevent extreme outliers
+ const clampedValue = Math.max(0, value);
+
+ if (clampedValue <= thresholds.good) {
+ return "rgba(34, 197, 94, 0.8)"; // Green for good performance
+ } else if (clampedValue <= thresholds.needs_improvement) {
+ // Interpolate between green and yellow for needs improvement
+ const ratio =
+ (clampedValue - thresholds.good) /
+ (thresholds.needs_improvement - thresholds.good);
+ const greenComponent = Math.round(34 + (251 - 34) * ratio);
+ const redComponent = Math.round(197 + (191 - 197) * ratio);
+ const blueComponent = Math.round(94 + (36 - 94) * ratio);
+ return `rgba(${greenComponent}, ${redComponent}, ${blueComponent}, 0.8)`;
+ } else {
+ return "rgba(239, 68, 68, 0.8)"; // Red for poor performance
+ }
+ };
+ }, [processedPerformanceData, selectedPerformanceMetric]);
+
+ const { data: countriesGeoData } = useCountries();
+
+ const handleStyle = (feature: Feature | undefined) => {
+ const countryCode = feature?.properties?.["ISO_A2"];
+
+ const foundData = processedPerformanceData?.find(
+ (item: any) => item.country === countryCode
+ );
+
+ const metricValue = foundData?.metricValue || 0;
+ const color =
+ foundData && metricValue > 0
+ ? colorScale(metricValue)
+ : "rgba(140, 140, 140, 0.3)";
+
+ return {
+ color: color,
+ weight: 1,
+ fill: true,
+ fillColor: color,
+ // Increase opacity if this feature is currently hovered
+ fillOpacity: hoveredId === countryCode ? 0.9 : 0.6,
+ };
+ };
+
+ const handleEachFeature = (feature: Feature, layer: Layer) => {
+ layer.on({
+ mouseover: () => {
+ const countryCode = feature.properties?.["ISO_A2"];
+ const countryName = feature.properties?.["ADMIN"];
+
+ // Mark this feature as hovered
+ setHoveredId(countryCode);
+
+ const foundData = processedPerformanceData?.find(
+ (item: any) => item.country === countryCode
+ );
+
+ if (foundData) {
+ setTooltipContent({
+ name: countryName,
+ code: countryCode,
+ eventCount: foundData.event_count,
+ metricValue: foundData.metricValue,
+ metricName: METRIC_LABELS_SHORT[selectedPerformanceMetric],
+ });
+ } else {
+ setTooltipContent({
+ name: countryName,
+ code: countryCode,
+ eventCount: 0,
+ metricValue: null,
+ metricName: METRIC_LABELS_SHORT[selectedPerformanceMetric],
+ });
+ }
+ },
+ mouseout: () => {
+ // Clear hover state
+ setHoveredId(null);
+ setTooltipContent(null);
+ },
+ click: () => {
+ const countryCode = feature.properties?.["ISO_A2"];
+
+ // Add country filter
+ addFilter({
+ parameter: "country",
+ value: [countryCode],
+ type: "equals",
+ });
+ },
+ });
+ };
+
+ const isLoadingData = isLoading || isFetching;
+
+ const [ref, { height: resolvedHeight }] = useMeasure();
+
+ const zoom = resolvedHeight ? Math.log2(resolvedHeight / 400) + 1 : 1;
+
+ return (
+ <div
+ onMouseMove={(e) => {
+ if (tooltipContent) {
+ setTooltipPosition({
+ x: e.clientX,
+ y: e.clientY,
+ });
+ }
+ }}
+ style={{
+ height: height,
+ }}
+ ref={ref}
+ >
+ {isLoadingData && (
+ <div className="absolute inset-0 bg-neutral-900/30 backdrop-blur-sm z-10 flex items-center justify-center">
+ <div className="flex flex-col items-center gap-2">
+ <div className="h-8 w-8 rounded-full border-2 border-accent-400 border-t-transparent animate-spin"></div>
+ <span className="text-sm text-neutral-300">
+ Loading performance data...
+ </span>
+ </div>
+ </div>
+ )}
+ {countriesGeoData && (
+ <MapContainer
+ preferCanvas={true}
+ attributionControl={false}
+ zoomControl={false}
+ center={[40, 3]}
+ zoom={zoom}
+ style={{
+ height: "100%",
+ background: "none",
+ cursor: "default",
+ outline: "none",
+ zIndex: "1",
+ }}
+ >
+ <GeoJSON
+ key={`performance-countries-${dataVersion}-${selectedPercentile}-${selectedPerformanceMetric}`}
+ data={countriesGeoData as GeoJsonObject}
+ style={handleStyle}
+ onEachFeature={handleEachFeature}
+ />
+ </MapContainer>
+ )}
+ {tooltipContent && (
+ <div
+ className="fixed z-50 bg-neutral-1000 text-white rounded-md p-3 shadow-lg text-sm pointer-events-none max-w-xs"
+ style={{
+ left: tooltipPosition.x,
+ top: tooltipPosition.y - 10,
+ transform: "translate(-50%, -100%)",
+ }}
+ >
+ <div className="font-sm flex items-center gap-1 mb-2">
+ {tooltipContent.code && (
+ <CountryFlag country={tooltipContent.code} />
+ )}
+ <span className="font-medium">{tooltipContent.name}</span>
+ </div>
+
+ {tooltipContent.eventCount > 0 ? (
+ <>
+ <div className="mb-2">
+ <span className="text-neutral-300">
+ {tooltipContent.metricName}:{" "}
+ </span>
+ {tooltipContent.metricValue !== null ? (
+ <span className="font-bold text-accent-400">
+ {formatMetricValue(
+ selectedPerformanceMetric,
+ tooltipContent.metricValue
+ )}
+ {getMetricUnit(
+ selectedPerformanceMetric,
+ tooltipContent.metricValue
+ )}
+ </span>
+ ) : (
+ <span className="text-neutral-400">No data</span>
+ )}
+ </div>
+
+ <div className="text-xs">
+ <div className="text-neutral-300">
+ <span className="font-bold text-accent-400">
+ {tooltipContent.eventCount.toLocaleString()}
+ </span>{" "}
+ performance events
+ </div>
+ </div>
+ </>
+ ) : (
+ <div className="text-neutral-400 text-xs">
+ No performance data available
+ </div>
+ )}
+ </div>
+ )}
+ </div>
+ );
+}
diff --git a/client/src/app/[site]/performance/components/PerformanceOverview.tsx b/client/src/app/[site]/performance/components/PerformanceOverview.tsx
new file mode 100644
index 000000000..82293bfb4
--- /dev/null
+++ b/client/src/app/[site]/performance/components/PerformanceOverview.tsx
@@ -0,0 +1,189 @@
+"use client";
+
+import { Skeleton } from "@/components/ui/skeleton";
+import { cn } from "@/lib/utils";
+import NumberFlow from "@number-flow/react";
+import { TrendingDown, TrendingUp } from "lucide-react";
+import { useGetPerformanceOverview } from "../../../../api/analytics/useGetPerformanceOverview";
+import { Card, CardContent, CardLoader } from "../../../../components/ui/card";
+import { useStore } from "../../../../lib/store";
+import { PerformanceMetric, usePerformanceStore } from "../performanceStore";
+import {
+ formatMetricValue,
+ getMetricColor,
+ getMetricUnit,
+} from "../utils/performanceUtils";
+import { PercentileSelector } from "./PercentileSelector";
+import { MetricTooltip } from "./shared/MetricTooltip";
+
+const ChangePercentage = ({
+ current,
+ previous,
+}: {
+ current: number;
+ previous: number;
+}) => {
+ const change = ((current - previous) / previous) * 100;
+
+ if (previous === 0) {
+ if (current === 0) {
+ return <div className="text-sm">0%</div>;
+ }
+ return <div className="text-sm">+999%</div>;
+ }
+
+ if (change === 0) {
+ return <div className="text-sm">0%</div>;
+ }
+
+ // For performance metrics, lower is better, so we reverse the color logic
+ return (
+ <div
+ className={cn(
+ "text-xs flex items-center gap-1",
+ change < 0 ? "text-green-400" : "text-red-400"
+ )}
+ >
+ {change > 0 ? (
+ <TrendingUp className="w-4 h-4" />
+ ) : (
+ <TrendingDown className="w-4 h-4" />
+ )}
+ {Math.abs(change).toFixed(1)}%
+ </div>
+ );
+};
+
+const Stat = ({
+ title,
+ id,
+ value,
+ previous,
+ isLoading,
+}: {
+ title: string;
+ id: PerformanceMetric;
+ value: number;
+ previous: number;
+ isLoading: boolean;
+}) => {
+ const {
+ selectedPerformanceMetric,
+ setSelectedPerformanceMetric,
+ selectedPercentile,
+ } = usePerformanceStore();
+
+ return (
+ <div
+ className={cn(
+ "flex flex-col cursor-pointer border-r border-neutral-800 last:border-r-0 text-nowrap",
+ selectedPerformanceMetric === id && "bg-neutral-850"
+ )}
+ onClick={() => setSelectedPerformanceMetric(id)}
+ >
+ <div className="flex flex-col px-3 py-2">
+ <div className="flex items-center gap-2 text-sm font-medium text-muted-foreground">
+ {title}
+ <MetricTooltip metric={id} />
+ </div>
+ <div className="text-2xl font-medium flex gap-2 items-center justify-between">
+ {isLoading ? (
+ <>
+ <Skeleton className="w-[60px] h-9 rounded-md" />
+ <Skeleton className="w-[50px] h-5 rounded-md" />
+ </>
+ ) : (
+ <>
+ <span className={getMetricColor(id, value)}>
+ <NumberFlow
+ respectMotionPreference={false}
+ value={Number(formatMetricValue(id, value))}
+ format={{ notation: "compact" }}
+ />
+ <span className="text-sm ml-1">{getMetricUnit(id, value)}</span>
+ </span>
+ <ChangePercentage current={value} previous={previous} />
+ </>
+ )}
+ </div>
+ </div>
+ </div>
+ );
+};
+
+export function PerformanceOverview() {
+ const { site } = useStore();
+ const { selectedPercentile } = usePerformanceStore();
+
+ const {
+ data: overviewData,
+ isLoading: isOverviewLoading,
+ isFetching,
+ } = useGetPerformanceOverview({ site });
+
+ const { data: overviewDataPrevious, isLoading: isOverviewLoadingPrevious } =
+ useGetPerformanceOverview({ site, periodTime: "previous" });
+
+ const isLoading = isOverviewLoading || isOverviewLoadingPrevious;
+
+ const currentData = overviewData?.data ?? {};
+ const previousData = overviewDataPrevious?.data ?? {};
+
+ // Helper function to get metric value for selected percentile
+ const getMetricValue = (data: any, metric: PerformanceMetric): number => {
+ const key = `${metric}_${selectedPercentile}`;
+ return data[key] ?? 0;
+ };
+
+ return (
+ <div className="space-y-4">
+ <div className="flex items-center justify-between">
+ <h2 className="text-lg font-semibold">Web Vitals</h2>
+ <PercentileSelector />
+ </div>
+
+ <Card>
+ <CardContent className="p-0 w-full">
+ <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-5 gap-0 items-center 0 rounded-lg overflow-hidden">
+ <Stat
+ title="Largest Contentful Paint"
+ id="lcp"
+ value={getMetricValue(currentData, "lcp")}
+ previous={getMetricValue(previousData, "lcp")}
+ isLoading={isLoading}
+ />
+ <Stat
+ title="Cumulative Layout Shift"
+ id="cls"
+ value={getMetricValue(currentData, "cls")}
+ previous={getMetricValue(previousData, "cls")}
+ isLoading={isLoading}
+ />
+ <Stat
+ title="Interaction to Next Paint"
+ id="inp"
+ value={getMetricValue(currentData, "inp")}
+ previous={getMetricValue(previousData, "inp")}
+ isLoading={isLoading}
+ />
+ <Stat
+ title="First Contentful Paint"
+ id="fcp"
+ value={getMetricValue(currentData, "fcp")}
+ previous={getMetricValue(previousData, "fcp")}
+ isLoading={isLoading}
+ />
+ <Stat
+ title="Time to First Byte"
+ id="ttfb"
+ value={getMetricValue(currentData, "ttfb")}
+ previous={getMetricValue(previousData, "ttfb")}
+ isLoading={isLoading}
+ />
+ </div>
+ </CardContent>
+ {isFetching && <CardLoader />}
+ </Card>
+ </div>
+ );
+}
diff --git a/client/src/app/[site]/performance/components/PerformanceTable.tsx b/client/src/app/[site]/performance/components/PerformanceTable.tsx
new file mode 100644
index 000000000..6e74894d4
--- /dev/null
+++ b/client/src/app/[site]/performance/components/PerformanceTable.tsx
@@ -0,0 +1,522 @@
+"use client";
+
+import { Skeleton } from "@/components/ui/skeleton";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/components/ui/table";
+import {
+ createColumnHelper,
+ flexRender,
+ getCoreRowModel,
+ getSortedRowModel,
+ SortingState,
+ useReactTable,
+} from "@tanstack/react-table";
+import {
+ ChevronDown,
+ ChevronsUpDown,
+ ChevronUp,
+ Monitor,
+ Smartphone,
+ Tablet,
+ SquareArrowOutUpRight,
+} from "lucide-react";
+import { useMemo, useState, useCallback } from "react";
+import { useGetSite } from "../../../../api/admin/sites";
+import {
+ PerformanceByDimensionItem,
+ useGetPerformanceByDimension,
+} from "../../../../api/analytics/useGetPerformanceByDimension";
+import { TablePagination } from "../../../../components/pagination";
+import {
+ useStore,
+ addFilter,
+ removeFilter,
+ FilterParameter,
+} from "../../../../lib/store";
+import { PerformanceMetric, usePerformanceStore } from "../performanceStore";
+import {
+ formatMetricValue,
+ getMetricColor,
+ getMetricUnit,
+} from "../utils/performanceUtils";
+import { CountryFlag } from "../../components/shared/icons/CountryFlag";
+import { Browser } from "../../components/shared/icons/Browser";
+import { OperatingSystem } from "../../components/shared/icons/OperatingSystem";
+import { getCountryName } from "../../../../lib/utils";
+import { MetricTooltip } from "./shared/MetricTooltip";
+import { CardLoader } from "../../../../components/ui/card";
+
+const MetricCell = ({
+ metric,
+ value,
+ percentile,
+}: {
+ metric: PerformanceMetric;
+ value: number | null | undefined;
+ percentile: string;
+}) => {
+ if (value === null || value === undefined) {
+ return <span className="text-neutral-500">-</span>;
+ }
+
+ return (
+ <span className={getMetricColor(metric, value)}>
+ {formatMetricValue(metric, value)}
+ <span className="text-xs ml-1 text-neutral-400">
+ {getMetricUnit(metric, value)}
+ </span>
+ </span>
+ );
+};
+
+const columnHelper = createColumnHelper<PerformanceByDimensionItem>();
+
+interface PerformanceTableProps {
+ dimension: string;
+ title: string;
+}
+
+// Custom hook for filter handling logic
+const useFilterToggle = () => {
+ const filters = useStore((state) => state.filters);
+
+ const toggleFilter = useCallback(
+ (parameter: FilterParameter, value: string) => {
+ const foundFilter = filters.find(
+ (f) => f.parameter === parameter && f.value.some((v) => v === value)
+ );
+ if (foundFilter) {
+ removeFilter(foundFilter);
+ } else {
+ addFilter({
+ parameter,
+ value: [value],
+ type: "equals",
+ });
+ }
+ },
+ [filters]
+ );
+
+ return toggleFilter;
+};
+
+export function PerformanceTable({ dimension, title }: PerformanceTableProps) {
+ const { site } = useStore();
+ const { data: siteMetadata } = useGetSite();
+ const { selectedPercentile } = usePerformanceStore();
+ const toggleFilter = useFilterToggle();
+ const [pagination, setPagination] = useState({
+ pageIndex: 0,
+ pageSize: 25,
+ });
+
+ const [sorting, setSorting] = useState<SortingState>([
+ { id: "event_count", desc: true },
+ ]);
+
+ const {
+ data: performanceData,
+ isLoading,
+ isFetching,
+ } = useGetPerformanceByDimension({
+ site,
+ dimension,
+ page: pagination.pageIndex + 1, // API expects 1-based page numbers
+ limit: pagination.pageSize,
+ sortBy: sorting[0]?.id || "event_count",
+ sortOrder: sorting[0]?.desc ? "desc" : "asc",
+ });
+
+ const paths = performanceData?.data ?? [];
+ const totalCount = performanceData?.totalCount ?? 0;
+ const totalPages = Math.ceil(totalCount / pagination.pageSize);
+
+ // Create columns based on selected percentile and dimension
+ const columns = useMemo(
+ () => [
+ columnHelper.accessor(dimension, {
+ header:
+ dimension === "pathname"
+ ? "Path"
+ : dimension === "country"
+ ? "Country"
+ : dimension === "device_type"
+ ? "Device Type"
+ : dimension === "browser"
+ ? "Browser"
+ : dimension === "operating_system"
+ ? "Operating System"
+ : dimension.charAt(0).toUpperCase() + dimension.slice(1),
+ cell: (info) => {
+ const value = info.getValue();
+ const displayValue =
+ value || (dimension === "pathname" ? "/" : "Unknown");
+
+ const handleClick = () => {
+ if (value) {
+ toggleFilter(dimension as FilterParameter, value);
+ }
+ };
+
+ return (
+ <div
+ className="text-white max-w-[300px] truncate flex items-center gap-2 cursor-pointer hover:underline"
+ onClick={handleClick}
+ >
+ {dimension === "country" && value ? (
+ <>
+ <CountryFlag country={value} />
+ {getCountryName(value) || value}
+ </>
+ ) : dimension === "device_type" ? (
+ <>
+ {value === "Desktop" ? (
+ <Monitor className="h-4 w-4" />
+ ) : value === "Mobile" ? (
+ <Smartphone className="h-4 w-4" />
+ ) : value === "Tablet" ? (
+ <Tablet className="h-4 w-4" />
+ ) : null}
+ {value || "Other"}
+ </>
+ ) : dimension === "browser" && value ? (
+ <>
+ <Browser browser={value} />
+ {value || "Other"}
+ </>
+ ) : dimension === "operating_system" ? (
+ <>
+ <OperatingSystem os={value || "Other"} />
+ {value || "Other"}
+ </>
+ ) : (
+ <>
+ {displayValue}
+ {dimension === "pathname" && value && (
+ <a
+ href={`https://${siteMetadata?.domain}${value}`}
+ target="_blank"
+ onClick={(e) => e.stopPropagation()}
+ >
+ <SquareArrowOutUpRight
+ className="w-3 h-3 text-neutral-300 hover:text-neutral-100"
+ strokeWidth={3}
+ />
+ </a>
+ )}
+ </>
+ )}
+ </div>
+ );
+ },
+ }),
+ columnHelper.accessor(`lcp_${selectedPercentile}`, {
+ header: () => (
+ <div className="flex items-center justify-center gap-1">
+ LCP
+ <MetricTooltip metric="lcp" />
+ </div>
+ ),
+ cell: (info) => (
+ <div className="text-center">
+ <MetricCell
+ metric="lcp"
+ value={info.getValue() as number}
+ percentile={selectedPercentile}
+ />
+ </div>
+ ),
+ }),
+ columnHelper.accessor(`cls_${selectedPercentile}`, {
+ header: () => (
+ <div className="flex items-center justify-center gap-1">
+ CLS
+ <MetricTooltip metric="cls" />
+ </div>
+ ),
+ cell: (info) => (
+ <div className="text-center">
+ <MetricCell
+ metric="cls"
+ value={info.getValue() as number}
+ percentile={selectedPercentile}
+ />
+ </div>
+ ),
+ }),
+ columnHelper.accessor(`inp_${selectedPercentile}`, {
+ header: () => (
+ <div className="flex items-center justify-center gap-1">
+ INP
+ <MetricTooltip metric="inp" />
+ </div>
+ ),
+ cell: (info) => (
+ <div className="text-center">
+ <MetricCell
+ metric="inp"
+ value={info.getValue() as number}
+ percentile={selectedPercentile}
+ />
+ </div>
+ ),
+ }),
+ columnHelper.accessor(`fcp_${selectedPercentile}`, {
+ header: () => (
+ <div className="flex items-center justify-center gap-1">
+ FCP
+ <MetricTooltip metric="fcp" />
+ </div>
+ ),
+ cell: (info) => (
+ <div className="text-center">
+ <MetricCell
+ metric="fcp"
+ value={info.getValue() as number}
+ percentile={selectedPercentile}
+ />
+ </div>
+ ),
+ }),
+ columnHelper.accessor(`ttfb_${selectedPercentile}`, {
+ header: () => (
+ <div className="flex items-center justify-center gap-1">
+ TTFB
+ <MetricTooltip metric="ttfb" />
+ </div>
+ ),
+ cell: (info) => (
+ <div className="text-center">
+ <MetricCell
+ metric="ttfb"
+ value={info.getValue() as number}
+ percentile={selectedPercentile}
+ />
+ </div>
+ ),
+ }),
+ columnHelper.accessor("event_count", {
+ header: "Events",
+ cell: (info) => (
+ <div className="text-center text-neutral-300">
+ {info.getValue()?.toLocaleString() ?? 0}
+ </div>
+ ),
+ }),
+ ],
+ [selectedPercentile]
+ );
+
+ const table = useReactTable({
+ data: paths,
+ columns,
+ getCoreRowModel: getCoreRowModel(),
+ getSortedRowModel: getSortedRowModel(),
+ onSortingChange: (updater) => {
+ setSorting(updater);
+ // Reset to first page when sorting changes
+ setPagination((prev) => ({ ...prev, pageIndex: 0 }));
+ },
+ state: {
+ sorting,
+ },
+ // Disable client-side sorting since we're doing server-side sorting
+ enableSortingRemoval: false,
+ manualSorting: true,
+ });
+
+ // Create pagination controller that matches the interface
+ const paginationController = {
+ getState: () => ({ pagination }),
+ getCanPreviousPage: () => pagination.pageIndex > 0,
+ getCanNextPage: () => pagination.pageIndex < totalPages - 1,
+ getPageCount: () => totalPages,
+ setPageIndex: (index: number) =>
+ setPagination((prev) => ({ ...prev, pageIndex: index })),
+ previousPage: () =>
+ setPagination((prev) => ({
+ ...prev,
+ pageIndex: Math.max(0, prev.pageIndex - 1),
+ })),
+ nextPage: () =>
+ setPagination((prev) => ({
+ ...prev,
+ pageIndex: Math.min(totalPages - 1, prev.pageIndex + 1),
+ })),
+ };
+
+ // Transform data to match expected format
+ const paginationData = {
+ items: paths,
+ total: totalCount,
+ };
+
+ return (
+ <>
+ {isFetching && (
+ <div className="absolute top-[-8px] left-0 w-full h-full">
+ <CardLoader />
+ </div>
+ )}
+ {isLoading ? (
+ <Table>
+ <TableHeader>
+ <TableRow className="border-neutral-800">
+ <TableHead className="text-neutral-300">
+ <Skeleton className="h-4 w-20" />
+ </TableHead>
+ <TableHead className="text-neutral-300 text-center">
+ <Skeleton className="h-4 w-8 mx-auto" />
+ </TableHead>
+ <TableHead className="text-neutral-300 text-center">
+ <Skeleton className="h-4 w-8 mx-auto" />
+ </TableHead>
+ <TableHead className="text-neutral-300 text-center">
+ <Skeleton className="h-4 w-8 mx-auto" />
+ </TableHead>
+ <TableHead className="text-neutral-300 text-center">
+ <Skeleton className="h-4 w-8 mx-auto" />
+ </TableHead>
+ <TableHead className="text-neutral-300 text-center">
+ <Skeleton className="h-4 w-10 mx-auto" />
+ </TableHead>
+ <TableHead className="text-neutral-300 text-center">
+ <Skeleton className="h-4 w-12 mx-auto" />
+ </TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {Array.from({ length: 10 }).map((_, i) => (
+ <TableRow key={i} className="border-neutral-800">
+ <TableCell>
+ <div className="flex items-center gap-2">
+ <Skeleton className="h-4 w-4 rounded" />
+ <Skeleton className="h-4 w-32" />
+ </div>
+ </TableCell>
+ <TableCell>
+ <div className="text-center">
+ <Skeleton className="h-4 w-12 mx-auto" />
+ </div>
+ </TableCell>
+ <TableCell>
+ <div className="text-center">
+ <Skeleton className="h-4 w-10 mx-auto" />
+ </div>
+ </TableCell>
+ <TableCell>
+ <div className="text-center">
+ <Skeleton className="h-4 w-12 mx-auto" />
+ </div>
+ </TableCell>
+ <TableCell>
+ <div className="text-center">
+ <Skeleton className="h-4 w-12 mx-auto" />
+ </div>
+ </TableCell>
+ <TableCell>
+ <div className="text-center">
+ <Skeleton className="h-4 w-12 mx-auto" />
+ </div>
+ </TableCell>
+ <TableCell>
+ <div className="text-center">
+ <Skeleton className="h-4 w-16 mx-auto" />
+ </div>
+ </TableCell>
+ </TableRow>
+ ))}
+ </TableBody>
+ </Table>
+ ) : (
+ <>
+ <Table>
+ <TableHeader>
+ {table.getHeaderGroups().map((headerGroup) => (
+ <TableRow key={headerGroup.id} className="border-neutral-800">
+ {headerGroup.headers.map((header) => (
+ <TableHead
+ key={header.id}
+ className={`text-neutral-300 ${
+ header.column.getCanSort()
+ ? "cursor-pointer hover:text-white transition-colors select-none"
+ : ""
+ }`}
+ onClick={header.column.getToggleSortingHandler()}
+ >
+ <div className="flex items-center justify-center gap-1">
+ {flexRender(
+ header.column.columnDef.header,
+ header.getContext()
+ )}
+ {header.column.getCanSort() && (
+ <div className="flex flex-col">
+ {header.column.getIsSorted() === "asc" ? (
+ <ChevronUp className="h-3 w-3 text-blue-400" />
+ ) : header.column.getIsSorted() === "desc" ? (
+ <ChevronDown className="h-3 w-3 text-blue-400" />
+ ) : (
+ <ChevronsUpDown className="h-3 w-3 text-neutral-600" />
+ )}
+ </div>
+ )}
+ </div>
+ </TableHead>
+ ))}
+ </TableRow>
+ ))}
+ </TableHeader>
+ <TableBody>
+ {table.getRowModel().rows.length === 0 ? (
+ <TableRow>
+ <TableCell
+ colSpan={columns.length}
+ className="text-center text-neutral-500 py-8"
+ >
+ No performance data available
+ </TableCell>
+ </TableRow>
+ ) : (
+ table.getRowModel().rows.map((row) => (
+ <TableRow
+ key={row.id}
+ className="border-neutral-800 hover:bg-neutral-900/50"
+ >
+ {row.getVisibleCells().map((cell) => (
+ <TableCell key={cell.id}>
+ {flexRender(
+ cell.column.columnDef.cell,
+ cell.getContext()
+ )}
+ </TableCell>
+ ))}
+ </TableRow>
+ ))
+ )}
+ </TableBody>
+ </Table>
+
+ {totalPages > 1 && (
+ <div className="mt-4">
+ <TablePagination
+ table={paginationController}
+ data={paginationData}
+ pagination={pagination}
+ setPagination={setPagination}
+ isLoading={isLoading}
+ itemName={dimension === "pathname" ? "paths" : dimension}
+ />
+ </div>
+ )}
+ </>
+ )}
+ </>
+ );
+}
diff --git a/client/src/app/[site]/performance/components/shared/MetricTooltip.tsx b/client/src/app/[site]/performance/components/shared/MetricTooltip.tsx
new file mode 100644
index 000000000..abd2e9882
--- /dev/null
+++ b/client/src/app/[site]/performance/components/shared/MetricTooltip.tsx
@@ -0,0 +1,102 @@
+import {
+ Tooltip,
+ TooltipContent,
+ TooltipProvider,
+ TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { HelpCircle } from "lucide-react";
+import { PerformanceMetric } from "../../performanceStore";
+
+interface MetricInfo {
+ importance: string;
+ description: string;
+ threshold: string;
+}
+
+// Metric explanations with importance and structured content
+export const getMetricInfo = (metric: PerformanceMetric): MetricInfo => {
+ switch (metric) {
+ case "lcp":
+ return {
+ importance: "Core Web Vital",
+ description:
+ "Measures loading performance. LCP marks the time when the largest content element becomes visible in the viewport.",
+ threshold: "Good LCP scores are 2.5 seconds or faster.",
+ };
+ case "cls":
+ return {
+ importance: "Core Web Vital",
+ description:
+ "Measures visual stability. CLS quantifies how much visible content shifts during page load.",
+ threshold: "Good CLS scores are 0.1 or less.",
+ };
+ case "inp":
+ return {
+ importance: "Core Web Vital",
+ description:
+ "Measures interactivity. INP assesses responsiveness by measuring the time from user interaction to the next paint.",
+ threshold: "Good INP scores are 200ms or faster.",
+ };
+ case "fcp":
+ return {
+ importance: "Supporting Metric",
+ description:
+ "Measures perceived loading speed. FCP marks when the first content element becomes visible.",
+ threshold: "Good FCP scores are 1.8 seconds or faster.",
+ };
+ case "ttfb":
+ return {
+ importance: "Supporting Metric",
+ description:
+ "Measures server response time. TTFB is the time from request start to when the first byte is received.",
+ threshold: "Good TTFB scores are 800ms or faster.",
+ };
+ default:
+ return {
+ importance: "Web Vital",
+ description: "Web Vitals metric for measuring website performance.",
+ threshold: "Check Google's Web Vitals documentation for thresholds.",
+ };
+ }
+};
+
+interface MetricTooltipProps {
+ metric: PerformanceMetric;
+ children?: React.ReactNode;
+}
+
+export function MetricTooltip({ metric, children }: MetricTooltipProps) {
+ const metricInfo = getMetricInfo(metric);
+
+ return (
+ <TooltipProvider>
+ <Tooltip>
+ <TooltipTrigger asChild>
+ {children || (
+ <HelpCircle className="h-3 w-3 text-neutral-300 hover:text-neutral-100 cursor-help" />
+ )}
+ </TooltipTrigger>
+ <TooltipContent side="top" className="max-w-xs p-3">
+ <div className="space-y-2">
+ <div className="flex items-center justify-between">
+ <span className="text-xs font-medium text-neutral-400 uppercase tracking-wide">
+ {metricInfo.importance}
+ </span>
+ {metricInfo.importance === "Core Web Vital" && (
+ <div className="w-2 h-2 bg-blue-400 rounded-full"></div>
+ )}
+ </div>
+ <p className="text-sm text-neutral-200 leading-relaxed">
+ {metricInfo.description}
+ </p>
+ <div className="pt-1 border-t border-neutral-700">
+ <p className="text-xs text-neutral-400 italic">
+ {metricInfo.threshold}
+ </p>
+ </div>
+ </div>
+ </TooltipContent>
+ </Tooltip>
+ </TooltipProvider>
+ );
+}
diff --git a/client/src/app/[site]/performance/page.tsx b/client/src/app/[site]/performance/page.tsx
new file mode 100644
index 000000000..816ac97eb
--- /dev/null
+++ b/client/src/app/[site]/performance/page.tsx
@@ -0,0 +1,20 @@
+"use client";
+
+import { SubHeader } from "../components/SubHeader/SubHeader";
+import { PerformanceChart } from "./components/PerformanceChart";
+import { PerformanceOverview } from "./components/PerformanceOverview";
+import { PerformanceByDimensions } from "./components/PerformanceByDimensions";
+
+export default function PerformancePage() {
+ return (
+ <div className="p-2 md:p-4 max-w-[1100px] mx-auto space-y-3 ">
+ <SubHeader />
+
+ <div className="space-y-4">
+ <PerformanceOverview />
+ <PerformanceChart />
+ <PerformanceByDimensions />
+ </div>
+ </div>
+ );
+}
diff --git a/client/src/app/[site]/performance/performanceStore.ts b/client/src/app/[site]/performance/performanceStore.ts
new file mode 100644
index 000000000..de2917e35
--- /dev/null
+++ b/client/src/app/[site]/performance/performanceStore.ts
@@ -0,0 +1,21 @@
+import { create } from "zustand";
+
+export type PerformanceMetric = "lcp" | "cls" | "inp" | "fcp" | "ttfb";
+
+export type PercentileLevel = "p50" | "p75" | "p90" | "p99";
+
+type PerformanceStore = {
+ selectedPercentile: PercentileLevel;
+ setSelectedPercentile: (percentile: PercentileLevel) => void;
+ selectedPerformanceMetric: PerformanceMetric;
+ setSelectedPerformanceMetric: (metric: PerformanceMetric) => void;
+};
+
+export const usePerformanceStore = create<PerformanceStore>((set) => ({
+ selectedPercentile: "p90",
+ setSelectedPercentile: (percentile) =>
+ set({ selectedPercentile: percentile }),
+ selectedPerformanceMetric: "lcp",
+ setSelectedPerformanceMetric: (metric) =>
+ set({ selectedPerformanceMetric: metric }),
+}));
diff --git a/client/src/app/[site]/performance/utils/performanceUtils.ts b/client/src/app/[site]/performance/utils/performanceUtils.ts
new file mode 100644
index 000000000..7ccd3f9a7
--- /dev/null
+++ b/client/src/app/[site]/performance/utils/performanceUtils.ts
@@ -0,0 +1,114 @@
+import { round } from "lodash";
+import { PerformanceMetric } from "../performanceStore";
+
+// Performance metric thresholds for color coding based on Web Vitals standards
+// These thresholds are consistent regardless of percentile level
+const PERFORMANCE_THRESHOLDS = {
+ lcp: { good: 2500, needs_improvement: 4000, poor: Infinity }, // Web Vitals standard
+ cls: { good: 0.1, needs_improvement: 0.25, poor: Infinity }, // Web Vitals standard
+ inp: { good: 200, needs_improvement: 500, poor: Infinity }, // Web Vitals standard
+ fcp: { good: 1800, needs_improvement: 3000, poor: Infinity }, // Web Vitals standard
+ ttfb: { good: 800, needs_improvement: 1800, poor: Infinity }, // Web Vitals standard
+} as const;
+
+/**
+ * Get the appropriate color class for a performance metric value based on Web Vitals thresholds
+ */
+export const getMetricColor = (
+ metric: PerformanceMetric,
+ value: number
+): string => {
+ const thresholds = PERFORMANCE_THRESHOLDS[metric];
+
+ if (!thresholds) {
+ return "text-white";
+ }
+
+ if (value <= thresholds.good) {
+ return "text-green-400";
+ }
+
+ if (value <= thresholds.needs_improvement) {
+ return "text-yellow-400";
+ }
+
+ // Poor performance (above needs_improvement threshold)
+ return "text-red-400";
+};
+
+/**
+ * Format a performance metric value for display
+ */
+export const formatMetricValue = (
+ metric: PerformanceMetric,
+ value: number
+): string => {
+ if (metric === "cls") {
+ return round(value, 3).toString();
+ }
+ if (value >= 1000) {
+ return round(value / 1000, 2).toString();
+ }
+ return round(value, 0).toString();
+};
+
+/**
+ * Get the appropriate unit for a performance metric value
+ */
+export const getMetricUnit = (
+ metric: PerformanceMetric,
+ value: number
+): string => {
+ if (metric === "cls") return "";
+ if (value >= 1000) return "s";
+ return "ms";
+};
+
+/**
+ * Get the chart color for a performance metric (used in charts)
+ */
+export const getMetricChartColor = (metric: PerformanceMetric): string => {
+ switch (metric) {
+ case "lcp":
+ return "#3b82f6"; // blue
+ case "cls":
+ return "#10b981"; // emerald
+ case "inp":
+ return "#f59e0b"; // amber
+ case "fcp":
+ return "#8b5cf6"; // violet
+ case "ttfb":
+ return "#ef4444"; // red
+ default:
+ return "#6b7280"; // gray
+ }
+};
+
+/**
+ * Performance metric labels for display
+ */
+export const METRIC_LABELS: Record<PerformanceMetric, string> = {
+ lcp: "Largest Contentful Paint",
+ cls: "Cumulative Layout Shift",
+ inp: "Interaction to Next Paint",
+ fcp: "First Contentful Paint",
+ ttfb: "Time to First Byte",
+};
+
+/**
+ * Short metric labels for compact display
+ */
+export const METRIC_LABELS_SHORT: Record<PerformanceMetric, string> = {
+ lcp: "LCP",
+ cls: "CLS",
+ inp: "INP",
+ fcp: "FCP",
+ ttfb: "TTFB",
+};
+
+/**
+ * Get the performance thresholds for a specific metric
+ */
+export const getPerformanceThresholds = (metric: PerformanceMetric) => {
+ return PERFORMANCE_THRESHOLDS[metric] || null;
+};
diff --git a/client/src/components/BucketSelection.tsx b/client/src/components/BucketSelection.tsx
new file mode 100644
index 000000000..80bfc3336
--- /dev/null
+++ b/client/src/components/BucketSelection.tsx
@@ -0,0 +1,156 @@
+"use client";
+
+import { useStore } from "@/lib/store";
+import {
+ SelectItem,
+ Select,
+ SelectContent,
+ SelectTrigger,
+ SelectValue,
+} from "@/components/ui/select";
+import { DateTime } from "luxon";
+import { Time } from "./DateSelector/types";
+
+const getOptions = (time: Time) => {
+ if (time.mode === "last-24-hours") {
+ return (
+ <SelectContent>
+ <SelectItem size="sm" value="minute">
+ Minute
+ </SelectItem>
+ <SelectItem size="sm" value="five_minutes">
+ 5 Minutes
+ </SelectItem>
+ <SelectItem size="sm" value="fifteen_minutes">
+ 15 Minutes
+ </SelectItem>
+ <SelectItem size="sm" value="hour">
+ Hour
+ </SelectItem>
+ </SelectContent>
+ );
+ }
+ if (time.mode === "day") {
+ return (
+ <SelectContent>
+ <SelectItem size="sm" value="minute">
+ Minute
+ </SelectItem>
+ <SelectItem size="sm" value="five_minutes">
+ 5 Minutes
+ </SelectItem>
+ <SelectItem size="sm" value="fifteen_minutes">
+ 15 Minutes
+ </SelectItem>
+ <SelectItem size="sm" value="hour">
+ Hour
+ </SelectItem>
+ </SelectContent>
+ );
+ }
+ if (time.mode === "week") {
+ return (
+ <SelectContent>
+ <SelectItem size="sm" value="fifteen_minutes">
+ 15 Minutes
+ </SelectItem>
+ <SelectItem size="sm" value="hour">
+ Hour
+ </SelectItem>
+ <SelectItem size="sm" value="day">
+ Day
+ </SelectItem>
+ </SelectContent>
+ );
+ }
+ if (time.mode === "month") {
+ return (
+ <SelectContent>
+ <SelectItem size="sm" value="hour">
+ Hour
+ </SelectItem>
+ <SelectItem size="sm" value="day">
+ Day
+ </SelectItem>
+ <SelectItem size="sm" value="week">
+ Week
+ </SelectItem>
+ </SelectContent>
+ );
+ }
+ if (time.mode === "year" || time.mode === "all-time") {
+ return (
+ <SelectContent>
+ <SelectItem size="sm" value="day">
+ Day
+ </SelectItem>
+ <SelectItem size="sm" value="week">
+ Week
+ </SelectItem>
+ <SelectItem size="sm" value="month">
+ Month
+ </SelectItem>
+ </SelectContent>
+ );
+ }
+
+ if (time.mode === "range") {
+ const timeRangeLength = DateTime.fromISO(time.endDate).diff(
+ DateTime.fromISO(time.startDate),
+ "days"
+ ).days;
+
+ return (
+ <SelectContent>
+ {timeRangeLength <= 7 && (
+ <SelectItem size="sm" value="five_minutes">
+ 5 Minutes
+ </SelectItem>
+ )}
+ {timeRangeLength <= 14 && (
+ <>
+ <SelectItem size="sm" value="ten_minutes">
+ 10 Minutes
+ </SelectItem>
+ <SelectItem size="sm" value="fifteen_minutes">
+ 15 Minutes
+ </SelectItem>
+ </>
+ )}
+ {timeRangeLength <= 30 && (
+ <SelectItem size="sm" value="hour">
+ Hour
+ </SelectItem>
+ )}
+ {timeRangeLength > 1 && (
+ <SelectItem size="sm" value="day">
+ Day
+ </SelectItem>
+ )}
+ {timeRangeLength >= 28 && (
+ <SelectItem size="sm" value="week">
+ Week
+ </SelectItem>
+ )}
+ {timeRangeLength >= 60 && (
+ <SelectItem size="sm" value="month">
+ Month
+ </SelectItem>
+ )}
+ </SelectContent>
+ );
+ }
+};
+
+export function BucketSelection() {
+ const { bucket, setBucket, time } = useStore();
+
+ return (
+ <Select value={bucket} onValueChange={setBucket}>
+ <SelectTrigger className="w-[100px]" size="sm">
+ <SelectValue />
+ </SelectTrigger>
+ {getOptions(time)}
+ </Select>
+ );
+}
diff --git a/client/src/lib/urlParams.ts b/client/src/lib/urlParams.ts
index b6f825d6f..ca6a5dbd2 100644
--- a/client/src/lib/urlParams.ts
+++ b/client/src/lib/urlParams.ts
@@ -174,7 +174,7 @@ export const useSyncStateWithUrl = () => {
if (!pathname) return false;
const pathParts = pathname.split("/");
if (pathParts.length < 3) return false;
- return ["main", "sessions", "users"].includes(pathParts[2]);
+ return ["main", "sessions", "users", "performance"].includes(pathParts[2]);
};
// Initialize from URL params after site is set
diff --git a/server/public/script-full.js b/server/public/script-full.js
index 3003d6db0..5335ca5ae 100644
--- a/server/public/script-full.js
+++ b/server/public/script-full.js
@@ -3,6 +3,27 @@
const scriptTag = document.currentScript;
const ANALYTICS_HOST = scriptTag.getAttribute("src").split("/script.js")[0];
+ // Load Web Vitals library dynamically from CDN
+ const loadWebVitals = () => {
+ return new Promise((resolve, reject) => {
+ const script = document.createElement("script");
+ script.src = "https://unpkg.com/web-vitals@3/dist/web-vitals.iife.js";
+ script.onload = () => resolve();
+ script.onerror = () =>
+ reject(new Error("Failed to load web-vitals library"));
+ document.head.appendChild(script);
+ });
+ };
+
+ // Initialize web vitals loading
+ loadWebVitals()
+ .then(() => {
+ initWebVitals();
+ })
+ .catch((e) => {
+ console.warn("Failed to load web vitals library:", e);
+ });
+
// Check if the user has opted out of tracking via localStorage
if (localStorage.getItem("disable-rybbit") !== null) {
// Create a no-op implementation to ensure the API still works
@@ -137,17 +158,8 @@
}
}
- const track = (eventType = "pageview", eventName = "", properties = {}) => {
- if (
- eventType === "custom_event" &&
- (!eventName || typeof eventName !== "string")
- ) {
- console.error(
- "Event name is required and must be a string for custom events"
- );
- return;
- }
-
+ // Helper function to create base payload with pattern matching
+ const createBasePayload = () => {
const url = new URL(window.location.href);
let pathname = url.pathname;
@@ -157,10 +169,12 @@
pathname = url.hash.substring(1);
}
+ // Check skip patterns
if (findMatchingPattern(pathname, skipPatterns)) {
- return;
+ return null; // Indicates tracking should be skipped
}
+ // Apply mask patterns
const maskMatch = findMatchingPattern(pathname, maskPatterns);
if (maskMatch) {
pathname = maskMatch;
@@ -176,12 +190,6 @@
language: navigator.language,
page_title: document.title,
referrer: document.referrer,
- type: eventType,
- event_name: eventName,
- properties:
- eventType === "custom_event" || eventType === "outbound"
- ? JSON.stringify(properties)
- : undefined,
};
// Add custom user ID only if it's set
@@ -189,6 +197,11 @@
payload.user_id = customUserId;
}
+ return payload;
+ };
+
+ // Helper function to send tracking data
+ const sendTrackingData = (payload) => {
fetch(`${ANALYTICS_HOST}/track`, {
method: "POST",
headers: {
@@ -200,6 +213,131 @@
}).catch(console.error);
};
+ const track = (eventType = "pageview", eventName = "", properties = {}) => {
+ if (
+ eventType === "custom_event" &&
+ (!eventName || typeof eventName !== "string")
+ ) {
+ console.error(
+ "Event name is required and must be a string for custom events"
+ );
+ return;
+ }
+
+ const basePayload = createBasePayload();
+ if (!basePayload) {
+ return; // Skip tracking due to pattern match
+ }
+
+ const payload = {
+ ...basePayload,
+ type: eventType,
+ event_name: eventName,
+ properties:
+ eventType === "custom_event" || eventType === "outbound"
+ ? JSON.stringify(properties)
+ : undefined,
+ };
+
+ sendTrackingData(payload);
+ };
+
+ // Web vitals collection state
+ let webVitalsData = {
+ lcp: null,
+ cls: null,
+ inp: null,
+ fcp: null,
+ ttfb: null,
+ };
+ let webVitalsSent = false;
+ let webVitalsTimeout = null;
+
+ // Check if all metrics are collected and send if ready
+ const checkAndSendWebVitals = () => {
+ if (webVitalsSent) return;
+
+ const allMetricsCollected = Object.values(webVitalsData).every(
+ (value) => value !== null
+ );
+
+ if (allMetricsCollected) {
+ sendWebVitals();
+ }
+ };
+
+ // Send web vitals data in a single request
+ const sendWebVitals = () => {
+ if (webVitalsSent) return;
+ webVitalsSent = true;
+
+ // Clear timeout if it exists
+ if (webVitalsTimeout) {
+ clearTimeout(webVitalsTimeout);
+ webVitalsTimeout = null;
+ }
+
+ const basePayload = createBasePayload();
+ if (!basePayload) {
+ return; // Skip web vitals tracking due to pattern match
+ }
+
+ const payload = {
+ ...basePayload,
+ type: "performance",
+ event_name: "web-vitals",
+ // Include all collected metrics
+ lcp: webVitalsData.lcp,
+ cls: webVitalsData.cls,
+ inp: webVitalsData.inp,
+ fcp: webVitalsData.fcp,
+ ttfb: webVitalsData.ttfb,
+ };
+
+ sendTrackingData(payload);
+ };
+
+ // Individual metric collectors
+ const collectMetric = (metric) => {
+ if (webVitalsSent) return;
+
+ webVitalsData[metric.name.toLowerCase()] = metric.value;
+ checkAndSendWebVitals();
+ };
+
+ // Initialize web vitals tracking if available
+ const initWebVitals = () => {
+ if (typeof webVitals !== "undefined") {
+ try {
+ // Track Core Web Vitals
+ webVitals.getLCP(collectMetric);
+ webVitals.getCLS(collectMetric);
+ webVitals.getINP(collectMetric);
+
+ // Track additional metrics
+ webVitals.getFCP(collectMetric);
+ webVitals.getTTFB(collectMetric);
+
+ // Set a timeout to send metrics even if not all are collected
+ // This handles cases where some metrics might not fire (e.g., no user interactions for INP)
+ webVitalsTimeout = setTimeout(() => {
+ if (!webVitalsSent) {
+ sendWebVitals();
+ }
+ }, 20000);
+
+ // Also send on page unload to capture any remaining metrics
+ window.addEventListener("beforeunload", () => {
+ if (!webVitalsSent) {
+ sendWebVitals();
+ }
+ });
+ } catch (e) {
+ console.warn("Error initializing web vitals tracking:", e);
+ }
+ }
+ };
+
const trackPageview = () => track("pageview");
const debouncedTrackPageview =
diff --git a/server/public/script.js b/server/public/script.js
index db8b4e9a1..38562a6ea 100644
--- a/server/public/script.js
+++ b/server/public/script.js
@@ -1 +1 @@
-!function(){let t=document.currentScript,e=t.getAttribute("src").split("/script.js")[0];if(null!==localStorage.getItem("disable-rybbit")){window.rybbit={pageview(){},event(){},trackOutbound(){},identify(){},clearUserId(){},getUserId:()=>null};return}if(!e){console.error("Please provide a valid analytics host");return}let r=t.getAttribute("data-site-id")||t.getAttribute("site-id");if(!r||isNaN(Number(r))){console.error("Please provide a valid site ID using the data-site-id attribute");return}let a=t.getAttribute("data-debounce")?Math.max(0,parseInt(t.getAttribute("data-debounce"))):500,i="false"!==t.getAttribute("data-auto-track-pageview"),n="false"!==t.getAttribute("data-track-spa"),s="false"!==t.getAttribute("data-track-query"),u="false"!==t.getAttribute("data-track-outbound"),l=[];try{let o=t.getAttribute("data-skip-patterns");o&&(l=JSON.parse(o),Array.isArray(l)||(l=[]))}catch(c){console.error("Error parsing data-skip-patterns:",c)}let d=[];try{let p=t.getAttribute("data-mask-patterns");p&&(d=JSON.parse(p),Array.isArray(d)||(d=[]))}catch(g){console.error("Error parsing data-mask-patterns:",g)}let h=null;try{let b=localStorage.getItem("rybbit-user-id");b&&(h=b)}catch(f){}function y(t){let e="__DOUBLE_ASTERISK_TOKEN__",r="__SINGLE_ASTERISK_TOKEN__",a=t.replace(/\*\*/g,e).replace(/\*/g,r).replace(/[.+?^${}()|[\]\\]/g,"\\$&"),i=(a=a.replace(/\//g,"\\/")).replace(RegExp(e,"g"),".*").replace(RegExp(r,"g"),"[^/]+");return RegExp("^"+i+"$")}function m(t,e){for(let r of e)try{let a=y(r);if(a.test(t))return r}catch(i){console.error(`Invalid pattern: ${r}`,i)}return null}let v=(t="pageview",a="",i={})=>{if("custom_event"===t&&(!a||"string"!=typeof a)){console.error("Event name is required and must be a string for custom events");return}let n=new URL(window.location.href),u=n.pathname;if(n.hash&&n.hash.startsWith("#/")&&(u=n.hash.substring(1)),m(u,l))return;let o=m(u,d);o&&(u=o);let c={site_id:r,hostname:n.hostname,pathname:u,querystring:s?n.search:"",screenWidth:window.innerWidth,screenHeight:window.innerHeight,language:navigator.language,page_title:document.title,referrer:document.referrer,type:t,event_name:a,properties:"custom_event"===t||"outbound"===t?JSON.stringify(i):void 0};h&&(c.user_id=h),fetch(`${e}/track`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(c),mode:"cors",keepalive:!0}).catch(console.error)},A=()=>v("pageview"),I=a>0?function t(e,r){let a;return(...t)=>{clearTimeout(a),a=setTimeout(()=>e.apply(this,t),r)}}(A,a):A;if(u&&document.addEventListener("click",function(t){let e=t.target.closest("a");e&&e.href&&function t(e){try{let r=window.location.hostname,a=new URL(e).hostname;return a!==r&&""!==a}catch(i){return!1}}(e.href)&&v("outbound","",{url:e.href,text:e.innerText||e.textContent||"",target:e.target||"_self"})}),n){let k=history.pushState,E=history.replaceState;history.pushState=function(...t){k.apply(this,t),I()},history.replaceState=function(...t){E.apply(this,t),I()},window.addEventListener("popstate",I),window.addEventListener("hashchange",I)}window.rybbit={pageview:A,event:(t,e={})=>v("custom_event",t,e),trackOutbound:(t,e="",r="_self")=>v("outbound","",{url:t,text:e,target:r}),identify(t){if("string"!=typeof t||""===t.trim()){console.error("User ID must be a non-empty string");return}h=t.trim();try{localStorage.setItem("rybbit-user-id",h)}catch(e){console.warn("Could not persist user ID to localStorage")}},clearUserId(){h=null;try{localStorage.removeItem("rybbit-user-id")}catch(t){}},getUserId:()=>h},i&&A()}();
\ No newline at end of file
+!function(){const t=document.currentScript,e=t.getAttribute("src").split("/script.js")[0];if(new Promise(((t,e)=>{const r=document.createElement("script");r.src="https://unpkg.com/web-vitals@3/dist/web-vitals.iife.js",r.onload=()=>t(),r.onerror=()=>e(new Error("Failed to load web-vitals library")),document.head.appendChild(r)})).then((()=>{_()})).catch((t=>{console.warn("Failed to load web vitals library:",t)})),null!==localStorage.getItem("disable-rybbit"))return void(window.rybbit={pageview:()=>{},event:()=>{},trackOutbound:()=>{},identify:()=>{},clearUserId:()=>{},getUserId:()=>null});if(!e)return void console.error("Please provide a valid analytics host");const r=t.getAttribute("data-site-id")||t.getAttribute("site-id");if(!r||isNaN(Number(r)))return void console.error("Please provide a valid site ID using the data-site-id attribute");const n=t.getAttribute("data-debounce")?Math.max(0,parseInt(t.getAttribute("data-debounce"))):500,a="false"!==t.getAttribute("data-auto-track-pageview"),i="false"!==t.getAttribute("data-track-spa"),o="false"!==t.getAttribute("data-track-query"),s="false"!==t.getAttribute("data-track-outbound");let l=[];try{const e=t.getAttribute("data-skip-patterns");e&&(l=JSON.parse(e),Array.isArray(l)||(l=[]))}catch(t){console.error("Error parsing data-skip-patterns:",t)}let c=[];try{const e=t.getAttribute("data-mask-patterns");e&&(c=JSON.parse(e),Array.isArray(c)||(c=[]))}catch(t){console.error("Error parsing data-mask-patterns:",t)}let u=null;try{const t=localStorage.getItem("rybbit-user-id");t&&(u=t)}catch(t){}function d(t){const e="__DOUBLE_ASTERISK_TOKEN__",r="__SINGLE_ASTERISK_TOKEN__";let n=t.replace(/\*\*/g,e).replace(/\*/g,r).replace(/[.+?^${}()|[\]\\]/g,"\\$&");n=n.replace(/\//g,"\\/");let a=n.replace(new RegExp(e,"g"),".*").replace(new RegExp(r,"g"),"[^/]+");return new RegExp("^"+a+"$")}function p(t,e){for(const r of e)try{if(d(r).test(t))return r}catch(t){console.error(`Invalid pattern: ${r}`,t)}return null}const g=()=>{const t=new URL(window.location.href);let e=t.pathname;if(t.hash&&t.hash.startsWith("#/")&&(e=t.hash.substring(1)),p(e,l))return null;const n=p(e,c);n&&(e=n);const a={site_id:r,hostname:t.hostname,pathname:e,querystring:o?t.search:"",screenWidth:window.innerWidth,screenHeight:window.innerHeight,language:navigator.language,page_title:document.title,referrer:document.referrer};return u&&(a.user_id=u),a},b=t=>{fetch(`${e}/track`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(t),mode:"cors",keepalive:!0}).catch(console.error)},f=(t="pageview",e="",r={})=>{if("custom_event"===t&&(!e||"string"!=typeof e))return void console.error("Event name is required and must be a string for custom events");const n=g();if(!n)return;const a={...n,type:t,event_name:e,properties:"custom_event"===t||"outbound"===t?JSON.stringify(r):void 0};b(a)};let h={lcp:null,cls:null,inp:null,fcp:null,ttfb:null},w=!1,m=null;const y=()=>{if(w)return;w=!0,m&&(clearTimeout(m),m=null);const t=g();if(!t)return;const e={...t,type:"performance",event_name:"web-vitals",lcp:h.lcp,cls:h.cls,inp:h.inp,fcp:h.fcp,ttfb:h.ttfb};b(e)},v=t=>{w||(h[t.name.toLowerCase()]=t.value,(()=>{if(w)return;Object.values(h).every((t=>null!==t))&&y()})())},_=()=>{if("undefined"!=typeof webVitals)try{webVitals.getLCP(v),webVitals.getCLS(v),webVitals.getINP(v),webVitals.getFCP(v),webVitals.getTTFB(v),m=setTimeout((()=>{w||y()}),2e4),window.addEventListener("beforeunload",(()=>{w||y()}))}catch(t){console.warn("Error initializing web vitals tracking:",t)}},S=()=>f("pageview"),E=n>0?function(t,e){let r;return(...n)=>{clearTimeout(r),r=setTimeout((()=>t.apply(this,n)),e)}}(S,n):S;if(s&&document.addEventListener("click",(function(t){const e=t.target.closest("a");e&&e.href&&function(t){try{const e=window.location.hostname,r=new URL(t).hostname;return r!==e&&""!==r}catch(t){return!1}}(e.href)&&f("outbound","",{url:e.href,text:e.innerText||e.textContent||"",target:e.target||"_self"})})),i){const t=history.pushState,e=history.replaceState;history.pushState=function(...e){t.apply(this,e),E()},history.replaceState=function(...t){e.apply(this,t),E()},window.addEventListener("popstate",E),window.addEventListener("hashchange",E)}window.rybbit={pageview:S,event:(t,e={})=>f("custom_event",t,e),trackOutbound:(t,e="",r="_self")=>f("outbound","",{url:t,text:e,target:r}),identify:t=>{if("string"==typeof t&&""!==t.trim()){u=t.trim();try{localStorage.setItem("rybbit-user-id",u)}catch(t){console.warn("Could not persist user ID to localStorage")}}else console.error("User ID must be a non-empty string")},clearUserId:()=>{u=null;try{localStorage.removeItem("rybbit-user-id")}catch(t){}},getUserId:()=>u},a&&S()}();
\ No newline at end of file
diff --git a/server/src/api/analytics/getPerformanceByDimension.ts b/server/src/api/analytics/getPerformanceByDimension.ts
new file mode 100644
index 000000000..03c271009
--- /dev/null
+++ b/server/src/api/analytics/getPerformanceByDimension.ts
@@ -0,0 +1,313 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import clickhouse from "../../db/clickhouse/clickhouse.js";
+import { getUserHasAccessToSitePublic } from "../../lib/auth-utils.js";
+import {
+ getFilterStatement,
+ getTimeStatement,
+ processResults,
+} from "./utils.js";
+
+interface GetPerformanceByDimensionRequest {
+ Params: {
+ site: string;
+ };
+ Querystring: {
+ startDate: string;
+ endDate: string;
+ pastMinutesStart?: number;
+ pastMinutesEnd?: number;
+ timeZone: string;
+ filters: string;
+ limit?: number;
+ page?: number;
+ sortBy?: string;
+ sortOrder?: "asc" | "desc";
+ dimension: string;
+ };
+}
+
+// Generic type for performance by dimension
+export type PerformanceByDimensionItem = {
+ [key: string]: any; // The dimension field (pathname, country, etc.)
+ event_count: number;
+ lcp_avg: number | null;
+ lcp_p50: number | null;
+ lcp_p75: number | null;
+ lcp_p90: number | null;
+ lcp_p99: number | null;
+ cls_avg: number | null;
+ cls_p50: number | null;
+ cls_p75: number | null;
+ cls_p90: number | null;
+ cls_p99: number | null;
+ inp_avg: number | null;
+ inp_p50: number | null;
+ inp_p75: number | null;
+ inp_p90: number | null;
+ inp_p99: number | null;
+ fcp_avg: number | null;
+ fcp_p50: number | null;
+ fcp_p75: number | null;
+ fcp_p90: number | null;
+ fcp_p99: number | null;
+ ttfb_avg: number | null;
+ ttfb_p50: number | null;
+ ttfb_p75: number | null;
+ ttfb_p90: number | null;
+ ttfb_p99: number | null;
+};
+
+type GetPerformanceByDimensionPaginatedResponse = {
+ data: PerformanceByDimensionItem[];
+ totalCount: number;
+};
+
+const getQuery = (
+ request: FastifyRequest<GetPerformanceByDimensionRequest>,
+ isCountQuery: boolean = false
+) => {
+ const queryParams = request.query;
+ const {
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ limit,
+ page,
+ pastMinutesStart,
+ pastMinutesEnd,
+ sortBy,
+ sortOrder,
+ dimension,
+ } = queryParams;
+
+ // Validate dimension
+ const validDimensions = [
+ "pathname",
+ "country",
+ "device_type",
+ "browser",
+ "operating_system",
+ "region",
+ ];
+
+ if (!validDimensions.includes(dimension)) {
+ throw new Error(`Invalid dimension: ${dimension}`);
+ }
+
+ const filterStatement = getFilterStatement(filters);
+
+ // Handle specific past minutes range if provided
+ const pastMinutesRange =
+ pastMinutesStart && pastMinutesEnd
+ ? { start: Number(pastMinutesStart), end: Number(pastMinutesEnd) }
+ : undefined;
+
+ const timeStatement = getTimeStatement(
+ pastMinutesRange
+ ? { pastMinutesRange }
+ : {
+ date: { startDate, endDate, timeZone },
+ }
+ );
+
+ let validatedLimit: number | null = null;
+ if (!isCountQuery && limit !== undefined) {
+ const parsedLimit = parseInt(String(limit), 10);
+ if (!isNaN(parsedLimit) && parsedLimit > 0) {
+ validatedLimit = parsedLimit;
+ }
+ }
+ const limitStatement =
+ !isCountQuery && validatedLimit
+ ? `LIMIT ${validatedLimit}`
+ : isCountQuery
+ ? ""
+ : "LIMIT 100";
+
+ let validatedOffset: number | null = null;
+ if (!isCountQuery && page !== undefined) {
+ const parsedPage = parseInt(String(page), 10);
+ if (!isNaN(parsedPage) && parsedPage >= 1) {
+ const pageOffset = (parsedPage - 1) * (validatedLimit || 100);
+ validatedOffset = pageOffset;
+ }
+ }
+ const offsetStatement =
+ !isCountQuery && validatedOffset ? `OFFSET ${validatedOffset}` : "";
+
+ // Handle sorting
+ const validSortColumns = [
+ dimension,
+ "event_count",
+ "lcp_avg",
+ "lcp_p50",
+ "lcp_p75",
+ "lcp_p90",
+ "lcp_p99",
+ "cls_avg",
+ "cls_p50",
+ "cls_p75",
+ "cls_p90",
+ "cls_p99",
+ "inp_avg",
+ "inp_p50",
+ "inp_p75",
+ "inp_p90",
+ "inp_p99",
+ "fcp_avg",
+ "fcp_p50",
+ "fcp_p75",
+ "fcp_p90",
+ "fcp_p99",
+ "ttfb_avg",
+ "ttfb_p50",
+ "ttfb_p75",
+ "ttfb_p90",
+ "ttfb_p99",
+ ];
+ const validSortBy =
+ sortBy && validSortColumns.includes(sortBy) ? sortBy : "event_count";
+ const validSortOrder = sortOrder === "asc" ? "ASC" : "DESC";
+ const orderByStatement = !isCountQuery
+ ? `ORDER BY ${validSortBy} ${validSortOrder} NULLS LAST`
+ : "";
+
+ const baseCteQuery = `
+ PerformanceStats AS (
+ SELECT
+ ${dimension},
+ COUNT(*) as event_count,
+ avgIf(lcp, lcp IS NOT NULL) as lcp_avg,
+ quantileIf(0.5)(lcp, lcp IS NOT NULL) as lcp_p50,
+ quantileIf(0.75)(lcp, lcp IS NOT NULL) as lcp_p75,
+ quantileIf(0.9)(lcp, lcp IS NOT NULL) as lcp_p90,
+ quantileIf(0.99)(lcp, lcp IS NOT NULL) as lcp_p99,
+ avgIf(cls, cls IS NOT NULL) as cls_avg,
+ quantileIf(0.5)(cls, cls IS NOT NULL) as cls_p50,
+ quantileIf(0.75)(cls, cls IS NOT NULL) as cls_p75,
+ quantileIf(0.9)(cls, cls IS NOT NULL) as cls_p90,
+ quantileIf(0.99)(cls, cls IS NOT NULL) as cls_p99,
+ avgIf(inp, inp IS NOT NULL) as inp_avg,
+ quantileIf(0.5)(inp, inp IS NOT NULL) as inp_p50,
+ quantileIf(0.75)(inp, inp IS NOT NULL) as inp_p75,
+ quantileIf(0.9)(inp, inp IS NOT NULL) as inp_p90,
+ quantileIf(0.99)(inp, inp IS NOT NULL) as inp_p99,
+ avgIf(fcp, fcp IS NOT NULL) as fcp_avg,
+ quantileIf(0.5)(fcp, fcp IS NOT NULL) as fcp_p50,
+ quantileIf(0.75)(fcp, fcp IS NOT NULL) as fcp_p75,
+ quantileIf(0.9)(fcp, fcp IS NOT NULL) as fcp_p90,
+ quantileIf(0.99)(fcp, fcp IS NOT NULL) as fcp_p99,
+ avgIf(ttfb, ttfb IS NOT NULL) as ttfb_avg,
+ quantileIf(0.5)(ttfb, ttfb IS NOT NULL) as ttfb_p50,
+ quantileIf(0.75)(ttfb, ttfb IS NOT NULL) as ttfb_p75,
+ quantileIf(0.9)(ttfb, ttfb IS NOT NULL) as ttfb_p90,
+ quantileIf(0.99)(ttfb, ttfb IS NOT NULL) as ttfb_p99
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND type = 'performance'
+ AND ${dimension} IS NOT NULL
+ AND ${dimension} <> ''
+ ${filterStatement}
+ ${timeStatement}
+ GROUP BY ${dimension}
+ )
+ `;
+
+ if (isCountQuery) {
+ return `
+ WITH ${baseCteQuery}
+ SELECT COUNT(DISTINCT ${dimension}) as totalCount FROM PerformanceStats;
+ `;
+ }
+
+ return `
+ WITH ${baseCteQuery}
+ SELECT
+ ${dimension},
+ event_count,
+ lcp_avg,
+ lcp_p50,
+ lcp_p75,
+ lcp_p90,
+ lcp_p99,
+ cls_avg,
+ cls_p50,
+ cls_p75,
+ cls_p90,
+ cls_p99,
+ inp_avg,
+ inp_p50,
+ inp_p75,
+ inp_p90,
+ inp_p99,
+ fcp_avg,
+ fcp_p50,
+ fcp_p75,
+ fcp_p90,
+ fcp_p99,
+ ttfb_avg,
+ ttfb_p50,
+ ttfb_p75,
+ ttfb_p90,
+ ttfb_p99
+ FROM PerformanceStats
+ ${orderByStatement}
+ ${limitStatement}
+ ${offsetStatement};
+ `;
+};
+
+export async function getPerformanceByDimension(
+ req: FastifyRequest<GetPerformanceByDimensionRequest>,
+ res: FastifyReply
+) {
+ const { page, dimension } = req.query;
+ const site = req.params.site;
+
+ const userHasAccessToSite = await getUserHasAccessToSitePublic(req, site);
+ if (!userHasAccessToSite) {
+ return res.status(403).send({ error: "Forbidden" });
+ }
+
+ const isPaginatedRequest = page !== undefined;
+
+ try {
+ const dataQuery = getQuery(req, false);
+ const countQuery = getQuery(req, true);
+
+ // Run both queries in parallel
+ const [dataResult, countResult] = await Promise.all([
+ clickhouse.query({
+ query: dataQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ }),
+ clickhouse.query({
+ query: countQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ }),
+ ]);
+
+ const items = await processResults<PerformanceByDimensionItem>(dataResult);
+ const countData = await processResults<{ totalCount: number }>(countResult);
+ const totalCount = countData.length > 0 ? countData[0].totalCount : 0;
+
+ return res.send({ data: { data: items, totalCount } });
+ } catch (error) {
+ console.error("Error fetching performance by dimension:", error);
+ console.error("Failed dataQuery for dimension:", dimension);
+ if (isPaginatedRequest) {
+ console.error("Failed countQuery for dimension:", dimension);
+ }
+ return res
+ .status(500)
+ .send({ error: "Failed to fetch performance by dimension" });
+ }
+}
diff --git a/server/src/api/analytics/getPerformanceByPath.ts b/server/src/api/analytics/getPerformanceByPath.ts
new file mode 100644
index 000000000..08a8b06c7
--- /dev/null
+++ b/server/src/api/analytics/getPerformanceByPath.ts
@@ -0,0 +1,267 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import clickhouse from "../../db/clickhouse/clickhouse.js";
+import { getUserHasAccessToSitePublic } from "../../lib/auth-utils.js";
+import {
+ getFilterStatement,
+ getTimeStatement,
+ processResults,
+} from "./utils.js";
+import { PerformanceByPathItem } from "./types.js";
+
+interface GetPerformanceByPathRequest {
+ Params: {
+ site: string;
+ };
+ Querystring: {
+ startDate: string;
+ endDate: string;
+ pastMinutesStart?: number;
+ pastMinutesEnd?: number;
+ timeZone: string;
+ filters: string;
+ limit?: number;
+ page?: number;
+ sortBy?: string;
+ sortOrder?: "asc" | "desc";
+ };
+}
+
+// This is the structure the API will now send
+type GetPerformanceByPathPaginatedResponse = {
+ data: PerformanceByPathItem[];
+ totalCount: number;
+};
+
+const getQuery = (
+ request: FastifyRequest<GetPerformanceByPathRequest>,
+ isCountQuery: boolean = false
+) => {
+ const {
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ limit,
+ page,
+ pastMinutesStart,
+ pastMinutesEnd,
+ sortBy,
+ sortOrder,
+ } = request.query;
+
+ const filterStatement = getFilterStatement(filters);
+
+ // Handle specific past minutes range if provided
+ const pastMinutesRange =
+ pastMinutesStart && pastMinutesEnd
+ ? { start: Number(pastMinutesStart), end: Number(pastMinutesEnd) }
+ : undefined;
+
+ const timeStatement = getTimeStatement(
+ pastMinutesRange
+ ? { pastMinutesRange }
+ : {
+ date: { startDate, endDate, timeZone },
+ }
+ );
+
+ let validatedLimit: number | null = null;
+ if (!isCountQuery && limit !== undefined) {
+ const parsedLimit = parseInt(String(limit), 10);
+ if (!isNaN(parsedLimit) && parsedLimit > 0) {
+ validatedLimit = parsedLimit;
+ }
+ }
+ const limitStatement =
+ !isCountQuery && validatedLimit
+ ? `LIMIT ${validatedLimit}`
+ : isCountQuery
+ ? ""
+ : "LIMIT 100";
+
+ let validatedOffset: number | null = null;
+ if (!isCountQuery && page !== undefined) {
+ const parsedPage = parseInt(String(page), 10);
+ if (!isNaN(parsedPage) && parsedPage >= 1) {
+ const pageOffset = (parsedPage - 1) * (validatedLimit || 100);
+ validatedOffset = pageOffset;
+ }
+ }
+ const offsetStatement =
+ !isCountQuery && validatedOffset ? `OFFSET ${validatedOffset}` : "";
+
+ // Handle sorting
+ const validSortColumns = [
+ "pathname",
+ "event_count",
+ "lcp_avg",
+ "lcp_p50",
+ "lcp_p75",
+ "lcp_p90",
+ "lcp_p99",
+ "cls_avg",
+ "cls_p50",
+ "cls_p75",
+ "cls_p90",
+ "cls_p99",
+ "inp_avg",
+ "inp_p50",
+ "inp_p75",
+ "inp_p90",
+ "inp_p99",
+ "fcp_avg",
+ "fcp_p50",
+ "fcp_p75",
+ "fcp_p90",
+ "fcp_p99",
+ "ttfb_avg",
+ "ttfb_p50",
+ "ttfb_p75",
+ "ttfb_p90",
+ "ttfb_p99",
+ ];
+ const validSortBy =
+ sortBy && validSortColumns.includes(sortBy) ? sortBy : "event_count";
+ const validSortOrder = sortOrder === "asc" ? "ASC" : "DESC";
+ const orderByStatement = !isCountQuery
+ ? `ORDER BY ${validSortBy} ${validSortOrder} NULLS LAST`
+ : "";
+
+ const baseCteQuery = `
+ PerformanceStats AS (
+ SELECT
+ pathname,
+ COUNT(*) as event_count,
+ avgIf(lcp, lcp IS NOT NULL) as lcp_avg,
+ quantileIf(0.5)(lcp, lcp IS NOT NULL) as lcp_p50,
+ quantileIf(0.75)(lcp, lcp IS NOT NULL) as lcp_p75,
+ quantileIf(0.9)(lcp, lcp IS NOT NULL) as lcp_p90,
+ quantileIf(0.99)(lcp, lcp IS NOT NULL) as lcp_p99,
+ avgIf(cls, cls IS NOT NULL) as cls_avg,
+ quantileIf(0.5)(cls, cls IS NOT NULL) as cls_p50,
+ quantileIf(0.75)(cls, cls IS NOT NULL) as cls_p75,
+ quantileIf(0.9)(cls, cls IS NOT NULL) as cls_p90,
+ quantileIf(0.99)(cls, cls IS NOT NULL) as cls_p99,
+ avgIf(inp, inp IS NOT NULL) as inp_avg,
+ quantileIf(0.5)(inp, inp IS NOT NULL) as inp_p50,
+ quantileIf(0.75)(inp, inp IS NOT NULL) as inp_p75,
+ quantileIf(0.9)(inp, inp IS NOT NULL) as inp_p90,
+ quantileIf(0.99)(inp, inp IS NOT NULL) as inp_p99,
+ avgIf(fcp, fcp IS NOT NULL) as fcp_avg,
+ quantileIf(0.5)(fcp, fcp IS NOT NULL) as fcp_p50,
+ quantileIf(0.75)(fcp, fcp IS NOT NULL) as fcp_p75,
+ quantileIf(0.9)(fcp, fcp IS NOT NULL) as fcp_p90,
+ quantileIf(0.99)(fcp, fcp IS NOT NULL) as fcp_p99,
+ avgIf(ttfb, ttfb IS NOT NULL) as ttfb_avg,
+ quantileIf(0.5)(ttfb, ttfb IS NOT NULL) as ttfb_p50,
+ quantileIf(0.75)(ttfb, ttfb IS NOT NULL) as ttfb_p75,
+ quantileIf(0.9)(ttfb, ttfb IS NOT NULL) as ttfb_p90,
+ quantileIf(0.99)(ttfb, ttfb IS NOT NULL) as ttfb_p99
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND type = 'performance'
+ AND pathname IS NOT NULL
+ AND pathname <> ''
+ ${filterStatement}
+ ${timeStatement}
+ GROUP BY pathname
+ )
+ `;
+
+ if (isCountQuery) {
+ return `
+ WITH ${baseCteQuery}
+ SELECT COUNT(DISTINCT pathname) as totalCount FROM PerformanceStats;
+ `;
+ }
+
+ return `
+ WITH ${baseCteQuery}
+ SELECT
+ pathname,
+ event_count,
+ lcp_avg,
+ lcp_p50,
+ lcp_p75,
+ lcp_p90,
+ lcp_p99,
+ cls_avg,
+ cls_p50,
+ cls_p75,
+ cls_p90,
+ cls_p99,
+ inp_avg,
+ inp_p50,
+ inp_p75,
+ inp_p90,
+ inp_p99,
+ fcp_avg,
+ fcp_p50,
+ fcp_p75,
+ fcp_p90,
+ fcp_p99,
+ ttfb_avg,
+ ttfb_p50,
+ ttfb_p75,
+ ttfb_p90,
+ ttfb_p99
+ FROM PerformanceStats
+ ${orderByStatement}
+ ${limitStatement}
+ ${offsetStatement};
+ `;
+};
+
+export async function getPerformanceByPath(
+ req: FastifyRequest<GetPerformanceByPathRequest>,
+ res: FastifyReply
+) {
+ const { page } = req.query;
+ const site = req.params.site;
+
+ const userHasAccessToSite = await getUserHasAccessToSitePublic(req, site);
+ if (!userHasAccessToSite) {
+ return res.status(403).send({ error: "Forbidden" });
+ }
+
+ const isPaginatedRequest = page !== undefined;
+
+ const dataQuery = getQuery(req, false);
+ const countQuery = getQuery(req, true);
+
+ try {
+ // Run both queries in parallel
+ const [dataResult, countResult] = await Promise.all([
+ clickhouse.query({
+ query: dataQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ }),
+ clickhouse.query({
+ query: countQuery,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ }),
+ ]);
+
+ const items = await processResults<PerformanceByPathItem>(dataResult);
+ const countData = await processResults<{ totalCount: number }>(countResult);
+ const totalCount = countData.length > 0 ? countData[0].totalCount : 0;
+
+ return res.send({ data: { data: items, totalCount } });
+ } catch (error) {
+ console.error("Error fetching performance by path:", error);
+ console.error("Failed dataQuery:", dataQuery);
+ if (isPaginatedRequest) {
+ console.error("Failed countQuery:", countQuery);
+ }
+ return res
+ .status(500)
+ .send({ error: "Failed to fetch performance by path" });
+ }
+}
diff --git a/server/src/api/analytics/getPerformanceOverview.ts b/server/src/api/analytics/getPerformanceOverview.ts
new file mode 100644
index 000000000..b7c0c65b6
--- /dev/null
+++ b/server/src/api/analytics/getPerformanceOverview.ts
@@ -0,0 +1,122 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import clickhouse from "../../db/clickhouse/clickhouse.js";
+import {
+ getFilterStatement,
+ getTimeStatement,
+ processResults,
+} from "./utils.js";
+import { getUserHasAccessToSitePublic } from "../../lib/auth-utils.js";
+import { PerformanceOverviewMetrics } from "./types.js";
+
+const getQuery = ({
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ pastMinutesRange,
+}: {
+ startDate: string;
+ endDate: string;
+ timeZone: string;
+ filters: string;
+ pastMinutesRange?: { start: number; end: number };
+}) => {
+ const timeParams = pastMinutesRange
+ ? { pastMinutesRange }
+ : { date: { startDate, endDate, timeZone } };
+
+ const filterStatement = getFilterStatement(filters);
+
+ return `SELECT
+ quantile(0.5)(lcp) AS lcp_p50,
+ quantile(0.75)(lcp) AS lcp_p75,
+ quantile(0.9)(lcp) AS lcp_p90,
+ quantile(0.99)(lcp) AS lcp_p99,
+ quantile(0.5)(cls) AS cls_p50,
+ quantile(0.75)(cls) AS cls_p75,
+ quantile(0.9)(cls) AS cls_p90,
+ quantile(0.99)(cls) AS cls_p99,
+ quantile(0.5)(inp) AS inp_p50,
+ quantile(0.75)(inp) AS inp_p75,
+ quantile(0.9)(inp) AS inp_p90,
+ quantile(0.99)(inp) AS inp_p99,
+ quantile(0.5)(fcp) AS fcp_p50,
+ quantile(0.75)(fcp) AS fcp_p75,
+ quantile(0.9)(fcp) AS fcp_p90,
+ quantile(0.99)(fcp) AS fcp_p99,
+ quantile(0.5)(ttfb) AS ttfb_p50,
+ quantile(0.75)(ttfb) AS ttfb_p75,
+ quantile(0.9)(ttfb) AS ttfb_p90,
+ quantile(0.99)(ttfb) AS ttfb_p99,
+ COUNT(*) AS total_performance_events
+ FROM events
+ WHERE
+ site_id = {siteId:Int32}
+ AND type = 'performance'
+ ${filterStatement}
+ ${getTimeStatement(timeParams)}`;
+};
+
+export interface PerformanceOverviewRequest {
+ Params: {
+ site: string;
+ };
+ Querystring: {
+ startDate: string;
+ endDate: string;
+ timeZone: string;
+ filters: string;
+ pastMinutesStart?: number;
+ pastMinutesEnd?: number;
+ };
+}
+
+export async function getPerformanceOverview(
+ req: FastifyRequest<PerformanceOverviewRequest>,
+ res: FastifyReply
+) {
+ const {
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ pastMinutesStart,
+ pastMinutesEnd,
+ } = req.query;
+ const site = req.params.site;
+ const userHasAccessToSite = await getUserHasAccessToSitePublic(req, site);
+ if (!userHasAccessToSite) {
+ return res.status(403).send({ error: "Forbidden" });
+ }
+
+ const pastMinutesRange =
+ pastMinutesStart && pastMinutesEnd
+ ? { start: Number(pastMinutesStart), end: Number(pastMinutesEnd) }
+ : undefined;
+
+ const query = getQuery({
+ startDate,
+ endDate,
+ timeZone,
+ filters,
+ pastMinutesRange: pastMinutesRange,
+ });
+
+ try {
+ const result = await clickhouse.query({
+ query,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ });
+
+ const data = await processResults<PerformanceOverviewMetrics>(result);
+ return res.send({ data: data[0] });
+ } catch (error) {
+ console.error("Error fetching performance overview:", error);
+ return res
+ .status(500)
+ .send({ error: "Failed to fetch performance overview" });
+ }
+}
diff --git a/server/src/api/analytics/getPerformanceTimeSeries.ts b/server/src/api/analytics/getPerformanceTimeSeries.ts
new file mode 100644
index 000000000..eb6e7e272
--- /dev/null
+++ b/server/src/api/analytics/getPerformanceTimeSeries.ts
@@ -0,0 +1,244 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import clickhouse from "../../db/clickhouse/clickhouse.js";
+import {
+ getFilterStatement,
+ getTimeStatement,
+ processResults,
+} from "./utils.js";
+import SqlString from "sqlstring";
+import { getUserHasAccessToSitePublic } from "../../lib/auth-utils.js";
+import { validateTimeStatementFillParams } from "./query-validation.js";
+import { TimeBucket, PerformanceTimeSeriesPoint } from "./types.js";
+
+const TimeBucketToFn = {
+ minute: "toStartOfMinute",
+ five_minutes: "toStartOfFiveMinutes",
+ ten_minutes: "toStartOfTenMinutes",
+ fifteen_minutes: "toStartOfFifteenMinutes",
+ hour: "toStartOfHour",
+ day: "toStartOfDay",
+ week: "toStartOfWeek",
+ month: "toStartOfMonth",
+ year: "toStartOfYear",
+};
+
+const bucketIntervalMap = {
+ minute: "1 MINUTE",
+ five_minutes: "5 MINUTES",
+ ten_minutes: "10 MINUTES",
+ fifteen_minutes: "15 MINUTES",
+ hour: "1 HOUR",
+ day: "1 DAY",
+ week: "7 DAY",
+ month: "1 MONTH",
+ year: "1 YEAR",
+} as const;
+
+function getTimeStatementFill(
+ {
+ date,
+ pastMinutesRange,
+ }: {
+ date?: { startDate: string; endDate: string; timeZone: string };
+ pastMinutesRange?: { start: number; end: number };
+ },
+ bucket: TimeBucket
+) {
+ const { params, bucket: validatedBucket } = validateTimeStatementFillParams(
+ { date, pastMinutesRange },
+ bucket
+ );
+
+ if (params.date) {
+ const { startDate, endDate, timeZone } = params.date;
+ return `WITH FILL FROM toTimeZone(
+ toDateTime(${
+ TimeBucketToFn[validatedBucket]
+ }(toDateTime(${SqlString.escape(startDate)}, ${SqlString.escape(
+ timeZone
+ )}))),
+ 'UTC'
+ )
+ TO if(
+ toDate(${SqlString.escape(endDate)}) = toDate(now(), ${SqlString.escape(
+ timeZone
+ )}),
+ now(),
+ toTimeZone(
+ toDateTime(${
+ TimeBucketToFn[validatedBucket]
+ }(toDateTime(${SqlString.escape(endDate)}, ${SqlString.escape(
+ timeZone
+ )}))) + INTERVAL 1 DAY,
+ 'UTC'
+ )
+ ) STEP INTERVAL ${bucketIntervalMap[validatedBucket]}`;
+ }
+ // For specific past minutes range - convert to exact timestamps for better performance
+ if (params.pastMinutesRange) {
+ const { start, end } = params.pastMinutesRange;
+
+ // Calculate exact timestamps in JavaScript to avoid runtime ClickHouse calculations
+ const now = new Date();
+ const startTimestamp = new Date(now.getTime() - start * 60 * 1000);
+ const endTimestamp = new Date(now.getTime() - end * 60 * 1000);
+
+ // Format as YYYY-MM-DD HH:MM:SS without milliseconds for ClickHouse
+ const startIso = startTimestamp
+ .toISOString()
+ .slice(0, 19)
+ .replace("T", " ");
+ const endIso = endTimestamp.toISOString().slice(0, 19).replace("T", " ");
+
+ return ` WITH FILL
+ FROM ${TimeBucketToFn[validatedBucket]}(toDateTime(${SqlString.escape(startIso)}))
+ TO ${TimeBucketToFn[validatedBucket]}(toDateTime(${SqlString.escape(endIso)})) + INTERVAL 1 ${
+ validatedBucket === "minute"
+ ? "MINUTE"
+ : validatedBucket === "five_minutes"
+ ? "MINUTE"
+ : validatedBucket === "ten_minutes"
+ ? "MINUTE"
+ : validatedBucket === "fifteen_minutes"
+ ? "MINUTE"
+ : validatedBucket === "month"
+ ? "MONTH"
+ : validatedBucket === "week"
+ ? "WEEK"
+ : validatedBucket === "day"
+ ? "DAY"
+ : "HOUR"
+ }
+ STEP INTERVAL ${bucketIntervalMap[validatedBucket]}`;
+ }
+ return "";
+}
+
+const getQuery = ({
+ startDate,
+ endDate,
+ timeZone,
+ bucket,
+ filters,
+ pastMinutesRange,
+}: {
+ startDate: string;
+ endDate: string;
+ timeZone: string;
+ bucket: TimeBucket;
+ filters: string;
+ pastMinutesRange?: { start: number; end: number };
+}) => {
+ const filterStatement = getFilterStatement(filters);
+
+ const isAllTime = !startDate && !endDate && !pastMinutesRange;
+
+ const timeParams = pastMinutesRange
+ ? { pastMinutesRange }
+ : { date: { startDate, endDate, timeZone } };
+
+ const query = `
+SELECT
+ toDateTime(${
+ TimeBucketToFn[bucket]
+ }(toTimeZone(timestamp, ${SqlString.escape(timeZone)}))) AS time,
+ quantile(0.5)(lcp) AS lcp_p50,
+ quantile(0.75)(lcp) AS lcp_p75,
+ quantile(0.9)(lcp) AS lcp_p90,
+ quantile(0.99)(lcp) AS lcp_p99,
+ quantile(0.5)(cls) AS cls_p50,
+ quantile(0.75)(cls) AS cls_p75,
+ quantile(0.9)(cls) AS cls_p90,
+ quantile(0.99)(cls) AS cls_p99,
+ quantile(0.5)(inp) AS inp_p50,
+ quantile(0.75)(inp) AS inp_p75,
+ quantile(0.9)(inp) AS inp_p90,
+ quantile(0.99)(inp) AS inp_p99,
+ quantile(0.5)(fcp) AS fcp_p50,
+ quantile(0.75)(fcp) AS fcp_p75,
+ quantile(0.9)(fcp) AS fcp_p90,
+ quantile(0.99)(fcp) AS fcp_p99,
+ quantile(0.5)(ttfb) AS ttfb_p50,
+ quantile(0.75)(ttfb) AS ttfb_p75,
+ quantile(0.9)(ttfb) AS ttfb_p90,
+ quantile(0.99)(ttfb) AS ttfb_p99,
+ COUNT(*) AS event_count
+FROM events
+WHERE
+ site_id = {siteId:Int32}
+ AND type = 'performance'
+ ${filterStatement}
+ ${getTimeStatement(timeParams)}
+GROUP BY time ORDER BY time ${
+ isAllTime ? "" : getTimeStatementFill(timeParams, bucket)
+ }`;
+
+ return query;
+};
+
+export async function getPerformanceTimeSeries(
+ req: FastifyRequest<{
+ Params: {
+ site: string;
+ };
+ Querystring: {
+ startDate: string;
+ endDate: string;
+ timeZone: string;
+ bucket: TimeBucket;
+ filters: string;
+ pastMinutesStart?: number;
+ pastMinutesEnd?: number;
+ };
+ }>,
+ res: FastifyReply
+) {
+ const {
+ startDate,
+ endDate,
+ timeZone,
+ bucket,
+ filters,
+ pastMinutesStart,
+ pastMinutesEnd,
+ } = req.query;
+ const site = req.params.site;
+
+ const userHasAccessToSite = await getUserHasAccessToSitePublic(req, site);
+ if (!userHasAccessToSite) {
+ return res.status(403).send({ error: "Forbidden" });
+ }
+
+ // Handle specific past minutes range if provided
+ const pastMinutesRange =
+ pastMinutesStart && pastMinutesEnd
+ ? { start: Number(pastMinutesStart), end: Number(pastMinutesEnd) }
+ : undefined;
+
+ const query = getQuery({
+ startDate,
+ endDate,
+ timeZone,
+ bucket,
+ filters,
+ pastMinutesRange,
+ });
+
+ try {
+ const result = await clickhouse.query({
+ query,
+ format: "JSONEachRow",
+ query_params: {
+ siteId: Number(site),
+ },
+ });
+
+ const data = await processResults<PerformanceTimeSeriesPoint>(result);
+ return res.send({ data });
+ } catch (error) {
+ console.error("Error fetching performance time series:", error);
+ return res
+ .status(500)
+ .send({ error: "Failed to fetch performance time series" });
+ }
+}
diff --git a/server/src/api/analytics/types.ts b/server/src/api/analytics/types.ts
index 4fc12ffb7..6f4e545d7 100644
--- a/server/src/api/analytics/types.ts
+++ b/server/src/api/analytics/types.ts
@@ -31,3 +31,41 @@ export type Filter = {
value: string[];
type: FilterType;
};
+
+// Performance-related types
+export type WebVitalMetric = "lcp" | "cls" | "inp" | "fcp" | "ttfb";
+
+export type PercentileLevel = "p50" | "p75" | "p90" | "p99";
+
+export type TimeBucket =
+ | "minute"
+ | "five_minutes"
+ | "ten_minutes"
+ | "fifteen_minutes"
+ | "hour"
+ | "day"
+ | "week"
+ | "month"
+ | "year";
+
+export type PerformanceOverviewMetrics = {
+ [K in WebVitalMetric as `${K}_${PercentileLevel}`]: number | null;
+} & {
+ total_performance_events: number;
+};
+
+export type PerformanceTimeSeriesPoint = {
+ time: string;
+ event_count: number;
+} & {
+ [K in WebVitalMetric as `${K}_${PercentileLevel}`]: number | null;
+};
+
+export type PerformanceByPathItem = {
+ pathname: string;
+ event_count: number;
+} & {
+ [K in WebVitalMetric as `${K}_avg`]: number | null;
+} & {
+ [K in WebVitalMetric as `${K}_${PercentileLevel}`]: number | null;
+};
diff --git a/server/src/api/analytics/utils.ts b/server/src/api/analytics/utils.ts
index 5146155fb..6bf148c7d 100644
--- a/server/src/api/analytics/utils.ts
+++ b/server/src/api/analytics/utils.ts
@@ -81,7 +81,13 @@ export async function processResults<T>(
const data: T[] = await results.json();
for (const row of data) {
for (const key in row) {
- if (!isNaN(Number(row[key])) && row[key] !== "") {
+ // Only convert to number if the value is not null/undefined and is a valid number
+ if (
+ row[key] !== null &&
+ row[key] !== undefined &&
+ row[key] !== "" &&
+ !isNaN(Number(row[key]))
+ ) {
row[key] = Number(row[key]) as any;
}
}
diff --git a/server/src/db/clickhouse/clickhouse.ts b/server/src/db/clickhouse/clickhouse.ts
index c5b2a8ddf..698d5fc36 100644
--- a/server/src/db/clickhouse/clickhouse.ts
+++ b/server/src/db/clickhouse/clickhouse.ts
@@ -46,6 +46,18 @@ export const initializeClickhouse = async () => {
`,
});
+ // Add performance metric columns if they don't exist
+ await clickhouse.exec({
+ query: `
+ ALTER TABLE events
+ ADD COLUMN IF NOT EXISTS lcp Nullable(Float64),
+ ADD COLUMN IF NOT EXISTS cls Nullable(Float64),
+ ADD COLUMN IF NOT EXISTS inp Nullable(Float64),
+ ADD COLUMN IF NOT EXISTS fcp Nullable(Float64),
+ ADD COLUMN IF NOT EXISTS ttfb Nullable(Float64)
+ `,
+ });
+
if (IS_CLOUD) {
await clickhouse.exec({
query: `
diff --git a/server/src/index.ts b/server/src/index.ts
index 647ec0c9e..22ad68a04 100644
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@ -24,6 +24,10 @@ import { getOrgEventCount } from "./api/analytics/getOrgEventCount.js";
import { getOverview } from "./api/analytics/getOverview.js";
import { getOverviewBucketed } from "./api/analytics/getOverviewBucketed.js";
import { getPageTitles } from "./api/analytics/getPageTitles.js";
+import { getPerformanceByPath } from "./api/analytics/getPerformanceByPath.js";
+import { getPerformanceByDimension } from "./api/analytics/getPerformanceByDimension.js";
+import { getPerformanceOverview } from "./api/analytics/getPerformanceOverview.js";
+import { getPerformanceTimeSeries } from "./api/analytics/getPerformanceTimeSeries.js";
import { getRetention } from "./api/analytics/getRetention.js";
import { getSession } from "./api/analytics/getSession.js";
import { getSessions } from "./api/analytics/getSessions.js";
@@ -153,6 +157,10 @@ const ANALYTICS_ROUTES = [
"/api/analytics/events/properties/",
"/api/events/",
"/api/get-site",
+ "/api/performance/overview/",
+ "/api/performance/time-series/",
+ "/api/performance/by-path/",
+ "/api/performance/by-dimension/",
];
server.addHook("onRequest", async (request, reply) => {
@@ -235,6 +243,12 @@ server.get("/api/events/names/:site", getEventNames);
server.get("/api/events/properties/:site", getEventProperties);
server.get("/api/org-event-count/:organizationId", getOrgEventCount);
+// Performance Analytics
+server.get("/api/performance/overview/:site", getPerformanceOverview);
+server.get("/api/performance/time-series/:site", getPerformanceTimeSeries);
+server.get("/api/performance/by-path/:site", getPerformanceByPath);
+server.get("/api/performance/by-dimension/:site", getPerformanceByDimension);
+
// Administrative
server.get("/api/config", getConfig);
server.post("/api/add-site", addSite);
diff --git a/server/src/tracker/pageviewQueue.ts b/server/src/tracker/pageviewQueue.ts
index 2717c0d6a..c059a6848 100644
--- a/server/src/tracker/pageviewQueue.ts
+++ b/server/src/tracker/pageviewQueue.ts
@@ -16,6 +16,12 @@ type TotalPayload = TrackingPayload & {
type?: string;
event_name?: string;
properties?: string;
+ // Performance metrics
+ lcp?: number;
+ cls?: number;
+ inp?: number;
+ fcp?: number;
+ ttfb?: number;
};
const getParsedProperties = (properties: string | undefined) => {
@@ -114,6 +120,12 @@ class PageviewQueue {
event_name: pv.event_name || "",
props: getParsedProperties(pv.properties),
url_parameters: allUrlParams,
+ // Performance metrics (only included for performance events)
+ lcp: pv.lcp || null,
+ cls: pv.cls || null,
+ inp: pv.inp || null,
+ fcp: pv.fcp || null,
+ ttfb: pv.ttfb || null,
};
});
diff --git a/server/src/tracker/trackEvent.ts b/server/src/tracker/trackEvent.ts
index f2f16eddb..5fd108a66 100644
--- a/server/src/tracker/trackEvent.ts
+++ b/server/src/tracker/trackEvent.ts
@@ -62,6 +62,27 @@ export const trackingPayloadSchema = z.discriminatedUnion("type", [
.optional(), // Optional but must be valid JSON if present
user_id: z.string().max(255).optional(),
}),
+ z.object({
+ type: z.literal("performance"),
+ site_id: z.string().min(1),
+ hostname: z.string().max(253).optional(),
+ pathname: z.string().max(2048).optional(),
+ querystring: z.string().max(2048).optional(),
+ screenWidth: z.number().int().positive().optional(),
+ screenHeight: z.number().int().positive().optional(),
+ language: z.string().max(35).optional(),
+ page_title: z.string().max(512).optional(),
+ referrer: z.string().max(2048).optional(),
+ event_name: z.string().max(256).optional(),
+ properties: z.string().max(2048).optional(),
+ user_id: z.string().max(255).optional(),
+ // Performance metrics (can be null if not collected)
+ lcp: z.number().positive().nullable().optional(),
+ cls: z.number().min(0).nullable().optional(),
+ inp: z.number().positive().nullable().optional(),
+ fcp: z.number().positive().nullable().optional(),
+ ttfb: z.number().positive().nullable().optional(),
+ }),
]);
// Update session for both pageviews and events
diff --git a/server/src/tracker/trackingUtils.ts b/server/src/tracker/trackingUtils.ts
index 8d9d57fb6..5489fe1dd 100644
--- a/server/src/tracker/trackingUtils.ts
+++ b/server/src/tracker/trackingUtils.ts
@@ -118,7 +118,7 @@ export async function getExistingSession(userId: string, siteId: string) {
// Create base tracking payload from request
export function createBasePayload(
request: FastifyRequest,
- eventType: "pageview" | "custom_event" = "pageview",
+ eventType: "pageview" | "custom_event" | "performance" = "pageview",
validatedBody: ValidatedTrackingPayload
): TotalTrackingPayload {
const userAgent = request.headers["user-agent"] || "";