489 lines
16 KiB
Python
489 lines
16 KiB
Python
"""斗鱼账号平台运行状态与覆盖率快照。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import UTC, date, datetime, timedelta
|
||
from typing import Any
|
||
|
||
from sqlalchemy import case, func
|
||
from sqlalchemy.orm import Session
|
||
|
||
from ..models import (
|
||
Account,
|
||
AccountCommodityState,
|
||
AccountEvent,
|
||
AccountSyncRun,
|
||
AccountSyncState,
|
||
AccountWorkItem,
|
||
LoginAttempt,
|
||
)
|
||
from .account_capability_service import AVAILABILITY_AVAILABLE, AVAILABILITY_LIMITED
|
||
from .account_supply_service import evaluate_supply_targets
|
||
|
||
TREND_DAYS = 7
|
||
|
||
|
||
def _day_key(value: Any) -> str:
|
||
if isinstance(value, datetime):
|
||
return value.date().isoformat()
|
||
if isinstance(value, date):
|
||
return value.isoformat()
|
||
return str(value or "")[:10]
|
||
|
||
|
||
def _trend_days(moment: datetime) -> list[str]:
|
||
today = moment.date()
|
||
return [
|
||
(today - timedelta(days=offset)).isoformat()
|
||
for offset in range(TREND_DAYS - 1, -1, -1)
|
||
]
|
||
|
||
|
||
def _rate(success: int, finished: int) -> float:
|
||
if finished <= 0:
|
||
return 0.0
|
||
return round(success * 100 / finished, 1)
|
||
|
||
|
||
def _platform_trends(db: Session, moment: datetime) -> dict[str, Any]:
|
||
days = _trend_days(moment)
|
||
start_at = datetime.combine(
|
||
date.fromisoformat(days[0]),
|
||
datetime.min.time(),
|
||
tzinfo=UTC,
|
||
)
|
||
query_days = {
|
||
day: {
|
||
"date": day,
|
||
"total": 0,
|
||
"success": 0,
|
||
"failed": 0,
|
||
"running": 0,
|
||
"success_rate": 0.0,
|
||
"duration_ms": 0,
|
||
"domains": {},
|
||
}
|
||
for day in days
|
||
}
|
||
sync_day = func.date(AccountSyncRun.started_at)
|
||
sync_rows = (
|
||
db.query(
|
||
sync_day,
|
||
AccountSyncRun.domain,
|
||
AccountSyncRun.status,
|
||
func.count(AccountSyncRun.id),
|
||
func.coalesce(func.sum(AccountSyncRun.duration_ms), 0),
|
||
)
|
||
.filter(AccountSyncRun.started_at >= start_at)
|
||
.group_by(sync_day, AccountSyncRun.domain, AccountSyncRun.status)
|
||
.all()
|
||
)
|
||
for raw_day, domain, status, count, duration_ms in sync_rows:
|
||
day = _day_key(raw_day)
|
||
bucket = query_days.get(day)
|
||
if bucket is None:
|
||
continue
|
||
count_value = int(count or 0)
|
||
domain_bucket = bucket["domains"].setdefault(
|
||
str(domain),
|
||
{"total": 0, "success": 0, "failed": 0, "running": 0},
|
||
)
|
||
bucket["total"] += count_value
|
||
bucket["duration_ms"] += int(duration_ms or 0)
|
||
domain_bucket["total"] += count_value
|
||
if status in {"success", "failed", "running"}:
|
||
bucket[str(status)] += count_value
|
||
domain_bucket[str(status)] += count_value
|
||
for bucket in query_days.values():
|
||
finished = bucket["success"] + bucket["failed"]
|
||
bucket["success_rate"] = _rate(bucket["success"], finished)
|
||
for domain_bucket in bucket["domains"].values():
|
||
domain_finished = domain_bucket["success"] + domain_bucket["failed"]
|
||
domain_bucket["success_rate"] = _rate(
|
||
domain_bucket["success"],
|
||
domain_finished,
|
||
)
|
||
|
||
login_days = {
|
||
day: {
|
||
"date": day,
|
||
"total": 0,
|
||
"success": 0,
|
||
"failed": 0,
|
||
"pending": 0,
|
||
"success_rate": 0.0,
|
||
"categories": {},
|
||
}
|
||
for day in days
|
||
}
|
||
login_day = LoginAttempt.quota_day
|
||
login_rows = (
|
||
db.query(
|
||
login_day,
|
||
LoginAttempt.category,
|
||
LoginAttempt.status,
|
||
func.count(LoginAttempt.id),
|
||
)
|
||
.filter(LoginAttempt.quota_day >= date.fromisoformat(days[0]))
|
||
.group_by(login_day, LoginAttempt.category, LoginAttempt.status)
|
||
.all()
|
||
)
|
||
for raw_day, category, status, count in login_rows:
|
||
day = _day_key(raw_day)
|
||
bucket = login_days.get(day)
|
||
if bucket is None:
|
||
continue
|
||
count_value = int(count or 0)
|
||
category_bucket = bucket["categories"].setdefault(
|
||
str(category),
|
||
{"total": 0, "success": 0, "failed": 0, "pending": 0},
|
||
)
|
||
bucket["total"] += count_value
|
||
category_bucket["total"] += count_value
|
||
if status in {"success", "failed", "pending"}:
|
||
bucket[str(status)] += count_value
|
||
category_bucket[str(status)] += count_value
|
||
for bucket in login_days.values():
|
||
finished = bucket["success"] + bucket["failed"]
|
||
bucket["success_rate"] = _rate(bucket["success"], finished)
|
||
for category_bucket in bucket["categories"].values():
|
||
category_finished = category_bucket["success"] + category_bucket["failed"]
|
||
category_bucket["success_rate"] = _rate(
|
||
category_bucket["success"],
|
||
category_finished,
|
||
)
|
||
|
||
lifecycle_days = {
|
||
day: {
|
||
"date": day,
|
||
"ck_invalid": 0,
|
||
"relogin_ok": 0,
|
||
"relogin_failed": 0,
|
||
}
|
||
for day in days
|
||
}
|
||
lifecycle_events = ("ck_invalid", "relogin_ok", "relogin_failed")
|
||
event_day = func.date(AccountEvent.occurred_at)
|
||
event_rows = (
|
||
db.query(
|
||
event_day,
|
||
AccountEvent.event_type,
|
||
func.count(AccountEvent.id),
|
||
)
|
||
.filter(
|
||
AccountEvent.occurred_at >= start_at,
|
||
AccountEvent.event_type.in_(lifecycle_events),
|
||
)
|
||
.group_by(event_day, AccountEvent.event_type)
|
||
.all()
|
||
)
|
||
for raw_day, event_type, count in event_rows:
|
||
bucket = lifecycle_days.get(_day_key(raw_day))
|
||
if bucket is not None and event_type in bucket:
|
||
bucket[str(event_type)] = int(count or 0)
|
||
|
||
return {
|
||
"days": TREND_DAYS,
|
||
"from": days[0],
|
||
"to": days[-1],
|
||
"query": list(query_days.values()),
|
||
"login": list(login_days.values()),
|
||
"lifecycle": list(lifecycle_days.values()),
|
||
}
|
||
|
||
|
||
def account_platform_status(
|
||
db: Session,
|
||
*,
|
||
now: datetime | None = None,
|
||
) -> dict[str, Any]:
|
||
moment = now or datetime.now(UTC)
|
||
in_24h = moment + timedelta(hours=24)
|
||
in_72h = moment + timedelta(hours=72)
|
||
|
||
account_counts = dict(
|
||
db.query(Account.ck_check_status, func.count(Account.id))
|
||
.group_by(Account.ck_check_status)
|
||
.all()
|
||
)
|
||
total_accounts = int(db.query(func.count(Account.id)).scalar() or 0)
|
||
cookie_accounts = int(
|
||
db.query(func.count(Account.id))
|
||
.filter(Account.cookie.isnot(None), Account.cookie != "")
|
||
.scalar()
|
||
or 0
|
||
)
|
||
|
||
expiring_24h = int(
|
||
db.query(func.count(Account.id))
|
||
.filter(
|
||
Account.ck_check_status == "valid",
|
||
Account.ck_expected_expires_at.isnot(None),
|
||
Account.ck_expected_expires_at > moment,
|
||
Account.ck_expected_expires_at <= in_24h,
|
||
)
|
||
.scalar()
|
||
or 0
|
||
)
|
||
expiring_72h = int(
|
||
db.query(func.count(Account.id))
|
||
.filter(
|
||
Account.ck_check_status == "valid",
|
||
Account.ck_expected_expires_at.isnot(None),
|
||
Account.ck_expected_expires_at > moment,
|
||
Account.ck_expected_expires_at <= in_72h,
|
||
)
|
||
.scalar()
|
||
or 0
|
||
)
|
||
predicted_expired = int(
|
||
db.query(func.count(Account.id))
|
||
.filter(
|
||
Account.ck_check_status == "valid",
|
||
Account.ck_expected_expires_at.isnot(None),
|
||
Account.ck_expected_expires_at <= moment,
|
||
)
|
||
.scalar()
|
||
or 0
|
||
)
|
||
|
||
queue_rows = (
|
||
db.query(
|
||
AccountWorkItem.work_type,
|
||
AccountWorkItem.status,
|
||
func.count(AccountWorkItem.id),
|
||
func.min(AccountWorkItem.due_at),
|
||
)
|
||
.group_by(AccountWorkItem.work_type, AccountWorkItem.status)
|
||
.all()
|
||
)
|
||
work_queue: dict[str, dict[str, Any]] = {}
|
||
for work_type, status, count, oldest_due in queue_rows:
|
||
bucket = work_queue.setdefault(str(work_type), {})
|
||
bucket[str(status)] = int(count or 0)
|
||
if status == "pending":
|
||
bucket["oldest_pending_due_at"] = oldest_due
|
||
|
||
sync_rows = (
|
||
db.query(
|
||
AccountSyncState.domain,
|
||
AccountSyncState.status,
|
||
func.count(AccountSyncState.id),
|
||
)
|
||
.group_by(AccountSyncState.domain, AccountSyncState.status)
|
||
.all()
|
||
)
|
||
sync_domains: dict[str, dict[str, Any]] = {}
|
||
for domain, status, count in sync_rows:
|
||
bucket = sync_domains.setdefault(str(domain), {})
|
||
bucket[str(status)] = int(count or 0)
|
||
fresh_rows = (
|
||
db.query(AccountSyncState.domain, func.count(AccountSyncState.id))
|
||
.filter(
|
||
AccountSyncState.status == "success",
|
||
AccountSyncState.valid_until.isnot(None),
|
||
AccountSyncState.valid_until > moment,
|
||
)
|
||
.group_by(AccountSyncState.domain)
|
||
.all()
|
||
)
|
||
for domain, count in fresh_rows:
|
||
sync_domains.setdefault(str(domain), {})["fresh"] = int(count or 0)
|
||
|
||
commodity_rows = (
|
||
db.query(
|
||
AccountCommodityState.availability,
|
||
func.count(AccountCommodityState.id),
|
||
func.sum(
|
||
case(
|
||
(
|
||
AccountCommodityState.valid_until > moment,
|
||
1,
|
||
),
|
||
else_=0,
|
||
)
|
||
),
|
||
)
|
||
.filter(AccountCommodityState.platform == "douyu")
|
||
.group_by(AccountCommodityState.availability)
|
||
.all()
|
||
)
|
||
commodities = {
|
||
str(availability): {
|
||
"total": int(total or 0),
|
||
"fresh": int(fresh or 0),
|
||
}
|
||
for availability, total, fresh in commodity_rows
|
||
}
|
||
fresh_available = int(commodities.get(AVAILABILITY_AVAILABLE, {}).get("fresh", 0))
|
||
fresh_limited = int(commodities.get(AVAILABILITY_LIMITED, {}).get("fresh", 0))
|
||
|
||
inventories = evaluate_supply_targets(db, now=moment)
|
||
supply_targets: list[dict[str, Any]] = []
|
||
alerts: list[dict[str, Any]] = []
|
||
for item in inventories:
|
||
shortage = max(
|
||
item.covered_shortage,
|
||
item.available_shortage,
|
||
item.allocatable_shortage,
|
||
)
|
||
supply_targets.append(
|
||
{
|
||
"target_id": item.target_id,
|
||
"scope": item.scope,
|
||
"commodity_id": item.commodity_id,
|
||
"value_class": item.value_class,
|
||
"target_covered": item.target_covered,
|
||
"target_available": item.target_available,
|
||
"target_allocatable": item.target_allocatable,
|
||
"safety_buffer": item.safety_buffer,
|
||
"covered": item.covered,
|
||
"available": item.available,
|
||
"allocatable": item.allocatable,
|
||
"covered_shortage": item.covered_shortage,
|
||
"available_shortage": item.available_shortage,
|
||
"allocatable_shortage": item.allocatable_shortage,
|
||
"needs_replenishment": item.needs_replenishment,
|
||
}
|
||
)
|
||
if not item.needs_replenishment:
|
||
continue
|
||
critical = (
|
||
(item.target_available > 0 and item.available <= 0)
|
||
or (item.target_allocatable > 0 and item.allocatable <= 0)
|
||
)
|
||
alerts.append(
|
||
{
|
||
"code": "supply_shortage",
|
||
"severity": "critical" if critical else "warning",
|
||
"scope": item.scope,
|
||
"commodity_id": item.commodity_id,
|
||
"value_class": item.value_class,
|
||
"shortage": shortage,
|
||
"message": (
|
||
f"{item.scope}/{item.commodity_id or 'all'}/"
|
||
f"{item.value_class} 库存短缺 {shortage}"
|
||
),
|
||
}
|
||
)
|
||
|
||
if not inventories:
|
||
alerts.append(
|
||
{
|
||
"code": "supply_targets_missing",
|
||
"severity": "warning",
|
||
"message": "尚未配置启用的账号供给目标",
|
||
}
|
||
)
|
||
if expiring_24h:
|
||
alerts.append(
|
||
{
|
||
"code": "ck_expiring_24h",
|
||
"severity": "warning",
|
||
"count": expiring_24h,
|
||
"message": f"未来 24 小时预计有 {expiring_24h} 个 CK 到期",
|
||
}
|
||
)
|
||
overdue_work = int(
|
||
db.query(func.count(AccountWorkItem.id))
|
||
.filter(
|
||
AccountWorkItem.status == "pending",
|
||
AccountWorkItem.due_at < moment,
|
||
)
|
||
.scalar()
|
||
or 0
|
||
)
|
||
if overdue_work:
|
||
alerts.append(
|
||
{
|
||
"code": "account_work_overdue",
|
||
"severity": "warning",
|
||
"count": overdue_work,
|
||
"message": f"账号内部工作队列有 {overdue_work} 项待处理已过期",
|
||
}
|
||
)
|
||
|
||
trends = _platform_trends(db, moment)
|
||
query_sample = sum(
|
||
int(row["success"]) + int(row["failed"])
|
||
for row in trends["query"]
|
||
)
|
||
query_success = sum(int(row["success"]) for row in trends["query"])
|
||
query_rate = _rate(query_success, query_sample)
|
||
if query_sample >= 20 and query_rate < 80:
|
||
alerts.append(
|
||
{
|
||
"code": "query_success_rate_low",
|
||
"severity": "critical" if query_rate < 50 else "warning",
|
||
"count": query_sample,
|
||
"message": (
|
||
f"近 {TREND_DAYS} 天查询成功率 {query_rate:.1f}%"
|
||
f"({query_sample} 次已完成查询)"
|
||
),
|
||
}
|
||
)
|
||
|
||
login_sample = sum(
|
||
int(row["success"]) + int(row["failed"])
|
||
for row in trends["login"]
|
||
)
|
||
login_success = sum(int(row["success"]) for row in trends["login"])
|
||
login_rate = _rate(login_success, login_sample)
|
||
if login_sample >= 10 and login_rate < 60:
|
||
alerts.append(
|
||
{
|
||
"code": "login_success_rate_low",
|
||
"severity": "critical" if login_rate < 40 else "warning",
|
||
"count": login_sample,
|
||
"message": (
|
||
f"近 {TREND_DAYS} 天登录成功率 {login_rate:.1f}%"
|
||
f"({login_sample} 次已完成尝试)"
|
||
),
|
||
}
|
||
)
|
||
|
||
relogin_ok = sum(int(row["relogin_ok"]) for row in trends["lifecycle"])
|
||
relogin_failed = sum(
|
||
int(row["relogin_failed"]) for row in trends["lifecycle"]
|
||
)
|
||
if relogin_failed >= 5 and relogin_failed > relogin_ok:
|
||
alerts.append(
|
||
{
|
||
"code": "relogin_failure_trend_high",
|
||
"severity": "warning",
|
||
"count": relogin_failed,
|
||
"message": (
|
||
f"近 {TREND_DAYS} 天重登失败 {relogin_failed} 次,"
|
||
f"成功 {relogin_ok} 次"
|
||
),
|
||
}
|
||
)
|
||
|
||
return {
|
||
"checked_at": moment,
|
||
"accounts": {
|
||
"total": total_accounts,
|
||
"with_cookie": cookie_accounts,
|
||
"ck_valid": int(account_counts.get("valid", 0)),
|
||
"ck_invalid": int(account_counts.get("invalid", 0)),
|
||
"ck_error": int(account_counts.get("error", 0)),
|
||
"ck_unchecked": int(account_counts.get("", 0) or 0),
|
||
"ck_expiring_24h": expiring_24h,
|
||
"ck_expiring_72h": expiring_72h,
|
||
"ck_predicted_expired": predicted_expired,
|
||
},
|
||
"work_queue": work_queue,
|
||
"sync_domains": sync_domains,
|
||
"commodities": {
|
||
"by_availability": commodities,
|
||
"fresh_available": fresh_available,
|
||
"fresh_limited": fresh_limited,
|
||
},
|
||
"supply_targets": supply_targets,
|
||
"alerts": alerts,
|
||
"trends": trends,
|
||
}
|
||
|
||
|
||
__all__ = ["account_platform_status"]
|