Private
Public Access
Ingestion did a get_or_create per entry. It now prefetches existing articles for the poll in one query, bulk-inserts new ones and bulk-updates changed ones (falling back to row-by-row only if a concurrent fetch wins a race), and dispatches rule evaluation in bounded chunks so a huge first fetch is several small tasks. /health/ stays a DB-only liveness check (upgrade.sh gates on it right after restart). New /health/ready/ also checks Redis and that poll_due_feeds ticked within five minutes — proving beat and a worker are both alive — and returns 503 with per-check detail otherwise. The sidebar unread-count cache and login throttle now degrade instead of erroring when Redis is unreachable: every authenticated page and every login would otherwise 500 during a cache outage. Found while verifying in a sandbox with no Redis. Also includes the dashboard's oldest-article metric (core/views.py). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
87 lines
3.3 KiB
Python
87 lines
3.3 KiB
Python
import logging
|
|
|
|
from django.core.cache import cache
|
|
from django.db.models import Count
|
|
|
|
from apps.core.cache_utils import SIDEBAR_UNREAD_CACHE_TTL_SECONDS, sidebar_unread_cache_key
|
|
|
|
from .models import SAVED_TAG_NAME, STARRED_TAG_NAME, Article, ArticleTag, UserArticleState
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def with_user_state(articles, user):
|
|
"""Annotates an iterable of Article instances with is_read/is_starred/
|
|
is_saved_for_later booleans for the given user, in two queries total
|
|
regardless of how many articles there are (no N+1). Starred/saved come
|
|
from ArticleTag against the pre-configured system tags, not a field on
|
|
UserArticleState — see Tag.is_system.
|
|
|
|
Accepts either a queryset or a plain list (search backends return
|
|
plain lists already ordered by relevance), materializing it either
|
|
way.
|
|
"""
|
|
articles = list(articles)
|
|
if not articles:
|
|
return articles
|
|
|
|
article_ids = [a.pk for a in articles]
|
|
states = {
|
|
state.article_id: state
|
|
for state in UserArticleState.objects.filter(user=user, article_id__in=article_ids)
|
|
}
|
|
|
|
starred_ids = set()
|
|
saved_ids = set()
|
|
tag_rows = ArticleTag.objects.filter(
|
|
user=user,
|
|
article_id__in=article_ids,
|
|
tag__is_system=True,
|
|
tag__name__in=[STARRED_TAG_NAME, SAVED_TAG_NAME],
|
|
).values_list("article_id", "tag__name")
|
|
for article_id, tag_name in tag_rows:
|
|
(starred_ids if tag_name == STARRED_TAG_NAME else saved_ids).add(article_id)
|
|
|
|
for article in articles:
|
|
state = states.get(article.pk)
|
|
article.is_read = state.is_read if state else False
|
|
article.is_starred = article.pk in starred_ids
|
|
article.is_saved_for_later = article.pk in saved_ids
|
|
return articles
|
|
|
|
|
|
def unread_counts_by_feed(user):
|
|
"""{feed_id: unread_count} for every feed the user subscribes to — used
|
|
by the sidebar's context processor, which runs on every authenticated
|
|
page render, so the underlying join/group-by over the user's whole
|
|
article corpus is cached for a short TTL rather than recomputed on
|
|
every single page view (C3). apps.core.cache_utils.
|
|
invalidate_sidebar_unread_cache is called wherever a request changes
|
|
the current user's own read state, so this is rarely visibly stale.
|
|
"""
|
|
cache_key = sidebar_unread_cache_key(user.pk)
|
|
# The cache is an optimization here, never a dependency: every
|
|
# authenticated page render goes through this, so a Redis outage must
|
|
# degrade to recomputing the count, not to a 500 on every page.
|
|
try:
|
|
counts = cache.get(cache_key)
|
|
except Exception:
|
|
logger.warning("Sidebar cache unavailable; computing unread counts directly")
|
|
counts = None
|
|
if counts is not None:
|
|
return counts
|
|
|
|
rows = (
|
|
Article.objects.filter(feed__subscriptions__user=user)
|
|
.exclude(user_states__user=user, user_states__is_read=True)
|
|
.exclude(user_states__user=user, user_states__is_hidden=True)
|
|
.values("feed_id")
|
|
.annotate(unread=Count("id"))
|
|
)
|
|
counts = {row["feed_id"]: row["unread"] for row in rows}
|
|
try:
|
|
cache.set(cache_key, counts, SIDEBAR_UNREAD_CACHE_TTL_SECONDS)
|
|
except Exception:
|
|
logger.warning("Sidebar cache unavailable; skipping cache write")
|
|
return counts
|