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): queue activity summaries for users with only mcp reads (#126916)

posthog[bot]f5cd6e3adafa
diff --git a/products/signals/backend/activity_summary/config.py b/products/signals/backend/activity_summary/config.py
index 88d27d06df61..ddcd451fa135 100644
--- a/products/signals/backend/activity_summary/config.py
+++ b/products/signals/backend/activity_summary/config.py
@@ -48,6 +48,8 @@ class SourceWeights:
repeat_view_days: float = 0.0
# A new day of opening a product scene.
scene_views: float = 0.0
+ # A distinct MCP session after the pair's watermark, without plumbing routes.
+ mcp: float = 1.0
@frozen
@@ -114,6 +116,8 @@ class ActivitySummaryConfig:
mcp_buffer_days: int = 10
# Renders the buffer in the input. Apart from `mcp_buffer_enabled`, so the buffer can fill before the prompt uses it.
mcp_render_enabled: bool = False
+ # Drains the buffer's dirty set into the queue, so a pair with only MCP calls can come due. Needs `mcp_render_enabled`.
+ mcp_queue_enabled: bool = False
DISABLED = ActivitySummaryConfig()
@@ -260,6 +264,7 @@ def parse_config(payload: Any) -> ActivitySummaryConfig:
_positive_int(payload.get("mcp_buffer_days"), defaults.mcp_buffer_days), MAX_MCP_BUFFER_DAYS
),
mcp_render_enabled=_bool(payload.get("mcp_render_enabled"), defaults.mcp_render_enabled),
+ mcp_queue_enabled=_bool(payload.get("mcp_queue_enabled"), defaults.mcp_queue_enabled),
)
diff --git a/products/signals/backend/activity_summary/inputs.py b/products/signals/backend/activity_summary/inputs.py
index 36fc0520a53d..ea5c0d07d92d 100644
--- a/products/signals/backend/activity_summary/inputs.py
+++ b/products/signals/backend/activity_summary/inputs.py
@@ -164,7 +164,7 @@ class McpRead:
read_error: bool = False
-def _mcp_redis_client() -> redis.Redis:
+def mcp_redis_client() -> redis.Redis:
return get_client(
settings.ACTIVITY_SUMMARY_MCP_BUFFER_REDIS_URL or None,
socket_timeout=MCP_READ_TIMEOUT_SECONDS,
@@ -179,7 +179,7 @@ def user_mcp_records(
end: datetime.datetime,
*,
max_days: int,
- redis_client: Callable[[], redis.Redis] = _mcp_redis_client,
+ redis_client: Callable[[], redis.Redis] = mcp_redis_client,
) -> McpRead:
"""The user's buffered MCP calls in [start, end), from the newest `max_days` UTC days, in one pipeline.
diff --git a/products/signals/backend/activity_summary/queue.py b/products/signals/backend/activity_summary/queue.py
index 565e6e65d0f7..d3f2798933f3 100644
--- a/products/signals/backend/activity_summary/queue.py
+++ b/products/signals/backend/activity_summary/queue.py
@@ -41,13 +41,17 @@ from django.db.models import (
from django.db.models.expressions import Combinable
from django.db.models.functions import Cast, Coalesce, Extract, Greatest, Ln, RowNumber
+import redis
+import structlog
+
from posthog.dataclasses import frozen
from posthog.models import ActivityLog, FileSystemViewLog, Team
from products.signals.backend import org_rollout
from products.signals.backend.activity_summary.config import ActivitySummaryConfig, SourceWeights
-from products.signals.backend.activity_summary.inputs import TASK_ORIGIN_PRODUCTS
+from products.signals.backend.activity_summary.inputs import TASK_ORIGIN_PRODUCTS, mcp_redis_client
from products.signals.backend.activity_summary.logic import EXCEPTION_ERROR_PREFIX
+from products.signals.backend.activity_summary.mcp_buffer import DIRTY_KEY, parse_record, records_key, window_days
from products.signals.backend.activity_summary.prompt import COMPUTED_MAX_CHARS, PROMPT_VERSION, system_prompt
from products.signals.backend.activity_summary.render import (
DEFAULT_LIMITS,
@@ -60,7 +64,9 @@ from products.signals.backend.activity_summary.render import (
SCENE_VIEW_TYPE,
SCOUT_CLIENT_PREFIX,
SETUP_SCOPES,
+ McpItem,
RenderLimits,
+ is_plumbing_route,
)
from products.signals.backend.activity_summary.summaries import DEFAULT_MODEL, MAX_ATTEMPTS, MODEL_PRICES, cost_usd
from products.signals.backend.models import (
@@ -70,6 +76,8 @@ from products.signals.backend.models import (
)
from products.tasks.backend.facade.user_task_summaries import list_user_task_times
+logger = structlog.get_logger(__name__)
+
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
@@ -92,6 +100,9 @@ TIER_PAYING = "paying"
TIER_FREE = "free"
# A summary younger than this many target intervals counts as fresh on the tick event.
_FRESH_STALENESS = 2
+# One tick drains at most this many members of the MCP dirty set. The other members wait for the next tick.
+MAX_MCP_FEED_PAIRS = 2_000
+_MCP_FEED_BATCH = 200
# Why the queue picked a pair.
TRIGGER_ACTIVITY = "activity"
@@ -100,7 +111,9 @@ TRIGGER_VIEWS = "views"
# A pair with no summary and a pending score below `min_score`, due on its days with views.
TRIGGER_COLD_START_VIEWS = "cold_start_views"
TRIGGER_STALE = "stale"
-TRIGGERS = (TRIGGER_ACTIVITY, TRIGGER_VIEWS, TRIGGER_COLD_START_VIEWS, TRIGGER_STALE)
+# MCP sessions make up at least half of the weighted pending score.
+TRIGGER_MCP = "mcp"
+TRIGGERS = (TRIGGER_ACTIVITY, TRIGGER_VIEWS, TRIGGER_COLD_START_VIEWS, TRIGGER_STALE, TRIGGER_MCP)
VIEW_TRIGGERS = frozenset({TRIGGER_VIEWS, TRIGGER_COLD_START_VIEWS})
@@ -585,6 +598,122 @@ def feed_queue(config: ActivitySummaryConfig, now: datetime.datetime, team_ids:
return fed
+@frozen
+class McpFeed:
+ pairs: int = 0
+ sessions: int = 0
+ # Dirty members of teams that are not enrolled, or members that do not parse.
+ ignored: int = 0
+ error: bool = False
+
+
+def _mcp_pair(member: bytes | str | int | float, team_ids: set[int]) -> ActivitySummaryPair | None:
+ text = member.decode() if isinstance(member, bytes) else str(member)
+ team_id, _, user_id = text.partition(":")
+ try:
+ pair = ActivitySummaryPair(team_id=int(team_id), user_id=int(user_id))
+ except ValueError:
+ return None
+ return pair if pair.team_id in team_ids else None
+
+
+def _mcp_sessions(records: Iterable[McpItem]) -> tuple[int, datetime.datetime | None]:
+ """The distinct sessions of the records without plumbing routes, and the time of the newest one.
+
+ A record with no session id counts as its own session."""
+ sessions: set[str] = set()
+ without_session = 0
+ last_at: datetime.datetime | None = None
+ for record in records:
+ if is_plumbing_route(record.route_name):
+ continue
+ if record.session_id:
+ sessions.add(record.session_id)
+ else:
+ without_session += 1
+ last_at = record.at if last_at is None else max(last_at, record.at)
+ return len(sessions) + without_session, last_at
+
+
+def _read_mcp(
+ client: redis.Redis,
+ pairs: list[ActivitySummaryPair],
+ watermarks: dict[ActivitySummaryPair, datetime.datetime | None],
+ config: ActivitySummaryConfig,
+ now: datetime.datetime,
+) -> dict[ActivitySummaryPair, list[McpItem]]:
+ """The buffered records of each pair after its watermark, from the newest `mcp_buffer_days` days, in one pipeline."""
+ window_start = now - datetime.timedelta(days=config.limits.window_days)
+ starts: dict[ActivitySummaryPair, datetime.datetime] = {}
+ keys: list[tuple[ActivitySummaryPair, str]] = []
+ for pair in pairs:
+ watermark = watermarks.get(pair)
+ starts[pair] = window_start if watermark is None else max(window_start, watermark)
+ for day in window_days(starts[pair], now, config.mcp_buffer_days):
+ keys.append((pair, records_key(pair.team_id, pair.user_id, day)))
+ pipeline = client.pipeline(transaction=False)
+ for _, key in keys:
+ pipeline.lrange(key, 0, -1)
+ records: dict[ActivitySummaryPair, list[McpItem]] = {pair: [] for pair in pairs}
+ for (pair, _), values in zip(keys, pipeline.execute()):
+ for value in values:
+ record = parse_record(value)
+ if record is not None and record.at > starts[pair]:
+ records[pair].append(record)
+ return records
+
+
+def _set_mcp_score(pair: ActivitySummaryPair, score: float, last_at: datetime.datetime | None) -> None:
+ fields: dict[str, Any] = {
+ # Postgres reads the old `pending_mcp_score` on the right side of every assignment.
+ "pending_score": F("pending_score") - F("pending_mcp_score") + score,
+ "pending_mcp_score": score,
+ }
+ if last_at is not None:
+ fields["last_activity_at"] = Greatest("last_activity_at", last_at)
+ UserActivitySummaryQueueState.objects.for_team(pair.team_id).filter(user_id=pair.user_id).update(**fields)
+
+
+def feed_mcp_queue(
+ config: ActivitySummaryConfig,
+ now: datetime.datetime,
+ team_ids: list[int],
+ redis_client: Callable[[], redis.Redis] = mcp_redis_client,
+) -> McpFeed:
+ """Drain the MCP buffer's dirty set into the queue state of the enrolled pairs.
+
+ Each drained pair gets its MCP score again from the records after its watermark: the `mcp` weight
+ times its distinct sessions. The score replaces the earlier MCP part, so a record never counts twice.
+ The buffer is optional context, so this never raises. A member that left the set before an error
+ comes back with the user's next MCP call.
+ """
+ enrolled = set(team_ids)
+ pairs_fed = sessions_fed = ignored = 0
+ try:
+ client = redis_client()
+ drained = 0
+ while drained < MAX_MCP_FEED_PAIRS:
+ members = client.spop(DIRTY_KEY, min(_MCP_FEED_BATCH, MAX_MCP_FEED_PAIRS - drained))
+ if not members:
+ break
+ drained += len(members)
+ pairs = sorted({pair for member in members if (pair := _mcp_pair(member, enrolled)) is not None})
+ ignored += len(members) - len(pairs)
+ if not pairs:
+ continue
+ records = _read_mcp(client, pairs, _watermarks(sorted({pair.team_id for pair in pairs})), config, now)
+ counted = {pair: _mcp_sessions(records[pair]) for pair in pairs}
+ _create_missing_states([pair for pair, (sessions, _) in counted.items() if sessions])
+ for pair, (sessions, last_at) in counted.items():
+ _set_mcp_score(pair, sessions * config.source_weights.mcp, last_at)
+ pairs_fed += sessions > 0
+ sessions_fed += sessions
+ except Exception:
+ logger.warning("activity_summary.mcp_queue_feed_failed", exc_info=True)
+ return McpFeed(pairs=pairs_fed, sessions=sessions_fed, ignored=ignored, error=True)
+ return McpFeed(pairs=pairs_fed, sessions=sessions_fed, ignored=ignored)
+
+
def seed_queue(config: ActivitySummaryConfig, team_ids: list[int], end: datetime.datetime) -> int:
"""Set the queue state of these teams from the rows in the window before `end`.
@@ -609,7 +738,7 @@ def seed_queue(config: ActivitySummaryConfig, team_ids: list[int], end: datetime
with transaction.atomic():
# nosemgrep: idor-lookup-without-team (operator backfill with no user input; filtered to the given teams)
UserActivitySummaryQueueState.all_teams.filter(team_id__in=team_ids).update(
- pending_units=0, pending_score=0.0, pending_view_score=0.0, view_active_days=0
+ pending_units=0, pending_score=0.0, pending_view_score=0.0, pending_mcp_score=0.0, view_active_days=0
)
_add_pending(pending)
_add_pending(viewed, views)
@@ -643,7 +772,12 @@ def sync_pair_state(team_id: int, user_id: int) -> None:
watermark = stored["input_watermark"]
cleared = {
name: F(name) if watermark is None else Case(When(last_activity_at__lte=watermark, then=zero), default=F(name))
- for name, zero in (("pending_units", 0), ("pending_score", 0.0), ("pending_view_score", 0.0))
+ for name, zero in (
+ ("pending_units", 0),
+ ("pending_score", 0.0),
+ ("pending_view_score", 0.0),
+ ("pending_mcp_score", 0.0),
+ )
}
UserActivitySummaryQueueState.objects.for_team(team_id).filter(user_id=user_id).update(
**_state_fields(stored), **cleared
@@ -714,6 +848,7 @@ def _due(states: QuerySet, config: ActivitySummaryConfig, now: datetime.datetime
When(stale=True, then=Value(TRIGGER_STALE)),
# A due pair below `min_score` that is not stale is due only on its days with views.
When(weighted_score__lt=config.min_score, then=Value(TRIGGER_COLD_START_VIEWS)),
+ When(pending_mcp_score__gte=F("weighted_score") / 2, then=Value(TRIGGER_MCP)),
When(write_score__lt=F("weighted_score") / 2, then=Value(TRIGGER_VIEWS)),
default=Value(TRIGGER_ACTIVITY),
)
diff --git a/products/signals/backend/activity_summary/render.py b/products/signals/backend/activity_summary/render.py
index 6f77d236dd14..1a52ae17d8bf 100644
--- a/products/signals/backend/activity_summary/render.py
+++ b/products/signals/backend/activity_summary/render.py
@@ -1090,7 +1090,7 @@ def view_units(
return sorted(units, key=lambda unit: (unit.at, unit.text))
-def _is_plumbing_route(route_name: str) -> bool:
+def is_plumbing_route(route_name: str) -> bool:
return route_name in MCP_PLUMBING_ROUTES or route_name.startswith(MCP_PLUMBING_ROUTE_PREFIXES)
@@ -1143,7 +1143,7 @@ def _mcp_sessions(records: Iterable[McpItem], shown_intents: frozenset[str], dro
A record without a session id is its own session, and a long pause splits a session in two."""
grouped: dict[tuple[str, int], list[McpItem]] = {}
for index, record in enumerate(records):
- if _is_plumbing_route(record.route_name):
+ if is_plumbing_route(record.route_name):
drops[Drop.MCP_PLUMBING_ROUTE] += 1
continue
grouped.setdefault((record.session_id, -1) if record.session_id else ("", index), []).append(record)
diff --git a/products/signals/backend/activity_summary/tick.py b/products/signals/backend/activity_summary/tick.py
index 37ad55c9addc..c7f350447d80 100644
--- a/products/signals/backend/activity_summary/tick.py
+++ b/products/signals/backend/activity_summary/tick.py
@@ -51,8 +51,10 @@ from products.signals.backend.activity_summary.queue import (
VIEW_TRIGGERS,
ActivitySummaryPair,
ActivitySummaryTierStats,
+ McpFeed,
daily_usage,
enrollment,
+ feed_mcp_queue,
feed_queue,
is_team_enrolled_for_generation,
max_update_cost_usd,
@@ -136,6 +138,7 @@ class ActivitySummaryTickPlan:
# The days of the MCP intent buffer each update reads. None when `mcp_render_enabled` is off.
mcp_buffer_days: int | None = None
emit_profile_embeddings: bool = False
+ mcp_feed: McpFeed = dataclasses.field(default_factory=McpFeed)
@frozen
@@ -184,6 +187,7 @@ class ActivitySummaryTickResult:
refresh_builds: int = 0
# Due pairs at the start of the tick, per trigger.
due_by_trigger: dict[str, int] = dataclasses.field(default_factory=dict)
+ mcp_feed: McpFeed = dataclasses.field(default_factory=McpFeed)
def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickPlan:
@@ -207,6 +211,9 @@ def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickP
if config.enabled:
# The cursors move even when a cap stops the tick, so new rows do not pile up behind them.
feed_queue(config, now, enrolled.team_ids)
+ mcp_feed = McpFeed()
+ if config.enabled and config.mcp_queue_enabled and config.mcp_render_enabled:
+ mcp_feed = feed_mcp_queue(config, now, enrolled.team_ids)
usage = daily_usage(now) if 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
@@ -248,6 +255,7 @@ def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickP
rebuild_before=config.rebuild_before,
max_versions=config.max_versions,
mcp_buffer_days=config.mcp_buffer_days if config.mcp_render_enabled else None,
+ mcp_feed=mcp_feed,
)
@@ -420,6 +428,7 @@ def capture_tick(result: ActivitySummaryTickResult) -> None:
new_builds=result.new_builds,
refresh_builds=result.refresh_builds,
due_by_trigger=result.due_by_trigger,
+ **{f"mcp_feed_{name}": value for name, value in dataclasses.asdict(result.mcp_feed).items()},
**dataclasses.asdict(result.enrollment),
)
ph_background_capture()(
@@ -436,6 +445,7 @@ def capture_tick(result: ActivitySummaryTickResult) -> None:
"new_builds": result.new_builds,
"refresh_builds": result.refresh_builds,
**{f"due_{trigger}": result.due_by_trigger.get(trigger, 0) for trigger in TRIGGERS},
+ **{f"mcp_feed_{name}": value for name, value in dataclasses.asdict(result.mcp_feed).items()},
**dataclasses.asdict(result.enrollment),
**{
f"{tier.tier}_{name}": getattr(tier, name)
@@ -568,6 +578,7 @@ class ActivitySummaryTickWorkflow:
new_builds=builds[True],
refresh_builds=builds[False],
due_by_trigger=plan.due_by_trigger,
+ mcp_feed=plan.mcp_feed,
)
await workflow.execute_activity(
capture_activity_summary_tick_activity,
diff --git a/products/signals/backend/migrations/0228_useractivitysummaryqueuestate_pending_mcp_score.py b/products/signals/backend/migrations/0228_useractivitysummaryqueuestate_pending_mcp_score.py
new file mode 100644
index 000000000000..01c2317e5a72
--- /dev/null
+++ b/products/signals/backend/migrations/0228_useractivitysummaryqueuestate_pending_mcp_score.py
@@ -0,0 +1,15 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("signals", "0227_personalinboxranking_checked_at"),
+ ]
+
+ operations = [
+ migrations.AddField(
+ model_name="useractivitysummaryqueuestate",
+ name="pending_mcp_score",
+ field=models.FloatField(default=0.0),
+ ),
+ ]
diff --git a/products/signals/backend/migrations/max_migration.txt b/products/signals/backend/migrations/max_migration.txt
index fc3442974dc3..1950e812051f 100644
--- a/products/signals/backend/migrations/max_migration.txt
+++ b/products/signals/backend/migrations/max_migration.txt
@@ -1 +1 @@
-0227_personalinboxranking_checked_at
+0228_useractivitysummaryqueuestate_pending_mcp_score
diff --git a/products/signals/backend/models.py b/products/signals/backend/models.py
index 92ebaff3dbe6..3e9c7abefbc6 100644
--- a/products/signals/backend/models.py
+++ b/products/signals/backend/models.py
@@ -4265,6 +4265,8 @@ class UserActivitySummaryQueueState(TeamScopedRootMixin, UUIDModel):
pending_view_score = models.FloatField(default=0.0)
# Distinct days with an opened object or scene in the window, for the first summary of a view-only pair.
view_active_days = models.IntegerField(default=0)
+ # The MCP part of `pending_score`. The MCP feed computes it again from the buffer, so a record counts once.
+ pending_mcp_score = models.FloatField(default=0.0)
last_activity_at = models.DateTimeField(null=True, blank=True)
# The pair is due when this is empty or past. A copy of `UserActivitySummary.next_eligible_at`.
due_at = models.DateTimeField(null=True, blank=True)
diff --git a/products/signals/backend/test/test_activity_summary_tick.py b/products/signals/backend/test/test_activity_summary_tick.py
index 0e03597f9a9f..24af42a89c51 100644
--- a/products/signals/backend/test/test_activity_summary_tick.py
+++ b/products/signals/backend/test/test_activity_summary_tick.py
@@ -13,6 +13,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
from django.test import override_settings
import redis
+import fakeredis
from parameterized import parameterized
from temporalio import activity
from temporalio.client import Client, ScheduleState
@@ -31,6 +32,7 @@ from products.signals.backend.activity_summary import (
)
from products.signals.backend.activity_summary.computed import MAX_OWNED, MAX_WATCHED
from products.signals.backend.activity_summary.config import ActivitySummaryConfig, SourceWeights, parse_config
+from products.signals.backend.activity_summary.mcp_buffer import DIRTY_KEY, build_record, records_key
from products.signals.backend.activity_summary.prompt import (
MAX_HEADLINE_CHARS,
MAX_LABEL_CHARS,
@@ -47,6 +49,7 @@ from products.signals.backend.activity_summary.queue import (
daily_usage,
enrolled_team_ids,
enrollment,
+ feed_mcp_queue,
feed_queue,
is_team_enrolled_for_generation,
is_team_enrolled_for_read,
@@ -163,7 +166,6 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [
"max_org_share": 0.3,
"self_driving_organization_percentage": 12.5,
"deny_organization_ids": ["org-b", 4],
- "source_weights": {"new_views": 1, "repeat_view_days": 0.25},
"min_score": 4.5,
"view_update_interval_hours": 72,
"cold_start_min_active_days": 5,
@@ -173,6 +175,8 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [
"mcp_calls_per_day": 20,
"mcp_buffer_days": 14,
"mcp_render_enabled": True,
+ "mcp_queue_enabled": True,
+ "source_weights": {"new_views": 1, "repeat_view_days": 0.25, "mcp": 2},
},
ActivitySummaryConfig(
enabled=True,
@@ -189,7 +193,7 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [
max_org_share=0.3,
self_driving_organization_percentage=12.5,
deny_organization_ids=("org-b",),
- source_weights=SourceWeights(new_views=1.0, repeat_view_days=0.25),
+ source_weights=SourceWeights(new_views=1.0, repeat_view_days=0.25, mcp=2.0),
min_score=4.5,
view_update_interval_hours=72.0,
cold_start_min_active_days=5,
@@ -199,6 +203,7 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [
mcp_calls_per_day=20,
mcp_buffer_days=14,
mcp_render_enabled=True,
+ mcp_queue_enabled=True,
),
),
(
@@ -897,7 +902,7 @@ class TestActivitySummaryQueue(BaseTest):
assert [(pair.user_id, pair.trigger) for pair in selection.pairs] == [(self.user.id, trigger)][: bool(trigger)]
assert selection.due_by_trigger == {
- name: int(name == trigger) for name in ("activity", "views", "cold_start_views", "stale")
+ name: int(name == trigger) for name in ("activity", "views", "cold_start_views", "stale", "mcp")
}
def test_the_feed_counts_one_repeat_day_for_many_reopens_of_a_known_object_in_a_day(self) -> None:
@@ -956,6 +961,101 @@ class TestActivitySummaryQueue(BaseTest):
feed_queue(config, later)
assert self._select(seed=False, now=later) == [(self.team.id, self.user.id)]
+ def _mcp_calls(self, redis: fakeredis.FakeRedis, calls: list[tuple[str, str, float]], team: Team | None = None):
+ records = [
+ build_record(
+ team_id=(team or self.team).id,
+ user_id=self.user.id,
+ session_id=session_id,
+ route_name=route_name,
+ intent="Find why signups dropped",
+ at=NOW - datetime.timedelta(hours=hours_ago),
+ )
+ for session_id, route_name, hours_ago in calls
+ ]
+ for record in records:
+ redis.rpush(records_key(record.team_id, record.user_id, record.day), record.value)
+ redis.sadd(DIRTY_KEY, f"{record.team_id}:{record.user_id}")
+
+ @parameterized.expand(
+ [
+ ("three sessions", [("s1", "insights-list", 3), ("s2", "insights-list", 2), ("", "insights-list", 1)], 3),
+ (
+ "many calls in one session",
+ [("s1", "insights-list", 3), ("s1", "insights-detail", 2), ("s1", "query-create", 1)],
+ 1,
+ ),
+ (
+ "plumbing routes and calls before the watermark",
+ [
+ ("s1", "users-detail", 3),
+ ("s2", "project_llm_skills-list", 2),
+ ("s3", "insights-list", 30),
+ ("s4", "insights-list", 1),
+ ],
+ 1,
+ ),
+ ]
+ )
+ def test_the_mcp_feed_scores_sessions_and_counts_a_record_once(
+ self, _name: str, calls: list[tuple[str, str, float]], sessions: int
+ ) -> None:
+ watermark = NOW - datetime.timedelta(hours=24)
+ self._summary(self.user, generated_at=watermark, input_watermark=watermark)
+ redis = fakeredis.FakeRedis()
+ self._mcp_calls(redis, calls)
+ config = self._config()
+
+ feeds = [feed_mcp_queue(config, NOW, [self.team.id], redis_client=lambda: redis)]
+ redis.sadd(DIRTY_KEY, f"{self.team.id}:{self.user.id}")
+ feeds.append(feed_mcp_queue(config, NOW, [self.team.id], redis_client=lambda: redis))
+
+ assert [(feed.pairs, feed.sessions, feed.error) for feed in feeds] == [(1, sessions, False)] * 2
+ state = UserActivitySummaryQueueState.objects.for_team(self.team.id).get(user_id=self.user.id)
+ assert (state.pending_score, state.pending_mcp_score) == (float(sessions), float(sessions))
+ selection = select_pairs(config, NOW, 10)
+ assert [(pair.user_id, pair.trigger) for pair in selection.pairs] == [(self.user.id, "mcp")][: sessions >= 3]
+
+ def test_the_mcp_feed_ignores_teams_that_are_not_enrolled_and_survives_a_redis_error(self) -> None:
+ other_team = Team.objects.create(organization=self.organization)
+ redis = fakeredis.FakeRedis()
+ self._mcp_calls(redis, [("s1", "insights-list", 1)], team=other_team)
+
+ feed = feed_mcp_queue(self._config(), NOW, [self.team.id], redis_client=lambda: redis)
+ broken = feed_mcp_queue(
+ self._config(), NOW, [self.team.id], redis_client=MagicMock(side_effect=ConnectionError("unreachable"))
+ )
+
+ assert (feed.pairs, feed.ignored, feed.error) == (0, 1, False)
+ assert broken.error is True
+ assert not UserActivitySummaryQueueState.objects.for_team(other_team.id).exists()
+
+ @parameterized.expand([("queue off", False, True, 1), ("render off", True, False, 1), ("both on", True, True, 0)])
+ def test_the_tick_drains_the_mcp_dirty_set_only_when_both_switches_are_on(
+ self, _name: str, queue_enabled: bool, render_enabled: bool, members_left: int
+ ) -> None:
+ redis = fakeredis.FakeRedis()
+ self._mcp_calls(redis, [("s1", "insights-list", 1), ("s2", "insights-list", 1), ("s3", "insights-list", 1)])
+ config = self._config(mcp_queue_enabled=queue_enabled, mcp_render_enabled=render_enabled)
+
+ with (
+ override_settings(AI_GATEWAY_URL="https://ai-gateway.example/v1", AI_GATEWAY_API_KEY="phs_test"),
+ patch.object(tick, "read_config", return_value=config),
+ patch.object(
+ tick,
+ "feed_mcp_queue",
+ side_effect=lambda config, now, team_ids: feed_mcp_queue(
+ config, now, team_ids, redis_client=lambda: redis
+ ),
+ ),
+ patch("products.signals.backend.activity_summary.queue.list_user_task_times", return_value=[]),
+ ):
+ plan = plan_tick(None, NOW)
+
+ assert redis.scard(DIRTY_KEY) == members_left
+ assert plan.mcp_feed.sessions == 3 * (1 - members_left)
+ assert [pair.trigger for pair in plan.pairs] == ["mcp"][: 1 - members_left]
+
@parameterized.expand([("activity", 24), ("views", 168), ("cold_start_views", 168), (None, 24)])
def test_an_ok_update_emits_the_embedding_and_an_event_without_the_summary(
self, trigger: str | None, wait_hours: int