File size: 6,647 Bytes
b0074f5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
"""
请求日志路由模块 - 处理 /usage-logs/* 相关的HTTP请求
查询 usage_log 表:分页列表、聚合统计、清理、请求体详细日志读取
"""

import asyncio
import time
from typing import Optional

from fastapi import APIRouter, Depends, HTTPException
from fastapi.responses import JSONResponse
from sqlalchemy import text

from config import get_usage_log_enabled
from log import log
from src.request_body_log import clear_request_body_logs, read_request_body_log
from src.storage.database import UsageLog, get_database
from src.usage_log import clear_usage_logs, flush_usage_logs
from src.utils import verify_panel_token


# 创建路由器
router = APIRouter(prefix="/usage-logs", tags=["usage-logs"])


@router.get("/list")
async def get_usage_logs(
    token: str = Depends(verify_panel_token),
    offset: int = 0,
    limit: int = 50,
    start_timestamp: Optional[float] = None,
    end_timestamp: Optional[float] = None,
    model_name: str = "",
    credential_email: str = "",
    api_format: str = "",
    status: str = "all",
    is_stream: Optional[bool] = None,
    status_code: Optional[int] = None,
):
    """分页查询请求日志(新 -> 旧)"""
    try:
        if limit < 1 or limit > 1000:
            raise HTTPException(status_code=400, detail="limit 必须在 1-1000 之间")
        if offset < 0:
            raise HTTPException(status_code=400, detail="offset 不能为负数")

        database = await get_database()
        # 批量写队列中的待落库日志先刷盘,保证面板看到最新数据
        await flush_usage_logs()
        items, total = await database.query_usage_logs(
            offset=offset,
            limit=limit,
            start_timestamp=start_timestamp,
            end_timestamp=end_timestamp,
            model_name=model_name.strip(),
            credential_email=credential_email.strip(),
            api_format=api_format.strip(),
            status=status,
            is_stream=is_stream,
            status_code=status_code,
        )
        return JSONResponse(content={"items": items, "total": total})
    except HTTPException:
        raise
    except Exception as e:
        log.error(f"查询请求日志失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/stats")
async def get_usage_stats(
    token: str = Depends(verify_panel_token),
    start_timestamp: Optional[float] = None,
    end_timestamp: Optional[float] = None,
    model_name: str = "",
    credential_email: str = "",
    api_format: str = "",
):
    """聚合统计:请求数 / 成功失败 / token 汇总 / 平均耗时 / 每模型分布"""
    try:
        database = await get_database()
        # 批量写队列中的待落库日志先刷盘,保证统计完整
        await flush_usage_logs()
        stats = await database.usage_log_stats(
            start_timestamp=start_timestamp,
            end_timestamp=end_timestamp,
            model_name=model_name.strip(),
            credential_email=credential_email.strip(),
            api_format=api_format.strip(),
        )
        return JSONResponse(content=stats)
    except Exception as e:
        log.error(f"查询日志统计失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/clear")
async def clear_logs(
    token: str = Depends(verify_panel_token),
    days: int = 30,
):
    """清理 N 天前的日志,返回删除条数"""
    try:
        if days < 0:
            raise HTTPException(status_code=400, detail="天数不能为负数")
        if days == 0:
            # 0 = 删除所有(cutoff = now),同步清空请求体详细日志文件
            deleted = await clear_usage_logs(0)
            files_deleted = await asyncio.to_thread(clear_request_body_logs)
            return JSONResponse(content={
                "message": "已清理全部日志",
                "deleted": deleted,
                "files_deleted": files_deleted,
            })
        deleted = await clear_usage_logs(days)
        # 同步删除 N 天前的请求体详细日志文件
        files_deleted = await asyncio.to_thread(
            clear_request_body_logs, time.time() - days * 86400
        )
        return JSONResponse(content={
            "message": f"已清理 {days} 天前的日志",
            "deleted": deleted,
            "files_deleted": files_deleted,
        })
    except HTTPException:
        raise
    except Exception as e:
        log.error(f"清理日志失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/truncate")
async def truncate_logs(token: str = Depends(verify_panel_token)):
    """清空日志:直接 DROP 整张 usage_log 表并重建,不留任何残留"""
    try:
        database = await get_database()
        # 先刷掉批量写队列中的待落库日志
        await flush_usage_logs()
        # 先统计当前条数用于返回
        _, total = await database.query_usage_logs(offset=0, limit=1)

        async with database.session() as s:
            await s.execute(text(f"DROP TABLE IF EXISTS {UsageLog.__tablename__}"))

        # 重新建表(走统一的建表逻辑,保证结构最新)
        async with database._engine.begin() as conn:
            await conn.run_sync(database._create_tables)

        # 同步清空全部请求体详细日志文件
        files_deleted = await asyncio.to_thread(clear_request_body_logs)

        return JSONResponse(content={
            "message": "已清空全部日志(表已重建)",
            "deleted": total,
            "files_deleted": files_deleted,
        })
    except Exception as e:
        log.error(f"清空日志失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/request-body")
async def get_request_body_log(
    path: str,
    token: str = Depends(verify_panel_token),
):
    """按文件索引从磁盘读取请求体详细日志(JSON)"""
    try:
        data = await asyncio.to_thread(read_request_body_log, path)
        if data is None:
            raise HTTPException(status_code=404, detail="详细日志文件不存在或已清理")
        return JSONResponse(content=data)
    except HTTPException:
        raise
    except Exception as e:
        log.error(f"读取请求体详细日志失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.get("/config")
async def get_usage_log_config(token: str = Depends(verify_panel_token)):
    """获取日志开关配置"""
    return JSONResponse(content={
        "enabled": await get_usage_log_enabled(),
    })