新增后端日志，且更改了平台名字

backend/app/api/v1/endpoints/data_process.py

@@ -35,6 +35,7 @@ from fastapi.responses import StreamingResponse
 from psycopg.rows import dict_row
 
 from app.core.auth import filter_accessible_resource_ids, get_current_user, is_admin
+from app.core.logging import get_structured_logger
 from app.modules.data_process.algorithms import (
     ParsedText,
     canonical_record_json,
@@ -103,6 +104,7 @@ from app.schemas.data_process import (
 
 router = APIRouter(prefix="/data-process")
 logger = logging.getLogger(__name__)
+biz_logger = get_structured_logger("app.biz.data_process")
 MAX_SOURCE_FILE_BYTES = 200 * 1024 * 1024
 MAX_SOURCE_FILE_COUNT = 20
 MAX_SOURCE_BATCH_BYTES = 500 * 1024 * 1024
@@ -854,6 +856,7 @@ def create_task(
 ) -> dict[str, Any]:
     with api_errors():
         task = store.create_task(payload.model_dump(mode="json"))
+        biz_logger.info("data-process:create success", taskId=task["id"], processType=task.get("process_type", ""))
         return ok(task, "data process task created")
 
 
@@ -879,10 +882,9 @@ def update_task(
     store: DataProcessStore = Depends(get_data_process_store),
 ) -> dict[str, Any]:
     with api_errors():
-        return ok(
-            store.update_task(task_id, payload.model_dump(exclude_unset=True, mode="json")),
-            "data process task updated",
-        )
+        result = store.update_task(task_id, payload.model_dump(exclude_unset=True, mode="json"))
+        biz_logger.info("data-process:update success", taskId=task_id)
+        return ok(result, "data process task updated")
 
 
 @router.put("/{task_id}/workflow-step")
@@ -1047,6 +1049,7 @@ def delete_task(
 ) -> dict[str, Any]:
     with api_errors():
         store.delete_task(task_id)
+        biz_logger.info("data-process:delete success", taskId=task_id)
         return ok({"deleted": task_id}, "data process task deleted")
 
 
@@ -1359,13 +1362,12 @@ def delete_source_file(
                 expected_source_file_id=file_id,
             )
         except Exception:
-            # 数据库软删除已经提交，不能再向客户端返回可重试的失败；保留逻辑引用，
-            # 由后续存储清理任务重试物理删除。
             cleanup_pending = True
             logger.exception(
                 "failed to remove data process source object after soft deletion",
                 extra={"task_id": task_id, "source_file_id": file_id},
             )
+        biz_logger.info("data-process:delete-source-file success", taskId=task_id, fileId=file_id, storageCleanupPending=cleanup_pending)
         return ok(
             {"deleted": file_id, "storage_cleanup_pending": cleanup_pending},
             "source file removed",
@@ -1964,6 +1966,7 @@ def stop(
 ) -> dict[str, Any]:
     with api_errors():
         store.stop_task(task_id)
+        biz_logger.info("data-process:stop success", taskId=task_id)
         return ok(store.progress(task_id), "data process task stopped")
 
 
@@ -2005,7 +2008,9 @@ def confirm_results(
     store: DataProcessStore = Depends(get_data_process_store),
 ) -> dict[str, Any]:
     with api_errors():
-        return ok(store.confirm_results(task_id), "data process results confirmed")
+        result = store.confirm_results(task_id)
+        biz_logger.info("data-process:confirm-results success", taskId=task_id)
+        return ok(result, "data process results confirmed")
 
 
 @router.put("/{task_id}/results/{result_id}")
@@ -2499,5 +2504,6 @@ def publish(
 ) -> dict[str, Any]:
     with api_errors():
         result = store.publish(task_id, payload.model_dump(mode="json"))
+        biz_logger.info("data-process:publish success", taskId=task_id, datasetId=result.get("dataset_id", ""))
         message = "dataset published" if result["created"] else "dataset already published"
         return ok(result, message)

backend/app/api/v1/endpoints/platform.py

@@ -471,6 +471,7 @@ async def _fine_tune_preflight_with_job_payload(
 
 
 @router.post("/login")
+@op_log(module=OpModule.SYSTEM, action=OpAction.LOGIN, target_type="user", target_name_param="username")
 async def login(payload: dict[str, Any] = Body(...), request: Request = None) -> dict[str, Any]:
     store = get_platform_store()
     ip = request.client.host if request and request.client else "unknown"
@@ -488,6 +489,7 @@ async def login(payload: dict[str, Any] = Body(...), request: Request = None) ->
 
 
 @router.post("/logout")
+@op_log(module=OpModule.SYSTEM, action=OpAction.LOGOUT, target_type="user")
 async def logout(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     store = get_platform_store()
     session_id = payload.get("session_id", "")
@@ -717,11 +719,13 @@ async def users() -> dict[str, Any]:
 
 
 @router.post("/users")
+@op_log(module=OpModule.SYSTEM, action=OpAction.CREATE, target_type="user", target_name_param="username")
 async def create_user(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     return ok(get_platform_store().create_user(payload))
 
 
 @router.put("/users/{user_id}")
+@op_log(module=OpModule.SYSTEM, action=OpAction.UPDATE, target_type="user", target_name_param="user_id")
 async def update_user(user_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     try:
         return ok(get_platform_store().update_user(user_id, payload))
@@ -730,6 +734,7 @@ async def update_user(user_id: str, payload: dict[str, Any] = Body(...)) -> dict
 
 
 @router.delete("/users/{user_id}")
+@op_log(module=OpModule.SYSTEM, action=OpAction.DELETE, target_type="user", target_name_param="user_id")
 async def delete_user(user_id: str, current_username: str | None = Query(default=None)) -> dict[str, Any]:
     try:
         get_platform_store().delete_user(user_id)
@@ -741,6 +746,7 @@ async def delete_user(user_id: str, current_username: str | None = Query(default
 
 
 @router.post("/users/{user_id}/reset-password")
+@op_log(module=OpModule.SYSTEM, action=OpAction.UPDATE, target_type="user_password", target_name_param="user_id")
 async def reset_user_password(
     user_id: str,
     payload: dict[str, Any] = Body(default={}),
@@ -756,6 +762,7 @@ async def reset_user_password(
 
 
 @router.post("/users/me/password")
+@op_log(module=OpModule.SYSTEM, action=OpAction.UPDATE, target_type="user_password")
 async def change_my_password(
     payload: dict[str, Any] = Body(...),
     current_user: dict = Depends(get_current_user),
@@ -819,6 +826,7 @@ async def trained_models(current_user: dict = Depends(get_current_user)) -> dict
 
 
 @router.delete("/model-manage/trained-models/{model_id}")
+@op_log(module=OpModule.MODEL_MANAGE, action=OpAction.DELETE, target_type="trained_model", target_name_param="model_id")
 async def delete_trained_model(model_id: str, type: str = Query(default="merged"), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     if not has_resource_access("trained_model", model_id, current_user, "delete"):
         raise fail(403, "no permission to delete this trained model")
@@ -922,6 +930,7 @@ async def test_online_model(payload: dict[str, Any] = Body(...)) -> dict[str, An
 
 
 @router.post("/model-manage")
+@op_log(module=OpModule.MODEL_MANAGE, action=OpAction.CREATE, target_type="model", target_name_param="name")
 @audit_log(
     action=AuditActions.CREATE_MODEL,
     target_type="model",
@@ -950,6 +959,7 @@ async def model_detail(model_id: str, current_user: dict = Depends(get_current_u
 
 
 @router.put("/model-manage/{model_id}")
+@op_log(module=OpModule.MODEL_MANAGE, action=OpAction.UPDATE, target_type="model", target_name_param="model_id")
 @audit_log(
     action=AuditActions.UPDATE_MODEL,
     target_type="model",
@@ -966,6 +976,7 @@ async def update_model(model_id: str, payload: dict[str, Any] = Body(...), curre
 
 
 @router.put("/model-manage/{model_id}/purpose")
+@op_log(module=OpModule.MODEL_MANAGE, action=OpAction.UPDATE, target_type="model_purpose", target_name_param="model_id")
 async def update_model_purpose(model_id: str, payload: dict[str, Any] = Body(...), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     # 基座模型（配置模型）只有管理员可以修改用途
     if not is_admin(current_user):
@@ -977,6 +988,7 @@ async def update_model_purpose(model_id: str, payload: dict[str, Any] = Body(...
 
 
 @router.delete("/model-manage/{model_id}")
+@op_log(module=OpModule.MODEL_MANAGE, action=OpAction.DELETE, target_type="model", target_name_param="model_id")
 async def delete_model(model_id: str, current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     # 基座模型（配置模型）只有管理员可以删除
     if not is_admin(current_user):
@@ -1100,6 +1112,7 @@ async def dataset_version_content(file_id: str, version_id: str) -> dict[str, An
 
 
 @router.post("/dataset-manage/versions/{file_id}")
+@op_log(module=OpModule.DATASET, action=OpAction.CREATE, target_type="dataset_version", target_name_param="file_id")
 async def create_dataset_version(file_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     try:
         return ok(get_platform_store().create_file_version(file_id, payload))
@@ -1116,6 +1129,7 @@ async def activate_dataset_version(file_id: str, payload: dict[str, Any] = Body(
 
 
 @router.delete("/dataset-manage/versions/{file_id}/{version_id}")
+@op_log(module=OpModule.DATASET, action=OpAction.DELETE, target_type="dataset_version", target_name_param="version_id")
 async def delete_dataset_version(file_id: str, version_id: str) -> dict[str, Any]:
     try:
         return ok(get_platform_store().delete_file_version(file_id, version_id))
@@ -1281,6 +1295,7 @@ async def _sync_training_dataset_to_compute_node(
 
 
 @router.post("/dataset-manage/upload/{dataset_id}")
+@op_log(module=OpModule.DATASET, action=OpAction.UPLOAD, target_type="dataset_file", target_name_param="dataset_id")
 async def upload_dataset_files(
     dataset_id: str,
     files: list[UploadFile] = File(default=[]),
@@ -1403,6 +1418,7 @@ async def dataset_list(current_user: dict = Depends(get_current_user)) -> dict[s
 
 
 @router.post("/dataset-manage")
+@op_log(module=OpModule.DATASET, action=OpAction.CREATE, target_type="dataset", target_name_param="name")
 @audit_log(
     action=AuditActions.CREATE_DATASET,
     target_type="dataset",
@@ -1430,6 +1446,7 @@ async def dataset_detail(dataset_id: str, current_user: dict = Depends(get_curre
 
 
 @router.put("/dataset-manage/{dataset_id}")
+@op_log(module=OpModule.DATASET, action=OpAction.UPDATE, target_type="dataset", target_name_param="dataset_id")
 @audit_log(
     action=AuditActions.UPDATE_DATASET,
     target_type="dataset",
@@ -1491,6 +1508,7 @@ async def fine_tune_list(current_user: dict = Depends(get_current_user)) -> dict
 
 
 @router.post("/fine-tune")
+@op_log(module=OpModule.FINE_TUNE, action=OpAction.CREATE, target_type="fine_tune", target_name_param="name")
 @audit_log(
     action=AuditActions.CREATE_FINE_TUNE,
     target_type="fine_tune",
@@ -1662,6 +1680,7 @@ async def fine_tune_diagnostics(task_id: str) -> dict[str, Any]:
 
 
 @router.put("/fine-tune/{task_id}")
+@op_log(module=OpModule.FINE_TUNE, action=OpAction.UPDATE, target_type="fine_tune", target_name_param="task_id")
 async def update_fine_tune(task_id: str, payload: dict[str, Any] = Body(...), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     if not has_resource_access("fine-tune", task_id, current_user, "write"):
         raise fail(403, "no permission to update this task")
@@ -1696,6 +1715,7 @@ async def stop_fine_tune_alt(task_id: str, current_user: dict = Depends(get_curr
 
 
 @router.post("/fine-tune/{task_id}/retry")
+@op_log(module=OpModule.FINE_TUNE, action=OpAction.RETRY, target_type="fine_tune", target_name_param="task_id")
 async def retry_fine_tune(task_id: str, payload: dict[str, Any] | None = Body(default=None), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     store = get_platform_store()
     payload = payload or {}
@@ -1964,6 +1984,7 @@ async def model_eval_start(payload: dict[str, Any] = Body(...), current_user: di
 
 
 @router.delete("/model-eval/{task_id}")
+@op_log(module=OpModule.MODEL_EVAL, action=OpAction.DELETE, target_type="eval_task", target_name_param="task_id")
 async def model_eval_delete(task_id: str, current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     if not has_resource_access("eval", task_id, current_user, "delete"):
         raise fail(403, "no permission to delete this eval task")
@@ -1980,6 +2001,7 @@ async def dimension_list() -> dict[str, Any]:
 
 
 @router.post("/dimension")
+@op_log(module=OpModule.MODEL_EVAL, action=OpAction.CREATE, target_type="dimension", target_name_param="name")
 async def dimension_create(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     return ok(get_platform_store().create_dimension(payload))
 
@@ -1993,6 +2015,7 @@ async def dimension_detail(dimension_id: str) -> dict[str, Any]:
 
 
 @router.put("/dimension/{dimension_id}")
+@op_log(module=OpModule.MODEL_EVAL, action=OpAction.UPDATE, target_type="dimension", target_name_param="dimension_id")
 async def dimension_update(dimension_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
     try:
         return ok(get_platform_store().update_dimension(dimension_id, payload))
@@ -2001,6 +2024,7 @@ async def dimension_update(dimension_id: str, payload: dict[str, Any] = Body(...
 
 
 @router.delete("/dimension/{dimension_id}")
+@op_log(module=OpModule.MODEL_EVAL, action=OpAction.DELETE, target_type="dimension", target_name_param="dimension_id")
 async def dimension_delete(dimension_id: str) -> dict[str, Any]:
     get_platform_store().delete_dimension(dimension_id)
     return ok({"deleted": dimension_id})
@@ -2019,6 +2043,7 @@ async def model_compare_list(current_user: dict = Depends(get_current_user)) ->
 
 
 @router.post("/model-compare")
+@op_log(module=OpModule.INFERENCE, action=OpAction.CREATE, target_type="compare_task", target_name_param="name")
 async def model_compare_create(payload: dict[str, Any] = Body(...), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     payload.setdefault("created_by", current_user.get("id"))
     model_ids = payload.get("model_ids") or payload.get("models") or []
@@ -2574,6 +2599,7 @@ async def compute_node_detail(node_id: str, current_user: dict = Depends(get_cur
 
 
 @router.post("/compute/nodes")
+@op_log(module=OpModule.COMPUTE, action=OpAction.CREATE, target_type="compute_node", target_name_param="name")
 async def create_compute_node(payload: dict[str, Any] = Body(...), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     if not is_admin(current_user):
         raise fail(403, "admin permission required")
@@ -2586,6 +2612,7 @@ async def create_compute_node(payload: dict[str, Any] = Body(...), current_user:
 
 
 @router.put("/compute/nodes/{node_id}")
+@op_log(module=OpModule.COMPUTE, action=OpAction.UPDATE, target_type="compute_node", target_name_param="node_id")
 async def update_compute_node(node_id: str, payload: dict[str, Any] = Body(...), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     if not is_admin(current_user):
         raise fail(403, "admin permission required")
@@ -2598,6 +2625,7 @@ async def update_compute_node(node_id: str, payload: dict[str, Any] = Body(...),
 
 
 @router.delete("/compute/nodes/{node_id}")
+@op_log(module=OpModule.COMPUTE, action=OpAction.DELETE, target_type="compute_node", target_name_param="node_id")
 async def delete_compute_node(node_id: str, current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     if not is_admin(current_user):
         raise fail(403, "admin permission required")
@@ -2904,6 +2932,7 @@ async def compute_job_detail(job_id: str) -> dict[str, Any]:
 
 
 @router.post("/compute/jobs/{job_id}/stop")
+@op_log(module=OpModule.COMPUTE, action=OpAction.STOP, target_type="compute_job", target_name_param="job_id")
 async def compute_job_stop(job_id: str, current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     task = _task_for_compute_job(job_id)
     if task and not has_resource_access("fine-tune", task["id"], current_user, "write"):
@@ -2942,6 +2971,7 @@ async def compute_job_logs(
 
 
 @router.post("/compute/jobs/{job_id}/retry")
+@op_log(module=OpModule.COMPUTE, action=OpAction.RETRY, target_type="compute_job", target_name_param="job_id")
 async def compute_job_retry(job_id: str, payload: dict[str, Any] | None = Body(default=None), current_user: dict = Depends(get_current_user)) -> dict[str, Any]:
     store = get_platform_store()
     payload = payload or {}

backend/app/core/config.py

@@ -50,7 +50,7 @@ def docs_kwargs(enabled: bool) -> dict[str, Any]:
 
 @dataclass(frozen=True)
 class Settings:
-    app_name: str = os.getenv("APP_NAME", "YG Fine-Tune Platform API")
+    app_name: str = os.getenv("APP_NAME", "YG Zhilian API")
     app_env: str = os.getenv("APP_ENV", "local")
     route_prefix: str = os.getenv("MODELTF_ROUTE_PREFIX", "/modelTF")
     app_mode: str = os.getenv("APP_MODE", "local")

backend/app/core/logging.py

@@ -1,162 +1,255 @@
 from __future__ import annotations
 
-from contextvars import ContextVar
-from datetime import date, datetime, timedelta
 import json
 import logging
+import re
+import socket
 import sys
+import time
+from contextvars import ContextVar
+from datetime import date, datetime, timedelta
 from logging import Handler, LogRecord
 from pathlib import Path
-import re
-import time
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 from uuid import uuid4
 
 from fastapi import FastAPI, Request
 
 from app.core.config import Settings, get_settings
 
+# ==================== 链路追踪 ContextVar ====================
+
 request_id_var: ContextVar[str] = ContextVar("request_id", default="-")
+user_id_var: ContextVar[str] = ContextVar("user_id", default="")
+client_ip_var: ContextVar[str] = ContextVar("client_ip", default="")
 
-# ==================== 敏感数据脱敏规则 ====================
+# ==================== 敏感数据脱敏 ====================
 
-SENSITIVE_PATTERNS: dict[str, Callable | str] = {
-    "token": "***",
-    "password": "***",
-    "access_token": "***",
-    "refresh_token": "***",
-    "secret_key": "***",
-    "authorization": "***",
-    "bearer": "***",
-    "api_key": "***",
-    "private_key": "***",
+SENSITIVE_KEYS: set[str] = {
+    "password", "token", "access_token", "refresh_token",
+    "secret_key", "authorization", "bearer", "api_key",
+    "private_key", "secret", "cookie",
 }
 
-def mask_value(key: str, value: Any) -> str:
-    """对单个值进行脱敏处理"""
+FULL_MASK_KEYS: set[str] = {
+    "password", "token", "access_token", "refresh_token",
+    "secret_key", "authorization", "bearer", "api_key",
+    "private_key", "secret", "cookie",
+}
+
+
+def _mask_phone(value: str) -> str:
+    """手机号脱敏：138****5678"""
+    if len(value) >= 11:
+        return value[:3] + "****" + value[-4:]
+    return value
+
+
+def _mask_id_card(value: str) -> str:
+    """身份证号脱敏：110***********1234"""
+    if len(value) >= 18:
+        return value[:3] + "***********" + value[-4:]
+    return value
+
+
+def mask_value(key: str, value: Any) -> Any:
+    """对单个值进行脱敏处理。"""
     if value is None:
         return ""
+    key_lower = key.lower()
+    if key_lower in FULL_MASK_KEYS:
+        return "***"
     str_val = str(value)
-    
-    handler = SENSITIVE_PATTERNS.get(key)
-    if callable(handler):
-        return handler(str_val)
-    elif isinstance(handler, str):
-        # 支持正则替换模式，如 r"1\d{3}\d{4}"
-        try:
-            return re.sub(handler, "***", str_val)
-        except re.error:
-            return "***"
-    return handler
+    # 手机号模式（11位数字，1开头）
+    if re.match(r"^1[3-9]\d{9}$", str_val):
+        return _mask_phone(str_val)
+    # 身份证模式（18位）
+    if re.match(r"^\d{17}[\dXx]$", str_val):
+        return _mask_id_card(str_val)
+    return value
 
 
 def mask_sensitive_dict(data: dict) -> dict:
-    """递归脱敏字典中的敏感字段"""
+    """递归脱敏字典中的敏感字段。"""
     if not data or not isinstance(data, dict):
         return data
-    
-    result = {}
+    result: dict[str, Any] = {}
     for key, value in data.items():
-        result[key] = mask_value(key, value)
+        if isinstance(value, dict):
+            result[key] = mask_sensitive_dict(value)
+        elif isinstance(value, list):
+            result[key] = [
+                mask_sensitive_dict(item) if isinstance(item, dict) else item
+                for item in value
+            ]
+        else:
+            result[key] = mask_value(key, value)
     return result
 
 
 def mask_sensitive_string(text: str) -> str:
-    """从文本中脱敏常见敏感信息"""
+    """从文本中脱敏常见敏感信息。"""
     if not text:
         return text
-    
-    patterns = [
-        (r'Bearer\s+[A-Za-z0-9\-._]+', '***'),
-        (r'token\s*[:=]\s*', '***'),
-        (r'password\s*[:=]\s*', '***'),
-        (r'secret[_-]?key\s*[:=]', '***'),
-        (r'api[-_]?key\s*[:=]', '***'),
-        (r'private[_-]?key\s*[:=]', '***'),
-        (r'\d{11}', r'\d{3}\*\d{4}'),  # 手机号/身份证
-        (r'1[3-9]\d{9}', r'1\*{3}\*{4}'),  # 手机号
+    patterns: list[tuple[str, str]] = [
+        (r"Bearer\s+[A-Za-z0-9\-._]+", "Bearer ***"),
+        (r"(?i)token\s*[:=]\s*\S+", "token=***"),
+        (r"(?i)password\s*[:=]\s*\S+", "password=***"),
+        (r"(?i)secret[_-]?key\s*[:=]\s*\S+", "secret_key=***"),
+        (r"(?i)api[-_]?key\s*[:=]\s*\S+", "api_key=***"),
+        (r"(?i)private[_-]?key\s*[:=]\s*\S+", "private_key=***"),
+        (r"(?i)authorization\s*[:=]\s*\S+", "authorization=***"),
     ]
-    
     for pattern, replacement in patterns:
-        try:
-            text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
-        except re.error:
-            pass
+        text = re.sub(pattern, replacement, text)
+    # 手机号脱敏
+    text = re.sub(r"\b1[3-9]\d{9}\b", lambda m: _mask_phone(m.group()), text)
     return text
 
 
-# ==================== RequestId Filter ====================
+# ==================== 大对象截断 ====================
+
+MAX_FIELD_SIZE = 1024  # 超过 1KB 的内容自动截断
+
+
+def truncate_large_value(value: Any, max_size: int = MAX_FIELD_SIZE) -> Any:
+    """超过 max_size 的字符串自动截断（前 500 + 后 500）。"""
+    if isinstance(value, str) and len(value) > max_size:
+        half = max_size // 2
+        return value[:half] + f"...[truncated {len(value) - max_size} chars]..." + value[-half:]
+    if isinstance(value, dict):
+        return {k: truncate_large_value(v, max_size) for k, v in value.items()}
+    if isinstance(value, list):
+        return [truncate_large_value(v, max_size) for v in value]
+    return value
+
+
+# ==================== TraceId Filter ====================
+
+class TraceIdFilter(logging.Filter):
+    """自动注入 traceId / userId / clientIp 到每条日志记录。"""
 
-class RequestIdFilter(logging.Filter):
     def filter(self, record: LogRecord) -> bool:
-        record.request_id = request_id_var.get()
+        record.traceId = request_id_var.get()
+        record.userId = user_id_var.get("")
+        record.clientIp = client_ip_var.get("")
+        record.host = getattr(self, "_host", None) or socket.gethostname()
+        record.app = getattr(self, "_app", "yg-ft-platform")
+        record.env = getattr(self, "_env", "dev")
         return True
 
+    def set_context(self, app: str, env: str, host: str) -> None:
+        self._app = app
+        self._env = env
+        self._host = host
 
-# ==================== Enhanced JSON Formatter ====================
+
+# ==================== JSON Formatter ====================
 
 class JsonLogFormatter(logging.Formatter):
     """
-    增强的 JSON 日志格式化器，支持结构化字段输出。
-    
+    生产级 JSON 日志格式化器，符合方案文档 §3.2 字段规范。
+
     输出示例：
     {
-      "@timestamp": "2026-08-17T18:30:00.123Z",
+      "@timestamp": "2026-08-19T10:30:45.123+08:00",
       "level": "INFO",
-      "logger": "dataset.router",
+      "logger": "app.api.v1.endpoints.platform",
+      "traceId": "abc-123-def-456",
+      "userId": "u_admin",
       "message": "数据集创建成功",
-      "module": "dataset.router",
-      "function": "create_dataset",
-      "file": "dataset/router.py",
-      "line": 45,
-      "process": 12345,
+      "fields": {"datasetId": "ds_001", "costMs": 23},
+      "file": "platform.py:156",
       "thread": "MainThread",
-      "request_id": "req-abc123",
-      "user_id": "u_admin",
-      "client_ip": "192.168.1.100",
-      "extra": {...}
+      "host": "pod-7x9k2",
+      "app": "yg-ft-platform",
+      "env": "dev"
     }
     """
 
+    # 标准 LogRecord 属性名集合，用于区分 extra 字段
+    _STD_ATTRS: set[str] = set(vars(logging.LogRecord("", 0, "", 0, "", None, None)).keys()) | {
+        "traceId", "userId", "clientIp", "host", "app", "env",
+        "request_id", "user_id", "client_ip",
+        "asctime", "message", "module", "function", "process",
+        "thread", "threadName", "levelname", "levelno", "name",
+        "pathname", "filename", "lineno", "funcName", "created",
+        "msecs", "relativeCreated", "exc_info", "exc_text",
+        "stack_info", "msg", "args", "processName", "process",
+    }
+
     def format(self, record: LogRecord) -> str:
+        # 时间戳：ISO8601 带时区
+        timestamp = datetime.fromtimestamp(record.created).astimezone().isoformat(
+            timespec="milliseconds"
+        )
+
         payload: dict[str, Any] = {
-            "@timestamp": datetime.fromtimestamp(record.created).astimezone().isoformat(
-                timespec="milliseconds"
-            ),
+            "@timestamp": timestamp,
             "level": record.levelname,
             "logger": record.name,
+            "traceId": getattr(record, "traceId", "-"),
             "message": record.getMessage(),
-            "module": record.module,
-            "function": record.funcName,
-            "file": record.pathname,
-            "line": record.lineno,
-            "process": record.process,
-            "thread": record.thread,
-            "thread_name": record.threadName,
-            "request_id": getattr(record, "request_id", "-"),
+            "file": f"{Path(record.pathname).name}:{record.lineno}",
+            "thread": record.threadName,
+            "host": getattr(record, "host", ""),
+            "app": getattr(record, "app", ""),
+            "env": getattr(record, "env", ""),
         }
-        
-        # 从 record 中提取额外字段（通过 extra 参数传入）
-        for attr in ("user_id", "client_ip", "target_type", "target_id", 
-                    "duration_ms", "status_code", "error"):
+
+        # userId（业务必填，未登录可为空）
+        user_id = getattr(record, "userId", "") or getattr(record, "user_id", "")
+        if user_id:
+            payload["userId"] = user_id
+
+        # clientIp
+        client_ip = getattr(record, "clientIp", "") or getattr(record, "client_ip", "")
+        if client_ip:
+            payload["clientIp"] = client_ip
+
+        # 提取结构化业务字段：只收集通过 extra 传入的非标准属性
+        fields: dict[str, Any] = {}
+        for attr in dir(record):
+            if attr.startswith("_"):
+                continue
+            if attr in self._STD_ATTRS:
+                continue
+            if attr in ("traceId", "userId", "clientIp", "host", "app", "env"):
+                continue
             val = getattr(record, attr, None)
-            if val is not None:
-                payload[attr] = val
-        
-        # 处理异常信息
-        if record.exc_info:
+            if val is not None and not callable(val):
+                fields[attr] = truncate_large_value(val)
+        if fields:
+            payload["fields"] = mask_sensitive_dict(fields)
+
+        # ERROR 级别额外字段
+        if record.levelname == "ERROR" or record.exc_info:
+            error_obj: dict[str, Any] = {
+                "type": type(record.exc_info[1]).__name__ if record.exc_info and record.exc_info[1] else "Error",
+                "message": record.getMessage(),
+            }
+            if record.exc_info:
+                error_obj["stack_trace"] = self.formatException(record.exc_info)
+            if record.stack_info:
+                error_obj["stack_trace"] = self.formatStack(record.stack_info)
+            payload["error"] = error_obj
+
+        # 兼容旧字段名 exception
+        if record.exc_info and "error" not in payload:
             payload["exception"] = self.formatException(record.exc_info)
-        if record.stack_info:
-            payload["stack"] = self.formatStack(record.stack_info)
-            
+
         return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
 
 
 # ==================== DateSizeRotatingFileHandler ====================
-# （保持不变，已有实现）
 
 class DateSizeRotatingFileHandler(Handler):
-    """Rotate log files by date and size while keeping date in every file name."""
+    """按日期+大小滚动的文件日志处理器。
+
+    - 按天创建文件，文件名包含日期
+    - 单文件超过 max_bytes 时自动滚动（带序号后缀）
+    - 自动清理超过 retention_days 的旧日志
+    """
 
     def __init__(
         self,
@@ -214,10 +307,8 @@ class DateSizeRotatingFileHandler(Handler):
         today = date.today()
         if not force and self._stream and self._current_date == today:
             return
-
         if self._stream and not self._stream.closed:
             self._stream.close()
-
         self._current_date = today
         self._current_path = self._dated_path(today)
         self._stream = self._current_path.open("a", encoding=self.encoding)
@@ -232,11 +323,9 @@ class DateSizeRotatingFileHandler(Handler):
     def _rotate_by_size(self) -> None:
         if not self._current_path or not self._current_path.exists():
             return
-
         if self._stream and not self._stream.closed:
             self._stream.close()
             self._stream = None
-
         stem = self._current_path.stem
         suffix = self._current_path.suffix
         index = 1
@@ -250,7 +339,6 @@ class DateSizeRotatingFileHandler(Handler):
     def _cleanup_expired_files(self) -> None:
         if self.retention_days <= 0:
             return
-
         cutoff = date.today() - timedelta(days=self.retention_days - 1)
         pattern = re.compile(
             rf"^{re.escape(self.file_prefix)}-(\d{{4}}-\d{{2}}-\d{{2}})(?:\.\d+)?\.log$"
@@ -264,98 +352,125 @@ class DateSizeRotatingFileHandler(Handler):
                 path.unlink(missing_ok=True)
 
 
-# ==================== Structured Logger 封装 ====================
+# ==================== StructuredLogger 封装 ====================
 
 class StructuredLogger:
     """
-    结构化日志记录器，提供统一的日志接口。
-    
+    结构化日志记录器，提供符合方案文档 §4.2 的 5W1H 日志接口。
+
     使用方式：
-        logger = get_structured_logger('dataset.router')
-        logger.info('创建数据集', dataset_id='ds_123')
+        logger = get_structured_logger('app.api.dataset')
+        logger.info('数据集创建成功', datasetId='ds_001', costMs=23)
     """
-    
+
     def __init__(self, name: str, module: str = ""):
         self.logger = logging.getLogger(name)
         self.name = name
         self.module = module
-        
+
     @property
     def trace_id(self) -> str:
         return request_id_var.get("-")
-    
-    def info(self, message: str, **extra: Any) -> None:
-        self._log("INFO", message, **extra)
 
-    def warning(self, message: str, **extra: Any) -> None:
-        self._log("WARNING", message, **extra)
+    def info(self, message: str, **fields: Any) -> None:
+        self._log(logging.INFO, message, **fields)
 
-    def error(self, message: str, **extra: Any) -> None:
-        self._log("ERROR", message, **extra)
+    def warning(self, message: str, **fields: Any) -> None:
+        self._log(logging.WARNING, message, **fields)
 
-    def debug(self, message: str, **extra: Any) -> None:
-        self._log("DEBUG", message, **extra)
+    def error(self, message: str, **fields: Any) -> None:
+        self._log(logging.ERROR, message, **fields)
 
-    def _log(self, level: str, message: str, **extra: Any) -> None:
-        """统一日志记录方法"""
-        log_entry: dict[str, Any] = {
-            "timestamp": datetime.utcnow().isoformat(),
-            "level": level,
-            "logger": self.name,
-            "module": self.module,
-            "message": message,
-            "trace_id": self.trace_id,
-            "extra": extra,
-        }
-        self.logger.log(getattr(logging, level, logging.INFO), json.dumps(log_entry, ensure_ascii=False, default=str))
+    def debug(self, message: str, **fields: Any) -> None:
+        self._log(logging.DEBUG, message, **fields)
+
+    def _log(self, level: int, message: str, **fields: Any) -> None:
+        """统一日志记录方法，通过 extra 传递结构化字段。"""
+        extra: dict[str, Any] = {}
+        if self.module:
+            extra["module"] = self.module
+        # 脱敏 + 截断
+        for k, v in fields.items():
+            extra[k] = truncate_large_value(v)
+        self.logger.log(level, message, extra=extra, stack_info=False)
 
 
 def get_structured_logger(name: str, module: str = "") -> StructuredLogger:
-    """获取结构化日志记录器"""
+    """获取结构化日志记录器。"""
     return StructuredLogger(name, module)
 
 
 # ==================== 快捷函数 ====================
 
 def get_logger(name: str) -> logging.Logger:
-    """获取标准 Python logger"""
+    """获取标准 Python logger。"""
     return logging.getLogger(name)
 
 
 def set_request_id(request_id: str) -> None:
-    """设置当前请求的追踪 ID"""
+    """设置当前请求的追踪 ID。"""
     request_id_var.set(request_id)
 
 
+def set_user_context(user_id: str = "", client_ip: str = "") -> None:
+    """设置当前请求的用户上下文（在鉴权后调用）。"""
+    if user_id:
+        user_id_var.set(user_id)
+    if client_ip:
+        client_ip_var.set(client_ip)
+
+
+# ==================== 请求日志中间件 ====================
+
 def setup_request_logging(app: FastAPI) -> None:
-    """配置 FastAPI 请求日志中间件"""
+    """配置 FastAPI 请求日志中间件，符合方案文档 §五（链路追踪）和 §十（访问日志）。"""
     logger = get_logger("app.access")
 
     @app.middleware("http")
     async def request_logging_middleware(request: Request, call_next):  # type: ignore[no-untyped-def]
-        request_id = request.headers.get("X-Request-ID") or str(uuid4())
-        token = request_id_var.set(request_id)
+        # 入口生成 traceId（优先使用前端传入的 X-Trace-Id）
+        trace_id = request.headers.get("X-Trace-Id") or request.headers.get("X-Request-ID") or str(uuid4())
+        token = request_id_var.set(trace_id)
         started_at = time.perf_counter()
+
+        # 提取客户端 IP
+        client_ip = "-"
+        if request.client:
+            client_ip = request.client.host
+        # 支持反向代理传递的真实 IP
+        forwarded_for = request.headers.get("X-Forwarded-For", "")
+        if forwarded_for:
+            client_ip = forwarded_for.split(",")[0].strip()
+        client_ip_var.set(client_ip)
+
         try:
             response = await call_next(request)
             elapsed_ms = (time.perf_counter() - started_at) * 1000
 
+            # 噪声路径降级为 DEBUG（健康检查等）
             noisy_paths = ("/health", "/system-info", "/compute/jobs/", "/model-eval/", "/model-compare/")
-            log_method = logger.debug if request.method == "GET" and response.status_code < 400 else logger.info
-            if any(request.url.path.endswith(path) or path in request.url.path for path in noisy_paths) and response.status_code < 400:
+            log_method = logger.info
+            if any(request.url.path.endswith(p) or p in request.url.path for p in noisy_paths) and response.status_code < 400:
                 log_method = logger.debug
-            if response.status_code >= 400:
+            if response.status_code >= 500:
+                log_method = logger.error
+            elif response.status_code >= 400:
                 log_method = logger.warning
+
+            # 结构化访问日志
             log_method(
-                "request completed method=%s path=%s status_code=%s duration_ms=%.2f client=%s",
-                request.method,
-                request.url.path,
-                response.status_code,
-                elapsed_ms,
-                request.client.host if request.client else "-",
+                "request completed",
+                extra={
+                    "request_method": request.method,
+                    "request_path": request.url.path,
+                    "status_code": response.status_code,
+                    "duration_ms": round(elapsed_ms, 2),
+                    "client_ip": client_ip,
+                    "user_agent": request.headers.get("User-Agent", "")[:200],
+                },
             )
 
-            # 5xx 系统错误自动写入操作日志（未被 @op_log 覆盖的系统级异常）
+            # 5xx 系统错误自动写入操作日志
             if response.status_code >= 500:
                 try:
                     from app.core.op_log import log_operation, OpModule, OpStatus
@@ -373,18 +488,23 @@ def setup_request_logging(app: FastAPI) -> None:
                         duration_ms=elapsed_ms,
                     )
                 except Exception:
-                    pass  # 日志写入失败不影响主流程
+                    pass
 
-            response.headers["X-Request-ID"] = request_id
+            response.headers["X-Trace-Id"] = trace_id
+            response.headers["X-Request-ID"] = trace_id
             return response
+
         except Exception:
             elapsed_ms = (time.perf_counter() - started_at) * 1000
-            logger.exception(
-                "request failed method=%s path=%s duration_ms=%.2f client=%s",
-                request.method,
-                request.url.path,
-                elapsed_ms,
-                request.client.host if request.client else "-",
+            logger.error(
+                "request failed",
+                extra={
+                    "request_method": request.method,
+                    "request_path": request.url.path,
+                    "duration_ms": round(elapsed_ms, 2),
+                    "client_ip": client_ip,
+                },
+                exc_info=True,
             )
 
             # 未被捕获的异常，写入操作日志
@@ -406,7 +526,7 @@ def setup_request_logging(app: FastAPI) -> None:
                     duration_ms=elapsed_ms,
                 )
             except Exception:
-                pass  # 日志写入失败不影响主流程
+                pass
 
             raise
         finally:
@@ -416,53 +536,122 @@ def setup_request_logging(app: FastAPI) -> None:
 # ==================== 配置函数 ====================
 
 def configure_logging(settings: Settings | None = None) -> None:
+    """
+    生产级日志配置，符合方案文档 §二（分类分流）和 §六（性能安全）。
+
+    日志分类：
+    - 业务日志 (app-biz):  INFO+ 业务流程（保留 7 天）
+    - 系统日志 (app-sys):  框架/中间件日志（保留 7 天）
+    - 访问日志 (app-access): HTTP 请求日志（保留 15 天）
+    - 错误日志 (app-error): ERROR 级别（保留 30 天）
+    """
     settings = settings or get_settings()
 
     root_logger = logging.getLogger()
     root_logger.handlers.clear()
     root_logger.setLevel(settings.log_level.upper())
 
+    # ---- Formatter ----
     console_formatter = logging.Formatter(
         fmt=(
             "%(asctime)s | %(levelname)s | pid=%(process)d | %(threadName)s | "
-            "request_id=%(request_id)s | %(name)s | %(pathname)s:%(lineno)d | %(message)s"
+            "traceId=%(traceId)s | %(name)s | %(pathname)s:%(lineno)d | %(message)s"
         ),
         datefmt="%Y-%m-%d %H:%M:%S",
     )
     json_formatter = JsonLogFormatter()
-    request_filter = RequestIdFilter()
 
+    # ---- TraceIdFilter（全局注入 traceId/userId/host/app/env）----
+    trace_filter = TraceIdFilter()
+    trace_filter.set_context(
+        app=settings.app_name,
+        env=settings.app_env,
+        host=socket.gethostname(),
+    )
+
+    # ---- 控制台 Handler ----
     console_handler = logging.StreamHandler()
     console_handler.setFormatter(console_formatter)
-    console_handler.addFilter(request_filter)
+    console_handler.addFilter(trace_filter)
 
-    file_handler = DateSizeRotatingFileHandler(
+    # ---- 业务日志文件 Handler (app-biz) ----
+    biz_file_handler = DateSizeRotatingFileHandler(
         log_dir=settings.log_dir,
-        file_prefix=settings.log_file_prefix,
+        file_prefix="app-biz",
         max_bytes=settings.log_max_bytes,
-        retention_days=settings.log_retention_days,
+        retention_days=7,
     )
-    file_handler.setFormatter(json_formatter)
-    file_handler.addFilter(request_filter)
+    biz_file_handler.setFormatter(json_formatter)
+    biz_file_handler.addFilter(trace_filter)
 
+    # ---- 访问日志文件 Handler (app-access) ----
+    access_file_handler = DateSizeRotatingFileHandler(
+        log_dir=settings.log_dir,
+        file_prefix="app-access",
+        max_bytes=settings.log_max_bytes,
+        retention_days=15,
+    )
+    access_file_handler.setFormatter(json_formatter)
+    access_file_handler.addFilter(trace_filter)
+
+    # ---- 错误日志文件 Handler (app-error) ----
     error_file_handler = DateSizeRotatingFileHandler(
         log_dir=settings.log_dir,
-        file_prefix=settings.log_error_file_prefix,
+        file_prefix="app-error",
         max_bytes=settings.log_max_bytes,
-        retention_days=settings.log_retention_days,
+        retention_days=30,
     )
     error_file_handler.setLevel(logging.ERROR)
     error_file_handler.setFormatter(json_formatter)
-    error_file_handler.addFilter(request_filter)
+    error_file_handler.addFilter(trace_filter)
 
+    # ---- 注册 Handler ----
     root_logger.addHandler(console_handler)
-    root_logger.addHandler(file_handler)
+    root_logger.addHandler(biz_file_handler)
+    root_logger.addHandler(access_file_handler)
     root_logger.addHandler(error_file_handler)
 
-    for logger_name in ("uvicorn", "uvicorn.error", "uvicorn.access"):
-        logger = logging.getLogger(logger_name)
-        logger.handlers.clear()
-        logger.propagate = True
+    # ---- 访问日志 Logger 独立路由到访问日志文件 ----
+    access_logger = logging.getLogger("app.access")
+    access_logger.propagate = False  # 不向 root 传播，避免重复写入业务日志
+    access_logger.addHandler(console_handler)
+    access_logger.addHandler(access_file_handler)
+    # 访问日志中的 ERROR 也要进错误日志
+    access_logger.addHandler(error_file_handler)
 
+    # ---- 框架类 Logger 降级 ----
+    for logger_name in ("uvicorn", "uvicorn.error", "uvicorn.access"):
+        lg = logging.getLogger(logger_name)
+        lg.handlers.clear()
+        lg.propagate = True
+
+    # 框架类日志归入系统日志，生产环境设为 WARN
     logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
     logging.getLogger("psycopg.pool").setLevel(logging.ERROR)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
+    # ---- 兼容旧文件前缀（向后兼容）----
+    # 如果配置了旧的 log_file_prefix，也创建一个对应的 handler
+    if settings.log_file_prefix and settings.log_file_prefix != "app-biz":
+        legacy_file_handler = DateSizeRotatingFileHandler(
+            log_dir=settings.log_dir,
+            file_prefix=settings.log_file_prefix,
+            max_bytes=settings.log_max_bytes,
+            retention_days=settings.log_retention_days,
+        )
+        legacy_file_handler.setFormatter(json_formatter)
+        legacy_file_handler.addFilter(trace_filter)
+        root_logger.addHandler(legacy_file_handler)
+
+    # 旧错误日志前缀兼容
+    if settings.log_error_file_prefix and settings.log_error_file_prefix != "app-error":
+        legacy_error_handler = DateSizeRotatingFileHandler(
+            log_dir=settings.log_dir,
+            file_prefix=settings.log_error_file_prefix,
+            max_bytes=settings.log_max_bytes,
+            retention_days=settings.log_retention_days,
+        )
+        legacy_error_handler.setLevel(logging.ERROR)
+        legacy_error_handler.setFormatter(json_formatter)
+        legacy_error_handler.addFilter(trace_filter)
+        root_logger.addHandler(legacy_error_handler)

backend/app/core/op_log.py

@@ -31,10 +31,11 @@ from typing import Any, Callable, Optional, TypeVar
 
 from fastapi import Request
 
-from app.core.logging import get_logger, request_id_var
+from app.core.logging import get_logger, get_structured_logger, request_id_var
 from app.db.platform_store import get_platform_store, new_id, utcnow
 
 logger = get_logger("app.op_log")
+biz_logger = get_structured_logger("app.biz")
 
 F = TypeVar("F", bound=Callable[..., Any])
 
@@ -341,20 +342,44 @@ def _write_log(
     trace_id: str,
     duration_ms: float,
 ) -> None:
-    """写入操作日志到数据库"""
+    """写入操作日志到数据库 + 文件日志"""
+    user_id = user.get("id") if user else None
+    username = user.get("username") if user else None
+    client_ip = None
+    req_method = None
+    req_path = None
+    if request:
+        client_ip = request.client.host if request.client else None
+        req_method = request.method
+        req_path = request.url.path
+
+    # ---- 写文件日志（app-biz）----
+    log_fields = {
+        "bizModule": module,
+        "action": action,
+        "targetType": target_type or "",
+        "targetId": target_id or "",
+        "targetName": target_name or "",
+        "opStatus": status,
+        "durationMs": round(duration_ms, 2),
+        "username": username or "",
+    }
+    if detail:
+        log_fields["detail"] = detail[:500]
+    if error_message:
+        log_fields["errorMessage"] = error_message[:500]
+    if error_type:
+        log_fields["errorType"] = error_type
+
+    if status == OpStatus.SUCCESS:
+        biz_logger.info(f"{module}:{action} {status} - {target_name or target_id or ''}", **log_fields)
+    elif status == OpStatus.FAILURE:
+        biz_logger.error(f"{module}:{action} {status} - {target_name or target_id or ''} - {error_type}: {error_message[:200]}", **log_fields)
+
+    # ---- 写数据库 ----
     try:
         store = get_platform_store()
         log_id = new_id("op")
-        user_id = user.get("id") if user else None
-        username = user.get("username") if user else None
-        client_ip = None
-        req_method = None
-        req_path = None
-        if request:
-            client_ip = request.client.host if request.client else None
-            req_method = request.method
-            req_path = request.url.path
-
         with store.connect() as conn:
             conn.execute(
                 """
@@ -379,4 +404,4 @@ def _write_log(
                 ),
             )
     except Exception:
-        logger.error("写入操作日志失败 module=%s action=%s", module, action, exc_info=True)
+        logger.error("写入操作日志到数据库失败 module=%s action=%s", module, action, exc_info=True)

backend/app/db/sql/000_full_init.sql

@@ -1,5 +1,5 @@
 -- ============================================================================
--- YG Fine-Tune Platform — PostgreSQL 完整初始化脚本（一键建库建表）
+-- YG Zhilian — PostgreSQL 完整初始化脚本（一键建库建表）
 -- ============================================================================
 -- 用途：切换到新的 PG 数据集时，一次性创建平台运行所需的全部数据库对象与
 --       基础种子数据（幂等，可重复执行）。