feat: Add group support to the lifecycle insight

frontend/src/queries/nodes/InsightQuery/utils/queryNodeToFilter.ts

@@ -149,7 +149,7 @@ export const queryNodeToFilter = (query: InsightQueryNode): Partial<FilterType>
         Object.assign(filters, objectClean<Partial<Record<keyof BreakdownFilter, unknown>>>(query.breakdownFilter))
     }
 
-    if (!isLifecycleQuery(query) && !isStickinessQuery(query)) {
+    if (!isStickinessQuery(query)) {
         Object.assign(
             filters,
             objectClean({

frontend/src/queries/nodes/InsightViz/TrendsSeries.tsx

@@ -5,6 +5,7 @@ import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
 import { alphabet } from 'lib/utils'
 import { ActionFilter } from 'scenes/insights/filters/ActionFilter/ActionFilter'
 import { MathAvailability } from 'scenes/insights/filters/ActionFilter/ActionFilterRow/ActionFilterRow'
+import { AggregationSelect } from 'scenes/insights/filters/AggregationSelect'
 import { insightLogic } from 'scenes/insights/insightLogic'
 import { insightVizDataLogic } from 'scenes/insights/insightVizDataLogic'
 import { keyForInsightLogicProps } from 'scenes/insights/sharedUtils'
@@ -25,7 +26,7 @@ export function TrendsSeries(): JSX.Element | null {
     const { updateQuerySource } = useActions(insightVizDataLogic(insightProps))
     const { featureFlags } = useValues(featureFlagLogic)
 
-    const { groupsTaxonomicTypes } = useValues(groupsModel)
+    const { showGroupsOptions, groupsTaxonomicTypes } = useValues(groupsModel)
 
     const propertiesTaxonomicGroupTypes = [
         TaxonomicFilterGroupType.EventProperties,
@@ -57,7 +58,15 @@ export function TrendsSeries(): JSX.Element | null {
         <>
             {isLifecycle && (
                 <div className="leading-6">
-                    Showing <b>Unique users</b> who did
+                    <div className="flex items-center">
+                        Showing
+                        {showGroupsOptions ? (
+                            <AggregationSelect className="mx-2" insightProps={insightProps} hogqlAvailable={false} />
+                        ) : (
+                            <b> Unique users </b>
+                        )}
+                        who did
+                    </div>
                 </div>
             )}
             <ActionFilter

frontend/src/queries/schema.json

@@ -3220,6 +3220,10 @@
         "LifecycleQuery": {
             "additionalProperties": false,
             "properties": {
+                "aggregation_group_type_index": {
+                    "description": "Groups aggregation",
+                    "type": "integer"
+                },
                 "dateRange": {
                     "$ref": "#/definitions/DateRange",
                     "description": "Date range for the query"

frontend/src/queries/schema.ts

@@ -929,7 +929,7 @@ export interface LifecycleQueryResponse extends QueryResponse {
     results: Record<string, any>[]
 }
 
-export interface LifecycleQuery extends Omit<InsightsQueryBase, 'aggregation_group_type_index'> {
+export interface LifecycleQuery extends InsightsQueryBase {
     kind: NodeKind.LifecycleQuery
     /** Granularity of the response. Can be one of `hour`, `day`, `week` or `month` */
     interval?: IntervalType

frontend/src/scenes/insights/filters/AggregationSelect.tsx

@@ -7,7 +7,7 @@ import { insightVizDataLogic } from 'scenes/insights/insightVizDataLogic'
 
 import { groupsModel } from '~/models/groupsModel'
 import { FunnelsQuery } from '~/queries/schema'
-import { isFunnelsQuery, isInsightQueryNode, isLifecycleQuery, isStickinessQuery } from '~/queries/utils'
+import { isFunnelsQuery, isInsightQueryNode, isStickinessQuery } from '~/queries/utils'
 import { InsightLogicProps } from '~/types'
 
 function getHogQLValue(groupIndex?: number, aggregationQuery?: string): string {
@@ -52,9 +52,7 @@ export function AggregationSelect({
     }
 
     const value = getHogQLValue(
-        isLifecycleQuery(querySource) || isStickinessQuery(querySource)
-            ? undefined
-            : querySource.aggregation_group_type_index,
+        isStickinessQuery(querySource) ? undefined : querySource.aggregation_group_type_index,
         isFunnelsQuery(querySource) ? querySource.funnelsFilter?.funnelAggregateByHogQL : undefined
     )
     const onChange = (value: string): void => {

frontend/src/scenes/insights/summarizeInsight.test.ts

@@ -477,6 +477,27 @@ describe('summarizing insights', () => {
                 )
             ).toEqual('User lifecycle based on Rageclick')
         })
+
+        it('summarizes a Lifecycle insight on a different group', () => {
+            expect(
+                summarizeInsight(
+                    null,
+                    {
+                        insight: InsightType.LIFECYCLE,
+                        events: [
+                            {
+                                id: '$rageclick',
+                                name: '$rageclick',
+                                type: 'event',
+                                order: 1,
+                            },
+                        ],
+                        aggregation_group_type_index: 0,
+                    },
+                    summaryContext
+                )
+            ).toEqual('Organization lifecycle based on Rageclick')
+        })
     })
 
     describe('summariseInsightQuery()', () => {
@@ -883,6 +904,28 @@ describe('summarizing insights', () => {
 
             expect(result).toEqual('User lifecycle based on Rageclick')
         })
+
+        it('summarizes a Lifecycle insight with groups', () => {
+            const query: LifecycleQuery = {
+                kind: NodeKind.LifecycleQuery,
+                series: [
+                    {
+                        kind: NodeKind.EventsNode,
+                        event: '$rageclick',
+                        name: '$rageclick',
+                    },
+                ],
+                aggregation_group_type_index: 0,
+            }
+
+            const result = summarizeInsight(
+                { kind: NodeKind.InsightVizNode, source: query } as InsightVizNode,
+                {},
+                summaryContext
+            )
+
+            expect(result).toEqual('Organization lifecycle based on Rageclick')
+        })
     })
 
     describe('summarize data table query', () => {

frontend/src/scenes/insights/summarizeInsight.ts

@@ -105,7 +105,9 @@ function summarizeInsightFilters(filters: AnyPartialFilterType, context: Summary
         }
         return summary
     } else if (isLifecycleFilter(filters)) {
-        return `User lifecycle based on ${getDisplayNameFromEntityFilter(localFilters[0])}`
+        return `${capitalizeFirstLetter(
+            context.aggregationLabel(filters.aggregation_group_type_index, true).singular
+        )} lifecycle based on ${getDisplayNameFromEntityFilter(localFilters[0])}`
     } else if (isFunnelsFilter(filters)) {
         let summary
         const linkSymbol =
@@ -293,7 +295,9 @@ export function summarizeInsightQuery(query: InsightQueryNode, context: SummaryC
                 .join(' & ')
         )
     } else if (isLifecycleQuery(query)) {
-        return `User lifecycle based on ${getDisplayNameFromEntityNode(query.series[0])}`
+        return `${capitalizeFirstLetter(
+            context.aggregationLabel(query.aggregation_group_type_index, true).singular
+        )} lifecycle based on ${getDisplayNameFromEntityNode(query.series[0])}`
     }
     return ''
 }

frontend/src/scenes/trends/trendsDataLogic.test.ts

@@ -116,6 +116,7 @@ describe('trendsDataLogic', () => {
                     insightVizDataLogic.findMounted(insightProps)?.actions.updateQuerySource(query)
                     builtDataNodeLogic.actions.loadDataSuccess(insight)
                 }).toMatchValues({
+                    labelGroupType: 'people',
                     indexedResults: [
                         expect.objectContaining({
                             count: -50255.0,
@@ -137,6 +138,14 @@ describe('trendsDataLogic', () => {
                         }),
                     ],
                 })
+
+                query.aggregation_group_type_index = 1
+                await expectLogic(logic, () => {
+                    insightVizDataLogic.findMounted(insightProps)?.actions.updateQuerySource(query)
+                    builtDataNodeLogic.actions.loadDataSuccess(insight)
+                }).toMatchValues({
+                    labelGroupType: 1,
+                })
             })
         })
     })

frontend/src/scenes/trends/trendsDataLogic.ts

@@ -11,7 +11,7 @@ import {
     isOtherBreakdown,
 } from 'scenes/insights/utils'
 
-import { EntityNode } from '~/queries/schema'
+import { EntityNode, LifecycleQuery } from '~/queries/schema'
 import {
     ChartDisplayType,
     CountPerActorMathType,
@@ -44,6 +44,7 @@ export const trendsDataLogic = kea<trendsDataLogicType>([
         values: [
             insightVizDataLogic(props),
             [
+                'querySource',
                 'insightData',
                 'insightDataLoading',
                 'series',
@@ -149,13 +150,20 @@ export const trendsDataLogic = kea<trendsDataLogicType>([
         ],
 
         labelGroupType: [
-            (s) => [s.series],
-            (series): 'people' | 'none' | number => {
+            (s) => [s.series, s.querySource, s.isLifecycle],
+            (series, querySource, isLifecycle): 'people' | 'none' | number => {
                 // Find the commonly shared aggregation group index if there is one.
-                const firstAggregationGroupTypeIndex = series?.[0]?.math_group_type_index
-                return series?.every((eOrA) => eOrA?.math_group_type_index === firstAggregationGroupTypeIndex)
-                    ? firstAggregationGroupTypeIndex ?? 'people' // if undefined, will resolve to 'people' label
-                    : 'none' // mixed group types
+                let firstAggregationGroupTypeIndex: 'people' | 'none' | number | undefined
+                if (isLifecycle) {
+                    firstAggregationGroupTypeIndex = (querySource as LifecycleQuery)?.aggregation_group_type_index
+                } else {
+                    firstAggregationGroupTypeIndex = series?.[0]?.math_group_type_index
+                    if (!series?.every((eOrA) => eOrA?.math_group_type_index === firstAggregationGroupTypeIndex)) {
+                        return 'none' // mixed group types
+                    }
+                }
+
+                return firstAggregationGroupTypeIndex ?? 'people'
             },
         ],
 

posthog/hogql_queries/insights/insight_actors_query_runner.py

@@ -21,6 +21,7 @@
     StickinessQuery,
     TrendsQuery,
     FunnelsQuery,
+    LifecycleQuery,
 )
 from posthog.types import InsightActorsQueryNode
 
@@ -89,6 +90,11 @@ def group_type_index(self) -> int | None:
             assert isinstance(self.query.source, FunnelsQuery)
             return self.query.source.aggregation_group_type_index
 
+        if isinstance(self.source_runner, LifecycleQueryRunner):
+            # Lifecycle Query uses a plain InsightActorsQuery
+            assert isinstance(self.query.source, LifecycleQuery)
+            return self.query.source.aggregation_group_type_index
+
         if (
             isinstance(self.source_runner, StickinessQueryRunner) and isinstance(self.query.source, StickinessQuery)
         ) or (isinstance(self.source_runner, TrendsQueryRunner) and isinstance(self.query.source, TrendsQuery)):

posthog/hogql_queries/insights/lifecycle_query_runner.py

@@ -75,7 +75,7 @@ def to_query(self) -> ast.SelectQuery | ast.SelectUnionQuery:
                             ORDER BY status, start_of_period
                             UNION ALL
                             SELECT
-                                start_of_period, count(DISTINCT person_id) AS counts, status
+                                start_of_period, count(DISTINCT actor_id) AS counts, status
                             FROM {events_query}
                             GROUP BY start_of_period, status
                         )
@@ -94,7 +94,7 @@ def to_query(self) -> ast.SelectQuery | ast.SelectUnionQuery:
     def to_actors_query(
         self, day: Optional[str] = None, status: Optional[str] = None
     ) -> ast.SelectQuery | ast.SelectUnionQuery:
-        with self.timings.measure("persons_query"):
+        with self.timings.measure("actors_query"):
             exprs = []
             if day is not None:
                 exprs.append(
@@ -116,7 +116,7 @@ def to_actors_query(
                 )
 
             return parse_select(
-                "SELECT DISTINCT person_id FROM {events_query} WHERE {where}",
+                "SELECT DISTINCT actor_id FROM {events_query} WHERE {where}",
                 placeholders={
                     "events_query": self.events_query,
                     "where": ast.And(exprs=exprs) if len(exprs) > 0 else ast.Constant(value=1),
@@ -270,20 +270,46 @@ def event_filter(self) -> ast.Expr:
                 for property in self.team.test_account_filters:
                     event_filters.append(property_to_expr(property, self.team))
 
+        if self.has_group_type:
+            event_filters.append(
+                ast.Not(
+                    expr=ast.Call(
+                        name="has",
+                        args=[
+                            ast.Array(exprs=[ast.Constant(value="")]),
+                            self.target_field,
+                        ],
+                    ),
+                ),
+            )
+
         if len(event_filters) == 0:
             return ast.Constant(value=True)
         elif len(event_filters) == 1:
             return event_filters[0]
         else:
             return ast.And(exprs=event_filters)
 
+    @property
+    def has_group_type(self) -> bool:
+        return self.group_type_index is not None and 0 <= self.group_type_index <= 4
+
+    @property
+    def group_type_index(self) -> int | None:
+        return self.query.aggregation_group_type_index
+
+    @property
+    def target_field(self):
+        if self.has_group_type:
+            return ast.Field(chain=["events", f"$group_{self.group_type_index}"])
+        return ast.Field(chain=["person_id"])
+
     @cached_property
     def events_query(self):
         with self.timings.measure("events_query"):
             events_query = parse_select(
                 """
                     SELECT
-                        events.person_id as person_id,
                         min(events.person.created_at) AS created_at,
                         arraySort(groupUniqArray({trunc_timestamp})) AS all_activity,
                         arrayPopBack(arrayPushFront(all_activity, {trunc_created_at})) as previous_activity,
@@ -295,13 +321,15 @@ def events_query(self):
                         arrayConcat(arrayZip(all_activity, initial_status), arrayZip(dormant_periods, dormant_label)) as temp_concat,
                         arrayJoin(temp_concat) as period_status_pairs,
                         period_status_pairs.1 as start_of_period,
-                        period_status_pairs.2 as status
+                        period_status_pairs.2 as status,
+                        {target}
                     FROM events
                     WHERE {event_filter}
-                    GROUP BY person_id
+                    GROUP BY actor_id
                 """,
                 placeholders={
                     **self.query_date_range.to_placeholders(),
+                    "target": ast.Alias(alias="actor_id", expr=self.target_field),
                     "event_filter": self.event_filter,
                     "trunc_timestamp": self.query_date_range.date_to_start_of_interval_hogql(
                         ast.Field(chain=["events", "timestamp"])