Skip to content

: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.

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.py
index 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)
@property
def _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 = entry
if split_candidate is None:
cached_response_candidate = None
else:
cached_response_candidate = split_candidate.header
if 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 any
custom_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 results
was_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 = True
return cached_response, was_modified
diff --git a/products/product_analytics/backend/hogql_queries/lifecycle/lifecycle_query_runner.py b/products/product_analytics/backend/hogql_queries/lifecycle/lifecycle_query_runner.py
index 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 arbitrary
column 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_series
cols = {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.py
index 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.py
index 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.py
index 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 data
diff --git a/products/product_analytics/backend/hogql_queries/trends/test/test_formula.py b/products/product_analytics/backend/hogql_queries/trends/test/test_formula.py
index 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.py
index 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"] == 16
assert 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.py
index 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_threads
from posthog.hogql_queries.utils.query_compare_to_date_range import QueryCompareToDateRange
from posthog.hogql_queries.utils.query_date_range import QueryDateRange
from 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_name
from posthog.hogql_queries.utils.sampling import correct_result_for_sampling
from posthog.hogql_queries.utils.timestamp_utils import format_label_date, get_earliest_timestamp_from_series
from posthog.hogql_queries.utils.utils import get_response_hogql
@@ -100,6 +101,20 @@ from products.product_analytics.backend.hogql_queries.trends.trends_query_builde
from 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: TrendsQuery
cached_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.formula
base_result = results_group[0]
base_result["label"] = formula_node.custom_name or f"Formula ({formula})"
+ base_result["custom_name"] = formula_node.custom_name
if 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.py
new file mode 100644
index 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_queries
diff --git a/products/product_analytics/frontend/insights/funnels/funnelDataLogic.ts b/products/product_analytics/frontend/insights/funnels/funnelDataLogic.ts
index 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.py
index 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.py
index 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.py
index 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"] = True
diff --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.py
index 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),
}