🐸 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.jsonindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxindex 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" />}+ />+ )}<SidebarLinklabel="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.tsxindex 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_minutesconst displayDashed = formattedData.length >= 2 && !shouldNotDisplay;const baseGradient = {@@ -245,13 +252,21 @@ export function Chart({return series.map(({ id, data, color }) => (<pathkey={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.tsxindex 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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 setdiff --git a/server/public/script-full.js b/server/public/script-full.jsindex 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 localStorageif (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 patternsif (findMatchingPattern(pathname, skipPatterns)) {- return;+ return null; // Indicates tracking should be skipped}+ // Apply mask patternsconst 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.jsindex 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 filediff --git a/server/src/api/analytics/getPerformanceByDimension.ts b/server/src/api/analytics/getPerformanceByDimension.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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);+// Administrativeserver.get("/api/config", getConfig);server.post("/api/add-site", addSite);diff --git a/server/src/tracker/pageviewQueue.ts b/server/src/tracker/pageviewQueue.tsindex 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.tsindex 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 presentuser_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 eventsdiff --git a/server/src/tracker/trackingUtils.ts b/server/src/tracker/trackingUtils.tsindex 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 requestexport function createBasePayload(request: FastifyRequest,- eventType: "pageview" | "custom_event" = "pageview",+ eventType: "pageview" | "custom_event" | "performance" = "pageview",validatedBody: ValidatedTrackingPayload): TotalTrackingPayload {const userAgent = request.headers["user-agent"] || "";