:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(insights): return series custom_name on insight result rows (#127441)
Thomas Obermüller27db03406400
diff --git a/posthog/hogql_queries/query_runner.py b/posthog/hogql_queries/query_runner.pyindex af4837d9910f..9fe5a87e7ba7 100644--- a/posthog/hogql_queries/query_runner.py+++ b/posthog/hogql_queries/query_runner.py@@ -2130,11 +2130,27 @@ class QueryRunner(ABC, Generic[Q, R, CR]):isinstance(data, dict) and "is_cached" in data)- def _query_has_series_custom_names(self) -> bool:- # apply_series_custom_names patches only funnel steps, so another query kind has nothing to patch- if not isinstance(self.query, FunnelsQuery):+ def _series_custom_names(self) -> list[str | None] | None:+ """Each series' `custom_name`, indexed like the `order` on the query's result rows.++ Returns None when apply_series_custom_names has nothing to patch: another query kind, or a trends formula.+ A formula row takes its `order` and its name from the formula nodes, and the cache key includes those.+ """+ query = self.query+ if isinstance(query, TrendsQuery) and query.trendsFilter is not None:+ if query.trendsFilter.formulaNodes or query.trendsFilter.formula:+ return None+ if not isinstance(query, TrendsQuery | FunnelsQuery | StickinessQuery | LifecycleQuery):+ return None+ return [series.custom_name for series in query.series]++ def _cached_results_need_custom_name_patch(self, results_have_custom_names: bool) -> bool:+ # A named trends formula row sets results_have_custom_names, but _series_custom_names skips formulas,+ # so that flag alone must not force the results off the raw-bytes path.+ custom_names = self._series_custom_names()+ if custom_names is None:return False- return any(s.custom_name is not None for s in self.query.series)+ return results_have_custom_names or any(name is not None for name in custom_names)@propertydef _limit_context_aliased_for_cache(self) -> LimitContext:@@ -2254,19 +2270,16 @@ class QueryRunner(ABC, Generic[Q, R, CR]):# payload. Only safe when the caller opted in AND validation of the parsed results# wouldn't add protection (the response class types them as plain data — for# model-typed results, e.g. retention, validating a `[]` placeholder would bypass- # the schema-drift check that triggers recomputation) AND neither the query nor- # the cached results carry custom series names — otherwise- # apply_series_custom_names below must be able to patch the parsed results.+ # the schema-drift check that triggers recomputation) AND apply_series_custom_names+ # below has no series name to patch into the parsed results.split_candidate = entryif split_candidate is None:cached_response_candidate = Noneelse:cached_response_candidate = split_candidate.headerif split_candidate.results_bytes is not None:- if (- response_results_contain_models(CachedResponse)- or split_candidate.results_have_custom_names- or self._query_has_series_custom_names()+ if response_results_contain_models(CachedResponse) or self._cached_results_need_custom_name_patch(+ split_candidate.results_have_custom_names):cached_response_candidate["results"] = orjson.loads(split_candidate.results_bytes)else:@@ -3319,9 +3332,10 @@ class QueryRunner(ABC, Generic[Q, R, CR]):Tuple of (patched_response, was_modified) - was_modified is True if anycustom_name values were actually changed."""- if isinstance(self.query, FunnelsQuery):- return self._apply_funnels_custom_names(cached_response)- return cached_response, False+ custom_names = self._series_custom_names()+ if custom_names is None:+ return cached_response, False+ return self._apply_custom_names_by_order(cached_response, custom_names)def _fill_action_names(self, response: object) -> None:"""Set `action_names` on a trends, stickiness or lifecycle response that lacks it.@@ -3342,52 +3356,30 @@ class QueryRunner(ABC, Generic[Q, R, CR]):if response.action_names is None:response.action_names = get_response_action_names(self.team, self.query.model_dump(mode="json"))- def _apply_funnels_custom_names(self, cached_response: CR) -> tuple[CR, bool]:+ def _apply_custom_names_by_order(self, cached_response: CR, custom_names: list[str | None]) -> tuple[CR, bool]:"""- Apply custom_name values to FunnelsQuery results (top-level of step dict).+ Set the top-level `custom_name` of each result row to the name of the series at the row's `order`.- Funnel results have two structures:- - Without breakdown: flat list of steps [step1, step2, ...]- - With breakdown: list of lists [[step1, step2], [step1, step2], ...]+ Results have two structures:+ - Flat list of rows: trends series, stickiness series, lifecycle statuses, funnel steps without breakdown+ - Funnel steps with breakdown: list of lists [[step1, step2], [step1, step2], ...]"""- series = getattr(self.query, "series", None)- if not series:- return cached_response, False-results = getattr(cached_response, "results", None)if not results or not isinstance(results, list):return cached_response, False- custom_names_by_order: dict[int, str | None] = {}- for i, s in enumerate(series):- custom_name = getattr(s, "custom_name", None)- custom_names_by_order[i] = custom_name+ rows = [row for group in results for row in group] if isinstance(results[0], list) else resultswas_modified = False-- if results and len(results) > 0 and isinstance(results[0], list):- # Breakdown case: iterate through each breakdown group- for breakdown_group in results:- for step in breakdown_group:- if not isinstance(step, dict):- continue- order = step.get("order")- if order is not None and order in custom_names_by_order:- new_name = custom_names_by_order[order]- if step.get("custom_name") != new_name:- step["custom_name"] = new_name- was_modified = True- else:- # Non-breakdown case: flat list of steps- for step in results:- if not isinstance(step, dict):- continue- order = step.get("order")- if order is not None and order in custom_names_by_order:- new_name = custom_names_by_order[order]- if step.get("custom_name") != new_name:- step["custom_name"] = new_name- was_modified = True+ for row in rows:+ if not isinstance(row, dict):+ continue+ order = row.get("order")+ if not isinstance(order, int) or not 0 <= order < len(custom_names):+ continue+ if row.get("custom_name") != custom_names[order]:+ row["custom_name"] = custom_names[order]+ was_modified = Truereturn cached_response, was_modifieddiff --git a/products/product_analytics/backend/hogql_queries/lifecycle/lifecycle_query_runner.py b/products/product_analytics/backend/hogql_queries/lifecycle/lifecycle_query_runner.pyindex 79dd16ac9b28..f9993712f618 100644--- a/products/product_analytics/backend/hogql_queries/lifecycle/lifecycle_query_runner.py+++ b/products/product_analytics/backend/hogql_queries/lifecycle/lifecycle_query_runner.py@@ -210,7 +210,7 @@ class LifecycleQueryRunner(AnalyticsQueryRunner[LifecycleQueryResponse]):Columns are accessed by name (date, total, status) to support arbitrarycolumn ordering (materialized tables return columns alphabetically).- Returns list of dicts with: action, data, count, labels, days, order, label, status.+ Returns list of dicts with: data, count, labels, days, order, custom_name, label, status."""series = self.first_seriescols = {name: i for i, name in enumerate(response.columns or [])}@@ -254,6 +254,7 @@ class LifecycleQueryRunner(AnalyticsQueryRunner[LifecycleQueryResponse]):"labels": labels,"days": days,"order": 0,+ "custom_name": series.custom_name,**additional_values,})diff --git a/products/product_analytics/backend/hogql_queries/lifecycle/test/test_lifecycle_query_runner.py b/products/product_analytics/backend/hogql_queries/lifecycle/test/test_lifecycle_query_runner.pyindex 967f099f1850..9af417be6a60 100644--- a/products/product_analytics/backend/hogql_queries/lifecycle/test/test_lifecycle_query_runner.py+++ b/products/product_analytics/backend/hogql_queries/lifecycle/test/test_lifecycle_query_runner.py@@ -188,6 +188,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "new",},{@@ -233,6 +234,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "returning",},{@@ -278,6 +280,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "resurrecting",},{@@ -323,6 +326,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "dormant",},],@@ -438,6 +442,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "new",},{@@ -483,6 +488,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "returning",},{@@ -528,6 +534,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "resurrecting",},{@@ -573,6 +580,7 @@ class TestLifecycleQueryRetentionGroupAggregation(ClickhouseTestMixin, APIBaseTe"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "dormant",},],@@ -914,6 +922,7 @@ class TestLifecycleQueryRunner(ClickhouseTestMixin, APIBaseTest):"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "new",},{@@ -959,6 +968,7 @@ class TestLifecycleQueryRunner(ClickhouseTestMixin, APIBaseTest):"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "returning",},{@@ -1004,6 +1014,7 @@ class TestLifecycleQueryRunner(ClickhouseTestMixin, APIBaseTest):"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "resurrecting",},{@@ -1049,6 +1060,7 @@ class TestLifecycleQueryRunner(ClickhouseTestMixin, APIBaseTest):"19-Jan-2020",],"order": 0,+ "custom_name": None,"status": "dormant",},],diff --git a/products/product_analytics/backend/hogql_queries/stickiness/stickiness_query_runner.py b/products/product_analytics/backend/hogql_queries/stickiness/stickiness_query_runner.pyindex 146353c1d65e..8590f766f535 100644--- a/products/product_analytics/backend/hogql_queries/stickiness/stickiness_query_runner.py+++ b/products/product_analytics/backend/hogql_queries/stickiness/stickiness_query_runner.py@@ -359,6 +359,7 @@ class StickinessQueryRunner(AnalyticsQueryRunner[StickinessQueryResponse]):"data": data,"days": val[1],"order": series_with_extra.series_order,+ "custom_name": series_with_extra.series.custom_name,"label": "All events" if series_label is None else series_label,"labels": [f"{day} {self.query_date_range.interval_name}{'' if day == 1 else 's'} or more"diff --git a/products/product_analytics/backend/hogql_queries/trends/calendar_heatmap_trends_query_runner.py b/products/product_analytics/backend/hogql_queries/trends/calendar_heatmap_trends_query_runner.pyindex 382197bb80d2..7e850a86e258 100644--- a/products/product_analytics/backend/hogql_queries/trends/calendar_heatmap_trends_query_runner.py+++ b/products/product_analytics/backend/hogql_queries/trends/calendar_heatmap_trends_query_runner.py@@ -68,6 +68,7 @@ class CalendarHeatmapTrendsQueryRunner(TrendsQueryRunner):{"label": self.series_event(self.query.series[0]) if self.query.series else "Heatmap","order": 0,+ "custom_name": self.series_custom_name(self.query.series[0]) if self.query.series else None,"data": [], # Empty array for non-time-series data"aggregated_value": results.allAggregations,"calendar_heatmap_data": results, # Store the original heatmap datadiff --git a/products/product_analytics/backend/hogql_queries/trends/test/test_formula.py b/products/product_analytics/backend/hogql_queries/trends/test/test_formula.pyindex 67430a364544..4adf70f220c3 100644--- a/products/product_analytics/backend/hogql_queries/trends/test/test_formula.py+++ b/products/product_analytics/backend/hogql_queries/trends/test/test_formula.py@@ -563,6 +563,7 @@ class TestFormula(ClickhouseTestMixin, APIBaseTest):"label": "Formula (B / A)","breakdown_value": "Paris","order": 0,+ "custom_name": None,},{"data": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],@@ -590,6 +591,7 @@ class TestFormula(ClickhouseTestMixin, APIBaseTest):"label": "Formula (B / A)","breakdown_value": "London","order": 0,+ "custom_name": None,},],)diff --git a/products/product_analytics/backend/hogql_queries/trends/test/test_trends_query_runner.py b/products/product_analytics/backend/hogql_queries/trends/test/test_trends_query_runner.pyindex fa56c842793c..282bf05aa13d 100644--- a/products/product_analytics/backend/hogql_queries/trends/test/test_trends_query_runner.py+++ b/products/product_analytics/backend/hogql_queries/trends/test/test_trends_query_runner.py@@ -472,19 +472,28 @@ class TestTrendsQueryRunner(ClickhouseTestMixin, APIBaseTest):limit_context=limit_context,).calculate()- def test_trends_label(self):+ @parameterized.expand(+ [+ ("unnamed", {}, None),+ ("custom_name_wins_over_name", {"name": "Views", "custom_name": "Page views"}, "Page views"),+ ("name_override", {"name": "Views"}, "Views"),+ ("name_matching_the_event", {"name": "$pageview"}, None),+ ]+ )+ def test_trends_label(self, _name: str, rename: dict[str, str], expected_custom_name: str | None):self._create_test_events()response = self._run_trends_query(self.default_date_from,self.default_date_to,IntervalType.DAY,- None,+ [EventsNode(event="$pageview", **rename)],None,None,)self.assertEqual("$pageview", response.results[0]["label"])+ self.assertEqual(expected_custom_name, response.results[0]["custom_name"])def test_multi_series_builds_database_once(self):self._create_test_events()@@ -1739,6 +1748,10 @@ class TestTrendsQueryRunner(ClickhouseTestMixin, APIBaseTest):assert response.results[3]["count"] == 16assert response.results[3]["data"] == [1, 0, 2, 4, 4, 0, 2, 1, 1, 0, 1, 0]+ assert [result["custom_name"] for result in response.results] == [+ result["label"] for result in response.results+ ]+def test_formula_with_multi_cohort_all_breakdown_with_compare(self):self._create_test_events()cohort1 = Cohort.objects.create(diff --git a/products/product_analytics/backend/hogql_queries/trends/trends_query_runner.py b/products/product_analytics/backend/hogql_queries/trends/trends_query_runner.pyindex 26899742b163..eb822f14bfe1 100644--- a/products/product_analytics/backend/hogql_queries/trends/trends_query_runner.py+++ b/products/product_analytics/backend/hogql_queries/trends/trends_query_runner.py@@ -67,6 +67,7 @@ from posthog.hogql_queries.utils.parallel import run_in_parallel_threadsfrom posthog.hogql_queries.utils.query_compare_to_date_range import QueryCompareToDateRangefrom posthog.hogql_queries.utils.query_date_range import QueryDateRangefrom posthog.hogql_queries.utils.query_previous_period_date_range import QueryPreviousPeriodDateRange+from posthog.hogql_queries.utils.result_series import get_action_names, get_series_custom_namefrom posthog.hogql_queries.utils.sampling import correct_result_for_samplingfrom posthog.hogql_queries.utils.timestamp_utils import format_label_date, get_earliest_timestamp_from_seriesfrom posthog.hogql_queries.utils.utils import get_response_hogql@@ -100,6 +101,20 @@ from products.product_analytics.backend.hogql_queries.trends.trends_query_buildefrom products.warehouse_sources.backend.facade.hogql import get_view_or_table_by_name+def resolve_series_custom_name(+ series: Union[EventsNode, ActionsNode, DataWarehouseNode, GroupNode], series_label: str | None+) -> str | None:+ # A series' display override for legends and tooltips. `custom_name` is set by the in-app+ # "Rename graph series" modal; a `name` that differs from the series label (None for all events)+ # is a rename applied via the query editor or API. Either should win over the raw event name.+ # get_series_custom_name applies the same rule to a serialized node, for exports and cache hits.+ if series.custom_name:+ return series.custom_name+ if series.name and series.name != series_label:+ return series.name+ return None++class TrendsQueryRunner(AnalyticsQueryRunner[TrendsQueryResponse]):query: TrendsQuerycached_response: CachedTrendsQueryResponse@@ -760,6 +775,7 @@ class TrendsQueryRunner(AnalyticsQueryRunner[TrendsQueryResponse]):]series_object["order"] = series.series_order+ series_object["custom_name"] = resolve_series_custom_name(series.series, series_label)res.append(series_object)return res@@ -896,6 +912,34 @@ class TrendsQueryRunner(AnalyticsQueryRunner[TrendsQueryResponse]):return None # type: ignore [unreachable]+ def series_custom_name(self, series: Union[EventsNode, ActionsNode, DataWarehouseNode, GroupNode]) -> str | None:+ """The `custom_name` that build_series_response writes on the rows of this series."""+ if series.custom_name:+ return series.custom_name+ if not series.name:+ return None+ # The series label costs a query for an action series, so it is resolved only when a `name` needs comparing+ try:+ series_label = self.series_event(series)+ except Action.DoesNotExist:+ # build_series_response drops a series whose action is gone, so no row reads this name+ return None+ return resolve_series_custom_name(series, series_label)++ def _series_custom_names(self) -> list[str | None] | None:+ if super()._series_custom_names() is None:+ return None+ return self._resolved_series_custom_names++ @cached_property+ def _resolved_series_custom_names(self) -> list[str | None]:+ # A cache hit asks for the names twice: to decide whether to parse the results, then to patch them.+ # get_action_names loads every action the series reference in one query, where series_event runs one per series.+ series_query = {"series": [series.model_dump(mode="json") for series in self.query.series]}+ needs_label = any(not series.custom_name and series.name for series in self.query.series)+ action_names = get_action_names(self.team, series_query) if needs_label else {}+ return [get_series_custom_name(node, action_names) for node in series_query["series"]]+def update_hogql_modifiers(self) -> None:if (self.modifiers.inCohortVia == InCohortVia.AUTO@@ -1157,6 +1201,7 @@ class TrendsQueryRunner(AnalyticsQueryRunner[TrendsQueryResponse]):formula = formula_node.formulabase_result = results_group[0]base_result["label"] = formula_node.custom_name or f"Formula ({formula})"+ base_result["custom_name"] = formula_node.custom_nameif aggregate_values:series_data = [[s["aggregated_value"]] for s in results_group]diff --git a/products/product_analytics/backend/tests/test_series_custom_name_cache.py b/products/product_analytics/backend/tests/test_series_custom_name_cache.pynew file mode 100644index 000000000000..f514bf8112f5--- /dev/null+++ b/products/product_analytics/backend/tests/test_series_custom_name_cache.py@@ -0,0 +1,162 @@+import json+from typing import Any++from posthog.test.base import BaseTest+from unittest import mock++from django.db import connection+from django.test.utils import CaptureQueriesContext++from parameterized import parameterized++from posthog.schema import (+ ActionsNode,+ CachedLifecycleQueryResponse,+ CachedStickinessQueryResponse,+ CachedTrendsQueryResponse,+ EventsNode,+ LifecycleQuery,+ LifecycleQueryResponse,+ StickinessQuery,+ StickinessQueryResponse,+ TrendsFilter,+ TrendsFormulaNode,+ TrendsQuery,+ TrendsQueryResponse,+)++from posthog.hogql_queries.query_runner import ExecutionMode, QueryRunner++from products.actions.backend.models.action import Action+from products.product_analytics.backend.hogql_queries.lifecycle.lifecycle_query_runner import LifecycleQueryRunner+from products.product_analytics.backend.hogql_queries.stickiness.stickiness_query_runner import StickinessQueryRunner+from products.product_analytics.backend.hogql_queries.trends.trends_query_runner import TrendsQueryRunner++RENAMED = {"custom_name": "Renamed"}+FORMULA = {"trendsFilter": TrendsFilter(formulaNodes=[TrendsFormulaNode(formula="A", custom_name="Total")])}+++class TestSeriesCustomNameCache(BaseTest):+ @parameterized.expand(+ [+ ("trends", TrendsQueryRunner, TrendsQuery, TrendsQueryResponse, {}, {}, RENAMED, None, "Renamed", False),+ (+ "trends_cleared_custom_name_falls_back_to_name",+ TrendsQueryRunner,+ TrendsQuery,+ TrendsQueryResponse,+ {},+ {"name": "Views", "custom_name": "Old"},+ {"name": "Views"},+ "Old",+ "Views",+ False,+ ),+ (+ "trends_name_matching_the_event_serves_raw",+ TrendsQueryRunner,+ TrendsQuery,+ TrendsQueryResponse,+ {},+ {"name": "$pageview"},+ {"name": "$pageview"},+ None,+ None,+ True,+ ),+ (+ "stickiness",+ StickinessQueryRunner,+ StickinessQuery,+ StickinessQueryResponse,+ {},+ {},+ RENAMED,+ None,+ "Renamed",+ False,+ ),+ (+ "lifecycle",+ LifecycleQueryRunner,+ LifecycleQuery,+ LifecycleQueryResponse,+ {},+ {},+ RENAMED,+ None,+ "Renamed",+ False,+ ),+ (+ "trends_formula_keeps_the_formula_name_and_serves_raw",+ TrendsQueryRunner,+ TrendsQuery,+ TrendsQueryResponse,+ FORMULA,+ {},+ RENAMED,+ "Total",+ "Total",+ True,+ ),+ ]+ )+ def test_raw_cache_read_patches_a_series_renamed_after_caching(+ self,+ _name: str,+ runner_class: type[QueryRunner],+ query_class: type[TrendsQuery | StickinessQuery | LifecycleQuery],+ response_class: type[TrendsQueryResponse | StickinessQueryResponse | LifecycleQueryResponse],+ query_kwargs: dict[str, Any],+ cached_series: dict[str, str],+ current_series: dict[str, str],+ cached_custom_name: str | None,+ expected_custom_name: str | None,+ served_raw: bool,+ ) -> None:+ cached_rows = [{"order": 0, "custom_name": cached_custom_name, "data": [1]}]+ with mock.patch.object(runner_class, "calculate", return_value=response_class(results=cached_rows)):+ runner_class(+ query=query_class(series=[EventsNode(event="$pageview", **cached_series)], **query_kwargs),+ team=self.team,+ ).run(execution_mode=ExecutionMode.CALCULATE_BLOCKING_ALWAYS)++ runner = runner_class(+ query=query_class(series=[EventsNode(event="$pageview", **current_series)], **query_kwargs),+ team=self.team,+ )+ runner.serve_raw_cached_results = True+ response = runner.run(execution_mode=ExecutionMode.CACHE_ONLY_NEVER_CALCULATE)++ assert isinstance(+ response, CachedTrendsQueryResponse | CachedStickinessQueryResponse | CachedLifecycleQueryResponse+ )+ raw_results = runner.raw_cached_results_bytes+ assert (raw_results is not None) == served_raw+ results = json.loads(raw_results) if raw_results is not None else response.results+ assert [row["custom_name"] for row in results] == [expected_custom_name]++ def test_cache_hit_resolves_action_series_names_in_one_query(self) -> None:+ signed_up = Action.objects.create(team=self.team, name="Signed up", steps_json=[{"event": "signed up"}])+ paid = Action.objects.create(team=self.team, name="Paid", steps_json=[{"event": "paid"}])+ query = TrendsQuery(+ series=[+ ActionsNode(id=signed_up.pk, name="Signed up"),+ ActionsNode(id=paid.pk, name="Converted"),+ ActionsNode(id=paid.pk, name="Revenue"),+ ]+ )+ cached_rows = [{"order": order, "custom_name": None, "data": [1]} for order in range(3)]+ with mock.patch.object(TrendsQueryRunner, "_calculate", return_value=TrendsQueryResponse(results=cached_rows)):+ TrendsQueryRunner(query=query, team=self.team).run(execution_mode=ExecutionMode.CALCULATE_BLOCKING_ALWAYS)++ runner = TrendsQueryRunner(query=query, team=self.team)+ runner.serve_raw_cached_results = True+ with CaptureQueriesContext(connection) as queries:+ response = runner.run(execution_mode=ExecutionMode.CACHE_ONLY_NEVER_CALCULATE)++ assert isinstance(response, CachedTrendsQueryResponse)+ assert [row["custom_name"] for row in response.results] == [None, "Converted", "Revenue"]+ action_queries = [query["sql"] for query in queries.captured_queries if 'FROM "posthog_action"' in query["sql"]]+ assert len(action_queries) == 1, action_queriesdiff --git a/products/product_analytics/frontend/insights/funnels/funnelDataLogic.ts b/products/product_analytics/frontend/insights/funnels/funnelDataLogic.tsindex 244705119d18..6de97e8b024e 100644--- a/products/product_analytics/frontend/insights/funnels/funnelDataLogic.ts+++ b/products/product_analytics/frontend/insights/funnels/funnelDataLogic.ts@@ -221,10 +221,10 @@ function describesStep(node: FunnelsQuerySeriesNodeUnion, step: FunnelStepWithNe/*** Cached results carry the step names from the run that produced them, so a step renamed since then- * renders under its old label. Mirrors `_apply_funnels_custom_names` in `query_runner.py`, which the+ * renders under its old label. Mirrors `_apply_custom_names_by_order` in `query_runner.py`, which the* stored-result path bypasses: the query wins in both directions. A cleared `custom_name` falls back* to a `name` override, and blanks the label only when `name` matches the raw key. The `name` half is- * a widening `_apply_funnels_custom_names` does not yet share, so backend-rendered surfaces — CSV+ * a widening `_apply_custom_names_by_order` does not yet share, so backend-rendered surfaces — CSV* exports and API consumers reading `results[].custom_name` — keep the raw label until it does.* Unordered funnels are exempt because they label steps by position, not by series.*/diff --git a/products/web_analytics/backend/hogql_queries/test/test_web_trends_lazy_precompute.py b/products/web_analytics/backend/hogql_queries/test/test_web_trends_lazy_precompute.pyindex b8fa7139cbe0..c0929f85c46d 100644--- a/products/web_analytics/backend/hogql_queries/test/test_web_trends_lazy_precompute.py+++ b/products/web_analytics/backend/hogql_queries/test/test_web_trends_lazy_precompute.py@@ -219,6 +219,7 @@ class TestWebTrendsLazyPrecompute(ClickhouseTestMixin, APIBaseTest):assert pre_series["count"] == live_series["count"]assert pre_series["label"] == live_series["label"]assert pre_series["order"] == live_series["order"]+ assert pre_series["custom_name"] == live_series["custom_name"] == "My metric"@time_machine.travel("2024-01-15T12:00:00Z", tick=False)def test_compare_period_matches_live_trends(self) -> None:diff --git a/products/web_analytics/backend/hogql_queries/test/test_web_vitals_timeseries_lazy_precompute.py b/products/web_analytics/backend/hogql_queries/test/test_web_vitals_timeseries_lazy_precompute.pyindex 32fbdb7ee470..7f96899fc198 100644--- a/products/web_analytics/backend/hogql_queries/test/test_web_vitals_timeseries_lazy_precompute.py+++ b/products/web_analytics/backend/hogql_queries/test/test_web_vitals_timeseries_lazy_precompute.py@@ -249,6 +249,7 @@ class TestWebVitalsTimeseriesLazyPrecompute(ClickhouseTestMixin, APIBaseTest):assert pre_series["days"] == live_series["days"]assert pre_series["data"] == live_series["data"], live_series["order"]assert pre_series["order"] == live_series["order"]+ assert pre_series["custom_name"] == live_series["custom_name"] is not None@time_machine.travel("2024-01-15T12:00:00Z", tick=False)def test_dispatch_routes_only_when_flag_enabled(self) -> None:diff --git a/products/web_analytics/backend/hogql_queries/web_trends_lazy_precompute.py b/products/web_analytics/backend/hogql_queries/web_trends_lazy_precompute.pyindex e5c8ceda9c23..6bf830a90681 100644--- a/products/web_analytics/backend/hogql_queries/web_trends_lazy_precompute.py+++ b/products/web_analytics/backend/hogql_queries/web_trends_lazy_precompute.py@@ -306,6 +306,7 @@ def _series_dict("count": float(sum(data)),"label": "All events" if series_label is None else series_label,"order": 0,+ "custom_name": runner.series_custom_name(series),}if query.compareFilter is not None and query.compareFilter.compare:series_object["compare"] = Truediff --git a/products/web_analytics/backend/hogql_queries/web_vitals_timeseries_lazy_precompute.py b/products/web_analytics/backend/hogql_queries/web_vitals_timeseries_lazy_precompute.pyindex 88cc37c27035..6c27739d05f2 100644--- a/products/web_analytics/backend/hogql_queries/web_vitals_timeseries_lazy_precompute.py+++ b/products/web_analytics/backend/hogql_queries/web_vitals_timeseries_lazy_precompute.py@@ -286,6 +286,7 @@ def _series_dict("count": float(sum(data)),"label": "All events" if series_label is None else series_label,"order": order,+ "custom_name": runner.series_custom_name(series),}