codex-lb 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

app/modules/request_logs/api.py

@@ -5,27 +5,81 @@ from datetime import datetime
 from fastapi import APIRouter, Depends, Query
 
 from app.dependencies import RequestLogsContext, get_request_logs_context
-from app.modules.request_logs.schemas import RequestLogsResponse
+from app.modules.request_logs.schemas import (
+    RequestLogFilterOptionsResponse,
+    RequestLogModelOption,
+    RequestLogsResponse,
+)
+from app.modules.request_logs.service import RequestLogModelOption as ServiceRequestLogModelOption
 
 router = APIRouter(prefix="/api/request-logs", tags=["dashboard"])
 
+_MODEL_OPTION_DELIMITER = ":::"
+
+
+def _parse_model_option(value: str) -> ServiceRequestLogModelOption | None:
+    raw = (value or "").strip()
+    if not raw:
+        return None
+    if _MODEL_OPTION_DELIMITER not in raw:
+        return ServiceRequestLogModelOption(model=raw, reasoning_effort=None)
+    model, effort = raw.split(_MODEL_OPTION_DELIMITER, 1)
+    model = model.strip()
+    effort = effort.strip()
+    if not model:
+        return None
+    return ServiceRequestLogModelOption(model=model, reasoning_effort=effort or None)
+
 
 @router.get("", response_model=RequestLogsResponse)
 async def list_request_logs(
-    limit: int = Query(50, ge=1, le=200),
-    account_id: str | None = Query(default=None, alias="accountId"),
-    status: str | None = Query(default=None),
-    model: str | None = Query(default=None),
+    limit: int = Query(50, ge=1, le=1000),
+    offset: int = Query(0, ge=0),
+    search: str | None = Query(default=None),
+    account_id: list[str] | None = Query(default=None, alias="accountId"),
+    status: list[str] | None = Query(default=None),
+    model: list[str] | None = Query(default=None),
+    reasoning_effort: list[str] | None = Query(default=None, alias="reasoningEffort"),
+    model_option: list[str] | None = Query(default=None, alias="modelOption"),
     since: datetime | None = Query(default=None),
     until: datetime | None = Query(default=None),
     context: RequestLogsContext = Depends(get_request_logs_context),
 ) -> RequestLogsResponse:
+    parsed_options: list[ServiceRequestLogModelOption] | None = None
+    if model_option:
+        parsed = [_parse_model_option(value) for value in model_option]
+        parsed_options = [value for value in parsed if value is not None] or None
     logs = await context.service.list_recent(
         limit=limit,
+        offset=offset,
+        search=search,
         since=since,
         until=until,
-        account_id=account_id,
-        model=model,
+        account_ids=account_id,
+        model_options=parsed_options,
+        models=model,
+        reasoning_efforts=reasoning_effort,
         status=status,
     )
     return RequestLogsResponse(requests=logs)
+
+
+@router.get("/options", response_model=RequestLogFilterOptionsResponse)
+async def list_request_log_filter_options(
+    status: list[str] | None = Query(default=None),
+    since: datetime | None = Query(default=None),
+    until: datetime | None = Query(default=None),
+    context: RequestLogsContext = Depends(get_request_logs_context),
+) -> RequestLogFilterOptionsResponse:
+    options = await context.service.list_filter_options(
+        status=status,
+        since=since,
+        until=until,
+    )
+    return RequestLogFilterOptionsResponse(
+        account_ids=options.account_ids,
+        model_options=[
+            RequestLogModelOption(model=option.model, reasoning_effort=option.reasoning_effort)
+            for option in options.model_options
+        ],
+    )

app/modules/request_logs/repository.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 from datetime import datetime
 
 import anyio
-from sqlalchemy import and_, select
+from sqlalchemy import String, and_, cast, or_, select
+from sqlalchemy import exc as sa_exc
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.utils.request_id import ensure_request_id
 from app.core.utils.time import utcnow
-from app.db.models import RequestLog
+from app.db.models import Account, RequestLog
 
 
 class RequestLogsRepository:
@@ -56,6 +57,8 @@ class RequestLogsRepository:
             await self._session.commit()
             await self._session.refresh(log)
             return log
+        except sa_exc.ResourceClosedError:
+            return log
         except BaseException:
             await _safe_rollback(self._session)
             raise
@@ -63,35 +66,147 @@ class RequestLogsRepository:
     async def list_recent(
         self,
         limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
         since: datetime | None = None,
         until: datetime | None = None,
-        account_id: str | None = None,
-        model: str | None = None,
-        status: str | None = None,
-        error_codes: list[str] | None = None,
+        account_ids: list[str] | None = None,
+        model_options: list[tuple[str, str | None]] | None = None,
+        models: list[str] | None = None,
+        reasoning_efforts: list[str] | None = None,
+        include_success: bool = True,
+        include_error_other: bool = True,
+        error_codes_in: list[str] | None = None,
+        error_codes_excluding: list[str] | None = None,
     ) -> list[RequestLog]:
         conditions = []
         if since is not None:
             conditions.append(RequestLog.requested_at >= since)
         if until is not None:
             conditions.append(RequestLog.requested_at <= until)
-        if account_id is not None:
-            conditions.append(RequestLog.account_id == account_id)
-        if model is not None:
-            conditions.append(RequestLog.model == model)
-        if status is not None:
-            conditions.append(RequestLog.status == status)
-        if error_codes:
-            conditions.append(RequestLog.error_code.in_(error_codes))
-
-        stmt = select(RequestLog).order_by(RequestLog.requested_at.desc())
+        if account_ids:
+            conditions.append(RequestLog.account_id.in_(account_ids))
+
+        if model_options:
+            pair_conditions = []
+            for model, effort in model_options:
+                base = (model or "").strip()
+                if not base:
+                    continue
+                if effort is None:
+                    pair_conditions.append(and_(RequestLog.model == base, RequestLog.reasoning_effort.is_(None)))
+                else:
+                    pair_conditions.append(and_(RequestLog.model == base, RequestLog.reasoning_effort == effort))
+            if pair_conditions:
+                conditions.append(or_(*pair_conditions))
+        else:
+            if models:
+                conditions.append(RequestLog.model.in_(models))
+            if reasoning_efforts:
+                conditions.append(RequestLog.reasoning_effort.in_(reasoning_efforts))
+
+        status_conditions = []
+        if include_success:
+            status_conditions.append(RequestLog.status == "success")
+        if error_codes_in:
+            status_conditions.append(and_(RequestLog.status == "error", RequestLog.error_code.in_(error_codes_in)))
+        if include_error_other:
+            error_clause = [RequestLog.status == "error"]
+            if error_codes_excluding:
+                error_clause.append(
+                    or_(
+                        RequestLog.error_code.is_(None),
+                        ~RequestLog.error_code.in_(error_codes_excluding),
+                    )
+                )
+            status_conditions.append(and_(*error_clause))
+        if status_conditions:
+            conditions.append(or_(*status_conditions))
+        if search:
+            search_pattern = f"%{search}%"
+            conditions.append(
+                or_(
+                    RequestLog.account_id.ilike(search_pattern),
+                    Account.email.ilike(search_pattern),
+                    RequestLog.request_id.ilike(search_pattern),
+                    RequestLog.model.ilike(search_pattern),
+                    RequestLog.reasoning_effort.ilike(search_pattern),
+                    RequestLog.status.ilike(search_pattern),
+                    RequestLog.error_code.ilike(search_pattern),
+                    RequestLog.error_message.ilike(search_pattern),
+                    cast(RequestLog.requested_at, String).ilike(search_pattern),
+                    cast(RequestLog.input_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.output_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.cached_input_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.reasoning_tokens, String).ilike(search_pattern),
+                    cast(RequestLog.latency_ms, String).ilike(search_pattern),
+                )
+            )
+
+        stmt = (
+            select(RequestLog)
+            .outerjoin(Account, Account.id == RequestLog.account_id)
+            .order_by(RequestLog.requested_at.desc())
+        )
         if conditions:
             stmt = stmt.where(and_(*conditions))
+        if offset:
+            stmt = stmt.offset(offset)
         if limit:
             stmt = stmt.limit(limit)
         result = await self._session.execute(stmt)
         return list(result.scalars().all())
 
+    async def list_filter_options(
+        self,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        include_success: bool = True,
+        include_error_other: bool = True,
+        error_codes_in: list[str] | None = None,
+        error_codes_excluding: list[str] | None = None,
+    ) -> tuple[list[str], list[tuple[str, str | None]]]:
+        conditions = []
+        if since is not None:
+            conditions.append(RequestLog.requested_at >= since)
+        if until is not None:
+            conditions.append(RequestLog.requested_at <= until)
+        status_conditions = []
+        if include_success:
+            status_conditions.append(RequestLog.status == "success")
+        if error_codes_in:
+            status_conditions.append(and_(RequestLog.status == "error", RequestLog.error_code.in_(error_codes_in)))
+        if include_error_other:
+            error_clause = [RequestLog.status == "error"]
+            if error_codes_excluding:
+                error_clause.append(
+                    or_(
+                        RequestLog.error_code.is_(None),
+                        ~RequestLog.error_code.in_(error_codes_excluding),
+                    )
+                )
+            status_conditions.append(and_(*error_clause))
+        if status_conditions:
+            conditions.append(or_(*status_conditions))
+
+        account_stmt = select(RequestLog.account_id).distinct().order_by(RequestLog.account_id.asc())
+        model_stmt = (
+            select(RequestLog.model, RequestLog.reasoning_effort)
+            .distinct()
+            .order_by(RequestLog.model.asc(), RequestLog.reasoning_effort.asc())
+        )
+        if conditions:
+            clause = and_(*conditions)
+            account_stmt = account_stmt.where(clause)
+            model_stmt = model_stmt.where(clause)
+
+        account_rows = await self._session.execute(account_stmt)
+        model_rows = await self._session.execute(model_stmt)
+
+        account_ids = [row[0] for row in account_rows.all() if row[0]]
+        model_options = [(row[0], row[1]) for row in model_rows.all() if row[0]]
+        return account_ids, model_options
+
 
 async def _safe_rollback(session: AsyncSession) -> None:
     if not session.in_transaction():

app/modules/request_logs/schemas.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import List
 
 from pydantic import Field
 
@@ -24,4 +23,14 @@ class RequestLogEntry(DashboardModel):
 
 
 class RequestLogsResponse(DashboardModel):
-    requests: List[RequestLogEntry] = Field(default_factory=list)
+    requests: list[RequestLogEntry] = Field(default_factory=list)
+
+
+class RequestLogModelOption(DashboardModel):
+    model: str
+    reasoning_effort: str | None = None
+
+
+class RequestLogFilterOptionsResponse(DashboardModel):
+    account_ids: list[str] = Field(default_factory=list)
+    model_options: list[RequestLogModelOption] = Field(default_factory=list)

app/modules/request_logs/service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from datetime import datetime
 from typing import cast
 
@@ -17,6 +18,26 @@ RATE_LIMIT_CODES = {"rate_limit_exceeded", "usage_limit_reached"}
 QUOTA_CODES = {"insufficient_quota", "usage_not_included", "quota_exceeded"}
 
 
+@dataclass(frozen=True, slots=True)
+class RequestLogModelOption:
+    model: str
+    reasoning_effort: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class RequestLogStatusFilter:
+    include_success: bool
+    include_error_other: bool
+    error_codes_in: list[str] | None
+    error_codes_excluding: list[str] | None
+
+
+@dataclass(frozen=True, slots=True)
+class RequestLogFilterOptions:
+    account_ids: list[str]
+    model_options: list[RequestLogModelOption]
+
+
 class RequestLogsService:
     def __init__(self, repo: RequestLogsRepository) -> None:
         self._repo = repo
@@ -24,38 +45,94 @@ class RequestLogsService:
     async def list_recent(
         self,
         limit: int = 50,
+        offset: int = 0,
+        search: str | None = None,
         since: datetime | None = None,
         until: datetime | None = None,
-        account_id: str | None = None,
-        model: str | None = None,
-        status: str | None = None,
+        account_ids: list[str] | None = None,
+        model_options: list[RequestLogModelOption] | None = None,
+        models: list[str] | None = None,
+        reasoning_efforts: list[str] | None = None,
+        status: list[str] | None = None,
     ) -> list[RequestLogEntry]:
-        status_filter, error_codes = _map_status_filter(status)
+        status_filter = _map_status_filter(status)
         logs = await self._repo.list_recent(
             limit=limit,
+            offset=offset,
+            search=search,
             since=since,
             until=until,
-            account_id=account_id,
-            model=model,
-            status=status_filter,
-            error_codes=error_codes,
+            account_ids=account_ids,
+            model_options=(
+                [(option.model, option.reasoning_effort) for option in model_options] if model_options else None
+            ),
+            models=models,
+            reasoning_efforts=reasoning_efforts,
+            include_success=status_filter.include_success,
+            include_error_other=status_filter.include_error_other,
+            error_codes_in=status_filter.error_codes_in,
+            error_codes_excluding=status_filter.error_codes_excluding,
         )
         return [_to_entry(log) for log in logs]
 
+    async def list_filter_options(
+        self,
+        since: datetime | None = None,
+        until: datetime | None = None,
+        status: list[str] | None = None,
+    ) -> RequestLogFilterOptions:
+        status_filter = _map_status_filter(status)
+        account_ids, model_options = await self._repo.list_filter_options(
+            since=since,
+            until=until,
+            include_success=status_filter.include_success,
+            include_error_other=status_filter.include_error_other,
+            error_codes_in=status_filter.error_codes_in,
+            error_codes_excluding=status_filter.error_codes_excluding,
+        )
+        return RequestLogFilterOptions(
+            account_ids=account_ids,
+            model_options=[
+                RequestLogModelOption(model=model, reasoning_effort=reasoning_effort)
+                for model, reasoning_effort in model_options
+            ],
+        )
+
 
-def _map_status_filter(status: str | None) -> tuple[str | None, list[str] | None]:
+def _map_status_filter(status: list[str] | None) -> RequestLogStatusFilter:
     if not status:
-        return None, None
-    normalized = status.lower()
-    if normalized == "ok":
-        return "success", None
-    if normalized == "rate_limit":
-        return "error", sorted(RATE_LIMIT_CODES)
-    if normalized == "quota":
-        return "error", sorted(QUOTA_CODES)
-    if normalized == "error":
-        return "error", None
-    return status, None
+        return RequestLogStatusFilter(
+            include_success=True,
+            include_error_other=True,
+            error_codes_in=None,
+            error_codes_excluding=None,
+        )
+    normalized = {value.lower() for value in status if value}
+    if not normalized or "all" in normalized:
+        return RequestLogStatusFilter(
+            include_success=True,
+            include_error_other=True,
+            error_codes_in=None,
+            error_codes_excluding=None,
+        )
+
+    include_success = "ok" in normalized
+    include_rate_limit = "rate_limit" in normalized
+    include_quota = "quota" in normalized
+    include_error_other = "error" in normalized
+
+    error_codes_in: set[str] = set()
+    if include_rate_limit:
+        error_codes_in |= RATE_LIMIT_CODES
+    if include_quota:
+        error_codes_in |= QUOTA_CODES
+
+    return RequestLogStatusFilter(
+        include_success=include_success,
+        include_error_other=include_error_other,
+        error_codes_in=sorted(error_codes_in) if error_codes_in else None,
+        error_codes_excluding=sorted(RATE_LIMIT_CODES | QUOTA_CODES) if include_error_other else None,
+    )
 
 
 def _log_status(log: RequestLog) -> str:

app/modules/usage/service.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
+import asyncio
+import weakref
+from collections.abc import Callable
+from dataclasses import dataclass
 from datetime import timedelta
-from typing import cast
+from typing import AsyncContextManager, ClassVar, cast
 
 from app.core import usage as usage_core
 from app.core.usage.logs import (
@@ -37,17 +41,30 @@ from app.modules.usage.schemas import (
 from app.modules.usage.updater import UsageUpdater
 
 
+@dataclass(slots=True)
+class _RefreshState:
+    lock: asyncio.Lock
+    task: asyncio.Task[None] | None = None
+
+
 class UsageService:
+    _refresh_states: ClassVar[weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, _RefreshState]] = (
+        weakref.WeakKeyDictionary()
+    )
+
     def __init__(
         self,
         usage_repo: UsageRepository,
         logs_repo: RequestLogsRepository,
         accounts_repo: AccountsRepository,
+        refresh_repo_factory: Callable[[], AsyncContextManager[tuple[UsageRepository, AccountsRepository]]]
+        | None = None,
     ) -> None:
         self._usage_repo = usage_repo
         self._logs_repo = logs_repo
         self._accounts_repo = accounts_repo
         self._usage_updater = UsageUpdater(usage_repo, accounts_repo)
+        self._refresh_repo_factory = refresh_repo_factory
 
     async def get_usage_summary(self) -> UsageSummaryResponse:
         await self._refresh_usage()
@@ -114,9 +131,53 @@ class UsageService:
         )
 
     async def _refresh_usage(self) -> None:
-        accounts = await self._accounts_repo.list_accounts()
-        latest_usage = await self._usage_repo.latest_by_account(window="primary")
-        await self._usage_updater.refresh_accounts(accounts, latest_usage)
+        state = self._refresh_state()
+        task = state.task
+        if task and not task.done():
+            await asyncio.shield(task)
+            return
+
+        created = False
+        async with state.lock:
+            task = state.task
+            if not task or task.done():
+                task = asyncio.create_task(self._refresh_usage_once())
+                state.task = task
+                created = True
+
+        if task is None:
+            return
+
+        try:
+            if created:
+                await asyncio.shield(task)
+            else:
+                await asyncio.shield(task)
+        finally:
+            if task.done() and state.task is task:
+                state.task = None
+
+    async def _refresh_usage_once(self) -> None:
+        if self._refresh_repo_factory is None:
+            accounts = await self._accounts_repo.list_accounts()
+            latest_usage = await self._usage_repo.latest_by_account(window="primary")
+            await self._usage_updater.refresh_accounts(accounts, latest_usage)
+            return
+
+        async with self._refresh_repo_factory() as (usage_repo, accounts_repo):
+            latest_usage = await usage_repo.latest_by_account(window="primary")
+            accounts = await accounts_repo.list_accounts()
+            updater = UsageUpdater(usage_repo, accounts_repo)
+            await updater.refresh_accounts(accounts, latest_usage)
+
+    @classmethod
+    def _refresh_state(cls) -> _RefreshState:
+        loop = asyncio.get_running_loop()
+        state = cls._refresh_states.get(loop)
+        if state is None:
+            state = _RefreshState(lock=asyncio.Lock())
+            cls._refresh_states[loop] = state
+        return state
 
     async def _latest_usage_rows(self, window: str) -> list[UsageWindowRow]:
         latest = await self._usage_repo.latest_by_account(window=window)