: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(signals): run activity summaries on a schedule with flag-controlled caps (#120746)
posthog[bot]0e4e45114afc
diff --git a/posthog/settings/object_storage.py b/posthog/settings/object_storage.pyindex 7f1649002def..2c1298b66c6e 100644--- a/posthog/settings/object_storage.py+++ b/posthog/settings/object_storage.py@@ -136,6 +136,9 @@ INBOX_RANKING_SCORING_MAX_AGE_DAYS = get_from_env("INBOX_RANKING_SCORING_MAX_AGEINBOX_RANKING_SCORING_MAX_REPORTS_PER_TICK = get_from_env("INBOX_RANKING_SCORING_MAX_REPORTS_PER_TICK", 2000, type_cast=int)+# Activity summary tick (products/signals/backend/activity_summary/tick.py). The `activity-summary`+# flag payload gates the work and holds the caps, so the schedule ticks in every environment.+ACTIVITY_SUMMARY_TICK_INTERVAL_MINUTES = get_from_env("ACTIVITY_SUMMARY_TICK_INTERVAL_MINUTES", 60, type_cast=int)# Identity matching scratch storage (products/growth `identity_matching_job`). The job writes# per-run Parquet objects via ClickHouse `INSERT INTO FUNCTION s3(...)` and the read API globsdiff --git a/posthog/temporal/schedule.py b/posthog/temporal/schedule.pyindex 0b789b7e6f1a..bfdca3bf59ce 100644--- a/posthog/temporal/schedule.py+++ b/posthog/temporal/schedule.py@@ -134,6 +134,7 @@ from products.replay_vision.backend.temporal.search_suggestions import create_refrom products.replay_vision.backend.temporal.vision_alerts.schedule import create_vision_alert_check_schedulefrom products.review_hog.backend.facade.temporal import create_review_hog_finding_outcomes_schedulefrom products.security.backend.facade.temporal import create_sync_access_rules_schedule+from products.signals.backend.activity_summary.schedule import create_activity_summary_tick_schedulefrom products.signals.backend.emission.conversations_schedule import create_conversations_signals_coordinator_schedulefrom products.signals.backend.ranking.schedule import create_inbox_ranking_scoring_schedulefrom products.signals.backend.temporal.agentic.schedule import (@@ -953,6 +954,7 @@ schedules = [delete_today_briefing_schedule,create_signals_scout_coordinator_schedule,create_inbox_ranking_scoring_schedule,+ create_activity_summary_tick_schedule,create_scout_suggestions_coordinator_schedule,create_support_reply_coordinator_schedule,create_channel_summary_coordinator_schedule,diff --git a/products/signals/backend/activity_summary/config.py b/products/signals/backend/activity_summary/config.pynew file mode 100644index 000000000000..a9c5552a7542--- /dev/null+++ b/products/signals/backend/activity_summary/config.py@@ -0,0 +1,95 @@+"""The levers of the scheduled activity summary tick, read from the `activity-summary` flag payload.++The parse fails closed: a missing, malformed or unreadable payload turns the tick off. An invalid+field falls back to its default, and no default is unbounded.+"""++from typing import Any++import structlog++from posthog.dataclasses import frozen++from products.signals.backend.activity_summary.logic import MIN_UNITS, MIN_UPDATE_INTERVAL+from products.signals.backend.scout_harness.team_limits import read_flag_payload++logger = structlog.get_logger(__name__)++ACTIVITY_SUMMARY_FLAG = "activity-summary"+# Not a person: the flag must serve its payload to this id.+ACTIVITY_SUMMARY_FLAG_DISTINCT_ID = "signals_activity_summary"+++@frozen+class ActivitySummaryConfig:+ enabled: bool = False+ organization_ids: tuple[str, ...] = ()+ skip_team_ids: tuple[int, ...] = ()+ max_pairs_per_tick: int = 50+ # Rolling 24 hours, counted from the stored rows, so the caps hold across ticks and workers.+ max_pairs_per_day: int = 500+ max_cost_usd_per_day: float = 5.0+ max_concurrency: int = 4+ min_units: int = MIN_UNITS+ min_update_interval_hours: float = MIN_UPDATE_INTERVAL.total_seconds() / 3600+ emit_embeddings: bool = True+ capture_events: bool = True+++DISABLED = ActivitySummaryConfig()+++def _positive_int(value: Any, default: int) -> int:+ # `bool` is an `int` subclass, and `true` is not a count.+ return value if isinstance(value, int) and not isinstance(value, bool) and value > 0 else default+++def _positive_number(value: Any, default: float) -> float:+ if isinstance(value, bool) or not isinstance(value, int | float) or value <= 0:+ return default+ return float(value)+++def _bool(value: Any, default: bool) -> bool:+ return value if isinstance(value, bool) else default+++def _team_ids(value: Any) -> tuple[int, ...]:+ if not isinstance(value, list):+ return ()+ return tuple(item for item in value if isinstance(item, int) and not isinstance(item, bool))+++def _organization_ids(value: Any) -> tuple[str, ...]:+ return tuple(item for item in value if isinstance(item, str) and item) if isinstance(value, list) else ()+++def parse_config(payload: Any) -> ActivitySummaryConfig:+ if not isinstance(payload, dict) or payload.get("enabled") is not True:+ return DISABLED+ defaults = ActivitySummaryConfig()+ return ActivitySummaryConfig(+ enabled=True,+ organization_ids=_organization_ids(payload.get("organization_ids")),+ skip_team_ids=_team_ids(payload.get("skip_team_ids")),+ max_pairs_per_tick=_positive_int(payload.get("max_pairs_per_tick"), defaults.max_pairs_per_tick),+ max_pairs_per_day=_positive_int(payload.get("max_pairs_per_day"), defaults.max_pairs_per_day),+ max_cost_usd_per_day=_positive_number(payload.get("max_cost_usd_per_day"), defaults.max_cost_usd_per_day),+ max_concurrency=_positive_int(payload.get("max_concurrency"), defaults.max_concurrency),+ min_units=_positive_int(payload.get("min_units"), defaults.min_units),+ min_update_interval_hours=_positive_number(+ payload.get("min_update_interval_hours"), defaults.min_update_interval_hours+ ),+ emit_embeddings=_bool(payload.get("emit_embeddings"), defaults.emit_embeddings),+ capture_events=_bool(payload.get("capture_events"), defaults.capture_events),+ )+++def read_config() -> ActivitySummaryConfig:+ config = parse_config(read_flag_payload(ACTIVITY_SUMMARY_FLAG, ACTIVITY_SUMMARY_FLAG_DISTINCT_ID))+ logger.info(+ "activity_summary_config_read",+ enabled=config.enabled,+ organizations=len(config.organization_ids),+ )+ return configdiff --git a/products/signals/backend/activity_summary/logic.py b/products/signals/backend/activity_summary/logic.pyindex 455e33c97b17..61c96115e0f6 100644--- a/products/signals/backend/activity_summary/logic.py+++ b/products/signals/backend/activity_summary/logic.py@@ -24,6 +24,8 @@ from products.signals.backend.models import UserActivitySummary# Fewer rendered lines than this since the last update say too little to change the summary.MIN_UNITS = 3MIN_UPDATE_INTERVAL = datetime.timedelta(days=1)+# A pair that skipped or failed waits this long, so it does not take the queue head on every tick.+RETRY_BACKOFF = datetime.timedelta(hours=6)# The watermark is inclusive in the stored summary, so the next read starts just after it._WATERMARK_STEP = datetime.timedelta(microseconds=1)@@ -55,14 +57,35 @@ def _input_start(watermark: datetime.datetime | None, now: datetime.datetime) ->return earliest if watermark is None else max(earliest, watermark + _WATERMARK_STEP)+def _back_off(+ team_id: int, user_id: int, stored: UserActivitySummary | None, next_eligible_at: datetime.datetime+) -> None:+ # `update()` leaves `updated_at` alone, so the daily caps do not count a skip as a model call.+ if stored is not None:+ UserActivitySummary.objects.for_team(team_id).filter(id=stored.id).update(next_eligible_at=next_eligible_at)+ return+ UserActivitySummary.objects.for_team(team_id).get_or_create(+ team_id=team_id,+ user_id=user_id,+ defaults={"status": UserActivitySummary.Status.SKIPPED, "next_eligible_at": next_eligible_at},+ )++def update_activity_summary(- team_id: int, user_id: int, *, dry_run: bool = False, force: bool = False+ team_id: int,+ user_id: int,+ *,+ dry_run: bool = False,+ force: bool = False,+ min_units: int = MIN_UNITS,+ min_update_interval: datetime.timedelta = MIN_UPDATE_INTERVAL,) -> ActivitySummaryUpdate:"""Update the stored activity summary of one user in one project.Reads only the inputs newer than the stored watermark, or the last `WINDOW_DAYS` on a firstrun. A failed update records the error and keeps the stored summary and the watermark. With`dry_run`, the model is still called but nothing is written. `force` ignores `next_eligible_at`.+ A skip for too few units and a failed update set `next_eligible_at` to `RETRY_BACKOFF` from now."""team = Team.objects.select_related("organization").get(id=team_id)if team.organization.is_ai_data_processing_approved is not True:@@ -77,7 +100,9 @@ def update_activity_summary(tasks = user_tasks(team_id, user_id, start, now)activity = user_activity(team_id, user_id, start, now)rendered = build_input(tasks, activity, as_of=now, seed=sampling_seed(now.date().isoformat(), team_id, user_id))- if rendered is None or rendered.units < MIN_UNITS:+ if rendered is None or rendered.units < min_units:+ if not dry_run:+ _back_off(team_id, user_id, stored, now + RETRY_BACKOFF)return ActivitySummaryUpdate(status=UpdateStatus.SKIPPED_TOO_FEW_UNITS,rendered_input=rendered.text if rendered else None,@@ -128,7 +153,11 @@ def update_activity_summary(UserActivitySummary.objects.for_team(team_id).update_or_create(team_id=team_id,user_id=user_id,- defaults={**accounting, "status": UserActivitySummary.Status.FAILED},+ defaults={+ **accounting,+ "status": UserActivitySummary.Status.FAILED,+ "next_eligible_at": now + RETRY_BACKOFF,+ },)return result@@ -145,7 +174,7 @@ def update_activity_summary("prompt_version": PROMPT_VERSION,"render_version": RENDER_VERSION,"input_watermark": watermark,- "next_eligible_at": now + MIN_UPDATE_INTERVAL,+ "next_eligible_at": now + min_update_interval,},)return resultdiff --git a/products/signals/backend/activity_summary/queue.py b/products/signals/backend/activity_summary/queue.pynew file mode 100644index 000000000000..d637a0675078--- /dev/null+++ b/products/signals/backend/activity_summary/queue.py@@ -0,0 +1,188 @@+"""Pick the (team, user) pairs that the next activity summary tick updates, and measure the daily caps.++Row counts here are only a queue estimate. `update_activity_summary` still applies the real drop+rules and `min_units`, and backs a pair off when it skips, so the pair leaves the queue head.+"""++import datetime+from collections import Counter++from django.db.models import Count, OuterRef, Q, Subquery, Sum+from django.db.models.functions import Coalesce++from posthog.dataclasses import frozen+from posthog.models import ActivityLog, Team++from products.signals.backend.activity_summary.config import ActivitySummaryConfig+from products.signals.backend.activity_summary.inputs import TASK_ORIGIN_PRODUCTS+from products.signals.backend.activity_summary.prompt import SYSTEM_PROMPT+from products.signals.backend.activity_summary.render import (+ MAX_SUMMARY_CHARS,+ SCOUT_CLIENT_PREFIX,+ SECTIONS_MAX_CHARS,+ WINDOW_DAYS,+)+from products.signals.backend.activity_summary.summaries import (+ DEFAULT_MODEL,+ MAX_ATTEMPTS,+ MAX_COMPLETION_TOKENS,+ MODEL_PRICES,+ cost_usd,+)+from products.signals.backend.models import UserActivitySummary+from products.tasks.backend.facade.user_task_summaries import list_user_task_times++DAY = datetime.timedelta(days=1)+# Fewer characters per token than the render estimate, so the bound is high, not low.+_BOUND_CHARS_PER_TOKEN = 2+# The cost bound when the model has no price. One update of the default model costs far less.+_UNPRICED_UPDATE_COST_USD = 0.05+_CALLED_MODEL = (UserActivitySummary.Status.OK, UserActivitySummary.Status.FAILED)+++@frozen(order=True)+class ActivitySummaryPair:+ team_id: int+ user_id: int+++@frozen+class _Stored:+ input_watermark: datetime.datetime | None+ generated_at: datetime.datetime | None+ next_eligible_at: datetime.datetime | None+++@frozen+class DailyUsage:+ updates: int+ cost_usd: float+++def max_update_cost_usd(model: str = DEFAULT_MODEL) -> float:+ """The most one update can cost: every attempt with the largest input and output."""+ input_chars = SECTIONS_MAX_CHARS + MAX_SUMMARY_CHARS + len(SYSTEM_PROMPT)+ bound = cost_usd(+ MAX_ATTEMPTS * input_chars // _BOUND_CHARS_PER_TOKEN,+ MAX_ATTEMPTS * MAX_COMPLETION_TOKENS,+ MODEL_PRICES.get(model),+ )+ return _UNPRICED_UPDATE_COST_USD if bound is None else bound+++def daily_usage(now: datetime.datetime) -> DailyUsage:+ """Updates that called the model in the last 24 hours, and their summed cost, over all teams.++ One row holds the latest update of a pair, so an earlier update of the same pair in the same 24+ hours is not counted. With the minimum update interval that happens only after a failure.+ A row without a cost counts as the most one update can cost, so missing usage cannot pass the cap.+ """+ # nosemgrep: idor-lookup-without-team (the daily caps are global over all teams, with no user input)+ rows = UserActivitySummary.all_teams.filter(status__in=_CALLED_MODEL, updated_at__gte=now - DAY).aggregate(+ updates=Count("id"),+ unpriced=Count("id", filter=Q(cost_usd__isnull=True)),+ cost=Sum("cost_usd"),+ )+ return DailyUsage(+ updates=rows["updates"],+ cost_usd=(rows["cost"] or 0.0) + rows["unpriced"] * max_update_cost_usd(),+ )+++def _enrolled_team_ids(config: ActivitySummaryConfig) -> list[int]:+ if not config.organization_ids:+ return []+ return list(+ Team.objects.filter(+ organization_id__in=config.organization_ids,+ organization__is_ai_data_processing_approved=True,+ )+ .exclude(id__in=config.skip_team_ids)+ .values_list("id", flat=True)+ )+++def _stored_rows(team_ids: list[int]) -> dict[ActivitySummaryPair, _Stored]:+ # nosemgrep: idor-lookup-without-team (system tick with no user input; filtered to the enrolled teams)+ rows = UserActivitySummary.all_teams.filter(team_id__in=team_ids).values_list(+ "team_id", "user_id", "input_watermark", "generated_at", "next_eligible_at"+ )+ return {+ ActivitySummaryPair(team_id=team_id, user_id=user_id): _Stored(+ input_watermark=watermark, generated_at=generated_at, next_eligible_at=eligible+ )+ for team_id, user_id, watermark, generated_at, eligible in rows+ }+++def _new_activity_rows(+ team_ids: list[int], window_start: datetime.datetime, now: datetime.datetime+) -> dict[ActivitySummaryPair, int]:+ """Activity log rows per pair after the pair's watermark, with the scope filters of `inputs.py`."""+ watermark = Subquery(+ # nosemgrep: idor-lookup-without-team (correlated on the outer row's team_id)+ UserActivitySummary.all_teams.filter(team_id=OuterRef("team_id"), user_id=OuterRef("user_id")).values(+ "input_watermark"+ )[:1]+ )+ rows = (+ ActivityLog.objects.filter(+ team_id__in=team_ids, user_id__isnull=False, created_at__gte=window_start, created_at__lt=now+ )+ .exclude(is_system=True)+ .exclude(was_impersonated=True)+ .exclude(client__startswith=SCOUT_CLIENT_PREFIX)+ .filter(created_at__gt=Coalesce(watermark, window_start))+ .values("team_id", "user_id")+ .annotate(rows=Count("id"))+ .values_list("team_id", "user_id", "rows")+ )+ return {+ ActivitySummaryPair(team_id=team_id, user_id=user_id): count+ for team_id, user_id, count in rows+ if team_id is not None and user_id is not None+ }+++def _new_tasks(+ team_ids: list[int],+ window_start: datetime.datetime,+ now: datetime.datetime,+ stored: dict[ActivitySummaryPair, _Stored],+) -> Counter[ActivitySummaryPair]:+ counts: Counter[ActivitySummaryPair] = Counter()+ for task in list_user_task_times(+ team_ids=team_ids, start=window_start, end=now, origin_products=TASK_ORIGIN_PRODUCTS+ ):+ pair = ActivitySummaryPair(team_id=task.team_id, user_id=task.user_id)+ row = stored.get(pair)+ if row is None or row.input_watermark is None or task.created_at > row.input_watermark:+ counts[pair] += 1+ return counts+++def select_pairs(config: ActivitySummaryConfig, now: datetime.datetime, limit: int) -> list[ActivitySummaryPair]:+ """The due pairs of the enrolled teams, highest priority first, cut to `limit`.++ A pair is due when it has a task or an activity log row after its watermark, or in the last+ `WINDOW_DAYS` with no watermark, and its `next_eligible_at` is empty or past. Pairs with no+ summary come first, then the pairs with the most new rows, then the oldest summaries.+ """+ team_ids = _enrolled_team_ids(config)+ if not team_ids or limit <= 0:+ return []+ window_start = now - datetime.timedelta(days=WINDOW_DAYS)+ stored = _stored_rows(team_ids)+ new_rows = Counter(_new_activity_rows(team_ids, window_start, now)) + _new_tasks(+ team_ids, window_start, now, stored+ )++ due: list[tuple[bool, int, datetime.datetime, ActivitySummaryPair]] = []+ for pair, count in new_rows.items():+ row = stored.get(pair)+ if row is not None and row.next_eligible_at is not None and row.next_eligible_at > now:+ continue+ generated_at = row.generated_at if row is not None else None+ due.append((generated_at is not None, -count, generated_at or window_start, pair))+ due.sort()+ return [pair for *_, pair in due[:limit]]diff --git a/products/signals/backend/activity_summary/schedule.py b/products/signals/backend/activity_summary/schedule.pynew file mode 100644index 000000000000..598df0198003--- /dev/null+++ b/products/signals/backend/activity_summary/schedule.py@@ -0,0 +1,57 @@+"""Schedule registration for the activity summary tick."""++from dataclasses import asdict+from datetime import timedelta++from django.conf import settings++from temporalio.client import (+ Client,+ Schedule,+ ScheduleActionStartWorkflow,+ ScheduleIntervalSpec,+ ScheduleOverlapPolicy,+ SchedulePolicy,+ ScheduleSpec,+)++from posthog.scheduling.jitter import deterministic_offset+from posthog.temporal.common.schedule import a_create_schedule, a_schedule_exists, a_update_schedule++from products.signals.backend.activity_summary.tick import TICK_WORKFLOW_NAME, ActivitySummaryTickInput++ACTIVITY_SUMMARY_TICK_SCHEDULE_ID = "activity-summary-tick-schedule"+++async def create_activity_summary_tick_schedule(client: Client) -> None:+ """Create or update the tick schedule on the self-driving task queue.++ The schedule exists in every environment. The `activity-summary` flag gates the work, so turning+ the tick on or off needs no schedule change. SKIP on overlap: two ticks must not update the same+ pair at the same time, and a slow tick leaves the rest of the queue to the next one.+ """+ interval = timedelta(minutes=settings.ACTIVITY_SUMMARY_TICK_INTERVAL_MINUTES)+ schedule = Schedule(+ action=ScheduleActionStartWorkflow(+ TICK_WORKFLOW_NAME,+ asdict(ActivitySummaryTickInput()),+ id=ACTIVITY_SUMMARY_TICK_SCHEDULE_ID,+ task_queue=settings.SELF_DRIVING_TASK_QUEUE,+ execution_timeout=interval,+ ),+ spec=ScheduleSpec(+ intervals=[+ ScheduleIntervalSpec(+ every=interval, offset=deterministic_offset(ACTIVITY_SUMMARY_TICK_SCHEDULE_ID, interval)+ )+ ]+ ),+ policy=SchedulePolicy(overlap=ScheduleOverlapPolicy.SKIP),+ )+ if await a_schedule_exists(client, ACTIVITY_SUMMARY_TICK_SCHEDULE_ID):+ # Keep the live state, so a deploy does not resume a schedule that an operator paused.+ description = await client.get_schedule_handle(ACTIVITY_SUMMARY_TICK_SCHEDULE_ID).describe()+ schedule.state = description.schedule.state+ await a_update_schedule(client, ACTIVITY_SUMMARY_TICK_SCHEDULE_ID, schedule)+ else:+ await a_create_schedule(client, ACTIVITY_SUMMARY_TICK_SCHEDULE_ID, schedule, trigger_immediately=False)diff --git a/products/signals/backend/activity_summary/tick.py b/products/signals/backend/activity_summary/tick.pynew file mode 100644index 000000000000..ebb15e34a8e0--- /dev/null+++ b/products/signals/backend/activity_summary/tick.py@@ -0,0 +1,338 @@+"""The scheduled activity summary tick: a Temporal workflow that drains the queue of due (team, user) pairs.++The `activity-summary` flag payload holds every lever, and a missing or malformed payload turns the+tick off. The pair activity calls `update_activity_summary`, then queues the embedding and the event.+"""++import asyncio+import datetime+from collections import Counter++from django.utils import timezone++import structlog+from temporalio import activity, workflow+from temporalio.common import RetryPolicy++from posthog.dataclasses import frozen+from posthog.models import Team+from posthog.ph_client import ph_background_capture+from posthog.schema_enums import EmbeddingModelName+from posthog.sync import database_sync_to_async+from posthog.temporal.common.heartbeat import Heartbeater+from posthog.temporal.common.scoped import scoped_temporal+from posthog.temporal.common.utils import close_db_connections++from products.signals.backend.activity_summary.config import read_config+from products.signals.backend.activity_summary.logic import ActivitySummaryUpdate, UpdateStatus, update_activity_summary+from products.signals.backend.activity_summary.prompt import PROMPT_VERSION+from products.signals.backend.activity_summary.queue import (+ ActivitySummaryPair,+ daily_usage,+ max_update_cost_usd,+ select_pairs,+)+from products.signals.backend.activity_summary.render import RENDER_VERSION+from products.signals.backend.activity_summary.summaries import DEFAULT_MODEL, PIPELINE_DISTINCT_ID+from products.signals.backend.models import UserActivitySummary+from products.signals.backend.report_embeddings import EMBEDDING_PRODUCT++logger = structlog.get_logger(__name__)++TICK_WORKFLOW_NAME = "activity-summary-tick"+EMBEDDING_DOCUMENT_TYPE = "activity_summary"+EMBEDDING_RENDERING = "summary_text"++# Stop reasons of a tick. Null when the tick updated every due pair.+STOP_MAX_PAIRS_PER_TICK = "max_pairs_per_tick"+STOP_MAX_PAIRS_PER_DAY = "max_pairs_per_day"+STOP_MAX_COST_USD_PER_DAY = "max_cost_usd_per_day"++_PLAN_TIMEOUT = datetime.timedelta(minutes=5)+# One model call has a 120 second request timeout and one retry on a malformed answer.+_PAIR_TIMEOUT = datetime.timedelta(minutes=5)+_PAIR_HEARTBEAT_TIMEOUT = datetime.timedelta(minutes=1)+# Only transient errors raise out of the pair activity: `update_activity_summary` records model failures.+_PAIR_RETRY_POLICY = RetryPolicy(maximum_attempts=2, initial_interval=datetime.timedelta(seconds=10))+++@frozen+class ActivitySummaryTickInput:+ # A manual run can override the per-tick cap of the flag.+ limit: int | None = None+++@frozen+class ActivitySummaryTickPlan:+ enabled: bool+ pairs: list[ActivitySummaryPair]+ candidates: int+ # Updates and cost left today, from the stored rows at the start of the tick.+ updates_left: int+ cost_left_usd: float+ max_update_cost_usd: float+ max_concurrency: int+ min_units: int+ min_update_interval_hours: float+ emit_embeddings: bool+ capture_events: bool+ stop_reason: str | None+++@frozen+class ActivitySummaryPairInput:+ team_id: int+ user_id: int+ min_units: int+ min_update_interval_hours: float+ emit_embeddings: bool+ capture_events: bool+++@frozen+class ActivitySummaryPairResult:+ status: str+ cost_usd: float | None+ called_model: bool+++@frozen+class ActivitySummaryTickResult:+ enabled: bool = False+ candidates: int = 0+ picked: int = 0+ statuses: dict[str, int] | None = None+ errored: int = 0+ cost_usd: float = 0.0+ stop_reason: str | None = None+++def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickPlan:+ config = read_config()+ usage = daily_usage(now) if config.enabled else None+ updates_left = max(0, config.max_pairs_per_day - usage.updates) if usage else 0+ cost_left = max(0.0, config.max_cost_usd_per_day - usage.cost_usd) if usage else 0.0+ tick_limit = limit or config.max_pairs_per_tick+ # One more than the cut, to tell a full queue from a queue the cut emptied.+ due = select_pairs(config, now, tick_limit + 1) if updates_left and cost_left else []++ stop_reason: str | None = None+ if config.enabled and not updates_left:+ stop_reason = STOP_MAX_PAIRS_PER_DAY+ elif config.enabled and not cost_left:+ stop_reason = STOP_MAX_COST_USD_PER_DAY+ elif len(due) > tick_limit:+ stop_reason = STOP_MAX_PAIRS_PER_TICK+ return ActivitySummaryTickPlan(+ enabled=config.enabled,+ pairs=due[:tick_limit],+ candidates=len(due),+ updates_left=updates_left,+ cost_left_usd=cost_left,+ max_update_cost_usd=max_update_cost_usd(),+ max_concurrency=config.max_concurrency,+ min_units=config.min_units,+ min_update_interval_hours=config.min_update_interval_hours,+ emit_embeddings=config.emit_embeddings,+ capture_events=config.capture_events,+ stop_reason=stop_reason,+ )+++def _emit_embedding(team_id: int, user_id: int) -> None:+ # Deferred so importing the tick does not load the Kafka and ClickHouse chain behind the producer.+ from posthog.api.embedding_worker import emit_embedding_request # noqa: PLC0415++ stored = UserActivitySummary.objects.for_team(team_id).filter(user_id=user_id).first()+ if stored is None or not stored.summary_text or stored.generated_at is None:+ return+ emit_embedding_request(+ content=stored.summary_text,+ team_id=team_id,+ product=EMBEDDING_PRODUCT,+ document_type=EMBEDDING_DOCUMENT_TYPE,+ rendering=EMBEDDING_RENDERING,+ # One vector per user per day, so an analysis can read the vector a user had on a given day.+ document_id=f"{user_id}:{stored.generated_at.date().isoformat()}",+ # The models of the report embeddings, so both share one vector space.+ models=[model.value for model in EmbeddingModelName],+ timestamp=stored.generated_at,+ metadata={+ "prompt_version": stored.prompt_version,+ "render_version": stored.render_version,+ "model": stored.model,+ },+ )+++def _capture_generated(team_id: int, user_id: int, update: ActivitySummaryUpdate) -> None:+ team = Team.objects.only("uuid", "organization_id").get(id=team_id)+ # Counts and accounting only. The summary and the rendered input are user content.+ ph_background_capture()(+ distinct_id=PIPELINE_DISTINCT_ID,+ event="activity summary generated",+ properties={+ "team_id": team_id,+ "user_id": user_id,+ "status": update.status.value,+ "error": update.error,+ "model": DEFAULT_MODEL,+ "prompt_version": PROMPT_VERSION,+ "render_version": RENDER_VERSION,+ "tokens_in": update.tokens_in,+ "tokens_out": update.tokens_out,+ "cost_usd": update.cost_usd,+ "latency_ms": update.latency_ms,+ "inputs_used": update.inputs_used,+ },+ groups={"organization": str(team.organization_id), "project": str(team.uuid)},+ )+++def run_pair(input: ActivitySummaryPairInput) -> ActivitySummaryPairResult:+ update = update_activity_summary(+ input.team_id,+ input.user_id,+ min_units=input.min_units,+ min_update_interval=datetime.timedelta(hours=input.min_update_interval_hours),+ )+ called_model = update.status in (UpdateStatus.OK, UpdateStatus.FAILED)+ if update.status == UpdateStatus.OK and input.emit_embeddings:+ try:+ _emit_embedding(input.team_id, input.user_id)+ except Exception:+ logger.exception("activity_summary_embedding_failed", team_id=input.team_id, user_id=input.user_id)+ if called_model and input.capture_events:+ try:+ _capture_generated(input.team_id, input.user_id, update)+ except Exception:+ logger.exception("activity_summary_capture_failed", team_id=input.team_id, user_id=input.user_id)+ return ActivitySummaryPairResult(status=update.status.value, cost_usd=update.cost_usd, called_model=called_model)+++def capture_tick(result: ActivitySummaryTickResult) -> None:+ logger.info(+ "activity_summary_tick_finished",+ candidates=result.candidates,+ picked=result.picked,+ statuses=result.statuses,+ errored=result.errored,+ cost_usd=result.cost_usd,+ stop_reason=result.stop_reason,+ )+ ph_background_capture()(+ distinct_id=PIPELINE_DISTINCT_ID,+ event="activity summary tick",+ properties={+ "candidates": result.candidates,+ "picked": result.picked,+ **{f"status_{status}": count for status, count in (result.statuses or {}).items()},+ "errored": result.errored,+ "cost_usd": result.cost_usd,+ "stop_reason": result.stop_reason,+ },+ )+++@scoped_temporal()+@close_db_connections+async def plan_activity_summary_tick_activity(input: ActivitySummaryTickInput) -> ActivitySummaryTickPlan:+ return await database_sync_to_async(plan_tick, thread_sensitive=False)(input.limit, timezone.now())+++@scoped_temporal()+@close_db_connections+async def update_activity_summary_pair_activity(input: ActivitySummaryPairInput) -> ActivitySummaryPairResult:+ async with Heartbeater():+ return await database_sync_to_async(run_pair, thread_sensitive=False)(input)+++@scoped_temporal()+@close_db_connections+async def capture_activity_summary_tick_activity(result: ActivitySummaryTickResult) -> None:+ await database_sync_to_async(capture_tick, thread_sensitive=False)(result)++[email protected](name=TICK_WORKFLOW_NAME)+class ActivitySummaryTickWorkflow:+ @workflow.run+ async def run(self, inputs: ActivitySummaryTickInput) -> ActivitySummaryTickResult:+ plan = await workflow.execute_activity(+ plan_activity_summary_tick_activity,+ inputs,+ start_to_close_timeout=_PLAN_TIMEOUT,+ retry_policy=RetryPolicy(maximum_attempts=2),+ )+ if not plan.enabled:+ return ActivitySummaryTickResult()++ statuses: Counter[str] = Counter()+ errored = 0+ cost = 0.0+ updates_left = plan.updates_left+ stop_reason = plan.stop_reason+ picked = 0+ concurrency = max(1, plan.max_concurrency)+ index = 0+ while index < len(plan.pairs):+ # A wave can pass the cost cap by at most one wave of updates at their highest cost.+ if updates_left <= 0:+ stop_reason = STOP_MAX_PAIRS_PER_DAY+ break+ if cost >= plan.cost_left_usd:+ stop_reason = STOP_MAX_COST_USD_PER_DAY+ break+ wave = plan.pairs[index : index + min(concurrency, updates_left)]+ index += len(wave)+ picked += len(wave)+ results = await asyncio.gather(+ *(+ workflow.execute_activity(+ update_activity_summary_pair_activity,+ ActivitySummaryPairInput(+ team_id=pair.team_id,+ user_id=pair.user_id,+ min_units=plan.min_units,+ min_update_interval_hours=plan.min_update_interval_hours,+ emit_embeddings=plan.emit_embeddings,+ capture_events=plan.capture_events,+ ),+ start_to_close_timeout=_PAIR_TIMEOUT,+ heartbeat_timeout=_PAIR_HEARTBEAT_TIMEOUT,+ retry_policy=_PAIR_RETRY_POLICY,+ )+ for pair in wave+ ),+ return_exceptions=True,+ )+ for outcome in results:+ if isinstance(outcome, BaseException):+ # The attempt can have called the model, so it counts at the highest cost.+ errored += 1+ updates_left -= 1+ cost += plan.max_update_cost_usd+ continue+ statuses[outcome.status] += 1+ if outcome.called_model:+ updates_left -= 1+ cost += plan.max_update_cost_usd if outcome.cost_usd is None else outcome.cost_usd++ result = ActivitySummaryTickResult(+ enabled=True,+ candidates=plan.candidates,+ picked=picked,+ statuses=dict(statuses),+ errored=errored,+ cost_usd=cost,+ stop_reason=stop_reason,+ )+ await workflow.execute_activity(+ capture_activity_summary_tick_activity,+ result,+ start_to_close_timeout=datetime.timedelta(minutes=1),+ retry_policy=RetryPolicy(maximum_attempts=2),+ )+ return resultdiff --git a/products/signals/backend/migrations/0188_useractivitysummary_skipped_status.py b/products/signals/backend/migrations/0188_useractivitysummary_skipped_status.pynew file mode 100644index 000000000000..86beb618ae89--- /dev/null+++ b/products/signals/backend/migrations/0188_useractivitysummary_skipped_status.py@@ -0,0 +1,20 @@+# Generated by Django 5.2.18 on 2026-10-20 22:41++from django.db import migrations, models+++class Migration(migrations.Migration):+ dependencies = [+ ("signals", "0187_useractivitysummary"),+ ]++ operations = [+ migrations.AlterField(+ model_name="useractivitysummary",+ name="status",+ field=models.CharField(+ choices=[("ok", "Ok"), ("failed", "Failed"), ("skipped", "Skipped")],+ max_length=20,+ ),+ ),+ ]diff --git a/products/signals/backend/migrations/max_migration.txt b/products/signals/backend/migrations/max_migration.txtindex 13afc68b1d76..e8b3c3234040 100644--- a/products/signals/backend/migrations/max_migration.txt+++ b/products/signals/backend/migrations/max_migration.txt@@ -1 +1 @@-0187_useractivitysummary+0188_useractivitysummary_skipped_statusdiff --git a/products/signals/backend/models.py b/products/signals/backend/models.pyindex 4baf9fb15a8e..f61ec849e281 100644--- a/products/signals/backend/models.py+++ b/products/signals/backend/models.py@@ -3747,6 +3747,8 @@ class UserActivitySummary(TeamScopedRootMixin, UUIDModel):class Status(models.TextChoices):OK = "ok"FAILED = "failed"+ # No update called the model yet. The row only holds the backoff in `next_eligible_at`.+ SKIPPED = "skipped"# See SignalReportRefund.all_teams for rationale.all_teams = models.Manager() # noqa: DJ012diff --git a/products/signals/backend/temporal/__init__.py b/products/signals/backend/temporal/__init__.pyindex 93ffccb0f8b1..1d4435c42eca 100644--- a/products/signals/backend/temporal/__init__.py+++ b/products/signals/backend/temporal/__init__.py@@ -1,3 +1,9 @@+from products.signals.backend.activity_summary.tick import (+ ActivitySummaryTickWorkflow,+ capture_activity_summary_tick_activity,+ plan_activity_summary_tick_activity,+ update_activity_summary_pair_activity,+)from products.signals.backend.ranking.sweep import InboxRankingScoringWorkflow, score_inbox_reports_activityfrom products.signals.backend.temporal.agentic.report import run_agentic_report_activityfrom products.signals.backend.temporal.agentic.scout_coordinator import (@@ -218,5 +224,10 @@ ACTIVITIES = []# The temporal-worker-self-driving fleet runs these, not video-export.-SELF_DRIVING_WORKFLOWS = [InboxRankingScoringWorkflow]-SELF_DRIVING_ACTIVITIES = [score_inbox_reports_activity]+SELF_DRIVING_WORKFLOWS = [InboxRankingScoringWorkflow, ActivitySummaryTickWorkflow]+SELF_DRIVING_ACTIVITIES = [+ score_inbox_reports_activity,+ plan_activity_summary_tick_activity,+ update_activity_summary_pair_activity,+ capture_activity_summary_tick_activity,+]diff --git a/products/signals/backend/test/test_activity_summary_tick.py b/products/signals/backend/test/test_activity_summary_tick.pynew file mode 100644index 000000000000..f59d59924d6d--- /dev/null+++ b/products/signals/backend/test/test_activity_summary_tick.py@@ -0,0 +1,378 @@+import json+import uuid+import asyncio+import datetime+from typing import Any++import pytest+import time_machine+from posthog.test.base import BaseTest+from unittest.mock import AsyncMock, MagicMock, patch++from parameterized import parameterized+from temporalio import activity+from temporalio.client import Client, ScheduleState+from temporalio.testing import WorkflowEnvironment+from temporalio.worker import UnsandboxedWorkflowRunner, Worker++from posthog.models import ActivityLog, Organization, Team, User++from products.signals.backend.activity_summary import (+ schedule as tick_schedule,+ tick,+)+from products.signals.backend.activity_summary.config import ActivitySummaryConfig, parse_config+from products.signals.backend.activity_summary.queue import (+ ActivitySummaryPair,+ daily_usage,+ max_update_cost_usd,+ select_pairs,+)+from products.signals.backend.activity_summary.schedule import (+ ACTIVITY_SUMMARY_TICK_SCHEDULE_ID,+ create_activity_summary_tick_schedule,+)+from products.signals.backend.activity_summary.tick import (+ STOP_MAX_COST_USD_PER_DAY,+ STOP_MAX_PAIRS_PER_DAY,+ STOP_MAX_PAIRS_PER_TICK,+ ActivitySummaryPairInput,+ ActivitySummaryPairResult,+ ActivitySummaryTickInput,+ ActivitySummaryTickPlan,+ ActivitySummaryTickResult,+ ActivitySummaryTickWorkflow,+ plan_tick,+ run_pair,+)+from products.signals.backend.models import UserActivitySummary+from products.signals.backend.test.test_activity_summary_render import FakeLLM+from products.tasks.backend.facade.user_task_summaries import UserTaskTime++NOW = datetime.datetime(2026, 10, 19, 12, tzinfo=datetime.UTC)+ANSWER = json.dumps(+ {+ "summary": "Builds the signup funnel.",+ "focus_areas": [{"topic": "signup funnel", "strength": "high", "last_seen": "2026-10-18"}],+ "products": ["product_analytics"],+ "recent_shift": None,+ }+)+++_CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [+ ("no payload", None, ActivitySummaryConfig()),+ ("not an object", "[1, 2]", ActivitySummaryConfig()),+ ("enabled is missing", {"organization_ids": ["a"]}, ActivitySummaryConfig()),+ ("enabled is not a bool", {"enabled": "true"}, ActivitySummaryConfig()),+ ("enabled with defaults", {"enabled": True}, ActivitySummaryConfig(enabled=True)),+ (+ "invalid fields fall back to the defaults",+ {+ "enabled": True,+ "organization_ids": ["org-a", 7, ""],+ "skip_team_ids": [3, "4", True],+ "max_pairs_per_tick": 0,+ "max_pairs_per_day": True,+ "max_cost_usd_per_day": -1,+ "max_concurrency": "8",+ "min_units": None,+ "min_update_interval_hours": 0,+ "emit_embeddings": "no",+ },+ ActivitySummaryConfig(enabled=True, organization_ids=("org-a",), skip_team_ids=(3,)),+ ),+ (+ "valid fields",+ {+ "enabled": True,+ "max_pairs_per_tick": 5,+ "max_cost_usd_per_day": 1,+ "min_update_interval_hours": 12,+ "capture_events": False,+ },+ ActivitySummaryConfig(+ enabled=True,+ max_pairs_per_tick=5,+ max_cost_usd_per_day=1.0,+ min_update_interval_hours=12.0,+ capture_events=False,+ ),+ ),+]++[email protected](_CONFIG_CASES)+def test_parse_config(_name: str, payload: Any, expected: ActivitySummaryConfig) -> None:+ assert parse_config(payload) == expected+++@time_machine.travel(NOW, tick=False)+class TestActivitySummaryQueue(BaseTest):+ def _config(self, **overrides: Any) -> ActivitySummaryConfig:+ return ActivitySummaryConfig(enabled=True, organization_ids=(str(self.organization.id),), **overrides)++ def _user(self, email: str) -> User:+ return User.objects.create_and_join(self.organization, email, None)++ def _changes(self, user: User, count: int, *, days_ago: float = 1, team: Team | None = None, **fields: Any):+ for index in range(count):+ ActivityLog.objects.create(+ team_id=(team or self.team).id,+ organization_id=self.organization.id,+ user=user,+ scope="Insight",+ activity="created",+ item_id=str(index),+ detail={"name": f"Funnel {index}"},+ created_at=NOW - datetime.timedelta(days=days_ago + index / 100),+ **fields,+ )++ def _summary(self, user: User, **fields: Any) -> None:+ UserActivitySummary.objects.for_team(self.team.id).create(+ team_id=self.team.id, user_id=user.id, status=UserActivitySummary.Status.OK, **fields+ )++ def _select(self, config: ActivitySummaryConfig | None = None, tasks: list[UserTaskTime] | None = None):+ with patch("products.signals.backend.activity_summary.queue.list_user_task_times", return_value=tasks or []):+ return [(pair.team_id, pair.user_id) for pair in select_pairs(config or self._config(), NOW, 10)]++ def test_orders_cold_starts_then_most_new_rows_then_oldest_summary(self) -> None:+ stale, fresh, busy, cold = (self._user(f"{name}@example.com") for name in ("stale", "fresh", "busy", "cold"))+ self._summary(+ stale, generated_at=NOW - datetime.timedelta(days=5), input_watermark=NOW - datetime.timedelta(days=3)+ )+ self._summary(+ fresh, generated_at=NOW - datetime.timedelta(days=2), input_watermark=NOW - datetime.timedelta(days=3)+ )+ self._summary(+ busy, generated_at=NOW - datetime.timedelta(days=1), input_watermark=NOW - datetime.timedelta(days=3)+ )+ self._changes(stale, 1)+ self._changes(fresh, 1)+ # Rows at or before the watermark are not new.+ self._changes(busy, 2, days_ago=4)+ self._changes(busy, 2)+ self._changes(cold, 1)+ tasks = [UserTaskTime(team_id=self.team.id, user_id=busy.id, created_at=NOW - datetime.timedelta(hours=1))]++ assert self._select(tasks=tasks) == [+ (self.team.id, cold.id),+ (self.team.id, busy.id),+ (self.team.id, stale.id),+ (self.team.id, fresh.id),+ ]++ def test_leaves_out_pairs_that_are_not_due_or_not_enrolled(self) -> None:+ waiting, scout_only, impersonated, skipped_team = (+ self._user(f"{name}@example.com") for name in ("waiting", "scout", "impersonated", "skipped")+ )+ due = self._user("[email protected]")+ self._summary(waiting, next_eligible_at=NOW + datetime.timedelta(hours=1))+ self._changes(waiting, 3)+ self._changes(scout_only, 3, client="scout:product-analytics")+ self._changes(impersonated, 3, was_impersonated=True)+ other_team = Team.objects.create(organization=self.organization, name="Skipped")+ self._changes(skipped_team, 3, team=other_team)+ self._changes(due, 3)+ other_org = Organization.objects.create(name="Not enrolled")+ self._changes(due, 3, team=Team.objects.create(organization=other_org, name="Other"))++ assert self._select(self._config(skip_team_ids=(other_team.id,))) == [(self.team.id, due.id)]++ def test_selects_nothing_without_ai_data_processing_approval(self) -> None:+ self.organization.is_ai_data_processing_approved = False+ self.organization.save()+ self._changes(self.user, 3)++ assert self._select() == []++ def test_daily_usage_counts_model_calls_and_prices_a_missing_cost_at_the_bound(self) -> None:+ priced, unpriced, skipped = (self._user(f"{name}@example.com") for name in ("priced", "unpriced", "skipped"))+ self._summary(priced, cost_usd=0.25)+ UserActivitySummary.objects.for_team(self.team.id).create(+ team_id=self.team.id, user_id=unpriced.id, status=UserActivitySummary.Status.FAILED+ )+ UserActivitySummary.objects.for_team(self.team.id).create(+ team_id=self.team.id, user_id=skipped.id, status=UserActivitySummary.Status.SKIPPED+ )++ usage = daily_usage(NOW)++ assert usage.updates == 2+ assert usage.cost_usd == pytest.approx(0.25 + max_update_cost_usd())+ with time_machine.travel(NOW + datetime.timedelta(days=1, minutes=1), tick=False):+ assert daily_usage(NOW + datetime.timedelta(days=1, minutes=1)).updates == 0++ @parameterized.expand(+ [+ ("the tick cap", {"max_pairs_per_tick": 1}, STOP_MAX_PAIRS_PER_TICK, 1),+ ("the daily pair cap", {"max_pairs_per_day": 1}, STOP_MAX_PAIRS_PER_DAY, 0),+ ("the daily cost cap", {"max_cost_usd_per_day": 0.1}, STOP_MAX_COST_USD_PER_DAY, 0),+ ("no cap", {}, None, 2),+ ]+ )+ def test_plan_names_the_cap_that_stops_it(+ self, _name: str, overrides: dict[str, Any], stop_reason: str | None, pairs: int+ ) -> None:+ self._changes(self._user("[email protected]"), 3)+ self._changes(self._user("[email protected]"), 3)+ self._summary(self.user, cost_usd=0.1)++ with (+ patch.object(tick, "read_config", return_value=self._config(**overrides)),+ patch("products.signals.backend.activity_summary.queue.list_user_task_times", return_value=[]),+ ):+ plan = plan_tick(None, NOW)++ assert (plan.stop_reason, len(plan.pairs)) == (stop_reason, pairs)++ def test_a_skipped_pair_does_not_come_back_on_the_next_tick(self) -> None:+ self._changes(self.user, 2)+ pair_input = ActivitySummaryPairInput(+ team_id=self.team.id,+ user_id=self.user.id,+ min_units=3,+ min_update_interval_hours=24,+ emit_embeddings=True,+ capture_events=True,+ )+ assert self._select() == [(self.team.id, self.user.id)]++ with patch("products.signals.backend.activity_summary.logic.gateway_client", return_value=FakeLLM([ANSWER])):+ result = run_pair(pair_input)++ assert (result.status, result.called_model) == ("skipped_too_few_units", False)+ assert self._select() == []++ def test_an_ok_update_emits_the_embedding_and_an_event_without_the_summary(self) -> None:+ self._changes(self.user, 3)+ capture = MagicMock()+ with (+ patch("products.signals.backend.activity_summary.logic.gateway_client", return_value=FakeLLM([ANSWER])),+ patch("posthog.api.embedding_worker.emit_embedding_request") as emit,+ patch.object(tick, "ph_background_capture", return_value=capture),+ ):+ result = run_pair(+ ActivitySummaryPairInput(+ team_id=self.team.id,+ user_id=self.user.id,+ min_units=3,+ min_update_interval_hours=24,+ emit_embeddings=True,+ capture_events=True,+ )+ )++ assert (result.status, result.called_model) == ("ok", True)+ assert emit.call_args.kwargs["document_id"] == f"{self.user.id}:2026-10-19"+ assert emit.call_args.kwargs["content"] == "Builds the signup funnel.\nFocus areas: signup funnel"+ event = capture.call_args.kwargs+ assert event["event"] == "activity summary generated"+ assert "signup funnel" not in json.dumps(event["properties"]).lower()+++async def test_an_update_keeps_an_operator_pause() -> None:+ client = MagicMock(spec=Client)+ state = ScheduleState(paused=True, note="Paused by an operator")+ client.get_schedule_handle.return_value.describe = AsyncMock(+ return_value=MagicMock(schedule=MagicMock(state=state))+ )+ with (+ patch.object(tick_schedule, "a_schedule_exists", return_value=True),+ patch.object(tick_schedule, "a_create_schedule") as create,+ patch.object(tick_schedule, "a_update_schedule") as update,+ ):+ await create_activity_summary_tick_schedule(client)++ create.assert_not_awaited()+ client.get_schedule_handle.assert_called_once_with(ACTIVITY_SUMMARY_TICK_SCHEDULE_ID)+ assert update.await_args is not None+ assert update.await_args.args[2].state == state+++def _plan(pairs: int, **overrides: Any) -> ActivitySummaryTickPlan:+ fields: dict[str, Any] = {+ "enabled": True,+ "pairs": [ActivitySummaryPair(team_id=1, user_id=user_id) for user_id in range(pairs)],+ "candidates": pairs,+ "updates_left": 100,+ "cost_left_usd": 100.0,+ "max_update_cost_usd": 1.0,+ "max_concurrency": 2,+ "min_units": 3,+ "min_update_interval_hours": 24.0,+ "emit_embeddings": True,+ "capture_events": True,+ "stop_reason": None,+ }+ return ActivitySummaryTickPlan(**{**fields, **overrides})+++async def _run_tick(+ plan: ActivitySummaryTickPlan, pair_cost: float | None+) -> tuple[ActivitySummaryTickResult, int, list[ActivitySummaryTickResult]]:+ running = peak = 0+ captured: list[ActivitySummaryTickResult] = []++ @activity.defn(name="plan_activity_summary_tick_activity")+ async def fake_plan(input: ActivitySummaryTickInput) -> ActivitySummaryTickPlan:+ return plan++ @activity.defn(name="update_activity_summary_pair_activity")+ async def fake_pair(input: ActivitySummaryPairInput) -> ActivitySummaryPairResult:+ nonlocal running, peak+ running += 1+ peak = max(peak, running)+ await asyncio.sleep(0.01)+ running -= 1+ return ActivitySummaryPairResult(status="ok", cost_usd=pair_cost, called_model=True)++ @activity.defn(name="capture_activity_summary_tick_activity")+ async def fake_capture(result: ActivitySummaryTickResult) -> None:+ captured.append(result)++ async with await WorkflowEnvironment.start_time_skipping() as env:+ async with Worker(+ env.client,+ task_queue="activity-summary-tick-test",+ workflows=[ActivitySummaryTickWorkflow],+ activities=[fake_plan, fake_pair, fake_capture],+ workflow_runner=UnsandboxedWorkflowRunner(),+ ):+ result = await env.client.execute_workflow(+ ActivitySummaryTickWorkflow.run,+ ActivitySummaryTickInput(),+ id=f"activity-summary-tick-{uuid.uuid4()}",+ task_queue="activity-summary-tick-test",+ )+ return result, peak, captured+++ "plan,pair_cost,picked,stop_reason",+ [+ (_plan(5), 0.01, 5, None),+ (_plan(5, updates_left=3), 0.01, 3, STOP_MAX_PAIRS_PER_DAY),+ # A missing cost counts at the bound, so the second wave spends the last of the budget.+ (_plan(6, cost_left_usd=3.0), None, 4, STOP_MAX_COST_USD_PER_DAY),+ ],+)+async def test_the_tick_bounds_concurrency_and_stops_at_the_daily_caps(+ plan: ActivitySummaryTickPlan, pair_cost: float | None, picked: int, stop_reason: str | None+) -> None:+ result, peak, captured = await _run_tick(plan, pair_cost)++ assert peak <= plan.max_concurrency+ assert (result.picked, result.statuses, result.stop_reason) == (picked, {"ok": picked}, stop_reason)+ assert captured == [result]+++async def test_a_disabled_tick_runs_no_pair() -> None:+ result, peak, captured = await _run_tick(_plan(0, enabled=False), 0.01)++ assert (result, peak, captured) == (ActivitySummaryTickResult(), 0, [])diff --git a/products/signals/backend/test/test_activity_summary_update.py b/products/signals/backend/test/test_activity_summary_update.pyindex 9cecd472e001..ef295dd71dca 100644--- a/products/signals/backend/test/test_activity_summary_update.py+++ b/products/signals/backend/test/test_activity_summary_update.py@@ -99,10 +99,11 @@ class TestUpdateActivitySummary(BaseTest):assert after.error == "malformed_output: response was truncated"assert (after.summary, after.input_watermark) == (before.summary, before.input_watermark)assert (after.tokens_in, after.tokens_out, after.cost_usd) == (None, None, None)+ assert after.next_eligible_at == NOW + datetime.timedelta(hours=6)@parameterized.expand([- ("too few units", 2, {}, UpdateStatus.SKIPPED_TOO_FEW_UNITS),+ ("too few units in a dry run", 2, {"dry_run": True}, UpdateStatus.SKIPPED_TOO_FEW_UNITS),("a dry run", 3, {"dry_run": True}, UpdateStatus.OK),])@@ -113,6 +114,28 @@ class TestUpdateActivitySummary(BaseTest):assert self._update(FakeLLM([ANSWER]), **kwargs).status == statusassert self._stored() is None+ def test_too_few_units_backs_off_without_touching_the_stored_summary(self) -> None:+ self._changes(2)+ llm = FakeLLM([ANSWER])++ assert self._update(llm).status == UpdateStatus.SKIPPED_TOO_FEW_UNITS+ assert llm.requests == []+ skipped = self._stored()+ assert skipped is not None+ assert (skipped.status, skipped.summary) == (UserActivitySummary.Status.SKIPPED, None)+ assert skipped.next_eligible_at == NOW + datetime.timedelta(hours=6)++ with time_machine.travel(NOW + datetime.timedelta(hours=7), tick=False):+ assert self._update(FakeLLM([ANSWER]), min_units=2).status == UpdateStatus.OK+ before = self._stored()+ assert before is not None+ with time_machine.travel(NOW + datetime.timedelta(days=2), tick=False):+ assert self._update(FakeLLM([ANSWER])).status == UpdateStatus.SKIPPED_TOO_FEW_UNITS+ after = self._stored()+ assert after is not None+ assert (after.status, after.summary, after.updated_at) == (before.status, before.summary, before.updated_at)+ assert after.next_eligible_at == NOW + datetime.timedelta(days=2, hours=6)+def test_skips_until_next_eligible_unless_forced(self) -> None:self._changes(3, days_ago=2)self._update(FakeLLM([ANSWER]))diff --git a/products/tasks/backend/facade/user_task_summaries.py b/products/tasks/backend/facade/user_task_summaries.pyindex 3e78c1c2d157..302646fd7afc 100644--- a/products/tasks/backend/facade/user_task_summaries.py+++ b/products/tasks/backend/facade/user_task_summaries.py@@ -1,5 +1,10 @@"""Facade re-export for reading the tasks a person started, with their latest run's summary and tags."""-from products.tasks.backend.logic.user_task_summaries import UserTaskSummary, list_user_task_summaries+from products.tasks.backend.logic.user_task_summaries import (+ UserTaskSummary,+ UserTaskTime,+ list_user_task_summaries,+ list_user_task_times,+)-__all__ = ["UserTaskSummary", "list_user_task_summaries"]+__all__ = ["UserTaskSummary", "UserTaskTime", "list_user_task_summaries", "list_user_task_times"]diff --git a/products/tasks/backend/logic/user_task_summaries.py b/products/tasks/backend/logic/user_task_summaries.pyindex 882c89d79653..f1d434562ed2 100644--- a/products/tasks/backend/logic/user_task_summaries.py+++ b/products/tasks/backend/logic/user_task_summaries.py@@ -34,6 +34,13 @@ class UserTaskSummary:tags: tuple[str, ...]+@frozen+class UserTaskTime:+ team_id: int+ user_id: int+ created_at: datetime.datetime++def _tags(value: object) -> tuple[str, ...]:return tuple(tag for tag in value if isinstance(tag, str)) if isinstance(value, list) else ()@@ -99,3 +106,30 @@ def list_user_task_summaries())return summaries+++def list_user_task_times(+ *,+ team_ids: Collection[int],+ start: datetime.datetime,+ end: datetime.datetime,+ origin_products: Collection[str],+) -> list[UserTaskTime]:+ """The creator and creation time of every non-deleted task in these teams, in [start, end).++ One query for all users, so a caller can count new tasks per person without a query per person.+ Tasks with no creator are left out.+ """+ if not team_ids or not origin_products:+ return []+ rows = Task.objects.filter(+ team_id__in=list(team_ids),+ created_by_id__isnull=False,+ origin_product__in=list(origin_products),+ created_at__gte=start,+ created_at__lt=end,+ deleted=False,+ ).values_list("team_id", "created_by_id", "created_at")+ return [+ UserTaskTime(team_id=team_id, user_id=user_id, created_at=created_at) for team_id, user_id, created_at in rows+ ]diff --git a/products/tasks/backend/tests/test_user_task_summaries.py b/products/tasks/backend/tests/test_user_task_summaries.pyindex 7cbc7fd25159..cbcba4fb017f 100644--- a/products/tasks/backend/tests/test_user_task_summaries.py+++ b/products/tasks/backend/tests/test_user_task_summaries.py@@ -4,7 +4,7 @@ from posthog.test.base import BaseTestfrom posthog.models import User-from products.tasks.backend.facade.user_task_summaries import list_user_task_summaries+from products.tasks.backend.facade.user_task_summaries import list_user_task_summaries, list_user_task_timesfrom products.tasks.backend.models import Task, TaskRunNOW = datetime(2026, 10, 19, tzinfo=UTC)@@ -44,3 +44,24 @@ class TestListUserTaskSummaries(BaseTest):assert [(s.title, s.summary, s.tags) for s in summaries] == [("why did signups drop", "Goal: find the signup drop.", ()),]++ def test_lists_the_creator_and_time_of_every_own_task_in_the_window(self) -> None:+ other = User.objects.create(email="[email protected]")+ self._task("mine", days_ago=3)+ self._task("theirs", user=other, days_ago=2)+ self._task("scout run", origin="signals_scout")+ self._task("too old", days_ago=40)+ deleted = self._task("deleted")+ deleted.deleted = True+ deleted.save()++ times = list_user_task_times(+ team_ids=[self.team.id],+ start=NOW - timedelta(days=28),+ end=NOW,+ origin_products=["slack", "posthog_ai", "user_created"],+ )++ assert sorted((t.user_id, t.created_at) for t in times) == sorted(+ [(self.user.id, NOW - timedelta(days=3)), (other.id, NOW - timedelta(days=2))]+ )