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(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.py
index 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_AGE
INBOX_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 globs
diff --git a/posthog/temporal/schedule.py b/posthog/temporal/schedule.py
index 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_re
from products.replay_vision.backend.temporal.vision_alerts.schedule import create_vision_alert_check_schedule
from products.review_hog.backend.facade.temporal import create_review_hog_finding_outcomes_schedule
from products.security.backend.facade.temporal import create_sync_access_rules_schedule
+from products.signals.backend.activity_summary.schedule import create_activity_summary_tick_schedule
from products.signals.backend.emission.conversations_schedule import create_conversations_signals_coordinator_schedule
from products.signals.backend.ranking.schedule import create_inbox_ranking_scoring_schedule
from 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.py
new file mode 100644
index 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 config
diff --git a/products/signals/backend/activity_summary/logic.py b/products/signals/backend/activity_summary/logic.py
index 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 = 3
MIN_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 first
run. 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 result
diff --git a/products/signals/backend/activity_summary/queue.py b/products/signals/backend/activity_summary/queue.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 result
diff --git a/products/signals/backend/migrations/0188_useractivitysummary_skipped_status.py b/products/signals/backend/migrations/0188_useractivitysummary_skipped_status.py
new file mode 100644
index 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.txt
index 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_status
diff --git a/products/signals/backend/models.py b/products/signals/backend/models.py
index 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: DJ012
diff --git a/products/signals/backend/temporal/__init__.py b/products/signals/backend/temporal/__init__.py
index 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_activity
from products.signals.backend.temporal.agentic.report import run_agentic_report_activity
from 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.py
new file mode 100644
index 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.py
index 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 == status
assert 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.py
index 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.py
index 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.py
index 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 BaseTest
from 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_times
from products.tasks.backend.models import Task, TaskRun
NOW = 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))]
+ )