Skip to content

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

refactor(analytics): integrate session filtering into analytics queries

Bill Yang1404cb1c0459
diff --git a/server/src/api/analytics/events/getAutocaptureEvents.ts b/server/src/api/analytics/events/getAutocaptureEvents.ts
index c7ff85b88..a29ef6562 100644
--- a/server/src/api/analytics/events/getAutocaptureEvents.ts
+++ b/server/src/api/analytics/events/getAutocaptureEvents.ts
@@ -41,7 +41,9 @@ export const buildAutocaptureEventsQuery = (
const { filters } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = filters ? getFilterStatement(filters, siteId, timeStatement) : "";
+ const filterStatement = filters
+ ? getFilterStatement(filters, siteId, timeStatement, { sessionLevelParams: ["channel"] })
+ : "";
const valueExpression = VALUE_EXPRESSIONS[type];
return `
diff --git a/server/src/api/analytics/events/getAutocaptureValues.ts b/server/src/api/analytics/events/getAutocaptureValues.ts
index a5ae3cd5a..af20df6e9 100644
--- a/server/src/api/analytics/events/getAutocaptureValues.ts
+++ b/server/src/api/analytics/events/getAutocaptureValues.ts
@@ -28,7 +28,9 @@ export const buildAutocaptureValuesQuery = (
const { filters } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = filters ? getFilterStatement(filters, siteId, timeStatement) : "";
+ const filterStatement = filters
+ ? getFilterStatement(filters, siteId, timeStatement, { sessionLevelParams: ["channel"] })
+ : "";
const propExtracts = AUTOCAPTURE_PATTERN_PROPS[type]
.map(prop => `JSONExtractString(toString(props), ${SqlString.escape(prop)})`)
diff --git a/server/src/api/analytics/events/getEventBucketed.ts b/server/src/api/analytics/events/getEventBucketed.ts
index ecfe93679..9e5edfda5 100644
--- a/server/src/api/analytics/events/getEventBucketed.ts
+++ b/server/src/api/analytics/events/getEventBucketed.ts
@@ -33,7 +33,9 @@ export const buildEventBucketedQuery = (query: GetEventBucketedRequest["Querystr
const { bucket = "hour" } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filterStatement = getFilterStatement(query.filters, siteId, timeStatement, {
+ sessionLevelParams: ["channel"],
+ });
return `
WITH top_events AS (
diff --git a/server/src/api/analytics/events/getEventNames.ts b/server/src/api/analytics/events/getEventNames.ts
index f87126e93..8f41ab319 100644
--- a/server/src/api/analytics/events/getEventNames.ts
+++ b/server/src/api/analytics/events/getEventNames.ts
@@ -23,7 +23,9 @@ export const buildEventNamesQuery = (query: GetEventNamesRequest["Querystring"],
const timeStatement = getTimeStatement(query);
- const filterStatement = filters ? getFilterStatement(filters, siteId, timeStatement) : "";
+ const filterStatement = filters
+ ? getFilterStatement(filters, siteId, timeStatement, { sessionLevelParams: ["channel"] })
+ : "";
return `
SELECT
diff --git a/server/src/api/analytics/events/getEventProperties.ts b/server/src/api/analytics/events/getEventProperties.ts
index 129546a06..c4f4b5973 100644
--- a/server/src/api/analytics/events/getEventProperties.ts
+++ b/server/src/api/analytics/events/getEventProperties.ts
@@ -24,7 +24,9 @@ export const buildEventPropertiesQuery = (query: GetEventPropertiesRequest["Quer
const timeStatement = getTimeStatement(query);
- const filterStatement = filters ? getFilterStatement(filters, siteId, timeStatement) : "";
+ const filterStatement = filters
+ ? getFilterStatement(filters, siteId, timeStatement, { sessionLevelParams: ["channel"] })
+ : "";
return `
SELECT
diff --git a/server/src/api/analytics/events/getEvents.test.ts b/server/src/api/analytics/events/getEvents.test.ts
index 84f3dbac0..376dc77c5 100644
--- a/server/src/api/analytics/events/getEvents.test.ts
+++ b/server/src/api/analytics/events/getEvents.test.ts
@@ -8,6 +8,13 @@ vi.mock("../../../db/postgres/postgres.js", () => ({
}));
import { buildEventsQuery } from "./getEvents.js";
+import { buildEventBucketedQuery } from "./getEventBucketed.js";
+import { buildEventNamesQuery } from "./getEventNames.js";
+import { buildSiteEventCountQuery } from "./getSiteEventCount.js";
+import { buildEventPropertiesQuery } from "./getEventProperties.js";
+import { buildAutocaptureEventsQuery } from "./getAutocaptureEvents.js";
+import { buildAutocaptureValuesQuery } from "./getAutocaptureValues.js";
+import { buildOutboundLinksQuery } from "./getOutboundLinks.js";
const SITE_ID = 1;
@@ -45,3 +52,47 @@ describe("buildEventsQuery filters", () => {
expect(params).toEqual({ siteId: SITE_ID, limit: 50 });
});
});
+
+describe("event summary filter consistency", () => {
+ const eventNameFilter = JSON.stringify([{ parameter: "event_name", type: "equals", value: ["signup"] }]);
+
+ it.each([
+ ["names", () => buildEventNamesQuery({ ...baseQuery({ filters: eventNameFilter }), event_name: "" }, SITE_ID)],
+ [
+ "time series",
+ () => buildEventBucketedQuery({ ...baseQuery({ filters: eventNameFilter }), bucket: "day" }, SITE_ID),
+ ],
+ [
+ "site count",
+ () => buildSiteEventCountQuery({ ...baseQuery({ filters: eventNameFilter }), bucket: "day" }, SITE_ID),
+ ],
+ [
+ "properties",
+ () => buildEventPropertiesQuery({ ...baseQuery({ filters: eventNameFilter }), event_name: "signup" }, SITE_ID),
+ ],
+ [
+ "autocapture",
+ () =>
+ buildAutocaptureEventsQuery(
+ { ...baseQuery({ filters: eventNameFilter }), type: "form_submit" },
+ SITE_ID,
+ "form_submit"
+ ),
+ ],
+ [
+ "autocapture values",
+ () =>
+ buildAutocaptureValuesQuery(
+ { ...baseQuery({ filters: eventNameFilter }), type: "form_submit" },
+ SITE_ID,
+ "form_submit"
+ ),
+ ],
+ ["outbound", () => buildOutboundLinksQuery(baseQuery({ filters: eventNameFilter }), SITE_ID)],
+ ])("keeps event_name row-scoped in the %s query", (_name, buildQuery) => {
+ const query = buildQuery();
+
+ expect(query).toContain("AND event_name = 'signup'");
+ expect(query).not.toContain("SELECT DISTINCT session_id");
+ });
+});
diff --git a/server/src/api/analytics/events/getOutboundLinks.ts b/server/src/api/analytics/events/getOutboundLinks.ts
index 3c8413b98..598118237 100644
--- a/server/src/api/analytics/events/getOutboundLinks.ts
+++ b/server/src/api/analytics/events/getOutboundLinks.ts
@@ -21,7 +21,9 @@ export const buildOutboundLinksQuery = (query: GetOutboundLinksRequest["Querystr
const { filters } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = filters ? getFilterStatement(filters, siteId, timeStatement) : "";
+ const filterStatement = filters
+ ? getFilterStatement(filters, siteId, timeStatement, { sessionLevelParams: ["channel"] })
+ : "";
return `
SELECT
diff --git a/server/src/api/analytics/events/getSiteEventCount.ts b/server/src/api/analytics/events/getSiteEventCount.ts
index 9a3a2c3d8..74b417e6d 100644
--- a/server/src/api/analytics/events/getSiteEventCount.ts
+++ b/server/src/api/analytics/events/getSiteEventCount.ts
@@ -32,7 +32,9 @@ export const buildSiteEventCountQuery = (query: GetSiteEventCountRequest["Querys
const { bucket = "day" } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filterStatement = getFilterStatement(query.filters, siteId, timeStatement, {
+ sessionLevelParams: ["channel"],
+ });
return `
SELECT
diff --git a/server/src/api/analytics/funnels/funnelQueries.test.ts b/server/src/api/analytics/funnels/funnelQueries.test.ts
new file mode 100644
index 000000000..9a22b624d
--- /dev/null
+++ b/server/src/api/analytics/funnels/funnelQueries.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+vi.mock("../../../db/postgres/postgres.js", () => ({
+ db: {},
+}));
+
+import { buildFunnelQuery } from "./getFunnel.js";
+import { buildFunnelStepSessionsQuery } from "./getFunnelStepSessions.js";
+import { FunnelStep } from "./funnelSteps.js";
+
+const CAMPAIGN_FILTER = JSON.stringify([{ parameter: "utm_campaign", type: "equals", value: ["launch"] }]);
+
+const query = {
+ filters: CAMPAIGN_FILTER,
+ start_date: "",
+ end_date: "",
+ time_zone: "UTC",
+};
+
+const steps: FunnelStep[] = [
+ { type: "page", value: "/pricing" },
+ { type: "event", value: "signup" },
+];
+
+const getSessionActions = (sql: string) => {
+ const match = sql.match(/SessionActions AS \(([\s\S]*?)\n\s*\),/);
+ expect(match).not.toBeNull();
+ return match?.[1] ?? "";
+};
+
+describe("funnel queries with global session filters", () => {
+ it("qualifies the session by its landing campaign without removing later funnel-step events", () => {
+ const sql = buildFunnelQuery(query, 1, steps);
+ const sessionActions = getSessionActions(sql);
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("argMin(url_parameters, timestamp)['utm_campaign'] AS utm_campaign");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'launch'");
+ expect(sessionActions).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sessionActions).not.toContain("url_parameters['utm_campaign'] = 'launch'");
+ expect(sessionActions).toContain("pathname");
+ expect(sessionActions).toContain("event_name");
+ });
+
+ it("uses the same campaign-qualified full session for reached-session drilldown", () => {
+ const sql = buildFunnelStepSessionsQuery({ ...query, mode: "reached", page: 1, limit: 25 }, 1, steps, 2);
+ const sessionActions = getSessionActions(sql);
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'launch'");
+ expect(sessionActions).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sessionActions).not.toContain("url_parameters['utm_campaign'] = 'launch'");
+ expect(sql).toContain("FROM Step2");
+ });
+
+ it("does not misclassify a later untagged conversion as a filtered-session dropoff", () => {
+ const sql = buildFunnelStepSessionsQuery({ ...query, mode: "dropped", page: 1, limit: 25 }, 1, steps, 1);
+ const sessionActions = getSessionActions(sql);
+
+ expect(sessionActions).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sessionActions).not.toContain("url_parameters['utm_campaign'] = 'launch'");
+ expect(sql).toContain("FROM Step1");
+ expect(sql).toContain("FROM Step2");
+ });
+
+ it("returns the same canonical attribution fields used by session filtering", () => {
+ const sql = buildFunnelStepSessionsQuery({ ...query, mode: "reached", page: 1, limit: 25 }, 1, steps, 2);
+
+ expect(sql).toContain("argMinIf(referrer, timestamp, referrer != '') AS referrer");
+ expect(sql).toContain("channel NOT IN ('Direct', 'Internal', '')");
+ expect(sql).not.toContain("argMin(e.referrer, e.timestamp) AS referrer");
+ expect(sql).not.toContain("argMin(e.channel, e.timestamp) AS channel");
+ });
+});
diff --git a/server/src/api/analytics/funnels/getFunnel.ts b/server/src/api/analytics/funnels/getFunnel.ts
index aac47d652..c9156ea66 100644
--- a/server/src/api/analytics/funnels/getFunnel.ts
+++ b/server/src/api/analytics/funnels/getFunnel.ts
@@ -2,8 +2,8 @@ import { FilterParams } from "@rybbit/shared";
import { FastifyReply, FastifyRequest } from "fastify";
import SqlString from "sqlstring";
import { getTimeStatement } from "../utils/timeWindow.js";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { AnalyticsQueryError, runAnalyticsQuery } from "../utils/analyticsQuery.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { buildFunnelStepCondition, FunnelStep } from "./funnelSteps.js";
type Funnel = {
@@ -21,7 +21,7 @@ type FunnelResponse = {
export const buildFunnelQuery = (query: FilterParams<{}>, siteId: number, steps: FunnelStep[]) => {
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
// Build conditional statements for each step
const stepConditions = steps.map(step => buildFunnelStepCondition(step));
@@ -29,6 +29,7 @@ export const buildFunnelQuery = (query: FilterParams<{}>, siteId: number, steps:
// Build the funnel query - session-based tracking
return `
WITH
+ ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
-- Get all session actions in the time period
SessionActions AS (
SELECT
@@ -41,10 +42,10 @@ export const buildFunnelQuery = (query: FilterParams<{}>, siteId: number, steps:
hostname,
url_parameters
FROM events
+ ${filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : ""}
WHERE
site_id = {siteId:Int32}
${timeStatement}
- ${filterStatement}
),
-- Initial step (all sessions who completed step 1)
Step1 AS (
diff --git a/server/src/api/analytics/funnels/getFunnelStepSessions.ts b/server/src/api/analytics/funnels/getFunnelStepSessions.ts
index 285b9dfdd..2612d1117 100644
--- a/server/src/api/analytics/funnels/getFunnelStepSessions.ts
+++ b/server/src/api/analytics/funnels/getFunnelStepSessions.ts
@@ -3,8 +3,9 @@ import { FastifyReply, FastifyRequest } from "fastify";
import { enrichWithTraits } from "../utils/utils.js";
import { getTimeStatement } from "../utils/timeWindow.js";
import { GetSessionsResponse } from "../sessions/getSessions.js";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
+import { SESSION_CHANNEL_AGG, SESSION_REFERRER_AGG } from "../utils/sessionAttribution.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { buildFunnelStepCondition, FunnelStep } from "./funnelSteps.js";
type Funnel = {
@@ -32,12 +33,7 @@ export const buildFunnelStepSessionsQuery = (
) => {
const { mode } = query;
const timeStatement = getTimeStatement(query);
-
- // Applied once, in the SessionActions CTE against raw events (same as the
- // funnel analyze endpoint), where every filter parameter's column exists.
- // Re-applying it to the aggregated outer query breaks on parameters the
- // aggregate doesn't project (utm_*, pathname, timezone → unknown identifier).
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
// Build conditional statements for each step we need
const stepsToCheck = mode === "reached" ? stepNumber : stepNumber + 1;
@@ -46,6 +42,7 @@ export const buildFunnelStepSessionsQuery = (
// Build CTEs for each funnel step to identify qualifying sessions
const stepCTEs = [
`
+ ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
SessionActions AS (
SELECT
session_id,
@@ -58,10 +55,10 @@ export const buildFunnelStepSessionsQuery = (
url_parameters,
tag
FROM events
+ ${filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : ""}
WHERE
site_id = {siteId:Int32}
${timeStatement}
- ${filterStatement}
),
Step1 AS (
SELECT DISTINCT
@@ -134,8 +131,8 @@ export const buildFunnelStepSessionsQuery = (
argMax(e.operating_system_version, e.timestamp) AS operating_system_version,
argMax(e.screen_width, e.timestamp) AS screen_width,
argMax(e.screen_height, e.timestamp) AS screen_height,
- argMin(e.referrer, e.timestamp) AS referrer,
- argMin(e.channel, e.timestamp) AS channel,
+ ${SESSION_REFERRER_AGG} AS referrer,
+ ${SESSION_CHANNEL_AGG} AS channel,
argMin(e.hostname, e.timestamp) AS hostname,
argMin(e.page_title, e.timestamp) AS page_title,
argMin(e.querystring, e.timestamp) AS querystring,
diff --git a/server/src/api/analytics/getErrorBucketed.ts b/server/src/api/analytics/getErrorBucketed.ts
index b5577c257..3ab2bf5d8 100644
--- a/server/src/api/analytics/getErrorBucketed.ts
+++ b/server/src/api/analytics/getErrorBucketed.ts
@@ -2,8 +2,8 @@ import { FilterParams } from "@rybbit/shared";
import { FastifyReply, FastifyRequest } from "fastify";
import { resolveTimeWindow } from "./utils/timeWindow.js";
import { TimeBucket } from "./types.js";
-import { getFilterStatement } from "./utils/getFilterStatement.js";
import { AnalyticsQueryError, runAnalyticsQuery } from "./utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments, TARGET_EVENT_ROW_LEVEL_PARAMS } from "./utils/sessionFilters.js";
interface GetErrorBucketedRequest {
Params: {
@@ -24,19 +24,27 @@ export const buildErrorBucketedQuery = (query: GetErrorBucketedRequest["Querystr
const { bucket } = query;
const window = resolveTimeWindow(query);
const timeStatement = window.where();
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ query.filters,
+ siteId,
+ timeStatement,
+ TARGET_EVENT_ROW_LEVEL_PARAMS
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
const timeStatementFill = window.fill(bucket);
return `
+ ${filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : ""}
SELECT
${window.bucketed("timestamp", bucket)} AS time,
COUNT(*) AS error_count
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'error'
AND JSONExtractString(toString(props), 'message') = {errorMessage:String}
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
GROUP BY time
ORDER BY time
diff --git a/server/src/api/analytics/getErrorEvents.ts b/server/src/api/analytics/getErrorEvents.ts
index 571076255..4b61a1352 100644
--- a/server/src/api/analytics/getErrorEvents.ts
+++ b/server/src/api/analytics/getErrorEvents.ts
@@ -1,8 +1,13 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { getTimeStatement } from "./utils/timeWindow.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "./utils/getFilterStatement.js";
-import { analyticsRoute, getPaginationStatements, runAnalyticsQuery, runPaginatedQuery } from "./utils/analyticsQuery.js";
+import {
+ analyticsRoute,
+ getPaginationStatements,
+ runAnalyticsQuery,
+ runPaginatedQuery,
+} from "./utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments, TARGET_EVENT_ROW_LEVEL_PARAMS } from "./utils/sessionFilters.js";
interface GetErrorEventsRequest {
Params: {
@@ -54,25 +59,34 @@ export const buildErrorEventsQuery = (
const { filters } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ filters,
+ siteId,
+ timeStatement,
+ TARGET_EVENT_ROW_LEVEL_PARAMS
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
// Default to 20 for error events
const { limitStatement, offsetStatement } = getPaginationStatements(query, 20, isCountQuery);
if (isCountQuery) {
return `
+ ${filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : ""}
SELECT COUNT(*) as totalCount
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'error'
AND JSONExtractString(toString(props), 'message') = {errorMessage:String}
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
`;
}
return `
+ ${filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : ""}
SELECT
timestamp,
session_id,
@@ -106,11 +120,12 @@ export const buildErrorEventsQuery = (
ELSE NULL
END as columnNumber
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'error'
AND JSONExtractString(toString(props), 'message') = {errorMessage:String}
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
ORDER BY timestamp DESC
${limitStatement}
diff --git a/server/src/api/analytics/getErrorNames.ts b/server/src/api/analytics/getErrorNames.ts
index 4158daa85..fda464c4b 100644
--- a/server/src/api/analytics/getErrorNames.ts
+++ b/server/src/api/analytics/getErrorNames.ts
@@ -1,8 +1,13 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { getTimeStatement } from "./utils/timeWindow.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "./utils/getFilterStatement.js";
-import { analyticsRoute, getPaginationStatements, runAnalyticsQuery, runPaginatedQuery } from "./utils/analyticsQuery.js";
+import {
+ analyticsRoute,
+ getPaginationStatements,
+ runAnalyticsQuery,
+ runPaginatedQuery,
+} from "./utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments, TARGET_EVENT_ROW_LEVEL_PARAMS } from "./utils/sessionFilters.js";
interface GetErrorNamesRequest {
Params: {
@@ -37,7 +42,13 @@ export const buildErrorNamesQuery = (
const { filters } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ filters,
+ siteId,
+ timeStatement,
+ TARGET_EVENT_ROW_LEVEL_PARAMS
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
// Default to 10 for non-paginated use
const { limitStatement, offsetStatement } = getPaginationStatements(query, 10, isCountQuery);
@@ -52,6 +63,7 @@ export const buildErrorNamesQuery = (
count(*) as total_occurrences,
count(DISTINCT session_id) as unique_sessions
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'error'
@@ -59,7 +71,7 @@ export const buildErrorNamesQuery = (
AND event_name <> ''
AND JSONHas(toString(props), 'message')
AND JSONExtractString(toString(props), 'message') <> ''
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
GROUP BY value
)
@@ -67,13 +79,13 @@ export const buildErrorNamesQuery = (
if (isCountQuery) {
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT COUNT(*) as totalCount FROM ErrorStats;
`;
}
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT
value,
errorName,
diff --git a/server/src/api/analytics/getJourneys.test.ts b/server/src/api/analytics/getJourneys.test.ts
new file mode 100644
index 000000000..f6f31fb88
--- /dev/null
+++ b/server/src/api/analytics/getJourneys.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+
+import { buildJourneysQuery } from "./getJourneys.js";
+
+const baseQuery = (filters: string) => ({
+ filters,
+ start_date: "",
+ end_date: "",
+ time_zone: "UTC",
+});
+
+const filter = (parameter: string, value: string) => ({ parameter, type: "equals", value: [value] });
+
+describe("buildJourneysQuery session-scoped filters", () => {
+ it("keeps later journey pageviews when the referrer exists only on the acquisition row", () => {
+ const sql = buildJourneysQuery(baseQuery(JSON.stringify([filter("referrer", "google.com")])), 1, {});
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("argMinIf(referrer, timestamp, referrer != '') AS referrer");
+ expect(sql).toContain("WHERE 1 = 1 AND domainWithoutWWW(referrer) = 'google.com'");
+ expect(sql).toContain("FROM events\n INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql).toContain("AND type = 'pageview'");
+ expect(sql).toContain("SELECT count() FROM FilteredSessions");
+ expect(sql.match(/domainWithoutWWW\(referrer\) = 'google\.com'/g)).toHaveLength(1);
+ });
+
+ it("allows campaign and a later pathname to qualify on different rows", () => {
+ const filters = JSON.stringify([filter("utm_campaign", "recipe_book_2026"), filter("pathname", "/thank-you")]);
+ const sql = buildJourneysQuery(baseQuery(filters), 1, {});
+
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("SELECT DISTINCT session_id\n FROM events");
+ expect(sql).toContain("AND pathname = '/thank-you'");
+ expect(sql.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ expect(sql.match(/pathname = '\/thank-you'/g)).toHaveLength(1);
+ });
+});
diff --git a/server/src/api/analytics/getJourneys.ts b/server/src/api/analytics/getJourneys.ts
index 18e72a9e8..994184dbe 100644
--- a/server/src/api/analytics/getJourneys.ts
+++ b/server/src/api/analytics/getJourneys.ts
@@ -2,7 +2,7 @@ import { FilterParams } from "@rybbit/shared";
import { FastifyReply, FastifyRequest } from "fastify";
import SqlString from "sqlstring";
import { z } from "zod";
-import { getFilterStatement } from "./utils/getFilterStatement.js";
+import { buildFilteredSessionsCTE } from "./utils/sessionFilters.js";
import { patternToRegex } from "./utils/utils.js";
import { getTimeStatement } from "./utils/timeWindow.js";
import { AnalyticsQueryError, runAnalyticsQuery } from "./utils/analyticsQuery.js";
@@ -37,7 +37,8 @@ export const buildJourneysQuery = (
) => {
// Time conditions using getTimeStatement
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
+ const filteredSessionsJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
// Build step filter conditions for the HAVING clause
// Supports wildcard patterns: * matches single segment, ** matches multiple segments
@@ -57,7 +58,8 @@ export const buildJourneysQuery = (
// Query to find sequences of events (journeys) for each user
return `
- WITH user_paths AS (
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+ user_paths AS (
SELECT
session_id,
arrayCompact(groupArray(pathname)) AS path_sequence
@@ -67,10 +69,10 @@ export const buildJourneysQuery = (
pathname,
timestamp
FROM events
+ ${filteredSessionsJoin}
WHERE
site_id = {siteId:Int32}
${timeStatement || ""}
- ${filterStatement || ""}
AND type = 'pageview'
ORDER BY session_id, timestamp
)
@@ -93,11 +95,14 @@ export const buildJourneysQuery = (
journey,
sessions_count,
sessions_count * 100 / (
- SELECT count(DISTINCT session_id)
- FROM events
- WHERE site_id = {siteId:Int32}
- ${timeStatement || ""}
- ${filterStatement || ""}
+ ${
+ filteredSessionsCTE
+ ? "SELECT count() FROM FilteredSessions"
+ : `SELECT count(DISTINCT session_id)
+ FROM events
+ WHERE site_id = {siteId:Int32}
+ ${timeStatement || ""}`
+ }
) AS percentage
FROM journey_segments
`;
diff --git a/server/src/api/analytics/getMetric.test.ts b/server/src/api/analytics/getMetric.test.ts
index bbef713d0..ee675a0f5 100644
--- a/server/src/api/analytics/getMetric.test.ts
+++ b/server/src/api/analytics/getMetric.test.ts
@@ -57,6 +57,19 @@ describe("buildMetricQuery", () => {
const sql = buildMetricQuery(baseQuery({ parameter: "event_name" }), SITE_ID, true);
expect(sql).toContain("COUNT(DISTINCT event_name) as totalCount");
});
+
+ it("keeps event names row-scoped inside a session-qualified campaign", () => {
+ const filters = JSON.stringify([
+ { parameter: "utm_campaign", type: "equals", value: ["launch"] },
+ { parameter: "event_name", type: "equals", value: ["signup"] },
+ ]);
+ const sql = buildMetricQuery(baseQuery({ parameter: "event_name", filters }), SITE_ID);
+
+ expect(sql).toContain("FilteredSessions AS (");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql).toContain("AND event_name = 'signup'");
+ expect(sql.slice(sql.lastIndexOf("FROM events"))).not.toContain("url_parameters['utm_campaign']");
+ });
});
describe("page_title", () => {
@@ -97,6 +110,15 @@ describe("buildMetricQuery", () => {
expect(sql).toContain("anyHeavy(hostname) as top_hostname");
expect(sql).toContain("GROUP BY pathname");
});
+
+ it("builds paths from all pageviews in campaign-qualified sessions", () => {
+ const filters = JSON.stringify([{ parameter: "utm_campaign", type: "equals", value: ["launch"] }]);
+ const sql = buildMetricQuery(baseQuery({ parameter: "pathname", filters }), SITE_ID);
+
+ expect(sql).toContain("FilteredSessions AS (");
+ expect(sql).toContain("INNER JOIN FilteredSessions fs ON e.session_id = fs.session_id");
+ expect(sql.slice(sql.indexOf("EventTimes AS (")).lastIndexOf("url_parameters['utm_campaign']")).toBe(-1);
+ });
});
describe("pagination", () => {
diff --git a/server/src/api/analytics/getMetric.ts b/server/src/api/analytics/getMetric.ts
index f142326a5..9ae1e3897 100644
--- a/server/src/api/analytics/getMetric.ts
+++ b/server/src/api/analytics/getMetric.ts
@@ -1,10 +1,11 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { FilterParameter } from "./types.js";
import { getTimeStatement } from "./utils/timeWindow.js";
-import { getFilterStatement, getSqlParam } from "./utils/getFilterStatement.js";
+import { getSqlParam } from "./utils/getFilterStatement.js";
import { SESSION_CHANNEL_AGG } from "./utils/sessionAttribution.js";
import { FilterParams } from "@rybbit/shared";
import { analyticsRoute, getPaginationStatements, runPaginatedQuery } from "./utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments } from "./utils/sessionFilters.js";
interface GetMetricRequest {
Params: {
@@ -62,35 +63,49 @@ export const buildMetricQuery = (
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ filters,
+ siteId,
+ timeStatement,
+ parameter === "event_name" ? ["event_name"] : []
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
+ const aliasedSessionJoin = filteredSessionsCTE
+ ? "INNER JOIN FilteredSessions fs ON e.session_id = fs.session_id"
+ : "";
+ const withFilteredSessions = filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : "";
const { limitStatement, offsetStatement } = getPaginationStatements(query, 100, isCountQuery);
if (parameter === "event_name") {
if (isCountQuery) {
return `
+ ${withFilteredSessions}
SELECT COUNT(DISTINCT event_name) as totalCount
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND event_name IS NOT NULL
AND event_name <> ''
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
AND type = 'custom_event';
`;
}
return `
+ ${withFilteredSessions}
SELECT
event_name as value,
COUNT(*) as count,
ROUND(COUNT(distinct(session_id)) * 100.0 / SUM(COUNT(distinct(session_id))) OVER (), 2) as percentage
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND event_name IS NOT NULL
AND event_name <> ''
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
AND type = 'custom_event'
GROUP BY event_name ORDER BY count desc, event_name asc
@@ -106,22 +121,22 @@ export const buildMetricQuery = (
argMax(pathname, timestamp) as pathname,
COUNT(DISTINCT session_id) as unique_sessions
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND page_title IS NOT NULL
AND page_title <> ''
- -- AND type = 'pageview'
- ${filterStatement}
+ AND type = 'pageview'
${timeStatement}
GROUP BY page_title
`;
if (isCountQuery) {
- return `SELECT COUNT(*) as totalCount FROM (${corePageTitleLogic});`;
+ return `${withFilteredSessions} SELECT COUNT(*) as totalCount FROM (${corePageTitleLogic});`;
}
return `
- WITH SessionPageCounts AS (
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} SessionPageCounts AS (
SELECT
session_id,
COUNT() as pageviews_in_session
@@ -136,15 +151,16 @@ export const buildMetricQuery = (
SELECT
e.page_title as value,
e.pathname as pathname,
- e.session_id,
+ e.session_id AS session_id,
spc.pageviews_in_session
FROM events e
+ ${aliasedSessionJoin}
LEFT JOIN SessionPageCounts spc ON e.session_id = spc.session_id
WHERE
e.site_id = {siteId:Int32}
AND e.page_title IS NOT NULL
AND e.page_title <> ''
- ${filterStatement}
+ AND e.type = 'pageview'
${timeStatement}
)
SELECT
@@ -185,14 +201,17 @@ export const buildMetricQuery = (
),
RelevantEvents AS (
SELECT
- e.*,
+ e.session_id AS session_id,
+ e.pathname AS pathname,
+ e.hostname AS hostname,
+ e.timestamp AS timestamp,
spc.pageviews_in_session
FROM events e
+ ${aliasedSessionJoin}
LEFT JOIN SessionPageCounts spc ON e.session_id = spc.session_id
WHERE
e.site_id = {siteId:Int32}
- -- AND type = 'pageview'
- ${filterStatement}
+ AND e.type = 'pageview'
${timeStatement}
),
EventTimes AS (
@@ -239,13 +258,13 @@ export const buildMetricQuery = (
if (isCountQuery) {
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT COUNT(DISTINCT pathname) as totalCount FROM PathStats;
`;
}
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT
pathname as value,
top_hostname as hostname,
@@ -276,18 +295,18 @@ export const buildMetricQuery = (
),
EventTimes AS (
SELECT
- e.session_id,
+ e.session_id AS session_id,
e.pathname,
e.hostname,
e.timestamp,
spc.pageviews_in_session,
leadInFrame(e.timestamp) OVER (PARTITION BY e.session_id ORDER BY e.timestamp ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) as next_timestamp
FROM events e
+ ${aliasedSessionJoin}
LEFT JOIN SessionPageCounts spc ON e.session_id = spc.session_id
WHERE
e.site_id = {siteId:Int32}
- -- AND type = 'pageview'
- ${filterStatement}
+ AND e.type = 'pageview'
${timeStatement}
),
PageDurations AS (
@@ -315,12 +334,12 @@ export const buildMetricQuery = (
`;
if (isCountQuery) {
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT COUNT(DISTINCT pathname) as totalCount FROM PathStats;
`;
}
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT
pathname as value,
top_hostname as hostname,
@@ -346,16 +365,17 @@ export const buildMetricQuery = (
if (isCountQuery) {
return `
+ ${withFilteredSessions}
SELECT COUNT(DISTINCT value) as totalCount
FROM (
SELECT
${valueExpression} as value
FROM events e
+ ${aliasedSessionJoin}
WHERE
e.site_id = {siteId:Int32}
AND ${sqlParam} IS NOT NULL
AND ${sqlParam} <> ''
- ${filterStatement}
${timeStatement}
GROUP BY e.session_id
);
@@ -363,7 +383,7 @@ export const buildMetricQuery = (
}
return `
- WITH SessionPageCounts AS (
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} SessionPageCounts AS (
SELECT
session_id,
COUNT() as pageviews_in_session
@@ -377,15 +397,15 @@ export const buildMetricQuery = (
SessionData AS (
SELECT
${valueExpression} as value,
- e.session_id,
+ e.session_id AS session_id,
any(spc.pageviews_in_session) as pageviews_in_session
FROM events e
+ ${aliasedSessionJoin}
LEFT JOIN SessionPageCounts spc ON e.session_id = spc.session_id
WHERE
e.site_id = {siteId:Int32}
AND ${sqlParam} IS NOT NULL
AND ${sqlParam} <> ''
- ${filterStatement}
${timeStatement}
GROUP BY e.session_id
)
diff --git a/server/src/api/analytics/getOverviewBucketed.ts b/server/src/api/analytics/getOverviewBucketed.ts
index 99b678589..799f9704a 100644
--- a/server/src/api/analytics/getOverviewBucketed.ts
+++ b/server/src/api/analytics/getOverviewBucketed.ts
@@ -1,51 +1,35 @@
import { FilterParams } from "@rybbit/shared";
import { FastifyReply, FastifyRequest } from "fastify";
import { resolveTimeWindow } from "./utils/timeWindow.js";
-import { getFilterStatement } from "./utils/getFilterStatement.js";
import { TimeBucket } from "./types.js";
import { analyticsRoute, runAnalyticsQuery } from "./utils/analyticsQuery.js";
import { effectiveUserId } from "./utils/effectiveUserId.js";
+import { buildFilteredSessionsCTE } from "./utils/sessionFilters.js";
export const buildOverviewBucketedQuery = (params: FilterParams<{ bucket: TimeBucket }>, siteId: number) => {
const { bucket = "hour", filters } = params;
const window = resolveTimeWindow(params);
const timeStatement = window.where();
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(filters, siteId, timeStatement);
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
const fillClause = window.fill(bucket);
return `
WITH
-AllSessionPageviews AS (
- SELECT
- session_id,
- countIf(type = 'pageview') AS total_pageviews_in_session
- FROM events
- WHERE
- site_id = {siteId:Int32}
- ${timeStatement}
- GROUP BY session_id
-),
-FilteredSessions AS (
+${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+SessionsWithStats AS (
SELECT
session_id,
MIN(timestamp) AS start_time,
- MAX(timestamp) AS end_time
+ MAX(timestamp) AS end_time,
+ countIf(type = 'pageview') AS total_pageviews_in_session
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
- ${filterStatement}
${timeStatement}
GROUP BY session_id
-),
-SessionsWithPageviews AS (
- SELECT
- fs.session_id,
- fs.start_time,
- fs.end_time,
- asp.total_pageviews_in_session
- FROM FilteredSessions fs
- LEFT JOIN AllSessionPageviews asp ON fs.session_id = asp.session_id
)
SELECT
session_stats.time AS time,
@@ -63,7 +47,7 @@ FROM
AVG(total_pageviews_in_session) AS pages_per_session,
sumIf(1, total_pageviews_in_session = 1) / COUNT() AS bounce_rate,
AVG(end_time - start_time) AS session_duration
- FROM SessionsWithPageviews
+ FROM SessionsWithStats
GROUP BY time ORDER BY time ${fillClause}
) AS session_stats
FULL JOIN
@@ -73,9 +57,9 @@ FULL JOIN
countIf(type = 'pageview') AS pageviews,
COUNT(DISTINCT ${effectiveUserId()}) AS users
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
- ${filterStatement}
${timeStatement}
GROUP BY time ORDER BY time ${fillClause}
) AS page_stats
diff --git a/server/src/api/analytics/getPageTitles.ts b/server/src/api/analytics/getPageTitles.ts
index 29a5364a5..88ff9e442 100644
--- a/server/src/api/analytics/getPageTitles.ts
+++ b/server/src/api/analytics/getPageTitles.ts
@@ -1,8 +1,13 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { getTimeStatement } from "./utils/timeWindow.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "./utils/getFilterStatement.js";
-import { analyticsRoute, getPaginationStatements, runAnalyticsQuery, runPaginatedQuery } from "./utils/analyticsQuery.js";
+import {
+ analyticsRoute,
+ getPaginationStatements,
+ runAnalyticsQuery,
+ runPaginatedQuery,
+} from "./utils/analyticsQuery.js";
+import { buildFilteredSessionsCTE } from "./utils/sessionFilters.js";
interface GetPageTitlesRequest {
Params: {
@@ -39,7 +44,8 @@ export const buildPageTitlesQuery = (
const { filters } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(filters, siteId, timeStatement);
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
// StandardSection usually shows a small number, e.g., 7 or 10. Default to 10 for non-paginated use.
const { limitStatement, offsetStatement } = getPaginationStatements(query, 10, isCountQuery);
@@ -53,6 +59,7 @@ export const buildPageTitlesQuery = (
session_id,
COUNT() as pageviews_in_session
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'pageview'
@@ -67,10 +74,10 @@ export const buildPageTitlesQuery = (
timestamp,
leadInFrame(timestamp) OVER (PARTITION BY session_id ORDER BY timestamp ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING) as next_timestamp
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'pageview'
- ${filterStatement}
${timeStatement}
),
PageDurations AS (
@@ -102,13 +109,13 @@ export const buildPageTitlesQuery = (
if (isCountQuery) {
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT COUNT(*) as totalCount FROM PageTitleStats;
`;
}
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT
value,
pathname,
diff --git a/server/src/api/analytics/goals/getGoalSessions.ts b/server/src/api/analytics/goals/getGoalSessions.ts
index 57b95693c..36fa11baf 100644
--- a/server/src/api/analytics/goals/getGoalSessions.ts
+++ b/server/src/api/analytics/goals/getGoalSessions.ts
@@ -6,6 +6,7 @@ import { getTimeStatement } from "../utils/timeWindow.js";
import { FilterParams } from "@rybbit/shared";
import { GetSessionsResponse } from "../sessions/getSessions.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { buildGoalCondition } from "./goalConditions.js";
export interface GetGoalSessionsRequest {
@@ -25,13 +26,16 @@ export const buildGoalSessionsQuery = (
goalCondition: string
) => {
const timeStatement = getTimeStatement(query);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
// Build query to find sessions that match the goal
// First, find all session_ids that have at least one event matching the goal
return `
- WITH GoalSessions AS (
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+ GoalSessions AS (
SELECT DISTINCT session_id
FROM events
+ ${filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : ""}
WHERE
site_id = {siteId:Int32}
AND (${goalCondition})
diff --git a/server/src/api/analytics/goals/getGoalTimeSeries.ts b/server/src/api/analytics/goals/getGoalTimeSeries.ts
index 4b1a0e7ef..ec266a2eb 100644
--- a/server/src/api/analytics/goals/getGoalTimeSeries.ts
+++ b/server/src/api/analytics/goals/getGoalTimeSeries.ts
@@ -5,7 +5,7 @@ import SqlString from "sqlstring";
import { db } from "../../../db/postgres/postgres.js";
import { goals } from "../../../db/postgres/schema.js";
import { TimeBucket } from "../types.js";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { getTimeStatement, TimeBucketToFn } from "../utils/timeWindow.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
import { buildGoalCondition } from "./goalConditions.js";
@@ -58,7 +58,8 @@ export const buildGoalTimeSeriesQuery = (
): string | null => {
const { bucket = "hour" } = query;
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
+ const filteredSessionsJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
const bucketFn = TimeBucketToFn[bucket];
const conversionQueries = siteGoals
@@ -72,11 +73,11 @@ export const buildGoalTimeSeriesQuery = (
${SqlString.escape(goal.goalId)} AS goal_id,
COUNT(DISTINCT session_id) AS conversions
FROM events
+ ${filteredSessionsJoin}
WHERE
site_id = {siteId:Int32}
AND (${goalCondition})
${timeStatement}
- ${filterStatement}
GROUP BY time, goal_id
`;
})
@@ -89,15 +90,16 @@ export const buildGoalTimeSeriesQuery = (
const validGoalIds = siteGoals.map(goal => goal.goalId).join(", ");
return `
WITH
+ ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
sessions_by_bucket AS (
SELECT
toDateTime(${bucketFn}(toTimeZone(timestamp, {timeZone:String}))) AS time,
COUNT(DISTINCT session_id) AS total_sessions
FROM events
+ ${filteredSessionsJoin}
WHERE
site_id = {siteId:Int32}
${timeStatement}
- ${filterStatement}
GROUP BY time
),
goal_ids AS (
diff --git a/server/src/api/analytics/goals/getGoals.ts b/server/src/api/analytics/goals/getGoals.ts
index 3cff75dd0..cbeacb94c 100644
--- a/server/src/api/analytics/goals/getGoals.ts
+++ b/server/src/api/analytics/goals/getGoals.ts
@@ -5,8 +5,8 @@ import { eq, desc, asc, sql } from "drizzle-orm";
import { getTimeStatement } from "../utils/timeWindow.js";
import SqlString from "sqlstring";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { buildGoalCondition } from "./goalConditions.js";
// Types for the response
@@ -45,14 +45,21 @@ interface GetGoalsRequest {
export const buildGoalsTotalSessionsQuery = (query: GetGoalsRequest["Querystring"], siteId: number) => {
const timeStatement = getTimeStatement(query);
- const filterStatement = query.filters ? getFilterStatement(query.filters, siteId, timeStatement) : "";
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
+
+ if (filteredSessionsCTE) {
+ return `
+ WITH ${filteredSessionsCTE}
+ SELECT COUNT(*) AS total_sessions
+ FROM FilteredSessions
+ `;
+ }
return `
SELECT COUNT(DISTINCT session_id) AS total_sessions
FROM events
WHERE site_id = ${SqlString.escape(siteId)}
${timeStatement}
- ${filterStatement}
`;
};
@@ -66,7 +73,7 @@ export const buildGoalsConversionsQuery = (
siteGoals: (typeof goals.$inferSelect)[]
): string | null => {
const timeStatement = getTimeStatement(query);
- const filterStatement = query.filters ? getFilterStatement(query.filters, siteId, timeStatement) : "";
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
// Build a single query that calculates all goal conversions at once using conditional aggregation
// This is more efficient than separate queries for each goal
@@ -90,12 +97,13 @@ export const buildGoalsConversionsQuery = (
}
return `
+ ${filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : ""}
SELECT
${conditionalClauses.join(", ")}
FROM events
+ ${filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : ""}
WHERE site_id = ${SqlString.escape(siteId)}
${timeStatement}
- ${filterStatement}
`;
};
diff --git a/server/src/api/analytics/goals/goalQueries.test.ts b/server/src/api/analytics/goals/goalQueries.test.ts
new file mode 100644
index 000000000..ce5dd4f3e
--- /dev/null
+++ b/server/src/api/analytics/goals/goalQueries.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+vi.mock("../../../db/postgres/postgres.js", () => ({
+ db: {},
+}));
+
+import { buildGoalSessionsQuery } from "./getGoalSessions.js";
+import { buildGoalTimeSeriesQuery } from "./getGoalTimeSeries.js";
+import { buildGoalsConversionsQuery, buildGoalsTotalSessionsQuery } from "./getGoals.js";
+
+const CAMPAIGN_FILTER = JSON.stringify([{ parameter: "utm_campaign", type: "equals", value: ["recipe_book_2026"] }]);
+
+const query = {
+ filters: CAMPAIGN_FILTER,
+ start_date: "",
+ end_date: "",
+ time_zone: "UTC",
+};
+
+const formGoal = {
+ goalId: 115,
+ siteId: 1,
+ name: "Recipe book form",
+ goalType: "form_submit",
+ config: { valuePattern: "gform_115" },
+ createdAt: null,
+};
+
+describe("goal queries with global session filters", () => {
+ it("qualifies sessions by campaign before counting a later goal event", () => {
+ const sql = buildGoalsConversionsQuery(query, 1, [formGoal] as any);
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("argMin(url_parameters, timestamp)['utm_campaign'] AS utm_campaign");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql).toContain("type = 'form_submit'");
+ });
+
+ it("uses the same campaign-qualified sessions for the conversion-rate denominator", () => {
+ const sql = buildGoalsTotalSessionsQuery(query, 1);
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("FROM FilteredSessions");
+ });
+
+ it("uses the same campaign-qualified sessions in the time series", () => {
+ const sql = buildGoalTimeSeriesQuery({ ...query, bucket: "hour" }, 1, [formGoal] as any);
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql).toContain("type = 'form_submit'");
+ });
+
+ it("applies the campaign filter to the expanded converted-sessions list", () => {
+ const sql = buildGoalSessionsQuery(
+ { ...query, page: 1, limit: 25 },
+ 1,
+ "type = 'form_submit' AND JSONExtractString(toString(props), 'formId') = 'gform_115'"
+ );
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ });
+});
diff --git a/server/src/api/analytics/performance/getPerformanceByDimension.ts b/server/src/api/analytics/performance/getPerformanceByDimension.ts
index 6d6959bbc..c2d3df8ff 100644
--- a/server/src/api/analytics/performance/getPerformanceByDimension.ts
+++ b/server/src/api/analytics/performance/getPerformanceByDimension.ts
@@ -1,8 +1,8 @@
import { FastifyReply, FastifyRequest } from "fastify";
import { getTimeStatement } from "../utils/timeWindow.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { analyticsRoute, getPaginationStatements, runPaginatedQuery } from "../utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments, TARGET_EVENT_ROW_LEVEL_PARAMS } from "../utils/sessionFilters.js";
interface GetPerformanceByDimensionRequest {
Params: {
@@ -68,7 +68,13 @@ export const buildPerformanceByDimensionQuery = (
}
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ filters,
+ siteId,
+ timeStatement,
+ TARGET_EVENT_ROW_LEVEL_PARAMS
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
const { limitStatement, offsetStatement } = getPaginationStatements(query, 100, isCountQuery);
@@ -137,12 +143,13 @@ export const buildPerformanceByDimensionQuery = (
quantileIf(0.9)(ttfb, ttfb IS NOT NULL) as ttfb_p90,
quantileIf(0.99)(ttfb, ttfb IS NOT NULL) as ttfb_p99
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'performance'
AND ${dimension} IS NOT NULL
AND ${dimension} <> ''
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
GROUP BY ${dimension}
)
@@ -150,13 +157,13 @@ export const buildPerformanceByDimensionQuery = (
if (isCountQuery) {
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT COUNT(DISTINCT ${dimension}) as totalCount FROM PerformanceStats;
`;
}
return `
- WITH ${baseCteQuery}
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} ${baseCteQuery}
SELECT
${dimension},
event_count,
diff --git a/server/src/api/analytics/performance/getPerformanceOverview.ts b/server/src/api/analytics/performance/getPerformanceOverview.ts
index e9ddc108c..e9fa1a07e 100644
--- a/server/src/api/analytics/performance/getPerformanceOverview.ts
+++ b/server/src/api/analytics/performance/getPerformanceOverview.ts
@@ -2,14 +2,21 @@ import { FastifyReply, FastifyRequest } from "fastify";
import { getTimeStatement } from "../utils/timeWindow.js";
import { PerformanceOverviewMetrics } from "../types.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments, TARGET_EVENT_ROW_LEVEL_PARAMS } from "../utils/sessionFilters.js";
export const buildPerformanceOverviewQuery = (query: FilterParams, siteId: number) => {
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ query.filters,
+ siteId,
+ timeStatement,
+ TARGET_EVENT_ROW_LEVEL_PARAMS
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
- return `SELECT
+ return `${filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : ""}
+ SELECT
quantile(0.5)(lcp) AS lcp_p50,
quantile(0.75)(lcp) AS lcp_p75,
quantile(0.9)(lcp) AS lcp_p90,
@@ -32,10 +39,11 @@ export const buildPerformanceOverviewQuery = (query: FilterParams, siteId: numbe
quantile(0.99)(ttfb) AS ttfb_p99,
COUNT(*) AS total_performance_events
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'performance'
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}`;
};
diff --git a/server/src/api/analytics/performance/getPerformanceTimeSeries.ts b/server/src/api/analytics/performance/getPerformanceTimeSeries.ts
index 75d6f2983..29fd02cb7 100644
--- a/server/src/api/analytics/performance/getPerformanceTimeSeries.ts
+++ b/server/src/api/analytics/performance/getPerformanceTimeSeries.ts
@@ -2,17 +2,24 @@ import { FastifyReply, FastifyRequest } from "fastify";
import { resolveTimeWindow } from "../utils/timeWindow.js";
import { TimeBucket, PerformanceTimeSeriesPoint } from "../types.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
+import { buildSessionAndRowFilterFragments, TARGET_EVENT_ROW_LEVEL_PARAMS } from "../utils/sessionFilters.js";
export const buildPerformanceTimeSeriesQuery = (params: FilterParams<{ bucket: TimeBucket }>, siteId: number) => {
const { bucket = "hour", filters } = params;
const window = resolveTimeWindow(params);
const timeStatement = window.where();
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const { filteredSessionsCTE, rowFilterStatement } = buildSessionAndRowFilterFragments(
+ filters,
+ siteId,
+ timeStatement,
+ TARGET_EVENT_ROW_LEVEL_PARAMS
+ );
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
const query = `
+${filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : ""}
SELECT
${window.bucketed("timestamp", bucket)} AS time,
quantile(0.5)(lcp) AS lcp_p50,
@@ -37,10 +44,11 @@ SELECT
quantile(0.99)(ttfb) AS ttfb_p99,
COUNT(*) AS event_count
FROM events
+${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND type = 'performance'
- ${filterStatement}
+ ${rowFilterStatement}
${timeStatement}
GROUP BY time ORDER BY time ${window.fill(bucket)}`;
diff --git a/server/src/api/analytics/sessionScopedQueries.test.ts b/server/src/api/analytics/sessionScopedQueries.test.ts
new file mode 100644
index 000000000..7d6ae601a
--- /dev/null
+++ b/server/src/api/analytics/sessionScopedQueries.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+vi.mock("../../db/postgres/postgres.js", () => ({
+ db: {},
+}));
+
+import { buildErrorBucketedQuery } from "./getErrorBucketed.js";
+import { buildErrorEventsQuery } from "./getErrorEvents.js";
+import { buildErrorNamesQuery } from "./getErrorNames.js";
+import { buildOverviewBucketedQuery } from "./getOverviewBucketed.js";
+import { buildPageTitlesQuery } from "./getPageTitles.js";
+import { buildPerformanceByDimensionQuery } from "./performance/getPerformanceByDimension.js";
+import { buildPerformanceOverviewQuery } from "./performance/getPerformanceOverview.js";
+import { buildPerformanceTimeSeriesQuery } from "./performance/getPerformanceTimeSeries.js";
+
+const SITE_ID = 1;
+const campaignFilter = JSON.stringify([{ parameter: "utm_campaign", type: "equals", value: ["recipe_book_2026"] }]);
+const baseParams = {
+ start_date: "2026-08-01",
+ end_date: "2026-08-31",
+ time_zone: "UTC",
+ filters: campaignFilter,
+};
+
+const expectSessionQualifiedTarget = (sql: string, targetPredicate: string) => {
+ expect(sql).toContain("FilteredSessions AS (");
+ expect(sql).toContain("INNER JOIN FilteredSessions");
+
+ const targetQuery = sql.slice(sql.lastIndexOf(targetPredicate));
+ expect(targetQuery).not.toContain("url_parameters['utm_campaign']");
+};
+
+describe("session-qualified target-event analytics", () => {
+ it("qualifies performance overview sessions before measuring performance rows", () => {
+ const sql = buildPerformanceOverviewQuery(baseParams, SITE_ID);
+ expectSessionQualifiedTarget(sql, "AND type = 'performance'");
+ });
+
+ it("keeps performance pathname filters on the measured row", () => {
+ const pathFilter = JSON.stringify([{ parameter: "pathname", type: "equals", value: ["/pricing"] }]);
+ const sql = buildPerformanceOverviewQuery({ ...baseParams, filters: pathFilter }, SITE_ID);
+
+ expect(sql).toContain("AND pathname = '/pricing'");
+ expect(sql).not.toContain("FilteredSessions AS (");
+ });
+
+ it("combines a campaign cohort with a measured performance path", () => {
+ const filters = JSON.stringify([
+ { parameter: "utm_campaign", type: "equals", value: ["launch"] },
+ { parameter: "pathname", type: "equals", value: ["/pricing"] },
+ ]);
+ const sql = buildPerformanceOverviewQuery({ ...baseParams, filters }, SITE_ID);
+
+ expect(sql).toContain("FilteredSessions AS (");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql.slice(sql.lastIndexOf("AND type = 'performance'"))).toContain("AND pathname = '/pricing'");
+ });
+
+ it("qualifies performance time-series sessions before measuring performance rows", () => {
+ const sql = buildPerformanceTimeSeriesQuery({ ...baseParams, bucket: "day" }, SITE_ID);
+ expectSessionQualifiedTarget(sql, "AND type = 'performance'");
+ });
+
+ it("qualifies performance dimension sessions in data and count queries", () => {
+ for (const isCountQuery of [false, true]) {
+ const sql = buildPerformanceByDimensionQuery({ ...baseParams, dimension: "pathname" }, SITE_ID, isCountQuery);
+ expectSessionQualifiedTarget(sql, "AND type = 'performance'");
+ }
+ });
+
+ it("qualifies error-name sessions before measuring error rows", () => {
+ const sql = buildErrorNamesQuery(baseParams, SITE_ID);
+ expectSessionQualifiedTarget(sql, "AND type = 'error'");
+ });
+
+ it("keeps error pathname filters on the error row", () => {
+ const pathFilter = JSON.stringify([{ parameter: "pathname", type: "equals", value: ["/checkout"] }]);
+ const sql = buildErrorNamesQuery({ ...baseParams, filters: pathFilter }, SITE_ID);
+
+ expect(sql).toContain("AND pathname = '/checkout'");
+ expect(sql).not.toContain("FilteredSessions AS (");
+ });
+
+ it("qualifies error time-series sessions before measuring error rows", () => {
+ const sql = buildErrorBucketedQuery({ ...baseParams, bucket: "day", errorMessage: "boom" }, SITE_ID);
+ expectSessionQualifiedTarget(sql, "AND type = 'error'");
+ });
+
+ it("qualifies error-event sessions in data and count queries", () => {
+ for (const isCountQuery of [false, true]) {
+ const sql = buildErrorEventsQuery({ ...baseParams, errorMessage: "boom" }, SITE_ID, isCountQuery);
+ expectSessionQualifiedTarget(sql, "AND type = 'error'");
+ }
+ });
+
+ it("builds bucketed overview stats from all rows in qualifying sessions", () => {
+ const sql = buildOverviewBucketedQuery({ ...baseParams, bucket: "day" }, SITE_ID);
+
+ expect(sql).toContain("FilteredSessions AS (");
+ expect(sql).toContain("INNER JOIN FilteredSessions");
+ expect(sql.slice(sql.indexOf("SessionsWithStats AS ("))).not.toContain("url_parameters['utm_campaign']");
+ });
+
+ it("builds page-title metrics from all pageviews in qualifying sessions", () => {
+ const sql = buildPageTitlesQuery(baseParams, SITE_ID);
+
+ expect(sql).toContain("FilteredSessions AS (");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql.slice(sql.indexOf("EventTimes AS ("))).not.toContain("url_parameters['utm_campaign']");
+ });
+});
diff --git a/server/src/api/analytics/sessions/getSessionLocations.test.ts b/server/src/api/analytics/sessions/getSessionLocations.test.ts
new file mode 100644
index 000000000..1cc5de7fd
--- /dev/null
+++ b/server/src/api/analytics/sessions/getSessionLocations.test.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+
+import { buildSessionLocationsQuery } from "./getSessionLocations.js";
+
+describe("buildSessionLocationsQuery session-scoped filters", () => {
+ it("keeps a session whose campaign and pathname occur on different rows", () => {
+ const filters = JSON.stringify([
+ { parameter: "utm_campaign", type: "equals", value: ["recipe_book_2026"] },
+ { parameter: "pathname", type: "equals", value: ["/thank-you"] },
+ ]);
+ const sql = buildSessionLocationsQuery({ filters, start_date: "", end_date: "", time_zone: "UTC" }, 1);
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("AND pathname = '/thank-you'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql).toContain("argMax(lat, timestamp) AS lat");
+ expect(sql.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ expect(sql.match(/pathname = '\/thank-you'/g)).toHaveLength(1);
+ });
+});
diff --git a/server/src/api/analytics/sessions/getSessionLocations.ts b/server/src/api/analytics/sessions/getSessionLocations.ts
index 55403b813..afc3d3f9f 100644
--- a/server/src/api/analytics/sessions/getSessionLocations.ts
+++ b/server/src/api/analytics/sessions/getSessionLocations.ts
@@ -1,7 +1,7 @@
import { FilterParams } from "@rybbit/shared";
import { FastifyReply, FastifyRequest } from "fastify";
import { getTimeStatement } from "../utils/timeWindow.js";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
export interface GetSessionLocationsRequest {
@@ -13,22 +13,24 @@ export interface GetSessionLocationsRequest {
export const buildSessionLocationsQuery = (query: GetSessionLocationsRequest["Querystring"], siteId: number) => {
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
+ const filteredSessionsJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
return `
-WITH stuff AS (
+WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+stuff AS (
SELECT
session_id,
- any(lat) AS lat,
- any(lon) AS lon,
- any(city) AS city,
- any(country) AS country
+ argMax(lat, timestamp) AS lat,
+ argMax(lon, timestamp) AS lon,
+ argMax(city, timestamp) AS city,
+ argMax(country, timestamp) AS country
FROM
events
+ ${filteredSessionsJoin}
WHERE
site_id = {site:Int32}
${timeStatement}
- ${filterStatement}
GROUP BY
session_id
)
diff --git a/server/src/api/analytics/sessions/getSessions.ts b/server/src/api/analytics/sessions/getSessions.ts
index 2771a8d65..41434d9c9 100644
--- a/server/src/api/analytics/sessions/getSessions.ts
+++ b/server/src/api/analytics/sessions/getSessions.ts
@@ -1,7 +1,7 @@
import { FilterParams } from "@rybbit/shared";
import { FastifyReply, FastifyRequest } from "fastify";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { SESSION_CHANNEL_AGG, SESSION_REFERRER_AGG } from "../utils/sessionAttribution.js";
+import { getSessionFilterStatement } from "../utils/sessionFilters.js";
import { enrichWithTraits } from "../utils/utils.js";
import { getTimeStatement } from "../utils/timeWindow.js";
import { analyticsRoute, runAnalyticsQuery, QuerySpec } from "../utils/analyticsQuery.js";
@@ -60,8 +60,7 @@ export interface GetSessionsRequest {
limit: number;
page: number;
user_id?: string;
- session_id?: string
- ;
+ session_id?: string;
identified_only?: string;
min_pageviews?: string;
min_events?: string;
@@ -69,15 +68,6 @@ export interface GetSessionsRequest {
}>;
}
-// Field mappings for the CTE which extracts UTM params as separate columns
-const SESSION_FIELD_MAPPINGS = {
- "url_parameters['utm_source']": "utm_source",
- "url_parameters['utm_medium']": "utm_medium",
- "url_parameters['utm_campaign']": "utm_campaign",
- "url_parameters['utm_term']": "utm_term",
- "url_parameters['utm_content']": "utm_content",
-};
-
export const buildSessionsQuery = (query: GetSessionsRequest["Querystring"], siteId: number): QuerySpec => {
const {
filters,
@@ -102,10 +92,7 @@ export const buildSessionsQuery = (query: GetSessionsRequest["Querystring"], sit
// containing a matching event) — required for any parameter the aggregated CTE
// below doesn't project, otherwise the outer WHERE hits an unknown identifier
// - fieldMappings: CTE extracts UTM params as separate columns, so we need to map the field names
- const filterStatement = getFilterStatement(filters, siteId, timeStatement, {
- sessionLevelParams: ["event_name", "pathname", "page_title", "querystring", "channel"],
- fieldMappings: SESSION_FIELD_MAPPINGS,
- });
+ const filterStatement = getSessionFilterStatement(filters, siteId, timeStatement);
const querySQL = `
WITH AggregatedSessions AS (
diff --git a/server/src/api/analytics/users/getUserInfo.ts b/server/src/api/analytics/users/getUserInfo.ts
index bd43df608..a82db847b 100644
--- a/server/src/api/analytics/users/getUserInfo.ts
+++ b/server/src/api/analytics/users/getUserInfo.ts
@@ -3,8 +3,8 @@ import { FastifyReply, FastifyRequest } from "fastify";
import { eq, and } from "drizzle-orm";
import { db } from "../../../db/postgres/postgres.js";
import { userProfiles, userAliases } from "../../../db/postgres/schema.js";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { SESSION_CHANNEL_AGG, SESSION_REFERRER_AGG } from "../utils/sessionAttribution.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { getTimeStatement } from "../utils/timeWindow.js";
import { matchesUser } from "../utils/effectiveUserId.js";
import { runAnalyticsQuery } from "../utils/analyticsQuery.js";
@@ -89,24 +89,26 @@ export const buildUserInfoQueries = (query: FilterParams, siteId: number) => {
// Optional time range + dimension filters; both empty when the page is on
// all-time with no filters, which keeps the original full-history behavior.
const timeStatement = getTimeStatement(query);
- const filterStatement = getFilterStatement(query.filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
+ const filteredSessionsJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
+ const withFilteredSessions = filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : "";
- // Filters run in a subquery below each aggregation: the aggregate SELECTs
- // alias argMax(...) to the same names as raw columns (browser_version, …),
- // and ClickHouse resolves unqualified WHERE references at that level to the
- // aliases, throwing ILLEGAL_AGGREGATION.
+ // Filters select sessions first. Every panel then reads all events in those
+ // sessions, keeping the summary, vitals, locations, devices, and session list
+ // on the same session-scoped semantics.
const scopedEvents = `(
- SELECT *
- FROM events
+ SELECT source_events.*
+ FROM events AS source_events
+ ${filteredSessionsJoin}
WHERE
- ${matchesUser("{userId:String}", "events")}
- AND site_id = {site:Int32}
+ ${matchesUser("{userId:String}", "source_events")}
+ AND source_events.site_id = {site:Int32}
${timeStatement}
- ${filterStatement}
) AS events`;
const sessionsQuery = `
- WITH sessions AS (
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+ sessions AS (
SELECT
session_id,
argMax(user_id, timestamp) AS user_id,
@@ -180,6 +182,7 @@ export const buildUserInfoQueries = (query: FilterParams, siteId: number) => {
// Separate query: the sessions CTE collapses rows per session, which
// would turn an event-level quantile into a quantile of session picks.
const vitalsQuery = `
+ ${withFilteredSessions}
SELECT
quantile(0.75)(lcp) AS lcp_p75,
quantile(0.75)(cls) AS cls_p75,
@@ -194,6 +197,7 @@ export const buildUserInfoQueries = (query: FilterParams, siteId: number) => {
// Every location this user was seen in, by session share. A session that
// moves between cities counts once per city, so shares are approximate.
const locationsQuery = `
+ ${withFilteredSessions}
SELECT
country,
region,
@@ -213,6 +217,7 @@ export const buildUserInfoQueries = (query: FilterParams, siteId: number) => {
// browser update doesn't split one physical device into many rows;
// versions and screen are argMax'd to the latest sighting instead.
const devicesQuery = `
+ ${withFilteredSessions}
SELECT
device_type,
browser,
diff --git a/server/src/api/analytics/users/getUserSessionCount.ts b/server/src/api/analytics/users/getUserSessionCount.ts
index 1fb880756..0db5decf8 100644
--- a/server/src/api/analytics/users/getUserSessionCount.ts
+++ b/server/src/api/analytics/users/getUserSessionCount.ts
@@ -1,7 +1,7 @@
import { FastifyReply, FastifyRequest } from "fastify";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
import { matchesUser } from "../utils/effectiveUserId.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import SqlString from "sqlstring";
export interface GetUserSessionCountRequest {
@@ -25,17 +25,26 @@ export const buildUserSessionCountQuery = (query: GetUserSessionCountRequest["Qu
// The calendar spans the user's full history, so dimension filters apply
// but no time range does.
- const filterStatement = getFilterStatement(filters ?? "", siteId);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(filters, siteId, "");
+ const filteredSessionsJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
return `
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+ UserSessions AS (
+ SELECT
+ session_id,
+ min(timestamp) AS session_start
+ FROM events
+ ${filteredSessionsJoin}
+ WHERE
+ site_id = {siteId:Int32}
+ AND ${matchesUser("{userId:String}")}
+ GROUP BY session_id
+ )
SELECT
- toDate(timestamp, ${SqlString.escape(timeZone)}) as date,
- count(DISTINCT session_id) as sessions
- FROM events
- WHERE
- site_id = {siteId:Int32}
- AND ${matchesUser("{userId:String}")}
- ${filterStatement}
+ toDate(session_start, ${SqlString.escape(timeZone)}) as date,
+ count() as sessions
+ FROM UserSessions
GROUP BY date
ORDER BY date ASC
`;
diff --git a/server/src/api/analytics/users/getUsers.ts b/server/src/api/analytics/users/getUsers.ts
index b0c0d9fc2..44da580de 100644
--- a/server/src/api/analytics/users/getUsers.ts
+++ b/server/src/api/analytics/users/getUsers.ts
@@ -4,8 +4,8 @@ import { db } from "../../../db/postgres/postgres.js";
import { enrichWithTraits } from "../utils/utils.js";
import { getTimeStatement } from "../utils/timeWindow.js";
import { FilterParams } from "@rybbit/shared";
-import { getFilterStatement } from "../utils/getFilterStatement.js";
import { SESSION_CHANNEL_AGG, SESSION_REFERRER_AGG } from "../utils/sessionAttribution.js";
+import { buildFilteredSessionsCTE } from "../utils/sessionFilters.js";
import { analyticsRoute, runAnalyticsQuery } from "../utils/analyticsQuery.js";
import { effectiveUserId } from "../utils/effectiveUserId.js";
@@ -64,48 +64,47 @@ export const buildUsersQuery = (
const actualSortBy = validSortFields.includes(sortBy) ? sortBy : "last_seen";
const actualSortOrder = sortOrder === "asc" ? "ASC" : "DESC";
- // Generate filter statement and time statement
+ // Dimension filters qualify sessions. User aggregates then consume every
+ // event in those sessions, so an acquisition value on the landing event does
+ // not discard later pageviews or custom events from the same session.
const timeStatement = getTimeStatement(query);
- // Applied against raw events (same placement as the count queries): the
- // aggregate doesn't project every filterable column (pathname, querystring,
- // utm_*, …), and event-level placement keeps the returned rows consistent
- // with totalCount.
- const filterStatement = getFilterStatement(filters, siteId, timeStatement);
+ const filteredSessionsCTE = buildFilteredSessionsCTE(filters, siteId, timeStatement);
+ const filteredSessionsJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
+ const withFilteredSessions = filteredSessionsCTE ? `WITH ${filteredSessionsCTE}` : "";
// Query to get total count
if (isCountQuery) {
return filterIdentified
? `
+${withFilteredSessions}
SELECT count(*) AS total_count
FROM (
SELECT DISTINCT identified_user_id
FROM events
+ ${filteredSessionsJoin}
WHERE
site_id = {siteId:Int32}
AND identified_user_id != ''
${timeStatement}
- ${filterStatement}
${matchingUserIds ? "AND events.identified_user_id IN ({matchingUserIds:Array(String)})" : ""}
)
`
: `
+${withFilteredSessions}
SELECT
count(DISTINCT ${effectiveUserId("events")}) AS total_count
FROM events
+${filteredSessionsJoin}
WHERE
site_id = {siteId:Int32}
- ${filterStatement}
${timeStatement}
${matchingUserIds ? "AND events.identified_user_id IN ({matchingUserIds:Array(String)})" : ""}
`;
}
- // Filters must run in a subquery below the aggregation: the aggregate SELECT
- // aliases argMax(...) to the same names as the raw columns (country, browser,
- // …), and ClickHouse resolves unqualified WHERE references at that level to
- // the aliases, throwing ILLEGAL_AGGREGATION.
return `
-WITH AggregatedUsers AS (
+WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+AggregatedUsers AS (
SELECT
-- Group by effective user: identified_user_id for identified users, user_id (device) for anonymous
${effectiveUserId("events")} AS effective_user_id,
@@ -134,10 +133,10 @@ WITH AggregatedUsers AS (
FROM (
SELECT *
FROM events
+ ${filteredSessionsJoin}
WHERE
site_id = {siteId:Int32}
${timeStatement}
- ${filterStatement}
${matchingUserIds ? "AND events.identified_user_id IN ({matchingUserIds:Array(String)})" : ""}
) AS events
GROUP BY
@@ -180,7 +179,7 @@ export const getUsers = analyticsRoute<GetUsersRequest>(
LIMIT ${MAX_MATCHING_USER_IDS}
`);
- matchingUserIds = searchResult.map((r) => r.user_id);
+ matchingUserIds = searchResult.map(r => r.user_id);
if (matchingUserIds.length === 0) {
return res.send({
data: [],
diff --git a/server/src/api/analytics/users/userQueries.test.ts b/server/src/api/analytics/users/userQueries.test.ts
new file mode 100644
index 000000000..6127bd432
--- /dev/null
+++ b/server/src/api/analytics/users/userQueries.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+vi.mock("../../../db/postgres/postgres.js", () => ({
+ db: {},
+}));
+
+import { buildUserInfoQueries } from "./getUserInfo.js";
+import { buildUserSessionCountQuery } from "./getUserSessionCount.js";
+import { buildUsersQuery } from "./getUsers.js";
+
+const CAMPAIGN = "recipe_book_2026";
+const campaignFilter = { parameter: "utm_campaign", type: "equals", value: [CAMPAIGN] };
+const pathnameFilter = { parameter: "pathname", type: "equals", value: ["/thank-you"] };
+
+const baseQuery = (filters: string) => ({
+ filters,
+ start_date: "",
+ end_date: "",
+ time_zone: "UTC",
+});
+
+describe("user queries with session-scoped filters", () => {
+ it("aggregates all user events after a landing-only campaign qualifies the session", () => {
+ const query = baseQuery(JSON.stringify([campaignFilter]));
+ const dataSql = buildUsersQuery(query, 1, null, false);
+ const countSql = buildUsersQuery(query, 1, null, true);
+
+ for (const sql of [dataSql, countSql]) {
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ }
+
+ expect(dataSql).toContain("countIf(type = 'pageview') AS pageviews");
+ expect(dataSql).toContain("countIf(type = 'custom_event') AS events");
+ });
+
+ it("lets campaign and pathname filters match different rows for list and count", () => {
+ const query = baseQuery(JSON.stringify([campaignFilter, pathnameFilter]));
+
+ for (const sql of [buildUsersQuery(query, 1, null, false), buildUsersQuery(query, 1, null, true)]) {
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("AND pathname = '/thank-you'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ expect(sql.match(/pathname = '\/thank-you'/g)).toHaveLength(1);
+ }
+ });
+
+ it("uses the same selected sessions for every user-detail panel", () => {
+ const queries = buildUserInfoQueries(baseQuery(JSON.stringify([campaignFilter])), 1);
+
+ for (const sql of Object.values(queries)) {
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ }
+
+ expect(queries.sessionsQuery).toContain("dateDiff('second', MIN(timestamp), MAX(timestamp)) AS session_duration");
+ expect(queries.vitalsQuery).toContain("WHERE type = 'performance'");
+ });
+
+ it("counts compound-filtered sessions by their start date", () => {
+ const sql = buildUserSessionCountQuery(
+ {
+ filters: JSON.stringify([campaignFilter, pathnameFilter]),
+ time_zone: "America/New_York",
+ },
+ 1
+ );
+
+ expect(sql).toContain("FilteredSessions AS");
+ expect(sql).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(sql).toContain("AND pathname = '/thank-you'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(sql).toContain("min(timestamp) AS session_start");
+ expect(sql).toContain("toDate(session_start, 'America/New_York') as date");
+ expect(sql).toContain("FROM UserSessions");
+ });
+});
diff --git a/server/src/api/analytics/utils/getFilterStatement.test.ts b/server/src/api/analytics/utils/getFilterStatement.test.ts
index f62a75571..efa8766bc 100644
--- a/server/src/api/analytics/utils/getFilterStatement.test.ts
+++ b/server/src/api/analytics/utils/getFilterStatement.test.ts
@@ -49,13 +49,13 @@ describe("getSqlParam", () => {
it("should handle entry_page", () => {
expect(getSqlParam("entry_page")).toBe(
- "(SELECT argMin(pathname, timestamp) FROM events WHERE session_id = events.session_id)"
+ "(SELECT argMinIf(pathname, timestamp, type = 'pageview') FROM events WHERE session_id = events.session_id)"
);
});
it("should handle exit_page", () => {
expect(getSqlParam("exit_page")).toBe(
- "(SELECT argMax(pathname, timestamp) FROM events WHERE session_id = events.session_id)"
+ "(SELECT argMaxIf(pathname, timestamp, type = 'pageview') FROM events WHERE session_id = events.session_id)"
);
});
@@ -239,9 +239,7 @@ describe("getFilterStatement", () => {
it("matches an identified user, or a device only while it is still anonymous", () => {
const filters = JSON.stringify([{ parameter: "user_id", type: "equals", value: ["user123"] }]);
const result = getFilterStatement(filters);
- expect(result).toBe(
- "AND (identified_user_id = 'user123' OR (user_id = 'user123' AND identified_user_id = ''))"
- );
+ expect(result).toBe("AND (identified_user_id = 'user123' OR (user_id = 'user123' AND identified_user_id = ''))");
});
it("negates exactly the equals predicate for not_equals", () => {
@@ -329,6 +327,7 @@ describe("getFilterStatement", () => {
const result = getFilterStatement(filters);
expect(result).toContain("session_id IN");
expect(result).toContain("argMin(pathname, timestamp) AS entry_pathname");
+ expect(result).toContain("type = 'pageview'");
expect(result).toContain("entry_pathname = '/home'");
});
@@ -353,6 +352,7 @@ describe("getFilterStatement", () => {
const result = getFilterStatement(filters);
expect(result).toContain("session_id IN");
expect(result).toContain("argMax(pathname, timestamp) AS exit_pathname");
+ expect(result).toContain("type = 'pageview'");
expect(result).toContain("exit_pathname = '/checkout'");
});
@@ -575,20 +575,26 @@ describe("getFilterStatement", () => {
});
it("should handle negated filters inside the session subquery", () => {
- // Note the semantics: this selects sessions containing at least one event
- // whose hostname differs, not sessions with no matching event.
const filters = JSON.stringify([{ parameter: "hostname", type: "not_equals", value: ["bad.example.com"] }]);
const result = getFilterStatement(filters, undefined, undefined, { sessionLevelParams: ["hostname"] });
expect(normalize(result)).toBe(
- "AND session_id IN ( SELECT DISTINCT session_id FROM events WHERE hostname != 'bad.example.com' )"
+ "AND session_id NOT IN ( SELECT DISTINCT session_id FROM events WHERE hostname = 'bad.example.com' )"
);
});
- it("should AND-join multi-value not_contains inside the session subquery", () => {
+ it("excludes sessions containing any negatively filtered value", () => {
const filters = JSON.stringify([{ parameter: "pathname", type: "not_contains", value: ["/admin", "/debug"] }]);
const result = getFilterStatement(filters, undefined, undefined, { sessionLevelParams: ["pathname"] });
expect(normalize(result)).toBe(
- "AND session_id IN ( SELECT DISTINCT session_id FROM events WHERE (pathname NOT LIKE '%/admin%' AND pathname NOT LIKE '%/debug%') )"
+ "AND session_id NOT IN ( SELECT DISTINCT session_id FROM events WHERE (pathname LIKE '%/admin%' OR pathname LIKE '%/debug%') )"
+ );
+ });
+
+ it("treats is_null as no non-empty value anywhere in the session", () => {
+ const filters = JSON.stringify([{ parameter: "event_name", type: "is_null", value: [] }]);
+ const result = getFilterStatement(filters, undefined, undefined, { sessionLevelParams: ["event_name"] });
+ expect(normalize(result)).toBe(
+ "AND session_id NOT IN ( SELECT DISTINCT session_id FROM events WHERE (event_name IS NOT NULL AND event_name != '') )"
);
});
diff --git a/server/src/api/analytics/utils/getFilterStatement.ts b/server/src/api/analytics/utils/getFilterStatement.ts
index 07f4c3833..ccadd9592 100644
--- a/server/src/api/analytics/utils/getFilterStatement.ts
+++ b/server/src/api/analytics/utils/getFilterStatement.ts
@@ -150,10 +150,10 @@ export const getSqlParam = (parameter: FilterParameter) => {
return "domainWithoutWWW(referrer)";
}
if (parameter === "entry_page") {
- return "(SELECT argMin(pathname, timestamp) FROM events WHERE session_id = events.session_id)";
+ return "(SELECT argMinIf(pathname, timestamp, type = 'pageview') FROM events WHERE session_id = events.session_id)";
}
if (parameter === "exit_page") {
- return "(SELECT argMax(pathname, timestamp) FROM events WHERE session_id = events.session_id)";
+ return "(SELECT argMaxIf(pathname, timestamp, type = 'pageview') FROM events WHERE session_id = events.session_id)";
}
if (parameter === "dimensions") {
return "concat(toString(screen_width), 'x', toString(screen_height))";
@@ -214,11 +214,19 @@ export function getFilterStatement(
// inside the subquery. fieldMappings deliberately do NOT apply here: the
// subquery selects from the raw events table, where the caller's CTE
// aliases don't exist.
- const condition = buildStringFilterCondition(getSqlParam(param), filterType, values);
+ const negatedSessionFilterTypes: Partial<Record<FilterType, FilterType>> = {
+ not_equals: "equals",
+ not_contains: "contains",
+ not_regex: "regex",
+ is_null: "is_not_null",
+ };
+ const positiveFilterType = negatedSessionFilterTypes[filterType] ?? filterType;
+ const condition = buildStringFilterCondition(getSqlParam(param), positiveFilterType, values);
+ const membershipOperator = negatedSessionFilterTypes[filterType] ? "NOT IN" : "IN";
const finalWhere = whereClause ? `WHERE ${whereClause} AND ${condition}` : `WHERE ${condition}`;
- return `session_id IN (
+ return `session_id ${membershipOperator} (
SELECT DISTINCT session_id
FROM events
${finalWhere}
@@ -262,7 +270,7 @@ export function getFilterStatement(
}
if (filter.parameter === "entry_page") {
- const whereClause = [siteIdFilter, timeFilter].filter(Boolean).join(" AND ");
+ const whereClause = [siteIdFilter, timeFilter, "type = 'pageview'"].filter(Boolean).join(" AND ");
const whereStatement = whereClause ? `WHERE ${whereClause}` : "";
const condition = buildStringFilterCondition("entry_pathname", filter.type, filter.value);
@@ -281,7 +289,7 @@ export function getFilterStatement(
}
if (filter.parameter === "exit_page") {
- const whereClause = [siteIdFilter, timeFilter].filter(Boolean).join(" AND ");
+ const whereClause = [siteIdFilter, timeFilter, "type = 'pageview'"].filter(Boolean).join(" AND ");
const whereStatement = whereClause ? `WHERE ${whereClause}` : "";
const condition = buildStringFilterCondition("exit_pathname", filter.type, filter.value);
diff --git a/server/src/api/analytics/utils/sessionFilters.test.ts b/server/src/api/analytics/utils/sessionFilters.test.ts
new file mode 100644
index 000000000..0e7368f9f
--- /dev/null
+++ b/server/src/api/analytics/utils/sessionFilters.test.ts
@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { buildFilteredSessionsCTE } from "./sessionFilters.js";
+
+const SITE_ID = 1;
+const timeStatement = "AND timestamp >= toDateTime('2026-08-01 00:00:00')";
+
+const build = (parameter: string, value: string) =>
+ buildFilteredSessionsCTE(JSON.stringify([{ parameter, type: "equals", value: [value] }]), SITE_ID, timeStatement)!;
+
+describe("buildFilteredSessionsCTE", () => {
+ it("projects only the aggregate needed by a UTM filter", () => {
+ const sql = build("utm_campaign", "launch");
+
+ expect(sql).toContain("argMin(url_parameters, timestamp)['utm_campaign'] AS utm_campaign");
+ expect(sql).not.toContain("argMax(browser,");
+ expect(sql).not.toContain("AS utm_source");
+ expect(sql).not.toContain("feature_flags");
+ });
+
+ it("projects the component columns needed by transformed filters", () => {
+ const sql = build("browser_version", "Chrome 140");
+
+ expect(sql).toContain("argMax(browser, timestamp) AS browser");
+ expect(sql).toContain("argMax(browser_version, timestamp) AS browser_version");
+ expect(sql).not.toContain("argMax(country,");
+ });
+
+ it("uses membership subqueries without projecting unrelated event fields", () => {
+ const sql = build("pathname", "/pricing");
+
+ expect(sql).toContain("session_id IN (");
+ expect(sql).toContain("pathname = '/pricing'");
+ expect(sql).not.toContain("argMax(pathname,");
+ expect(sql).not.toContain("argMax(browser,");
+ });
+});
diff --git a/server/src/api/analytics/utils/sessionFilters.ts b/server/src/api/analytics/utils/sessionFilters.ts
new file mode 100644
index 000000000..8c991333a
--- /dev/null
+++ b/server/src/api/analytics/utils/sessionFilters.ts
@@ -0,0 +1,153 @@
+import { FilterParameter } from "../types.js";
+import { getFilterStatement } from "./getFilterStatement.js";
+import { validateFilters } from "./query-validation.js";
+import { SESSION_REFERRER_AGG } from "./sessionAttribution.js";
+
+// These fields are event-scoped rather than stable session attributes. Session
+// reports include a session when any event matches them; channel has its own
+// acquisition aggregation inside getFilterStatement.
+const SESSION_EVENT_LEVEL_PARAMS: FilterParameter[] = [
+ "event_name",
+ "pathname",
+ "page_title",
+ "querystring",
+ "channel",
+];
+
+// Session aggregates expose UTM values as aliases instead of Map lookups.
+const SESSION_FIELD_MAPPINGS = {
+ "url_parameters['utm_source']": "utm_source",
+ "url_parameters['utm_medium']": "utm_medium",
+ "url_parameters['utm_campaign']": "utm_campaign",
+ "url_parameters['utm_term']": "utm_term",
+ "url_parameters['utm_content']": "utm_content",
+};
+
+// Attributes that describe the measured event itself on target-event reports.
+// Acquisition and cohort fields (UTM, referrer, channel, entry/exit, identity,
+// feature flags) remain session qualifiers.
+export const TARGET_EVENT_ROW_LEVEL_PARAMS: readonly FilterParameter[] = [
+ "hostname",
+ "browser",
+ "browser_version",
+ "operating_system",
+ "operating_system_version",
+ "language",
+ "country",
+ "region",
+ "city",
+ "device_type",
+ "pathname",
+ "page_title",
+ "querystring",
+ "dimensions",
+ "lat",
+ "lon",
+ "timezone",
+ "tag",
+];
+
+export const getSessionFilterStatement = (filters: string | undefined, siteId: number, timeStatement: string) =>
+ getFilterStatement(filters ?? "", siteId, timeStatement, {
+ sessionLevelParams: SESSION_EVENT_LEVEL_PARAMS,
+ fieldMappings: SESSION_FIELD_MAPPINGS,
+ });
+
+/**
+ * Builds one row per session and applies filters to those session attributes.
+ * Analytics queries use the resulting IDs so a landing-page filter and a later
+ * target event can match the same session without occurring on the same row.
+ */
+export const buildFilteredSessionsCTE = (
+ filters: string | undefined,
+ siteId: number,
+ timeStatement: string,
+ cteName = "FilteredSessions"
+): string | null => {
+ if (!filters) return null;
+
+ const parsedFilters = validateFilters(filters);
+ if (parsedFilters.length === 0) return null;
+
+ const filterStatement = getSessionFilterStatement(filters, siteId, timeStatement);
+ if (!filterStatement) return null;
+
+ const aggregates = new Set<string>();
+ const subqueryOnlyParams = new Set<FilterParameter>([...SESSION_EVENT_LEVEL_PARAMS, "entry_page", "exit_page"]);
+
+ for (const { parameter } of parsedFilters) {
+ if (subqueryOnlyParams.has(parameter)) continue;
+
+ if (parameter === "user_id") {
+ aggregates.add("argMax(user_id, timestamp) AS user_id");
+ aggregates.add("argMax(identified_user_id, timestamp) AS identified_user_id");
+ } else if (parameter === "referrer") {
+ aggregates.add(`${SESSION_REFERRER_AGG} AS referrer`);
+ } else if (parameter.startsWith("utm_")) {
+ aggregates.add(`argMin(url_parameters, timestamp)['${parameter}'] AS ${parameter}`);
+ } else if (parameter === "hostname") {
+ aggregates.add("argMin(hostname, timestamp) AS hostname");
+ } else if (parameter === "dimensions") {
+ aggregates.add("argMax(screen_width, timestamp) AS screen_width");
+ aggregates.add("argMax(screen_height, timestamp) AS screen_height");
+ } else if (parameter === "city") {
+ aggregates.add("argMax(region, timestamp) AS region");
+ aggregates.add("argMax(city, timestamp) AS city");
+ } else if (parameter === "browser_version") {
+ aggregates.add("argMax(browser, timestamp) AS browser");
+ aggregates.add("argMax(browser_version, timestamp) AS browser_version");
+ } else if (parameter === "operating_system_version") {
+ aggregates.add("argMax(operating_system, timestamp) AS operating_system");
+ aggregates.add("argMax(operating_system_version, timestamp) AS operating_system_version");
+ } else if (parameter.startsWith("feature_flag:")) {
+ aggregates.add("argMax(feature_flags, timestamp) AS feature_flags");
+ } else {
+ aggregates.add(`argMax(${parameter}, timestamp) AS ${parameter}`);
+ }
+ }
+
+ const aggregateProjection = aggregates.size ? `,\n ${[...aggregates].join(",\n ")}` : "";
+
+ return `${cteName} AS (
+ SELECT session_id
+ FROM (
+ SELECT
+ session_id${aggregateProjection}
+ FROM events
+ WHERE site_id = ${siteId}
+ ${timeStatement}
+ GROUP BY session_id
+ )
+ WHERE 1 = 1 ${filterStatement}
+ )`;
+};
+
+/**
+ * Splits filters for reports that select target event rows inside a qualifying
+ * session. Parameters listed in `rowLevelParams` still constrain the measured
+ * event; every other parameter qualifies the session first.
+ */
+export const buildSessionAndRowFilterFragments = (
+ filters: string | undefined,
+ siteId: number,
+ timeStatement: string,
+ rowLevelParams: readonly FilterParameter[],
+ cteName = "FilteredSessions"
+): { filteredSessionsCTE: string | null; rowFilterStatement: string } => {
+ if (!filters) {
+ return { filteredSessionsCTE: null, rowFilterStatement: "" };
+ }
+
+ const parsedFilters = validateFilters(filters);
+ const rowFilters = parsedFilters.filter(filter => rowLevelParams.includes(filter.parameter));
+ const sessionFilters = parsedFilters.filter(filter => !rowLevelParams.includes(filter.parameter));
+
+ const filteredSessionsCTE = sessionFilters.length
+ ? buildFilteredSessionsCTE(JSON.stringify(sessionFilters), siteId, timeStatement, cteName)
+ : null;
+ const rowFilterStatement = rowFilters.length
+ ? getFilterStatement(JSON.stringify(rowFilters), siteId, timeStatement, { sessionLevelParams: [] })
+ : "";
+
+ return { filteredSessionsCTE, rowFilterStatement };
+};
diff --git a/server/src/api/experiments/getExperimentResults.test.ts b/server/src/api/experiments/getExperimentResults.test.ts
new file mode 100644
index 000000000..a84e994dc
--- /dev/null
+++ b/server/src/api/experiments/getExperimentResults.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../../db/clickhouse/clickhouse.js", () => ({
+ clickhouse: { query: vi.fn() },
+}));
+vi.mock("../../db/postgres/postgres.js", () => ({
+ db: {},
+}));
+
+import { buildExperimentResultQueries } from "./getExperimentResults.js";
+
+const CAMPAIGN_FILTER = JSON.stringify([{ parameter: "utm_campaign", type: "equals", value: ["recipe_book_2026"] }]);
+
+const query = {
+ filters: CAMPAIGN_FILTER,
+ start_date: "",
+ end_date: "",
+ time_zone: "UTC",
+};
+
+const buildQueries = () =>
+ buildExperimentResultQueries({
+ query,
+ siteId: 1,
+ flagKey: "recipe_book_test",
+ goalCondition: "type = 'form_submit' AND JSONExtractString(toString(props), 'formId') = 'gform_115'",
+ });
+
+describe("experiment result queries", () => {
+ it("qualifies the session by its landing campaign before selecting later exposure and goal events", () => {
+ const { exposureQuery } = buildQueries();
+
+ expect(exposureQuery).toContain("FilteredSessions AS");
+ expect(exposureQuery).toContain("argMin(url_parameters, timestamp)['utm_campaign'] AS utm_campaign");
+ expect(exposureQuery).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(exposureQuery.match(/INNER JOIN FilteredSessions USING \(session_id\)/g)).toHaveLength(2);
+ expect(exposureQuery).toContain("event_name = 'feature_flag_exposure'");
+ expect(exposureQuery).toContain("type = 'form_submit'");
+
+ // The campaign condition belongs only to FilteredSessions, not separately
+ // to the exposure and goal event rows.
+ expect(exposureQuery.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ });
+
+ it("uses the same campaign-qualified sessions for assignment fallback and goal events", () => {
+ const { assignmentQuery } = buildQueries();
+
+ expect(assignmentQuery).toContain("FilteredSessions AS");
+ expect(assignmentQuery).toContain("WHERE 1 = 1 AND utm_campaign = 'recipe_book_2026'");
+ expect(assignmentQuery.match(/INNER JOIN FilteredSessions USING \(session_id\)/g)).toHaveLength(2);
+ expect(assignmentQuery).toContain("feature_flags['recipe_book_test'] != ''");
+ expect(assignmentQuery).toContain("type = 'form_submit'");
+ expect(assignmentQuery.match(/utm_campaign = 'recipe_book_2026'/g)).toHaveLength(1);
+ });
+
+ it("attributes a session to its first exposure variant instead of grouping it into every observed variant", () => {
+ const { exposureQuery } = buildQueries();
+
+ expect(exposureQuery).toContain("argMin(JSONExtractString(toString(props), 'value'), timestamp) AS variant");
+ expect(exposureQuery).not.toContain("GROUP BY session_id, variant");
+ });
+
+ it("attributes assignment fallback to the first assigned variant per session", () => {
+ const { assignmentQuery } = buildQueries();
+
+ expect(assignmentQuery).toContain("argMin(feature_flags['recipe_book_test'], timestamp) AS variant");
+ expect(assignmentQuery).not.toContain("GROUP BY session_id, variant");
+ });
+});
diff --git a/server/src/api/experiments/getExperimentResults.ts b/server/src/api/experiments/getExperimentResults.ts
index a0048fcb4..22509902f 100644
--- a/server/src/api/experiments/getExperimentResults.ts
+++ b/server/src/api/experiments/getExperimentResults.ts
@@ -4,7 +4,7 @@ import SqlString from "sqlstring";
import { z } from "zod";
import { clickhouse } from "../../db/clickhouse/clickhouse.js";
import { buildGoalCondition } from "../analytics/goals/goalConditions.js";
-import { getFilterStatement } from "../analytics/utils/getFilterStatement.js";
+import { buildFilteredSessionsCTE } from "../analytics/utils/sessionFilters.js";
import { processResults } from "../analytics/utils/utils.js";
import { getTimeStatement } from "../analytics/utils/timeWindow.js";
import type { ExperimentResultRow } from "./types.js";
@@ -17,6 +17,106 @@ import {
serializeExperiment,
} from "./utils.js";
+type BuildExperimentResultQueriesParams = {
+ query: FilterParams;
+ siteId: number;
+ flagKey: string;
+ goalCondition: string;
+};
+
+export function buildExperimentResultQueries({
+ query,
+ siteId,
+ flagKey,
+ goalCondition,
+}: BuildExperimentResultQueriesParams) {
+ const timeStatement = getTimeStatement(query);
+ const filteredSessionsCte = buildFilteredSessionsCTE(query.filters, siteId, timeStatement);
+ const filteredSessionsJoin = filteredSessionsCte ? "INNER JOIN FilteredSessions USING (session_id)" : "";
+ const filteredSessionsPrefix = filteredSessionsCte ? `${filteredSessionsCte},` : "";
+ const escapedSiteId = SqlString.escape(siteId);
+ const escapedFlagKey = SqlString.escape(flagKey);
+
+ // A session qualifies once, independently of which event carried the filter
+ // value. Goal, exposure, and assignment rows are then scoped to that cohort.
+ const goalSessionsCte = `
+ goal_sessions AS (
+ SELECT
+ session_id,
+ max(timestamp) AS last_goal_at
+ FROM events
+ ${filteredSessionsJoin}
+ WHERE site_id = ${escapedSiteId}
+ AND (${goalCondition})
+ ${timeStatement}
+ GROUP BY session_id
+ )`;
+
+ // The first observed exposure fixes the experiment arm for the session. A
+ // later flag refresh must not count one session in multiple variants.
+ const exposureQuery = `
+ WITH
+ ${filteredSessionsPrefix}
+ exposure_sessions AS (
+ SELECT
+ session_id,
+ argMin(JSONExtractString(toString(props), 'value'), timestamp) AS variant,
+ min(timestamp) AS exposed_at,
+ count() AS exposures
+ FROM events
+ ${filteredSessionsJoin}
+ WHERE site_id = ${escapedSiteId}
+ AND type = 'custom_event'
+ AND event_name = 'feature_flag_exposure'
+ AND JSONExtractString(toString(props), 'key') = ${escapedFlagKey}
+ AND JSONExtractString(toString(props), 'value') != ''
+ ${timeStatement}
+ GROUP BY session_id
+ ),
+ ${goalSessionsCte}
+ SELECT
+ e.variant AS variant,
+ uniqExact(e.session_id) AS sessions,
+ sum(e.exposures) AS exposures,
+ uniqExactIf(e.session_id, g.last_goal_at >= e.exposed_at) AS conversions
+ FROM exposure_sessions e
+ LEFT JOIN goal_sessions g ON g.session_id = e.session_id
+ GROUP BY e.variant
+ ORDER BY e.variant ASC
+ `;
+
+ // Assignment fallback follows the same one-arm-per-session rule, using the
+ // first event that carried an assignment for the flag.
+ const assignmentQuery = `
+ WITH
+ ${filteredSessionsPrefix}
+ assignment_sessions AS (
+ SELECT
+ session_id,
+ argMin(feature_flags[${escapedFlagKey}], timestamp) AS variant,
+ min(timestamp) AS assigned_at
+ FROM events
+ ${filteredSessionsJoin}
+ WHERE site_id = ${escapedSiteId}
+ AND feature_flags[${escapedFlagKey}] != ''
+ ${timeStatement}
+ GROUP BY session_id
+ ),
+ ${goalSessionsCte}
+ SELECT
+ a.variant AS variant,
+ uniqExact(a.session_id) AS sessions,
+ uniqExact(a.session_id) AS exposures,
+ uniqExactIf(a.session_id, g.last_goal_at >= a.assigned_at) AS conversions
+ FROM assignment_sessions a
+ LEFT JOIN goal_sessions g ON g.session_id = a.session_id
+ GROUP BY a.variant
+ ORDER BY a.variant ASC
+ `;
+
+ return { assignmentQuery, exposureQuery };
+}
+
export async function getExperimentResults(
request: FastifyRequest<{
Params: { siteId: string; experimentId: string };
@@ -52,62 +152,12 @@ export async function getExperimentResults(
});
}
- const timeStatement = getTimeStatement(request.query);
- const filterStatement = request.query.filters
- ? getFilterStatement(request.query.filters as string, siteId, timeStatement)
- : "";
- const escapedSiteId = SqlString.escape(siteId);
- const escapedFlagKey = SqlString.escape(record.featureFlag.key);
-
- // One row per session that completed the goal, scoped to the same time
- // window and filters the goals page uses, so experiment conversions can
- // never exceed the goal's own count. Aggregating per session also keeps the
- // join below one-to-one, so exposure counts aren't inflated.
- const goalSessionsCte = `
- goal_sessions AS (
- SELECT
- session_id,
- max(timestamp) AS last_goal_at
- FROM events
- WHERE site_id = ${escapedSiteId}
- AND (${goalCondition})
- ${timeStatement}
- ${filterStatement}
- GROUP BY session_id
- )`;
-
- // Exposure-based: counts only sessions that explicitly read the flag via
- // rybbit.flag(), which emits a feature_flag_exposure event. This is the
- // statistically correct unit of analysis for an experiment.
- const exposureQuery = `
- WITH
- exposure_sessions AS (
- SELECT
- session_id,
- JSONExtractString(toString(props), 'value') AS variant,
- min(timestamp) AS exposed_at,
- count() AS exposures
- FROM events
- WHERE site_id = ${escapedSiteId}
- AND type = 'custom_event'
- AND event_name = 'feature_flag_exposure'
- AND JSONExtractString(toString(props), 'key') = ${escapedFlagKey}
- AND JSONExtractString(toString(props), 'value') != ''
- ${timeStatement}
- ${filterStatement}
- GROUP BY session_id, variant
- ),
- ${goalSessionsCte}
- SELECT
- e.variant AS variant,
- uniqExact(e.session_id) AS sessions,
- sum(e.exposures) AS exposures,
- uniqExactIf(e.session_id, g.last_goal_at >= e.exposed_at) AS conversions
- FROM exposure_sessions e
- LEFT JOIN goal_sessions g ON g.session_id = e.session_id
- GROUP BY e.variant
- ORDER BY e.variant ASC
- `;
+ const { assignmentQuery, exposureQuery } = buildExperimentResultQueries({
+ query: request.query,
+ siteId,
+ flagKey: record.featureFlag.key,
+ goalCondition,
+ });
const exposureResult = await clickhouse.query({ query: exposureQuery, format: "JSONEachRow" });
let rows = await processResults<ExperimentResultRow>(exposureResult);
@@ -119,32 +169,6 @@ export async function getExperimentResults(
// empty result when the flag is clearly assigning traffic.
const hasExposures = rows.some(row => Number(row.sessions) > 0);
if (!hasExposures) {
- const assignmentQuery = `
- WITH
- assignment_sessions AS (
- SELECT
- session_id,
- feature_flags[${escapedFlagKey}] AS variant,
- min(timestamp) AS assigned_at
- FROM events
- WHERE site_id = ${escapedSiteId}
- AND feature_flags[${escapedFlagKey}] != ''
- ${timeStatement}
- ${filterStatement}
- GROUP BY session_id, variant
- ),
- ${goalSessionsCte}
- SELECT
- a.variant AS variant,
- uniqExact(a.session_id) AS sessions,
- uniqExact(a.session_id) AS exposures,
- uniqExactIf(a.session_id, g.last_goal_at >= a.assigned_at) AS conversions
- FROM assignment_sessions a
- LEFT JOIN goal_sessions g ON g.session_id = a.session_id
- GROUP BY a.variant
- ORDER BY a.variant ASC
- `;
-
const assignmentResult = await clickhouse.query({ query: assignmentQuery, format: "JSONEachRow" });
const assignmentRows = await processResults<ExperimentResultRow>(assignmentResult);
if (assignmentRows.some(row => Number(row.sessions) > 0)) {
diff --git a/server/src/services/pdfReports/pdfReportService.ts b/server/src/services/pdfReports/pdfReportService.ts
index 36e91bef0..c4bc82435 100644
--- a/server/src/services/pdfReports/pdfReportService.ts
+++ b/server/src/services/pdfReports/pdfReportService.ts
@@ -11,6 +11,7 @@ import { createServiceLogger } from "../../lib/logger/logger.js";
import {
BreakdownDimension,
buildBreakdownQuery,
+ buildChartQuery,
buildMetricsSpecForWindow,
buildOverviewQuery,
SiteMetricsSpec,
@@ -73,14 +74,12 @@ class PdfReportService {
time_zone: timeZone,
});
- // Each period gets its own filter statement: session-level filters compile to
- // a subquery that is bounded by the time statement passed here, so reusing the
- // current period's filters for the previous one would compare a correctly
- // scoped window against a mis-scoped one and bias every growth percentage.
+ // Each period gets its own qualifying-session CTE, bounded by that period's
+ // time statement. Reusing the current cohort for the previous period would
+ // bias every growth percentage.
const filtersJson = filters ? JSON.stringify(filters) : "";
const spec = buildMetricsSpecForWindow(filtersJson, siteId, timeStatement);
const previousSpec = buildMetricsSpecForWindow(filtersJson, siteId, previousTimeStatement);
- const filterStatement = spec.filterStatement ?? "";
// Determine bucket size based on date range
const bucket = durationDays <= 1 ? "hour" : durationDays <= 60 ? "day" : "week";
@@ -101,7 +100,7 @@ class PdfReportService {
] = await Promise.all([
this.fetchOverviewData(siteId, spec),
this.fetchOverviewData(siteId, previousSpec),
- this.fetchChartData(siteId, startDate, endDate, timeZone, bucket, filterStatement),
+ this.fetchChartData(siteId, timeZone, bucket, spec),
this.fetchTopN(siteId, "country", spec),
this.fetchTopN(siteId, "region", spec),
this.fetchTopN(siteId, "city", spec),
@@ -140,36 +139,20 @@ class PdfReportService {
private async fetchChartData(
siteId: number,
- startDate: string,
- endDate: string,
timeZone: string,
bucket: "hour" | "day" | "week",
- filterStatement: string
+ spec: SiteMetricsSpec
): Promise<ChartDataPoint[]> {
try {
const bucketFn = bucket === "hour" ? "toStartOfHour" : bucket === "day" ? "toStartOfDay" : "toStartOfWeek";
- const query = `
- SELECT
- toString(toTimeZone(${bucketFn}(toTimeZone(timestamp, {timeZone:String})), {timeZone:String})) AS time,
- COUNT(DISTINCT session_id) AS sessions,
- countIf(type = 'pageview') AS pageviews
- FROM events
- WHERE
- site_id = {siteId:Int32}
- AND timestamp >= toDateTime({startDate:String}, {timeZone:String})
- AND timestamp < toDateTime({endDate:String}, {timeZone:String}) + INTERVAL 1 DAY
- ${filterStatement}
- GROUP BY time
- ORDER BY time`;
+ const query = buildChartQuery(spec, bucketFn);
const result = await clickhouse.query({
query,
format: "JSONEachRow",
query_params: {
siteId,
- startDate,
- endDate,
timeZone,
},
});
diff --git a/server/src/services/siteMetrics/siteMetrics.test.ts b/server/src/services/siteMetrics/siteMetrics.test.ts
index 641aa618c..1d7f67911 100644
--- a/server/src/services/siteMetrics/siteMetrics.test.ts
+++ b/server/src/services/siteMetrics/siteMetrics.test.ts
@@ -13,6 +13,7 @@ import { buildOverviewQuery as buildDashboardOverviewQuery } from "../../api/ana
import {
BreakdownDimension,
buildBreakdownQuery,
+ buildChartQuery,
buildMetricsSpec,
buildMetricsSpecForWindow,
buildOverviewQuery,
@@ -32,7 +33,6 @@ const DASHBOARD_PARAMS = {
/** How the PDF report expresses its window: the same builder, no HTTP request. */
const pdfSpec: SiteMetricsSpec = {
timeStatement: getTimeStatement({ start_date: "2026-07-17", end_date: "2026-07-23", time_zone: "UTC" }),
- filterStatement: "",
};
/** How the weekly email expresses its window: an exact UTC datetime range. */
@@ -94,20 +94,21 @@ describe("site metrics", () => {
});
it("reports bounce rate as a percentage of the session's full pageview count", () => {
- const sql = buildOverviewQuery({ timeStatement: "", filterStatement: "AND browser = 'Chrome'" });
+ const filters = JSON.stringify([{ parameter: "browser", type: "equals", value: ["Chrome"] }]);
+ const sql = buildOverviewQuery(buildMetricsSpecForWindow(filters, SITE_ID, ""));
- // A session that saw three pages is not a bounce because a filter hid two
- // of them, so the bounce test reads the unfiltered CTE.
- expect(sql).toContain("sumIf(1, asp.total_pageviews_in_session = 1) / COUNT() * 100 AS bounce_rate");
- const unfilteredCte = sql.split("AllSessionPageviews AS (")[1].split(")")[0];
- expect(unfilteredCte).not.toContain("browser = 'Chrome'");
+ expect(sql).toContain("sumIf(1, f.pageviews = 1) / COUNT() * 100 AS bounce_rate");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
});
- it("applies the filter to the session, pageview and user counts", () => {
- const sql = buildOverviewQuery({ timeStatement: "", filterStatement: "AND browser = 'Chrome'" });
+ it("qualifies sessions before calculating complete session stats", () => {
+ const filters = JSON.stringify([{ parameter: "browser", type: "equals", value: ["Chrome"] }]);
+ const sql = buildOverviewQuery(buildMetricsSpecForWindow(filters, SITE_ID, ""));
const filteredCte = sql.split("FilteredSessionsWithStats AS (")[1];
- expect(filteredCte).toContain("browser = 'Chrome'");
+ expect(sql).toContain("browser = 'Chrome'");
+ expect(filteredCte).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ expect(filteredCte).not.toContain("browser = 'Chrome'");
});
});
@@ -145,9 +146,25 @@ describe("site metrics", () => {
});
it("carries the caller's filters into the breakdown", () => {
- const sql = buildBreakdownQuery("country", { timeStatement: "", filterStatement: "AND browser = 'Chrome'" });
+ const filters = JSON.stringify([{ parameter: "browser", type: "equals", value: ["Chrome"] }]);
+ const sql = buildBreakdownQuery("country", buildMetricsSpecForWindow(filters, SITE_ID, ""));
expect(sql).toContain("browser = 'Chrome'");
+ expect(sql).toContain("INNER JOIN FilteredSessions USING (session_id)");
+ });
+ });
+
+ describe("buildChartQuery", () => {
+ it("counts each qualifying session in its start bucket while retaining all pageviews", () => {
+ const filters = JSON.stringify([{ parameter: "utm_campaign", type: "equals", value: ["launch"] }]);
+ const sql = buildChartQuery(buildMetricsSpecForWindow(filters, SITE_ID, pdfSpec.timeStatement), "toStartOfDay");
+
+ expect(sql).toContain("SessionStarts AS (");
+ expect(sql).toContain("min(timestamp) AS session_start");
+ expect(sql).toContain("FROM SessionStarts");
+ expect(sql).toContain("count() AS sessions");
+ expect(sql.match(/INNER JOIN FilteredSessions USING \(session_id\)/g)).toHaveLength(2);
+ expect(sql).toContain("countIf(type = 'pageview') AS pageviews");
});
});
@@ -159,7 +176,7 @@ describe("site metrics", () => {
);
expect(spec.timeStatement).toContain("2026-07-17");
- expect(spec.filterStatement).toContain("Chrome");
+ expect(spec.filteredSessionsCTE).toContain("Chrome");
});
it("bounds a session-level filter's subquery to the spec's own window", () => {
@@ -169,8 +186,8 @@ describe("site metrics", () => {
const eventFilter = JSON.stringify([{ parameter: "event_name", type: "equals", value: ["signup"] }]);
const spec = buildMetricsSpecForWindow(eventFilter, SITE_ID, pdfSpec.timeStatement);
- expect(spec.filterStatement).toContain("session_id IN (");
- expect(spec.filterStatement).toContain("2026-07-17");
+ expect(spec.filteredSessionsCTE).toContain("session_id IN (");
+ expect(spec.filteredSessionsCTE).toContain("2026-07-17");
});
it("scopes each period's filters to that period, so growth comparisons are fair", () => {
@@ -182,9 +199,9 @@ describe("site metrics", () => {
getTimeStatement({ start_date: "2026-07-10", end_date: "2026-07-16", time_zone: "UTC" })
);
- expect(current.filterStatement).toContain("2026-07-17");
- expect(previous.filterStatement).toContain("2026-07-10");
- expect(previous.filterStatement).not.toContain("2026-07-23");
+ expect(current.filteredSessionsCTE).toContain("2026-07-17");
+ expect(previous.filteredSessionsCTE).toContain("2026-07-10");
+ expect(previous.filteredSessionsCTE).not.toContain("2026-07-23");
});
});
});
diff --git a/server/src/services/siteMetrics/siteMetrics.ts b/server/src/services/siteMetrics/siteMetrics.ts
index 1fc32175e..66f5d9e37 100644
--- a/server/src/services/siteMetrics/siteMetrics.ts
+++ b/server/src/services/siteMetrics/siteMetrics.ts
@@ -1,6 +1,6 @@
import { FilterParams } from "@rybbit/shared";
import { EFFECTIVE_SESSION_USER_ID } from "../../api/analytics/utils/effectiveUserId.js";
-import { getFilterStatement } from "../../api/analytics/utils/getFilterStatement.js";
+import { buildFilteredSessionsCTE } from "../../api/analytics/utils/sessionFilters.js";
import { getTimeStatement } from "../../api/analytics/utils/timeWindow.js";
/**
@@ -38,18 +38,19 @@ export interface BreakdownRow {
percentage: number | null;
}
+export type ChartBucketFunction = "toStartOfHour" | "toStartOfDay" | "toStartOfWeek";
+
/**
* The window and filters a metrics query runs over.
*
- * Both fields are SQL fragments that already begin with `AND` (or are empty), so
- * they drop straight into a `WHERE`. Callers build the time statement however
- * suits them — {@link buildMetricsSpec} from HTTP query params, or
- * `getTimeStatement` directly from a datetime range — and bind `siteId` (and
- * `limit`, for breakdowns) as query parameters at execution time.
+ * Callers build the time statement however suits them — {@link buildMetricsSpec}
+ * from HTTP query params, or `getTimeStatement` directly from a datetime range.
+ * When filters are present, `filteredSessionsCTE` identifies the qualifying
+ * sessions so every metric can use the session's complete activity.
*/
export interface SiteMetricsSpec {
timeStatement: string;
- filterStatement?: string;
+ filteredSessionsCTE?: string;
}
/**
@@ -67,7 +68,7 @@ export interface SiteMetricsSpec {
export function buildMetricsSpecForWindow(filters: string, siteId: number, timeStatement: string): SiteMetricsSpec {
return {
timeStatement,
- filterStatement: getFilterStatement(filters, siteId, timeStatement),
+ filteredSessionsCTE: buildFilteredSessionsCTE(filters, siteId, timeStatement) ?? undefined,
};
}
@@ -80,25 +81,17 @@ export function buildMetricsSpec(params: FilterParams, siteId: number): SiteMetr
* Sessions, pageviews, users, pages per session, bounce rate and session duration
* for one window. Binds `{siteId:Int32}`.
*
- * Pages per session and bounce rate deliberately read from `AllSessionPageviews`,
- * which is *not* filtered: a session that landed on three pages is not a bounce
- * just because a filter narrowed the view to one of them.
+ * Filters qualify session IDs first: a session that landed on three pages is not
+ * a bounce, and does not lose duration or pageviews, because its acquisition
+ * filter happened to match only the landing event.
*/
export function buildOverviewQuery(spec: SiteMetricsSpec): string {
- const { timeStatement, filterStatement = "" } = spec;
+ const { timeStatement, filteredSessionsCTE } = spec;
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
return `
WITH
- AllSessionPageviews AS (
- SELECT
- session_id,
- countIf(type = 'pageview') AS total_pageviews_in_session
- FROM events
- WHERE
- site_id = {siteId:Int32}
- ${timeStatement}
- GROUP BY session_id
- ),
+ ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
FilteredSessionsWithStats AS (
SELECT
session_id,
@@ -107,35 +100,27 @@ export function buildOverviewQuery(spec: SiteMetricsSpec): string {
${EFFECTIVE_SESSION_USER_ID} AS effective_user_id,
MIN(timestamp) AS start_time,
MAX(timestamp) AS end_time,
- countIf(type = 'pageview') AS filtered_pageviews
+ countIf(type = 'pageview') AS pageviews
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
- ${filterStatement}
${timeStatement}
GROUP BY session_id
)
SELECT
COUNT() AS sessions,
- AVG(asp.total_pageviews_in_session) AS pages_per_session,
- sumIf(1, asp.total_pageviews_in_session = 1) / COUNT() * 100 AS bounce_rate,
+ AVG(f.pageviews) AS pages_per_session,
+ sumIf(1, f.pageviews = 1) / COUNT() * 100 AS bounce_rate,
AVG(f.end_time - f.start_time) AS session_duration,
- SUM(f.filtered_pageviews) AS pageviews,
+ SUM(f.pageviews) AS pageviews,
COUNT(DISTINCT f.effective_user_id) AS users
- FROM FilteredSessionsWithStats f
- LEFT JOIN AllSessionPageviews asp ON f.session_id = asp.session_id`;
+ FROM FilteredSessionsWithStats f`;
}
/** The dimensions a report can be broken down by. */
export type BreakdownDimension =
- | "browser"
- | "city"
- | "country"
- | "device_type"
- | "operating_system"
- | "pathname"
- | "referrer"
- | "region";
+ "browser" | "city" | "country" | "device_type" | "operating_system" | "pathname" | "referrer" | "region";
interface DimensionDefinition {
/** The expression rows are grouped by and reported as `value`. */
@@ -170,21 +155,22 @@ const DIMENSIONS: Record<BreakdownDimension, DimensionDefinition> = {
*/
export function buildBreakdownQuery(dimension: BreakdownDimension, spec: SiteMetricsSpec): string {
const { expression, restriction = "" } = DIMENSIONS[dimension];
- const { timeStatement, filterStatement = "" } = spec;
+ const { timeStatement, filteredSessionsCTE } = spec;
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
return `
- WITH BreakdownStats AS (
+ WITH ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""} BreakdownStats AS (
SELECT
${expression} AS value,
COUNT(DISTINCT session_id) AS unique_sessions
FROM events
+ ${sessionJoin}
WHERE
site_id = {siteId:Int32}
AND ${expression} IS NOT NULL
AND ${expression} <> ''
${restriction}
${timeStatement}
- ${filterStatement}
GROUP BY value
)
SELECT
@@ -195,3 +181,51 @@ export function buildBreakdownQuery(dimension: BreakdownDimension, spec: SiteMet
ORDER BY count DESC, value ASC
LIMIT {limit:Int32}`;
}
+
+/** Sessions bucketed by session start, alongside pageviews bucketed by event time. */
+export function buildChartQuery(spec: SiteMetricsSpec, bucketFn: ChartBucketFunction): string {
+ const { timeStatement, filteredSessionsCTE } = spec;
+ const sessionJoin = filteredSessionsCTE ? "INNER JOIN FilteredSessions USING (session_id)" : "";
+ const bucket = (column: string) =>
+ `toString(toTimeZone(${bucketFn}(toTimeZone(${column}, {timeZone:String})), {timeZone:String}))`;
+
+ return `
+ WITH
+ ${filteredSessionsCTE ? `${filteredSessionsCTE},` : ""}
+ SessionStarts AS (
+ SELECT
+ session_id,
+ min(timestamp) AS session_start
+ FROM events
+ ${sessionJoin}
+ WHERE
+ site_id = {siteId:Int32}
+ ${timeStatement}
+ GROUP BY session_id
+ ),
+ SessionStats AS (
+ SELECT
+ ${bucket("session_start")} AS time,
+ count() AS sessions
+ FROM SessionStarts
+ GROUP BY time
+ ),
+ PageStats AS (
+ SELECT
+ ${bucket("timestamp")} AS time,
+ countIf(type = 'pageview') AS pageviews
+ FROM events
+ ${sessionJoin}
+ WHERE
+ site_id = {siteId:Int32}
+ ${timeStatement}
+ GROUP BY time
+ )
+ SELECT
+ time,
+ coalesce(sessions, 0) AS sessions,
+ coalesce(pageviews, 0) AS pageviews
+ FROM SessionStats
+ FULL JOIN PageStats USING (time)
+ ORDER BY time`;
+}