chore: remove accidentally committed test binary

.gitignore

@@ -83,8 +83,6 @@ temp/
 *.log
 *.bak
 .cache/
-.dev/
-.serena/
 
 # ===================
 # 构建产物
@@ -128,4 +126,6 @@ backend/cmd/server/server
 deploy/docker-compose.override.yml
 .gocache/
 vite.config.js
+!docs/
 docs/*
+!docs/dependency-security.md

PR_DESCRIPTION.md

@@ -1,164 +0,0 @@
-## 概述
-
-全面增强运维监控系统（Ops）的错误日志管理和告警静默功能，优化前端 UI 组件代码质量和用户体验。本次更新重构了核心服务层和数据访问层，提升系统可维护性和运维效率。
-
-## 主要改动
-
-### 1. 错误日志查询优化
-
-**功能特性：**
-- 新增 GetErrorLogByID 接口，支持按 ID 精确查询错误详情
-- 优化错误日志过滤逻辑，支持多维度筛选（平台、阶段、来源、所有者等）
-- 改进查询参数处理，简化代码结构
-- 增强错误分类和标准化处理
-- 支持错误解决状态追踪（resolved 字段）
-
-**技术实现：**
-- `ops_handler.go` - 新增单条错误日志查询接口
-- `ops_repo.go` - 优化数据查询和过滤条件构建
-- `ops_models.go` - 扩展错误日志数据模型
-- 前端 API 接口同步更新
-
-### 2. 告警静默功能
-
-**功能特性：**
-- 支持按规则、平台、分组、区域等维度静默告警
-- 可设置静默时长和原因说明
-- 静默记录可追溯，记录创建人和创建时间
-- 自动过期机制，避免永久静默
-
-**技术实现：**
-- `037_ops_alert_silences.sql` - 新增告警静默表
-- `ops_alerts.go` - 告警静默逻辑实现
-- `ops_alerts_handler.go` - 告警静默 API 接口
-- `OpsAlertEventsCard.vue` - 前端告警静默操作界面
-
-**数据库结构：**
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| rule_id | BIGINT | 告警规则 ID |
-| platform | VARCHAR(64) | 平台标识 |
-| group_id | BIGINT | 分组 ID（可选） |
-| region | VARCHAR(64) | 区域（可选） |
-| until | TIMESTAMPTZ | 静默截止时间 |
-| reason | TEXT | 静默原因 |
-| created_by | BIGINT | 创建人 ID |
-
-### 3. 错误分类标准化
-
-**功能特性：**
-- 统一错误阶段分类（request|auth|routing|upstream|network|internal）
-- 规范错误归属分类（client|provider|platform）
-- 标准化错误来源分类（client_request|upstream_http|gateway）
-- 自动迁移历史数据到新分类体系
-
-**技术实现：**
-- `038_ops_errors_resolution_retry_results_and_standardize_classification.sql` - 分类标准化迁移
-- 自动映射历史遗留分类到新标准
-- 自动解决已恢复的上游错误（客户端状态码 < 400）
-
-### 4. Gateway 服务集成
-
-**功能特性：**
-- 完善各 Gateway 服务的 Ops 集成
-- 统一错误日志记录接口
-- 增强上游错误追踪能力
-
-**涉及服务：**
-- `antigravity_gateway_service.go` - Antigravity 网关集成
-- `gateway_service.go` - 通用网关集成
-- `gemini_messages_compat_service.go` - Gemini 兼容层集成
-- `openai_gateway_service.go` - OpenAI 网关集成
-
-### 5. 前端 UI 优化
-
-**代码重构：**
-- 大幅简化错误详情模态框代码（从 828 行优化到 450 行）
-- 优化错误日志表格组件，提升可读性
-- 清理未使用的 i18n 翻译，减少冗余
-- 统一组件代码风格和格式
-- 优化骨架屏组件，更好匹配实际看板布局
-
-**布局改进：**
-- 修复模态框内容溢出和滚动问题
-- 优化表格布局，使用 flex 布局确保正确显示
-- 改进看板头部布局和交互
-- 提升响应式体验
-- 骨架屏支持全屏模式适配
-
-**交互优化：**
-- 优化告警事件卡片功能和展示
-- 改进错误详情展示逻辑
-- 增强请求详情模态框
-- 完善运行时设置卡片
-- 改进加载动画效果
-
-### 6. 国际化完善
-
-**文案补充：**
-- 补充错误日志相关的英文翻译
-- 添加告警静默功能的中英文文案
-- 完善提示文本和错误信息
-- 统一术语翻译标准
-
-## 文件变更
-
-**后端（26 个文件）：**
-- `backend/internal/handler/admin/ops_alerts_handler.go` - 告警接口增强
-- `backend/internal/handler/admin/ops_handler.go` - 错误日志接口优化
-- `backend/internal/handler/ops_error_logger.go` - 错误记录器增强
-- `backend/internal/repository/ops_repo.go` - 数据访问层重构
-- `backend/internal/repository/ops_repo_alerts.go` - 告警数据访问增强
-- `backend/internal/service/ops_*.go` - 核心服务层重构（10 个文件）
-- `backend/internal/service/*_gateway_service.go` - Gateway 集成（4 个文件）
-- `backend/internal/server/routes/admin.go` - 路由配置更新
-- `backend/migrations/*.sql` - 数据库迁移（2 个文件）
-- 测试文件更新（5 个文件）
-
-**前端（13 个文件）：**
-- `frontend/src/views/admin/ops/OpsDashboard.vue` - 看板主页优化
-- `frontend/src/views/admin/ops/components/*.vue` - 组件重构（10 个文件）
-- `frontend/src/api/admin/ops.ts` - API 接口扩展
-- `frontend/src/i18n/locales/*.ts` - 国际化文本（2 个文件）
-
-## 代码统计
-
-- 44 个文件修改
-- 3733 行新增
-- 995 行删除
-- 净增加 2738 行
-
-## 核心改进
-
-**可维护性提升：**
-- 重构核心服务层，职责更清晰
-- 简化前端组件代码，降低复杂度
-- 统一代码风格和命名规范
-- 清理冗余代码和未使用的翻译
-- 标准化错误分类体系
-
-**功能完善：**
-- 告警静默功能，减少告警噪音
-- 错误日志查询优化，提升运维效率
-- Gateway 服务集成完善，统一监控能力
-- 错误解决状态追踪，便于问题管理
-
-**用户体验优化：**
-- 修复多个 UI 布局问题
-- 优化交互流程
-- 完善国际化支持
-- 提升响应式体验
-- 改进加载状态展示
-
-## 测试验证
-
-- ✅ 错误日志查询和过滤功能
-- ✅ 告警静默创建和自动过期
-- ✅ 错误分类标准化迁移
-- ✅ Gateway 服务错误日志记录
-- ✅ 前端组件布局和交互
-- ✅ 骨架屏全屏模式适配
-- ✅ 国际化文本完整性
-- ✅ API 接口功能正确性
-- ✅ 数据库迁移执行成功

README_CN.md

@@ -57,13 +57,6 @@ Sub2API 是一个 AI API 网关平台，用于分发和管理 AI 产品订阅（
 
 ---
 
-## OpenAI Responses 兼容注意事项
-
-- 当请求包含 `function_call_output` 时，需要携带 `previous_response_id`，或在 `input` 中包含带 `call_id` 的 `tool_call`/`function_call`，或带非空 `id` 且与 `function_call_output.call_id` 匹配的 `item_reference`。
-- 若依赖上游历史记录，网关会强制 `store=true` 并需要复用 `previous_response_id`，以避免出现 “No tool call found for function call output” 错误。
-
----
-
 ## 部署方式
 
 ### 方式一：脚本安装（推荐）

backend/.dockerignore

@@ -1,2 +0,0 @@
-.cache/
-.DS_Store

backend/.golangci.yml

@@ -18,12 +18,6 @@ linters:
           list-mode: original
           files:
             - "**/internal/service/**"
-            - "!**/internal/service/ops_aggregation_service.go"
-            - "!**/internal/service/ops_alert_evaluator_service.go"
-            - "!**/internal/service/ops_cleanup_service.go"
-            - "!**/internal/service/ops_metrics_collector.go"
-            - "!**/internal/service/ops_scheduled_report_service.go"
-            - "!**/internal/service/wire.go"
           deny:
             - pkg: github.com/Wei-Shaw/sub2api/internal/repository
               desc: "service must not import repository"

backend/cmd/server/wire.go

@@ -62,12 +62,6 @@ func provideServiceBuildInfo(buildInfo handler.BuildInfo) service.BuildInfo {
 func provideCleanup(
 	entClient *ent.Client,
 	rdb *redis.Client,
-	opsMetricsCollector *service.OpsMetricsCollector,
-	opsAggregation *service.OpsAggregationService,
-	opsAlertEvaluator *service.OpsAlertEvaluatorService,
-	opsCleanup *service.OpsCleanupService,
-	opsScheduledReport *service.OpsScheduledReportService,
-	schedulerSnapshot *service.SchedulerSnapshotService,
 	tokenRefresh *service.TokenRefreshService,
 	accountExpiry *service.AccountExpiryService,
 	pricing *service.PricingService,
@@ -87,42 +81,6 @@ func provideCleanup(
 			name string
 			fn   func() error
 		}{
-			{"OpsScheduledReportService", func() error {
-				if opsScheduledReport != nil {
-					opsScheduledReport.Stop()
-				}
-				return nil
-			}},
-			{"OpsCleanupService", func() error {
-				if opsCleanup != nil {
-					opsCleanup.Stop()
-				}
-				return nil
-			}},
-			{"OpsAlertEvaluatorService", func() error {
-				if opsAlertEvaluator != nil {
-					opsAlertEvaluator.Stop()
-				}
-				return nil
-			}},
-			{"OpsAggregationService", func() error {
-				if opsAggregation != nil {
-					opsAggregation.Stop()
-				}
-				return nil
-			}},
-			{"OpsMetricsCollector", func() error {
-				if opsMetricsCollector != nil {
-					opsMetricsCollector.Stop()
-				}
-				return nil
-			}},
-			{"SchedulerSnapshotService", func() error {
-				if schedulerSnapshot != nil {
-					schedulerSnapshot.Stop()
-				}
-				return nil
-			}},
 			{"TokenRefreshService", func() error {
 				tokenRefresh.Stop()
 				return nil

backend/cmd/server/wire_gen.go

@@ -55,37 +55,31 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	billingCache := repository.NewBillingCache(redisClient)
 	userSubscriptionRepository := repository.NewUserSubscriptionRepository(client)
 	billingCacheService := service.NewBillingCacheService(billingCache, userRepository, userSubscriptionRepository, configConfig)
+	promoService := service.NewPromoService(promoCodeRepository, userRepository, billingCacheService, client)
+	authService := service.NewAuthService(userRepository, configConfig, settingService, emailService, turnstileService, emailQueueService, promoService)
+	userService := service.NewUserService(userRepository)
+	authHandler := handler.NewAuthHandler(configConfig, authService, userService, settingService, promoService)
+	userHandler := handler.NewUserHandler(userService)
 	apiKeyRepository := repository.NewAPIKeyRepository(client)
 	groupRepository := repository.NewGroupRepository(client, db)
 	apiKeyCache := repository.NewAPIKeyCache(redisClient)
 	apiKeyService := service.NewAPIKeyService(apiKeyRepository, userRepository, groupRepository, userSubscriptionRepository, apiKeyCache, configConfig)
-	apiKeyAuthCacheInvalidator := service.ProvideAPIKeyAuthCacheInvalidator(apiKeyService)
-	promoService := service.NewPromoService(promoCodeRepository, userRepository, billingCacheService, client, apiKeyAuthCacheInvalidator)
-	authService := service.NewAuthService(userRepository, configConfig, settingService, emailService, turnstileService, emailQueueService, promoService)
-	userService := service.NewUserService(userRepository, apiKeyAuthCacheInvalidator)
-	authHandler := handler.NewAuthHandler(configConfig, authService, userService, settingService, promoService)
-	userHandler := handler.NewUserHandler(userService)
 	apiKeyHandler := handler.NewAPIKeyHandler(apiKeyService)
 	usageLogRepository := repository.NewUsageLogRepository(client, db)
-	usageService := service.NewUsageService(usageLogRepository, userRepository, client, apiKeyAuthCacheInvalidator)
+	usageService := service.NewUsageService(usageLogRepository, userRepository, client)
 	usageHandler := handler.NewUsageHandler(usageService, apiKeyService)
 	redeemCodeRepository := repository.NewRedeemCodeRepository(client)
 	subscriptionService := service.NewSubscriptionService(groupRepository, userSubscriptionRepository, billingCacheService)
 	redeemCache := repository.NewRedeemCache(redisClient)
-	redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client, apiKeyAuthCacheInvalidator)
+	redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client)
 	redeemHandler := handler.NewRedeemHandler(redeemService)
 	subscriptionHandler := handler.NewSubscriptionHandler(subscriptionService)
-	dashboardAggregationRepository := repository.NewDashboardAggregationRepository(db)
-	dashboardStatsCache := repository.NewDashboardCache(redisClient, configConfig)
-	dashboardService := service.NewDashboardService(usageLogRepository, dashboardAggregationRepository, dashboardStatsCache, configConfig)
-	timingWheelService := service.ProvideTimingWheelService()
-	dashboardAggregationService := service.ProvideDashboardAggregationService(dashboardAggregationRepository, timingWheelService, configConfig)
-	dashboardHandler := admin.NewDashboardHandler(dashboardService, dashboardAggregationService)
+	dashboardService := service.NewDashboardService(usageLogRepository)
+	dashboardHandler := admin.NewDashboardHandler(dashboardService)
 	accountRepository := repository.NewAccountRepository(client, db)
 	proxyRepository := repository.NewProxyRepository(client, db)
 	proxyExitInfoProber := repository.NewProxyExitInfoProber(configConfig)
-	proxyLatencyCache := repository.NewProxyLatencyCache(redisClient)
-	adminService := service.NewAdminService(userRepository, groupRepository, accountRepository, proxyRepository, apiKeyRepository, redeemCodeRepository, billingCacheService, proxyExitInfoProber, proxyLatencyCache, apiKeyAuthCacheInvalidator)
+	adminService := service.NewAdminService(userRepository, groupRepository, accountRepository, proxyRepository, apiKeyRepository, redeemCodeRepository, billingCacheService, proxyExitInfoProber)
 	adminUserHandler := admin.NewUserHandler(adminService)
 	groupHandler := admin.NewGroupHandler(adminService)
 	claudeOAuthClient := repository.NewClaudeOAuthClient()
@@ -98,14 +92,12 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
 	geminiQuotaService := service.NewGeminiQuotaService(configConfig, settingRepository)
 	tempUnschedCache := repository.NewTempUnschedCache(redisClient)
-	timeoutCounterCache := repository.NewTimeoutCounterCache(redisClient)
-	geminiTokenCache := repository.NewGeminiTokenCache(redisClient)
-	tokenCacheInvalidator := service.NewCompositeTokenCacheInvalidator(geminiTokenCache)
-	rateLimitService := service.ProvideRateLimitService(accountRepository, usageLogRepository, configConfig, geminiQuotaService, tempUnschedCache, timeoutCounterCache, settingService, tokenCacheInvalidator)
+	rateLimitService := service.NewRateLimitService(accountRepository, usageLogRepository, configConfig, geminiQuotaService, tempUnschedCache)
 	claudeUsageFetcher := repository.NewClaudeUsageFetcher()
 	antigravityQuotaFetcher := service.NewAntigravityQuotaFetcher(proxyRepository)
 	usageCache := service.NewUsageCache()
 	accountUsageService := service.NewAccountUsageService(accountRepository, usageLogRepository, claudeUsageFetcher, geminiQuotaService, antigravityQuotaFetcher, usageCache)
+	geminiTokenCache := repository.NewGeminiTokenCache(redisClient)
 	geminiTokenProvider := service.NewGeminiTokenProvider(accountRepository, geminiTokenCache, geminiOAuthService)
 	gatewayCache := repository.NewGatewayCache(redisClient)
 	antigravityTokenProvider := service.NewAntigravityTokenProvider(accountRepository, geminiTokenCache, antigravityOAuthService)
@@ -123,25 +115,7 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	proxyHandler := admin.NewProxyHandler(adminService)
 	adminRedeemHandler := admin.NewRedeemHandler(adminService)
 	promoHandler := admin.NewPromoHandler(promoService)
-	opsRepository := repository.NewOpsRepository(db)
-	schedulerCache := repository.NewSchedulerCache(redisClient)
-	schedulerOutboxRepository := repository.NewSchedulerOutboxRepository(db)
-	schedulerSnapshotService := service.ProvideSchedulerSnapshotService(schedulerCache, schedulerOutboxRepository, accountRepository, groupRepository, configConfig)
-	pricingRemoteClient := repository.ProvidePricingRemoteClient(configConfig)
-	pricingService, err := service.ProvidePricingService(configConfig, pricingRemoteClient)
-	if err != nil {
-		return nil, err
-	}
-	billingService := service.NewBillingService(configConfig, pricingService)
-	identityCache := repository.NewIdentityCache(redisClient)
-	identityService := service.NewIdentityService(identityCache)
-	deferredService := service.ProvideDeferredService(accountRepository, timingWheelService)
-	gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService)
-	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService)
-	geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, schedulerSnapshotService, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService, configConfig)
-	opsService := service.NewOpsService(opsRepository, settingRepository, configConfig, accountRepository, concurrencyService, gatewayService, openAIGatewayService, geminiMessagesCompatService, antigravityGatewayService)
-	settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService, opsService)
-	opsHandler := admin.NewOpsHandler(opsService)
+	settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService)
 	updateCache := repository.NewUpdateCache(redisClient)
 	gitHubReleaseClient := repository.ProvideGitHubReleaseClient(configConfig)
 	serviceBuildInfo := provideServiceBuildInfo(buildInfo)
@@ -153,24 +127,32 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	userAttributeValueRepository := repository.NewUserAttributeValueRepository(client)
 	userAttributeService := service.NewUserAttributeService(userAttributeDefinitionRepository, userAttributeValueRepository)
 	userAttributeHandler := admin.NewUserAttributeHandler(userAttributeService)
-	adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, opsHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler)
+	adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler)
+	pricingRemoteClient := repository.ProvidePricingRemoteClient(configConfig)
+	pricingService, err := service.ProvidePricingService(configConfig, pricingRemoteClient)
+	if err != nil {
+		return nil, err
+	}
+	billingService := service.NewBillingService(configConfig, pricingService)
+	identityCache := repository.NewIdentityCache(redisClient)
+	identityService := service.NewIdentityService(identityCache)
+	timingWheelService := service.ProvideTimingWheelService()
+	deferredService := service.ProvideDeferredService(accountRepository, timingWheelService)
+	gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService)
+	geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService, configConfig)
 	gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService, configConfig)
+	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService)
 	openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService, configConfig)
 	handlerSettingHandler := handler.ProvideSettingHandler(settingService, buildInfo)
 	handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, handlerSettingHandler)
 	jwtAuthMiddleware := middleware.NewJWTAuthMiddleware(authService, userService)
 	adminAuthMiddleware := middleware.NewAdminAuthMiddleware(authService, userService, settingService)
 	apiKeyAuthMiddleware := middleware.NewAPIKeyAuthMiddleware(apiKeyService, subscriptionService, configConfig)
-	engine := server.ProvideRouter(configConfig, handlers, jwtAuthMiddleware, adminAuthMiddleware, apiKeyAuthMiddleware, apiKeyService, subscriptionService, opsService, settingService, redisClient)
+	engine := server.ProvideRouter(configConfig, handlers, jwtAuthMiddleware, adminAuthMiddleware, apiKeyAuthMiddleware, apiKeyService, subscriptionService, settingService, redisClient)
 	httpServer := server.ProvideHTTPServer(configConfig, engine)
-	opsMetricsCollector := service.ProvideOpsMetricsCollector(opsRepository, settingRepository, accountRepository, concurrencyService, db, redisClient, configConfig)
-	opsAggregationService := service.ProvideOpsAggregationService(opsRepository, settingRepository, db, redisClient, configConfig)
-	opsAlertEvaluatorService := service.ProvideOpsAlertEvaluatorService(opsService, opsRepository, emailService, redisClient, configConfig)
-	opsCleanupService := service.ProvideOpsCleanupService(opsRepository, db, redisClient, configConfig)
-	opsScheduledReportService := service.ProvideOpsScheduledReportService(opsService, userService, emailService, redisClient, configConfig)
-	tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, tokenCacheInvalidator, configConfig)
+	tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, configConfig)
 	accountExpiryService := service.ProvideAccountExpiryService(accountRepository)
-	v := provideCleanup(client, redisClient, opsMetricsCollector, opsAggregationService, opsAlertEvaluatorService, opsCleanupService, opsScheduledReportService, schedulerSnapshotService, tokenRefreshService, accountExpiryService, pricingService, emailQueueService, billingCacheService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService)
+	v := provideCleanup(client, redisClient, tokenRefreshService, accountExpiryService, pricingService, emailQueueService, billingCacheService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService)
 	application := &Application{
 		Server:  httpServer,
 		Cleanup: v,
@@ -195,12 +177,6 @@ func provideServiceBuildInfo(buildInfo handler.BuildInfo) service.BuildInfo {
 func provideCleanup(
 	entClient *ent.Client,
 	rdb *redis.Client,
-	opsMetricsCollector *service.OpsMetricsCollector,
-	opsAggregation *service.OpsAggregationService,
-	opsAlertEvaluator *service.OpsAlertEvaluatorService,
-	opsCleanup *service.OpsCleanupService,
-	opsScheduledReport *service.OpsScheduledReportService,
-	schedulerSnapshot *service.SchedulerSnapshotService,
 	tokenRefresh *service.TokenRefreshService,
 	accountExpiry *service.AccountExpiryService,
 	pricing *service.PricingService,
@@ -219,42 +195,6 @@ func provideCleanup(
 			name string
 			fn   func() error
 		}{
-			{"OpsScheduledReportService", func() error {
-				if opsScheduledReport != nil {
-					opsScheduledReport.Stop()
-				}
-				return nil
-			}},
-			{"OpsCleanupService", func() error {
-				if opsCleanup != nil {
-					opsCleanup.Stop()
-				}
-				return nil
-			}},
-			{"OpsAlertEvaluatorService", func() error {
-				if opsAlertEvaluator != nil {
-					opsAlertEvaluator.Stop()
-				}
-				return nil
-			}},
-			{"OpsAggregationService", func() error {
-				if opsAggregation != nil {
-					opsAggregation.Stop()
-				}
-				return nil
-			}},
-			{"OpsMetricsCollector", func() error {
-				if opsMetricsCollector != nil {
-					opsMetricsCollector.Stop()
-				}
-				return nil
-			}},
-			{"SchedulerSnapshotService", func() error {
-				if schedulerSnapshot != nil {
-					schedulerSnapshot.Stop()
-				}
-				return nil
-			}},
 			{"TokenRefreshService", func() error {
 				tokenRefresh.Stop()
 				return nil

backend/ent/account.go

@@ -43,8 +43,6 @@ type Account struct {
 	Concurrency int `json:"concurrency,omitempty"`
 	// Priority holds the value of the "priority" field.
 	Priority int `json:"priority,omitempty"`
-	// RateMultiplier holds the value of the "rate_multiplier" field.
-	RateMultiplier float64 `json:"rate_multiplier,omitempty"`
 	// Status holds the value of the "status" field.
 	Status string `json:"status,omitempty"`
 	// ErrorMessage holds the value of the "error_message" field.
@@ -137,8 +135,6 @@ func (*Account) scanValues(columns []string) ([]any, error) {
 			values[i] = new([]byte)
 		case account.FieldAutoPauseOnExpired, account.FieldSchedulable:
 			values[i] = new(sql.NullBool)
-		case account.FieldRateMultiplier:
-			values[i] = new(sql.NullFloat64)
 		case account.FieldID, account.FieldProxyID, account.FieldConcurrency, account.FieldPriority:
 			values[i] = new(sql.NullInt64)
 		case account.FieldName, account.FieldNotes, account.FieldPlatform, account.FieldType, account.FieldStatus, account.FieldErrorMessage, account.FieldSessionWindowStatus:
@@ -245,12 +241,6 @@ func (_m *Account) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.Priority = int(value.Int64)
 			}
-		case account.FieldRateMultiplier:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field rate_multiplier", values[i])
-			} else if value.Valid {
-				_m.RateMultiplier = value.Float64
-			}
 		case account.FieldStatus:
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field status", values[i])
@@ -430,9 +420,6 @@ func (_m *Account) String() string {
 	builder.WriteString("priority=")
 	builder.WriteString(fmt.Sprintf("%v", _m.Priority))
 	builder.WriteString(", ")
-	builder.WriteString("rate_multiplier=")
-	builder.WriteString(fmt.Sprintf("%v", _m.RateMultiplier))
-	builder.WriteString(", ")
 	builder.WriteString("status=")
 	builder.WriteString(_m.Status)
 	builder.WriteString(", ")

backend/ent/account/account.go

@@ -39,8 +39,6 @@ const (
 	FieldConcurrency = "concurrency"
 	// FieldPriority holds the string denoting the priority field in the database.
 	FieldPriority = "priority"
-	// FieldRateMultiplier holds the string denoting the rate_multiplier field in the database.
-	FieldRateMultiplier = "rate_multiplier"
 	// FieldStatus holds the string denoting the status field in the database.
 	FieldStatus = "status"
 	// FieldErrorMessage holds the string denoting the error_message field in the database.
@@ -118,7 +116,6 @@ var Columns = []string{
 	FieldProxyID,
 	FieldConcurrency,
 	FieldPriority,
-	FieldRateMultiplier,
 	FieldStatus,
 	FieldErrorMessage,
 	FieldLastUsedAt,
@@ -177,8 +174,6 @@ var (
 	DefaultConcurrency int
 	// DefaultPriority holds the default value on creation for the "priority" field.
 	DefaultPriority int
-	// DefaultRateMultiplier holds the default value on creation for the "rate_multiplier" field.
-	DefaultRateMultiplier float64
 	// DefaultStatus holds the default value on creation for the "status" field.
 	DefaultStatus string
 	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
@@ -249,11 +244,6 @@ func ByPriority(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldPriority, opts...).ToFunc()
 }
 
-// ByRateMultiplier orders the results by the rate_multiplier field.
-func ByRateMultiplier(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldRateMultiplier, opts...).ToFunc()
-}
-
 // ByStatus orders the results by the status field.
 func ByStatus(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldStatus, opts...).ToFunc()

backend/ent/account/where.go

@@ -105,11 +105,6 @@ func Priority(v int) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldPriority, v))
 }
 
-// RateMultiplier applies equality check predicate on the "rate_multiplier" field. It's identical to RateMultiplierEQ.
-func RateMultiplier(v float64) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldRateMultiplier, v))
-}
-
 // Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
 func Status(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldStatus, v))
@@ -680,46 +675,6 @@ func PriorityLTE(v int) predicate.Account {
 	return predicate.Account(sql.FieldLTE(FieldPriority, v))
 }
 
-// RateMultiplierEQ applies the EQ predicate on the "rate_multiplier" field.
-func RateMultiplierEQ(v float64) predicate.Account {
-	return predicate.Account(sql.FieldEQ(FieldRateMultiplier, v))
-}
-
-// RateMultiplierNEQ applies the NEQ predicate on the "rate_multiplier" field.
-func RateMultiplierNEQ(v float64) predicate.Account {
-	return predicate.Account(sql.FieldNEQ(FieldRateMultiplier, v))
-}
-
-// RateMultiplierIn applies the In predicate on the "rate_multiplier" field.
-func RateMultiplierIn(vs ...float64) predicate.Account {
-	return predicate.Account(sql.FieldIn(FieldRateMultiplier, vs...))
-}
-
-// RateMultiplierNotIn applies the NotIn predicate on the "rate_multiplier" field.
-func RateMultiplierNotIn(vs ...float64) predicate.Account {
-	return predicate.Account(sql.FieldNotIn(FieldRateMultiplier, vs...))
-}
-
-// RateMultiplierGT applies the GT predicate on the "rate_multiplier" field.
-func RateMultiplierGT(v float64) predicate.Account {
-	return predicate.Account(sql.FieldGT(FieldRateMultiplier, v))
-}
-
-// RateMultiplierGTE applies the GTE predicate on the "rate_multiplier" field.
-func RateMultiplierGTE(v float64) predicate.Account {
-	return predicate.Account(sql.FieldGTE(FieldRateMultiplier, v))
-}
-
-// RateMultiplierLT applies the LT predicate on the "rate_multiplier" field.
-func RateMultiplierLT(v float64) predicate.Account {
-	return predicate.Account(sql.FieldLT(FieldRateMultiplier, v))
-}
-
-// RateMultiplierLTE applies the LTE predicate on the "rate_multiplier" field.
-func RateMultiplierLTE(v float64) predicate.Account {
-	return predicate.Account(sql.FieldLTE(FieldRateMultiplier, v))
-}
-
 // StatusEQ applies the EQ predicate on the "status" field.
 func StatusEQ(v string) predicate.Account {
 	return predicate.Account(sql.FieldEQ(FieldStatus, v))

backend/ent/account_create.go

@@ -153,20 +153,6 @@ func (_c *AccountCreate) SetNillablePriority(v *int) *AccountCreate {
 	return _c
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (_c *AccountCreate) SetRateMultiplier(v float64) *AccountCreate {
-	_c.mutation.SetRateMultiplier(v)
-	return _c
-}
-
-// SetNillableRateMultiplier sets the "rate_multiplier" field if the given value is not nil.
-func (_c *AccountCreate) SetNillableRateMultiplier(v *float64) *AccountCreate {
-	if v != nil {
-		_c.SetRateMultiplier(*v)
-	}
-	return _c
-}
-
 // SetStatus sets the "status" field.
 func (_c *AccountCreate) SetStatus(v string) *AccountCreate {
 	_c.mutation.SetStatus(v)
@@ -443,10 +429,6 @@ func (_c *AccountCreate) defaults() error {
 		v := account.DefaultPriority
 		_c.mutation.SetPriority(v)
 	}
-	if _, ok := _c.mutation.RateMultiplier(); !ok {
-		v := account.DefaultRateMultiplier
-		_c.mutation.SetRateMultiplier(v)
-	}
 	if _, ok := _c.mutation.Status(); !ok {
 		v := account.DefaultStatus
 		_c.mutation.SetStatus(v)
@@ -506,9 +488,6 @@ func (_c *AccountCreate) check() error {
 	if _, ok := _c.mutation.Priority(); !ok {
 		return &ValidationError{Name: "priority", err: errors.New(`ent: missing required field "Account.priority"`)}
 	}
-	if _, ok := _c.mutation.RateMultiplier(); !ok {
-		return &ValidationError{Name: "rate_multiplier", err: errors.New(`ent: missing required field "Account.rate_multiplier"`)}
-	}
 	if _, ok := _c.mutation.Status(); !ok {
 		return &ValidationError{Name: "status", err: errors.New(`ent: missing required field "Account.status"`)}
 	}
@@ -599,10 +578,6 @@ func (_c *AccountCreate) createSpec() (*Account, *sqlgraph.CreateSpec) {
 		_spec.SetField(account.FieldPriority, field.TypeInt, value)
 		_node.Priority = value
 	}
-	if value, ok := _c.mutation.RateMultiplier(); ok {
-		_spec.SetField(account.FieldRateMultiplier, field.TypeFloat64, value)
-		_node.RateMultiplier = value
-	}
 	if value, ok := _c.mutation.Status(); ok {
 		_spec.SetField(account.FieldStatus, field.TypeString, value)
 		_node.Status = value
@@ -918,24 +893,6 @@ func (u *AccountUpsert) AddPriority(v int) *AccountUpsert {
 	return u
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (u *AccountUpsert) SetRateMultiplier(v float64) *AccountUpsert {
-	u.Set(account.FieldRateMultiplier, v)
-	return u
-}
-
-// UpdateRateMultiplier sets the "rate_multiplier" field to the value that was provided on create.
-func (u *AccountUpsert) UpdateRateMultiplier() *AccountUpsert {
-	u.SetExcluded(account.FieldRateMultiplier)
-	return u
-}
-
-// AddRateMultiplier adds v to the "rate_multiplier" field.
-func (u *AccountUpsert) AddRateMultiplier(v float64) *AccountUpsert {
-	u.Add(account.FieldRateMultiplier, v)
-	return u
-}
-
 // SetStatus sets the "status" field.
 func (u *AccountUpsert) SetStatus(v string) *AccountUpsert {
 	u.Set(account.FieldStatus, v)
@@ -1368,27 +1325,6 @@ func (u *AccountUpsertOne) UpdatePriority() *AccountUpsertOne {
 	})
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (u *AccountUpsertOne) SetRateMultiplier(v float64) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetRateMultiplier(v)
-	})
-}
-
-// AddRateMultiplier adds v to the "rate_multiplier" field.
-func (u *AccountUpsertOne) AddRateMultiplier(v float64) *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.AddRateMultiplier(v)
-	})
-}
-
-// UpdateRateMultiplier sets the "rate_multiplier" field to the value that was provided on create.
-func (u *AccountUpsertOne) UpdateRateMultiplier() *AccountUpsertOne {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateRateMultiplier()
-	})
-}
-
 // SetStatus sets the "status" field.
 func (u *AccountUpsertOne) SetStatus(v string) *AccountUpsertOne {
 	return u.Update(func(s *AccountUpsert) {
@@ -2020,27 +1956,6 @@ func (u *AccountUpsertBulk) UpdatePriority() *AccountUpsertBulk {
 	})
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (u *AccountUpsertBulk) SetRateMultiplier(v float64) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.SetRateMultiplier(v)
-	})
-}
-
-// AddRateMultiplier adds v to the "rate_multiplier" field.
-func (u *AccountUpsertBulk) AddRateMultiplier(v float64) *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.AddRateMultiplier(v)
-	})
-}
-
-// UpdateRateMultiplier sets the "rate_multiplier" field to the value that was provided on create.
-func (u *AccountUpsertBulk) UpdateRateMultiplier() *AccountUpsertBulk {
-	return u.Update(func(s *AccountUpsert) {
-		s.UpdateRateMultiplier()
-	})
-}
-
 // SetStatus sets the "status" field.
 func (u *AccountUpsertBulk) SetStatus(v string) *AccountUpsertBulk {
 	return u.Update(func(s *AccountUpsert) {

backend/ent/account_update.go

@@ -193,27 +193,6 @@ func (_u *AccountUpdate) AddPriority(v int) *AccountUpdate {
 	return _u
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (_u *AccountUpdate) SetRateMultiplier(v float64) *AccountUpdate {
-	_u.mutation.ResetRateMultiplier()
-	_u.mutation.SetRateMultiplier(v)
-	return _u
-}
-
-// SetNillableRateMultiplier sets the "rate_multiplier" field if the given value is not nil.
-func (_u *AccountUpdate) SetNillableRateMultiplier(v *float64) *AccountUpdate {
-	if v != nil {
-		_u.SetRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddRateMultiplier adds value to the "rate_multiplier" field.
-func (_u *AccountUpdate) AddRateMultiplier(v float64) *AccountUpdate {
-	_u.mutation.AddRateMultiplier(v)
-	return _u
-}
-
 // SetStatus sets the "status" field.
 func (_u *AccountUpdate) SetStatus(v string) *AccountUpdate {
 	_u.mutation.SetStatus(v)
@@ -650,12 +629,6 @@ func (_u *AccountUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.AddedPriority(); ok {
 		_spec.AddField(account.FieldPriority, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.RateMultiplier(); ok {
-		_spec.SetField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
-		_spec.AddField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
 	if value, ok := _u.mutation.Status(); ok {
 		_spec.SetField(account.FieldStatus, field.TypeString, value)
 	}
@@ -1032,27 +1005,6 @@ func (_u *AccountUpdateOne) AddPriority(v int) *AccountUpdateOne {
 	return _u
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (_u *AccountUpdateOne) SetRateMultiplier(v float64) *AccountUpdateOne {
-	_u.mutation.ResetRateMultiplier()
-	_u.mutation.SetRateMultiplier(v)
-	return _u
-}
-
-// SetNillableRateMultiplier sets the "rate_multiplier" field if the given value is not nil.
-func (_u *AccountUpdateOne) SetNillableRateMultiplier(v *float64) *AccountUpdateOne {
-	if v != nil {
-		_u.SetRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddRateMultiplier adds value to the "rate_multiplier" field.
-func (_u *AccountUpdateOne) AddRateMultiplier(v float64) *AccountUpdateOne {
-	_u.mutation.AddRateMultiplier(v)
-	return _u
-}
-
 // SetStatus sets the "status" field.
 func (_u *AccountUpdateOne) SetStatus(v string) *AccountUpdateOne {
 	_u.mutation.SetStatus(v)
@@ -1519,12 +1471,6 @@ func (_u *AccountUpdateOne) sqlSave(ctx context.Context) (_node *Account, err er
 	if value, ok := _u.mutation.AddedPriority(); ok {
 		_spec.AddField(account.FieldPriority, field.TypeInt, value)
 	}
-	if value, ok := _u.mutation.RateMultiplier(); ok {
-		_spec.SetField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
-		_spec.AddField(account.FieldRateMultiplier, field.TypeFloat64, value)
-	}
 	if value, ok := _u.mutation.Status(); ok {
 		_spec.SetField(account.FieldStatus, field.TypeString, value)
 	}

backend/ent/migrate/schema.go

@@ -79,7 +79,6 @@ var (
 		{Name: "extra", Type: field.TypeJSON, SchemaType: map[string]string{"postgres": "jsonb"}},
 		{Name: "concurrency", Type: field.TypeInt, Default: 3},
 		{Name: "priority", Type: field.TypeInt, Default: 50},
-		{Name: "rate_multiplier", Type: field.TypeFloat64, Default: 1, SchemaType: map[string]string{"postgres": "decimal(10,4)"}},
 		{Name: "status", Type: field.TypeString, Size: 20, Default: "active"},
 		{Name: "error_message", Type: field.TypeString, Nullable: true, SchemaType: map[string]string{"postgres": "text"}},
 		{Name: "last_used_at", Type: field.TypeTime, Nullable: true, SchemaType: map[string]string{"postgres": "timestamptz"}},
@@ -102,7 +101,7 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:     "accounts_proxies_proxy",
-				Columns:    []*schema.Column{AccountsColumns[25]},
+				Columns:    []*schema.Column{AccountsColumns[24]},
 				RefColumns: []*schema.Column{ProxiesColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
@@ -121,12 +120,12 @@ var (
 			{
 				Name:    "account_status",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[13]},
+				Columns: []*schema.Column{AccountsColumns[12]},
 			},
 			{
 				Name:    "account_proxy_id",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[25]},
+				Columns: []*schema.Column{AccountsColumns[24]},
 			},
 			{
 				Name:    "account_priority",
@@ -136,27 +135,27 @@ var (
 			{
 				Name:    "account_last_used_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[15]},
+				Columns: []*schema.Column{AccountsColumns[14]},
 			},
 			{
 				Name:    "account_schedulable",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[18]},
+				Columns: []*schema.Column{AccountsColumns[17]},
 			},
 			{
 				Name:    "account_rate_limited_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[19]},
+				Columns: []*schema.Column{AccountsColumns[18]},
 			},
 			{
 				Name:    "account_rate_limit_reset_at",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[20]},
+				Columns: []*schema.Column{AccountsColumns[19]},
 			},
 			{
 				Name:    "account_overload_until",
 				Unique:  false,
-				Columns: []*schema.Column{AccountsColumns[21]},
+				Columns: []*schema.Column{AccountsColumns[20]},
 			},
 			{
 				Name:    "account_deleted_at",
@@ -450,7 +449,6 @@ var (
 		{Name: "total_cost", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,10)"}},
 		{Name: "actual_cost", Type: field.TypeFloat64, Default: 0, SchemaType: map[string]string{"postgres": "decimal(20,10)"}},
 		{Name: "rate_multiplier", Type: field.TypeFloat64, Default: 1, SchemaType: map[string]string{"postgres": "decimal(10,4)"}},
-		{Name: "account_rate_multiplier", Type: field.TypeFloat64, Nullable: true, SchemaType: map[string]string{"postgres": "decimal(10,4)"}},
 		{Name: "billing_type", Type: field.TypeInt8, Default: 0},
 		{Name: "stream", Type: field.TypeBool, Default: false},
 		{Name: "duration_ms", Type: field.TypeInt, Nullable: true},
@@ -474,31 +472,31 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:     "usage_logs_api_keys_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[26]},
+				Columns:    []*schema.Column{UsageLogsColumns[25]},
 				RefColumns: []*schema.Column{APIKeysColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 			{
 				Symbol:     "usage_logs_accounts_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[27]},
+				Columns:    []*schema.Column{UsageLogsColumns[26]},
 				RefColumns: []*schema.Column{AccountsColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 			{
 				Symbol:     "usage_logs_groups_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[28]},
+				Columns:    []*schema.Column{UsageLogsColumns[27]},
 				RefColumns: []*schema.Column{GroupsColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
 			{
 				Symbol:     "usage_logs_users_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[29]},
+				Columns:    []*schema.Column{UsageLogsColumns[28]},
 				RefColumns: []*schema.Column{UsersColumns[0]},
 				OnDelete:   schema.NoAction,
 			},
 			{
 				Symbol:     "usage_logs_user_subscriptions_usage_logs",
-				Columns:    []*schema.Column{UsageLogsColumns[30]},
+				Columns:    []*schema.Column{UsageLogsColumns[29]},
 				RefColumns: []*schema.Column{UserSubscriptionsColumns[0]},
 				OnDelete:   schema.SetNull,
 			},
@@ -507,32 +505,32 @@ var (
 			{
 				Name:    "usagelog_user_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[29]},
+				Columns: []*schema.Column{UsageLogsColumns[28]},
 			},
 			{
 				Name:    "usagelog_api_key_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[26]},
+				Columns: []*schema.Column{UsageLogsColumns[25]},
 			},
 			{
 				Name:    "usagelog_account_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[27]},
+				Columns: []*schema.Column{UsageLogsColumns[26]},
 			},
 			{
 				Name:    "usagelog_group_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[28]},
+				Columns: []*schema.Column{UsageLogsColumns[27]},
 			},
 			{
 				Name:    "usagelog_subscription_id",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[30]},
+				Columns: []*schema.Column{UsageLogsColumns[29]},
 			},
 			{
 				Name:    "usagelog_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[25]},
+				Columns: []*schema.Column{UsageLogsColumns[24]},
 			},
 			{
 				Name:    "usagelog_model",
@@ -547,12 +545,12 @@ var (
 			{
 				Name:    "usagelog_user_id_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[29], UsageLogsColumns[25]},
+				Columns: []*schema.Column{UsageLogsColumns[28], UsageLogsColumns[24]},
 			},
 			{
 				Name:    "usagelog_api_key_id_created_at",
 				Unique:  false,
-				Columns: []*schema.Column{UsageLogsColumns[26], UsageLogsColumns[25]},
+				Columns: []*schema.Column{UsageLogsColumns[25], UsageLogsColumns[24]},
 			},
 		},
 	}

backend/ent/mutation.go

@@ -1187,8 +1187,6 @@ type AccountMutation struct {
 	addconcurrency        *int
 	priority              *int
 	addpriority           *int
-	rate_multiplier       *float64
-	addrate_multiplier    *float64
 	status                *string
 	error_message         *string
 	last_used_at          *time.Time
@@ -1824,62 +1822,6 @@ func (m *AccountMutation) ResetPriority() {
 	m.addpriority = nil
 }
 
-// SetRateMultiplier sets the "rate_multiplier" field.
-func (m *AccountMutation) SetRateMultiplier(f float64) {
-	m.rate_multiplier = &f
-	m.addrate_multiplier = nil
-}
-
-// RateMultiplier returns the value of the "rate_multiplier" field in the mutation.
-func (m *AccountMutation) RateMultiplier() (r float64, exists bool) {
-	v := m.rate_multiplier
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldRateMultiplier returns the old "rate_multiplier" field's value of the Account entity.
-// If the Account object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *AccountMutation) OldRateMultiplier(ctx context.Context) (v float64, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldRateMultiplier is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldRateMultiplier requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldRateMultiplier: %w", err)
-	}
-	return oldValue.RateMultiplier, nil
-}
-
-// AddRateMultiplier adds f to the "rate_multiplier" field.
-func (m *AccountMutation) AddRateMultiplier(f float64) {
-	if m.addrate_multiplier != nil {
-		*m.addrate_multiplier += f
-	} else {
-		m.addrate_multiplier = &f
-	}
-}
-
-// AddedRateMultiplier returns the value that was added to the "rate_multiplier" field in this mutation.
-func (m *AccountMutation) AddedRateMultiplier() (r float64, exists bool) {
-	v := m.addrate_multiplier
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// ResetRateMultiplier resets all changes to the "rate_multiplier" field.
-func (m *AccountMutation) ResetRateMultiplier() {
-	m.rate_multiplier = nil
-	m.addrate_multiplier = nil
-}
-
 // SetStatus sets the "status" field.
 func (m *AccountMutation) SetStatus(s string) {
 	m.status = &s
@@ -2598,7 +2540,7 @@ func (m *AccountMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *AccountMutation) Fields() []string {
-	fields := make([]string, 0, 25)
+	fields := make([]string, 0, 24)
 	if m.created_at != nil {
 		fields = append(fields, account.FieldCreatedAt)
 	}
@@ -2635,9 +2577,6 @@ func (m *AccountMutation) Fields() []string {
 	if m.priority != nil {
 		fields = append(fields, account.FieldPriority)
 	}
-	if m.rate_multiplier != nil {
-		fields = append(fields, account.FieldRateMultiplier)
-	}
 	if m.status != nil {
 		fields = append(fields, account.FieldStatus)
 	}
@@ -2706,8 +2645,6 @@ func (m *AccountMutation) Field(name string) (ent.Value, bool) {
 		return m.Concurrency()
 	case account.FieldPriority:
 		return m.Priority()
-	case account.FieldRateMultiplier:
-		return m.RateMultiplier()
 	case account.FieldStatus:
 		return m.Status()
 	case account.FieldErrorMessage:
@@ -2765,8 +2702,6 @@ func (m *AccountMutation) OldField(ctx context.Context, name string) (ent.Value,
 		return m.OldConcurrency(ctx)
 	case account.FieldPriority:
 		return m.OldPriority(ctx)
-	case account.FieldRateMultiplier:
-		return m.OldRateMultiplier(ctx)
 	case account.FieldStatus:
 		return m.OldStatus(ctx)
 	case account.FieldErrorMessage:
@@ -2884,13 +2819,6 @@ func (m *AccountMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetPriority(v)
 		return nil
-	case account.FieldRateMultiplier:
-		v, ok := value.(float64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetRateMultiplier(v)
-		return nil
 	case account.FieldStatus:
 		v, ok := value.(string)
 		if !ok {
@@ -2989,9 +2917,6 @@ func (m *AccountMutation) AddedFields() []string {
 	if m.addpriority != nil {
 		fields = append(fields, account.FieldPriority)
 	}
-	if m.addrate_multiplier != nil {
-		fields = append(fields, account.FieldRateMultiplier)
-	}
 	return fields
 }
 
@@ -3004,8 +2929,6 @@ func (m *AccountMutation) AddedField(name string) (ent.Value, bool) {
 		return m.AddedConcurrency()
 	case account.FieldPriority:
 		return m.AddedPriority()
-	case account.FieldRateMultiplier:
-		return m.AddedRateMultiplier()
 	}
 	return nil, false
 }
@@ -3029,13 +2952,6 @@ func (m *AccountMutation) AddField(name string, value ent.Value) error {
 		}
 		m.AddPriority(v)
 		return nil
-	case account.FieldRateMultiplier:
-		v, ok := value.(float64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddRateMultiplier(v)
-		return nil
 	}
 	return fmt.Errorf("unknown Account numeric field %s", name)
 }
@@ -3174,9 +3090,6 @@ func (m *AccountMutation) ResetField(name string) error {
 	case account.FieldPriority:
 		m.ResetPriority()
 		return nil
-	case account.FieldRateMultiplier:
-		m.ResetRateMultiplier()
-		return nil
 	case account.FieldStatus:
 		m.ResetStatus()
 		return nil
@@ -10277,8 +10190,6 @@ type UsageLogMutation struct {
 	addactual_cost              *float64
 	rate_multiplier             *float64
 	addrate_multiplier          *float64
-	account_rate_multiplier     *float64
-	addaccount_rate_multiplier  *float64
 	billing_type                *int8
 	addbilling_type             *int8
 	stream                      *bool
@@ -11412,76 +11323,6 @@ func (m *UsageLogMutation) ResetRateMultiplier() {
 	m.addrate_multiplier = nil
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (m *UsageLogMutation) SetAccountRateMultiplier(f float64) {
-	m.account_rate_multiplier = &f
-	m.addaccount_rate_multiplier = nil
-}
-
-// AccountRateMultiplier returns the value of the "account_rate_multiplier" field in the mutation.
-func (m *UsageLogMutation) AccountRateMultiplier() (r float64, exists bool) {
-	v := m.account_rate_multiplier
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// OldAccountRateMultiplier returns the old "account_rate_multiplier" field's value of the UsageLog entity.
-// If the UsageLog object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UsageLogMutation) OldAccountRateMultiplier(ctx context.Context) (v *float64, err error) {
-	if !m.op.Is(OpUpdateOne) {
-		return v, errors.New("OldAccountRateMultiplier is only allowed on UpdateOne operations")
-	}
-	if m.id == nil || m.oldValue == nil {
-		return v, errors.New("OldAccountRateMultiplier requires an ID field in the mutation")
-	}
-	oldValue, err := m.oldValue(ctx)
-	if err != nil {
-		return v, fmt.Errorf("querying old value for OldAccountRateMultiplier: %w", err)
-	}
-	return oldValue.AccountRateMultiplier, nil
-}
-
-// AddAccountRateMultiplier adds f to the "account_rate_multiplier" field.
-func (m *UsageLogMutation) AddAccountRateMultiplier(f float64) {
-	if m.addaccount_rate_multiplier != nil {
-		*m.addaccount_rate_multiplier += f
-	} else {
-		m.addaccount_rate_multiplier = &f
-	}
-}
-
-// AddedAccountRateMultiplier returns the value that was added to the "account_rate_multiplier" field in this mutation.
-func (m *UsageLogMutation) AddedAccountRateMultiplier() (r float64, exists bool) {
-	v := m.addaccount_rate_multiplier
-	if v == nil {
-		return
-	}
-	return *v, true
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (m *UsageLogMutation) ClearAccountRateMultiplier() {
-	m.account_rate_multiplier = nil
-	m.addaccount_rate_multiplier = nil
-	m.clearedFields[usagelog.FieldAccountRateMultiplier] = struct{}{}
-}
-
-// AccountRateMultiplierCleared returns if the "account_rate_multiplier" field was cleared in this mutation.
-func (m *UsageLogMutation) AccountRateMultiplierCleared() bool {
-	_, ok := m.clearedFields[usagelog.FieldAccountRateMultiplier]
-	return ok
-}
-
-// ResetAccountRateMultiplier resets all changes to the "account_rate_multiplier" field.
-func (m *UsageLogMutation) ResetAccountRateMultiplier() {
-	m.account_rate_multiplier = nil
-	m.addaccount_rate_multiplier = nil
-	delete(m.clearedFields, usagelog.FieldAccountRateMultiplier)
-}
-
 // SetBillingType sets the "billing_type" field.
 func (m *UsageLogMutation) SetBillingType(i int8) {
 	m.billing_type = &i
@@ -12122,7 +11963,7 @@ func (m *UsageLogMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *UsageLogMutation) Fields() []string {
-	fields := make([]string, 0, 30)
+	fields := make([]string, 0, 29)
 	if m.user != nil {
 		fields = append(fields, usagelog.FieldUserID)
 	}
@@ -12183,9 +12024,6 @@ func (m *UsageLogMutation) Fields() []string {
 	if m.rate_multiplier != nil {
 		fields = append(fields, usagelog.FieldRateMultiplier)
 	}
-	if m.account_rate_multiplier != nil {
-		fields = append(fields, usagelog.FieldAccountRateMultiplier)
-	}
 	if m.billing_type != nil {
 		fields = append(fields, usagelog.FieldBillingType)
 	}
@@ -12261,8 +12099,6 @@ func (m *UsageLogMutation) Field(name string) (ent.Value, bool) {
 		return m.ActualCost()
 	case usagelog.FieldRateMultiplier:
 		return m.RateMultiplier()
-	case usagelog.FieldAccountRateMultiplier:
-		return m.AccountRateMultiplier()
 	case usagelog.FieldBillingType:
 		return m.BillingType()
 	case usagelog.FieldStream:
@@ -12330,8 +12166,6 @@ func (m *UsageLogMutation) OldField(ctx context.Context, name string) (ent.Value
 		return m.OldActualCost(ctx)
 	case usagelog.FieldRateMultiplier:
 		return m.OldRateMultiplier(ctx)
-	case usagelog.FieldAccountRateMultiplier:
-		return m.OldAccountRateMultiplier(ctx)
 	case usagelog.FieldBillingType:
 		return m.OldBillingType(ctx)
 	case usagelog.FieldStream:
@@ -12499,13 +12333,6 @@ func (m *UsageLogMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetRateMultiplier(v)
 		return nil
-	case usagelog.FieldAccountRateMultiplier:
-		v, ok := value.(float64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.SetAccountRateMultiplier(v)
-		return nil
 	case usagelog.FieldBillingType:
 		v, ok := value.(int8)
 		if !ok {
@@ -12616,9 +12443,6 @@ func (m *UsageLogMutation) AddedFields() []string {
 	if m.addrate_multiplier != nil {
 		fields = append(fields, usagelog.FieldRateMultiplier)
 	}
-	if m.addaccount_rate_multiplier != nil {
-		fields = append(fields, usagelog.FieldAccountRateMultiplier)
-	}
 	if m.addbilling_type != nil {
 		fields = append(fields, usagelog.FieldBillingType)
 	}
@@ -12665,8 +12489,6 @@ func (m *UsageLogMutation) AddedField(name string) (ent.Value, bool) {
 		return m.AddedActualCost()
 	case usagelog.FieldRateMultiplier:
 		return m.AddedRateMultiplier()
-	case usagelog.FieldAccountRateMultiplier:
-		return m.AddedAccountRateMultiplier()
 	case usagelog.FieldBillingType:
 		return m.AddedBillingType()
 	case usagelog.FieldDurationMs:
@@ -12775,13 +12597,6 @@ func (m *UsageLogMutation) AddField(name string, value ent.Value) error {
 		}
 		m.AddRateMultiplier(v)
 		return nil
-	case usagelog.FieldAccountRateMultiplier:
-		v, ok := value.(float64)
-		if !ok {
-			return fmt.Errorf("unexpected type %T for field %s", value, name)
-		}
-		m.AddAccountRateMultiplier(v)
-		return nil
 	case usagelog.FieldBillingType:
 		v, ok := value.(int8)
 		if !ok {
@@ -12824,9 +12639,6 @@ func (m *UsageLogMutation) ClearedFields() []string {
 	if m.FieldCleared(usagelog.FieldSubscriptionID) {
 		fields = append(fields, usagelog.FieldSubscriptionID)
 	}
-	if m.FieldCleared(usagelog.FieldAccountRateMultiplier) {
-		fields = append(fields, usagelog.FieldAccountRateMultiplier)
-	}
 	if m.FieldCleared(usagelog.FieldDurationMs) {
 		fields = append(fields, usagelog.FieldDurationMs)
 	}
@@ -12862,9 +12674,6 @@ func (m *UsageLogMutation) ClearField(name string) error {
 	case usagelog.FieldSubscriptionID:
 		m.ClearSubscriptionID()
 		return nil
-	case usagelog.FieldAccountRateMultiplier:
-		m.ClearAccountRateMultiplier()
-		return nil
 	case usagelog.FieldDurationMs:
 		m.ClearDurationMs()
 		return nil
@@ -12948,9 +12757,6 @@ func (m *UsageLogMutation) ResetField(name string) error {
 	case usagelog.FieldRateMultiplier:
 		m.ResetRateMultiplier()
 		return nil
-	case usagelog.FieldAccountRateMultiplier:
-		m.ResetAccountRateMultiplier()
-		return nil
 	case usagelog.FieldBillingType:
 		m.ResetBillingType()
 		return nil

backend/ent/runtime/runtime.go

@@ -177,26 +177,22 @@ func init() {
 	accountDescPriority := accountFields[8].Descriptor()
 	// account.DefaultPriority holds the default value on creation for the priority field.
 	account.DefaultPriority = accountDescPriority.Default.(int)
-	// accountDescRateMultiplier is the schema descriptor for rate_multiplier field.
-	accountDescRateMultiplier := accountFields[9].Descriptor()
-	// account.DefaultRateMultiplier holds the default value on creation for the rate_multiplier field.
-	account.DefaultRateMultiplier = accountDescRateMultiplier.Default.(float64)
 	// accountDescStatus is the schema descriptor for status field.
-	accountDescStatus := accountFields[10].Descriptor()
+	accountDescStatus := accountFields[9].Descriptor()
 	// account.DefaultStatus holds the default value on creation for the status field.
 	account.DefaultStatus = accountDescStatus.Default.(string)
 	// account.StatusValidator is a validator for the "status" field. It is called by the builders before save.
 	account.StatusValidator = accountDescStatus.Validators[0].(func(string) error)
 	// accountDescAutoPauseOnExpired is the schema descriptor for auto_pause_on_expired field.
-	accountDescAutoPauseOnExpired := accountFields[14].Descriptor()
+	accountDescAutoPauseOnExpired := accountFields[13].Descriptor()
 	// account.DefaultAutoPauseOnExpired holds the default value on creation for the auto_pause_on_expired field.
 	account.DefaultAutoPauseOnExpired = accountDescAutoPauseOnExpired.Default.(bool)
 	// accountDescSchedulable is the schema descriptor for schedulable field.
-	accountDescSchedulable := accountFields[15].Descriptor()
+	accountDescSchedulable := accountFields[14].Descriptor()
 	// account.DefaultSchedulable holds the default value on creation for the schedulable field.
 	account.DefaultSchedulable = accountDescSchedulable.Default.(bool)
 	// accountDescSessionWindowStatus is the schema descriptor for session_window_status field.
-	accountDescSessionWindowStatus := accountFields[21].Descriptor()
+	accountDescSessionWindowStatus := accountFields[20].Descriptor()
 	// account.SessionWindowStatusValidator is a validator for the "session_window_status" field. It is called by the builders before save.
 	account.SessionWindowStatusValidator = accountDescSessionWindowStatus.Validators[0].(func(string) error)
 	accountgroupFields := schema.AccountGroup{}.Fields()
@@ -582,31 +578,31 @@ func init() {
 	// usagelog.DefaultRateMultiplier holds the default value on creation for the rate_multiplier field.
 	usagelog.DefaultRateMultiplier = usagelogDescRateMultiplier.Default.(float64)
 	// usagelogDescBillingType is the schema descriptor for billing_type field.
-	usagelogDescBillingType := usagelogFields[21].Descriptor()
+	usagelogDescBillingType := usagelogFields[20].Descriptor()
 	// usagelog.DefaultBillingType holds the default value on creation for the billing_type field.
 	usagelog.DefaultBillingType = usagelogDescBillingType.Default.(int8)
 	// usagelogDescStream is the schema descriptor for stream field.
-	usagelogDescStream := usagelogFields[22].Descriptor()
+	usagelogDescStream := usagelogFields[21].Descriptor()
 	// usagelog.DefaultStream holds the default value on creation for the stream field.
 	usagelog.DefaultStream = usagelogDescStream.Default.(bool)
 	// usagelogDescUserAgent is the schema descriptor for user_agent field.
-	usagelogDescUserAgent := usagelogFields[25].Descriptor()
+	usagelogDescUserAgent := usagelogFields[24].Descriptor()
 	// usagelog.UserAgentValidator is a validator for the "user_agent" field. It is called by the builders before save.
 	usagelog.UserAgentValidator = usagelogDescUserAgent.Validators[0].(func(string) error)
 	// usagelogDescIPAddress is the schema descriptor for ip_address field.
-	usagelogDescIPAddress := usagelogFields[26].Descriptor()
+	usagelogDescIPAddress := usagelogFields[25].Descriptor()
 	// usagelog.IPAddressValidator is a validator for the "ip_address" field. It is called by the builders before save.
 	usagelog.IPAddressValidator = usagelogDescIPAddress.Validators[0].(func(string) error)
 	// usagelogDescImageCount is the schema descriptor for image_count field.
-	usagelogDescImageCount := usagelogFields[27].Descriptor()
+	usagelogDescImageCount := usagelogFields[26].Descriptor()
 	// usagelog.DefaultImageCount holds the default value on creation for the image_count field.
 	usagelog.DefaultImageCount = usagelogDescImageCount.Default.(int)
 	// usagelogDescImageSize is the schema descriptor for image_size field.
-	usagelogDescImageSize := usagelogFields[28].Descriptor()
+	usagelogDescImageSize := usagelogFields[27].Descriptor()
 	// usagelog.ImageSizeValidator is a validator for the "image_size" field. It is called by the builders before save.
 	usagelog.ImageSizeValidator = usagelogDescImageSize.Validators[0].(func(string) error)
 	// usagelogDescCreatedAt is the schema descriptor for created_at field.
-	usagelogDescCreatedAt := usagelogFields[29].Descriptor()
+	usagelogDescCreatedAt := usagelogFields[28].Descriptor()
 	// usagelog.DefaultCreatedAt holds the default value on creation for the created_at field.
 	usagelog.DefaultCreatedAt = usagelogDescCreatedAt.Default.(func() time.Time)
 	userMixin := schema.User{}.Mixin()

backend/ent/schema/account.go

@@ -102,12 +102,6 @@ func (Account) Fields() []ent.Field {
 		field.Int("priority").
 			Default(50),
 
-		// rate_multiplier: 账号计费倍率（>=0，允许 0 表示该账号计费为 0）
-		// 仅影响账号维度计费口径，不影响用户/API Key 扣费（分组倍率）
-		field.Float("rate_multiplier").
-			SchemaType(map[string]string{dialect.Postgres: "decimal(10,4)"}).
-			Default(1.0),
-
 		// status: 账户状态，如 "active", "error", "disabled"
 		field.String("status").
 			MaxLen(20).

backend/ent/schema/usage_log.go

@@ -85,12 +85,6 @@ func (UsageLog) Fields() []ent.Field {
 			Default(1).
 			SchemaType(map[string]string{dialect.Postgres: "decimal(10,4)"}),
 
-		// account_rate_multiplier: 账号计费倍率快照（NULL 表示按 1.0 处理）
-		field.Float("account_rate_multiplier").
-			Optional().
-			Nillable().
-			SchemaType(map[string]string{dialect.Postgres: "decimal(10,4)"}),
-
 		// 其他字段
 		field.Int8("billing_type").
 			Default(0),

backend/ent/usagelog.go

@@ -62,8 +62,6 @@ type UsageLog struct {
 	ActualCost float64 `json:"actual_cost,omitempty"`
 	// RateMultiplier holds the value of the "rate_multiplier" field.
 	RateMultiplier float64 `json:"rate_multiplier,omitempty"`
-	// AccountRateMultiplier holds the value of the "account_rate_multiplier" field.
-	AccountRateMultiplier *float64 `json:"account_rate_multiplier,omitempty"`
 	// BillingType holds the value of the "billing_type" field.
 	BillingType int8 `json:"billing_type,omitempty"`
 	// Stream holds the value of the "stream" field.
@@ -167,7 +165,7 @@ func (*UsageLog) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case usagelog.FieldStream:
 			values[i] = new(sql.NullBool)
-		case usagelog.FieldInputCost, usagelog.FieldOutputCost, usagelog.FieldCacheCreationCost, usagelog.FieldCacheReadCost, usagelog.FieldTotalCost, usagelog.FieldActualCost, usagelog.FieldRateMultiplier, usagelog.FieldAccountRateMultiplier:
+		case usagelog.FieldInputCost, usagelog.FieldOutputCost, usagelog.FieldCacheCreationCost, usagelog.FieldCacheReadCost, usagelog.FieldTotalCost, usagelog.FieldActualCost, usagelog.FieldRateMultiplier:
 			values[i] = new(sql.NullFloat64)
 		case usagelog.FieldID, usagelog.FieldUserID, usagelog.FieldAPIKeyID, usagelog.FieldAccountID, usagelog.FieldGroupID, usagelog.FieldSubscriptionID, usagelog.FieldInputTokens, usagelog.FieldOutputTokens, usagelog.FieldCacheCreationTokens, usagelog.FieldCacheReadTokens, usagelog.FieldCacheCreation5mTokens, usagelog.FieldCacheCreation1hTokens, usagelog.FieldBillingType, usagelog.FieldDurationMs, usagelog.FieldFirstTokenMs, usagelog.FieldImageCount:
 			values[i] = new(sql.NullInt64)
@@ -318,13 +316,6 @@ func (_m *UsageLog) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.RateMultiplier = value.Float64
 			}
-		case usagelog.FieldAccountRateMultiplier:
-			if value, ok := values[i].(*sql.NullFloat64); !ok {
-				return fmt.Errorf("unexpected type %T for field account_rate_multiplier", values[i])
-			} else if value.Valid {
-				_m.AccountRateMultiplier = new(float64)
-				*_m.AccountRateMultiplier = value.Float64
-			}
 		case usagelog.FieldBillingType:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field billing_type", values[i])
@@ -509,11 +500,6 @@ func (_m *UsageLog) String() string {
 	builder.WriteString("rate_multiplier=")
 	builder.WriteString(fmt.Sprintf("%v", _m.RateMultiplier))
 	builder.WriteString(", ")
-	if v := _m.AccountRateMultiplier; v != nil {
-		builder.WriteString("account_rate_multiplier=")
-		builder.WriteString(fmt.Sprintf("%v", *v))
-	}
-	builder.WriteString(", ")
 	builder.WriteString("billing_type=")
 	builder.WriteString(fmt.Sprintf("%v", _m.BillingType))
 	builder.WriteString(", ")

backend/ent/usagelog/usagelog.go

@@ -54,8 +54,6 @@ const (
 	FieldActualCost = "actual_cost"
 	// FieldRateMultiplier holds the string denoting the rate_multiplier field in the database.
 	FieldRateMultiplier = "rate_multiplier"
-	// FieldAccountRateMultiplier holds the string denoting the account_rate_multiplier field in the database.
-	FieldAccountRateMultiplier = "account_rate_multiplier"
 	// FieldBillingType holds the string denoting the billing_type field in the database.
 	FieldBillingType = "billing_type"
 	// FieldStream holds the string denoting the stream field in the database.
@@ -146,7 +144,6 @@ var Columns = []string{
 	FieldTotalCost,
 	FieldActualCost,
 	FieldRateMultiplier,
-	FieldAccountRateMultiplier,
 	FieldBillingType,
 	FieldStream,
 	FieldDurationMs,
@@ -323,11 +320,6 @@ func ByRateMultiplier(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldRateMultiplier, opts...).ToFunc()
 }
 
-// ByAccountRateMultiplier orders the results by the account_rate_multiplier field.
-func ByAccountRateMultiplier(opts ...sql.OrderTermOption) OrderOption {
-	return sql.OrderByField(FieldAccountRateMultiplier, opts...).ToFunc()
-}
-
 // ByBillingType orders the results by the billing_type field.
 func ByBillingType(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldBillingType, opts...).ToFunc()

backend/ent/usagelog/where.go

@@ -155,11 +155,6 @@ func RateMultiplier(v float64) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldRateMultiplier, v))
 }
 
-// AccountRateMultiplier applies equality check predicate on the "account_rate_multiplier" field. It's identical to AccountRateMultiplierEQ.
-func AccountRateMultiplier(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldAccountRateMultiplier, v))
-}
-
 // BillingType applies equality check predicate on the "billing_type" field. It's identical to BillingTypeEQ.
 func BillingType(v int8) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldBillingType, v))
@@ -975,56 +970,6 @@ func RateMultiplierLTE(v float64) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldLTE(FieldRateMultiplier, v))
 }
 
-// AccountRateMultiplierEQ applies the EQ predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierEQ(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldEQ(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierNEQ applies the NEQ predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierNEQ(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNEQ(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierIn applies the In predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierIn(vs ...float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIn(FieldAccountRateMultiplier, vs...))
-}
-
-// AccountRateMultiplierNotIn applies the NotIn predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierNotIn(vs ...float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotIn(FieldAccountRateMultiplier, vs...))
-}
-
-// AccountRateMultiplierGT applies the GT predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierGT(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGT(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierGTE applies the GTE predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierGTE(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldGTE(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierLT applies the LT predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierLT(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLT(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierLTE applies the LTE predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierLTE(v float64) predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldLTE(FieldAccountRateMultiplier, v))
-}
-
-// AccountRateMultiplierIsNil applies the IsNil predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierIsNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldIsNull(FieldAccountRateMultiplier))
-}
-
-// AccountRateMultiplierNotNil applies the NotNil predicate on the "account_rate_multiplier" field.
-func AccountRateMultiplierNotNil() predicate.UsageLog {
-	return predicate.UsageLog(sql.FieldNotNull(FieldAccountRateMultiplier))
-}
-
 // BillingTypeEQ applies the EQ predicate on the "billing_type" field.
 func BillingTypeEQ(v int8) predicate.UsageLog {
 	return predicate.UsageLog(sql.FieldEQ(FieldBillingType, v))

backend/ent/usagelog_create.go

@@ -267,20 +267,6 @@ func (_c *UsageLogCreate) SetNillableRateMultiplier(v *float64) *UsageLogCreate
 	return _c
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (_c *UsageLogCreate) SetAccountRateMultiplier(v float64) *UsageLogCreate {
-	_c.mutation.SetAccountRateMultiplier(v)
-	return _c
-}
-
-// SetNillableAccountRateMultiplier sets the "account_rate_multiplier" field if the given value is not nil.
-func (_c *UsageLogCreate) SetNillableAccountRateMultiplier(v *float64) *UsageLogCreate {
-	if v != nil {
-		_c.SetAccountRateMultiplier(*v)
-	}
-	return _c
-}
-
 // SetBillingType sets the "billing_type" field.
 func (_c *UsageLogCreate) SetBillingType(v int8) *UsageLogCreate {
 	_c.mutation.SetBillingType(v)
@@ -726,10 +712,6 @@ func (_c *UsageLogCreate) createSpec() (*UsageLog, *sqlgraph.CreateSpec) {
 		_spec.SetField(usagelog.FieldRateMultiplier, field.TypeFloat64, value)
 		_node.RateMultiplier = value
 	}
-	if value, ok := _c.mutation.AccountRateMultiplier(); ok {
-		_spec.SetField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-		_node.AccountRateMultiplier = &value
-	}
 	if value, ok := _c.mutation.BillingType(); ok {
 		_spec.SetField(usagelog.FieldBillingType, field.TypeInt8, value)
 		_node.BillingType = value
@@ -1233,30 +1215,6 @@ func (u *UsageLogUpsert) AddRateMultiplier(v float64) *UsageLogUpsert {
 	return u
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (u *UsageLogUpsert) SetAccountRateMultiplier(v float64) *UsageLogUpsert {
-	u.Set(usagelog.FieldAccountRateMultiplier, v)
-	return u
-}
-
-// UpdateAccountRateMultiplier sets the "account_rate_multiplier" field to the value that was provided on create.
-func (u *UsageLogUpsert) UpdateAccountRateMultiplier() *UsageLogUpsert {
-	u.SetExcluded(usagelog.FieldAccountRateMultiplier)
-	return u
-}
-
-// AddAccountRateMultiplier adds v to the "account_rate_multiplier" field.
-func (u *UsageLogUpsert) AddAccountRateMultiplier(v float64) *UsageLogUpsert {
-	u.Add(usagelog.FieldAccountRateMultiplier, v)
-	return u
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (u *UsageLogUpsert) ClearAccountRateMultiplier() *UsageLogUpsert {
-	u.SetNull(usagelog.FieldAccountRateMultiplier)
-	return u
-}
-
 // SetBillingType sets the "billing_type" field.
 func (u *UsageLogUpsert) SetBillingType(v int8) *UsageLogUpsert {
 	u.Set(usagelog.FieldBillingType, v)
@@ -1837,34 +1795,6 @@ func (u *UsageLogUpsertOne) UpdateRateMultiplier() *UsageLogUpsertOne {
 	})
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (u *UsageLogUpsertOne) SetAccountRateMultiplier(v float64) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetAccountRateMultiplier(v)
-	})
-}
-
-// AddAccountRateMultiplier adds v to the "account_rate_multiplier" field.
-func (u *UsageLogUpsertOne) AddAccountRateMultiplier(v float64) *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.AddAccountRateMultiplier(v)
-	})
-}
-
-// UpdateAccountRateMultiplier sets the "account_rate_multiplier" field to the value that was provided on create.
-func (u *UsageLogUpsertOne) UpdateAccountRateMultiplier() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateAccountRateMultiplier()
-	})
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (u *UsageLogUpsertOne) ClearAccountRateMultiplier() *UsageLogUpsertOne {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearAccountRateMultiplier()
-	})
-}
-
 // SetBillingType sets the "billing_type" field.
 func (u *UsageLogUpsertOne) SetBillingType(v int8) *UsageLogUpsertOne {
 	return u.Update(func(s *UsageLogUpsert) {
@@ -2636,34 +2566,6 @@ func (u *UsageLogUpsertBulk) UpdateRateMultiplier() *UsageLogUpsertBulk {
 	})
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (u *UsageLogUpsertBulk) SetAccountRateMultiplier(v float64) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.SetAccountRateMultiplier(v)
-	})
-}
-
-// AddAccountRateMultiplier adds v to the "account_rate_multiplier" field.
-func (u *UsageLogUpsertBulk) AddAccountRateMultiplier(v float64) *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.AddAccountRateMultiplier(v)
-	})
-}
-
-// UpdateAccountRateMultiplier sets the "account_rate_multiplier" field to the value that was provided on create.
-func (u *UsageLogUpsertBulk) UpdateAccountRateMultiplier() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.UpdateAccountRateMultiplier()
-	})
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (u *UsageLogUpsertBulk) ClearAccountRateMultiplier() *UsageLogUpsertBulk {
-	return u.Update(func(s *UsageLogUpsert) {
-		s.ClearAccountRateMultiplier()
-	})
-}
-
 // SetBillingType sets the "billing_type" field.
 func (u *UsageLogUpsertBulk) SetBillingType(v int8) *UsageLogUpsertBulk {
 	return u.Update(func(s *UsageLogUpsert) {

backend/ent/usagelog_update.go

@@ -415,33 +415,6 @@ func (_u *UsageLogUpdate) AddRateMultiplier(v float64) *UsageLogUpdate {
 	return _u
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (_u *UsageLogUpdate) SetAccountRateMultiplier(v float64) *UsageLogUpdate {
-	_u.mutation.ResetAccountRateMultiplier()
-	_u.mutation.SetAccountRateMultiplier(v)
-	return _u
-}
-
-// SetNillableAccountRateMultiplier sets the "account_rate_multiplier" field if the given value is not nil.
-func (_u *UsageLogUpdate) SetNillableAccountRateMultiplier(v *float64) *UsageLogUpdate {
-	if v != nil {
-		_u.SetAccountRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddAccountRateMultiplier adds value to the "account_rate_multiplier" field.
-func (_u *UsageLogUpdate) AddAccountRateMultiplier(v float64) *UsageLogUpdate {
-	_u.mutation.AddAccountRateMultiplier(v)
-	return _u
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (_u *UsageLogUpdate) ClearAccountRateMultiplier() *UsageLogUpdate {
-	_u.mutation.ClearAccountRateMultiplier()
-	return _u
-}
-
 // SetBillingType sets the "billing_type" field.
 func (_u *UsageLogUpdate) SetBillingType(v int8) *UsageLogUpdate {
 	_u.mutation.ResetBillingType()
@@ -834,15 +807,6 @@ func (_u *UsageLogUpdate) sqlSave(ctx context.Context) (_node int, err error) {
 	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
 		_spec.AddField(usagelog.FieldRateMultiplier, field.TypeFloat64, value)
 	}
-	if value, ok := _u.mutation.AccountRateMultiplier(); ok {
-		_spec.SetField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedAccountRateMultiplier(); ok {
-		_spec.AddField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if _u.mutation.AccountRateMultiplierCleared() {
-		_spec.ClearField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64)
-	}
 	if value, ok := _u.mutation.BillingType(); ok {
 		_spec.SetField(usagelog.FieldBillingType, field.TypeInt8, value)
 	}
@@ -1442,33 +1406,6 @@ func (_u *UsageLogUpdateOne) AddRateMultiplier(v float64) *UsageLogUpdateOne {
 	return _u
 }
 
-// SetAccountRateMultiplier sets the "account_rate_multiplier" field.
-func (_u *UsageLogUpdateOne) SetAccountRateMultiplier(v float64) *UsageLogUpdateOne {
-	_u.mutation.ResetAccountRateMultiplier()
-	_u.mutation.SetAccountRateMultiplier(v)
-	return _u
-}
-
-// SetNillableAccountRateMultiplier sets the "account_rate_multiplier" field if the given value is not nil.
-func (_u *UsageLogUpdateOne) SetNillableAccountRateMultiplier(v *float64) *UsageLogUpdateOne {
-	if v != nil {
-		_u.SetAccountRateMultiplier(*v)
-	}
-	return _u
-}
-
-// AddAccountRateMultiplier adds value to the "account_rate_multiplier" field.
-func (_u *UsageLogUpdateOne) AddAccountRateMultiplier(v float64) *UsageLogUpdateOne {
-	_u.mutation.AddAccountRateMultiplier(v)
-	return _u
-}
-
-// ClearAccountRateMultiplier clears the value of the "account_rate_multiplier" field.
-func (_u *UsageLogUpdateOne) ClearAccountRateMultiplier() *UsageLogUpdateOne {
-	_u.mutation.ClearAccountRateMultiplier()
-	return _u
-}
-
 // SetBillingType sets the "billing_type" field.
 func (_u *UsageLogUpdateOne) SetBillingType(v int8) *UsageLogUpdateOne {
 	_u.mutation.ResetBillingType()
@@ -1891,15 +1828,6 @@ func (_u *UsageLogUpdateOne) sqlSave(ctx context.Context) (_node *UsageLog, err
 	if value, ok := _u.mutation.AddedRateMultiplier(); ok {
 		_spec.AddField(usagelog.FieldRateMultiplier, field.TypeFloat64, value)
 	}
-	if value, ok := _u.mutation.AccountRateMultiplier(); ok {
-		_spec.SetField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if value, ok := _u.mutation.AddedAccountRateMultiplier(); ok {
-		_spec.AddField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64, value)
-	}
-	if _u.mutation.AccountRateMultiplierCleared() {
-		_spec.ClearField(usagelog.FieldAccountRateMultiplier, field.TypeFloat64)
-	}
 	if value, ok := _u.mutation.BillingType(); ok {
 		_spec.SetField(usagelog.FieldBillingType, field.TypeInt8, value)
 	}

backend/go.mod

@@ -8,11 +8,9 @@ require (
 	github.com/golang-jwt/jwt/v5 v5.2.2
 	github.com/google/uuid v1.6.0
 	github.com/google/wire v0.7.0
-	github.com/gorilla/websocket v1.5.3
 	github.com/imroc/req/v3 v3.57.0
 	github.com/lib/pq v1.10.9
 	github.com/redis/go-redis/v9 v9.17.2
-	github.com/shirou/gopsutil/v4 v4.25.6
 	github.com/spf13/viper v1.18.2
 	github.com/stretchr/testify v1.11.1
 	github.com/testcontainers/testcontainers-go/modules/postgres v0.40.0
@@ -46,13 +44,11 @@ require (
 	github.com/containerd/platforms v0.2.1 // indirect
 	github.com/cpuguy83/dockercfg v0.3.2 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/dgraph-io/ristretto v0.2.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/distribution/reference v0.6.0 // indirect
 	github.com/docker/docker v28.5.1+incompatible // indirect
 	github.com/docker/go-connections v0.6.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/ebitengine/purego v0.8.4 // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
@@ -108,9 +104,9 @@ require (
 	github.com/quic-go/quic-go v0.57.1 // indirect
 	github.com/refraction-networking/utls v1.8.1 // indirect
 	github.com/rivo/uniseg v0.2.0 // indirect
-	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/shirou/gopsutil/v4 v4.25.6 // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect

backend/go.sum

@@ -51,8 +51,6 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgraph-io/ristretto v0.2.0 h1:XAfl+7cmoUDWW/2Lx8TGZQjjxIQ2Ley9DSf52dru4WE=
-github.com/dgraph-io/ristretto v0.2.0/go.mod h1:8uBHCU/PBV4Ag0CJrP47b9Ofby5dqWNh4FicAdoqFNU=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
@@ -63,8 +61,6 @@ github.com/docker/go-connections v0.6.0 h1:LlMG9azAe1TqfR7sO+NJttz1gy6KO7VJBh+pM
 github.com/docker/go-connections v0.6.0/go.mod h1:AahvXYshr6JgfUJGdDCs2b5EZG/vmaMAntpSFH5BFKE=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw=
 github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
@@ -117,8 +113,6 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/wire v0.7.0 h1:JxUKI6+CVBgCO2WToKy/nQk0sS+amI9z9EjVmdaocj4=
 github.com/google/wire v0.7.0/go.mod h1:n6YbUQD9cPKTnHXEBN2DXlOp/mVADhVErcMFb0v3J18=
-github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
@@ -226,8 +220,6 @@ github.com/refraction-networking/utls v1.8.1 h1:yNY1kapmQU8JeM1sSw2H2asfTIwWxIkr
 github.com/refraction-networking/utls v1.8.1/go.mod h1:jkSOEkLqn+S/jtpEHPOsVv/4V4EVnelwbMQl4vCWXAM=
 github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=

backend/internal/config/config.go

@@ -36,29 +36,33 @@ const (
 )
 
 type Config struct {
-	Server       ServerConfig               `mapstructure:"server"`
-	CORS         CORSConfig                 `mapstructure:"cors"`
-	Security     SecurityConfig             `mapstructure:"security"`
-	Billing      BillingConfig              `mapstructure:"billing"`
-	Turnstile    TurnstileConfig            `mapstructure:"turnstile"`
-	Database     DatabaseConfig             `mapstructure:"database"`
-	Redis        RedisConfig                `mapstructure:"redis"`
-	Ops          OpsConfig                  `mapstructure:"ops"`
-	JWT          JWTConfig                  `mapstructure:"jwt"`
-	LinuxDo      LinuxDoConnectConfig       `mapstructure:"linuxdo_connect"`
-	Default      DefaultConfig              `mapstructure:"default"`
-	RateLimit    RateLimitConfig            `mapstructure:"rate_limit"`
-	Pricing      PricingConfig              `mapstructure:"pricing"`
-	Gateway      GatewayConfig              `mapstructure:"gateway"`
-	APIKeyAuth   APIKeyAuthCacheConfig      `mapstructure:"api_key_auth_cache"`
-	Dashboard    DashboardCacheConfig       `mapstructure:"dashboard_cache"`
-	DashboardAgg DashboardAggregationConfig `mapstructure:"dashboard_aggregation"`
-	Concurrency  ConcurrencyConfig          `mapstructure:"concurrency"`
-	TokenRefresh TokenRefreshConfig         `mapstructure:"token_refresh"`
-	RunMode      string                     `mapstructure:"run_mode" yaml:"run_mode"`
-	Timezone     string                     `mapstructure:"timezone"` // e.g. "Asia/Shanghai", "UTC"
-	Gemini       GeminiConfig               `mapstructure:"gemini"`
-	Update       UpdateConfig               `mapstructure:"update"`
+	Server       ServerConfig         `mapstructure:"server"`
+	CORS         CORSConfig           `mapstructure:"cors"`
+	Security     SecurityConfig       `mapstructure:"security"`
+	Billing      BillingConfig        `mapstructure:"billing"`
+	Turnstile    TurnstileConfig      `mapstructure:"turnstile"`
+	Database     DatabaseConfig       `mapstructure:"database"`
+	Redis        RedisConfig          `mapstructure:"redis"`
+	JWT          JWTConfig            `mapstructure:"jwt"`
+	LinuxDo      LinuxDoConnectConfig `mapstructure:"linuxdo_connect"`
+	Default      DefaultConfig        `mapstructure:"default"`
+	RateLimit    RateLimitConfig      `mapstructure:"rate_limit"`
+	Pricing      PricingConfig        `mapstructure:"pricing"`
+	Gateway      GatewayConfig        `mapstructure:"gateway"`
+	Concurrency  ConcurrencyConfig    `mapstructure:"concurrency"`
+	TokenRefresh TokenRefreshConfig   `mapstructure:"token_refresh"`
+	RunMode      string               `mapstructure:"run_mode" yaml:"run_mode"`
+	Timezone     string               `mapstructure:"timezone"` // e.g. "Asia/Shanghai", "UTC"
+	Gemini       GeminiConfig         `mapstructure:"gemini"`
+	Update       UpdateConfig         `mapstructure:"update"`
+}
+
+// UpdateConfig 在线更新相关配置
+type UpdateConfig struct {
+	// ProxyURL 用于访问 GitHub 的代理地址
+	// 支持 http/https/socks5/socks5h 协议
+	// 例如: "http://127.0.0.1:7890", "socks5://127.0.0.1:1080"
+	ProxyURL string `mapstructure:"proxy_url"`
 }
 
 type GeminiConfig struct {
@@ -83,33 +87,6 @@ type GeminiTierQuotaConfig struct {
 	CooldownMinutes *int   `mapstructure:"cooldown_minutes" json:"cooldown_minutes"`
 }
 
-type UpdateConfig struct {
-	// ProxyURL 用于访问 GitHub 的代理地址
-	// 支持 http/https/socks5/socks5h 协议
-	// 例如: "http://127.0.0.1:7890", "socks5://127.0.0.1:1080"
-	ProxyURL string `mapstructure:"proxy_url"`
-}
-
-type LinuxDoConnectConfig struct {
-	Enabled             bool   `mapstructure:"enabled"`
-	ClientID            string `mapstructure:"client_id"`
-	ClientSecret        string `mapstructure:"client_secret"`
-	AuthorizeURL        string `mapstructure:"authorize_url"`
-	TokenURL            string `mapstructure:"token_url"`
-	UserInfoURL         string `mapstructure:"userinfo_url"`
-	Scopes              string `mapstructure:"scopes"`
-	RedirectURL         string `mapstructure:"redirect_url"`          // 后端回调地址（需在提供方后台登记）
-	FrontendRedirectURL string `mapstructure:"frontend_redirect_url"` // 前端接收 token 的路由（默认：/auth/linuxdo/callback）
-	TokenAuthMethod     string `mapstructure:"token_auth_method"`     // client_secret_post / client_secret_basic / none
-	UsePKCE             bool   `mapstructure:"use_pkce"`
-
-	// 可选：用于从 userinfo JSON 中提取字段的 gjson 路径。
-	// 为空时，服务端会尝试一组常见字段名。
-	UserInfoEmailPath    string `mapstructure:"userinfo_email_path"`
-	UserInfoIDPath       string `mapstructure:"userinfo_id_path"`
-	UserInfoUsernamePath string `mapstructure:"userinfo_username_path"`
-}
-
 // TokenRefreshConfig OAuth token自动刷新配置
 type TokenRefreshConfig struct {
 	// 是否启用自动刷新
@@ -270,29 +247,6 @@ type GatewaySchedulingConfig struct {
 
 	// 过期槽位清理周期（0 表示禁用）
 	SlotCleanupInterval time.Duration `mapstructure:"slot_cleanup_interval"`
-
-	// 受控回源配置
-	DbFallbackEnabled bool `mapstructure:"db_fallback_enabled"`
-	// 受控回源超时（秒），0 表示不额外收紧超时
-	DbFallbackTimeoutSeconds int `mapstructure:"db_fallback_timeout_seconds"`
-	// 受控回源限流（实例级 QPS），0 表示不限制
-	DbFallbackMaxQPS int `mapstructure:"db_fallback_max_qps"`
-
-	// Outbox 轮询与滞后阈值配置
-	// Outbox 轮询周期（秒）
-	OutboxPollIntervalSeconds int `mapstructure:"outbox_poll_interval_seconds"`
-	// Outbox 滞后告警阈值（秒）
-	OutboxLagWarnSeconds int `mapstructure:"outbox_lag_warn_seconds"`
-	// Outbox 触发强制重建阈值（秒）
-	OutboxLagRebuildSeconds int `mapstructure:"outbox_lag_rebuild_seconds"`
-	// Outbox 连续滞后触发次数
-	OutboxLagRebuildFailures int `mapstructure:"outbox_lag_rebuild_failures"`
-	// Outbox 积压触发重建阈值（行数）
-	OutboxBacklogRebuildRows int `mapstructure:"outbox_backlog_rebuild_rows"`
-
-	// 全量重建周期配置
-	// 全量重建周期（秒），0 表示禁用
-	FullRebuildIntervalSeconds int `mapstructure:"full_rebuild_interval_seconds"`
 }
 
 func (s *ServerConfig) Address() string {
@@ -375,47 +329,6 @@ func (r *RedisConfig) Address() string {
 	return fmt.Sprintf("%s:%d", r.Host, r.Port)
 }
 
-type OpsConfig struct {
-	// Enabled controls whether ops features should run.
-	//
-	// NOTE: vNext still has a DB-backed feature flag (ops_monitoring_enabled) for runtime on/off.
-	// This config flag is the "hard switch" for deployments that want to disable ops completely.
-	Enabled bool `mapstructure:"enabled"`
-
-	// UsePreaggregatedTables prefers ops_metrics_hourly/daily for long-window dashboard queries.
-	UsePreaggregatedTables bool `mapstructure:"use_preaggregated_tables"`
-
-	// Cleanup controls periodic deletion of old ops data to prevent unbounded growth.
-	Cleanup OpsCleanupConfig `mapstructure:"cleanup"`
-
-	// MetricsCollectorCache controls Redis caching for expensive per-window collector queries.
-	MetricsCollectorCache OpsMetricsCollectorCacheConfig `mapstructure:"metrics_collector_cache"`
-
-	// Pre-aggregation configuration.
-	Aggregation OpsAggregationConfig `mapstructure:"aggregation"`
-}
-
-type OpsCleanupConfig struct {
-	Enabled  bool   `mapstructure:"enabled"`
-	Schedule string `mapstructure:"schedule"`
-
-	// Retention days (0 disables that cleanup target).
-	//
-	// vNext requirement: default 30 days across ops datasets.
-	ErrorLogRetentionDays      int `mapstructure:"error_log_retention_days"`
-	MinuteMetricsRetentionDays int `mapstructure:"minute_metrics_retention_days"`
-	HourlyMetricsRetentionDays int `mapstructure:"hourly_metrics_retention_days"`
-}
-
-type OpsAggregationConfig struct {
-	Enabled bool `mapstructure:"enabled"`
-}
-
-type OpsMetricsCollectorCacheConfig struct {
-	Enabled bool          `mapstructure:"enabled"`
-	TTL     time.Duration `mapstructure:"ttl"`
-}
-
 type JWTConfig struct {
 	Secret     string `mapstructure:"secret"`
 	ExpireHour int    `mapstructure:"expire_hour"`
@@ -425,6 +338,30 @@ type TurnstileConfig struct {
 	Required bool `mapstructure:"required"`
 }
 
+// LinuxDoConnectConfig 用于 LinuxDo Connect OAuth 登录（终端用户 SSO）。
+//
+// 注意：这与上游账号的 OAuth（例如 OpenAI/Gemini 账号接入）不是一回事。
+// 这里是用于登录 Sub2API 本身的用户体系。
+type LinuxDoConnectConfig struct {
+	Enabled             bool   `mapstructure:"enabled"`
+	ClientID            string `mapstructure:"client_id"`
+	ClientSecret        string `mapstructure:"client_secret"`
+	AuthorizeURL        string `mapstructure:"authorize_url"`
+	TokenURL            string `mapstructure:"token_url"`
+	UserInfoURL         string `mapstructure:"userinfo_url"`
+	Scopes              string `mapstructure:"scopes"`
+	RedirectURL         string `mapstructure:"redirect_url"`          // 后端回调地址（需在提供方后台登记）
+	FrontendRedirectURL string `mapstructure:"frontend_redirect_url"` // 前端接收 token 的路由（默认：/auth/linuxdo/callback）
+	TokenAuthMethod     string `mapstructure:"token_auth_method"`     // client_secret_post / client_secret_basic / none
+	UsePKCE             bool   `mapstructure:"use_pkce"`
+
+	// 可选：用于从 userinfo JSON 中提取字段的 gjson 路径。
+	// 为空时，服务端会尝试一组常见字段名。
+	UserInfoEmailPath    string `mapstructure:"userinfo_email_path"`
+	UserInfoIDPath       string `mapstructure:"userinfo_id_path"`
+	UserInfoUsernamePath string `mapstructure:"userinfo_username_path"`
+}
+
 type DefaultConfig struct {
 	AdminEmail      string  `mapstructure:"admin_email"`
 	AdminPassword   string  `mapstructure:"admin_password"`
@@ -438,55 +375,6 @@ type RateLimitConfig struct {
 	OverloadCooldownMinutes int `mapstructure:"overload_cooldown_minutes"` // 529过载冷却时间(分钟)
 }
 
-// APIKeyAuthCacheConfig API Key 认证缓存配置
-type APIKeyAuthCacheConfig struct {
-	L1Size             int  `mapstructure:"l1_size"`
-	L1TTLSeconds       int  `mapstructure:"l1_ttl_seconds"`
-	L2TTLSeconds       int  `mapstructure:"l2_ttl_seconds"`
-	NegativeTTLSeconds int  `mapstructure:"negative_ttl_seconds"`
-	JitterPercent      int  `mapstructure:"jitter_percent"`
-	Singleflight       bool `mapstructure:"singleflight"`
-}
-
-// DashboardCacheConfig 仪表盘统计缓存配置
-type DashboardCacheConfig struct {
-	// Enabled: 是否启用仪表盘缓存
-	Enabled bool `mapstructure:"enabled"`
-	// KeyPrefix: Redis key 前缀，用于多环境隔离
-	KeyPrefix string `mapstructure:"key_prefix"`
-	// StatsFreshTTLSeconds: 缓存命中认为“新鲜”的时间窗口（秒）
-	StatsFreshTTLSeconds int `mapstructure:"stats_fresh_ttl_seconds"`
-	// StatsTTLSeconds: Redis 缓存总 TTL（秒）
-	StatsTTLSeconds int `mapstructure:"stats_ttl_seconds"`
-	// StatsRefreshTimeoutSeconds: 异步刷新超时（秒）
-	StatsRefreshTimeoutSeconds int `mapstructure:"stats_refresh_timeout_seconds"`
-}
-
-// DashboardAggregationConfig 仪表盘预聚合配置
-type DashboardAggregationConfig struct {
-	// Enabled: 是否启用预聚合作业
-	Enabled bool `mapstructure:"enabled"`
-	// IntervalSeconds: 聚合刷新间隔（秒）
-	IntervalSeconds int `mapstructure:"interval_seconds"`
-	// LookbackSeconds: 回看窗口（秒）
-	LookbackSeconds int `mapstructure:"lookback_seconds"`
-	// BackfillEnabled: 是否允许全量回填
-	BackfillEnabled bool `mapstructure:"backfill_enabled"`
-	// BackfillMaxDays: 回填最大跨度（天）
-	BackfillMaxDays int `mapstructure:"backfill_max_days"`
-	// Retention: 各表保留窗口（天）
-	Retention DashboardAggregationRetentionConfig `mapstructure:"retention"`
-	// RecomputeDays: 启动时重算最近 N 天
-	RecomputeDays int `mapstructure:"recompute_days"`
-}
-
-// DashboardAggregationRetentionConfig 预聚合保留窗口
-type DashboardAggregationRetentionConfig struct {
-	UsageLogsDays int `mapstructure:"usage_logs_days"`
-	HourlyDays    int `mapstructure:"hourly_days"`
-	DailyDays     int `mapstructure:"daily_days"`
-}
-
 func NormalizeRunMode(value string) string {
 	normalized := strings.ToLower(strings.TrimSpace(value))
 	switch normalized {
@@ -552,7 +440,6 @@ func Load() (*Config, error) {
 	cfg.LinuxDo.UserInfoEmailPath = strings.TrimSpace(cfg.LinuxDo.UserInfoEmailPath)
 	cfg.LinuxDo.UserInfoIDPath = strings.TrimSpace(cfg.LinuxDo.UserInfoIDPath)
 	cfg.LinuxDo.UserInfoUsernamePath = strings.TrimSpace(cfg.LinuxDo.UserInfoUsernamePath)
-	cfg.Dashboard.KeyPrefix = strings.TrimSpace(cfg.Dashboard.KeyPrefix)
 	cfg.CORS.AllowedOrigins = normalizeStringSlice(cfg.CORS.AllowedOrigins)
 	cfg.Security.ResponseHeaders.AdditionalAllowed = normalizeStringSlice(cfg.Security.ResponseHeaders.AdditionalAllowed)
 	cfg.Security.ResponseHeaders.ForceRemove = normalizeStringSlice(cfg.Security.ResponseHeaders.ForceRemove)
@@ -591,6 +478,81 @@ func Load() (*Config, error) {
 	return &cfg, nil
 }
 
+// ValidateAbsoluteHTTPURL 校验一个绝对 http(s) URL（禁止 fragment）。
+func ValidateAbsoluteHTTPURL(raw string) error {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return fmt.Errorf("empty url")
+	}
+	u, err := url.Parse(raw)
+	if err != nil {
+		return err
+	}
+	if !u.IsAbs() {
+		return fmt.Errorf("must be absolute")
+	}
+	if !isHTTPScheme(u.Scheme) {
+		return fmt.Errorf("unsupported scheme: %s", u.Scheme)
+	}
+	if strings.TrimSpace(u.Host) == "" {
+		return fmt.Errorf("missing host")
+	}
+	if u.Fragment != "" {
+		return fmt.Errorf("must not include fragment")
+	}
+	return nil
+}
+
+// ValidateFrontendRedirectURL 校验前端回调地址：
+// - 允许同源相对路径（以 / 开头）
+// - 或绝对 http(s) URL（禁止 fragment）
+func ValidateFrontendRedirectURL(raw string) error {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return fmt.Errorf("empty url")
+	}
+	if strings.ContainsAny(raw, "\r\n") {
+		return fmt.Errorf("contains invalid characters")
+	}
+	if strings.HasPrefix(raw, "/") {
+		if strings.HasPrefix(raw, "//") {
+			return fmt.Errorf("must not start with //")
+		}
+		return nil
+	}
+	u, err := url.Parse(raw)
+	if err != nil {
+		return err
+	}
+	if !u.IsAbs() {
+		return fmt.Errorf("must be absolute http(s) url or relative path")
+	}
+	if !isHTTPScheme(u.Scheme) {
+		return fmt.Errorf("unsupported scheme: %s", u.Scheme)
+	}
+	if strings.TrimSpace(u.Host) == "" {
+		return fmt.Errorf("missing host")
+	}
+	if u.Fragment != "" {
+		return fmt.Errorf("must not include fragment")
+	}
+	return nil
+}
+
+func isHTTPScheme(scheme string) bool {
+	return strings.EqualFold(scheme, "http") || strings.EqualFold(scheme, "https")
+}
+
+func warnIfInsecureURL(field, raw string) {
+	u, err := url.Parse(strings.TrimSpace(raw))
+	if err != nil {
+		return
+	}
+	if strings.EqualFold(u.Scheme, "http") {
+		log.Printf("Warning: %s uses http scheme; use https in production to avoid token leakage.", field)
+	}
+}
+
 func setDefaults() {
 	viper.SetDefault("run_mode", RunModeStandard)
 
@@ -640,7 +602,7 @@ func setDefaults() {
 	// Turnstile
 	viper.SetDefault("turnstile.required", false)
 
-	// LinuxDo Connect OAuth 登录
+	// LinuxDo Connect OAuth 登录（终端用户 SSO）
 	viper.SetDefault("linuxdo_connect.enabled", false)
 	viper.SetDefault("linuxdo_connect.client_id", "")
 	viper.SetDefault("linuxdo_connect.client_secret", "")
@@ -679,20 +641,6 @@ func setDefaults() {
 	viper.SetDefault("redis.pool_size", 128)
 	viper.SetDefault("redis.min_idle_conns", 10)
 
-	// Ops (vNext)
-	viper.SetDefault("ops.enabled", true)
-	viper.SetDefault("ops.use_preaggregated_tables", false)
-	viper.SetDefault("ops.cleanup.enabled", true)
-	viper.SetDefault("ops.cleanup.schedule", "0 2 * * *")
-	// Retention days: vNext defaults to 30 days across ops datasets.
-	viper.SetDefault("ops.cleanup.error_log_retention_days", 30)
-	viper.SetDefault("ops.cleanup.minute_metrics_retention_days", 30)
-	viper.SetDefault("ops.cleanup.hourly_metrics_retention_days", 30)
-	viper.SetDefault("ops.aggregation.enabled", true)
-	viper.SetDefault("ops.metrics_collector_cache.enabled", true)
-	// TTL should be slightly larger than collection interval (1m) to maximize cross-replica cache hits.
-	viper.SetDefault("ops.metrics_collector_cache.ttl", 65*time.Second)
-
 	// JWT
 	viper.SetDefault("jwt.secret", "")
 	viper.SetDefault("jwt.expire_hour", 24)
@@ -721,35 +669,9 @@ func setDefaults() {
 	// Timezone (default to Asia/Shanghai for Chinese users)
 	viper.SetDefault("timezone", "Asia/Shanghai")
 
-	// API Key auth cache
-	viper.SetDefault("api_key_auth_cache.l1_size", 65535)
-	viper.SetDefault("api_key_auth_cache.l1_ttl_seconds", 15)
-	viper.SetDefault("api_key_auth_cache.l2_ttl_seconds", 300)
-	viper.SetDefault("api_key_auth_cache.negative_ttl_seconds", 30)
-	viper.SetDefault("api_key_auth_cache.jitter_percent", 10)
-	viper.SetDefault("api_key_auth_cache.singleflight", true)
-
-	// Dashboard cache
-	viper.SetDefault("dashboard_cache.enabled", true)
-	viper.SetDefault("dashboard_cache.key_prefix", "sub2api:")
-	viper.SetDefault("dashboard_cache.stats_fresh_ttl_seconds", 15)
-	viper.SetDefault("dashboard_cache.stats_ttl_seconds", 30)
-	viper.SetDefault("dashboard_cache.stats_refresh_timeout_seconds", 30)
-
-	// Dashboard aggregation
-	viper.SetDefault("dashboard_aggregation.enabled", true)
-	viper.SetDefault("dashboard_aggregation.interval_seconds", 60)
-	viper.SetDefault("dashboard_aggregation.lookback_seconds", 120)
-	viper.SetDefault("dashboard_aggregation.backfill_enabled", false)
-	viper.SetDefault("dashboard_aggregation.backfill_max_days", 31)
-	viper.SetDefault("dashboard_aggregation.retention.usage_logs_days", 90)
-	viper.SetDefault("dashboard_aggregation.retention.hourly_days", 180)
-	viper.SetDefault("dashboard_aggregation.retention.daily_days", 730)
-	viper.SetDefault("dashboard_aggregation.recompute_days", 2)
-
 	// Gateway
 	viper.SetDefault("gateway.response_header_timeout", 600) // 600秒(10分钟)等待上游响应头，LLM高负载时可能排队较久
-	viper.SetDefault("gateway.log_upstream_error_body", true)
+	viper.SetDefault("gateway.log_upstream_error_body", false)
 	viper.SetDefault("gateway.log_upstream_error_body_max_bytes", 2048)
 	viper.SetDefault("gateway.inject_beta_for_apikey", false)
 	viper.SetDefault("gateway.failover_on_400", false)
@@ -765,22 +687,13 @@ func setDefaults() {
 	viper.SetDefault("gateway.concurrency_slot_ttl_minutes", 30) // 并发槽位过期时间（支持超长请求）
 	viper.SetDefault("gateway.stream_data_interval_timeout", 180)
 	viper.SetDefault("gateway.stream_keepalive_interval", 10)
-	viper.SetDefault("gateway.max_line_size", 10*1024*1024)
+	viper.SetDefault("gateway.max_line_size", 40*1024*1024)
 	viper.SetDefault("gateway.scheduling.sticky_session_max_waiting", 3)
-	viper.SetDefault("gateway.scheduling.sticky_session_wait_timeout", 120*time.Second)
+	viper.SetDefault("gateway.scheduling.sticky_session_wait_timeout", 45*time.Second)
 	viper.SetDefault("gateway.scheduling.fallback_wait_timeout", 30*time.Second)
 	viper.SetDefault("gateway.scheduling.fallback_max_waiting", 100)
 	viper.SetDefault("gateway.scheduling.load_batch_enabled", true)
 	viper.SetDefault("gateway.scheduling.slot_cleanup_interval", 30*time.Second)
-	viper.SetDefault("gateway.scheduling.db_fallback_enabled", true)
-	viper.SetDefault("gateway.scheduling.db_fallback_timeout_seconds", 0)
-	viper.SetDefault("gateway.scheduling.db_fallback_max_qps", 0)
-	viper.SetDefault("gateway.scheduling.outbox_poll_interval_seconds", 1)
-	viper.SetDefault("gateway.scheduling.outbox_lag_warn_seconds", 5)
-	viper.SetDefault("gateway.scheduling.outbox_lag_rebuild_seconds", 10)
-	viper.SetDefault("gateway.scheduling.outbox_lag_rebuild_failures", 3)
-	viper.SetDefault("gateway.scheduling.outbox_backlog_rebuild_rows", 10000)
-	viper.SetDefault("gateway.scheduling.full_rebuild_interval_seconds", 300)
 	viper.SetDefault("concurrency.ping_interval", 10)
 
 	// TokenRefresh
@@ -797,6 +710,10 @@ func setDefaults() {
 	viper.SetDefault("gemini.oauth.client_secret", "")
 	viper.SetDefault("gemini.oauth.scopes", "")
 	viper.SetDefault("gemini.quota.policy", "")
+
+	// Update - 在线更新配置
+	// 代理地址为空表示直连 GitHub（适用于海外服务器）
+	viper.SetDefault("update.proxy_url", "")
 }
 
 func (c *Config) Validate() error {
@@ -837,8 +754,7 @@ func (c *Config) Validate() error {
 		if method == "none" && !c.LinuxDo.UsePKCE {
 			return fmt.Errorf("linuxdo_connect.use_pkce must be true when linuxdo_connect.token_auth_method=none")
 		}
-		if (method == "" || method == "client_secret_post" || method == "client_secret_basic") &&
-			strings.TrimSpace(c.LinuxDo.ClientSecret) == "" {
+		if (method == "" || method == "client_secret_post" || method == "client_secret_basic") && strings.TrimSpace(c.LinuxDo.ClientSecret) == "" {
 			return fmt.Errorf("linuxdo_connect.client_secret is required when linuxdo_connect.enabled=true and token_auth_method is client_secret_post/client_secret_basic")
 		}
 		if strings.TrimSpace(c.LinuxDo.FrontendRedirectURL) == "" {
@@ -911,78 +827,6 @@ func (c *Config) Validate() error {
 	if c.Redis.MinIdleConns > c.Redis.PoolSize {
 		return fmt.Errorf("redis.min_idle_conns cannot exceed redis.pool_size")
 	}
-	if c.Dashboard.Enabled {
-		if c.Dashboard.StatsFreshTTLSeconds <= 0 {
-			return fmt.Errorf("dashboard_cache.stats_fresh_ttl_seconds must be positive")
-		}
-		if c.Dashboard.StatsTTLSeconds <= 0 {
-			return fmt.Errorf("dashboard_cache.stats_ttl_seconds must be positive")
-		}
-		if c.Dashboard.StatsRefreshTimeoutSeconds <= 0 {
-			return fmt.Errorf("dashboard_cache.stats_refresh_timeout_seconds must be positive")
-		}
-		if c.Dashboard.StatsFreshTTLSeconds > c.Dashboard.StatsTTLSeconds {
-			return fmt.Errorf("dashboard_cache.stats_fresh_ttl_seconds must be <= dashboard_cache.stats_ttl_seconds")
-		}
-	} else {
-		if c.Dashboard.StatsFreshTTLSeconds < 0 {
-			return fmt.Errorf("dashboard_cache.stats_fresh_ttl_seconds must be non-negative")
-		}
-		if c.Dashboard.StatsTTLSeconds < 0 {
-			return fmt.Errorf("dashboard_cache.stats_ttl_seconds must be non-negative")
-		}
-		if c.Dashboard.StatsRefreshTimeoutSeconds < 0 {
-			return fmt.Errorf("dashboard_cache.stats_refresh_timeout_seconds must be non-negative")
-		}
-	}
-	if c.DashboardAgg.Enabled {
-		if c.DashboardAgg.IntervalSeconds <= 0 {
-			return fmt.Errorf("dashboard_aggregation.interval_seconds must be positive")
-		}
-		if c.DashboardAgg.LookbackSeconds < 0 {
-			return fmt.Errorf("dashboard_aggregation.lookback_seconds must be non-negative")
-		}
-		if c.DashboardAgg.BackfillMaxDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.backfill_max_days must be non-negative")
-		}
-		if c.DashboardAgg.BackfillEnabled && c.DashboardAgg.BackfillMaxDays == 0 {
-			return fmt.Errorf("dashboard_aggregation.backfill_max_days must be positive")
-		}
-		if c.DashboardAgg.Retention.UsageLogsDays <= 0 {
-			return fmt.Errorf("dashboard_aggregation.retention.usage_logs_days must be positive")
-		}
-		if c.DashboardAgg.Retention.HourlyDays <= 0 {
-			return fmt.Errorf("dashboard_aggregation.retention.hourly_days must be positive")
-		}
-		if c.DashboardAgg.Retention.DailyDays <= 0 {
-			return fmt.Errorf("dashboard_aggregation.retention.daily_days must be positive")
-		}
-		if c.DashboardAgg.RecomputeDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.recompute_days must be non-negative")
-		}
-	} else {
-		if c.DashboardAgg.IntervalSeconds < 0 {
-			return fmt.Errorf("dashboard_aggregation.interval_seconds must be non-negative")
-		}
-		if c.DashboardAgg.LookbackSeconds < 0 {
-			return fmt.Errorf("dashboard_aggregation.lookback_seconds must be non-negative")
-		}
-		if c.DashboardAgg.BackfillMaxDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.backfill_max_days must be non-negative")
-		}
-		if c.DashboardAgg.Retention.UsageLogsDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.retention.usage_logs_days must be non-negative")
-		}
-		if c.DashboardAgg.Retention.HourlyDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.retention.hourly_days must be non-negative")
-		}
-		if c.DashboardAgg.Retention.DailyDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.retention.daily_days must be non-negative")
-		}
-		if c.DashboardAgg.RecomputeDays < 0 {
-			return fmt.Errorf("dashboard_aggregation.recompute_days must be non-negative")
-		}
-	}
 	if c.Gateway.MaxBodySize <= 0 {
 		return fmt.Errorf("gateway.max_body_size must be positive")
 	}
@@ -1053,50 +897,6 @@ func (c *Config) Validate() error {
 	if c.Gateway.Scheduling.SlotCleanupInterval < 0 {
 		return fmt.Errorf("gateway.scheduling.slot_cleanup_interval must be non-negative")
 	}
-	if c.Gateway.Scheduling.DbFallbackTimeoutSeconds < 0 {
-		return fmt.Errorf("gateway.scheduling.db_fallback_timeout_seconds must be non-negative")
-	}
-	if c.Gateway.Scheduling.DbFallbackMaxQPS < 0 {
-		return fmt.Errorf("gateway.scheduling.db_fallback_max_qps must be non-negative")
-	}
-	if c.Gateway.Scheduling.OutboxPollIntervalSeconds <= 0 {
-		return fmt.Errorf("gateway.scheduling.outbox_poll_interval_seconds must be positive")
-	}
-	if c.Gateway.Scheduling.OutboxLagWarnSeconds < 0 {
-		return fmt.Errorf("gateway.scheduling.outbox_lag_warn_seconds must be non-negative")
-	}
-	if c.Gateway.Scheduling.OutboxLagRebuildSeconds < 0 {
-		return fmt.Errorf("gateway.scheduling.outbox_lag_rebuild_seconds must be non-negative")
-	}
-	if c.Gateway.Scheduling.OutboxLagRebuildFailures <= 0 {
-		return fmt.Errorf("gateway.scheduling.outbox_lag_rebuild_failures must be positive")
-	}
-	if c.Gateway.Scheduling.OutboxBacklogRebuildRows < 0 {
-		return fmt.Errorf("gateway.scheduling.outbox_backlog_rebuild_rows must be non-negative")
-	}
-	if c.Gateway.Scheduling.FullRebuildIntervalSeconds < 0 {
-		return fmt.Errorf("gateway.scheduling.full_rebuild_interval_seconds must be non-negative")
-	}
-	if c.Gateway.Scheduling.OutboxLagWarnSeconds > 0 &&
-		c.Gateway.Scheduling.OutboxLagRebuildSeconds > 0 &&
-		c.Gateway.Scheduling.OutboxLagRebuildSeconds < c.Gateway.Scheduling.OutboxLagWarnSeconds {
-		return fmt.Errorf("gateway.scheduling.outbox_lag_rebuild_seconds must be >= outbox_lag_warn_seconds")
-	}
-	if c.Ops.MetricsCollectorCache.TTL < 0 {
-		return fmt.Errorf("ops.metrics_collector_cache.ttl must be non-negative")
-	}
-	if c.Ops.Cleanup.ErrorLogRetentionDays < 0 {
-		return fmt.Errorf("ops.cleanup.error_log_retention_days must be non-negative")
-	}
-	if c.Ops.Cleanup.MinuteMetricsRetentionDays < 0 {
-		return fmt.Errorf("ops.cleanup.minute_metrics_retention_days must be non-negative")
-	}
-	if c.Ops.Cleanup.HourlyMetricsRetentionDays < 0 {
-		return fmt.Errorf("ops.cleanup.hourly_metrics_retention_days must be non-negative")
-	}
-	if c.Ops.Cleanup.Enabled && strings.TrimSpace(c.Ops.Cleanup.Schedule) == "" {
-		return fmt.Errorf("ops.cleanup.schedule is required when ops.cleanup.enabled=true")
-	}
 	if c.Concurrency.PingInterval < 5 || c.Concurrency.PingInterval > 30 {
 		return fmt.Errorf("concurrency.ping_interval must be between 5-30 seconds")
 	}
@@ -1173,77 +973,3 @@ func GetServerAddress() string {
 	port := v.GetInt("server.port")
 	return fmt.Sprintf("%s:%d", host, port)
 }
-
-// ValidateAbsoluteHTTPURL 验证是否为有效的绝对 HTTP(S) URL
-func ValidateAbsoluteHTTPURL(raw string) error {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return fmt.Errorf("empty url")
-	}
-	u, err := url.Parse(raw)
-	if err != nil {
-		return err
-	}
-	if !u.IsAbs() {
-		return fmt.Errorf("must be absolute")
-	}
-	if !isHTTPScheme(u.Scheme) {
-		return fmt.Errorf("unsupported scheme: %s", u.Scheme)
-	}
-	if strings.TrimSpace(u.Host) == "" {
-		return fmt.Errorf("missing host")
-	}
-	if u.Fragment != "" {
-		return fmt.Errorf("must not include fragment")
-	}
-	return nil
-}
-
-// ValidateFrontendRedirectURL 验证前端重定向 URL（可以是绝对 URL 或相对路径）
-func ValidateFrontendRedirectURL(raw string) error {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return fmt.Errorf("empty url")
-	}
-	if strings.ContainsAny(raw, "\r\n") {
-		return fmt.Errorf("contains invalid characters")
-	}
-	if strings.HasPrefix(raw, "/") {
-		if strings.HasPrefix(raw, "//") {
-			return fmt.Errorf("must not start with //")
-		}
-		return nil
-	}
-	u, err := url.Parse(raw)
-	if err != nil {
-		return err
-	}
-	if !u.IsAbs() {
-		return fmt.Errorf("must be absolute http(s) url or relative path")
-	}
-	if !isHTTPScheme(u.Scheme) {
-		return fmt.Errorf("unsupported scheme: %s", u.Scheme)
-	}
-	if strings.TrimSpace(u.Host) == "" {
-		return fmt.Errorf("missing host")
-	}
-	if u.Fragment != "" {
-		return fmt.Errorf("must not include fragment")
-	}
-	return nil
-}
-
-// isHTTPScheme 检查是否为 HTTP 或 HTTPS 协议
-func isHTTPScheme(scheme string) bool {
-	return strings.EqualFold(scheme, "http") || strings.EqualFold(scheme, "https")
-}
-
-func warnIfInsecureURL(field, raw string) {
-	u, err := url.Parse(strings.TrimSpace(raw))
-	if err != nil {
-		return
-	}
-	if strings.EqualFold(u.Scheme, "http") {
-		log.Printf("Warning: %s uses http scheme; use https in production to avoid token leakage.", field)
-	}
-}

backend/internal/config/config_test.go

@@ -39,8 +39,8 @@ func TestLoadDefaultSchedulingConfig(t *testing.T) {
 	if cfg.Gateway.Scheduling.StickySessionMaxWaiting != 3 {
 		t.Fatalf("StickySessionMaxWaiting = %d, want 3", cfg.Gateway.Scheduling.StickySessionMaxWaiting)
 	}
-	if cfg.Gateway.Scheduling.StickySessionWaitTimeout != 120*time.Second {
-		t.Fatalf("StickySessionWaitTimeout = %v, want 120s", cfg.Gateway.Scheduling.StickySessionWaitTimeout)
+	if cfg.Gateway.Scheduling.StickySessionWaitTimeout != 45*time.Second {
+		t.Fatalf("StickySessionWaitTimeout = %v, want 45s", cfg.Gateway.Scheduling.StickySessionWaitTimeout)
 	}
 	if cfg.Gateway.Scheduling.FallbackWaitTimeout != 30*time.Second {
 		t.Fatalf("FallbackWaitTimeout = %v, want 30s", cfg.Gateway.Scheduling.FallbackWaitTimeout)
@@ -141,142 +141,3 @@ func TestValidateLinuxDoPKCERequiredForPublicClient(t *testing.T) {
 		t.Fatalf("Validate() expected use_pkce error, got: %v", err)
 	}
 }
-
-func TestLoadDefaultDashboardCacheConfig(t *testing.T) {
-	viper.Reset()
-
-	cfg, err := Load()
-	if err != nil {
-		t.Fatalf("Load() error: %v", err)
-	}
-
-	if !cfg.Dashboard.Enabled {
-		t.Fatalf("Dashboard.Enabled = false, want true")
-	}
-	if cfg.Dashboard.KeyPrefix != "sub2api:" {
-		t.Fatalf("Dashboard.KeyPrefix = %q, want %q", cfg.Dashboard.KeyPrefix, "sub2api:")
-	}
-	if cfg.Dashboard.StatsFreshTTLSeconds != 15 {
-		t.Fatalf("Dashboard.StatsFreshTTLSeconds = %d, want 15", cfg.Dashboard.StatsFreshTTLSeconds)
-	}
-	if cfg.Dashboard.StatsTTLSeconds != 30 {
-		t.Fatalf("Dashboard.StatsTTLSeconds = %d, want 30", cfg.Dashboard.StatsTTLSeconds)
-	}
-	if cfg.Dashboard.StatsRefreshTimeoutSeconds != 30 {
-		t.Fatalf("Dashboard.StatsRefreshTimeoutSeconds = %d, want 30", cfg.Dashboard.StatsRefreshTimeoutSeconds)
-	}
-}
-
-func TestValidateDashboardCacheConfigEnabled(t *testing.T) {
-	viper.Reset()
-
-	cfg, err := Load()
-	if err != nil {
-		t.Fatalf("Load() error: %v", err)
-	}
-
-	cfg.Dashboard.Enabled = true
-	cfg.Dashboard.StatsFreshTTLSeconds = 10
-	cfg.Dashboard.StatsTTLSeconds = 5
-	err = cfg.Validate()
-	if err == nil {
-		t.Fatalf("Validate() expected error for stats_fresh_ttl_seconds > stats_ttl_seconds, got nil")
-	}
-	if !strings.Contains(err.Error(), "dashboard_cache.stats_fresh_ttl_seconds") {
-		t.Fatalf("Validate() expected stats_fresh_ttl_seconds error, got: %v", err)
-	}
-}
-
-func TestValidateDashboardCacheConfigDisabled(t *testing.T) {
-	viper.Reset()
-
-	cfg, err := Load()
-	if err != nil {
-		t.Fatalf("Load() error: %v", err)
-	}
-
-	cfg.Dashboard.Enabled = false
-	cfg.Dashboard.StatsTTLSeconds = -1
-	err = cfg.Validate()
-	if err == nil {
-		t.Fatalf("Validate() expected error for negative stats_ttl_seconds, got nil")
-	}
-	if !strings.Contains(err.Error(), "dashboard_cache.stats_ttl_seconds") {
-		t.Fatalf("Validate() expected stats_ttl_seconds error, got: %v", err)
-	}
-}
-
-func TestLoadDefaultDashboardAggregationConfig(t *testing.T) {
-	viper.Reset()
-
-	cfg, err := Load()
-	if err != nil {
-		t.Fatalf("Load() error: %v", err)
-	}
-
-	if !cfg.DashboardAgg.Enabled {
-		t.Fatalf("DashboardAgg.Enabled = false, want true")
-	}
-	if cfg.DashboardAgg.IntervalSeconds != 60 {
-		t.Fatalf("DashboardAgg.IntervalSeconds = %d, want 60", cfg.DashboardAgg.IntervalSeconds)
-	}
-	if cfg.DashboardAgg.LookbackSeconds != 120 {
-		t.Fatalf("DashboardAgg.LookbackSeconds = %d, want 120", cfg.DashboardAgg.LookbackSeconds)
-	}
-	if cfg.DashboardAgg.BackfillEnabled {
-		t.Fatalf("DashboardAgg.BackfillEnabled = true, want false")
-	}
-	if cfg.DashboardAgg.BackfillMaxDays != 31 {
-		t.Fatalf("DashboardAgg.BackfillMaxDays = %d, want 31", cfg.DashboardAgg.BackfillMaxDays)
-	}
-	if cfg.DashboardAgg.Retention.UsageLogsDays != 90 {
-		t.Fatalf("DashboardAgg.Retention.UsageLogsDays = %d, want 90", cfg.DashboardAgg.Retention.UsageLogsDays)
-	}
-	if cfg.DashboardAgg.Retention.HourlyDays != 180 {
-		t.Fatalf("DashboardAgg.Retention.HourlyDays = %d, want 180", cfg.DashboardAgg.Retention.HourlyDays)
-	}
-	if cfg.DashboardAgg.Retention.DailyDays != 730 {
-		t.Fatalf("DashboardAgg.Retention.DailyDays = %d, want 730", cfg.DashboardAgg.Retention.DailyDays)
-	}
-	if cfg.DashboardAgg.RecomputeDays != 2 {
-		t.Fatalf("DashboardAgg.RecomputeDays = %d, want 2", cfg.DashboardAgg.RecomputeDays)
-	}
-}
-
-func TestValidateDashboardAggregationConfigDisabled(t *testing.T) {
-	viper.Reset()
-
-	cfg, err := Load()
-	if err != nil {
-		t.Fatalf("Load() error: %v", err)
-	}
-
-	cfg.DashboardAgg.Enabled = false
-	cfg.DashboardAgg.IntervalSeconds = -1
-	err = cfg.Validate()
-	if err == nil {
-		t.Fatalf("Validate() expected error for negative dashboard_aggregation.interval_seconds, got nil")
-	}
-	if !strings.Contains(err.Error(), "dashboard_aggregation.interval_seconds") {
-		t.Fatalf("Validate() expected interval_seconds error, got: %v", err)
-	}
-}
-
-func TestValidateDashboardAggregationBackfillMaxDays(t *testing.T) {
-	viper.Reset()
-
-	cfg, err := Load()
-	if err != nil {
-		t.Fatalf("Load() error: %v", err)
-	}
-
-	cfg.DashboardAgg.BackfillEnabled = true
-	cfg.DashboardAgg.BackfillMaxDays = 0
-	err = cfg.Validate()
-	if err == nil {
-		t.Fatalf("Validate() expected error for dashboard_aggregation.backfill_max_days, got nil")
-	}
-	if !strings.Contains(err.Error(), "dashboard_aggregation.backfill_max_days") {
-		t.Fatalf("Validate() expected backfill_max_days error, got: %v", err)
-	}
-}

backend/internal/handler/admin/account_handler.go

@@ -84,7 +84,6 @@ type CreateAccountRequest struct {
 	ProxyID                 *int64         `json:"proxy_id"`
 	Concurrency             int            `json:"concurrency"`
 	Priority                int            `json:"priority"`
-	RateMultiplier          *float64       `json:"rate_multiplier"`
 	GroupIDs                []int64        `json:"group_ids"`
 	ExpiresAt               *int64         `json:"expires_at"`
 	AutoPauseOnExpired      *bool          `json:"auto_pause_on_expired"`
@@ -102,7 +101,6 @@ type UpdateAccountRequest struct {
 	ProxyID                 *int64         `json:"proxy_id"`
 	Concurrency             *int           `json:"concurrency"`
 	Priority                *int           `json:"priority"`
-	RateMultiplier          *float64       `json:"rate_multiplier"`
 	Status                  string         `json:"status" binding:"omitempty,oneof=active inactive"`
 	GroupIDs                *[]int64       `json:"group_ids"`
 	ExpiresAt               *int64         `json:"expires_at"`
@@ -117,7 +115,6 @@ type BulkUpdateAccountsRequest struct {
 	ProxyID                 *int64         `json:"proxy_id"`
 	Concurrency             *int           `json:"concurrency"`
 	Priority                *int           `json:"priority"`
-	RateMultiplier          *float64       `json:"rate_multiplier"`
 	Status                  string         `json:"status" binding:"omitempty,oneof=active inactive error"`
 	Schedulable             *bool          `json:"schedulable"`
 	GroupIDs                *[]int64       `json:"group_ids"`
@@ -202,10 +199,6 @@ func (h *AccountHandler) Create(c *gin.Context) {
 		response.BadRequest(c, "Invalid request: "+err.Error())
 		return
 	}
-	if req.RateMultiplier != nil && *req.RateMultiplier < 0 {
-		response.BadRequest(c, "rate_multiplier must be >= 0")
-		return
-	}
 
 	// 确定是否跳过混合渠道检查
 	skipCheck := req.ConfirmMixedChannelRisk != nil && *req.ConfirmMixedChannelRisk
@@ -220,7 +213,6 @@ func (h *AccountHandler) Create(c *gin.Context) {
 		ProxyID:               req.ProxyID,
 		Concurrency:           req.Concurrency,
 		Priority:              req.Priority,
-		RateMultiplier:        req.RateMultiplier,
 		GroupIDs:              req.GroupIDs,
 		ExpiresAt:             req.ExpiresAt,
 		AutoPauseOnExpired:    req.AutoPauseOnExpired,
@@ -266,10 +258,6 @@ func (h *AccountHandler) Update(c *gin.Context) {
 		response.BadRequest(c, "Invalid request: "+err.Error())
 		return
 	}
-	if req.RateMultiplier != nil && *req.RateMultiplier < 0 {
-		response.BadRequest(c, "rate_multiplier must be >= 0")
-		return
-	}
 
 	// 确定是否跳过混合渠道检查
 	skipCheck := req.ConfirmMixedChannelRisk != nil && *req.ConfirmMixedChannelRisk
@@ -283,7 +271,6 @@ func (h *AccountHandler) Update(c *gin.Context) {
 		ProxyID:               req.ProxyID,
 		Concurrency:           req.Concurrency, // 指针类型，nil 表示未提供
 		Priority:              req.Priority,    // 指针类型，nil 表示未提供
-		RateMultiplier:        req.RateMultiplier,
 		Status:                req.Status,
 		GroupIDs:              req.GroupIDs,
 		ExpiresAt:             req.ExpiresAt,
@@ -665,10 +652,6 @@ func (h *AccountHandler) BulkUpdate(c *gin.Context) {
 		response.BadRequest(c, "Invalid request: "+err.Error())
 		return
 	}
-	if req.RateMultiplier != nil && *req.RateMultiplier < 0 {
-		response.BadRequest(c, "rate_multiplier must be >= 0")
-		return
-	}
 
 	// 确定是否跳过混合渠道检查
 	skipCheck := req.ConfirmMixedChannelRisk != nil && *req.ConfirmMixedChannelRisk
@@ -677,7 +660,6 @@ func (h *AccountHandler) BulkUpdate(c *gin.Context) {
 		req.ProxyID != nil ||
 		req.Concurrency != nil ||
 		req.Priority != nil ||
-		req.RateMultiplier != nil ||
 		req.Status != "" ||
 		req.Schedulable != nil ||
 		req.GroupIDs != nil ||
@@ -695,7 +677,6 @@ func (h *AccountHandler) BulkUpdate(c *gin.Context) {
 		ProxyID:               req.ProxyID,
 		Concurrency:           req.Concurrency,
 		Priority:              req.Priority,
-		RateMultiplier:        req.RateMultiplier,
 		Status:                req.Status,
 		Schedulable:           req.Schedulable,
 		GroupIDs:              req.GroupIDs,

backend/internal/handler/admin/dashboard_handler.go

@@ -1,7 +1,6 @@
 package admin
 
 import (
-	"errors"
 	"strconv"
 	"time"
 
@@ -14,17 +13,15 @@ import (
 
 // DashboardHandler handles admin dashboard statistics
 type DashboardHandler struct {
-	dashboardService   *service.DashboardService
-	aggregationService *service.DashboardAggregationService
-	startTime          time.Time // Server start time for uptime calculation
+	dashboardService *service.DashboardService
+	startTime        time.Time // Server start time for uptime calculation
 }
 
 // NewDashboardHandler creates a new admin dashboard handler
-func NewDashboardHandler(dashboardService *service.DashboardService, aggregationService *service.DashboardAggregationService) *DashboardHandler {
+func NewDashboardHandler(dashboardService *service.DashboardService) *DashboardHandler {
 	return &DashboardHandler{
-		dashboardService:   dashboardService,
-		aggregationService: aggregationService,
-		startTime:          time.Now(),
+		dashboardService: dashboardService,
+		startTime:        time.Now(),
 	}
 }
 
@@ -117,58 +114,6 @@ func (h *DashboardHandler) GetStats(c *gin.Context) {
 		// 性能指标
 		"rpm": stats.Rpm,
 		"tpm": stats.Tpm,
-
-		// 预聚合新鲜度
-		"hourly_active_users": stats.HourlyActiveUsers,
-		"stats_updated_at":    stats.StatsUpdatedAt,
-		"stats_stale":         stats.StatsStale,
-	})
-}
-
-type DashboardAggregationBackfillRequest struct {
-	Start string `json:"start"`
-	End   string `json:"end"`
-}
-
-// BackfillAggregation handles triggering aggregation backfill
-// POST /api/v1/admin/dashboard/aggregation/backfill
-func (h *DashboardHandler) BackfillAggregation(c *gin.Context) {
-	if h.aggregationService == nil {
-		response.InternalError(c, "Aggregation service not available")
-		return
-	}
-
-	var req DashboardAggregationBackfillRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-	start, err := time.Parse(time.RFC3339, req.Start)
-	if err != nil {
-		response.BadRequest(c, "Invalid start time")
-		return
-	}
-	end, err := time.Parse(time.RFC3339, req.End)
-	if err != nil {
-		response.BadRequest(c, "Invalid end time")
-		return
-	}
-
-	if err := h.aggregationService.TriggerBackfill(start, end); err != nil {
-		if errors.Is(err, service.ErrDashboardBackfillDisabled) {
-			response.Forbidden(c, "Backfill is disabled")
-			return
-		}
-		if errors.Is(err, service.ErrDashboardBackfillTooLarge) {
-			response.BadRequest(c, "Backfill range too large")
-			return
-		}
-		response.InternalError(c, "Failed to trigger backfill")
-		return
-	}
-
-	response.Success(c, gin.H{
-		"status": "accepted",
 	})
 }
 
@@ -186,16 +131,13 @@ func (h *DashboardHandler) GetRealtimeMetrics(c *gin.Context) {
 
 // GetUsageTrend handles getting usage trend data
 // GET /api/v1/admin/dashboard/trend
-// Query params: start_date, end_date (YYYY-MM-DD), granularity (day/hour), user_id, api_key_id, model, account_id, group_id, stream
+// Query params: start_date, end_date (YYYY-MM-DD), granularity (day/hour), user_id, api_key_id
 func (h *DashboardHandler) GetUsageTrend(c *gin.Context) {
 	startTime, endTime := parseTimeRange(c)
 	granularity := c.DefaultQuery("granularity", "day")
 
 	// Parse optional filter params
-	var userID, apiKeyID, accountID, groupID int64
-	var model string
-	var stream *bool
-
+	var userID, apiKeyID int64
 	if userIDStr := c.Query("user_id"); userIDStr != "" {
 		if id, err := strconv.ParseInt(userIDStr, 10, 64); err == nil {
 			userID = id
@@ -206,26 +148,8 @@ func (h *DashboardHandler) GetUsageTrend(c *gin.Context) {
 			apiKeyID = id
 		}
 	}
-	if accountIDStr := c.Query("account_id"); accountIDStr != "" {
-		if id, err := strconv.ParseInt(accountIDStr, 10, 64); err == nil {
-			accountID = id
-		}
-	}
-	if groupIDStr := c.Query("group_id"); groupIDStr != "" {
-		if id, err := strconv.ParseInt(groupIDStr, 10, 64); err == nil {
-			groupID = id
-		}
-	}
-	if modelStr := c.Query("model"); modelStr != "" {
-		model = modelStr
-	}
-	if streamStr := c.Query("stream"); streamStr != "" {
-		if streamVal, err := strconv.ParseBool(streamStr); err == nil {
-			stream = &streamVal
-		}
-	}
 
-	trend, err := h.dashboardService.GetUsageTrendWithFilters(c.Request.Context(), startTime, endTime, granularity, userID, apiKeyID, accountID, groupID, model, stream)
+	trend, err := h.dashboardService.GetUsageTrendWithFilters(c.Request.Context(), startTime, endTime, granularity, userID, apiKeyID)
 	if err != nil {
 		response.Error(c, 500, "Failed to get usage trend")
 		return
@@ -241,14 +165,12 @@ func (h *DashboardHandler) GetUsageTrend(c *gin.Context) {
 
 // GetModelStats handles getting model usage statistics
 // GET /api/v1/admin/dashboard/models
-// Query params: start_date, end_date (YYYY-MM-DD), user_id, api_key_id, account_id, group_id, stream
+// Query params: start_date, end_date (YYYY-MM-DD), user_id, api_key_id
 func (h *DashboardHandler) GetModelStats(c *gin.Context) {
 	startTime, endTime := parseTimeRange(c)
 
 	// Parse optional filter params
-	var userID, apiKeyID, accountID, groupID int64
-	var stream *bool
-
+	var userID, apiKeyID int64
 	if userIDStr := c.Query("user_id"); userIDStr != "" {
 		if id, err := strconv.ParseInt(userIDStr, 10, 64); err == nil {
 			userID = id
@@ -259,23 +181,8 @@ func (h *DashboardHandler) GetModelStats(c *gin.Context) {
 			apiKeyID = id
 		}
 	}
-	if accountIDStr := c.Query("account_id"); accountIDStr != "" {
-		if id, err := strconv.ParseInt(accountIDStr, 10, 64); err == nil {
-			accountID = id
-		}
-	}
-	if groupIDStr := c.Query("group_id"); groupIDStr != "" {
-		if id, err := strconv.ParseInt(groupIDStr, 10, 64); err == nil {
-			groupID = id
-		}
-	}
-	if streamStr := c.Query("stream"); streamStr != "" {
-		if streamVal, err := strconv.ParseBool(streamStr); err == nil {
-			stream = &streamVal
-		}
-	}
 
-	stats, err := h.dashboardService.GetModelStatsWithFilters(c.Request.Context(), startTime, endTime, userID, apiKeyID, accountID, groupID, stream)
+	stats, err := h.dashboardService.GetModelStatsWithFilters(c.Request.Context(), startTime, endTime, userID, apiKeyID)
 	if err != nil {
 		response.Error(c, 500, "Failed to get model statistics")
 		return

backend/internal/handler/admin/ops_alerts_handler.go

@@ -1,602 +0,0 @@
-package admin
-
-import (
-	"encoding/json"
-	"fmt"
-	"math"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/response"
-	"github.com/Wei-Shaw/sub2api/internal/server/middleware"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/gin-gonic/gin"
-	"github.com/gin-gonic/gin/binding"
-)
-
-var validOpsAlertMetricTypes = []string{
-	"success_rate",
-	"error_rate",
-	"upstream_error_rate",
-	"cpu_usage_percent",
-	"memory_usage_percent",
-	"concurrency_queue_depth",
-}
-
-var validOpsAlertMetricTypeSet = func() map[string]struct{} {
-	set := make(map[string]struct{}, len(validOpsAlertMetricTypes))
-	for _, v := range validOpsAlertMetricTypes {
-		set[v] = struct{}{}
-	}
-	return set
-}()
-
-var validOpsAlertOperators = []string{">", "<", ">=", "<=", "==", "!="}
-
-var validOpsAlertOperatorSet = func() map[string]struct{} {
-	set := make(map[string]struct{}, len(validOpsAlertOperators))
-	for _, v := range validOpsAlertOperators {
-		set[v] = struct{}{}
-	}
-	return set
-}()
-
-var validOpsAlertSeverities = []string{"P0", "P1", "P2", "P3"}
-
-var validOpsAlertSeveritySet = func() map[string]struct{} {
-	set := make(map[string]struct{}, len(validOpsAlertSeverities))
-	for _, v := range validOpsAlertSeverities {
-		set[v] = struct{}{}
-	}
-	return set
-}()
-
-type opsAlertRuleValidatedInput struct {
-	Name       string
-	MetricType string
-	Operator   string
-	Threshold  float64
-
-	Severity string
-
-	WindowMinutes    int
-	SustainedMinutes int
-	CooldownMinutes  int
-
-	Enabled     bool
-	NotifyEmail bool
-
-	WindowProvided    bool
-	SustainedProvided bool
-	CooldownProvided  bool
-	SeverityProvided  bool
-	EnabledProvided   bool
-	NotifyProvided    bool
-}
-
-func isPercentOrRateMetric(metricType string) bool {
-	switch metricType {
-	case "success_rate",
-		"error_rate",
-		"upstream_error_rate",
-		"cpu_usage_percent",
-		"memory_usage_percent":
-		return true
-	default:
-		return false
-	}
-}
-
-func validateOpsAlertRulePayload(raw map[string]json.RawMessage) (*opsAlertRuleValidatedInput, error) {
-	if raw == nil {
-		return nil, fmt.Errorf("invalid request body")
-	}
-
-	requiredFields := []string{"name", "metric_type", "operator", "threshold"}
-	for _, field := range requiredFields {
-		if _, ok := raw[field]; !ok {
-			return nil, fmt.Errorf("%s is required", field)
-		}
-	}
-
-	var name string
-	if err := json.Unmarshal(raw["name"], &name); err != nil || strings.TrimSpace(name) == "" {
-		return nil, fmt.Errorf("name is required")
-	}
-	name = strings.TrimSpace(name)
-
-	var metricType string
-	if err := json.Unmarshal(raw["metric_type"], &metricType); err != nil || strings.TrimSpace(metricType) == "" {
-		return nil, fmt.Errorf("metric_type is required")
-	}
-	metricType = strings.TrimSpace(metricType)
-	if _, ok := validOpsAlertMetricTypeSet[metricType]; !ok {
-		return nil, fmt.Errorf("metric_type must be one of: %s", strings.Join(validOpsAlertMetricTypes, ", "))
-	}
-
-	var operator string
-	if err := json.Unmarshal(raw["operator"], &operator); err != nil || strings.TrimSpace(operator) == "" {
-		return nil, fmt.Errorf("operator is required")
-	}
-	operator = strings.TrimSpace(operator)
-	if _, ok := validOpsAlertOperatorSet[operator]; !ok {
-		return nil, fmt.Errorf("operator must be one of: %s", strings.Join(validOpsAlertOperators, ", "))
-	}
-
-	var threshold float64
-	if err := json.Unmarshal(raw["threshold"], &threshold); err != nil {
-		return nil, fmt.Errorf("threshold must be a number")
-	}
-	if math.IsNaN(threshold) || math.IsInf(threshold, 0) {
-		return nil, fmt.Errorf("threshold must be a finite number")
-	}
-	if isPercentOrRateMetric(metricType) {
-		if threshold < 0 || threshold > 100 {
-			return nil, fmt.Errorf("threshold must be between 0 and 100 for metric_type %s", metricType)
-		}
-	} else if threshold < 0 {
-		return nil, fmt.Errorf("threshold must be >= 0")
-	}
-
-	validated := &opsAlertRuleValidatedInput{
-		Name:       name,
-		MetricType: metricType,
-		Operator:   operator,
-		Threshold:  threshold,
-	}
-
-	if v, ok := raw["severity"]; ok {
-		validated.SeverityProvided = true
-		var sev string
-		if err := json.Unmarshal(v, &sev); err != nil {
-			return nil, fmt.Errorf("severity must be a string")
-		}
-		sev = strings.ToUpper(strings.TrimSpace(sev))
-		if sev != "" {
-			if _, ok := validOpsAlertSeveritySet[sev]; !ok {
-				return nil, fmt.Errorf("severity must be one of: %s", strings.Join(validOpsAlertSeverities, ", "))
-			}
-			validated.Severity = sev
-		}
-	}
-	if validated.Severity == "" {
-		validated.Severity = "P2"
-	}
-
-	if v, ok := raw["enabled"]; ok {
-		validated.EnabledProvided = true
-		if err := json.Unmarshal(v, &validated.Enabled); err != nil {
-			return nil, fmt.Errorf("enabled must be a boolean")
-		}
-	} else {
-		validated.Enabled = true
-	}
-
-	if v, ok := raw["notify_email"]; ok {
-		validated.NotifyProvided = true
-		if err := json.Unmarshal(v, &validated.NotifyEmail); err != nil {
-			return nil, fmt.Errorf("notify_email must be a boolean")
-		}
-	} else {
-		validated.NotifyEmail = true
-	}
-
-	if v, ok := raw["window_minutes"]; ok {
-		validated.WindowProvided = true
-		if err := json.Unmarshal(v, &validated.WindowMinutes); err != nil {
-			return nil, fmt.Errorf("window_minutes must be an integer")
-		}
-		switch validated.WindowMinutes {
-		case 1, 5, 60:
-		default:
-			return nil, fmt.Errorf("window_minutes must be one of: 1, 5, 60")
-		}
-	} else {
-		validated.WindowMinutes = 1
-	}
-
-	if v, ok := raw["sustained_minutes"]; ok {
-		validated.SustainedProvided = true
-		if err := json.Unmarshal(v, &validated.SustainedMinutes); err != nil {
-			return nil, fmt.Errorf("sustained_minutes must be an integer")
-		}
-		if validated.SustainedMinutes < 1 || validated.SustainedMinutes > 1440 {
-			return nil, fmt.Errorf("sustained_minutes must be between 1 and 1440")
-		}
-	} else {
-		validated.SustainedMinutes = 1
-	}
-
-	if v, ok := raw["cooldown_minutes"]; ok {
-		validated.CooldownProvided = true
-		if err := json.Unmarshal(v, &validated.CooldownMinutes); err != nil {
-			return nil, fmt.Errorf("cooldown_minutes must be an integer")
-		}
-		if validated.CooldownMinutes < 0 || validated.CooldownMinutes > 1440 {
-			return nil, fmt.Errorf("cooldown_minutes must be between 0 and 1440")
-		}
-	} else {
-		validated.CooldownMinutes = 0
-	}
-
-	return validated, nil
-}
-
-// ListAlertRules returns all ops alert rules.
-// GET /api/v1/admin/ops/alert-rules
-func (h *OpsHandler) ListAlertRules(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	rules, err := h.opsService.ListAlertRules(c.Request.Context())
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, rules)
-}
-
-// CreateAlertRule creates an ops alert rule.
-// POST /api/v1/admin/ops/alert-rules
-func (h *OpsHandler) CreateAlertRule(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	var raw map[string]json.RawMessage
-	if err := c.ShouldBindBodyWith(&raw, binding.JSON); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-	validated, err := validateOpsAlertRulePayload(raw)
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	var rule service.OpsAlertRule
-	if err := c.ShouldBindBodyWith(&rule, binding.JSON); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-
-	rule.Name = validated.Name
-	rule.MetricType = validated.MetricType
-	rule.Operator = validated.Operator
-	rule.Threshold = validated.Threshold
-	rule.WindowMinutes = validated.WindowMinutes
-	rule.SustainedMinutes = validated.SustainedMinutes
-	rule.CooldownMinutes = validated.CooldownMinutes
-	rule.Severity = validated.Severity
-	rule.Enabled = validated.Enabled
-	rule.NotifyEmail = validated.NotifyEmail
-
-	created, err := h.opsService.CreateAlertRule(c.Request.Context(), &rule)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, created)
-}
-
-// UpdateAlertRule updates an existing ops alert rule.
-// PUT /api/v1/admin/ops/alert-rules/:id
-func (h *OpsHandler) UpdateAlertRule(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid rule ID")
-		return
-	}
-
-	var raw map[string]json.RawMessage
-	if err := c.ShouldBindBodyWith(&raw, binding.JSON); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-	validated, err := validateOpsAlertRulePayload(raw)
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	var rule service.OpsAlertRule
-	if err := c.ShouldBindBodyWith(&rule, binding.JSON); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-
-	rule.ID = id
-	rule.Name = validated.Name
-	rule.MetricType = validated.MetricType
-	rule.Operator = validated.Operator
-	rule.Threshold = validated.Threshold
-	rule.WindowMinutes = validated.WindowMinutes
-	rule.SustainedMinutes = validated.SustainedMinutes
-	rule.CooldownMinutes = validated.CooldownMinutes
-	rule.Severity = validated.Severity
-	rule.Enabled = validated.Enabled
-	rule.NotifyEmail = validated.NotifyEmail
-
-	updated, err := h.opsService.UpdateAlertRule(c.Request.Context(), &rule)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, updated)
-}
-
-// DeleteAlertRule deletes an ops alert rule.
-// DELETE /api/v1/admin/ops/alert-rules/:id
-func (h *OpsHandler) DeleteAlertRule(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid rule ID")
-		return
-	}
-
-	if err := h.opsService.DeleteAlertRule(c.Request.Context(), id); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, gin.H{"deleted": true})
-}
-
-// GetAlertEvent returns a single ops alert event.
-// GET /api/v1/admin/ops/alert-events/:id
-func (h *OpsHandler) GetAlertEvent(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid event ID")
-		return
-	}
-
-	ev, err := h.opsService.GetAlertEventByID(c.Request.Context(), id)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, ev)
-}
-
-// UpdateAlertEventStatus updates an ops alert event status.
-// PUT /api/v1/admin/ops/alert-events/:id/status
-func (h *OpsHandler) UpdateAlertEventStatus(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid event ID")
-		return
-	}
-
-	var payload struct {
-		Status string `json:"status"`
-	}
-	if err := c.ShouldBindJSON(&payload); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-	payload.Status = strings.TrimSpace(payload.Status)
-	if payload.Status == "" {
-		response.BadRequest(c, "Invalid status")
-		return
-	}
-	if payload.Status != service.OpsAlertStatusResolved && payload.Status != service.OpsAlertStatusManualResolved {
-		response.BadRequest(c, "Invalid status")
-		return
-	}
-
-	var resolvedAt *time.Time
-	if payload.Status == service.OpsAlertStatusResolved || payload.Status == service.OpsAlertStatusManualResolved {
-		now := time.Now().UTC()
-		resolvedAt = &now
-	}
-	if err := h.opsService.UpdateAlertEventStatus(c.Request.Context(), id, payload.Status, resolvedAt); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, gin.H{"updated": true})
-}
-
-// ListAlertEvents lists recent ops alert events.
-// GET /api/v1/admin/ops/alert-events
-// CreateAlertSilence creates a scoped silence for ops alerts.
-// POST /api/v1/admin/ops/alert-silences
-func (h *OpsHandler) CreateAlertSilence(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	var payload struct {
-		RuleID   int64   `json:"rule_id"`
-		Platform string  `json:"platform"`
-		GroupID  *int64  `json:"group_id"`
-		Region   *string `json:"region"`
-		Until    string  `json:"until"`
-		Reason   string  `json:"reason"`
-	}
-	if err := c.ShouldBindJSON(&payload); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-	until, err := time.Parse(time.RFC3339, strings.TrimSpace(payload.Until))
-	if err != nil {
-		response.BadRequest(c, "Invalid until")
-		return
-	}
-
-	createdBy := (*int64)(nil)
-	if subject, ok := middleware.GetAuthSubjectFromContext(c); ok {
-		uid := subject.UserID
-		createdBy = &uid
-	}
-
-	silence := &service.OpsAlertSilence{
-		RuleID:    payload.RuleID,
-		Platform:  strings.TrimSpace(payload.Platform),
-		GroupID:   payload.GroupID,
-		Region:    payload.Region,
-		Until:     until,
-		Reason:    strings.TrimSpace(payload.Reason),
-		CreatedBy: createdBy,
-	}
-
-	created, err := h.opsService.CreateAlertSilence(c.Request.Context(), silence)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, created)
-}
-
-func (h *OpsHandler) ListAlertEvents(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	limit := 20
-	if raw := strings.TrimSpace(c.Query("limit")); raw != "" {
-		n, err := strconv.Atoi(raw)
-		if err != nil || n <= 0 {
-			response.BadRequest(c, "Invalid limit")
-			return
-		}
-		limit = n
-	}
-
-	filter := &service.OpsAlertEventFilter{
-		Limit:    limit,
-		Status:   strings.TrimSpace(c.Query("status")),
-		Severity: strings.TrimSpace(c.Query("severity")),
-	}
-
-	if v := strings.TrimSpace(c.Query("email_sent")); v != "" {
-		vv := strings.ToLower(v)
-		switch vv {
-		case "true", "1":
-			b := true
-			filter.EmailSent = &b
-		case "false", "0":
-			b := false
-			filter.EmailSent = &b
-		default:
-			response.BadRequest(c, "Invalid email_sent")
-			return
-		}
-	}
-
-	// Cursor pagination: both params must be provided together.
-	rawTS := strings.TrimSpace(c.Query("before_fired_at"))
-	rawID := strings.TrimSpace(c.Query("before_id"))
-	if (rawTS == "") != (rawID == "") {
-		response.BadRequest(c, "before_fired_at and before_id must be provided together")
-		return
-	}
-	if rawTS != "" {
-		ts, err := time.Parse(time.RFC3339Nano, rawTS)
-		if err != nil {
-			if t2, err2 := time.Parse(time.RFC3339, rawTS); err2 == nil {
-				ts = t2
-			} else {
-				response.BadRequest(c, "Invalid before_fired_at")
-				return
-			}
-		}
-		filter.BeforeFiredAt = &ts
-	}
-	if rawID != "" {
-		id, err := strconv.ParseInt(rawID, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid before_id")
-			return
-		}
-		filter.BeforeID = &id
-	}
-
-	// Optional global filter support (platform/group/time range).
-	if platform := strings.TrimSpace(c.Query("platform")); platform != "" {
-		filter.Platform = platform
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-	if startTime, endTime, err := parseOpsTimeRange(c, "24h"); err == nil {
-		// Only apply when explicitly provided to avoid surprising default narrowing.
-		if strings.TrimSpace(c.Query("start_time")) != "" || strings.TrimSpace(c.Query("end_time")) != "" || strings.TrimSpace(c.Query("time_range")) != "" {
-			filter.StartTime = &startTime
-			filter.EndTime = &endTime
-		}
-	} else {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	events, err := h.opsService.ListAlertEvents(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, events)
-}

backend/internal/handler/admin/ops_dashboard_handler.go

@@ -1,243 +0,0 @@
-package admin
-
-import (
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/response"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/gin-gonic/gin"
-)
-
-// GetDashboardOverview returns vNext ops dashboard overview (raw path).
-// GET /api/v1/admin/ops/dashboard/overview
-func (h *OpsHandler) GetDashboardOverview(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsDashboardFilter{
-		StartTime: startTime,
-		EndTime:   endTime,
-		Platform:  strings.TrimSpace(c.Query("platform")),
-		QueryMode: parseOpsQueryMode(c),
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-
-	data, err := h.opsService.GetDashboardOverview(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, data)
-}
-
-// GetDashboardThroughputTrend returns throughput time series (raw path).
-// GET /api/v1/admin/ops/dashboard/throughput-trend
-func (h *OpsHandler) GetDashboardThroughputTrend(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsDashboardFilter{
-		StartTime: startTime,
-		EndTime:   endTime,
-		Platform:  strings.TrimSpace(c.Query("platform")),
-		QueryMode: parseOpsQueryMode(c),
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-
-	bucketSeconds := pickThroughputBucketSeconds(endTime.Sub(startTime))
-	data, err := h.opsService.GetThroughputTrend(c.Request.Context(), filter, bucketSeconds)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, data)
-}
-
-// GetDashboardLatencyHistogram returns the latency distribution histogram (success requests).
-// GET /api/v1/admin/ops/dashboard/latency-histogram
-func (h *OpsHandler) GetDashboardLatencyHistogram(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsDashboardFilter{
-		StartTime: startTime,
-		EndTime:   endTime,
-		Platform:  strings.TrimSpace(c.Query("platform")),
-		QueryMode: parseOpsQueryMode(c),
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-
-	data, err := h.opsService.GetLatencyHistogram(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, data)
-}
-
-// GetDashboardErrorTrend returns error counts time series (raw path).
-// GET /api/v1/admin/ops/dashboard/error-trend
-func (h *OpsHandler) GetDashboardErrorTrend(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsDashboardFilter{
-		StartTime: startTime,
-		EndTime:   endTime,
-		Platform:  strings.TrimSpace(c.Query("platform")),
-		QueryMode: parseOpsQueryMode(c),
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-
-	bucketSeconds := pickThroughputBucketSeconds(endTime.Sub(startTime))
-	data, err := h.opsService.GetErrorTrend(c.Request.Context(), filter, bucketSeconds)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, data)
-}
-
-// GetDashboardErrorDistribution returns error distribution by status code (raw path).
-// GET /api/v1/admin/ops/dashboard/error-distribution
-func (h *OpsHandler) GetDashboardErrorDistribution(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsDashboardFilter{
-		StartTime: startTime,
-		EndTime:   endTime,
-		Platform:  strings.TrimSpace(c.Query("platform")),
-		QueryMode: parseOpsQueryMode(c),
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-
-	data, err := h.opsService.GetErrorDistribution(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, data)
-}
-
-func pickThroughputBucketSeconds(window time.Duration) int {
-	// Keep buckets predictable and avoid huge responses.
-	switch {
-	case window <= 2*time.Hour:
-		return 60
-	case window <= 24*time.Hour:
-		return 300
-	default:
-		return 3600
-	}
-}
-
-func parseOpsQueryMode(c *gin.Context) service.OpsQueryMode {
-	if c == nil {
-		return ""
-	}
-	raw := strings.TrimSpace(c.Query("mode"))
-	if raw == "" {
-		// Empty means "use server default" (DB setting ops_query_mode_default).
-		return ""
-	}
-	return service.ParseOpsQueryMode(raw)
-}

backend/internal/handler/admin/ops_handler.go

@@ -1,925 +0,0 @@
-package admin
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/response"
-	"github.com/Wei-Shaw/sub2api/internal/server/middleware"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/gin-gonic/gin"
-)
-
-type OpsHandler struct {
-	opsService *service.OpsService
-}
-
-// GetErrorLogByID returns ops error log detail.
-// GET /api/v1/admin/ops/errors/:id
-func (h *OpsHandler) GetErrorLogByID(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	detail, err := h.opsService.GetErrorLogByID(c.Request.Context(), id)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	response.Success(c, detail)
-}
-
-const (
-	opsListViewErrors   = "errors"
-	opsListViewExcluded = "excluded"
-	opsListViewAll      = "all"
-)
-
-func parseOpsViewParam(c *gin.Context) string {
-	if c == nil {
-		return ""
-	}
-	v := strings.ToLower(strings.TrimSpace(c.Query("view")))
-	switch v {
-	case "", opsListViewErrors:
-		return opsListViewErrors
-	case opsListViewExcluded:
-		return opsListViewExcluded
-	case opsListViewAll:
-		return opsListViewAll
-	default:
-		return opsListViewErrors
-	}
-}
-
-func NewOpsHandler(opsService *service.OpsService) *OpsHandler {
-	return &OpsHandler{opsService: opsService}
-}
-
-// GetErrorLogs lists ops error logs.
-// GET /api/v1/admin/ops/errors
-func (h *OpsHandler) GetErrorLogs(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	page, pageSize := response.ParsePagination(c)
-	// Ops list can be larger than standard admin tables.
-	if pageSize > 500 {
-		pageSize = 500
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsErrorLogFilter{Page: page, PageSize: pageSize}
-
-	if !startTime.IsZero() {
-		filter.StartTime = &startTime
-	}
-	if !endTime.IsZero() {
-		filter.EndTime = &endTime
-	}
-	filter.View = parseOpsViewParam(c)
-	filter.Phase = strings.TrimSpace(c.Query("phase"))
-	filter.Owner = strings.TrimSpace(c.Query("error_owner"))
-	filter.Source = strings.TrimSpace(c.Query("error_source"))
-	filter.Query = strings.TrimSpace(c.Query("q"))
-	filter.UserQuery = strings.TrimSpace(c.Query("user_query"))
-
-	// Force request errors: client-visible status >= 400.
-	// buildOpsErrorLogsWhere already applies this for non-upstream phase.
-	if strings.EqualFold(strings.TrimSpace(filter.Phase), "upstream") {
-		filter.Phase = ""
-	}
-
-	if platform := strings.TrimSpace(c.Query("platform")); platform != "" {
-		filter.Platform = platform
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-	if v := strings.TrimSpace(c.Query("account_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid account_id")
-			return
-		}
-		filter.AccountID = &id
-	}
-
-	if v := strings.TrimSpace(c.Query("resolved")); v != "" {
-		switch strings.ToLower(v) {
-		case "1", "true", "yes":
-			b := true
-			filter.Resolved = &b
-		case "0", "false", "no":
-			b := false
-			filter.Resolved = &b
-		default:
-			response.BadRequest(c, "Invalid resolved")
-			return
-		}
-	}
-	if statusCodesStr := strings.TrimSpace(c.Query("status_codes")); statusCodesStr != "" {
-		parts := strings.Split(statusCodesStr, ",")
-		out := make([]int, 0, len(parts))
-		for _, part := range parts {
-			p := strings.TrimSpace(part)
-			if p == "" {
-				continue
-			}
-			n, err := strconv.Atoi(p)
-			if err != nil || n < 0 {
-				response.BadRequest(c, "Invalid status_codes")
-				return
-			}
-			out = append(out, n)
-		}
-		filter.StatusCodes = out
-	}
-
-	result, err := h.opsService.GetErrorLogs(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Paginated(c, result.Errors, int64(result.Total), result.Page, result.PageSize)
-}
-
-// ListRequestErrors lists client-visible request errors.
-// GET /api/v1/admin/ops/request-errors
-func (h *OpsHandler) ListRequestErrors(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	page, pageSize := response.ParsePagination(c)
-	if pageSize > 500 {
-		pageSize = 500
-	}
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsErrorLogFilter{Page: page, PageSize: pageSize}
-	if !startTime.IsZero() {
-		filter.StartTime = &startTime
-	}
-	if !endTime.IsZero() {
-		filter.EndTime = &endTime
-	}
-	filter.View = parseOpsViewParam(c)
-	filter.Phase = strings.TrimSpace(c.Query("phase"))
-	filter.Owner = strings.TrimSpace(c.Query("error_owner"))
-	filter.Source = strings.TrimSpace(c.Query("error_source"))
-	filter.Query = strings.TrimSpace(c.Query("q"))
-	filter.UserQuery = strings.TrimSpace(c.Query("user_query"))
-
-	// Force request errors: client-visible status >= 400.
-	// buildOpsErrorLogsWhere already applies this for non-upstream phase.
-	if strings.EqualFold(strings.TrimSpace(filter.Phase), "upstream") {
-		filter.Phase = ""
-	}
-
-	if platform := strings.TrimSpace(c.Query("platform")); platform != "" {
-		filter.Platform = platform
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-	if v := strings.TrimSpace(c.Query("account_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid account_id")
-			return
-		}
-		filter.AccountID = &id
-	}
-
-	if v := strings.TrimSpace(c.Query("resolved")); v != "" {
-		switch strings.ToLower(v) {
-		case "1", "true", "yes":
-			b := true
-			filter.Resolved = &b
-		case "0", "false", "no":
-			b := false
-			filter.Resolved = &b
-		default:
-			response.BadRequest(c, "Invalid resolved")
-			return
-		}
-	}
-	if statusCodesStr := strings.TrimSpace(c.Query("status_codes")); statusCodesStr != "" {
-		parts := strings.Split(statusCodesStr, ",")
-		out := make([]int, 0, len(parts))
-		for _, part := range parts {
-			p := strings.TrimSpace(part)
-			if p == "" {
-				continue
-			}
-			n, err := strconv.Atoi(p)
-			if err != nil || n < 0 {
-				response.BadRequest(c, "Invalid status_codes")
-				return
-			}
-			out = append(out, n)
-		}
-		filter.StatusCodes = out
-	}
-
-	result, err := h.opsService.GetErrorLogs(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Paginated(c, result.Errors, int64(result.Total), result.Page, result.PageSize)
-}
-
-// GetRequestError returns request error detail.
-// GET /api/v1/admin/ops/request-errors/:id
-func (h *OpsHandler) GetRequestError(c *gin.Context) {
-	// same storage; just proxy to existing detail
-	h.GetErrorLogByID(c)
-}
-
-// ListRequestErrorUpstreamErrors lists upstream error logs correlated to a request error.
-// GET /api/v1/admin/ops/request-errors/:id/upstream-errors
-func (h *OpsHandler) ListRequestErrorUpstreamErrors(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	// Load request error to get correlation keys.
-	detail, err := h.opsService.GetErrorLogByID(c.Request.Context(), id)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	// Correlate by request_id/client_request_id.
-	requestID := strings.TrimSpace(detail.RequestID)
-	clientRequestID := strings.TrimSpace(detail.ClientRequestID)
-	if requestID == "" && clientRequestID == "" {
-		response.Paginated(c, []*service.OpsErrorLog{}, 0, 1, 10)
-		return
-	}
-
-	page, pageSize := response.ParsePagination(c)
-	if pageSize > 500 {
-		pageSize = 500
-	}
-
-	// Keep correlation window wide enough so linked upstream errors
-	// are discoverable even when UI defaults to 1h elsewhere.
-	startTime, endTime, err := parseOpsTimeRange(c, "30d")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsErrorLogFilter{Page: page, PageSize: pageSize}
-	if !startTime.IsZero() {
-		filter.StartTime = &startTime
-	}
-	if !endTime.IsZero() {
-		filter.EndTime = &endTime
-	}
-	filter.View = "all"
-	filter.Phase = "upstream"
-	filter.Owner = "provider"
-	filter.Source = strings.TrimSpace(c.Query("error_source"))
-	filter.Query = strings.TrimSpace(c.Query("q"))
-
-	if platform := strings.TrimSpace(c.Query("platform")); platform != "" {
-		filter.Platform = platform
-	}
-
-	// Prefer exact match on request_id; if missing, fall back to client_request_id.
-	if requestID != "" {
-		filter.RequestID = requestID
-	} else {
-		filter.ClientRequestID = clientRequestID
-	}
-
-	result, err := h.opsService.GetErrorLogs(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	// If client asks for details, expand each upstream error log to include upstream response fields.
-	includeDetail := strings.TrimSpace(c.Query("include_detail"))
-	if includeDetail == "1" || strings.EqualFold(includeDetail, "true") || strings.EqualFold(includeDetail, "yes") {
-		details := make([]*service.OpsErrorLogDetail, 0, len(result.Errors))
-		for _, item := range result.Errors {
-			if item == nil {
-				continue
-			}
-			d, err := h.opsService.GetErrorLogByID(c.Request.Context(), item.ID)
-			if err != nil || d == nil {
-				continue
-			}
-			details = append(details, d)
-		}
-		response.Paginated(c, details, int64(result.Total), result.Page, result.PageSize)
-		return
-	}
-
-	response.Paginated(c, result.Errors, int64(result.Total), result.Page, result.PageSize)
-}
-
-// RetryRequestErrorClient retries the client request based on stored request body.
-// POST /api/v1/admin/ops/request-errors/:id/retry-client
-func (h *OpsHandler) RetryRequestErrorClient(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	subject, ok := middleware.GetAuthSubjectFromContext(c)
-	if !ok || subject.UserID <= 0 {
-		response.Error(c, http.StatusUnauthorized, "Unauthorized")
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	result, err := h.opsService.RetryError(c.Request.Context(), subject.UserID, id, service.OpsRetryModeClient, nil)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, result)
-}
-
-// RetryRequestErrorUpstreamEvent retries a specific upstream attempt using captured upstream_request_body.
-// POST /api/v1/admin/ops/request-errors/:id/upstream-errors/:idx/retry
-func (h *OpsHandler) RetryRequestErrorUpstreamEvent(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	subject, ok := middleware.GetAuthSubjectFromContext(c)
-	if !ok || subject.UserID <= 0 {
-		response.Error(c, http.StatusUnauthorized, "Unauthorized")
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	idxStr := strings.TrimSpace(c.Param("idx"))
-	idx, err := strconv.Atoi(idxStr)
-	if err != nil || idx < 0 {
-		response.BadRequest(c, "Invalid upstream idx")
-		return
-	}
-
-	result, err := h.opsService.RetryUpstreamEvent(c.Request.Context(), subject.UserID, id, idx)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, result)
-}
-
-// ResolveRequestError toggles resolved status.
-// PUT /api/v1/admin/ops/request-errors/:id/resolve
-func (h *OpsHandler) ResolveRequestError(c *gin.Context) {
-	h.UpdateErrorResolution(c)
-}
-
-// ListUpstreamErrors lists independent upstream errors.
-// GET /api/v1/admin/ops/upstream-errors
-func (h *OpsHandler) ListUpstreamErrors(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	page, pageSize := response.ParsePagination(c)
-	if pageSize > 500 {
-		pageSize = 500
-	}
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsErrorLogFilter{Page: page, PageSize: pageSize}
-	if !startTime.IsZero() {
-		filter.StartTime = &startTime
-	}
-	if !endTime.IsZero() {
-		filter.EndTime = &endTime
-	}
-
-	filter.View = parseOpsViewParam(c)
-	filter.Phase = "upstream"
-	filter.Owner = "provider"
-	filter.Source = strings.TrimSpace(c.Query("error_source"))
-	filter.Query = strings.TrimSpace(c.Query("q"))
-
-	if platform := strings.TrimSpace(c.Query("platform")); platform != "" {
-		filter.Platform = platform
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-	if v := strings.TrimSpace(c.Query("account_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid account_id")
-			return
-		}
-		filter.AccountID = &id
-	}
-
-	if v := strings.TrimSpace(c.Query("resolved")); v != "" {
-		switch strings.ToLower(v) {
-		case "1", "true", "yes":
-			b := true
-			filter.Resolved = &b
-		case "0", "false", "no":
-			b := false
-			filter.Resolved = &b
-		default:
-			response.BadRequest(c, "Invalid resolved")
-			return
-		}
-	}
-	if statusCodesStr := strings.TrimSpace(c.Query("status_codes")); statusCodesStr != "" {
-		parts := strings.Split(statusCodesStr, ",")
-		out := make([]int, 0, len(parts))
-		for _, part := range parts {
-			p := strings.TrimSpace(part)
-			if p == "" {
-				continue
-			}
-			n, err := strconv.Atoi(p)
-			if err != nil || n < 0 {
-				response.BadRequest(c, "Invalid status_codes")
-				return
-			}
-			out = append(out, n)
-		}
-		filter.StatusCodes = out
-	}
-
-	result, err := h.opsService.GetErrorLogs(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Paginated(c, result.Errors, int64(result.Total), result.Page, result.PageSize)
-}
-
-// GetUpstreamError returns upstream error detail.
-// GET /api/v1/admin/ops/upstream-errors/:id
-func (h *OpsHandler) GetUpstreamError(c *gin.Context) {
-	h.GetErrorLogByID(c)
-}
-
-// RetryUpstreamError retries upstream error using the original account_id.
-// POST /api/v1/admin/ops/upstream-errors/:id/retry
-func (h *OpsHandler) RetryUpstreamError(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	subject, ok := middleware.GetAuthSubjectFromContext(c)
-	if !ok || subject.UserID <= 0 {
-		response.Error(c, http.StatusUnauthorized, "Unauthorized")
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	result, err := h.opsService.RetryError(c.Request.Context(), subject.UserID, id, service.OpsRetryModeUpstream, nil)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, result)
-}
-
-// ResolveUpstreamError toggles resolved status.
-// PUT /api/v1/admin/ops/upstream-errors/:id/resolve
-func (h *OpsHandler) ResolveUpstreamError(c *gin.Context) {
-	h.UpdateErrorResolution(c)
-}
-
-// ==================== Existing endpoints ====================
-
-// ListRequestDetails returns a request-level list (success + error) for drill-down.
-// GET /api/v1/admin/ops/requests
-func (h *OpsHandler) ListRequestDetails(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	page, pageSize := response.ParsePagination(c)
-	if pageSize > 100 {
-		pageSize = 100
-	}
-
-	startTime, endTime, err := parseOpsTimeRange(c, "1h")
-	if err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	filter := &service.OpsRequestDetailFilter{
-		Page:      page,
-		PageSize:  pageSize,
-		StartTime: &startTime,
-		EndTime:   &endTime,
-	}
-
-	filter.Kind = strings.TrimSpace(c.Query("kind"))
-	filter.Platform = strings.TrimSpace(c.Query("platform"))
-	filter.Model = strings.TrimSpace(c.Query("model"))
-	filter.RequestID = strings.TrimSpace(c.Query("request_id"))
-	filter.Query = strings.TrimSpace(c.Query("q"))
-	filter.Sort = strings.TrimSpace(c.Query("sort"))
-
-	if v := strings.TrimSpace(c.Query("user_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid user_id")
-			return
-		}
-		filter.UserID = &id
-	}
-	if v := strings.TrimSpace(c.Query("api_key_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid api_key_id")
-			return
-		}
-		filter.APIKeyID = &id
-	}
-	if v := strings.TrimSpace(c.Query("account_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid account_id")
-			return
-		}
-		filter.AccountID = &id
-	}
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		filter.GroupID = &id
-	}
-
-	if v := strings.TrimSpace(c.Query("min_duration_ms")); v != "" {
-		parsed, err := strconv.Atoi(v)
-		if err != nil || parsed < 0 {
-			response.BadRequest(c, "Invalid min_duration_ms")
-			return
-		}
-		filter.MinDurationMs = &parsed
-	}
-	if v := strings.TrimSpace(c.Query("max_duration_ms")); v != "" {
-		parsed, err := strconv.Atoi(v)
-		if err != nil || parsed < 0 {
-			response.BadRequest(c, "Invalid max_duration_ms")
-			return
-		}
-		filter.MaxDurationMs = &parsed
-	}
-
-	out, err := h.opsService.ListRequestDetails(c.Request.Context(), filter)
-	if err != nil {
-		// Invalid sort/kind/platform etc should be a bad request; keep it simple.
-		if strings.Contains(strings.ToLower(err.Error()), "invalid") {
-			response.BadRequest(c, err.Error())
-			return
-		}
-		response.Error(c, http.StatusInternalServerError, "Failed to list request details")
-		return
-	}
-
-	response.Paginated(c, out.Items, out.Total, out.Page, out.PageSize)
-}
-
-type opsRetryRequest struct {
-	Mode            string `json:"mode"`
-	PinnedAccountID *int64 `json:"pinned_account_id"`
-	Force           bool   `json:"force"`
-}
-
-type opsResolveRequest struct {
-	Resolved bool `json:"resolved"`
-}
-
-// RetryErrorRequest retries a failed request using stored request_body.
-// POST /api/v1/admin/ops/errors/:id/retry
-func (h *OpsHandler) RetryErrorRequest(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	subject, ok := middleware.GetAuthSubjectFromContext(c)
-	if !ok || subject.UserID <= 0 {
-		response.Error(c, http.StatusUnauthorized, "Unauthorized")
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	req := opsRetryRequest{Mode: service.OpsRetryModeClient}
-	if err := c.ShouldBindJSON(&req); err != nil && !errors.Is(err, io.EOF) {
-		response.BadRequest(c, "Invalid request: "+err.Error())
-		return
-	}
-	if strings.TrimSpace(req.Mode) == "" {
-		req.Mode = service.OpsRetryModeClient
-	}
-
-	// Force flag is currently a UI-level acknowledgement. Server may still enforce safety constraints.
-	_ = req.Force
-
-	// Legacy endpoint safety: only allow retrying the client request here.
-	// Upstream retries must go through the split endpoints.
-	if strings.EqualFold(strings.TrimSpace(req.Mode), service.OpsRetryModeUpstream) {
-		response.BadRequest(c, "upstream retry is not supported on this endpoint")
-		return
-	}
-
-	result, err := h.opsService.RetryError(c.Request.Context(), subject.UserID, id, req.Mode, req.PinnedAccountID)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	response.Success(c, result)
-}
-
-// ListRetryAttempts lists retry attempts for an error log.
-// GET /api/v1/admin/ops/errors/:id/retries
-func (h *OpsHandler) ListRetryAttempts(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	limit := 50
-	if v := strings.TrimSpace(c.Query("limit")); v != "" {
-		n, err := strconv.Atoi(v)
-		if err != nil || n <= 0 {
-			response.BadRequest(c, "Invalid limit")
-			return
-		}
-		limit = n
-	}
-
-	items, err := h.opsService.ListRetryAttemptsByErrorID(c.Request.Context(), id, limit)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, items)
-}
-
-// UpdateErrorResolution allows manual resolve/unresolve.
-// PUT /api/v1/admin/ops/errors/:id/resolve
-func (h *OpsHandler) UpdateErrorResolution(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	subject, ok := middleware.GetAuthSubjectFromContext(c)
-	if !ok || subject.UserID <= 0 {
-		response.Error(c, http.StatusUnauthorized, "Unauthorized")
-		return
-	}
-
-	idStr := strings.TrimSpace(c.Param("id"))
-	id, err := strconv.ParseInt(idStr, 10, 64)
-	if err != nil || id <= 0 {
-		response.BadRequest(c, "Invalid error id")
-		return
-	}
-
-	var req opsResolveRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request: "+err.Error())
-		return
-	}
-	uid := subject.UserID
-	if err := h.opsService.UpdateErrorResolution(c.Request.Context(), id, req.Resolved, &uid, nil); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	response.Success(c, gin.H{"ok": true})
-}
-
-func parseOpsTimeRange(c *gin.Context, defaultRange string) (time.Time, time.Time, error) {
-	startStr := strings.TrimSpace(c.Query("start_time"))
-	endStr := strings.TrimSpace(c.Query("end_time"))
-
-	parseTS := func(s string) (time.Time, error) {
-		if s == "" {
-			return time.Time{}, nil
-		}
-		if t, err := time.Parse(time.RFC3339Nano, s); err == nil {
-			return t, nil
-		}
-		return time.Parse(time.RFC3339, s)
-	}
-
-	start, err := parseTS(startStr)
-	if err != nil {
-		return time.Time{}, time.Time{}, err
-	}
-	end, err := parseTS(endStr)
-	if err != nil {
-		return time.Time{}, time.Time{}, err
-	}
-
-	// start/end explicitly provided (even partially)
-	if startStr != "" || endStr != "" {
-		if end.IsZero() {
-			end = time.Now()
-		}
-		if start.IsZero() {
-			dur, _ := parseOpsDuration(defaultRange)
-			start = end.Add(-dur)
-		}
-		if start.After(end) {
-			return time.Time{}, time.Time{}, fmt.Errorf("invalid time range: start_time must be <= end_time")
-		}
-		if end.Sub(start) > 30*24*time.Hour {
-			return time.Time{}, time.Time{}, fmt.Errorf("invalid time range: max window is 30 days")
-		}
-		return start, end, nil
-	}
-
-	// time_range fallback
-	tr := strings.TrimSpace(c.Query("time_range"))
-	if tr == "" {
-		tr = defaultRange
-	}
-	dur, ok := parseOpsDuration(tr)
-	if !ok {
-		dur, _ = parseOpsDuration(defaultRange)
-	}
-
-	end = time.Now()
-	start = end.Add(-dur)
-	if end.Sub(start) > 30*24*time.Hour {
-		return time.Time{}, time.Time{}, fmt.Errorf("invalid time range: max window is 30 days")
-	}
-	return start, end, nil
-}
-
-func parseOpsDuration(v string) (time.Duration, bool) {
-	switch strings.TrimSpace(v) {
-	case "5m":
-		return 5 * time.Minute, true
-	case "30m":
-		return 30 * time.Minute, true
-	case "1h":
-		return time.Hour, true
-	case "6h":
-		return 6 * time.Hour, true
-	case "24h":
-		return 24 * time.Hour, true
-	case "7d":
-		return 7 * 24 * time.Hour, true
-	case "30d":
-		return 30 * 24 * time.Hour, true
-	default:
-		return 0, false
-	}
-}

backend/internal/handler/admin/ops_realtime_handler.go

@@ -1,213 +0,0 @@
-package admin
-
-import (
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/response"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/gin-gonic/gin"
-)
-
-// GetConcurrencyStats returns real-time concurrency usage aggregated by platform/group/account.
-// GET /api/v1/admin/ops/concurrency
-func (h *OpsHandler) GetConcurrencyStats(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	if !h.opsService.IsRealtimeMonitoringEnabled(c.Request.Context()) {
-		response.Success(c, gin.H{
-			"enabled":   false,
-			"platform":  map[string]*service.PlatformConcurrencyInfo{},
-			"group":     map[int64]*service.GroupConcurrencyInfo{},
-			"account":   map[int64]*service.AccountConcurrencyInfo{},
-			"timestamp": time.Now().UTC(),
-		})
-		return
-	}
-
-	platformFilter := strings.TrimSpace(c.Query("platform"))
-	var groupID *int64
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		groupID = &id
-	}
-
-	platform, group, account, collectedAt, err := h.opsService.GetConcurrencyStats(c.Request.Context(), platformFilter, groupID)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	payload := gin.H{
-		"enabled":  true,
-		"platform": platform,
-		"group":    group,
-		"account":  account,
-	}
-	if collectedAt != nil {
-		payload["timestamp"] = collectedAt.UTC()
-	}
-	response.Success(c, payload)
-}
-
-// GetAccountAvailability returns account availability statistics.
-// GET /api/v1/admin/ops/account-availability
-//
-// Query params:
-// - platform: optional
-// - group_id: optional
-func (h *OpsHandler) GetAccountAvailability(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	if !h.opsService.IsRealtimeMonitoringEnabled(c.Request.Context()) {
-		response.Success(c, gin.H{
-			"enabled":   false,
-			"platform":  map[string]*service.PlatformAvailability{},
-			"group":     map[int64]*service.GroupAvailability{},
-			"account":   map[int64]*service.AccountAvailability{},
-			"timestamp": time.Now().UTC(),
-		})
-		return
-	}
-
-	platform := strings.TrimSpace(c.Query("platform"))
-	var groupID *int64
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		groupID = &id
-	}
-
-	platformStats, groupStats, accountStats, collectedAt, err := h.opsService.GetAccountAvailabilityStats(c.Request.Context(), platform, groupID)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	payload := gin.H{
-		"enabled":  true,
-		"platform": platformStats,
-		"group":    groupStats,
-		"account":  accountStats,
-	}
-	if collectedAt != nil {
-		payload["timestamp"] = collectedAt.UTC()
-	}
-	response.Success(c, payload)
-}
-
-func parseOpsRealtimeWindow(v string) (time.Duration, string, bool) {
-	switch strings.ToLower(strings.TrimSpace(v)) {
-	case "", "1min", "1m":
-		return 1 * time.Minute, "1min", true
-	case "5min", "5m":
-		return 5 * time.Minute, "5min", true
-	case "30min", "30m":
-		return 30 * time.Minute, "30min", true
-	case "1h", "60m", "60min":
-		return 1 * time.Hour, "1h", true
-	default:
-		return 0, "", false
-	}
-}
-
-// GetRealtimeTrafficSummary returns QPS/TPS current/peak/avg for the selected window.
-// GET /api/v1/admin/ops/realtime-traffic
-//
-// Query params:
-// - window: 1min|5min|30min|1h (default: 1min)
-// - platform: optional
-// - group_id: optional
-func (h *OpsHandler) GetRealtimeTrafficSummary(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	windowDur, windowLabel, ok := parseOpsRealtimeWindow(c.Query("window"))
-	if !ok {
-		response.BadRequest(c, "Invalid window")
-		return
-	}
-
-	platform := strings.TrimSpace(c.Query("platform"))
-	var groupID *int64
-	if v := strings.TrimSpace(c.Query("group_id")); v != "" {
-		id, err := strconv.ParseInt(v, 10, 64)
-		if err != nil || id <= 0 {
-			response.BadRequest(c, "Invalid group_id")
-			return
-		}
-		groupID = &id
-	}
-
-	endTime := time.Now().UTC()
-	startTime := endTime.Add(-windowDur)
-
-	if !h.opsService.IsRealtimeMonitoringEnabled(c.Request.Context()) {
-		disabledSummary := &service.OpsRealtimeTrafficSummary{
-			Window:    windowLabel,
-			StartTime: startTime,
-			EndTime:   endTime,
-			Platform:  platform,
-			GroupID:   groupID,
-			QPS:       service.OpsRateSummary{},
-			TPS:       service.OpsRateSummary{},
-		}
-		response.Success(c, gin.H{
-			"enabled":   false,
-			"summary":   disabledSummary,
-			"timestamp": endTime,
-		})
-		return
-	}
-
-	filter := &service.OpsDashboardFilter{
-		StartTime: startTime,
-		EndTime:   endTime,
-		Platform:  platform,
-		GroupID:   groupID,
-		QueryMode: service.OpsQueryModeRaw,
-	}
-
-	summary, err := h.opsService.GetRealtimeTrafficSummary(c.Request.Context(), filter)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-	if summary != nil {
-		summary.Window = windowLabel
-	}
-	response.Success(c, gin.H{
-		"enabled":   true,
-		"summary":   summary,
-		"timestamp": endTime,
-	})
-}

backend/internal/handler/admin/ops_settings_handler.go

@@ -1,194 +0,0 @@
-package admin
-
-import (
-	"net/http"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/response"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/gin-gonic/gin"
-)
-
-// GetEmailNotificationConfig returns Ops email notification config (DB-backed).
-// GET /api/v1/admin/ops/email-notification/config
-func (h *OpsHandler) GetEmailNotificationConfig(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	cfg, err := h.opsService.GetEmailNotificationConfig(c.Request.Context())
-	if err != nil {
-		response.Error(c, http.StatusInternalServerError, "Failed to get email notification config")
-		return
-	}
-	response.Success(c, cfg)
-}
-
-// UpdateEmailNotificationConfig updates Ops email notification config (DB-backed).
-// PUT /api/v1/admin/ops/email-notification/config
-func (h *OpsHandler) UpdateEmailNotificationConfig(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	var req service.OpsEmailNotificationConfigUpdateRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-
-	updated, err := h.opsService.UpdateEmailNotificationConfig(c.Request.Context(), &req)
-	if err != nil {
-		// Most failures here are validation errors from request payload; treat as 400.
-		response.Error(c, http.StatusBadRequest, err.Error())
-		return
-	}
-	response.Success(c, updated)
-}
-
-// GetAlertRuntimeSettings returns Ops alert evaluator runtime settings (DB-backed).
-// GET /api/v1/admin/ops/runtime/alert
-func (h *OpsHandler) GetAlertRuntimeSettings(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	cfg, err := h.opsService.GetOpsAlertRuntimeSettings(c.Request.Context())
-	if err != nil {
-		response.Error(c, http.StatusInternalServerError, "Failed to get alert runtime settings")
-		return
-	}
-	response.Success(c, cfg)
-}
-
-// UpdateAlertRuntimeSettings updates Ops alert evaluator runtime settings (DB-backed).
-// PUT /api/v1/admin/ops/runtime/alert
-func (h *OpsHandler) UpdateAlertRuntimeSettings(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	var req service.OpsAlertRuntimeSettings
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-
-	updated, err := h.opsService.UpdateOpsAlertRuntimeSettings(c.Request.Context(), &req)
-	if err != nil {
-		response.Error(c, http.StatusBadRequest, err.Error())
-		return
-	}
-	response.Success(c, updated)
-}
-
-// GetAdvancedSettings returns Ops advanced settings (DB-backed).
-// GET /api/v1/admin/ops/advanced-settings
-func (h *OpsHandler) GetAdvancedSettings(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	cfg, err := h.opsService.GetOpsAdvancedSettings(c.Request.Context())
-	if err != nil {
-		response.Error(c, http.StatusInternalServerError, "Failed to get advanced settings")
-		return
-	}
-	response.Success(c, cfg)
-}
-
-// UpdateAdvancedSettings updates Ops advanced settings (DB-backed).
-// PUT /api/v1/admin/ops/advanced-settings
-func (h *OpsHandler) UpdateAdvancedSettings(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	var req service.OpsAdvancedSettings
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-
-	updated, err := h.opsService.UpdateOpsAdvancedSettings(c.Request.Context(), &req)
-	if err != nil {
-		response.Error(c, http.StatusBadRequest, err.Error())
-		return
-	}
-	response.Success(c, updated)
-}
-
-// GetMetricThresholds returns Ops metric thresholds (DB-backed).
-// GET /api/v1/admin/ops/settings/metric-thresholds
-func (h *OpsHandler) GetMetricThresholds(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	cfg, err := h.opsService.GetMetricThresholds(c.Request.Context())
-	if err != nil {
-		response.Error(c, http.StatusInternalServerError, "Failed to get metric thresholds")
-		return
-	}
-	response.Success(c, cfg)
-}
-
-// UpdateMetricThresholds updates Ops metric thresholds (DB-backed).
-// PUT /api/v1/admin/ops/settings/metric-thresholds
-func (h *OpsHandler) UpdateMetricThresholds(c *gin.Context) {
-	if h.opsService == nil {
-		response.Error(c, http.StatusServiceUnavailable, "Ops service not available")
-		return
-	}
-	if err := h.opsService.RequireMonitoringEnabled(c.Request.Context()); err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	var req service.OpsMetricThresholds
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request body")
-		return
-	}
-
-	updated, err := h.opsService.UpdateMetricThresholds(c.Request.Context(), &req)
-	if err != nil {
-		response.Error(c, http.StatusBadRequest, err.Error())
-		return
-	}
-	response.Success(c, updated)
-}

backend/internal/handler/admin/ops_ws_handler.go

@@ -1,771 +0,0 @@
-package admin
-
-import (
-	"context"
-	"encoding/json"
-	"log"
-	"math"
-	"net"
-	"net/http"
-	"net/netip"
-	"net/url"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/gin-gonic/gin"
-	"github.com/gorilla/websocket"
-)
-
-type OpsWSProxyConfig struct {
-	TrustProxy     bool
-	TrustedProxies []netip.Prefix
-	OriginPolicy   string
-}
-
-const (
-	envOpsWSTrustProxy     = "OPS_WS_TRUST_PROXY"
-	envOpsWSTrustedProxies = "OPS_WS_TRUSTED_PROXIES"
-	envOpsWSOriginPolicy   = "OPS_WS_ORIGIN_POLICY"
-	envOpsWSMaxConns       = "OPS_WS_MAX_CONNS"
-	envOpsWSMaxConnsPerIP  = "OPS_WS_MAX_CONNS_PER_IP"
-)
-
-const (
-	OriginPolicyStrict     = "strict"
-	OriginPolicyPermissive = "permissive"
-)
-
-var opsWSProxyConfig = loadOpsWSProxyConfigFromEnv()
-
-var upgrader = websocket.Upgrader{
-	CheckOrigin: func(r *http.Request) bool {
-		return isAllowedOpsWSOrigin(r)
-	},
-	// Subprotocol negotiation:
-	// - The frontend passes ["sub2api-admin", "jwt.<token>"].
-	// - We always select "sub2api-admin" so the token is never echoed back in the handshake response.
-	Subprotocols: []string{"sub2api-admin"},
-}
-
-const (
-	qpsWSPushInterval       = 2 * time.Second
-	qpsWSRefreshInterval    = 5 * time.Second
-	qpsWSRequestCountWindow = 1 * time.Minute
-
-	defaultMaxWSConns      = 100
-	defaultMaxWSConnsPerIP = 20
-)
-
-var wsConnCount atomic.Int32
-var wsConnCountByIP sync.Map // map[string]*atomic.Int32
-
-const qpsWSIdleStopDelay = 30 * time.Second
-
-const (
-	opsWSCloseRealtimeDisabled = 4001
-)
-
-var qpsWSIdleStopMu sync.Mutex
-var qpsWSIdleStopTimer *time.Timer
-
-func cancelQPSWSIdleStop() {
-	qpsWSIdleStopMu.Lock()
-	if qpsWSIdleStopTimer != nil {
-		qpsWSIdleStopTimer.Stop()
-		qpsWSIdleStopTimer = nil
-	}
-	qpsWSIdleStopMu.Unlock()
-}
-
-func scheduleQPSWSIdleStop() {
-	qpsWSIdleStopMu.Lock()
-	if qpsWSIdleStopTimer != nil {
-		qpsWSIdleStopMu.Unlock()
-		return
-	}
-	qpsWSIdleStopTimer = time.AfterFunc(qpsWSIdleStopDelay, func() {
-		// Only stop if truly idle at fire time.
-		if wsConnCount.Load() == 0 {
-			qpsWSCache.Stop()
-		}
-		qpsWSIdleStopMu.Lock()
-		qpsWSIdleStopTimer = nil
-		qpsWSIdleStopMu.Unlock()
-	})
-	qpsWSIdleStopMu.Unlock()
-}
-
-type opsWSRuntimeLimits struct {
-	MaxConns      int32
-	MaxConnsPerIP int32
-}
-
-var opsWSLimits = loadOpsWSRuntimeLimitsFromEnv()
-
-const (
-	qpsWSWriteTimeout = 10 * time.Second
-	qpsWSPongWait     = 60 * time.Second
-	qpsWSPingInterval = 30 * time.Second
-
-	// We don't expect clients to send application messages; we only read to process control frames (Pong/Close).
-	qpsWSMaxReadBytes = 1024
-)
-
-type opsWSQPSCache struct {
-	refreshInterval    time.Duration
-	requestCountWindow time.Duration
-
-	lastUpdatedUnixNano atomic.Int64
-	payload             atomic.Value // []byte
-
-	opsService *service.OpsService
-	cancel     context.CancelFunc
-	done       chan struct{}
-
-	mu      sync.Mutex
-	running bool
-}
-
-var qpsWSCache = &opsWSQPSCache{
-	refreshInterval:    qpsWSRefreshInterval,
-	requestCountWindow: qpsWSRequestCountWindow,
-}
-
-func (c *opsWSQPSCache) start(opsService *service.OpsService) {
-	if c == nil || opsService == nil {
-		return
-	}
-
-	for {
-		c.mu.Lock()
-		if c.running {
-			c.mu.Unlock()
-			return
-		}
-
-		// If a previous refresh loop is currently stopping, wait for it to fully exit.
-		done := c.done
-		if done != nil {
-			c.mu.Unlock()
-			<-done
-
-			c.mu.Lock()
-			if c.done == done && !c.running {
-				c.done = nil
-			}
-			c.mu.Unlock()
-			continue
-		}
-
-		c.opsService = opsService
-		ctx, cancel := context.WithCancel(context.Background())
-		c.cancel = cancel
-		c.done = make(chan struct{})
-		done = c.done
-		c.running = true
-		c.mu.Unlock()
-
-		go func() {
-			defer close(done)
-			c.refreshLoop(ctx)
-		}()
-		return
-	}
-}
-
-// Stop stops the background refresh loop.
-// It is safe to call multiple times.
-func (c *opsWSQPSCache) Stop() {
-	if c == nil {
-		return
-	}
-
-	c.mu.Lock()
-	if !c.running {
-		done := c.done
-		c.mu.Unlock()
-		if done != nil {
-			<-done
-		}
-		return
-	}
-	cancel := c.cancel
-	c.cancel = nil
-	c.running = false
-	c.opsService = nil
-	done := c.done
-	c.mu.Unlock()
-
-	if cancel != nil {
-		cancel()
-	}
-	if done != nil {
-		<-done
-	}
-
-	c.mu.Lock()
-	if c.done == done && !c.running {
-		c.done = nil
-	}
-	c.mu.Unlock()
-}
-
-func (c *opsWSQPSCache) refreshLoop(ctx context.Context) {
-	ticker := time.NewTicker(c.refreshInterval)
-	defer ticker.Stop()
-
-	c.refresh(ctx)
-	for {
-		select {
-		case <-ticker.C:
-			c.refresh(ctx)
-		case <-ctx.Done():
-			return
-		}
-	}
-}
-
-func (c *opsWSQPSCache) refresh(parentCtx context.Context) {
-	if c == nil {
-		return
-	}
-
-	c.mu.Lock()
-	opsService := c.opsService
-	c.mu.Unlock()
-	if opsService == nil {
-		return
-	}
-
-	if parentCtx == nil {
-		parentCtx = context.Background()
-	}
-	ctx, cancel := context.WithTimeout(parentCtx, 10*time.Second)
-	defer cancel()
-
-	now := time.Now().UTC()
-	stats, err := opsService.GetWindowStats(ctx, now.Add(-c.requestCountWindow), now)
-	if err != nil || stats == nil {
-		if err != nil {
-			log.Printf("[OpsWS] refresh: get window stats failed: %v", err)
-		}
-		return
-	}
-
-	requestCount := stats.SuccessCount + stats.ErrorCountTotal
-	qps := 0.0
-	tps := 0.0
-	if c.requestCountWindow > 0 {
-		seconds := c.requestCountWindow.Seconds()
-		qps = roundTo1DP(float64(requestCount) / seconds)
-		tps = roundTo1DP(float64(stats.TokenConsumed) / seconds)
-	}
-
-	payload := gin.H{
-		"type":      "qps_update",
-		"timestamp": now.Format(time.RFC3339),
-		"data": gin.H{
-			"qps":           qps,
-			"tps":           tps,
-			"request_count": requestCount,
-		},
-	}
-
-	msg, err := json.Marshal(payload)
-	if err != nil {
-		log.Printf("[OpsWS] refresh: marshal payload failed: %v", err)
-		return
-	}
-
-	c.payload.Store(msg)
-	c.lastUpdatedUnixNano.Store(now.UnixNano())
-}
-
-func roundTo1DP(v float64) float64 {
-	return math.Round(v*10) / 10
-}
-
-func (c *opsWSQPSCache) getPayload() []byte {
-	if c == nil {
-		return nil
-	}
-	if cached, ok := c.payload.Load().([]byte); ok && cached != nil {
-		return cached
-	}
-	return nil
-}
-
-func closeWS(conn *websocket.Conn, code int, reason string) {
-	if conn == nil {
-		return
-	}
-	msg := websocket.FormatCloseMessage(code, reason)
-	_ = conn.WriteControl(websocket.CloseMessage, msg, time.Now().Add(qpsWSWriteTimeout))
-	_ = conn.Close()
-}
-
-// QPSWSHandler handles realtime QPS push via WebSocket.
-// GET /api/v1/admin/ops/ws/qps
-func (h *OpsHandler) QPSWSHandler(c *gin.Context) {
-	clientIP := requestClientIP(c.Request)
-
-	if h == nil || h.opsService == nil {
-		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "ops service not initialized"})
-		return
-	}
-
-	// If realtime monitoring is disabled, prefer a successful WS upgrade followed by a clean close
-	// with a deterministic close code. This prevents clients from spinning on 404/1006 reconnect loops.
-	if !h.opsService.IsRealtimeMonitoringEnabled(c.Request.Context()) {
-		conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
-		if err != nil {
-			c.JSON(http.StatusNotFound, gin.H{"error": "ops realtime monitoring is disabled"})
-			return
-		}
-		closeWS(conn, opsWSCloseRealtimeDisabled, "realtime_disabled")
-		return
-	}
-
-	cancelQPSWSIdleStop()
-	// Lazily start the background refresh loop so unit tests that never hit the
-	// websocket route don't spawn goroutines that depend on DB/Redis stubs.
-	qpsWSCache.start(h.opsService)
-
-	// Reserve a global slot before upgrading the connection to keep the limit strict.
-	if !tryAcquireOpsWSTotalSlot(opsWSLimits.MaxConns) {
-		log.Printf("[OpsWS] connection limit reached: %d/%d", wsConnCount.Load(), opsWSLimits.MaxConns)
-		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "too many connections"})
-		return
-	}
-	defer func() {
-		if wsConnCount.Add(-1) == 0 {
-			scheduleQPSWSIdleStop()
-		}
-	}()
-
-	if opsWSLimits.MaxConnsPerIP > 0 && clientIP != "" {
-		if !tryAcquireOpsWSIPSlot(clientIP, opsWSLimits.MaxConnsPerIP) {
-			log.Printf("[OpsWS] per-ip connection limit reached: ip=%s limit=%d", clientIP, opsWSLimits.MaxConnsPerIP)
-			c.JSON(http.StatusServiceUnavailable, gin.H{"error": "too many connections"})
-			return
-		}
-		defer releaseOpsWSIPSlot(clientIP)
-	}
-
-	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
-	if err != nil {
-		log.Printf("[OpsWS] upgrade failed: %v", err)
-		return
-	}
-
-	defer func() {
-		_ = conn.Close()
-	}()
-
-	handleQPSWebSocket(c.Request.Context(), conn)
-}
-
-func tryAcquireOpsWSTotalSlot(limit int32) bool {
-	if limit <= 0 {
-		return true
-	}
-	for {
-		current := wsConnCount.Load()
-		if current >= limit {
-			return false
-		}
-		if wsConnCount.CompareAndSwap(current, current+1) {
-			return true
-		}
-	}
-}
-
-func tryAcquireOpsWSIPSlot(clientIP string, limit int32) bool {
-	if strings.TrimSpace(clientIP) == "" || limit <= 0 {
-		return true
-	}
-
-	v, _ := wsConnCountByIP.LoadOrStore(clientIP, &atomic.Int32{})
-	counter, ok := v.(*atomic.Int32)
-	if !ok {
-		return false
-	}
-
-	for {
-		current := counter.Load()
-		if current >= limit {
-			return false
-		}
-		if counter.CompareAndSwap(current, current+1) {
-			return true
-		}
-	}
-}
-
-func releaseOpsWSIPSlot(clientIP string) {
-	if strings.TrimSpace(clientIP) == "" {
-		return
-	}
-
-	v, ok := wsConnCountByIP.Load(clientIP)
-	if !ok {
-		return
-	}
-	counter, ok := v.(*atomic.Int32)
-	if !ok {
-		return
-	}
-	next := counter.Add(-1)
-	if next <= 0 {
-		// Best-effort cleanup; safe even if a new slot was acquired concurrently.
-		wsConnCountByIP.Delete(clientIP)
-	}
-}
-
-func handleQPSWebSocket(parentCtx context.Context, conn *websocket.Conn) {
-	if conn == nil {
-		return
-	}
-
-	ctx, cancel := context.WithCancel(parentCtx)
-	defer cancel()
-
-	var closeOnce sync.Once
-	closeConn := func() {
-		closeOnce.Do(func() {
-			_ = conn.Close()
-		})
-	}
-
-	closeFrameCh := make(chan []byte, 1)
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		defer cancel()
-
-		conn.SetReadLimit(qpsWSMaxReadBytes)
-		if err := conn.SetReadDeadline(time.Now().Add(qpsWSPongWait)); err != nil {
-			log.Printf("[OpsWS] set read deadline failed: %v", err)
-			return
-		}
-		conn.SetPongHandler(func(string) error {
-			return conn.SetReadDeadline(time.Now().Add(qpsWSPongWait))
-		})
-		conn.SetCloseHandler(func(code int, text string) error {
-			select {
-			case closeFrameCh <- websocket.FormatCloseMessage(code, text):
-			default:
-			}
-			cancel()
-			return nil
-		})
-
-		for {
-			_, _, err := conn.ReadMessage()
-			if err != nil {
-				if websocket.IsUnexpectedCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway, websocket.CloseNoStatusReceived) {
-					log.Printf("[OpsWS] read failed: %v", err)
-				}
-				return
-			}
-		}
-	}()
-
-	// Push QPS data every 2 seconds (values are globally cached and refreshed at most once per qpsWSRefreshInterval).
-	pushTicker := time.NewTicker(qpsWSPushInterval)
-	defer pushTicker.Stop()
-
-	// Heartbeat ping every 30 seconds.
-	pingTicker := time.NewTicker(qpsWSPingInterval)
-	defer pingTicker.Stop()
-
-	writeWithTimeout := func(messageType int, data []byte) error {
-		if err := conn.SetWriteDeadline(time.Now().Add(qpsWSWriteTimeout)); err != nil {
-			return err
-		}
-		return conn.WriteMessage(messageType, data)
-	}
-
-	sendClose := func(closeFrame []byte) {
-		if closeFrame == nil {
-			closeFrame = websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")
-		}
-		_ = writeWithTimeout(websocket.CloseMessage, closeFrame)
-	}
-
-	for {
-		select {
-		case <-pushTicker.C:
-			msg := qpsWSCache.getPayload()
-			if msg == nil {
-				continue
-			}
-			if err := writeWithTimeout(websocket.TextMessage, msg); err != nil {
-				log.Printf("[OpsWS] write failed: %v", err)
-				cancel()
-				closeConn()
-				wg.Wait()
-				return
-			}
-
-		case <-pingTicker.C:
-			if err := writeWithTimeout(websocket.PingMessage, nil); err != nil {
-				log.Printf("[OpsWS] ping failed: %v", err)
-				cancel()
-				closeConn()
-				wg.Wait()
-				return
-			}
-
-		case closeFrame := <-closeFrameCh:
-			sendClose(closeFrame)
-			closeConn()
-			wg.Wait()
-			return
-
-		case <-ctx.Done():
-			var closeFrame []byte
-			select {
-			case closeFrame = <-closeFrameCh:
-			default:
-			}
-			sendClose(closeFrame)
-
-			closeConn()
-			wg.Wait()
-			return
-		}
-	}
-}
-
-func isAllowedOpsWSOrigin(r *http.Request) bool {
-	if r == nil {
-		return false
-	}
-	origin := strings.TrimSpace(r.Header.Get("Origin"))
-	if origin == "" {
-		switch strings.ToLower(strings.TrimSpace(opsWSProxyConfig.OriginPolicy)) {
-		case OriginPolicyStrict:
-			return false
-		case OriginPolicyPermissive, "":
-			return true
-		default:
-			return true
-		}
-	}
-	parsed, err := url.Parse(origin)
-	if err != nil || parsed.Hostname() == "" {
-		return false
-	}
-	originHost := strings.ToLower(parsed.Hostname())
-
-	trustProxyHeaders := shouldTrustOpsWSProxyHeaders(r)
-	reqHost := hostWithoutPort(r.Host)
-	if trustProxyHeaders {
-		xfHost := strings.TrimSpace(r.Header.Get("X-Forwarded-Host"))
-		if xfHost != "" {
-			xfHost = strings.TrimSpace(strings.Split(xfHost, ",")[0])
-			if xfHost != "" {
-				reqHost = hostWithoutPort(xfHost)
-			}
-		}
-	}
-	reqHost = strings.ToLower(reqHost)
-	if reqHost == "" {
-		return false
-	}
-	return originHost == reqHost
-}
-
-func shouldTrustOpsWSProxyHeaders(r *http.Request) bool {
-	if r == nil {
-		return false
-	}
-	if !opsWSProxyConfig.TrustProxy {
-		return false
-	}
-	peerIP, ok := requestPeerIP(r)
-	if !ok {
-		return false
-	}
-	return isAddrInTrustedProxies(peerIP, opsWSProxyConfig.TrustedProxies)
-}
-
-func requestPeerIP(r *http.Request) (netip.Addr, bool) {
-	if r == nil {
-		return netip.Addr{}, false
-	}
-	host, _, err := net.SplitHostPort(strings.TrimSpace(r.RemoteAddr))
-	if err != nil {
-		host = strings.TrimSpace(r.RemoteAddr)
-	}
-	host = strings.TrimPrefix(host, "[")
-	host = strings.TrimSuffix(host, "]")
-	if host == "" {
-		return netip.Addr{}, false
-	}
-	addr, err := netip.ParseAddr(host)
-	if err != nil {
-		return netip.Addr{}, false
-	}
-	return addr.Unmap(), true
-}
-
-func requestClientIP(r *http.Request) string {
-	if r == nil {
-		return ""
-	}
-
-	trustProxyHeaders := shouldTrustOpsWSProxyHeaders(r)
-	if trustProxyHeaders {
-		xff := strings.TrimSpace(r.Header.Get("X-Forwarded-For"))
-		if xff != "" {
-			// Use the left-most entry (original client). If multiple proxies add values, they are comma-separated.
-			xff = strings.TrimSpace(strings.Split(xff, ",")[0])
-			xff = strings.TrimPrefix(xff, "[")
-			xff = strings.TrimSuffix(xff, "]")
-			if addr, err := netip.ParseAddr(xff); err == nil && addr.IsValid() {
-				return addr.Unmap().String()
-			}
-		}
-	}
-
-	if peer, ok := requestPeerIP(r); ok && peer.IsValid() {
-		return peer.String()
-	}
-	return ""
-}
-
-func isAddrInTrustedProxies(addr netip.Addr, trusted []netip.Prefix) bool {
-	if !addr.IsValid() {
-		return false
-	}
-	for _, p := range trusted {
-		if p.Contains(addr) {
-			return true
-		}
-	}
-	return false
-}
-
-func loadOpsWSProxyConfigFromEnv() OpsWSProxyConfig {
-	cfg := OpsWSProxyConfig{
-		TrustProxy:     true,
-		TrustedProxies: defaultTrustedProxies(),
-		OriginPolicy:   OriginPolicyPermissive,
-	}
-
-	if v := strings.TrimSpace(os.Getenv(envOpsWSTrustProxy)); v != "" {
-		if parsed, err := strconv.ParseBool(v); err == nil {
-			cfg.TrustProxy = parsed
-		} else {
-			log.Printf("[OpsWS] invalid %s=%q (expected bool); using default=%v", envOpsWSTrustProxy, v, cfg.TrustProxy)
-		}
-	}
-
-	if raw := strings.TrimSpace(os.Getenv(envOpsWSTrustedProxies)); raw != "" {
-		prefixes, invalid := parseTrustedProxyList(raw)
-		if len(invalid) > 0 {
-			log.Printf("[OpsWS] invalid %s entries ignored: %s", envOpsWSTrustedProxies, strings.Join(invalid, ", "))
-		}
-		cfg.TrustedProxies = prefixes
-	}
-
-	if v := strings.TrimSpace(os.Getenv(envOpsWSOriginPolicy)); v != "" {
-		normalized := strings.ToLower(v)
-		switch normalized {
-		case OriginPolicyStrict, OriginPolicyPermissive:
-			cfg.OriginPolicy = normalized
-		default:
-			log.Printf("[OpsWS] invalid %s=%q (expected %q or %q); using default=%q", envOpsWSOriginPolicy, v, OriginPolicyStrict, OriginPolicyPermissive, cfg.OriginPolicy)
-		}
-	}
-
-	return cfg
-}
-
-func loadOpsWSRuntimeLimitsFromEnv() opsWSRuntimeLimits {
-	cfg := opsWSRuntimeLimits{
-		MaxConns:      defaultMaxWSConns,
-		MaxConnsPerIP: defaultMaxWSConnsPerIP,
-	}
-
-	if v := strings.TrimSpace(os.Getenv(envOpsWSMaxConns)); v != "" {
-		if parsed, err := strconv.Atoi(v); err == nil && parsed > 0 {
-			cfg.MaxConns = int32(parsed)
-		} else {
-			log.Printf("[OpsWS] invalid %s=%q (expected int>0); using default=%d", envOpsWSMaxConns, v, cfg.MaxConns)
-		}
-	}
-	if v := strings.TrimSpace(os.Getenv(envOpsWSMaxConnsPerIP)); v != "" {
-		if parsed, err := strconv.Atoi(v); err == nil && parsed >= 0 {
-			cfg.MaxConnsPerIP = int32(parsed)
-		} else {
-			log.Printf("[OpsWS] invalid %s=%q (expected int>=0); using default=%d", envOpsWSMaxConnsPerIP, v, cfg.MaxConnsPerIP)
-		}
-	}
-	return cfg
-}
-
-func defaultTrustedProxies() []netip.Prefix {
-	prefixes, _ := parseTrustedProxyList("127.0.0.0/8,::1/128")
-	return prefixes
-}
-
-func parseTrustedProxyList(raw string) (prefixes []netip.Prefix, invalid []string) {
-	for _, token := range strings.Split(raw, ",") {
-		item := strings.TrimSpace(token)
-		if item == "" {
-			continue
-		}
-
-		var (
-			p   netip.Prefix
-			err error
-		)
-		if strings.Contains(item, "/") {
-			p, err = netip.ParsePrefix(item)
-		} else {
-			var addr netip.Addr
-			addr, err = netip.ParseAddr(item)
-			if err == nil {
-				addr = addr.Unmap()
-				bits := 128
-				if addr.Is4() {
-					bits = 32
-				}
-				p = netip.PrefixFrom(addr, bits)
-			}
-		}
-
-		if err != nil || !p.IsValid() {
-			invalid = append(invalid, item)
-			continue
-		}
-
-		prefixes = append(prefixes, p.Masked())
-	}
-	return prefixes, invalid
-}
-
-func hostWithoutPort(hostport string) string {
-	hostport = strings.TrimSpace(hostport)
-	if hostport == "" {
-		return ""
-	}
-	if host, _, err := net.SplitHostPort(hostport); err == nil {
-		return host
-	}
-	if strings.HasPrefix(hostport, "[") && strings.HasSuffix(hostport, "]") {
-		return strings.Trim(hostport, "[]")
-	}
-	parts := strings.Split(hostport, ":")
-	return parts[0]
-}

backend/internal/handler/admin/proxy_handler.go

@@ -196,28 +196,6 @@ func (h *ProxyHandler) Delete(c *gin.Context) {
 	response.Success(c, gin.H{"message": "Proxy deleted successfully"})
 }
 
-// BatchDelete handles batch deleting proxies
-// POST /api/v1/admin/proxies/batch-delete
-func (h *ProxyHandler) BatchDelete(c *gin.Context) {
-	type BatchDeleteRequest struct {
-		IDs []int64 `json:"ids" binding:"required,min=1"`
-	}
-
-	var req BatchDeleteRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request: "+err.Error())
-		return
-	}
-
-	result, err := h.adminService.BatchDeleteProxies(c.Request.Context(), req.IDs)
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	response.Success(c, result)
-}
-
 // Test handles testing proxy connectivity
 // POST /api/v1/admin/proxies/:id/test
 func (h *ProxyHandler) Test(c *gin.Context) {
@@ -265,17 +243,19 @@ func (h *ProxyHandler) GetProxyAccounts(c *gin.Context) {
 		return
 	}
 
-	accounts, err := h.adminService.GetProxyAccounts(c.Request.Context(), proxyID)
+	page, pageSize := response.ParsePagination(c)
+
+	accounts, total, err := h.adminService.GetProxyAccounts(c.Request.Context(), proxyID, page, pageSize)
 	if err != nil {
 		response.ErrorFrom(c, err)
 		return
 	}
 
-	out := make([]dto.ProxyAccountSummary, 0, len(accounts))
+	out := make([]dto.Account, 0, len(accounts))
 	for i := range accounts {
-		out = append(out, *dto.ProxyAccountSummaryFromService(&accounts[i]))
+		out = append(out, *dto.AccountFromService(&accounts[i]))
 	}
-	response.Success(c, out)
+	response.Paginated(c, out, total, page, pageSize)
 }
 
 // BatchCreateProxyItem represents a single proxy in batch create request

backend/internal/handler/admin/setting_handler.go

@@ -19,16 +19,14 @@ type SettingHandler struct {
 	settingService   *service.SettingService
 	emailService     *service.EmailService
 	turnstileService *service.TurnstileService
-	opsService       *service.OpsService
 }
 
 // NewSettingHandler 创建系统设置处理器
-func NewSettingHandler(settingService *service.SettingService, emailService *service.EmailService, turnstileService *service.TurnstileService, opsService *service.OpsService) *SettingHandler {
+func NewSettingHandler(settingService *service.SettingService, emailService *service.EmailService, turnstileService *service.TurnstileService) *SettingHandler {
 	return &SettingHandler{
 		settingService:   settingService,
 		emailService:     emailService,
 		turnstileService: turnstileService,
-		opsService:       opsService,
 	}
 }
 
@@ -41,9 +39,6 @@ func (h *SettingHandler) GetSettings(c *gin.Context) {
 		return
 	}
 
-	// Check if ops monitoring is enabled (respects config.ops.enabled)
-	opsEnabled := h.opsService != nil && h.opsService.IsMonitoringEnabled(c.Request.Context())
-
 	response.Success(c, dto.SystemSettings{
 		RegistrationEnabled:                  settings.RegistrationEnabled,
 		EmailVerifyEnabled:                   settings.EmailVerifyEnabled,
@@ -77,10 +72,6 @@ func (h *SettingHandler) GetSettings(c *gin.Context) {
 		FallbackModelAntigravity:             settings.FallbackModelAntigravity,
 		EnableIdentityPatch:                  settings.EnableIdentityPatch,
 		IdentityPatchPrompt:                  settings.IdentityPatchPrompt,
-		OpsMonitoringEnabled:                 opsEnabled && settings.OpsMonitoringEnabled,
-		OpsRealtimeMonitoringEnabled:         settings.OpsRealtimeMonitoringEnabled,
-		OpsQueryModeDefault:                  settings.OpsQueryModeDefault,
-		OpsMetricsIntervalSeconds:            settings.OpsMetricsIntervalSeconds,
 	})
 }
 
@@ -104,7 +95,7 @@ type UpdateSettingsRequest struct {
 	TurnstileSiteKey   string `json:"turnstile_site_key"`
 	TurnstileSecretKey string `json:"turnstile_secret_key"`
 
-	// LinuxDo Connect OAuth 登录
+	// LinuxDo Connect OAuth 登录（终端用户 SSO）
 	LinuxDoConnectEnabled      bool   `json:"linuxdo_connect_enabled"`
 	LinuxDoConnectClientID     string `json:"linuxdo_connect_client_id"`
 	LinuxDoConnectClientSecret string `json:"linuxdo_connect_client_secret"`
@@ -133,12 +124,6 @@ type UpdateSettingsRequest struct {
 	// Identity patch configuration (Claude -> Gemini)
 	EnableIdentityPatch bool   `json:"enable_identity_patch"`
 	IdentityPatchPrompt string `json:"identity_patch_prompt"`
-
-	// Ops monitoring (vNext)
-	OpsMonitoringEnabled         *bool   `json:"ops_monitoring_enabled"`
-	OpsRealtimeMonitoringEnabled *bool   `json:"ops_realtime_monitoring_enabled"`
-	OpsQueryModeDefault          *string `json:"ops_query_mode_default"`
-	OpsMetricsIntervalSeconds    *int    `json:"ops_metrics_interval_seconds"`
 }
 
 // UpdateSettings 更新系统设置
@@ -223,18 +208,6 @@ func (h *SettingHandler) UpdateSettings(c *gin.Context) {
 		}
 	}
 
-	// Ops metrics collector interval validation (seconds).
-	if req.OpsMetricsIntervalSeconds != nil {
-		v := *req.OpsMetricsIntervalSeconds
-		if v < 60 {
-			v = 60
-		}
-		if v > 3600 {
-			v = 3600
-		}
-		req.OpsMetricsIntervalSeconds = &v
-	}
-
 	settings := &service.SystemSettings{
 		RegistrationEnabled:        req.RegistrationEnabled,
 		EmailVerifyEnabled:         req.EmailVerifyEnabled,
@@ -268,30 +241,6 @@ func (h *SettingHandler) UpdateSettings(c *gin.Context) {
 		FallbackModelAntigravity:   req.FallbackModelAntigravity,
 		EnableIdentityPatch:        req.EnableIdentityPatch,
 		IdentityPatchPrompt:        req.IdentityPatchPrompt,
-		OpsMonitoringEnabled: func() bool {
-			if req.OpsMonitoringEnabled != nil {
-				return *req.OpsMonitoringEnabled
-			}
-			return previousSettings.OpsMonitoringEnabled
-		}(),
-		OpsRealtimeMonitoringEnabled: func() bool {
-			if req.OpsRealtimeMonitoringEnabled != nil {
-				return *req.OpsRealtimeMonitoringEnabled
-			}
-			return previousSettings.OpsRealtimeMonitoringEnabled
-		}(),
-		OpsQueryModeDefault: func() string {
-			if req.OpsQueryModeDefault != nil {
-				return *req.OpsQueryModeDefault
-			}
-			return previousSettings.OpsQueryModeDefault
-		}(),
-		OpsMetricsIntervalSeconds: func() int {
-			if req.OpsMetricsIntervalSeconds != nil {
-				return *req.OpsMetricsIntervalSeconds
-			}
-			return previousSettings.OpsMetricsIntervalSeconds
-		}(),
 	}
 
 	if err := h.settingService.UpdateSettings(c.Request.Context(), settings); err != nil {
@@ -341,10 +290,6 @@ func (h *SettingHandler) UpdateSettings(c *gin.Context) {
 		FallbackModelAntigravity:             updatedSettings.FallbackModelAntigravity,
 		EnableIdentityPatch:                  updatedSettings.EnableIdentityPatch,
 		IdentityPatchPrompt:                  updatedSettings.IdentityPatchPrompt,
-		OpsMonitoringEnabled:                 updatedSettings.OpsMonitoringEnabled,
-		OpsRealtimeMonitoringEnabled:         updatedSettings.OpsRealtimeMonitoringEnabled,
-		OpsQueryModeDefault:                  updatedSettings.OpsQueryModeDefault,
-		OpsMetricsIntervalSeconds:            updatedSettings.OpsMetricsIntervalSeconds,
 	})
 }
 
@@ -466,18 +411,6 @@ func diffSettings(before *service.SystemSettings, after *service.SystemSettings,
 	if before.IdentityPatchPrompt != after.IdentityPatchPrompt {
 		changed = append(changed, "identity_patch_prompt")
 	}
-	if before.OpsMonitoringEnabled != after.OpsMonitoringEnabled {
-		changed = append(changed, "ops_monitoring_enabled")
-	}
-	if before.OpsRealtimeMonitoringEnabled != after.OpsRealtimeMonitoringEnabled {
-		changed = append(changed, "ops_realtime_monitoring_enabled")
-	}
-	if before.OpsQueryModeDefault != after.OpsQueryModeDefault {
-		changed = append(changed, "ops_query_mode_default")
-	}
-	if before.OpsMetricsIntervalSeconds != after.OpsMetricsIntervalSeconds {
-		changed = append(changed, "ops_metrics_interval_seconds")
-	}
 	return changed
 }
 
@@ -654,68 +587,3 @@ func (h *SettingHandler) DeleteAdminAPIKey(c *gin.Context) {
 
 	response.Success(c, gin.H{"message": "Admin API key deleted"})
 }
-
-// GetStreamTimeoutSettings 获取流超时处理配置
-// GET /api/v1/admin/settings/stream-timeout
-func (h *SettingHandler) GetStreamTimeoutSettings(c *gin.Context) {
-	settings, err := h.settingService.GetStreamTimeoutSettings(c.Request.Context())
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	response.Success(c, dto.StreamTimeoutSettings{
-		Enabled:                settings.Enabled,
-		Action:                 settings.Action,
-		TempUnschedMinutes:     settings.TempUnschedMinutes,
-		ThresholdCount:         settings.ThresholdCount,
-		ThresholdWindowMinutes: settings.ThresholdWindowMinutes,
-	})
-}
-
-// UpdateStreamTimeoutSettingsRequest 更新流超时配置请求
-type UpdateStreamTimeoutSettingsRequest struct {
-	Enabled                bool   `json:"enabled"`
-	Action                 string `json:"action"`
-	TempUnschedMinutes     int    `json:"temp_unsched_minutes"`
-	ThresholdCount         int    `json:"threshold_count"`
-	ThresholdWindowMinutes int    `json:"threshold_window_minutes"`
-}
-
-// UpdateStreamTimeoutSettings 更新流超时处理配置
-// PUT /api/v1/admin/settings/stream-timeout
-func (h *SettingHandler) UpdateStreamTimeoutSettings(c *gin.Context) {
-	var req UpdateStreamTimeoutSettingsRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		response.BadRequest(c, "Invalid request: "+err.Error())
-		return
-	}
-
-	settings := &service.StreamTimeoutSettings{
-		Enabled:                req.Enabled,
-		Action:                 req.Action,
-		TempUnschedMinutes:     req.TempUnschedMinutes,
-		ThresholdCount:         req.ThresholdCount,
-		ThresholdWindowMinutes: req.ThresholdWindowMinutes,
-	}
-
-	if err := h.settingService.SetStreamTimeoutSettings(c.Request.Context(), settings); err != nil {
-		response.BadRequest(c, err.Error())
-		return
-	}
-
-	// 重新获取设置返回
-	updatedSettings, err := h.settingService.GetStreamTimeoutSettings(c.Request.Context())
-	if err != nil {
-		response.ErrorFrom(c, err)
-		return
-	}
-
-	response.Success(c, dto.StreamTimeoutSettings{
-		Enabled:                updatedSettings.Enabled,
-		Action:                 updatedSettings.Action,
-		TempUnschedMinutes:     updatedSettings.TempUnschedMinutes,
-		ThresholdCount:         updatedSettings.ThresholdCount,
-		ThresholdWindowMinutes: updatedSettings.ThresholdWindowMinutes,
-	})
-}

backend/internal/handler/auth_handler.go

@@ -3,7 +3,6 @@ package handler
 import (
 	"github.com/Wei-Shaw/sub2api/internal/config"
 	"github.com/Wei-Shaw/sub2api/internal/handler/dto"
-	"github.com/Wei-Shaw/sub2api/internal/pkg/ip"
 	"github.com/Wei-Shaw/sub2api/internal/pkg/response"
 	middleware2 "github.com/Wei-Shaw/sub2api/internal/server/middleware"
 	"github.com/Wei-Shaw/sub2api/internal/service"
@@ -77,7 +76,7 @@ func (h *AuthHandler) Register(c *gin.Context) {
 
 	// Turnstile 验证（当提供了邮箱验证码时跳过，因为发送验证码时已验证过）
 	if req.VerifyCode == "" {
-		if err := h.authService.VerifyTurnstile(c.Request.Context(), req.TurnstileToken, ip.GetClientIP(c)); err != nil {
+		if err := h.authService.VerifyTurnstile(c.Request.Context(), req.TurnstileToken, c.ClientIP()); err != nil {
 			response.ErrorFrom(c, err)
 			return
 		}
@@ -106,7 +105,7 @@ func (h *AuthHandler) SendVerifyCode(c *gin.Context) {
 	}
 
 	// Turnstile 验证
-	if err := h.authService.VerifyTurnstile(c.Request.Context(), req.TurnstileToken, ip.GetClientIP(c)); err != nil {
+	if err := h.authService.VerifyTurnstile(c.Request.Context(), req.TurnstileToken, c.ClientIP()); err != nil {
 		response.ErrorFrom(c, err)
 		return
 	}
@@ -133,7 +132,7 @@ func (h *AuthHandler) Login(c *gin.Context) {
 	}
 
 	// Turnstile 验证
-	if err := h.authService.VerifyTurnstile(c.Request.Context(), req.TurnstileToken, ip.GetClientIP(c)); err != nil {
+	if err := h.authService.VerifyTurnstile(c.Request.Context(), req.TurnstileToken, c.ClientIP()); err != nil {
 		response.ErrorFrom(c, err)
 		return
 	}

backend/internal/handler/dto/mappers.go

@@ -125,7 +125,6 @@ func AccountFromServiceShallow(a *service.Account) *Account {
 		ProxyID:                 a.ProxyID,
 		Concurrency:             a.Concurrency,
 		Priority:                a.Priority,
-		RateMultiplier:          a.BillingRateMultiplier(),
 		Status:                  a.Status,
 		ErrorMessage:            a.ErrorMessage,
 		LastUsedAt:              a.LastUsedAt,
@@ -213,29 +212,8 @@ func ProxyWithAccountCountFromService(p *service.ProxyWithAccountCount) *ProxyWi
 		return nil
 	}
 	return &ProxyWithAccountCount{
-		Proxy:          *ProxyFromService(&p.Proxy),
-		AccountCount:   p.AccountCount,
-		LatencyMs:      p.LatencyMs,
-		LatencyStatus:  p.LatencyStatus,
-		LatencyMessage: p.LatencyMessage,
-		IPAddress:      p.IPAddress,
-		Country:        p.Country,
-		CountryCode:    p.CountryCode,
-		Region:         p.Region,
-		City:           p.City,
-	}
-}
-
-func ProxyAccountSummaryFromService(a *service.ProxyAccountSummary) *ProxyAccountSummary {
-	if a == nil {
-		return nil
-	}
-	return &ProxyAccountSummary{
-		ID:       a.ID,
-		Name:     a.Name,
-		Platform: a.Platform,
-		Type:     a.Type,
-		Notes:    a.Notes,
+		Proxy:        *ProxyFromService(&p.Proxy),
+		AccountCount: p.AccountCount,
 	}
 }
 
@@ -301,7 +279,6 @@ func usageLogFromServiceBase(l *service.UsageLog, account *AccountSummary, inclu
 		TotalCost:             l.TotalCost,
 		ActualCost:            l.ActualCost,
 		RateMultiplier:        l.RateMultiplier,
-		AccountRateMultiplier: l.AccountRateMultiplier,
 		BillingType:           l.BillingType,
 		Stream:                l.Stream,
 		DurationMs:            l.DurationMs,

backend/internal/handler/dto/settings.go

@@ -43,12 +43,6 @@ type SystemSettings struct {
 	// Identity patch configuration (Claude -> Gemini)
 	EnableIdentityPatch bool   `json:"enable_identity_patch"`
 	IdentityPatchPrompt string `json:"identity_patch_prompt"`
-
-	// Ops monitoring (vNext)
-	OpsMonitoringEnabled         bool   `json:"ops_monitoring_enabled"`
-	OpsRealtimeMonitoringEnabled bool   `json:"ops_realtime_monitoring_enabled"`
-	OpsQueryModeDefault          string `json:"ops_query_mode_default"`
-	OpsMetricsIntervalSeconds    int    `json:"ops_metrics_interval_seconds"`
 }
 
 type PublicSettings struct {
@@ -66,12 +60,3 @@ type PublicSettings struct {
 	LinuxDoOAuthEnabled bool   `json:"linuxdo_oauth_enabled"`
 	Version             string `json:"version"`
 }
-
-// StreamTimeoutSettings 流超时处理配置 DTO
-type StreamTimeoutSettings struct {
-	Enabled                bool   `json:"enabled"`
-	Action                 string `json:"action"`
-	TempUnschedMinutes     int    `json:"temp_unsched_minutes"`
-	ThresholdCount         int    `json:"threshold_count"`
-	ThresholdWindowMinutes int    `json:"threshold_window_minutes"`
-}

backend/internal/handler/dto/types.go

@@ -76,7 +76,6 @@ type Account struct {
 	ProxyID            *int64         `json:"proxy_id"`
 	Concurrency        int            `json:"concurrency"`
 	Priority           int            `json:"priority"`
-	RateMultiplier     float64        `json:"rate_multiplier"`
 	Status             string         `json:"status"`
 	ErrorMessage       string         `json:"error_message"`
 	LastUsedAt         *time.Time     `json:"last_used_at"`
@@ -130,23 +129,7 @@ type Proxy struct {
 
 type ProxyWithAccountCount struct {
 	Proxy
-	AccountCount   int64  `json:"account_count"`
-	LatencyMs      *int64 `json:"latency_ms,omitempty"`
-	LatencyStatus  string `json:"latency_status,omitempty"`
-	LatencyMessage string `json:"latency_message,omitempty"`
-	IPAddress      string `json:"ip_address,omitempty"`
-	Country        string `json:"country,omitempty"`
-	CountryCode    string `json:"country_code,omitempty"`
-	Region         string `json:"region,omitempty"`
-	City           string `json:"city,omitempty"`
-}
-
-type ProxyAccountSummary struct {
-	ID       int64   `json:"id"`
-	Name     string  `json:"name"`
-	Platform string  `json:"platform"`
-	Type     string  `json:"type"`
-	Notes    *string `json:"notes,omitempty"`
+	AccountCount int64 `json:"account_count"`
 }
 
 type RedeemCode struct {
@@ -186,14 +169,13 @@ type UsageLog struct {
 	CacheCreation5mTokens int `json:"cache_creation_5m_tokens"`
 	CacheCreation1hTokens int `json:"cache_creation_1h_tokens"`
 
-	InputCost             float64  `json:"input_cost"`
-	OutputCost            float64  `json:"output_cost"`
-	CacheCreationCost     float64  `json:"cache_creation_cost"`
-	CacheReadCost         float64  `json:"cache_read_cost"`
-	TotalCost             float64  `json:"total_cost"`
-	ActualCost            float64  `json:"actual_cost"`
-	RateMultiplier        float64  `json:"rate_multiplier"`
-	AccountRateMultiplier *float64 `json:"account_rate_multiplier"`
+	InputCost         float64 `json:"input_cost"`
+	OutputCost        float64 `json:"output_cost"`
+	CacheCreationCost float64 `json:"cache_creation_cost"`
+	CacheReadCost     float64 `json:"cache_read_cost"`
+	TotalCost         float64 `json:"total_cost"`
+	ActualCost        float64 `json:"actual_cost"`
+	RateMultiplier    float64 `json:"rate_multiplier"`
 
 	BillingType  int8 `json:"billing_type"`
 	Stream       bool `json:"stream"`

backend/internal/handler/gateway_handler.go

@@ -89,11 +89,6 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 		return
 	}
 
-	// 检查是否为 Claude Code 客户端，设置到 context 中
-	SetClaudeCodeClientContext(c, body)
-
-	setOpsRequestContext(c, "", false, body)
-
 	parsedReq, err := service.ParseGatewayRequest(body)
 	if err != nil {
 		h.errorResponse(c, http.StatusBadRequest, "invalid_request_error", "Failed to parse request body")
@@ -102,7 +97,8 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 	reqModel := parsedReq.Model
 	reqStream := parsedReq.Stream
 
-	setOpsRequestContext(c, reqModel, reqStream, body)
+	// 设置 Claude Code 客户端标识到 context（用于分组限制检查）
+	SetClaudeCodeClientContext(c, body)
 
 	// 验证 model 必填
 	if reqModel == "" {
@@ -116,10 +112,15 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 	// 获取订阅信息（可能为nil）- 提前获取用于后续检查
 	subscription, _ := middleware2.GetSubscriptionFromContext(c)
 
+	// 获取 User-Agent
+	userAgent := c.Request.UserAgent()
+
+	// 获取客户端 IP
+	clientIP := ip.GetClientIP(c)
+
 	// 0. 检查wait队列是否已满
 	maxWait := service.CalculateMaxWait(subject.Concurrency)
 	canWait, err := h.concurrencyHelper.IncrementWaitCount(c.Request.Context(), subject.UserID, maxWait)
-	waitCounted := false
 	if err != nil {
 		log.Printf("Increment wait count failed: %v", err)
 		// On error, allow request to proceed
@@ -127,15 +128,8 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 		h.errorResponse(c, http.StatusTooManyRequests, "rate_limit_error", "Too many pending requests, please retry later")
 		return
 	}
-	if err == nil && canWait {
-		waitCounted = true
-	}
-	// Ensure we decrement if we exit before acquiring the user slot.
-	defer func() {
-		if waitCounted {
-			h.concurrencyHelper.DecrementWaitCount(c.Request.Context(), subject.UserID)
-		}
-	}()
+	// 确保在函数退出时减少wait计数
+	defer h.concurrencyHelper.DecrementWaitCount(c.Request.Context(), subject.UserID)
 
 	// 1. 首先获取用户并发槽位
 	userReleaseFunc, err := h.concurrencyHelper.AcquireUserSlotWithWait(c, subject.UserID, subject.Concurrency, reqStream, &streamStarted)
@@ -144,11 +138,6 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 		h.handleConcurrencyError(c, err, "user", streamStarted)
 		return
 	}
-	// User slot acquired: no longer waiting in the queue.
-	if waitCounted {
-		h.concurrencyHelper.DecrementWaitCount(c.Request.Context(), subject.UserID)
-		waitCounted = false
-	}
 	// 在请求结束或 Context 取消时确保释放槽位，避免客户端断开造成泄漏
 	userReleaseFunc = wrapReleaseOnDone(c.Request.Context(), userReleaseFunc)
 	if userReleaseFunc != nil {
@@ -195,7 +184,6 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 				return
 			}
 			account := selection.Account
-			setOpsSelectedAccount(c, account.ID)
 
 			// 检查预热请求拦截（在账号选择后、转发前检查）
 			if account.IsInterceptWarmupEnabled() && isWarmupRequest(body) {
@@ -212,12 +200,12 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 
 			// 3. 获取账号并发槽位
 			accountReleaseFunc := selection.ReleaseFunc
+			var accountWaitRelease func()
 			if !selection.Acquired {
 				if selection.WaitPlan == nil {
 					h.handleStreamingAwareError(c, http.StatusServiceUnavailable, "api_error", "No available accounts", streamStarted)
 					return
 				}
-				accountWaitCounted := false
 				canWait, err := h.concurrencyHelper.IncrementAccountWaitCount(c.Request.Context(), account.ID, selection.WaitPlan.MaxWaiting)
 				if err != nil {
 					log.Printf("Increment account wait count failed: %v", err)
@@ -225,16 +213,12 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 					log.Printf("Account wait queue full: account=%d", account.ID)
 					h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error", "Too many pending requests, please retry later", streamStarted)
 					return
-				}
-				if err == nil && canWait {
-					accountWaitCounted = true
-				}
-				// Ensure the wait counter is decremented if we exit before acquiring the slot.
-				defer func() {
-					if accountWaitCounted {
+				} else {
+					// Only set release function if increment succeeded
+					accountWaitRelease = func() {
 						h.concurrencyHelper.DecrementAccountWaitCount(c.Request.Context(), account.ID)
 					}
-				}()
+				}
 
 				accountReleaseFunc, err = h.concurrencyHelper.AcquireAccountSlotWithWaitTimeout(
 					c,
@@ -245,21 +229,20 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 					&streamStarted,
 				)
 				if err != nil {
+					if accountWaitRelease != nil {
+						accountWaitRelease()
+					}
 					log.Printf("Account concurrency acquire failed: %v", err)
 					h.handleConcurrencyError(c, err, "account", streamStarted)
 					return
 				}
-				// Slot acquired: no longer waiting in queue.
-				if accountWaitCounted {
-					h.concurrencyHelper.DecrementAccountWaitCount(c.Request.Context(), account.ID)
-					accountWaitCounted = false
-				}
 				if err := h.gatewayService.BindStickySession(c.Request.Context(), apiKey.GroupID, sessionKey, account.ID); err != nil {
 					log.Printf("Bind sticky session failed: %v", err)
 				}
 			}
 			// 账号槽位/等待计数需要在超时或断开时安全回收
 			accountReleaseFunc = wrapReleaseOnDone(c.Request.Context(), accountReleaseFunc)
+			accountWaitRelease = wrapReleaseOnDone(c.Request.Context(), accountWaitRelease)
 
 			// 转发请求 - 根据账号平台分流
 			var result *service.ForwardResult
@@ -271,15 +254,19 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 			if accountReleaseFunc != nil {
 				accountReleaseFunc()
 			}
+			if accountWaitRelease != nil {
+				accountWaitRelease()
+			}
 			if err != nil {
 				var failoverErr *service.UpstreamFailoverError
 				if errors.As(err, &failoverErr) {
 					failedAccountIDs[account.ID] = struct{}{}
-					lastFailoverStatus = failoverErr.StatusCode
 					if switchCount >= maxAccountSwitches {
+						lastFailoverStatus = failoverErr.StatusCode
 						h.handleFailoverExhausted(c, lastFailoverStatus, streamStarted)
 						return
 					}
+					lastFailoverStatus = failoverErr.StatusCode
 					switchCount++
 					log.Printf("Account %d: upstream error %d, switching account %d/%d", account.ID, failoverErr.StatusCode, switchCount, maxAccountSwitches)
 					continue
@@ -289,12 +276,8 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 				return
 			}
 
-			// 捕获请求信息（用于异步记录，避免在 goroutine 中访问 gin.Context）
-			userAgent := c.GetHeader("User-Agent")
-			clientIP := ip.GetClientIP(c)
-
 			// 异步记录使用量（subscription已在函数开头获取）
-			go func(result *service.ForwardResult, usedAccount *service.Account, ua, clientIP string) {
+			go func(result *service.ForwardResult, usedAccount *service.Account, ua string, cip string) {
 				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 				defer cancel()
 				if err := h.gatewayService.RecordUsage(ctx, &service.RecordUsageInput{
@@ -304,7 +287,7 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 					Account:      usedAccount,
 					Subscription: subscription,
 					UserAgent:    ua,
-					IPAddress:    clientIP,
+					IPAddress:    cip,
 				}); err != nil {
 					log.Printf("Record usage failed: %v", err)
 				}
@@ -330,7 +313,6 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 			return
 		}
 		account := selection.Account
-		setOpsSelectedAccount(c, account.ID)
 
 		// 检查预热请求拦截（在账号选择后、转发前检查）
 		if account.IsInterceptWarmupEnabled() && isWarmupRequest(body) {
@@ -347,12 +329,12 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 
 		// 3. 获取账号并发槽位
 		accountReleaseFunc := selection.ReleaseFunc
+		var accountWaitRelease func()
 		if !selection.Acquired {
 			if selection.WaitPlan == nil {
 				h.handleStreamingAwareError(c, http.StatusServiceUnavailable, "api_error", "No available accounts", streamStarted)
 				return
 			}
-			accountWaitCounted := false
 			canWait, err := h.concurrencyHelper.IncrementAccountWaitCount(c.Request.Context(), account.ID, selection.WaitPlan.MaxWaiting)
 			if err != nil {
 				log.Printf("Increment account wait count failed: %v", err)
@@ -360,15 +342,12 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 				log.Printf("Account wait queue full: account=%d", account.ID)
 				h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error", "Too many pending requests, please retry later", streamStarted)
 				return
-			}
-			if err == nil && canWait {
-				accountWaitCounted = true
-			}
-			defer func() {
-				if accountWaitCounted {
+			} else {
+				// Only set release function if increment succeeded
+				accountWaitRelease = func() {
 					h.concurrencyHelper.DecrementAccountWaitCount(c.Request.Context(), account.ID)
 				}
-			}()
+			}
 
 			accountReleaseFunc, err = h.concurrencyHelper.AcquireAccountSlotWithWaitTimeout(
 				c,
@@ -379,20 +358,20 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 				&streamStarted,
 			)
 			if err != nil {
+				if accountWaitRelease != nil {
+					accountWaitRelease()
+				}
 				log.Printf("Account concurrency acquire failed: %v", err)
 				h.handleConcurrencyError(c, err, "account", streamStarted)
 				return
 			}
-			if accountWaitCounted {
-				h.concurrencyHelper.DecrementAccountWaitCount(c.Request.Context(), account.ID)
-				accountWaitCounted = false
-			}
 			if err := h.gatewayService.BindStickySession(c.Request.Context(), apiKey.GroupID, sessionKey, account.ID); err != nil {
 				log.Printf("Bind sticky session failed: %v", err)
 			}
 		}
 		// 账号槽位/等待计数需要在超时或断开时安全回收
 		accountReleaseFunc = wrapReleaseOnDone(c.Request.Context(), accountReleaseFunc)
+		accountWaitRelease = wrapReleaseOnDone(c.Request.Context(), accountWaitRelease)
 
 		// 转发请求 - 根据账号平台分流
 		var result *service.ForwardResult
@@ -404,15 +383,19 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 		if accountReleaseFunc != nil {
 			accountReleaseFunc()
 		}
+		if accountWaitRelease != nil {
+			accountWaitRelease()
+		}
 		if err != nil {
 			var failoverErr *service.UpstreamFailoverError
 			if errors.As(err, &failoverErr) {
 				failedAccountIDs[account.ID] = struct{}{}
-				lastFailoverStatus = failoverErr.StatusCode
 				if switchCount >= maxAccountSwitches {
+					lastFailoverStatus = failoverErr.StatusCode
 					h.handleFailoverExhausted(c, lastFailoverStatus, streamStarted)
 					return
 				}
+				lastFailoverStatus = failoverErr.StatusCode
 				switchCount++
 				log.Printf("Account %d: upstream error %d, switching account %d/%d", account.ID, failoverErr.StatusCode, switchCount, maxAccountSwitches)
 				continue
@@ -422,12 +405,8 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 			return
 		}
 
-		// 捕获请求信息（用于异步记录，避免在 goroutine 中访问 gin.Context）
-		userAgent := c.GetHeader("User-Agent")
-		clientIP := ip.GetClientIP(c)
-
 		// 异步记录使用量（subscription已在函数开头获取）
-		go func(result *service.ForwardResult, usedAccount *service.Account, ua, clientIP string) {
+		go func(result *service.ForwardResult, usedAccount *service.Account, ua string, cip string) {
 			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 			defer cancel()
 			if err := h.gatewayService.RecordUsage(ctx, &service.RecordUsageInput{
@@ -437,7 +416,7 @@ func (h *GatewayHandler) Messages(c *gin.Context) {
 				Account:      usedAccount,
 				Subscription: subscription,
 				UserAgent:    ua,
-				IPAddress:    clientIP,
+				IPAddress:    cip,
 			}); err != nil {
 				log.Printf("Record usage failed: %v", err)
 			}
@@ -707,22 +686,21 @@ func (h *GatewayHandler) CountTokens(c *gin.Context) {
 		return
 	}
 
-	setOpsRequestContext(c, "", false, body)
-
 	parsedReq, err := service.ParseGatewayRequest(body)
 	if err != nil {
 		h.errorResponse(c, http.StatusBadRequest, "invalid_request_error", "Failed to parse request body")
 		return
 	}
 
+	// 设置 Claude Code 客户端标识到 context（用于分组限制检查）
+	SetClaudeCodeClientContext(c, body)
+
 	// 验证 model 必填
 	if parsedReq.Model == "" {
 		h.errorResponse(c, http.StatusBadRequest, "invalid_request_error", "model is required")
 		return
 	}
 
-	setOpsRequestContext(c, parsedReq.Model, parsedReq.Stream, body)
-
 	// 获取订阅信息（可能为nil）
 	subscription, _ := middleware2.GetSubscriptionFromContext(c)
 
@@ -743,7 +721,6 @@ func (h *GatewayHandler) CountTokens(c *gin.Context) {
 		h.errorResponse(c, http.StatusServiceUnavailable, "api_error", "No available accounts: "+err.Error())
 		return
 	}
-	setOpsSelectedAccount(c, account.ID)
 
 	// 转发请求（不记录使用量）
 	if err := h.gatewayService.ForwardCountTokens(c.Request.Context(), c, account, parsedReq); err != nil {

backend/internal/handler/gemini_v1beta_handler.go

@@ -162,32 +162,28 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 		return
 	}
 
-	setOpsRequestContext(c, modelName, stream, body)
-
 	// Get subscription (may be nil)
 	subscription, _ := middleware.GetSubscriptionFromContext(c)
 
+	// 获取 User-Agent
+	userAgent := c.Request.UserAgent()
+
+	// 获取客户端 IP
+	clientIP := ip.GetClientIP(c)
+
 	// For Gemini native API, do not send Claude-style ping frames.
 	geminiConcurrency := NewConcurrencyHelper(h.concurrencyHelper.concurrencyService, SSEPingFormatNone, 0)
 
 	// 0) wait queue check
 	maxWait := service.CalculateMaxWait(authSubject.Concurrency)
 	canWait, err := geminiConcurrency.IncrementWaitCount(c.Request.Context(), authSubject.UserID, maxWait)
-	waitCounted := false
 	if err != nil {
 		log.Printf("Increment wait count failed: %v", err)
 	} else if !canWait {
 		googleError(c, http.StatusTooManyRequests, "Too many pending requests, please retry later")
 		return
 	}
-	if err == nil && canWait {
-		waitCounted = true
-	}
-	defer func() {
-		if waitCounted {
-			geminiConcurrency.DecrementWaitCount(c.Request.Context(), authSubject.UserID)
-		}
-	}()
+	defer geminiConcurrency.DecrementWaitCount(c.Request.Context(), authSubject.UserID)
 
 	// 1) user concurrency slot
 	streamStarted := false
@@ -196,10 +192,6 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 		googleError(c, http.StatusTooManyRequests, err.Error())
 		return
 	}
-	if waitCounted {
-		geminiConcurrency.DecrementWaitCount(c.Request.Context(), authSubject.UserID)
-		waitCounted = false
-	}
 	// 确保请求取消时也会释放槽位，避免长连接被动中断造成泄漏
 	userReleaseFunc = wrapReleaseOnDone(c.Request.Context(), userReleaseFunc)
 	if userReleaseFunc != nil {
@@ -215,6 +207,10 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 
 	// 3) select account (sticky session based on request body)
 	parsedReq, _ := service.ParseGatewayRequest(body)
+
+	// 设置 Claude Code 客户端标识到 context（用于分组限制检查）
+	SetClaudeCodeClientContext(c, body)
+
 	sessionHash := h.gatewayService.GenerateSessionHash(parsedReq)
 	sessionKey := sessionHash
 	if sessionHash != "" {
@@ -236,16 +232,15 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 			return
 		}
 		account := selection.Account
-		setOpsSelectedAccount(c, account.ID)
 
 		// 4) account concurrency slot
 		accountReleaseFunc := selection.ReleaseFunc
+		var accountWaitRelease func()
 		if !selection.Acquired {
 			if selection.WaitPlan == nil {
 				googleError(c, http.StatusServiceUnavailable, "No available Gemini accounts")
 				return
 			}
-			accountWaitCounted := false
 			canWait, err := geminiConcurrency.IncrementAccountWaitCount(c.Request.Context(), account.ID, selection.WaitPlan.MaxWaiting)
 			if err != nil {
 				log.Printf("Increment account wait count failed: %v", err)
@@ -253,15 +248,12 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 				log.Printf("Account wait queue full: account=%d", account.ID)
 				googleError(c, http.StatusTooManyRequests, "Too many pending requests, please retry later")
 				return
-			}
-			if err == nil && canWait {
-				accountWaitCounted = true
-			}
-			defer func() {
-				if accountWaitCounted {
+			} else {
+				// Only set release function if increment succeeded
+				accountWaitRelease = func() {
 					geminiConcurrency.DecrementAccountWaitCount(c.Request.Context(), account.ID)
 				}
-			}()
+			}
 
 			accountReleaseFunc, err = geminiConcurrency.AcquireAccountSlotWithWaitTimeout(
 				c,
@@ -272,19 +264,19 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 				&streamStarted,
 			)
 			if err != nil {
+				if accountWaitRelease != nil {
+					accountWaitRelease()
+				}
 				googleError(c, http.StatusTooManyRequests, err.Error())
 				return
 			}
-			if accountWaitCounted {
-				geminiConcurrency.DecrementAccountWaitCount(c.Request.Context(), account.ID)
-				accountWaitCounted = false
-			}
 			if err := h.gatewayService.BindStickySession(c.Request.Context(), apiKey.GroupID, sessionKey, account.ID); err != nil {
 				log.Printf("Bind sticky session failed: %v", err)
 			}
 		}
 		// 账号槽位/等待计数需要在超时或断开时安全回收
 		accountReleaseFunc = wrapReleaseOnDone(c.Request.Context(), accountReleaseFunc)
+		accountWaitRelease = wrapReleaseOnDone(c.Request.Context(), accountWaitRelease)
 
 		// 5) forward (根据平台分流)
 		var result *service.ForwardResult
@@ -296,6 +288,9 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 		if accountReleaseFunc != nil {
 			accountReleaseFunc()
 		}
+		if accountWaitRelease != nil {
+			accountWaitRelease()
+		}
 		if err != nil {
 			var failoverErr *service.UpstreamFailoverError
 			if errors.As(err, &failoverErr) {
@@ -315,12 +310,8 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 			return
 		}
 
-		// 捕获请求信息（用于异步记录，避免在 goroutine 中访问 gin.Context）
-		userAgent := c.GetHeader("User-Agent")
-		clientIP := ip.GetClientIP(c)
-
 		// 6) record usage async
-		go func(result *service.ForwardResult, usedAccount *service.Account, ua, ip string) {
+		go func(result *service.ForwardResult, usedAccount *service.Account, ua string, cip string) {
 			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 			defer cancel()
 			if err := h.gatewayService.RecordUsage(ctx, &service.RecordUsageInput{
@@ -330,7 +321,7 @@ func (h *GatewayHandler) GeminiV1BetaModels(c *gin.Context) {
 				Account:      usedAccount,
 				Subscription: subscription,
 				UserAgent:    ua,
-				IPAddress:    ip,
+				IPAddress:    cip,
 			}); err != nil {
 				log.Printf("Record usage failed: %v", err)
 			}

backend/internal/handler/handler.go

@@ -18,7 +18,6 @@ type AdminHandlers struct {
 	Redeem           *admin.RedeemHandler
 	Promo            *admin.PromoHandler
 	Setting          *admin.SettingHandler
-	Ops              *admin.OpsHandler
 	System           *admin.SystemHandler
 	Subscription     *admin.SubscriptionHandler
 	Usage            *admin.UsageHandler

backend/internal/handler/openai_gateway_handler.go

@@ -8,7 +8,6 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"strings"
 	"time"
 
 	"github.com/Wei-Shaw/sub2api/internal/config"
@@ -77,8 +76,6 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 		return
 	}
 
-	setOpsRequestContext(c, "", false, body)
-
 	// Parse request body to map for potential modification
 	var reqBody map[string]any
 	if err := json.Unmarshal(body, &reqBody); err != nil {
@@ -96,41 +93,19 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 		return
 	}
 
+	// For non-Codex CLI requests, set default instructions
 	userAgent := c.GetHeader("User-Agent")
+
+	// 获取客户端 IP
+	clientIP := ip.GetClientIP(c)
+
 	if !openai.IsCodexCLIRequest(userAgent) {
-		existingInstructions, _ := reqBody["instructions"].(string)
-		if strings.TrimSpace(existingInstructions) == "" {
-			if instructions := strings.TrimSpace(service.GetOpenCodeInstructions()); instructions != "" {
-				reqBody["instructions"] = instructions
-				// Re-serialize body
-				body, err = json.Marshal(reqBody)
-				if err != nil {
-					h.errorResponse(c, http.StatusInternalServerError, "api_error", "Failed to process request")
-					return
-				}
-			}
-		}
-	}
-
-	setOpsRequestContext(c, reqModel, reqStream, body)
-
-	// 提前校验 function_call_output 是否具备可关联上下文，避免上游 400。
-	// 要求 previous_response_id，或 input 内存在带 call_id 的 tool_call/function_call，
-	// 或带 id 且与 call_id 匹配的 item_reference。
-	if service.HasFunctionCallOutput(reqBody) {
-		previousResponseID, _ := reqBody["previous_response_id"].(string)
-		if strings.TrimSpace(previousResponseID) == "" && !service.HasToolCallContext(reqBody) {
-			if service.HasFunctionCallOutputMissingCallID(reqBody) {
-				log.Printf("[OpenAI Handler] function_call_output 缺少 call_id: model=%s", reqModel)
-				h.errorResponse(c, http.StatusBadRequest, "invalid_request_error", "function_call_output requires call_id or previous_response_id; if relying on history, ensure store=true and reuse previous_response_id")
-				return
-			}
-			callIDs := service.FunctionCallOutputCallIDs(reqBody)
-			if !service.HasItemReferenceForCallIDs(reqBody, callIDs) {
-				log.Printf("[OpenAI Handler] function_call_output 缺少匹配的 item_reference: model=%s", reqModel)
-				h.errorResponse(c, http.StatusBadRequest, "invalid_request_error", "function_call_output requires item_reference ids matching each call_id, or previous_response_id/tool_call context; if relying on history, ensure store=true and reuse previous_response_id")
-				return
-			}
+		reqBody["instructions"] = openai.DefaultInstructions
+		// Re-serialize body
+		body, err = json.Marshal(reqBody)
+		if err != nil {
+			h.errorResponse(c, http.StatusInternalServerError, "api_error", "Failed to process request")
+			return
 		}
 	}
 
@@ -143,7 +118,6 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 	// 0. Check if wait queue is full
 	maxWait := service.CalculateMaxWait(subject.Concurrency)
 	canWait, err := h.concurrencyHelper.IncrementWaitCount(c.Request.Context(), subject.UserID, maxWait)
-	waitCounted := false
 	if err != nil {
 		log.Printf("Increment wait count failed: %v", err)
 		// On error, allow request to proceed
@@ -151,14 +125,8 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 		h.errorResponse(c, http.StatusTooManyRequests, "rate_limit_error", "Too many pending requests, please retry later")
 		return
 	}
-	if err == nil && canWait {
-		waitCounted = true
-	}
-	defer func() {
-		if waitCounted {
-			h.concurrencyHelper.DecrementWaitCount(c.Request.Context(), subject.UserID)
-		}
-	}()
+	// Ensure wait count is decremented when function exits
+	defer h.concurrencyHelper.DecrementWaitCount(c.Request.Context(), subject.UserID)
 
 	// 1. First acquire user concurrency slot
 	userReleaseFunc, err := h.concurrencyHelper.AcquireUserSlotWithWait(c, subject.UserID, subject.Concurrency, reqStream, &streamStarted)
@@ -167,11 +135,6 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 		h.handleConcurrencyError(c, err, "user", streamStarted)
 		return
 	}
-	// User slot acquired: no longer waiting.
-	if waitCounted {
-		h.concurrencyHelper.DecrementWaitCount(c.Request.Context(), subject.UserID)
-		waitCounted = false
-	}
 	// 确保请求取消时也会释放槽位，避免长连接被动中断造成泄漏
 	userReleaseFunc = wrapReleaseOnDone(c.Request.Context(), userReleaseFunc)
 	if userReleaseFunc != nil {
@@ -209,16 +172,15 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 		}
 		account := selection.Account
 		log.Printf("[OpenAI Handler] Selected account: id=%d name=%s", account.ID, account.Name)
-		setOpsSelectedAccount(c, account.ID)
 
 		// 3. Acquire account concurrency slot
 		accountReleaseFunc := selection.ReleaseFunc
+		var accountWaitRelease func()
 		if !selection.Acquired {
 			if selection.WaitPlan == nil {
 				h.handleStreamingAwareError(c, http.StatusServiceUnavailable, "api_error", "No available accounts", streamStarted)
 				return
 			}
-			accountWaitCounted := false
 			canWait, err := h.concurrencyHelper.IncrementAccountWaitCount(c.Request.Context(), account.ID, selection.WaitPlan.MaxWaiting)
 			if err != nil {
 				log.Printf("Increment account wait count failed: %v", err)
@@ -226,15 +188,12 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 				log.Printf("Account wait queue full: account=%d", account.ID)
 				h.handleStreamingAwareError(c, http.StatusTooManyRequests, "rate_limit_error", "Too many pending requests, please retry later", streamStarted)
 				return
-			}
-			if err == nil && canWait {
-				accountWaitCounted = true
-			}
-			defer func() {
-				if accountWaitCounted {
+			} else {
+				// Only set release function if increment succeeded
+				accountWaitRelease = func() {
 					h.concurrencyHelper.DecrementAccountWaitCount(c.Request.Context(), account.ID)
 				}
-			}()
+			}
 
 			accountReleaseFunc, err = h.concurrencyHelper.AcquireAccountSlotWithWaitTimeout(
 				c,
@@ -245,26 +204,29 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 				&streamStarted,
 			)
 			if err != nil {
+				if accountWaitRelease != nil {
+					accountWaitRelease()
+				}
 				log.Printf("Account concurrency acquire failed: %v", err)
 				h.handleConcurrencyError(c, err, "account", streamStarted)
 				return
 			}
-			if accountWaitCounted {
-				h.concurrencyHelper.DecrementAccountWaitCount(c.Request.Context(), account.ID)
-				accountWaitCounted = false
-			}
 			if err := h.gatewayService.BindStickySession(c.Request.Context(), apiKey.GroupID, sessionHash, account.ID); err != nil {
 				log.Printf("Bind sticky session failed: %v", err)
 			}
 		}
 		// 账号槽位/等待计数需要在超时或断开时安全回收
 		accountReleaseFunc = wrapReleaseOnDone(c.Request.Context(), accountReleaseFunc)
+		accountWaitRelease = wrapReleaseOnDone(c.Request.Context(), accountWaitRelease)
 
 		// Forward request
 		result, err := h.gatewayService.Forward(c.Request.Context(), c, account, body)
 		if accountReleaseFunc != nil {
 			accountReleaseFunc()
 		}
+		if accountWaitRelease != nil {
+			accountWaitRelease()
+		}
 		if err != nil {
 			var failoverErr *service.UpstreamFailoverError
 			if errors.As(err, &failoverErr) {
@@ -284,12 +246,8 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 			return
 		}
 
-		// 捕获请求信息（用于异步记录，避免在 goroutine 中访问 gin.Context）
-		userAgent := c.GetHeader("User-Agent")
-		clientIP := ip.GetClientIP(c)
-
 		// Async record usage
-		go func(result *service.OpenAIForwardResult, usedAccount *service.Account, ua, ip string) {
+		go func(result *service.OpenAIForwardResult, usedAccount *service.Account, ua string, cip string) {
 			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 			defer cancel()
 			if err := h.gatewayService.RecordUsage(ctx, &service.OpenAIRecordUsageInput{
@@ -299,7 +257,7 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 				Account:      usedAccount,
 				Subscription: subscription,
 				UserAgent:    ua,
-				IPAddress:    ip,
+				IPAddress:    cip,
 			}); err != nil {
 				log.Printf("Record usage failed: %v", err)
 			}

backend/internal/handler/wire.go

@@ -21,7 +21,6 @@ func ProvideAdminHandlers(
 	redeemHandler *admin.RedeemHandler,
 	promoHandler *admin.PromoHandler,
 	settingHandler *admin.SettingHandler,
-	opsHandler *admin.OpsHandler,
 	systemHandler *admin.SystemHandler,
 	subscriptionHandler *admin.SubscriptionHandler,
 	usageHandler *admin.UsageHandler,
@@ -40,7 +39,6 @@ func ProvideAdminHandlers(
 		Redeem:           redeemHandler,
 		Promo:            promoHandler,
 		Setting:          settingHandler,
-		Ops:              opsHandler,
 		System:           systemHandler,
 		Subscription:     subscriptionHandler,
 		Usage:            usageHandler,
@@ -111,7 +109,6 @@ var ProviderSet = wire.NewSet(
 	admin.NewRedeemHandler,
 	admin.NewPromoHandler,
 	admin.NewSettingHandler,
-	admin.NewOpsHandler,
 	ProvideSystemHandler,
 	admin.NewSubscriptionHandler,
 	admin.NewUsageHandler,

backend/internal/middleware/rate_limiter.go

@@ -1,63 +1,13 @@
 package middleware
 
 import (
-	"context"
-	"fmt"
-	"log"
 	"net/http"
-	"strconv"
 	"time"
 
 	"github.com/gin-gonic/gin"
 	"github.com/redis/go-redis/v9"
 )
 
-// RateLimitFailureMode Redis 故障策略
-type RateLimitFailureMode int
-
-const (
-	RateLimitFailOpen RateLimitFailureMode = iota
-	RateLimitFailClose
-)
-
-// RateLimitOptions 限流可选配置
-type RateLimitOptions struct {
-	FailureMode RateLimitFailureMode
-}
-
-var rateLimitScript = redis.NewScript(`
-local current = redis.call('INCR', KEYS[1])
-local ttl = redis.call('PTTL', KEYS[1])
-local repaired = 0
-if current == 1 then
-  redis.call('PEXPIRE', KEYS[1], ARGV[1])
-elseif ttl == -1 then
-  redis.call('PEXPIRE', KEYS[1], ARGV[1])
-  repaired = 1
-end
-return {current, repaired}
-`)
-
-// rateLimitRun 允许测试覆写脚本执行逻辑
-var rateLimitRun = func(ctx context.Context, client *redis.Client, key string, windowMillis int64) (int64, bool, error) {
-	values, err := rateLimitScript.Run(ctx, client, []string{key}, windowMillis).Slice()
-	if err != nil {
-		return 0, false, err
-	}
-	if len(values) < 2 {
-		return 0, false, fmt.Errorf("rate limit script returned %d values", len(values))
-	}
-	count, err := parseInt64(values[0])
-	if err != nil {
-		return 0, false, err
-	}
-	repaired, err := parseInt64(values[1])
-	if err != nil {
-		return 0, false, err
-	}
-	return count, repaired == 1, nil
-}
-
 // RateLimiter Redis 速率限制器
 type RateLimiter struct {
 	redis  *redis.Client
@@ -77,85 +27,34 @@ func NewRateLimiter(redisClient *redis.Client) *RateLimiter {
 // limit: 时间窗口内最大请求数
 // window: 时间窗口
 func (r *RateLimiter) Limit(key string, limit int, window time.Duration) gin.HandlerFunc {
-	return r.LimitWithOptions(key, limit, window, RateLimitOptions{})
-}
-
-// LimitWithOptions 返回速率限制中间件（带可选配置）
-func (r *RateLimiter) LimitWithOptions(key string, limit int, window time.Duration, opts RateLimitOptions) gin.HandlerFunc {
-	failureMode := opts.FailureMode
-	if failureMode != RateLimitFailClose {
-		failureMode = RateLimitFailOpen
-	}
-
 	return func(c *gin.Context) {
 		ip := c.ClientIP()
 		redisKey := r.prefix + key + ":" + ip
 
 		ctx := c.Request.Context()
 
-		windowMillis := windowTTLMillis(window)
-
-		// 使用 Lua 脚本原子操作增加计数并设置过期
-		count, repaired, err := rateLimitRun(ctx, r.redis, redisKey, windowMillis)
+		// 使用 INCR 原子操作增加计数
+		count, err := r.redis.Incr(ctx, redisKey).Result()
 		if err != nil {
-			log.Printf("[RateLimit] redis error: key=%s mode=%s err=%v", redisKey, failureModeLabel(failureMode), err)
-			if failureMode == RateLimitFailClose {
-				abortRateLimit(c)
-				return
-			}
 			// Redis 错误时放行，避免影响正常服务
 			c.Next()
 			return
 		}
-		if repaired {
-			log.Printf("[RateLimit] ttl repaired: key=%s window_ms=%d", redisKey, windowMillis)
+
+		// 首次访问时设置过期时间
+		if count == 1 {
+			r.redis.Expire(ctx, redisKey, window)
 		}
 
 		// 超过限制
 		if count > int64(limit) {
-			abortRateLimit(c)
+			c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
+				"error":   "rate limit exceeded",
+				"message": "Too many requests, please try again later",
+			})
 			return
 		}
 
 		c.Next()
 	}
 }
-
-func windowTTLMillis(window time.Duration) int64 {
-	ttl := window.Milliseconds()
-	if ttl < 1 {
-		return 1
-	}
-	return ttl
-}
-
-func abortRateLimit(c *gin.Context) {
-	c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
-		"error":   "rate limit exceeded",
-		"message": "Too many requests, please try again later",
-	})
-}
-
-func failureModeLabel(mode RateLimitFailureMode) string {
-	if mode == RateLimitFailClose {
-		return "fail-close"
-	}
-	return "fail-open"
-}
-
-func parseInt64(value any) (int64, error) {
-	switch v := value.(type) {
-	case int64:
-		return v, nil
-	case int:
-		return int64(v), nil
-	case string:
-		parsed, err := strconv.ParseInt(v, 10, 64)
-		if err != nil {
-			return 0, err
-		}
-		return parsed, nil
-	default:
-		return 0, fmt.Errorf("unexpected value type %T", value)
-	}
-}

backend/internal/middleware/rate_limiter_integration_test.go

@@ -1,114 +0,0 @@
-//go:build integration
-
-package middleware
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/redis/go-redis/v9"
-	"github.com/stretchr/testify/require"
-	tcredis "github.com/testcontainers/testcontainers-go/modules/redis"
-)
-
-const redisImageTag = "redis:8.4-alpine"
-
-func TestRateLimiterSetsTTLAndDoesNotRefresh(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	ctx := context.Background()
-	rdb := startRedis(t, ctx)
-	limiter := NewRateLimiter(rdb)
-
-	router := gin.New()
-	router.Use(limiter.Limit("ttl-test", 10, 2*time.Second))
-	router.GET("/test", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{"ok": true})
-	})
-
-	recorder := performRequest(router)
-	require.Equal(t, http.StatusOK, recorder.Code)
-
-	redisKey := limiter.prefix + "ttl-test:127.0.0.1"
-	ttlBefore, err := rdb.PTTL(ctx, redisKey).Result()
-	require.NoError(t, err)
-	require.Greater(t, ttlBefore, time.Duration(0))
-	require.LessOrEqual(t, ttlBefore, 2*time.Second)
-
-	time.Sleep(50 * time.Millisecond)
-
-	recorder = performRequest(router)
-	require.Equal(t, http.StatusOK, recorder.Code)
-
-	ttlAfter, err := rdb.PTTL(ctx, redisKey).Result()
-	require.NoError(t, err)
-	require.Less(t, ttlAfter, ttlBefore)
-}
-
-func TestRateLimiterFixesMissingTTL(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	ctx := context.Background()
-	rdb := startRedis(t, ctx)
-	limiter := NewRateLimiter(rdb)
-
-	router := gin.New()
-	router.Use(limiter.Limit("ttl-missing", 10, 2*time.Second))
-	router.GET("/test", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{"ok": true})
-	})
-
-	redisKey := limiter.prefix + "ttl-missing:127.0.0.1"
-	require.NoError(t, rdb.Set(ctx, redisKey, 5, 0).Err())
-
-	ttlBefore, err := rdb.PTTL(ctx, redisKey).Result()
-	require.NoError(t, err)
-	require.Less(t, ttlBefore, time.Duration(0))
-
-	recorder := performRequest(router)
-	require.Equal(t, http.StatusOK, recorder.Code)
-
-	ttlAfter, err := rdb.PTTL(ctx, redisKey).Result()
-	require.NoError(t, err)
-	require.Greater(t, ttlAfter, time.Duration(0))
-}
-
-func performRequest(router *gin.Engine) *httptest.ResponseRecorder {
-	req := httptest.NewRequest(http.MethodGet, "/test", nil)
-	req.RemoteAddr = "127.0.0.1:1234"
-	recorder := httptest.NewRecorder()
-	router.ServeHTTP(recorder, req)
-	return recorder
-}
-
-func startRedis(t *testing.T, ctx context.Context) *redis.Client {
-	t.Helper()
-
-	redisContainer, err := tcredis.Run(ctx, redisImageTag)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		_ = redisContainer.Terminate(ctx)
-	})
-
-	redisHost, err := redisContainer.Host(ctx)
-	require.NoError(t, err)
-	redisPort, err := redisContainer.MappedPort(ctx, "6379/tcp")
-	require.NoError(t, err)
-
-	rdb := redis.NewClient(&redis.Options{
-		Addr: fmt.Sprintf("%s:%d", redisHost, redisPort.Int()),
-		DB:   0,
-	})
-	require.NoError(t, rdb.Ping(ctx).Err())
-
-	t.Cleanup(func() {
-		_ = rdb.Close()
-	})
-
-	return rdb
-}

backend/internal/middleware/rate_limiter_test.go

@@ -1,100 +0,0 @@
-package middleware
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/redis/go-redis/v9"
-	"github.com/stretchr/testify/require"
-)
-
-func TestWindowTTLMillis(t *testing.T) {
-	require.Equal(t, int64(1), windowTTLMillis(500*time.Microsecond))
-	require.Equal(t, int64(1), windowTTLMillis(1500*time.Microsecond))
-	require.Equal(t, int64(2), windowTTLMillis(2500*time.Microsecond))
-}
-
-func TestRateLimiterFailureModes(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	rdb := redis.NewClient(&redis.Options{
-		Addr:         "127.0.0.1:1",
-		DialTimeout:  50 * time.Millisecond,
-		ReadTimeout:  50 * time.Millisecond,
-		WriteTimeout: 50 * time.Millisecond,
-	})
-	t.Cleanup(func() {
-		_ = rdb.Close()
-	})
-
-	limiter := NewRateLimiter(rdb)
-
-	failOpenRouter := gin.New()
-	failOpenRouter.Use(limiter.Limit("test", 1, time.Second))
-	failOpenRouter.GET("/test", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{"ok": true})
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/test", nil)
-	req.RemoteAddr = "127.0.0.1:1234"
-	recorder := httptest.NewRecorder()
-	failOpenRouter.ServeHTTP(recorder, req)
-	require.Equal(t, http.StatusOK, recorder.Code)
-
-	failCloseRouter := gin.New()
-	failCloseRouter.Use(limiter.LimitWithOptions("test", 1, time.Second, RateLimitOptions{
-		FailureMode: RateLimitFailClose,
-	}))
-	failCloseRouter.GET("/test", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{"ok": true})
-	})
-
-	req = httptest.NewRequest(http.MethodGet, "/test", nil)
-	req.RemoteAddr = "127.0.0.1:1234"
-	recorder = httptest.NewRecorder()
-	failCloseRouter.ServeHTTP(recorder, req)
-	require.Equal(t, http.StatusTooManyRequests, recorder.Code)
-}
-
-func TestRateLimiterSuccessAndLimit(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	originalRun := rateLimitRun
-	counts := []int64{1, 2}
-	callIndex := 0
-	rateLimitRun = func(ctx context.Context, client *redis.Client, key string, windowMillis int64) (int64, bool, error) {
-		if callIndex >= len(counts) {
-			return counts[len(counts)-1], false, nil
-		}
-		value := counts[callIndex]
-		callIndex++
-		return value, false, nil
-	}
-	t.Cleanup(func() {
-		rateLimitRun = originalRun
-	})
-
-	limiter := NewRateLimiter(redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}))
-
-	router := gin.New()
-	router.Use(limiter.Limit("test", 1, time.Second))
-	router.GET("/test", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{"ok": true})
-	})
-
-	req := httptest.NewRequest(http.MethodGet, "/test", nil)
-	req.RemoteAddr = "127.0.0.1:1234"
-	recorder := httptest.NewRecorder()
-	router.ServeHTTP(recorder, req)
-	require.Equal(t, http.StatusOK, recorder.Code)
-
-	req = httptest.NewRequest(http.MethodGet, "/test", nil)
-	req.RemoteAddr = "127.0.0.1:1234"
-	recorder = httptest.NewRecorder()
-	router.ServeHTTP(recorder, req)
-	require.Equal(t, http.StatusTooManyRequests, recorder.Code)
-}

backend/internal/pkg/ctxkey/ctxkey.go

@@ -7,14 +7,7 @@ type Key string
 const (
 	// ForcePlatform 强制平台（用于 /antigravity 路由），由 middleware.ForcePlatform 设置
 	ForcePlatform Key = "ctx_force_platform"
-
-	// ClientRequestID 客户端请求的唯一标识，用于追踪请求全生命周期（用于 Ops 监控与排障）。
-	ClientRequestID Key = "ctx_client_request_id"
-
-	// RetryCount 表示当前请求在网关层的重试次数（用于 Ops 记录与排障）。
-	RetryCount Key = "ctx_retry_count"
-
-	// IsClaudeCodeClient 标识当前请求是否来自 Claude Code 客户端
+	// IsClaudeCodeClient 是否为 Claude Code 客户端，由中间件设置
 	IsClaudeCodeClient Key = "ctx_is_claude_code_client"
 	// Group 认证后的分组信息，由 API Key 认证中间件设置
 	Group Key = "ctx_group"

backend/internal/pkg/usagestats/account_stats.go

@@ -1,14 +1,8 @@
 package usagestats
 
 // AccountStats 账号使用统计
-//
-// cost: 账号口径费用（使用 total_cost * account_rate_multiplier）
-// standard_cost: 标准费用（使用 total_cost，不含倍率）
-// user_cost: 用户/API Key 口径费用（使用 actual_cost，受分组倍率影响）
 type AccountStats struct {
-	Requests     int64   `json:"requests"`
-	Tokens       int64   `json:"tokens"`
-	Cost         float64 `json:"cost"`
-	StandardCost float64 `json:"standard_cost"`
-	UserCost     float64 `json:"user_cost"`
+	Requests int64   `json:"requests"`
+	Tokens   int64   `json:"tokens"`
+	Cost     float64 `json:"cost"`
 }

backend/internal/pkg/usagestats/usage_log_types.go

@@ -9,12 +9,6 @@ type DashboardStats struct {
 	TotalUsers    int64 `json:"total_users"`
 	TodayNewUsers int64 `json:"today_new_users"` // 今日新增用户数
 	ActiveUsers   int64 `json:"active_users"`    // 今日有请求的用户数
-	// 小时活跃用户数（UTC 当前小时）
-	HourlyActiveUsers int64 `json:"hourly_active_users"`
-
-	// 预聚合新鲜度
-	StatsUpdatedAt string `json:"stats_updated_at"`
-	StatsStale     bool   `json:"stats_stale"`
 
 	// API Key 统计
 	TotalAPIKeys  int64 `json:"total_api_keys"`
@@ -147,15 +141,14 @@ type UsageLogFilters struct {
 
 // UsageStats represents usage statistics
 type UsageStats struct {
-	TotalRequests     int64    `json:"total_requests"`
-	TotalInputTokens  int64    `json:"total_input_tokens"`
-	TotalOutputTokens int64    `json:"total_output_tokens"`
-	TotalCacheTokens  int64    `json:"total_cache_tokens"`
-	TotalTokens       int64    `json:"total_tokens"`
-	TotalCost         float64  `json:"total_cost"`
-	TotalActualCost   float64  `json:"total_actual_cost"`
-	TotalAccountCost  *float64 `json:"total_account_cost,omitempty"`
-	AverageDurationMs float64  `json:"average_duration_ms"`
+	TotalRequests     int64   `json:"total_requests"`
+	TotalInputTokens  int64   `json:"total_input_tokens"`
+	TotalOutputTokens int64   `json:"total_output_tokens"`
+	TotalCacheTokens  int64   `json:"total_cache_tokens"`
+	TotalTokens       int64   `json:"total_tokens"`
+	TotalCost         float64 `json:"total_cost"`
+	TotalActualCost   float64 `json:"total_actual_cost"`
+	AverageDurationMs float64 `json:"average_duration_ms"`
 }
 
 // BatchUserUsageStats represents usage stats for a single user
@@ -178,29 +171,25 @@ type AccountUsageHistory struct {
 	Label      string  `json:"label"`
 	Requests   int64   `json:"requests"`
 	Tokens     int64   `json:"tokens"`
-	Cost       float64 `json:"cost"`        // 标准计费（total_cost）
-	ActualCost float64 `json:"actual_cost"` // 账号口径费用（total_cost * account_rate_multiplier）
-	UserCost   float64 `json:"user_cost"`   // 用户口径费用（actual_cost，受分组倍率影响）
+	Cost       float64 `json:"cost"`
+	ActualCost float64 `json:"actual_cost"`
 }
 
 // AccountUsageSummary represents summary statistics for an account
 type AccountUsageSummary struct {
 	Days              int     `json:"days"`
 	ActualDaysUsed    int     `json:"actual_days_used"`
-	TotalCost         float64 `json:"total_cost"`      // 账号口径费用
-	TotalUserCost     float64 `json:"total_user_cost"` // 用户口径费用
+	TotalCost         float64 `json:"total_cost"`
 	TotalStandardCost float64 `json:"total_standard_cost"`
 	TotalRequests     int64   `json:"total_requests"`
 	TotalTokens       int64   `json:"total_tokens"`
-	AvgDailyCost      float64 `json:"avg_daily_cost"` // 账号口径日均
-	AvgDailyUserCost  float64 `json:"avg_daily_user_cost"`
+	AvgDailyCost      float64 `json:"avg_daily_cost"`
 	AvgDailyRequests  float64 `json:"avg_daily_requests"`
 	AvgDailyTokens    float64 `json:"avg_daily_tokens"`
 	AvgDurationMs     float64 `json:"avg_duration_ms"`
 	Today             *struct {
 		Date     string  `json:"date"`
 		Cost     float64 `json:"cost"`
-		UserCost float64 `json:"user_cost"`
 		Requests int64   `json:"requests"`
 		Tokens   int64   `json:"tokens"`
 	} `json:"today"`
@@ -208,7 +197,6 @@ type AccountUsageSummary struct {
 		Date     string  `json:"date"`
 		Label    string  `json:"label"`
 		Cost     float64 `json:"cost"`
-		UserCost float64 `json:"user_cost"`
 		Requests int64   `json:"requests"`
 	} `json:"highest_cost_day"`
 	HighestRequestDay *struct {
@@ -216,7 +204,6 @@ type AccountUsageSummary struct {
 		Label    string  `json:"label"`
 		Requests int64   `json:"requests"`
 		Cost     float64 `json:"cost"`
-		UserCost float64 `json:"user_cost"`
 	} `json:"highest_request_day"`
 }
 

backend/internal/repository/account_repo.go

@@ -15,7 +15,6 @@ import (
 	"database/sql"
 	"encoding/json"
 	"errors"
-	"log"
 	"strconv"
 	"time"
 
@@ -80,10 +79,6 @@ func (r *accountRepository) Create(ctx context.Context, account *service.Account
 		SetSchedulable(account.Schedulable).
 		SetAutoPauseOnExpired(account.AutoPauseOnExpired)
 
-	if account.RateMultiplier != nil {
-		builder.SetRateMultiplier(*account.RateMultiplier)
-	}
-
 	if account.ProxyID != nil {
 		builder.SetProxyID(*account.ProxyID)
 	}
@@ -120,9 +115,6 @@ func (r *accountRepository) Create(ctx context.Context, account *service.Account
 	account.ID = created.ID
 	account.CreatedAt = created.CreatedAt
 	account.UpdatedAt = created.UpdatedAt
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &account.ID, nil, buildSchedulerGroupPayload(account.GroupIDs)); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue account create failed: account=%d err=%v", account.ID, err)
-	}
 	return nil
 }
 
@@ -295,10 +287,6 @@ func (r *accountRepository) Update(ctx context.Context, account *service.Account
 		SetSchedulable(account.Schedulable).
 		SetAutoPauseOnExpired(account.AutoPauseOnExpired)
 
-	if account.RateMultiplier != nil {
-		builder.SetRateMultiplier(*account.RateMultiplier)
-	}
-
 	if account.ProxyID != nil {
 		builder.SetProxyID(*account.ProxyID)
 	} else {
@@ -353,17 +341,10 @@ func (r *accountRepository) Update(ctx context.Context, account *service.Account
 		return translatePersistenceError(err, service.ErrAccountNotFound, nil)
 	}
 	account.UpdatedAt = updated.UpdatedAt
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &account.ID, nil, buildSchedulerGroupPayload(account.GroupIDs)); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue account update failed: account=%d err=%v", account.ID, err)
-	}
 	return nil
 }
 
 func (r *accountRepository) Delete(ctx context.Context, id int64) error {
-	groupIDs, err := r.loadAccountGroupIDs(ctx, id)
-	if err != nil {
-		return err
-	}
 	// 使用事务保证账号与关联分组的删除原子性
 	tx, err := r.client.Tx(ctx)
 	if err != nil && !errors.Is(err, dbent.ErrTxStarted) {
@@ -387,12 +368,7 @@ func (r *accountRepository) Delete(ctx context.Context, id int64) error {
 	}
 
 	if tx != nil {
-		if err := tx.Commit(); err != nil {
-			return err
-		}
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, buildSchedulerGroupPayload(groupIDs)); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue account delete failed: account=%d err=%v", id, err)
+		return tx.Commit()
 	}
 	return nil
 }
@@ -479,18 +455,7 @@ func (r *accountRepository) UpdateLastUsed(ctx context.Context, id int64) error
 		Where(dbaccount.IDEQ(id)).
 		SetLastUsedAt(now).
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	payload := map[string]any{
-		"last_used": map[string]int64{
-			strconv.FormatInt(id, 10): now.Unix(),
-		},
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountLastUsed, &id, nil, payload); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue last used failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) BatchUpdateLastUsed(ctx context.Context, updates map[int64]time.Time) error {
@@ -514,18 +479,7 @@ func (r *accountRepository) BatchUpdateLastUsed(ctx context.Context, updates map
 	args = append(args, pq.Array(ids))
 
 	_, err := r.sql.ExecContext(ctx, caseSQL, args...)
-	if err != nil {
-		return err
-	}
-	lastUsedPayload := make(map[string]int64, len(updates))
-	for id, ts := range updates {
-		lastUsedPayload[strconv.FormatInt(id, 10)] = ts.Unix()
-	}
-	payload := map[string]any{"last_used": lastUsedPayload}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountLastUsed, nil, nil, payload); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue batch last used failed: err=%v", err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) SetError(ctx context.Context, id int64, errorMsg string) error {
@@ -534,13 +488,7 @@ func (r *accountRepository) SetError(ctx context.Context, id int64, errorMsg str
 		SetStatus(service.StatusError).
 		SetErrorMessage(errorMsg).
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue set error failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) AddToGroup(ctx context.Context, accountID, groupID int64, priority int) error {
@@ -549,14 +497,7 @@ func (r *accountRepository) AddToGroup(ctx context.Context, accountID, groupID i
 		SetGroupID(groupID).
 		SetPriority(priority).
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	payload := buildSchedulerGroupPayload([]int64{groupID})
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountGroupsChanged, &accountID, nil, payload); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue add to group failed: account=%d group=%d err=%v", accountID, groupID, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) RemoveFromGroup(ctx context.Context, accountID, groupID int64) error {
@@ -566,14 +507,7 @@ func (r *accountRepository) RemoveFromGroup(ctx context.Context, accountID, grou
 			dbaccountgroup.GroupIDEQ(groupID),
 		).
 		Exec(ctx)
-	if err != nil {
-		return err
-	}
-	payload := buildSchedulerGroupPayload([]int64{groupID})
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountGroupsChanged, &accountID, nil, payload); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue remove from group failed: account=%d group=%d err=%v", accountID, groupID, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) GetGroups(ctx context.Context, accountID int64) ([]service.Group, error) {
@@ -594,10 +528,6 @@ func (r *accountRepository) GetGroups(ctx context.Context, accountID int64) ([]s
 }
 
 func (r *accountRepository) BindGroups(ctx context.Context, accountID int64, groupIDs []int64) error {
-	existingGroupIDs, err := r.loadAccountGroupIDs(ctx, accountID)
-	if err != nil {
-		return err
-	}
 	// 使用事务保证删除旧绑定与创建新绑定的原子性
 	tx, err := r.client.Tx(ctx)
 	if err != nil && !errors.Is(err, dbent.ErrTxStarted) {
@@ -638,13 +568,7 @@ func (r *accountRepository) BindGroups(ctx context.Context, accountID int64, gro
 	}
 
 	if tx != nil {
-		if err := tx.Commit(); err != nil {
-			return err
-		}
-	}
-	payload := buildSchedulerGroupPayload(mergeGroupIDs(existingGroupIDs, groupIDs))
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountGroupsChanged, &accountID, nil, payload); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue bind groups failed: account=%d err=%v", accountID, err)
+		return tx.Commit()
 	}
 	return nil
 }
@@ -748,13 +672,7 @@ func (r *accountRepository) SetRateLimited(ctx context.Context, id int64, resetA
 		SetRateLimitedAt(now).
 		SetRateLimitResetAt(resetAt).
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue rate limit failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) SetAntigravityQuotaScopeLimit(ctx context.Context, id int64, scope service.AntigravityQuotaScope, resetAt time.Time) error {
@@ -788,9 +706,6 @@ func (r *accountRepository) SetAntigravityQuotaScopeLimit(ctx context.Context, i
 	if affected == 0 {
 		return service.ErrAccountNotFound
 	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue quota scope failed: account=%d err=%v", id, err)
-	}
 	return nil
 }
 
@@ -799,13 +714,7 @@ func (r *accountRepository) SetOverloaded(ctx context.Context, id int64, until t
 		Where(dbaccount.IDEQ(id)).
 		SetOverloadUntil(until).
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue overload failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) SetTempUnschedulable(ctx context.Context, id int64, until time.Time, reason string) error {
@@ -818,13 +727,7 @@ func (r *accountRepository) SetTempUnschedulable(ctx context.Context, id int64,
 			AND deleted_at IS NULL
 			AND (temp_unschedulable_until IS NULL OR temp_unschedulable_until < $1)
 	`, until, reason, id)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue temp unschedulable failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) ClearTempUnschedulable(ctx context.Context, id int64) error {
@@ -836,13 +739,7 @@ func (r *accountRepository) ClearTempUnschedulable(ctx context.Context, id int64
 		WHERE id = $1
 			AND deleted_at IS NULL
 	`, id)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue clear temp unschedulable failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) ClearRateLimit(ctx context.Context, id int64) error {
@@ -852,13 +749,7 @@ func (r *accountRepository) ClearRateLimit(ctx context.Context, id int64) error
 		ClearRateLimitResetAt().
 		ClearOverloadUntil().
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue clear rate limit failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) ClearAntigravityQuotaScopes(ctx context.Context, id int64) error {
@@ -879,9 +770,6 @@ func (r *accountRepository) ClearAntigravityQuotaScopes(ctx context.Context, id
 	if affected == 0 {
 		return service.ErrAccountNotFound
 	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue clear quota scopes failed: account=%d err=%v", id, err)
-	}
 	return nil
 }
 
@@ -904,13 +792,7 @@ func (r *accountRepository) SetSchedulable(ctx context.Context, id int64, schedu
 		Where(dbaccount.IDEQ(id)).
 		SetSchedulable(schedulable).
 		Save(ctx)
-	if err != nil {
-		return err
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue schedulable change failed: account=%d err=%v", id, err)
-	}
-	return nil
+	return err
 }
 
 func (r *accountRepository) AutoPauseExpiredAccounts(ctx context.Context, now time.Time) (int64, error) {
@@ -931,11 +813,6 @@ func (r *accountRepository) AutoPauseExpiredAccounts(ctx context.Context, now ti
 	if err != nil {
 		return 0, err
 	}
-	if rows > 0 {
-		if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventFullRebuild, nil, nil, nil); err != nil {
-			log.Printf("[SchedulerOutbox] enqueue auto pause rebuild failed: err=%v", err)
-		}
-	}
 	return rows, nil
 }
 
@@ -967,9 +844,6 @@ func (r *accountRepository) UpdateExtra(ctx context.Context, id int64, updates m
 	if affected == 0 {
 		return service.ErrAccountNotFound
 	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountChanged, &id, nil, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue extra update failed: account=%d err=%v", id, err)
-	}
 	return nil
 }
 
@@ -1007,11 +881,6 @@ func (r *accountRepository) BulkUpdate(ctx context.Context, ids []int64, updates
 		args = append(args, *updates.Priority)
 		idx++
 	}
-	if updates.RateMultiplier != nil {
-		setClauses = append(setClauses, "rate_multiplier = $"+itoa(idx))
-		args = append(args, *updates.RateMultiplier)
-		idx++
-	}
 	if updates.Status != nil {
 		setClauses = append(setClauses, "status = $"+itoa(idx))
 		args = append(args, *updates.Status)
@@ -1059,12 +928,6 @@ func (r *accountRepository) BulkUpdate(ctx context.Context, ids []int64, updates
 	if err != nil {
 		return 0, err
 	}
-	if rows > 0 {
-		payload := map[string]any{"account_ids": ids}
-		if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventAccountBulkChanged, nil, nil, payload); err != nil {
-			log.Printf("[SchedulerOutbox] enqueue bulk update failed: err=%v", err)
-		}
-	}
 	return rows, nil
 }
 
@@ -1307,61 +1170,11 @@ func (r *accountRepository) loadAccountGroups(ctx context.Context, accountIDs []
 	return groupsByAccount, groupIDsByAccount, accountGroupsByAccount, nil
 }
 
-func (r *accountRepository) loadAccountGroupIDs(ctx context.Context, accountID int64) ([]int64, error) {
-	entries, err := r.client.AccountGroup.
-		Query().
-		Where(dbaccountgroup.AccountIDEQ(accountID)).
-		All(ctx)
-	if err != nil {
-		return nil, err
-	}
-	ids := make([]int64, 0, len(entries))
-	for _, entry := range entries {
-		ids = append(ids, entry.GroupID)
-	}
-	return ids, nil
-}
-
-func mergeGroupIDs(a []int64, b []int64) []int64 {
-	seen := make(map[int64]struct{}, len(a)+len(b))
-	out := make([]int64, 0, len(a)+len(b))
-	for _, id := range a {
-		if id <= 0 {
-			continue
-		}
-		if _, ok := seen[id]; ok {
-			continue
-		}
-		seen[id] = struct{}{}
-		out = append(out, id)
-	}
-	for _, id := range b {
-		if id <= 0 {
-			continue
-		}
-		if _, ok := seen[id]; ok {
-			continue
-		}
-		seen[id] = struct{}{}
-		out = append(out, id)
-	}
-	return out
-}
-
-func buildSchedulerGroupPayload(groupIDs []int64) map[string]any {
-	if len(groupIDs) == 0 {
-		return nil
-	}
-	return map[string]any{"group_ids": groupIDs}
-}
-
 func accountEntityToService(m *dbent.Account) *service.Account {
 	if m == nil {
 		return nil
 	}
 
-	rateMultiplier := m.RateMultiplier
-
 	return &service.Account{
 		ID:                  m.ID,
 		Name:                m.Name,
@@ -1373,7 +1186,6 @@ func accountEntityToService(m *dbent.Account) *service.Account {
 		ProxyID:             m.ProxyID,
 		Concurrency:         m.Concurrency,
 		Priority:            m.Priority,
-		RateMultiplier:      &rateMultiplier,
 		Status:              m.Status,
 		ErrorMessage:        derefString(m.ErrorMessage),
 		LastUsedAt:          m.LastUsedAt,

backend/internal/repository/api_key_cache.go

@@ -2,7 +2,6 @@ package repository
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"time"
@@ -14,7 +13,6 @@ import (
 const (
 	apiKeyRateLimitKeyPrefix = "apikey:ratelimit:"
 	apiKeyRateLimitDuration  = 24 * time.Hour
-	apiKeyAuthCachePrefix    = "apikey:auth:"
 )
 
 // apiKeyRateLimitKey generates the Redis key for API key creation rate limiting.
@@ -22,10 +20,6 @@ func apiKeyRateLimitKey(userID int64) string {
 	return fmt.Sprintf("%s%d", apiKeyRateLimitKeyPrefix, userID)
 }
 
-func apiKeyAuthCacheKey(key string) string {
-	return fmt.Sprintf("%s%s", apiKeyAuthCachePrefix, key)
-}
-
 type apiKeyCache struct {
 	rdb *redis.Client
 }
@@ -64,30 +58,3 @@ func (c *apiKeyCache) IncrementDailyUsage(ctx context.Context, apiKey string) er
 func (c *apiKeyCache) SetDailyUsageExpiry(ctx context.Context, apiKey string, ttl time.Duration) error {
 	return c.rdb.Expire(ctx, apiKey, ttl).Err()
 }
-
-func (c *apiKeyCache) GetAuthCache(ctx context.Context, key string) (*service.APIKeyAuthCacheEntry, error) {
-	val, err := c.rdb.Get(ctx, apiKeyAuthCacheKey(key)).Bytes()
-	if err != nil {
-		return nil, err
-	}
-	var entry service.APIKeyAuthCacheEntry
-	if err := json.Unmarshal(val, &entry); err != nil {
-		return nil, err
-	}
-	return &entry, nil
-}
-
-func (c *apiKeyCache) SetAuthCache(ctx context.Context, key string, entry *service.APIKeyAuthCacheEntry, ttl time.Duration) error {
-	if entry == nil {
-		return nil
-	}
-	payload, err := json.Marshal(entry)
-	if err != nil {
-		return err
-	}
-	return c.rdb.Set(ctx, apiKeyAuthCacheKey(key), payload, ttl).Err()
-}
-
-func (c *apiKeyCache) DeleteAuthCache(ctx context.Context, key string) error {
-	return c.rdb.Del(ctx, apiKeyAuthCacheKey(key)).Err()
-}

backend/internal/repository/api_key_repo.go

@@ -6,9 +6,7 @@ import (
 
 	dbent "github.com/Wei-Shaw/sub2api/ent"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
-	"github.com/Wei-Shaw/sub2api/ent/group"
 	"github.com/Wei-Shaw/sub2api/ent/schema/mixins"
-	"github.com/Wei-Shaw/sub2api/ent/user"
 	"github.com/Wei-Shaw/sub2api/internal/service"
 
 	"github.com/Wei-Shaw/sub2api/internal/pkg/pagination"
@@ -66,23 +64,23 @@ func (r *apiKeyRepository) GetByID(ctx context.Context, id int64) (*service.APIK
 	return apiKeyEntityToService(m), nil
 }
 
-// GetKeyAndOwnerID 根据 API Key ID 获取其 key 与所有者（用户）ID。
+// GetOwnerID 根据 API Key ID 获取其所有者（用户）的 ID。
 // 相比 GetByID，此方法性能更优，因为：
-//   - 使用 Select() 只查询必要字段，减少数据传输量
+//   - 使用 Select() 只查询 user_id 字段，减少数据传输量
 //   - 不加载完整的 API Key 实体及其关联数据（User、Group 等）
-//   - 适用于删除等只需 key 与用户 ID 的场景
-func (r *apiKeyRepository) GetKeyAndOwnerID(ctx context.Context, id int64) (string, int64, error) {
+//   - 适用于权限验证等只需用户 ID 的场景（如删除前的所有权检查）
+func (r *apiKeyRepository) GetOwnerID(ctx context.Context, id int64) (int64, error) {
 	m, err := r.activeQuery().
 		Where(apikey.IDEQ(id)).
-		Select(apikey.FieldKey, apikey.FieldUserID).
+		Select(apikey.FieldUserID).
 		Only(ctx)
 	if err != nil {
 		if dbent.IsNotFound(err) {
-			return "", 0, service.ErrAPIKeyNotFound
+			return 0, service.ErrAPIKeyNotFound
 		}
-		return "", 0, err
+		return 0, err
 	}
-	return m.Key, m.UserID, nil
+	return m.UserID, nil
 }
 
 func (r *apiKeyRepository) GetByKey(ctx context.Context, key string) (*service.APIKey, error) {
@@ -100,54 +98,6 @@ func (r *apiKeyRepository) GetByKey(ctx context.Context, key string) (*service.A
 	return apiKeyEntityToService(m), nil
 }
 
-func (r *apiKeyRepository) GetByKeyForAuth(ctx context.Context, key string) (*service.APIKey, error) {
-	m, err := r.activeQuery().
-		Where(apikey.KeyEQ(key)).
-		Select(
-			apikey.FieldID,
-			apikey.FieldUserID,
-			apikey.FieldGroupID,
-			apikey.FieldStatus,
-			apikey.FieldIPWhitelist,
-			apikey.FieldIPBlacklist,
-		).
-		WithUser(func(q *dbent.UserQuery) {
-			q.Select(
-				user.FieldID,
-				user.FieldStatus,
-				user.FieldRole,
-				user.FieldBalance,
-				user.FieldConcurrency,
-			)
-		}).
-		WithGroup(func(q *dbent.GroupQuery) {
-			q.Select(
-				group.FieldID,
-				group.FieldName,
-				group.FieldPlatform,
-				group.FieldStatus,
-				group.FieldSubscriptionType,
-				group.FieldRateMultiplier,
-				group.FieldDailyLimitUsd,
-				group.FieldWeeklyLimitUsd,
-				group.FieldMonthlyLimitUsd,
-				group.FieldImagePrice1k,
-				group.FieldImagePrice2k,
-				group.FieldImagePrice4k,
-				group.FieldClaudeCodeOnly,
-				group.FieldFallbackGroupID,
-			)
-		}).
-		Only(ctx)
-	if err != nil {
-		if dbent.IsNotFound(err) {
-			return nil, service.ErrAPIKeyNotFound
-		}
-		return nil, err
-	}
-	return apiKeyEntityToService(m), nil
-}
-
 func (r *apiKeyRepository) Update(ctx context.Context, key *service.APIKey) error {
 	// 使用原子操作：将软删除检查与更新合并到同一语句，避免竞态条件。
 	// 之前的实现先检查 Exist 再 UpdateOneID，若在两步之间发生软删除，
@@ -333,28 +283,6 @@ func (r *apiKeyRepository) CountByGroupID(ctx context.Context, groupID int64) (i
 	return int64(count), err
 }
 
-func (r *apiKeyRepository) ListKeysByUserID(ctx context.Context, userID int64) ([]string, error) {
-	keys, err := r.activeQuery().
-		Where(apikey.UserIDEQ(userID)).
-		Select(apikey.FieldKey).
-		Strings(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return keys, nil
-}
-
-func (r *apiKeyRepository) ListKeysByGroupID(ctx context.Context, groupID int64) ([]string, error) {
-	keys, err := r.activeQuery().
-		Where(apikey.GroupIDEQ(groupID)).
-		Select(apikey.FieldKey).
-		Strings(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return keys, nil
-}
-
 func apiKeyEntityToService(m *dbent.APIKey) *service.APIKey {
 	if m == nil {
 		return nil

backend/internal/repository/concurrency_cache.go

@@ -93,7 +93,7 @@ var (
 		return redis.call('ZCARD', key)
 	`)
 
-	// incrementWaitScript - refreshes TTL on each increment to keep queue depth accurate
+	// incrementWaitScript - only sets TTL on first creation to avoid refreshing
 	// KEYS[1] = wait queue key
 	// ARGV[1] = maxWait
 	// ARGV[2] = TTL in seconds
@@ -111,13 +111,15 @@ var (
 
 		local newVal = redis.call('INCR', KEYS[1])
 
-		-- Refresh TTL so long-running traffic doesn't expire active queue counters.
-		redis.call('EXPIRE', KEYS[1], ARGV[2])
+		-- Only set TTL on first creation to avoid refreshing zombie data
+		if newVal == 1 then
+			redis.call('EXPIRE', KEYS[1], ARGV[2])
+		end
 
 			return 1
 		`)
 
-	// incrementAccountWaitScript - account-level wait queue count (refresh TTL on each increment)
+	// incrementAccountWaitScript - account-level wait queue count
 	incrementAccountWaitScript = redis.NewScript(`
 			local current = redis.call('GET', KEYS[1])
 			if current == false then
@@ -132,8 +134,10 @@ var (
 
 			local newVal = redis.call('INCR', KEYS[1])
 
-			-- Refresh TTL so long-running traffic doesn't expire active queue counters.
-			redis.call('EXPIRE', KEYS[1], ARGV[2])
+			-- Only set TTL on first creation to avoid refreshing zombie data
+			if newVal == 1 then
+				redis.call('EXPIRE', KEYS[1], ARGV[2])
+			end
 
 			return 1
 		`)

backend/internal/repository/dashboard_aggregation_repo.go

@@ -1,392 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"log"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/timezone"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/lib/pq"
-)
-
-type dashboardAggregationRepository struct {
-	sql sqlExecutor
-}
-
-// NewDashboardAggregationRepository 创建仪表盘预聚合仓储。
-func NewDashboardAggregationRepository(sqlDB *sql.DB) service.DashboardAggregationRepository {
-	if sqlDB == nil {
-		return nil
-	}
-	if !isPostgresDriver(sqlDB) {
-		log.Printf("[DashboardAggregation] 检测到非 PostgreSQL 驱动，已自动禁用预聚合")
-		return nil
-	}
-	return newDashboardAggregationRepositoryWithSQL(sqlDB)
-}
-
-func newDashboardAggregationRepositoryWithSQL(sqlq sqlExecutor) *dashboardAggregationRepository {
-	return &dashboardAggregationRepository{sql: sqlq}
-}
-
-func isPostgresDriver(db *sql.DB) bool {
-	if db == nil {
-		return false
-	}
-	_, ok := db.Driver().(*pq.Driver)
-	return ok
-}
-
-func (r *dashboardAggregationRepository) AggregateRange(ctx context.Context, start, end time.Time) error {
-	loc := timezone.Location()
-	startLocal := start.In(loc)
-	endLocal := end.In(loc)
-	if !endLocal.After(startLocal) {
-		return nil
-	}
-
-	hourStart := startLocal.Truncate(time.Hour)
-	hourEnd := endLocal.Truncate(time.Hour)
-	if endLocal.After(hourEnd) {
-		hourEnd = hourEnd.Add(time.Hour)
-	}
-
-	dayStart := truncateToDay(startLocal)
-	dayEnd := truncateToDay(endLocal)
-	if endLocal.After(dayEnd) {
-		dayEnd = dayEnd.Add(24 * time.Hour)
-	}
-
-	// 以桶边界聚合，允许覆盖 end 所在桶的剩余区间。
-	if err := r.insertHourlyActiveUsers(ctx, hourStart, hourEnd); err != nil {
-		return err
-	}
-	if err := r.insertDailyActiveUsers(ctx, hourStart, hourEnd); err != nil {
-		return err
-	}
-	if err := r.upsertHourlyAggregates(ctx, hourStart, hourEnd); err != nil {
-		return err
-	}
-	if err := r.upsertDailyAggregates(ctx, dayStart, dayEnd); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (r *dashboardAggregationRepository) GetAggregationWatermark(ctx context.Context) (time.Time, error) {
-	var ts time.Time
-	query := "SELECT last_aggregated_at FROM usage_dashboard_aggregation_watermark WHERE id = 1"
-	if err := scanSingleRow(ctx, r.sql, query, nil, &ts); err != nil {
-		if err == sql.ErrNoRows {
-			return time.Unix(0, 0).UTC(), nil
-		}
-		return time.Time{}, err
-	}
-	return ts.UTC(), nil
-}
-
-func (r *dashboardAggregationRepository) UpdateAggregationWatermark(ctx context.Context, aggregatedAt time.Time) error {
-	query := `
-		INSERT INTO usage_dashboard_aggregation_watermark (id, last_aggregated_at, updated_at)
-		VALUES (1, $1, NOW())
-		ON CONFLICT (id)
-		DO UPDATE SET last_aggregated_at = EXCLUDED.last_aggregated_at, updated_at = EXCLUDED.updated_at
-	`
-	_, err := r.sql.ExecContext(ctx, query, aggregatedAt.UTC())
-	return err
-}
-
-func (r *dashboardAggregationRepository) CleanupAggregates(ctx context.Context, hourlyCutoff, dailyCutoff time.Time) error {
-	hourlyCutoffUTC := hourlyCutoff.UTC()
-	dailyCutoffUTC := dailyCutoff.UTC()
-	if _, err := r.sql.ExecContext(ctx, "DELETE FROM usage_dashboard_hourly WHERE bucket_start < $1", hourlyCutoffUTC); err != nil {
-		return err
-	}
-	if _, err := r.sql.ExecContext(ctx, "DELETE FROM usage_dashboard_hourly_users WHERE bucket_start < $1", hourlyCutoffUTC); err != nil {
-		return err
-	}
-	if _, err := r.sql.ExecContext(ctx, "DELETE FROM usage_dashboard_daily WHERE bucket_date < $1::date", dailyCutoffUTC); err != nil {
-		return err
-	}
-	if _, err := r.sql.ExecContext(ctx, "DELETE FROM usage_dashboard_daily_users WHERE bucket_date < $1::date", dailyCutoffUTC); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (r *dashboardAggregationRepository) CleanupUsageLogs(ctx context.Context, cutoff time.Time) error {
-	isPartitioned, err := r.isUsageLogsPartitioned(ctx)
-	if err != nil {
-		return err
-	}
-	if isPartitioned {
-		return r.dropUsageLogsPartitions(ctx, cutoff)
-	}
-	_, err = r.sql.ExecContext(ctx, "DELETE FROM usage_logs WHERE created_at < $1", cutoff.UTC())
-	return err
-}
-
-func (r *dashboardAggregationRepository) EnsureUsageLogsPartitions(ctx context.Context, now time.Time) error {
-	isPartitioned, err := r.isUsageLogsPartitioned(ctx)
-	if err != nil || !isPartitioned {
-		return err
-	}
-	monthStart := truncateToMonthUTC(now)
-	prevMonth := monthStart.AddDate(0, -1, 0)
-	nextMonth := monthStart.AddDate(0, 1, 0)
-
-	for _, m := range []time.Time{prevMonth, monthStart, nextMonth} {
-		if err := r.createUsageLogsPartition(ctx, m); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (r *dashboardAggregationRepository) insertHourlyActiveUsers(ctx context.Context, start, end time.Time) error {
-	tzName := timezone.Name()
-	query := `
-		INSERT INTO usage_dashboard_hourly_users (bucket_start, user_id)
-		SELECT DISTINCT
-			date_trunc('hour', created_at AT TIME ZONE $3) AT TIME ZONE $3 AS bucket_start,
-			user_id
-		FROM usage_logs
-		WHERE created_at >= $1 AND created_at < $2
-		ON CONFLICT DO NOTHING
-	`
-	_, err := r.sql.ExecContext(ctx, query, start, end, tzName)
-	return err
-}
-
-func (r *dashboardAggregationRepository) insertDailyActiveUsers(ctx context.Context, start, end time.Time) error {
-	tzName := timezone.Name()
-	query := `
-		INSERT INTO usage_dashboard_daily_users (bucket_date, user_id)
-		SELECT DISTINCT
-			(bucket_start AT TIME ZONE $3)::date AS bucket_date,
-			user_id
-		FROM usage_dashboard_hourly_users
-		WHERE bucket_start >= $1 AND bucket_start < $2
-		ON CONFLICT DO NOTHING
-	`
-	_, err := r.sql.ExecContext(ctx, query, start, end, tzName)
-	return err
-}
-
-func (r *dashboardAggregationRepository) upsertHourlyAggregates(ctx context.Context, start, end time.Time) error {
-	tzName := timezone.Name()
-	query := `
-		WITH hourly AS (
-			SELECT
-				date_trunc('hour', created_at AT TIME ZONE $3) AT TIME ZONE $3 AS bucket_start,
-				COUNT(*) AS total_requests,
-				COALESCE(SUM(input_tokens), 0) AS input_tokens,
-				COALESCE(SUM(output_tokens), 0) AS output_tokens,
-				COALESCE(SUM(cache_creation_tokens), 0) AS cache_creation_tokens,
-				COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens,
-				COALESCE(SUM(total_cost), 0) AS total_cost,
-				COALESCE(SUM(actual_cost), 0) AS actual_cost,
-				COALESCE(SUM(COALESCE(duration_ms, 0)), 0) AS total_duration_ms
-			FROM usage_logs
-			WHERE created_at >= $1 AND created_at < $2
-			GROUP BY 1
-		),
-		user_counts AS (
-			SELECT bucket_start, COUNT(*) AS active_users
-			FROM usage_dashboard_hourly_users
-			WHERE bucket_start >= $1 AND bucket_start < $2
-			GROUP BY bucket_start
-		)
-		INSERT INTO usage_dashboard_hourly (
-			bucket_start,
-			total_requests,
-			input_tokens,
-			output_tokens,
-			cache_creation_tokens,
-			cache_read_tokens,
-			total_cost,
-			actual_cost,
-			total_duration_ms,
-			active_users,
-			computed_at
-		)
-		SELECT
-			hourly.bucket_start,
-			hourly.total_requests,
-			hourly.input_tokens,
-			hourly.output_tokens,
-			hourly.cache_creation_tokens,
-			hourly.cache_read_tokens,
-			hourly.total_cost,
-			hourly.actual_cost,
-			hourly.total_duration_ms,
-			COALESCE(user_counts.active_users, 0) AS active_users,
-			NOW()
-		FROM hourly
-		LEFT JOIN user_counts ON user_counts.bucket_start = hourly.bucket_start
-		ON CONFLICT (bucket_start)
-		DO UPDATE SET
-			total_requests = EXCLUDED.total_requests,
-			input_tokens = EXCLUDED.input_tokens,
-			output_tokens = EXCLUDED.output_tokens,
-			cache_creation_tokens = EXCLUDED.cache_creation_tokens,
-			cache_read_tokens = EXCLUDED.cache_read_tokens,
-			total_cost = EXCLUDED.total_cost,
-			actual_cost = EXCLUDED.actual_cost,
-			total_duration_ms = EXCLUDED.total_duration_ms,
-			active_users = EXCLUDED.active_users,
-			computed_at = EXCLUDED.computed_at
-	`
-	_, err := r.sql.ExecContext(ctx, query, start, end, tzName)
-	return err
-}
-
-func (r *dashboardAggregationRepository) upsertDailyAggregates(ctx context.Context, start, end time.Time) error {
-	tzName := timezone.Name()
-	query := `
-		WITH daily AS (
-			SELECT
-				(bucket_start AT TIME ZONE $5)::date AS bucket_date,
-				COALESCE(SUM(total_requests), 0) AS total_requests,
-				COALESCE(SUM(input_tokens), 0) AS input_tokens,
-				COALESCE(SUM(output_tokens), 0) AS output_tokens,
-				COALESCE(SUM(cache_creation_tokens), 0) AS cache_creation_tokens,
-				COALESCE(SUM(cache_read_tokens), 0) AS cache_read_tokens,
-				COALESCE(SUM(total_cost), 0) AS total_cost,
-				COALESCE(SUM(actual_cost), 0) AS actual_cost,
-				COALESCE(SUM(total_duration_ms), 0) AS total_duration_ms
-			FROM usage_dashboard_hourly
-			WHERE bucket_start >= $1 AND bucket_start < $2
-			GROUP BY (bucket_start AT TIME ZONE $5)::date
-		),
-		user_counts AS (
-			SELECT bucket_date, COUNT(*) AS active_users
-			FROM usage_dashboard_daily_users
-			WHERE bucket_date >= $3::date AND bucket_date < $4::date
-			GROUP BY bucket_date
-		)
-		INSERT INTO usage_dashboard_daily (
-			bucket_date,
-			total_requests,
-			input_tokens,
-			output_tokens,
-			cache_creation_tokens,
-			cache_read_tokens,
-			total_cost,
-			actual_cost,
-			total_duration_ms,
-			active_users,
-			computed_at
-		)
-		SELECT
-			daily.bucket_date,
-			daily.total_requests,
-			daily.input_tokens,
-			daily.output_tokens,
-			daily.cache_creation_tokens,
-			daily.cache_read_tokens,
-			daily.total_cost,
-			daily.actual_cost,
-			daily.total_duration_ms,
-			COALESCE(user_counts.active_users, 0) AS active_users,
-			NOW()
-		FROM daily
-		LEFT JOIN user_counts ON user_counts.bucket_date = daily.bucket_date
-		ON CONFLICT (bucket_date)
-		DO UPDATE SET
-			total_requests = EXCLUDED.total_requests,
-			input_tokens = EXCLUDED.input_tokens,
-			output_tokens = EXCLUDED.output_tokens,
-			cache_creation_tokens = EXCLUDED.cache_creation_tokens,
-			cache_read_tokens = EXCLUDED.cache_read_tokens,
-			total_cost = EXCLUDED.total_cost,
-			actual_cost = EXCLUDED.actual_cost,
-			total_duration_ms = EXCLUDED.total_duration_ms,
-			active_users = EXCLUDED.active_users,
-			computed_at = EXCLUDED.computed_at
-	`
-	_, err := r.sql.ExecContext(ctx, query, start, end, start, end, tzName)
-	return err
-}
-
-func (r *dashboardAggregationRepository) isUsageLogsPartitioned(ctx context.Context) (bool, error) {
-	query := `
-		SELECT EXISTS(
-			SELECT 1
-			FROM pg_partitioned_table pt
-			JOIN pg_class c ON c.oid = pt.partrelid
-			WHERE c.relname = 'usage_logs'
-		)
-	`
-	var partitioned bool
-	if err := scanSingleRow(ctx, r.sql, query, nil, &partitioned); err != nil {
-		return false, err
-	}
-	return partitioned, nil
-}
-
-func (r *dashboardAggregationRepository) dropUsageLogsPartitions(ctx context.Context, cutoff time.Time) error {
-	rows, err := r.sql.QueryContext(ctx, `
-		SELECT c.relname
-		FROM pg_inherits
-		JOIN pg_class c ON c.oid = pg_inherits.inhrelid
-		JOIN pg_class p ON p.oid = pg_inherits.inhparent
-		WHERE p.relname = 'usage_logs'
-	`)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		_ = rows.Close()
-	}()
-
-	cutoffMonth := truncateToMonthUTC(cutoff)
-	for rows.Next() {
-		var name string
-		if err := rows.Scan(&name); err != nil {
-			return err
-		}
-		if !strings.HasPrefix(name, "usage_logs_") {
-			continue
-		}
-		suffix := strings.TrimPrefix(name, "usage_logs_")
-		month, err := time.Parse("200601", suffix)
-		if err != nil {
-			continue
-		}
-		month = month.UTC()
-		if month.Before(cutoffMonth) {
-			if _, err := r.sql.ExecContext(ctx, fmt.Sprintf("DROP TABLE IF EXISTS %s", pq.QuoteIdentifier(name))); err != nil {
-				return err
-			}
-		}
-	}
-	return rows.Err()
-}
-
-func (r *dashboardAggregationRepository) createUsageLogsPartition(ctx context.Context, month time.Time) error {
-	monthStart := truncateToMonthUTC(month)
-	nextMonth := monthStart.AddDate(0, 1, 0)
-	name := fmt.Sprintf("usage_logs_%s", monthStart.Format("200601"))
-	query := fmt.Sprintf(
-		"CREATE TABLE IF NOT EXISTS %s PARTITION OF usage_logs FOR VALUES FROM (%s) TO (%s)",
-		pq.QuoteIdentifier(name),
-		pq.QuoteLiteral(monthStart.Format("2006-01-02")),
-		pq.QuoteLiteral(nextMonth.Format("2006-01-02")),
-	)
-	_, err := r.sql.ExecContext(ctx, query)
-	return err
-}
-
-func truncateToDay(t time.Time) time.Time {
-	return timezone.StartOfDay(t)
-}
-
-func truncateToMonthUTC(t time.Time) time.Time {
-	t = t.UTC()
-	return time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, time.UTC)
-}

backend/internal/repository/dashboard_cache.go

@@ -1,58 +0,0 @@
-package repository
-
-import (
-	"context"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/config"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/redis/go-redis/v9"
-)
-
-const dashboardStatsCacheKey = "dashboard:stats:v1"
-
-type dashboardCache struct {
-	rdb       *redis.Client
-	keyPrefix string
-}
-
-func NewDashboardCache(rdb *redis.Client, cfg *config.Config) service.DashboardStatsCache {
-	prefix := "sub2api:"
-	if cfg != nil {
-		prefix = strings.TrimSpace(cfg.Dashboard.KeyPrefix)
-	}
-	if prefix != "" && !strings.HasSuffix(prefix, ":") {
-		prefix += ":"
-	}
-	return &dashboardCache{
-		rdb:       rdb,
-		keyPrefix: prefix,
-	}
-}
-
-func (c *dashboardCache) GetDashboardStats(ctx context.Context) (string, error) {
-	val, err := c.rdb.Get(ctx, c.buildKey()).Result()
-	if err != nil {
-		if err == redis.Nil {
-			return "", service.ErrDashboardStatsCacheMiss
-		}
-		return "", err
-	}
-	return val, nil
-}
-
-func (c *dashboardCache) SetDashboardStats(ctx context.Context, data string, ttl time.Duration) error {
-	return c.rdb.Set(ctx, c.buildKey(), data, ttl).Err()
-}
-
-func (c *dashboardCache) buildKey() string {
-	if c.keyPrefix == "" {
-		return dashboardStatsCacheKey
-	}
-	return c.keyPrefix + dashboardStatsCacheKey
-}
-
-func (c *dashboardCache) DeleteDashboardStats(ctx context.Context) error {
-	return c.rdb.Del(ctx, c.buildKey()).Err()
-}

backend/internal/repository/dashboard_cache_test.go

@@ -1,28 +0,0 @@
-package repository
-
-import (
-	"testing"
-
-	"github.com/Wei-Shaw/sub2api/internal/config"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewDashboardCacheKeyPrefix(t *testing.T) {
-	cache := NewDashboardCache(nil, &config.Config{
-		Dashboard: config.DashboardCacheConfig{
-			KeyPrefix: "prod",
-		},
-	})
-	impl, ok := cache.(*dashboardCache)
-	require.True(t, ok)
-	require.Equal(t, "prod:", impl.keyPrefix)
-
-	cache = NewDashboardCache(nil, &config.Config{
-		Dashboard: config.DashboardCacheConfig{
-			KeyPrefix: "staging:",
-		},
-	})
-	impl, ok = cache.(*dashboardCache)
-	require.True(t, ok)
-	require.Equal(t, "staging:", impl.keyPrefix)
-}

backend/internal/repository/gemini_token_cache.go

@@ -33,11 +33,6 @@ func (c *geminiTokenCache) SetAccessToken(ctx context.Context, cacheKey string,
 	return c.rdb.Set(ctx, key, token, ttl).Err()
 }
 
-func (c *geminiTokenCache) DeleteAccessToken(ctx context.Context, cacheKey string) error {
-	key := fmt.Sprintf("%s%s", geminiTokenKeyPrefix, cacheKey)
-	return c.rdb.Del(ctx, key).Err()
-}
-
 func (c *geminiTokenCache) AcquireRefreshLock(ctx context.Context, cacheKey string, ttl time.Duration) (bool, error) {
 	key := fmt.Sprintf("%s%s", geminiRefreshLockKeyPrefix, cacheKey)
 	return c.rdb.SetNX(ctx, key, 1, ttl).Result()

backend/internal/repository/gemini_token_cache_integration_test.go

@@ -1,47 +0,0 @@
-//go:build integration
-
-package repository
-
-import (
-	"errors"
-	"testing"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/redis/go-redis/v9"
-	"github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
-)
-
-type GeminiTokenCacheSuite struct {
-	IntegrationRedisSuite
-	cache service.GeminiTokenCache
-}
-
-func (s *GeminiTokenCacheSuite) SetupTest() {
-	s.IntegrationRedisSuite.SetupTest()
-	s.cache = NewGeminiTokenCache(s.rdb)
-}
-
-func (s *GeminiTokenCacheSuite) TestDeleteAccessToken() {
-	cacheKey := "project-123"
-	token := "token-value"
-	require.NoError(s.T(), s.cache.SetAccessToken(s.ctx, cacheKey, token, time.Minute))
-
-	got, err := s.cache.GetAccessToken(s.ctx, cacheKey)
-	require.NoError(s.T(), err)
-	require.Equal(s.T(), token, got)
-
-	require.NoError(s.T(), s.cache.DeleteAccessToken(s.ctx, cacheKey))
-
-	_, err = s.cache.GetAccessToken(s.ctx, cacheKey)
-	require.True(s.T(), errors.Is(err, redis.Nil), "expected redis.Nil after delete")
-}
-
-func (s *GeminiTokenCacheSuite) TestDeleteAccessToken_MissingKey() {
-	require.NoError(s.T(), s.cache.DeleteAccessToken(s.ctx, "missing-key"))
-}
-
-func TestGeminiTokenCacheSuite(t *testing.T) {
-	suite.Run(t, new(GeminiTokenCacheSuite))
-}

backend/internal/repository/gemini_token_cache_test.go

@@ -1,28 +0,0 @@
-//go:build unit
-
-package repository
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/redis/go-redis/v9"
-	"github.com/stretchr/testify/require"
-)
-
-func TestGeminiTokenCache_DeleteAccessToken_RedisError(t *testing.T) {
-	rdb := redis.NewClient(&redis.Options{
-		Addr:         "127.0.0.1:1",
-		DialTimeout:  50 * time.Millisecond,
-		ReadTimeout:  50 * time.Millisecond,
-		WriteTimeout: 50 * time.Millisecond,
-	})
-	t.Cleanup(func() {
-		_ = rdb.Close()
-	})
-
-	cache := NewGeminiTokenCache(rdb)
-	err := cache.DeleteAccessToken(context.Background(), "broken")
-	require.Error(t, err)
-}

backend/internal/repository/group_repo.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"log"
 
 	dbent "github.com/Wei-Shaw/sub2api/ent"
 	"github.com/Wei-Shaw/sub2api/ent/apikey"
@@ -56,9 +55,6 @@ func (r *groupRepository) Create(ctx context.Context, groupIn *service.Group) er
 		groupIn.ID = created.ID
 		groupIn.CreatedAt = created.CreatedAt
 		groupIn.UpdatedAt = created.UpdatedAt
-		if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventGroupChanged, nil, &groupIn.ID, nil); err != nil {
-			log.Printf("[SchedulerOutbox] enqueue group create failed: group=%d err=%v", groupIn.ID, err)
-		}
 	}
 	return translatePersistenceError(err, nil, service.ErrGroupExists)
 }
@@ -115,21 +111,12 @@ func (r *groupRepository) Update(ctx context.Context, groupIn *service.Group) er
 		return translatePersistenceError(err, service.ErrGroupNotFound, service.ErrGroupExists)
 	}
 	groupIn.UpdatedAt = updated.UpdatedAt
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventGroupChanged, nil, &groupIn.ID, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue group update failed: group=%d err=%v", groupIn.ID, err)
-	}
 	return nil
 }
 
 func (r *groupRepository) Delete(ctx context.Context, id int64) error {
 	_, err := r.client.Group.Delete().Where(group.IDEQ(id)).Exec(ctx)
-	if err != nil {
-		return translatePersistenceError(err, service.ErrGroupNotFound, nil)
-	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventGroupChanged, nil, &id, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue group delete failed: group=%d err=%v", id, err)
-	}
-	return nil
+	return translatePersistenceError(err, service.ErrGroupNotFound, nil)
 }
 
 func (r *groupRepository) List(ctx context.Context, params pagination.PaginationParams) ([]service.Group, *pagination.PaginationResult, error) {
@@ -259,9 +246,6 @@ func (r *groupRepository) DeleteAccountGroupsByGroupID(ctx context.Context, grou
 		return 0, err
 	}
 	affected, _ := res.RowsAffected()
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventGroupChanged, nil, &groupID, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue group account clear failed: group=%d err=%v", groupID, err)
-	}
 	return affected, nil
 }
 
@@ -369,9 +353,6 @@ func (r *groupRepository) DeleteCascade(ctx context.Context, id int64) ([]int64,
 			return nil, err
 		}
 	}
-	if err := enqueueSchedulerOutbox(ctx, r.sql, service.SchedulerOutboxEventGroupChanged, nil, &id, nil); err != nil {
-		log.Printf("[SchedulerOutbox] enqueue group cascade delete failed: group=%d err=%v", id, err)
-	}
 
 	return affectedUserIDs, nil
 }

backend/internal/repository/migrations_runner.go

@@ -28,23 +28,6 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 );
 `
 
-const atlasSchemaRevisionsTableDDL = `
-CREATE TABLE IF NOT EXISTS atlas_schema_revisions (
-	version TEXT PRIMARY KEY,
-	description TEXT NOT NULL,
-	type INTEGER NOT NULL,
-	applied INTEGER NOT NULL DEFAULT 0,
-	total INTEGER NOT NULL DEFAULT 0,
-	executed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-	execution_time BIGINT NOT NULL DEFAULT 0,
-	error TEXT NULL,
-	error_stmt TEXT NULL,
-	hash TEXT NOT NULL DEFAULT '',
-	partial_hashes TEXT[] NULL,
-	operator_version TEXT NULL
-);
-`
-
 // migrationsAdvisoryLockID 是用于序列化迁移操作的 PostgreSQL Advisory Lock ID。
 // 在多实例部署场景下，该锁确保同一时间只有一个实例执行迁移。
 // 任何稳定的 int64 值都可以，只要不与同一数据库中的其他锁冲突即可。
@@ -111,11 +94,6 @@ func applyMigrationsFS(ctx context.Context, db *sql.DB, fsys fs.FS) error {
 		return fmt.Errorf("create schema_migrations: %w", err)
 	}
 
-	// 自动对齐 Atlas 基线（如果检测到 legacy schema_migrations 且缺失 atlas_schema_revisions）。
-	if err := ensureAtlasBaselineAligned(ctx, db, fsys); err != nil {
-		return err
-	}
-
 	// 获取所有 .sql 迁移文件并按文件名排序。
 	// 命名规范：使用零填充数字前缀（如 001_init.sql, 002_add_users.sql）。
 	files, err := fs.Glob(fsys, "*.sql")
@@ -194,80 +172,6 @@ func applyMigrationsFS(ctx context.Context, db *sql.DB, fsys fs.FS) error {
 	return nil
 }
 
-func ensureAtlasBaselineAligned(ctx context.Context, db *sql.DB, fsys fs.FS) error {
-	hasLegacy, err := tableExists(ctx, db, "schema_migrations")
-	if err != nil {
-		return fmt.Errorf("check schema_migrations: %w", err)
-	}
-	if !hasLegacy {
-		return nil
-	}
-
-	hasAtlas, err := tableExists(ctx, db, "atlas_schema_revisions")
-	if err != nil {
-		return fmt.Errorf("check atlas_schema_revisions: %w", err)
-	}
-	if !hasAtlas {
-		if _, err := db.ExecContext(ctx, atlasSchemaRevisionsTableDDL); err != nil {
-			return fmt.Errorf("create atlas_schema_revisions: %w", err)
-		}
-	}
-
-	var count int
-	if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM atlas_schema_revisions").Scan(&count); err != nil {
-		return fmt.Errorf("count atlas_schema_revisions: %w", err)
-	}
-	if count > 0 {
-		return nil
-	}
-
-	version, description, hash, err := latestMigrationBaseline(fsys)
-	if err != nil {
-		return fmt.Errorf("atlas baseline version: %w", err)
-	}
-
-	if _, err := db.ExecContext(ctx, `
-		INSERT INTO atlas_schema_revisions (version, description, type, applied, total, executed_at, execution_time, hash)
-		VALUES ($1, $2, $3, 0, 0, NOW(), 0, $4)
-	`, version, description, 1, hash); err != nil {
-		return fmt.Errorf("insert atlas baseline: %w", err)
-	}
-	return nil
-}
-
-func tableExists(ctx context.Context, db *sql.DB, tableName string) (bool, error) {
-	var exists bool
-	err := db.QueryRowContext(ctx, `
-		SELECT EXISTS (
-			SELECT 1
-			FROM information_schema.tables
-			WHERE table_schema = 'public' AND table_name = $1
-		)
-	`, tableName).Scan(&exists)
-	return exists, err
-}
-
-func latestMigrationBaseline(fsys fs.FS) (string, string, string, error) {
-	files, err := fs.Glob(fsys, "*.sql")
-	if err != nil {
-		return "", "", "", err
-	}
-	if len(files) == 0 {
-		return "baseline", "baseline", "", nil
-	}
-	sort.Strings(files)
-	name := files[len(files)-1]
-	contentBytes, err := fs.ReadFile(fsys, name)
-	if err != nil {
-		return "", "", "", err
-	}
-	content := strings.TrimSpace(string(contentBytes))
-	sum := sha256.Sum256([]byte(content))
-	hash := hex.EncodeToString(sum[:])
-	version := strings.TrimSuffix(name, ".sql")
-	return version, version, hash, nil
-}
-
 // pgAdvisoryLock 获取 PostgreSQL Advisory Lock。
 // Advisory Lock 是一种轻量级的锁机制，不与任何特定的数据库对象关联。
 // 它非常适合用于应用层面的分布式锁场景，如迁移序列化。

backend/internal/repository/ops_repo_alerts.go

@@ -1,853 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) ListAlertRules(ctx context.Context) ([]*service.OpsAlertRule, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-
-	q := `
-SELECT
-  id,
-  name,
-  COALESCE(description, ''),
-  enabled,
-  COALESCE(severity, ''),
-  metric_type,
-  operator,
-  threshold,
-  window_minutes,
-  sustained_minutes,
-  cooldown_minutes,
-  COALESCE(notify_email, true),
-  filters,
-  last_triggered_at,
-  created_at,
-  updated_at
-FROM ops_alert_rules
-ORDER BY id DESC`
-
-	rows, err := r.db.QueryContext(ctx, q)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	out := []*service.OpsAlertRule{}
-	for rows.Next() {
-		var rule service.OpsAlertRule
-		var filtersRaw []byte
-		var lastTriggeredAt sql.NullTime
-		if err := rows.Scan(
-			&rule.ID,
-			&rule.Name,
-			&rule.Description,
-			&rule.Enabled,
-			&rule.Severity,
-			&rule.MetricType,
-			&rule.Operator,
-			&rule.Threshold,
-			&rule.WindowMinutes,
-			&rule.SustainedMinutes,
-			&rule.CooldownMinutes,
-			&rule.NotifyEmail,
-			&filtersRaw,
-			&lastTriggeredAt,
-			&rule.CreatedAt,
-			&rule.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		if lastTriggeredAt.Valid {
-			v := lastTriggeredAt.Time
-			rule.LastTriggeredAt = &v
-		}
-		if len(filtersRaw) > 0 && string(filtersRaw) != "null" {
-			var decoded map[string]any
-			if err := json.Unmarshal(filtersRaw, &decoded); err == nil {
-				rule.Filters = decoded
-			}
-		}
-		out = append(out, &rule)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (r *opsRepository) CreateAlertRule(ctx context.Context, input *service.OpsAlertRule) (*service.OpsAlertRule, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if input == nil {
-		return nil, fmt.Errorf("nil input")
-	}
-
-	filtersArg, err := opsNullJSONMap(input.Filters)
-	if err != nil {
-		return nil, err
-	}
-
-	q := `
-INSERT INTO ops_alert_rules (
-  name,
-  description,
-  enabled,
-  severity,
-  metric_type,
-  operator,
-  threshold,
-  window_minutes,
-  sustained_minutes,
-  cooldown_minutes,
-  notify_email,
-  filters,
-  created_at,
-  updated_at
-) VALUES (
-  $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,NOW(),NOW()
-)
-RETURNING
-  id,
-  name,
-  COALESCE(description, ''),
-  enabled,
-  COALESCE(severity, ''),
-  metric_type,
-  operator,
-  threshold,
-  window_minutes,
-  sustained_minutes,
-  cooldown_minutes,
-  COALESCE(notify_email, true),
-  filters,
-  last_triggered_at,
-  created_at,
-  updated_at`
-
-	var out service.OpsAlertRule
-	var filtersRaw []byte
-	var lastTriggeredAt sql.NullTime
-
-	if err := r.db.QueryRowContext(
-		ctx,
-		q,
-		strings.TrimSpace(input.Name),
-		strings.TrimSpace(input.Description),
-		input.Enabled,
-		strings.TrimSpace(input.Severity),
-		strings.TrimSpace(input.MetricType),
-		strings.TrimSpace(input.Operator),
-		input.Threshold,
-		input.WindowMinutes,
-		input.SustainedMinutes,
-		input.CooldownMinutes,
-		input.NotifyEmail,
-		filtersArg,
-	).Scan(
-		&out.ID,
-		&out.Name,
-		&out.Description,
-		&out.Enabled,
-		&out.Severity,
-		&out.MetricType,
-		&out.Operator,
-		&out.Threshold,
-		&out.WindowMinutes,
-		&out.SustainedMinutes,
-		&out.CooldownMinutes,
-		&out.NotifyEmail,
-		&filtersRaw,
-		&lastTriggeredAt,
-		&out.CreatedAt,
-		&out.UpdatedAt,
-	); err != nil {
-		return nil, err
-	}
-	if lastTriggeredAt.Valid {
-		v := lastTriggeredAt.Time
-		out.LastTriggeredAt = &v
-	}
-	if len(filtersRaw) > 0 && string(filtersRaw) != "null" {
-		var decoded map[string]any
-		if err := json.Unmarshal(filtersRaw, &decoded); err == nil {
-			out.Filters = decoded
-		}
-	}
-
-	return &out, nil
-}
-
-func (r *opsRepository) UpdateAlertRule(ctx context.Context, input *service.OpsAlertRule) (*service.OpsAlertRule, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if input == nil {
-		return nil, fmt.Errorf("nil input")
-	}
-	if input.ID <= 0 {
-		return nil, fmt.Errorf("invalid id")
-	}
-
-	filtersArg, err := opsNullJSONMap(input.Filters)
-	if err != nil {
-		return nil, err
-	}
-
-	q := `
-UPDATE ops_alert_rules
-SET
-  name = $2,
-  description = $3,
-  enabled = $4,
-  severity = $5,
-  metric_type = $6,
-  operator = $7,
-  threshold = $8,
-  window_minutes = $9,
-  sustained_minutes = $10,
-  cooldown_minutes = $11,
-  notify_email = $12,
-  filters = $13,
-  updated_at = NOW()
-WHERE id = $1
-RETURNING
-  id,
-  name,
-  COALESCE(description, ''),
-  enabled,
-  COALESCE(severity, ''),
-  metric_type,
-  operator,
-  threshold,
-  window_minutes,
-  sustained_minutes,
-  cooldown_minutes,
-  COALESCE(notify_email, true),
-  filters,
-  last_triggered_at,
-  created_at,
-  updated_at`
-
-	var out service.OpsAlertRule
-	var filtersRaw []byte
-	var lastTriggeredAt sql.NullTime
-
-	if err := r.db.QueryRowContext(
-		ctx,
-		q,
-		input.ID,
-		strings.TrimSpace(input.Name),
-		strings.TrimSpace(input.Description),
-		input.Enabled,
-		strings.TrimSpace(input.Severity),
-		strings.TrimSpace(input.MetricType),
-		strings.TrimSpace(input.Operator),
-		input.Threshold,
-		input.WindowMinutes,
-		input.SustainedMinutes,
-		input.CooldownMinutes,
-		input.NotifyEmail,
-		filtersArg,
-	).Scan(
-		&out.ID,
-		&out.Name,
-		&out.Description,
-		&out.Enabled,
-		&out.Severity,
-		&out.MetricType,
-		&out.Operator,
-		&out.Threshold,
-		&out.WindowMinutes,
-		&out.SustainedMinutes,
-		&out.CooldownMinutes,
-		&out.NotifyEmail,
-		&filtersRaw,
-		&lastTriggeredAt,
-		&out.CreatedAt,
-		&out.UpdatedAt,
-	); err != nil {
-		return nil, err
-	}
-
-	if lastTriggeredAt.Valid {
-		v := lastTriggeredAt.Time
-		out.LastTriggeredAt = &v
-	}
-	if len(filtersRaw) > 0 && string(filtersRaw) != "null" {
-		var decoded map[string]any
-		if err := json.Unmarshal(filtersRaw, &decoded); err == nil {
-			out.Filters = decoded
-		}
-	}
-
-	return &out, nil
-}
-
-func (r *opsRepository) DeleteAlertRule(ctx context.Context, id int64) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if id <= 0 {
-		return fmt.Errorf("invalid id")
-	}
-
-	res, err := r.db.ExecContext(ctx, "DELETE FROM ops_alert_rules WHERE id = $1", id)
-	if err != nil {
-		return err
-	}
-	affected, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if affected == 0 {
-		return sql.ErrNoRows
-	}
-	return nil
-}
-
-func (r *opsRepository) ListAlertEvents(ctx context.Context, filter *service.OpsAlertEventFilter) ([]*service.OpsAlertEvent, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		filter = &service.OpsAlertEventFilter{}
-	}
-
-	limit := filter.Limit
-	if limit <= 0 {
-		limit = 100
-	}
-	if limit > 500 {
-		limit = 500
-	}
-
-	where, args := buildOpsAlertEventsWhere(filter)
-	args = append(args, limit)
-	limitArg := "$" + itoa(len(args))
-
-	q := `
-SELECT
-  id,
-  COALESCE(rule_id, 0),
-  COALESCE(severity, ''),
-  COALESCE(status, ''),
-  COALESCE(title, ''),
-  COALESCE(description, ''),
-  metric_value,
-  threshold_value,
-  dimensions,
-  fired_at,
-  resolved_at,
-  email_sent,
-  created_at
-FROM ops_alert_events
-` + where + `
-ORDER BY fired_at DESC, id DESC
-LIMIT ` + limitArg
-
-	rows, err := r.db.QueryContext(ctx, q, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	out := []*service.OpsAlertEvent{}
-	for rows.Next() {
-		var ev service.OpsAlertEvent
-		var metricValue sql.NullFloat64
-		var thresholdValue sql.NullFloat64
-		var dimensionsRaw []byte
-		var resolvedAt sql.NullTime
-		if err := rows.Scan(
-			&ev.ID,
-			&ev.RuleID,
-			&ev.Severity,
-			&ev.Status,
-			&ev.Title,
-			&ev.Description,
-			&metricValue,
-			&thresholdValue,
-			&dimensionsRaw,
-			&ev.FiredAt,
-			&resolvedAt,
-			&ev.EmailSent,
-			&ev.CreatedAt,
-		); err != nil {
-			return nil, err
-		}
-		if metricValue.Valid {
-			v := metricValue.Float64
-			ev.MetricValue = &v
-		}
-		if thresholdValue.Valid {
-			v := thresholdValue.Float64
-			ev.ThresholdValue = &v
-		}
-		if resolvedAt.Valid {
-			v := resolvedAt.Time
-			ev.ResolvedAt = &v
-		}
-		if len(dimensionsRaw) > 0 && string(dimensionsRaw) != "null" {
-			var decoded map[string]any
-			if err := json.Unmarshal(dimensionsRaw, &decoded); err == nil {
-				ev.Dimensions = decoded
-			}
-		}
-		out = append(out, &ev)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (r *opsRepository) GetAlertEventByID(ctx context.Context, eventID int64) (*service.OpsAlertEvent, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if eventID <= 0 {
-		return nil, fmt.Errorf("invalid event id")
-	}
-
-	q := `
-SELECT
-  id,
-  COALESCE(rule_id, 0),
-  COALESCE(severity, ''),
-  COALESCE(status, ''),
-  COALESCE(title, ''),
-  COALESCE(description, ''),
-  metric_value,
-  threshold_value,
-  dimensions,
-  fired_at,
-  resolved_at,
-  email_sent,
-  created_at
-FROM ops_alert_events
-WHERE id = $1`
-
-	row := r.db.QueryRowContext(ctx, q, eventID)
-	ev, err := scanOpsAlertEvent(row)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return ev, nil
-}
-
-func (r *opsRepository) GetActiveAlertEvent(ctx context.Context, ruleID int64) (*service.OpsAlertEvent, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if ruleID <= 0 {
-		return nil, fmt.Errorf("invalid rule id")
-	}
-
-	q := `
-SELECT
-  id,
-  COALESCE(rule_id, 0),
-  COALESCE(severity, ''),
-  COALESCE(status, ''),
-  COALESCE(title, ''),
-  COALESCE(description, ''),
-  metric_value,
-  threshold_value,
-  dimensions,
-  fired_at,
-  resolved_at,
-  email_sent,
-  created_at
-FROM ops_alert_events
-WHERE rule_id = $1 AND status = $2
-ORDER BY fired_at DESC
-LIMIT 1`
-
-	row := r.db.QueryRowContext(ctx, q, ruleID, service.OpsAlertStatusFiring)
-	ev, err := scanOpsAlertEvent(row)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return ev, nil
-}
-
-func (r *opsRepository) GetLatestAlertEvent(ctx context.Context, ruleID int64) (*service.OpsAlertEvent, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if ruleID <= 0 {
-		return nil, fmt.Errorf("invalid rule id")
-	}
-
-	q := `
-SELECT
-  id,
-  COALESCE(rule_id, 0),
-  COALESCE(severity, ''),
-  COALESCE(status, ''),
-  COALESCE(title, ''),
-  COALESCE(description, ''),
-  metric_value,
-  threshold_value,
-  dimensions,
-  fired_at,
-  resolved_at,
-  email_sent,
-  created_at
-FROM ops_alert_events
-WHERE rule_id = $1
-ORDER BY fired_at DESC
-LIMIT 1`
-
-	row := r.db.QueryRowContext(ctx, q, ruleID)
-	ev, err := scanOpsAlertEvent(row)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return ev, nil
-}
-
-func (r *opsRepository) CreateAlertEvent(ctx context.Context, event *service.OpsAlertEvent) (*service.OpsAlertEvent, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if event == nil {
-		return nil, fmt.Errorf("nil event")
-	}
-
-	dimensionsArg, err := opsNullJSONMap(event.Dimensions)
-	if err != nil {
-		return nil, err
-	}
-
-	q := `
-INSERT INTO ops_alert_events (
-  rule_id,
-  severity,
-  status,
-  title,
-  description,
-  metric_value,
-  threshold_value,
-  dimensions,
-  fired_at,
-  resolved_at,
-  email_sent,
-  created_at
-) VALUES (
-  $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,NOW()
-)
-RETURNING
-  id,
-  COALESCE(rule_id, 0),
-  COALESCE(severity, ''),
-  COALESCE(status, ''),
-  COALESCE(title, ''),
-  COALESCE(description, ''),
-  metric_value,
-  threshold_value,
-  dimensions,
-  fired_at,
-  resolved_at,
-  email_sent,
-  created_at`
-
-	row := r.db.QueryRowContext(
-		ctx,
-		q,
-		opsNullInt64(&event.RuleID),
-		opsNullString(event.Severity),
-		opsNullString(event.Status),
-		opsNullString(event.Title),
-		opsNullString(event.Description),
-		opsNullFloat64(event.MetricValue),
-		opsNullFloat64(event.ThresholdValue),
-		dimensionsArg,
-		event.FiredAt,
-		opsNullTime(event.ResolvedAt),
-		event.EmailSent,
-	)
-	return scanOpsAlertEvent(row)
-}
-
-func (r *opsRepository) UpdateAlertEventStatus(ctx context.Context, eventID int64, status string, resolvedAt *time.Time) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if eventID <= 0 {
-		return fmt.Errorf("invalid event id")
-	}
-	if strings.TrimSpace(status) == "" {
-		return fmt.Errorf("invalid status")
-	}
-
-	q := `
-UPDATE ops_alert_events
-SET status = $2,
-    resolved_at = $3
-WHERE id = $1`
-
-	_, err := r.db.ExecContext(ctx, q, eventID, strings.TrimSpace(status), opsNullTime(resolvedAt))
-	return err
-}
-
-func (r *opsRepository) UpdateAlertEventEmailSent(ctx context.Context, eventID int64, emailSent bool) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if eventID <= 0 {
-		return fmt.Errorf("invalid event id")
-	}
-
-	_, err := r.db.ExecContext(ctx, "UPDATE ops_alert_events SET email_sent = $2 WHERE id = $1", eventID, emailSent)
-	return err
-}
-
-type opsAlertEventRow interface {
-	Scan(dest ...any) error
-}
-
-func (r *opsRepository) CreateAlertSilence(ctx context.Context, input *service.OpsAlertSilence) (*service.OpsAlertSilence, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if input == nil {
-		return nil, fmt.Errorf("nil input")
-	}
-	if input.RuleID <= 0 {
-		return nil, fmt.Errorf("invalid rule_id")
-	}
-	platform := strings.TrimSpace(input.Platform)
-	if platform == "" {
-		return nil, fmt.Errorf("invalid platform")
-	}
-	if input.Until.IsZero() {
-		return nil, fmt.Errorf("invalid until")
-	}
-
-	q := `
-INSERT INTO ops_alert_silences (
-  rule_id,
-  platform,
-  group_id,
-  region,
-  until,
-  reason,
-  created_by,
-  created_at
-) VALUES (
-  $1,$2,$3,$4,$5,$6,$7,NOW()
-)
-RETURNING id, rule_id, platform, group_id, region, until, COALESCE(reason,''), created_by, created_at`
-
-	row := r.db.QueryRowContext(
-		ctx,
-		q,
-		input.RuleID,
-		platform,
-		opsNullInt64(input.GroupID),
-		opsNullString(input.Region),
-		input.Until,
-		opsNullString(input.Reason),
-		opsNullInt64(input.CreatedBy),
-	)
-
-	var out service.OpsAlertSilence
-	var groupID sql.NullInt64
-	var region sql.NullString
-	var createdBy sql.NullInt64
-	if err := row.Scan(
-		&out.ID,
-		&out.RuleID,
-		&out.Platform,
-		&groupID,
-		&region,
-		&out.Until,
-		&out.Reason,
-		&createdBy,
-		&out.CreatedAt,
-	); err != nil {
-		return nil, err
-	}
-	if groupID.Valid {
-		v := groupID.Int64
-		out.GroupID = &v
-	}
-	if region.Valid {
-		v := strings.TrimSpace(region.String)
-		if v != "" {
-			out.Region = &v
-		}
-	}
-	if createdBy.Valid {
-		v := createdBy.Int64
-		out.CreatedBy = &v
-	}
-	return &out, nil
-}
-
-func (r *opsRepository) IsAlertSilenced(ctx context.Context, ruleID int64, platform string, groupID *int64, region *string, now time.Time) (bool, error) {
-	if r == nil || r.db == nil {
-		return false, fmt.Errorf("nil ops repository")
-	}
-	if ruleID <= 0 {
-		return false, fmt.Errorf("invalid rule id")
-	}
-	platform = strings.TrimSpace(platform)
-	if platform == "" {
-		return false, nil
-	}
-	if now.IsZero() {
-		now = time.Now().UTC()
-	}
-
-	q := `
-SELECT 1
-FROM ops_alert_silences
-WHERE rule_id = $1
-  AND platform = $2
-  AND (group_id IS NOT DISTINCT FROM $3)
-  AND (region IS NOT DISTINCT FROM $4)
-  AND until > $5
-LIMIT 1`
-
-	var dummy int
-	err := r.db.QueryRowContext(ctx, q, ruleID, platform, opsNullInt64(groupID), opsNullString(region), now).Scan(&dummy)
-	if err != nil {
-		if err == sql.ErrNoRows {
-			return false, nil
-		}
-		return false, err
-	}
-	return true, nil
-}
-
-func scanOpsAlertEvent(row opsAlertEventRow) (*service.OpsAlertEvent, error) {
-	var ev service.OpsAlertEvent
-	var metricValue sql.NullFloat64
-	var thresholdValue sql.NullFloat64
-	var dimensionsRaw []byte
-	var resolvedAt sql.NullTime
-
-	if err := row.Scan(
-		&ev.ID,
-		&ev.RuleID,
-		&ev.Severity,
-		&ev.Status,
-		&ev.Title,
-		&ev.Description,
-		&metricValue,
-		&thresholdValue,
-		&dimensionsRaw,
-		&ev.FiredAt,
-		&resolvedAt,
-		&ev.EmailSent,
-		&ev.CreatedAt,
-	); err != nil {
-		return nil, err
-	}
-	if metricValue.Valid {
-		v := metricValue.Float64
-		ev.MetricValue = &v
-	}
-	if thresholdValue.Valid {
-		v := thresholdValue.Float64
-		ev.ThresholdValue = &v
-	}
-	if resolvedAt.Valid {
-		v := resolvedAt.Time
-		ev.ResolvedAt = &v
-	}
-	if len(dimensionsRaw) > 0 && string(dimensionsRaw) != "null" {
-		var decoded map[string]any
-		if err := json.Unmarshal(dimensionsRaw, &decoded); err == nil {
-			ev.Dimensions = decoded
-		}
-	}
-	return &ev, nil
-}
-
-func buildOpsAlertEventsWhere(filter *service.OpsAlertEventFilter) (string, []any) {
-	clauses := []string{"1=1"}
-	args := []any{}
-
-	if filter == nil {
-		return "WHERE " + strings.Join(clauses, " AND "), args
-	}
-
-	if status := strings.TrimSpace(filter.Status); status != "" {
-		args = append(args, status)
-		clauses = append(clauses, "status = $"+itoa(len(args)))
-	}
-	if severity := strings.TrimSpace(filter.Severity); severity != "" {
-		args = append(args, severity)
-		clauses = append(clauses, "severity = $"+itoa(len(args)))
-	}
-	if filter.EmailSent != nil {
-		args = append(args, *filter.EmailSent)
-		clauses = append(clauses, "email_sent = $"+itoa(len(args)))
-	}
-	if filter.StartTime != nil && !filter.StartTime.IsZero() {
-		args = append(args, *filter.StartTime)
-		clauses = append(clauses, "fired_at >= $"+itoa(len(args)))
-	}
-	if filter.EndTime != nil && !filter.EndTime.IsZero() {
-		args = append(args, *filter.EndTime)
-		clauses = append(clauses, "fired_at < $"+itoa(len(args)))
-	}
-
-	// Cursor pagination (descending by fired_at, then id)
-	if filter.BeforeFiredAt != nil && !filter.BeforeFiredAt.IsZero() && filter.BeforeID != nil && *filter.BeforeID > 0 {
-		args = append(args, *filter.BeforeFiredAt)
-		tsArg := "$" + itoa(len(args))
-		args = append(args, *filter.BeforeID)
-		idArg := "$" + itoa(len(args))
-		clauses = append(clauses, fmt.Sprintf("(fired_at < %s OR (fired_at = %s AND id < %s))", tsArg, tsArg, idArg))
-	}
-	// Dimensions are stored in JSONB. We filter best-effort without requiring GIN indexes.
-	if platform := strings.TrimSpace(filter.Platform); platform != "" {
-		args = append(args, platform)
-		clauses = append(clauses, "(dimensions->>'platform') = $"+itoa(len(args)))
-	}
-	if filter.GroupID != nil && *filter.GroupID > 0 {
-		args = append(args, fmt.Sprintf("%d", *filter.GroupID))
-		clauses = append(clauses, "(dimensions->>'group_id') = $"+itoa(len(args)))
-	}
-
-	return "WHERE " + strings.Join(clauses, " AND "), args
-}
-
-func opsNullJSONMap(v map[string]any) (any, error) {
-	if v == nil {
-		return sql.NullString{}, nil
-	}
-	b, err := json.Marshal(v)
-	if err != nil {
-		return nil, err
-	}
-	if len(b) == 0 {
-		return sql.NullString{}, nil
-	}
-	return sql.NullString{String: string(b), Valid: true}, nil
-}

backend/internal/repository/ops_repo_histograms.go

@@ -1,79 +0,0 @@
-package repository
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) GetLatencyHistogram(ctx context.Context, filter *service.OpsDashboardFilter) (*service.OpsLatencyHistogramResponse, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		return nil, fmt.Errorf("nil filter")
-	}
-	if filter.StartTime.IsZero() || filter.EndTime.IsZero() {
-		return nil, fmt.Errorf("start_time/end_time required")
-	}
-
-	start := filter.StartTime.UTC()
-	end := filter.EndTime.UTC()
-
-	join, where, args, _ := buildUsageWhere(filter, start, end, 1)
-	rangeExpr := latencyHistogramRangeCaseExpr("ul.duration_ms")
-	orderExpr := latencyHistogramRangeOrderCaseExpr("ul.duration_ms")
-
-	q := `
-SELECT
-  ` + rangeExpr + ` AS range,
-  COALESCE(COUNT(*), 0) AS count,
-  ` + orderExpr + ` AS ord
-FROM usage_logs ul
-` + join + `
-` + where + `
-AND ul.duration_ms IS NOT NULL
-GROUP BY 1, 3
-ORDER BY 3 ASC`
-
-	rows, err := r.db.QueryContext(ctx, q, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	counts := make(map[string]int64, len(latencyHistogramOrderedRanges))
-	var total int64
-	for rows.Next() {
-		var label string
-		var count int64
-		var _ord int
-		if err := rows.Scan(&label, &count, &_ord); err != nil {
-			return nil, err
-		}
-		counts[label] = count
-		total += count
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	buckets := make([]*service.OpsLatencyHistogramBucket, 0, len(latencyHistogramOrderedRanges))
-	for _, label := range latencyHistogramOrderedRanges {
-		buckets = append(buckets, &service.OpsLatencyHistogramBucket{
-			Range: label,
-			Count: counts[label],
-		})
-	}
-
-	return &service.OpsLatencyHistogramResponse{
-		StartTime:     start,
-		EndTime:       end,
-		Platform:      strings.TrimSpace(filter.Platform),
-		GroupID:       filter.GroupID,
-		TotalRequests: total,
-		Buckets:       buckets,
-	}, nil
-}

backend/internal/repository/ops_repo_latency_histogram_buckets.go

@@ -1,64 +0,0 @@
-package repository
-
-import (
-	"fmt"
-	"strings"
-)
-
-type latencyHistogramBucket struct {
-	upperMs int
-	label   string
-}
-
-var latencyHistogramBuckets = []latencyHistogramBucket{
-	{upperMs: 100, label: "0-100ms"},
-	{upperMs: 200, label: "100-200ms"},
-	{upperMs: 500, label: "200-500ms"},
-	{upperMs: 1000, label: "500-1000ms"},
-	{upperMs: 2000, label: "1000-2000ms"},
-	{upperMs: 0, label: "2000ms+"}, // default bucket
-}
-
-var latencyHistogramOrderedRanges = func() []string {
-	out := make([]string, 0, len(latencyHistogramBuckets))
-	for _, b := range latencyHistogramBuckets {
-		out = append(out, b.label)
-	}
-	return out
-}()
-
-func latencyHistogramRangeCaseExpr(column string) string {
-	var sb strings.Builder
-	_, _ = sb.WriteString("CASE\n")
-
-	for _, b := range latencyHistogramBuckets {
-		if b.upperMs <= 0 {
-			continue
-		}
-		_, _ = sb.WriteString(fmt.Sprintf("\tWHEN %s < %d THEN '%s'\n", column, b.upperMs, b.label))
-	}
-
-	// Default bucket.
-	last := latencyHistogramBuckets[len(latencyHistogramBuckets)-1]
-	_, _ = sb.WriteString(fmt.Sprintf("\tELSE '%s'\n", last.label))
-	_, _ = sb.WriteString("END")
-	return sb.String()
-}
-
-func latencyHistogramRangeOrderCaseExpr(column string) string {
-	var sb strings.Builder
-	_, _ = sb.WriteString("CASE\n")
-
-	order := 1
-	for _, b := range latencyHistogramBuckets {
-		if b.upperMs <= 0 {
-			continue
-		}
-		_, _ = sb.WriteString(fmt.Sprintf("\tWHEN %s < %d THEN %d\n", column, b.upperMs, order))
-		order++
-	}
-
-	_, _ = sb.WriteString(fmt.Sprintf("\tELSE %d\n", order))
-	_, _ = sb.WriteString("END")
-	return sb.String()
-}

backend/internal/repository/ops_repo_latency_histogram_buckets_test.go

@@ -1,14 +0,0 @@
-package repository
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestLatencyHistogramBuckets_AreConsistent(t *testing.T) {
-	require.Equal(t, len(latencyHistogramBuckets), len(latencyHistogramOrderedRanges))
-	for i, b := range latencyHistogramBuckets {
-		require.Equal(t, b.label, latencyHistogramOrderedRanges[i])
-	}
-}

backend/internal/repository/ops_repo_metrics.go

@@ -1,422 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) InsertSystemMetrics(ctx context.Context, input *service.OpsInsertSystemMetricsInput) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if input == nil {
-		return fmt.Errorf("nil input")
-	}
-
-	window := input.WindowMinutes
-	if window <= 0 {
-		window = 1
-	}
-	createdAt := input.CreatedAt
-	if createdAt.IsZero() {
-		createdAt = time.Now().UTC()
-	}
-
-	q := `
-INSERT INTO ops_system_metrics (
-  created_at,
-  window_minutes,
-  platform,
-  group_id,
-
-  success_count,
-  error_count_total,
-  business_limited_count,
-  error_count_sla,
-
-  upstream_error_count_excl_429_529,
-  upstream_429_count,
-  upstream_529_count,
-
-  token_consumed,
-  qps,
-  tps,
-
-  duration_p50_ms,
-  duration_p90_ms,
-  duration_p95_ms,
-  duration_p99_ms,
-  duration_avg_ms,
-  duration_max_ms,
-
-  ttft_p50_ms,
-  ttft_p90_ms,
-  ttft_p95_ms,
-  ttft_p99_ms,
-  ttft_avg_ms,
-  ttft_max_ms,
-
-  cpu_usage_percent,
-  memory_used_mb,
-  memory_total_mb,
-  memory_usage_percent,
-
-  db_ok,
-  redis_ok,
-
-  redis_conn_total,
-  redis_conn_idle,
-
-  db_conn_active,
-  db_conn_idle,
-  db_conn_waiting,
-
-  goroutine_count,
-  concurrency_queue_depth
-) VALUES (
-  $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
-)`
-
-	_, err := r.db.ExecContext(
-		ctx,
-		q,
-		createdAt,
-		window,
-		opsNullString(input.Platform),
-		opsNullInt64(input.GroupID),
-
-		input.SuccessCount,
-		input.ErrorCountTotal,
-		input.BusinessLimitedCount,
-		input.ErrorCountSLA,
-
-		input.UpstreamErrorCountExcl429529,
-		input.Upstream429Count,
-		input.Upstream529Count,
-
-		input.TokenConsumed,
-		opsNullFloat64(input.QPS),
-		opsNullFloat64(input.TPS),
-
-		opsNullInt(input.DurationP50Ms),
-		opsNullInt(input.DurationP90Ms),
-		opsNullInt(input.DurationP95Ms),
-		opsNullInt(input.DurationP99Ms),
-		opsNullFloat64(input.DurationAvgMs),
-		opsNullInt(input.DurationMaxMs),
-
-		opsNullInt(input.TTFTP50Ms),
-		opsNullInt(input.TTFTP90Ms),
-		opsNullInt(input.TTFTP95Ms),
-		opsNullInt(input.TTFTP99Ms),
-		opsNullFloat64(input.TTFTAvgMs),
-		opsNullInt(input.TTFTMaxMs),
-
-		opsNullFloat64(input.CPUUsagePercent),
-		opsNullInt(input.MemoryUsedMB),
-		opsNullInt(input.MemoryTotalMB),
-		opsNullFloat64(input.MemoryUsagePercent),
-
-		opsNullBool(input.DBOK),
-		opsNullBool(input.RedisOK),
-
-		opsNullInt(input.RedisConnTotal),
-		opsNullInt(input.RedisConnIdle),
-
-		opsNullInt(input.DBConnActive),
-		opsNullInt(input.DBConnIdle),
-		opsNullInt(input.DBConnWaiting),
-
-		opsNullInt(input.GoroutineCount),
-		opsNullInt(input.ConcurrencyQueueDepth),
-	)
-	return err
-}
-
-func (r *opsRepository) GetLatestSystemMetrics(ctx context.Context, windowMinutes int) (*service.OpsSystemMetricsSnapshot, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if windowMinutes <= 0 {
-		windowMinutes = 1
-	}
-
-	q := `
-SELECT
-  id,
-  created_at,
-  window_minutes,
-
-  cpu_usage_percent,
-  memory_used_mb,
-  memory_total_mb,
-  memory_usage_percent,
-
-  db_ok,
-  redis_ok,
-
-  redis_conn_total,
-  redis_conn_idle,
-
-  db_conn_active,
-  db_conn_idle,
-  db_conn_waiting,
-
-  goroutine_count,
-  concurrency_queue_depth
-FROM ops_system_metrics
-WHERE window_minutes = $1
-  AND platform IS NULL
-  AND group_id IS NULL
-ORDER BY created_at DESC
-LIMIT 1`
-
-	var out service.OpsSystemMetricsSnapshot
-	var cpu sql.NullFloat64
-	var memUsed sql.NullInt64
-	var memTotal sql.NullInt64
-	var memPct sql.NullFloat64
-	var dbOK sql.NullBool
-	var redisOK sql.NullBool
-	var redisTotal sql.NullInt64
-	var redisIdle sql.NullInt64
-	var dbActive sql.NullInt64
-	var dbIdle sql.NullInt64
-	var dbWaiting sql.NullInt64
-	var goroutines sql.NullInt64
-	var queueDepth sql.NullInt64
-
-	if err := r.db.QueryRowContext(ctx, q, windowMinutes).Scan(
-		&out.ID,
-		&out.CreatedAt,
-		&out.WindowMinutes,
-		&cpu,
-		&memUsed,
-		&memTotal,
-		&memPct,
-		&dbOK,
-		&redisOK,
-		&redisTotal,
-		&redisIdle,
-		&dbActive,
-		&dbIdle,
-		&dbWaiting,
-		&goroutines,
-		&queueDepth,
-	); err != nil {
-		return nil, err
-	}
-
-	if cpu.Valid {
-		v := cpu.Float64
-		out.CPUUsagePercent = &v
-	}
-	if memUsed.Valid {
-		v := memUsed.Int64
-		out.MemoryUsedMB = &v
-	}
-	if memTotal.Valid {
-		v := memTotal.Int64
-		out.MemoryTotalMB = &v
-	}
-	if memPct.Valid {
-		v := memPct.Float64
-		out.MemoryUsagePercent = &v
-	}
-	if dbOK.Valid {
-		v := dbOK.Bool
-		out.DBOK = &v
-	}
-	if redisOK.Valid {
-		v := redisOK.Bool
-		out.RedisOK = &v
-	}
-	if redisTotal.Valid {
-		v := int(redisTotal.Int64)
-		out.RedisConnTotal = &v
-	}
-	if redisIdle.Valid {
-		v := int(redisIdle.Int64)
-		out.RedisConnIdle = &v
-	}
-	if dbActive.Valid {
-		v := int(dbActive.Int64)
-		out.DBConnActive = &v
-	}
-	if dbIdle.Valid {
-		v := int(dbIdle.Int64)
-		out.DBConnIdle = &v
-	}
-	if dbWaiting.Valid {
-		v := int(dbWaiting.Int64)
-		out.DBConnWaiting = &v
-	}
-	if goroutines.Valid {
-		v := int(goroutines.Int64)
-		out.GoroutineCount = &v
-	}
-	if queueDepth.Valid {
-		v := int(queueDepth.Int64)
-		out.ConcurrencyQueueDepth = &v
-	}
-
-	return &out, nil
-}
-
-func (r *opsRepository) UpsertJobHeartbeat(ctx context.Context, input *service.OpsUpsertJobHeartbeatInput) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if input == nil {
-		return fmt.Errorf("nil input")
-	}
-	if input.JobName == "" {
-		return fmt.Errorf("job_name required")
-	}
-
-	q := `
-INSERT INTO ops_job_heartbeats (
-  job_name,
-  last_run_at,
-  last_success_at,
-  last_error_at,
-  last_error,
-  last_duration_ms,
-  updated_at
-) VALUES (
-  $1,$2,$3,$4,$5,$6,NOW()
-)
-ON CONFLICT (job_name) DO UPDATE SET
-  last_run_at = COALESCE(EXCLUDED.last_run_at, ops_job_heartbeats.last_run_at),
-  last_success_at = COALESCE(EXCLUDED.last_success_at, ops_job_heartbeats.last_success_at),
-  last_error_at = CASE
-    WHEN EXCLUDED.last_success_at IS NOT NULL THEN NULL
-    ELSE COALESCE(EXCLUDED.last_error_at, ops_job_heartbeats.last_error_at)
-  END,
-  last_error = CASE
-    WHEN EXCLUDED.last_success_at IS NOT NULL THEN NULL
-    ELSE COALESCE(EXCLUDED.last_error, ops_job_heartbeats.last_error)
-  END,
-  last_duration_ms = COALESCE(EXCLUDED.last_duration_ms, ops_job_heartbeats.last_duration_ms),
-  updated_at = NOW()`
-
-	_, err := r.db.ExecContext(
-		ctx,
-		q,
-		input.JobName,
-		opsNullTime(input.LastRunAt),
-		opsNullTime(input.LastSuccessAt),
-		opsNullTime(input.LastErrorAt),
-		opsNullString(input.LastError),
-		opsNullInt(input.LastDurationMs),
-	)
-	return err
-}
-
-func (r *opsRepository) ListJobHeartbeats(ctx context.Context) ([]*service.OpsJobHeartbeat, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-
-	q := `
-SELECT
-  job_name,
-  last_run_at,
-  last_success_at,
-  last_error_at,
-  last_error,
-  last_duration_ms,
-  updated_at
-FROM ops_job_heartbeats
-ORDER BY job_name ASC`
-
-	rows, err := r.db.QueryContext(ctx, q)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	out := make([]*service.OpsJobHeartbeat, 0, 8)
-	for rows.Next() {
-		var item service.OpsJobHeartbeat
-		var lastRun sql.NullTime
-		var lastSuccess sql.NullTime
-		var lastErrorAt sql.NullTime
-		var lastError sql.NullString
-		var lastDuration sql.NullInt64
-
-		if err := rows.Scan(
-			&item.JobName,
-			&lastRun,
-			&lastSuccess,
-			&lastErrorAt,
-			&lastError,
-			&lastDuration,
-			&item.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-
-		if lastRun.Valid {
-			v := lastRun.Time
-			item.LastRunAt = &v
-		}
-		if lastSuccess.Valid {
-			v := lastSuccess.Time
-			item.LastSuccessAt = &v
-		}
-		if lastErrorAt.Valid {
-			v := lastErrorAt.Time
-			item.LastErrorAt = &v
-		}
-		if lastError.Valid {
-			v := lastError.String
-			item.LastError = &v
-		}
-		if lastDuration.Valid {
-			v := lastDuration.Int64
-			item.LastDurationMs = &v
-		}
-
-		out = append(out, &item)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func opsNullBool(v *bool) any {
-	if v == nil {
-		return sql.NullBool{}
-	}
-	return sql.NullBool{Bool: *v, Valid: true}
-}
-
-func opsNullFloat64(v *float64) any {
-	if v == nil {
-		return sql.NullFloat64{}
-	}
-	return sql.NullFloat64{Float64: *v, Valid: true}
-}
-
-func opsNullTime(v *time.Time) any {
-	if v == nil || v.IsZero() {
-		return sql.NullTime{}
-	}
-	return sql.NullTime{Time: *v, Valid: true}
-}

backend/internal/repository/ops_repo_preagg.go

@@ -1,363 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"time"
-)
-
-func (r *opsRepository) UpsertHourlyMetrics(ctx context.Context, startTime, endTime time.Time) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if startTime.IsZero() || endTime.IsZero() || !endTime.After(startTime) {
-		return nil
-	}
-
-	start := startTime.UTC()
-	end := endTime.UTC()
-
-	// NOTE:
-	// - We aggregate usage_logs + ops_error_logs into ops_metrics_hourly.
-	// - We emit three dimension granularities via GROUPING SETS:
-	//   1) overall: (bucket_start)
-	//   2) platform: (bucket_start, platform)
-	//   3) group: (bucket_start, platform, group_id)
-	//
-	// IMPORTANT: Postgres UNIQUE treats NULLs as distinct, so the table uses a COALESCE-based
-	// unique index; our ON CONFLICT target must match that expression set.
-	q := `
-WITH usage_base AS (
-  SELECT
-    date_trunc('hour', ul.created_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC' AS bucket_start,
-    g.platform AS platform,
-    ul.group_id AS group_id,
-    ul.duration_ms AS duration_ms,
-    ul.first_token_ms AS first_token_ms,
-    (ul.input_tokens + ul.output_tokens + ul.cache_creation_tokens + ul.cache_read_tokens) AS tokens
-  FROM usage_logs ul
-  JOIN groups g ON g.id = ul.group_id
-  WHERE ul.created_at >= $1 AND ul.created_at < $2
-),
-usage_agg AS (
-  SELECT
-    bucket_start,
-    CASE WHEN GROUPING(platform) = 1 THEN NULL ELSE platform END AS platform,
-    CASE WHEN GROUPING(group_id) = 1 THEN NULL ELSE group_id END AS group_id,
-    COUNT(*) AS success_count,
-    COALESCE(SUM(tokens), 0) AS token_consumed,
-
-    percentile_cont(0.50) WITHIN GROUP (ORDER BY duration_ms) FILTER (WHERE duration_ms IS NOT NULL) AS duration_p50_ms,
-    percentile_cont(0.90) WITHIN GROUP (ORDER BY duration_ms) FILTER (WHERE duration_ms IS NOT NULL) AS duration_p90_ms,
-    percentile_cont(0.95) WITHIN GROUP (ORDER BY duration_ms) FILTER (WHERE duration_ms IS NOT NULL) AS duration_p95_ms,
-    percentile_cont(0.99) WITHIN GROUP (ORDER BY duration_ms) FILTER (WHERE duration_ms IS NOT NULL) AS duration_p99_ms,
-    AVG(duration_ms) FILTER (WHERE duration_ms IS NOT NULL) AS duration_avg_ms,
-    MAX(duration_ms) AS duration_max_ms,
-
-    percentile_cont(0.50) WITHIN GROUP (ORDER BY first_token_ms) FILTER (WHERE first_token_ms IS NOT NULL) AS ttft_p50_ms,
-    percentile_cont(0.90) WITHIN GROUP (ORDER BY first_token_ms) FILTER (WHERE first_token_ms IS NOT NULL) AS ttft_p90_ms,
-    percentile_cont(0.95) WITHIN GROUP (ORDER BY first_token_ms) FILTER (WHERE first_token_ms IS NOT NULL) AS ttft_p95_ms,
-    percentile_cont(0.99) WITHIN GROUP (ORDER BY first_token_ms) FILTER (WHERE first_token_ms IS NOT NULL) AS ttft_p99_ms,
-    AVG(first_token_ms) FILTER (WHERE first_token_ms IS NOT NULL) AS ttft_avg_ms,
-    MAX(first_token_ms) AS ttft_max_ms
-  FROM usage_base
-  GROUP BY GROUPING SETS (
-    (bucket_start),
-    (bucket_start, platform),
-    (bucket_start, platform, group_id)
-  )
-),
-error_base AS (
-  SELECT
-    date_trunc('hour', created_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC' AS bucket_start,
-    -- platform is NULL for some early-phase errors (e.g. before routing); map to a sentinel
-    -- value so platform-level GROUPING SETS don't collide with the overall (platform=NULL) row.
-    COALESCE(platform, 'unknown') AS platform,
-    group_id AS group_id,
-    is_business_limited AS is_business_limited,
-    error_owner AS error_owner,
-    status_code AS client_status_code,
-    COALESCE(upstream_status_code, status_code, 0) AS effective_status_code
-  FROM ops_error_logs
-  -- Exclude count_tokens requests from error metrics as they are informational probes
-  WHERE created_at >= $1 AND created_at < $2
-    AND is_count_tokens = FALSE
-),
-error_agg AS (
-  SELECT
-    bucket_start,
-    CASE WHEN GROUPING(platform) = 1 THEN NULL ELSE platform END AS platform,
-    CASE WHEN GROUPING(group_id) = 1 THEN NULL ELSE group_id END AS group_id,
-    COUNT(*) FILTER (WHERE COALESCE(client_status_code, 0) >= 400) AS error_count_total,
-    COUNT(*) FILTER (WHERE COALESCE(client_status_code, 0) >= 400 AND is_business_limited) AS business_limited_count,
-    COUNT(*) FILTER (WHERE COALESCE(client_status_code, 0) >= 400 AND NOT is_business_limited) AS error_count_sla,
-    COUNT(*) FILTER (WHERE error_owner = 'provider' AND NOT is_business_limited AND COALESCE(effective_status_code, 0) NOT IN (429, 529)) AS upstream_error_count_excl_429_529,
-    COUNT(*) FILTER (WHERE error_owner = 'provider' AND NOT is_business_limited AND COALESCE(effective_status_code, 0) = 429) AS upstream_429_count,
-    COUNT(*) FILTER (WHERE error_owner = 'provider' AND NOT is_business_limited AND COALESCE(effective_status_code, 0) = 529) AS upstream_529_count
-  FROM error_base
-  GROUP BY GROUPING SETS (
-    (bucket_start),
-    (bucket_start, platform),
-    (bucket_start, platform, group_id)
-  )
-  HAVING GROUPING(group_id) = 1 OR group_id IS NOT NULL
-),
-combined AS (
-  SELECT
-    COALESCE(u.bucket_start, e.bucket_start) AS bucket_start,
-    COALESCE(u.platform, e.platform) AS platform,
-    COALESCE(u.group_id, e.group_id) AS group_id,
-
-    COALESCE(u.success_count, 0) AS success_count,
-    COALESCE(e.error_count_total, 0) AS error_count_total,
-    COALESCE(e.business_limited_count, 0) AS business_limited_count,
-    COALESCE(e.error_count_sla, 0) AS error_count_sla,
-    COALESCE(e.upstream_error_count_excl_429_529, 0) AS upstream_error_count_excl_429_529,
-    COALESCE(e.upstream_429_count, 0) AS upstream_429_count,
-    COALESCE(e.upstream_529_count, 0) AS upstream_529_count,
-
-    COALESCE(u.token_consumed, 0) AS token_consumed,
-
-    u.duration_p50_ms,
-    u.duration_p90_ms,
-    u.duration_p95_ms,
-    u.duration_p99_ms,
-    u.duration_avg_ms,
-    u.duration_max_ms,
-
-    u.ttft_p50_ms,
-    u.ttft_p90_ms,
-    u.ttft_p95_ms,
-    u.ttft_p99_ms,
-    u.ttft_avg_ms,
-    u.ttft_max_ms
-  FROM usage_agg u
-  FULL OUTER JOIN error_agg e
-    ON u.bucket_start = e.bucket_start
-   AND COALESCE(u.platform, '') = COALESCE(e.platform, '')
-   AND COALESCE(u.group_id, 0) = COALESCE(e.group_id, 0)
-)
-INSERT INTO ops_metrics_hourly (
-  bucket_start,
-  platform,
-  group_id,
-  success_count,
-  error_count_total,
-  business_limited_count,
-  error_count_sla,
-  upstream_error_count_excl_429_529,
-  upstream_429_count,
-  upstream_529_count,
-  token_consumed,
-  duration_p50_ms,
-  duration_p90_ms,
-  duration_p95_ms,
-  duration_p99_ms,
-  duration_avg_ms,
-  duration_max_ms,
-  ttft_p50_ms,
-  ttft_p90_ms,
-  ttft_p95_ms,
-  ttft_p99_ms,
-  ttft_avg_ms,
-  ttft_max_ms,
-  computed_at
-)
-SELECT
-  bucket_start,
-  NULLIF(platform, '') AS platform,
-  group_id,
-  success_count,
-  error_count_total,
-  business_limited_count,
-  error_count_sla,
-  upstream_error_count_excl_429_529,
-  upstream_429_count,
-  upstream_529_count,
-  token_consumed,
-  duration_p50_ms::int,
-  duration_p90_ms::int,
-  duration_p95_ms::int,
-  duration_p99_ms::int,
-  duration_avg_ms,
-  duration_max_ms::int,
-  ttft_p50_ms::int,
-  ttft_p90_ms::int,
-  ttft_p95_ms::int,
-  ttft_p99_ms::int,
-  ttft_avg_ms,
-  ttft_max_ms::int,
-  NOW()
-FROM combined
-WHERE bucket_start IS NOT NULL
-  AND (platform IS NULL OR platform <> '')
-ON CONFLICT (bucket_start, COALESCE(platform, ''), COALESCE(group_id, 0)) DO UPDATE SET
-  success_count = EXCLUDED.success_count,
-  error_count_total = EXCLUDED.error_count_total,
-  business_limited_count = EXCLUDED.business_limited_count,
-  error_count_sla = EXCLUDED.error_count_sla,
-  upstream_error_count_excl_429_529 = EXCLUDED.upstream_error_count_excl_429_529,
-  upstream_429_count = EXCLUDED.upstream_429_count,
-  upstream_529_count = EXCLUDED.upstream_529_count,
-  token_consumed = EXCLUDED.token_consumed,
-
-  duration_p50_ms = EXCLUDED.duration_p50_ms,
-  duration_p90_ms = EXCLUDED.duration_p90_ms,
-  duration_p95_ms = EXCLUDED.duration_p95_ms,
-  duration_p99_ms = EXCLUDED.duration_p99_ms,
-  duration_avg_ms = EXCLUDED.duration_avg_ms,
-  duration_max_ms = EXCLUDED.duration_max_ms,
-
-  ttft_p50_ms = EXCLUDED.ttft_p50_ms,
-  ttft_p90_ms = EXCLUDED.ttft_p90_ms,
-  ttft_p95_ms = EXCLUDED.ttft_p95_ms,
-  ttft_p99_ms = EXCLUDED.ttft_p99_ms,
-  ttft_avg_ms = EXCLUDED.ttft_avg_ms,
-  ttft_max_ms = EXCLUDED.ttft_max_ms,
-
-  computed_at = NOW()
-`
-
-	_, err := r.db.ExecContext(ctx, q, start, end)
-	return err
-}
-
-func (r *opsRepository) UpsertDailyMetrics(ctx context.Context, startTime, endTime time.Time) error {
-	if r == nil || r.db == nil {
-		return fmt.Errorf("nil ops repository")
-	}
-	if startTime.IsZero() || endTime.IsZero() || !endTime.After(startTime) {
-		return nil
-	}
-
-	start := startTime.UTC()
-	end := endTime.UTC()
-
-	q := `
-INSERT INTO ops_metrics_daily (
-  bucket_date,
-  platform,
-  group_id,
-  success_count,
-  error_count_total,
-  business_limited_count,
-  error_count_sla,
-  upstream_error_count_excl_429_529,
-  upstream_429_count,
-  upstream_529_count,
-  token_consumed,
-  duration_p50_ms,
-  duration_p90_ms,
-  duration_p95_ms,
-  duration_p99_ms,
-  duration_avg_ms,
-  duration_max_ms,
-  ttft_p50_ms,
-  ttft_p90_ms,
-  ttft_p95_ms,
-  ttft_p99_ms,
-  ttft_avg_ms,
-  ttft_max_ms,
-  computed_at
-)
-SELECT
-  (bucket_start AT TIME ZONE 'UTC')::date AS bucket_date,
-  platform,
-  group_id,
-
-  COALESCE(SUM(success_count), 0) AS success_count,
-  COALESCE(SUM(error_count_total), 0) AS error_count_total,
-  COALESCE(SUM(business_limited_count), 0) AS business_limited_count,
-  COALESCE(SUM(error_count_sla), 0) AS error_count_sla,
-  COALESCE(SUM(upstream_error_count_excl_429_529), 0) AS upstream_error_count_excl_429_529,
-  COALESCE(SUM(upstream_429_count), 0) AS upstream_429_count,
-  COALESCE(SUM(upstream_529_count), 0) AS upstream_529_count,
-  COALESCE(SUM(token_consumed), 0) AS token_consumed,
-
-  -- Approximation: weighted average for p50/p90, max for p95/p99 (conservative tail).
-  ROUND(SUM(duration_p50_ms::double precision * success_count) FILTER (WHERE duration_p50_ms IS NOT NULL)
-    / NULLIF(SUM(success_count) FILTER (WHERE duration_p50_ms IS NOT NULL), 0))::int AS duration_p50_ms,
-  ROUND(SUM(duration_p90_ms::double precision * success_count) FILTER (WHERE duration_p90_ms IS NOT NULL)
-    / NULLIF(SUM(success_count) FILTER (WHERE duration_p90_ms IS NOT NULL), 0))::int AS duration_p90_ms,
-  MAX(duration_p95_ms) AS duration_p95_ms,
-  MAX(duration_p99_ms) AS duration_p99_ms,
-  SUM(duration_avg_ms * success_count) FILTER (WHERE duration_avg_ms IS NOT NULL)
-    / NULLIF(SUM(success_count) FILTER (WHERE duration_avg_ms IS NOT NULL), 0) AS duration_avg_ms,
-  MAX(duration_max_ms) AS duration_max_ms,
-
-  ROUND(SUM(ttft_p50_ms::double precision * success_count) FILTER (WHERE ttft_p50_ms IS NOT NULL)
-    / NULLIF(SUM(success_count) FILTER (WHERE ttft_p50_ms IS NOT NULL), 0))::int AS ttft_p50_ms,
-  ROUND(SUM(ttft_p90_ms::double precision * success_count) FILTER (WHERE ttft_p90_ms IS NOT NULL)
-    / NULLIF(SUM(success_count) FILTER (WHERE ttft_p90_ms IS NOT NULL), 0))::int AS ttft_p90_ms,
-  MAX(ttft_p95_ms) AS ttft_p95_ms,
-  MAX(ttft_p99_ms) AS ttft_p99_ms,
-  SUM(ttft_avg_ms * success_count) FILTER (WHERE ttft_avg_ms IS NOT NULL)
-    / NULLIF(SUM(success_count) FILTER (WHERE ttft_avg_ms IS NOT NULL), 0) AS ttft_avg_ms,
-  MAX(ttft_max_ms) AS ttft_max_ms,
-
-  NOW()
-FROM ops_metrics_hourly
-WHERE bucket_start >= $1 AND bucket_start < $2
-GROUP BY 1, 2, 3
-ON CONFLICT (bucket_date, COALESCE(platform, ''), COALESCE(group_id, 0)) DO UPDATE SET
-  success_count = EXCLUDED.success_count,
-  error_count_total = EXCLUDED.error_count_total,
-  business_limited_count = EXCLUDED.business_limited_count,
-  error_count_sla = EXCLUDED.error_count_sla,
-  upstream_error_count_excl_429_529 = EXCLUDED.upstream_error_count_excl_429_529,
-  upstream_429_count = EXCLUDED.upstream_429_count,
-  upstream_529_count = EXCLUDED.upstream_529_count,
-  token_consumed = EXCLUDED.token_consumed,
-
-  duration_p50_ms = EXCLUDED.duration_p50_ms,
-  duration_p90_ms = EXCLUDED.duration_p90_ms,
-  duration_p95_ms = EXCLUDED.duration_p95_ms,
-  duration_p99_ms = EXCLUDED.duration_p99_ms,
-  duration_avg_ms = EXCLUDED.duration_avg_ms,
-  duration_max_ms = EXCLUDED.duration_max_ms,
-
-  ttft_p50_ms = EXCLUDED.ttft_p50_ms,
-  ttft_p90_ms = EXCLUDED.ttft_p90_ms,
-  ttft_p95_ms = EXCLUDED.ttft_p95_ms,
-  ttft_p99_ms = EXCLUDED.ttft_p99_ms,
-  ttft_avg_ms = EXCLUDED.ttft_avg_ms,
-  ttft_max_ms = EXCLUDED.ttft_max_ms,
-
-  computed_at = NOW()
-`
-
-	_, err := r.db.ExecContext(ctx, q, start, end)
-	return err
-}
-
-func (r *opsRepository) GetLatestHourlyBucketStart(ctx context.Context) (time.Time, bool, error) {
-	if r == nil || r.db == nil {
-		return time.Time{}, false, fmt.Errorf("nil ops repository")
-	}
-
-	var value sql.NullTime
-	if err := r.db.QueryRowContext(ctx, `SELECT MAX(bucket_start) FROM ops_metrics_hourly`).Scan(&value); err != nil {
-		return time.Time{}, false, err
-	}
-	if !value.Valid {
-		return time.Time{}, false, nil
-	}
-	return value.Time.UTC(), true, nil
-}
-
-func (r *opsRepository) GetLatestDailyBucketDate(ctx context.Context) (time.Time, bool, error) {
-	if r == nil || r.db == nil {
-		return time.Time{}, false, fmt.Errorf("nil ops repository")
-	}
-
-	var value sql.NullTime
-	if err := r.db.QueryRowContext(ctx, `SELECT MAX(bucket_date) FROM ops_metrics_daily`).Scan(&value); err != nil {
-		return time.Time{}, false, err
-	}
-	if !value.Valid {
-		return time.Time{}, false, nil
-	}
-	t := value.Time.UTC()
-	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC), true, nil
-}

backend/internal/repository/ops_repo_realtime_traffic.go

@@ -1,129 +0,0 @@
-package repository
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) GetRealtimeTrafficSummary(ctx context.Context, filter *service.OpsDashboardFilter) (*service.OpsRealtimeTrafficSummary, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		return nil, fmt.Errorf("nil filter")
-	}
-	if filter.StartTime.IsZero() || filter.EndTime.IsZero() {
-		return nil, fmt.Errorf("start_time/end_time required")
-	}
-
-	start := filter.StartTime.UTC()
-	end := filter.EndTime.UTC()
-	if start.After(end) {
-		return nil, fmt.Errorf("start_time must be <= end_time")
-	}
-
-	window := end.Sub(start)
-	if window <= 0 {
-		return nil, fmt.Errorf("invalid time window")
-	}
-	if window > time.Hour {
-		return nil, fmt.Errorf("window too large")
-	}
-
-	usageJoin, usageWhere, usageArgs, next := buildUsageWhere(filter, start, end, 1)
-	errorWhere, errorArgs, _ := buildErrorWhere(filter, start, end, next)
-
-	q := `
-WITH usage_buckets AS (
-  SELECT
-    date_trunc('minute', ul.created_at) AS bucket,
-    COALESCE(COUNT(*), 0) AS success_count,
-    COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) AS token_sum
-  FROM usage_logs ul
-  ` + usageJoin + `
-  ` + usageWhere + `
-  GROUP BY 1
-),
-error_buckets AS (
-  SELECT
-    date_trunc('minute', created_at) AS bucket,
-    COALESCE(COUNT(*), 0) AS error_count
-  FROM ops_error_logs
-  ` + errorWhere + `
-    AND COALESCE(status_code, 0) >= 400
-  GROUP BY 1
-),
-combined AS (
-  SELECT
-    COALESCE(u.bucket, e.bucket) AS bucket,
-    COALESCE(u.success_count, 0) AS success_count,
-    COALESCE(u.token_sum, 0) AS token_sum,
-    COALESCE(e.error_count, 0) AS error_count,
-    COALESCE(u.success_count, 0) + COALESCE(e.error_count, 0) AS request_total
-  FROM usage_buckets u
-  FULL OUTER JOIN error_buckets e ON u.bucket = e.bucket
-)
-SELECT
-  COALESCE(SUM(success_count), 0) AS success_total,
-  COALESCE(SUM(error_count), 0) AS error_total,
-  COALESCE(SUM(token_sum), 0) AS token_total,
-  COALESCE(MAX(request_total), 0) AS peak_requests_per_min,
-  COALESCE(MAX(token_sum), 0) AS peak_tokens_per_min
-FROM combined`
-
-	args := append(usageArgs, errorArgs...)
-	var successCount int64
-	var errorTotal int64
-	var tokenConsumed int64
-	var peakRequestsPerMin int64
-	var peakTokensPerMin int64
-	if err := r.db.QueryRowContext(ctx, q, args...).Scan(
-		&successCount,
-		&errorTotal,
-		&tokenConsumed,
-		&peakRequestsPerMin,
-		&peakTokensPerMin,
-	); err != nil {
-		return nil, err
-	}
-
-	windowSeconds := window.Seconds()
-	if windowSeconds <= 0 {
-		windowSeconds = 1
-	}
-
-	requestCountTotal := successCount + errorTotal
-	qpsAvg := roundTo1DP(float64(requestCountTotal) / windowSeconds)
-	tpsAvg := roundTo1DP(float64(tokenConsumed) / windowSeconds)
-
-	// Keep "current" consistent with the dashboard overview semantics: last 1 minute.
-	// This remains "within the selected window" since end=start+window.
-	qpsCurrent, tpsCurrent, err := r.queryCurrentRates(ctx, filter, end)
-	if err != nil {
-		return nil, err
-	}
-
-	qpsPeak := roundTo1DP(float64(peakRequestsPerMin) / 60.0)
-	tpsPeak := roundTo1DP(float64(peakTokensPerMin) / 60.0)
-
-	return &service.OpsRealtimeTrafficSummary{
-		StartTime: start,
-		EndTime:   end,
-		Platform:  strings.TrimSpace(filter.Platform),
-		GroupID:   filter.GroupID,
-		QPS: service.OpsRateSummary{
-			Current: qpsCurrent,
-			Peak:    qpsPeak,
-			Avg:     qpsAvg,
-		},
-		TPS: service.OpsRateSummary{
-			Current: tpsCurrent,
-			Peak:    tpsPeak,
-			Avg:     tpsAvg,
-		},
-	}, nil
-}

backend/internal/repository/ops_repo_request_details.go

@@ -1,286 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) ListRequestDetails(ctx context.Context, filter *service.OpsRequestDetailFilter) ([]*service.OpsRequestDetail, int64, error) {
-	if r == nil || r.db == nil {
-		return nil, 0, fmt.Errorf("nil ops repository")
-	}
-
-	page, pageSize, startTime, endTime := filter.Normalize()
-	offset := (page - 1) * pageSize
-
-	conditions := make([]string, 0, 16)
-	args := make([]any, 0, 24)
-
-	// Placeholders $1/$2 reserved for time window inside the CTE.
-	args = append(args, startTime.UTC(), endTime.UTC())
-
-	addCondition := func(condition string, values ...any) {
-		conditions = append(conditions, condition)
-		args = append(args, values...)
-	}
-
-	if filter != nil {
-		if kind := strings.TrimSpace(strings.ToLower(filter.Kind)); kind != "" && kind != "all" {
-			if kind != string(service.OpsRequestKindSuccess) && kind != string(service.OpsRequestKindError) {
-				return nil, 0, fmt.Errorf("invalid kind")
-			}
-			addCondition(fmt.Sprintf("kind = $%d", len(args)+1), kind)
-		}
-
-		if platform := strings.TrimSpace(strings.ToLower(filter.Platform)); platform != "" {
-			addCondition(fmt.Sprintf("platform = $%d", len(args)+1), platform)
-		}
-		if filter.GroupID != nil && *filter.GroupID > 0 {
-			addCondition(fmt.Sprintf("group_id = $%d", len(args)+1), *filter.GroupID)
-		}
-
-		if filter.UserID != nil && *filter.UserID > 0 {
-			addCondition(fmt.Sprintf("user_id = $%d", len(args)+1), *filter.UserID)
-		}
-		if filter.APIKeyID != nil && *filter.APIKeyID > 0 {
-			addCondition(fmt.Sprintf("api_key_id = $%d", len(args)+1), *filter.APIKeyID)
-		}
-		if filter.AccountID != nil && *filter.AccountID > 0 {
-			addCondition(fmt.Sprintf("account_id = $%d", len(args)+1), *filter.AccountID)
-		}
-
-		if model := strings.TrimSpace(filter.Model); model != "" {
-			addCondition(fmt.Sprintf("model = $%d", len(args)+1), model)
-		}
-		if requestID := strings.TrimSpace(filter.RequestID); requestID != "" {
-			addCondition(fmt.Sprintf("request_id = $%d", len(args)+1), requestID)
-		}
-		if q := strings.TrimSpace(filter.Query); q != "" {
-			like := "%" + strings.ToLower(q) + "%"
-			startIdx := len(args) + 1
-			addCondition(
-				fmt.Sprintf("(LOWER(COALESCE(request_id,'')) LIKE $%d OR LOWER(COALESCE(model,'')) LIKE $%d OR LOWER(COALESCE(message,'')) LIKE $%d)",
-					startIdx, startIdx+1, startIdx+2,
-				),
-				like, like, like,
-			)
-		}
-
-		if filter.MinDurationMs != nil {
-			addCondition(fmt.Sprintf("duration_ms >= $%d", len(args)+1), *filter.MinDurationMs)
-		}
-		if filter.MaxDurationMs != nil {
-			addCondition(fmt.Sprintf("duration_ms <= $%d", len(args)+1), *filter.MaxDurationMs)
-		}
-	}
-
-	where := ""
-	if len(conditions) > 0 {
-		where = "WHERE " + strings.Join(conditions, " AND ")
-	}
-
-	cte := `
-WITH combined AS (
-  SELECT
-    'success'::TEXT AS kind,
-    ul.created_at AS created_at,
-    ul.request_id AS request_id,
-    COALESCE(NULLIF(g.platform, ''), NULLIF(a.platform, ''), '') AS platform,
-    ul.model AS model,
-    ul.duration_ms AS duration_ms,
-    NULL::INT AS status_code,
-    NULL::BIGINT AS error_id,
-    NULL::TEXT AS phase,
-    NULL::TEXT AS severity,
-    NULL::TEXT AS message,
-    ul.user_id AS user_id,
-    ul.api_key_id AS api_key_id,
-    ul.account_id AS account_id,
-    ul.group_id AS group_id,
-    ul.stream AS stream
-  FROM usage_logs ul
-  LEFT JOIN groups g ON g.id = ul.group_id
-  LEFT JOIN accounts a ON a.id = ul.account_id
-  WHERE ul.created_at >= $1 AND ul.created_at < $2
-
-  UNION ALL
-
-  SELECT
-    'error'::TEXT AS kind,
-    o.created_at AS created_at,
-    COALESCE(NULLIF(o.request_id,''), NULLIF(o.client_request_id,''), '') AS request_id,
-    COALESCE(NULLIF(o.platform, ''), NULLIF(g.platform, ''), NULLIF(a.platform, ''), '') AS platform,
-    o.model AS model,
-    o.duration_ms AS duration_ms,
-    o.status_code AS status_code,
-    o.id AS error_id,
-    o.error_phase AS phase,
-    o.severity AS severity,
-    o.error_message AS message,
-    o.user_id AS user_id,
-    o.api_key_id AS api_key_id,
-    o.account_id AS account_id,
-    o.group_id AS group_id,
-    o.stream AS stream
-  FROM ops_error_logs o
-  LEFT JOIN groups g ON g.id = o.group_id
-  LEFT JOIN accounts a ON a.id = o.account_id
-  WHERE o.created_at >= $1 AND o.created_at < $2
-    AND COALESCE(o.status_code, 0) >= 400
-)
-`
-
-	countQuery := fmt.Sprintf(`%s SELECT COUNT(1) FROM combined %s`, cte, where)
-	var total int64
-	if err := r.db.QueryRowContext(ctx, countQuery, args...).Scan(&total); err != nil {
-		if err == sql.ErrNoRows {
-			total = 0
-		} else {
-			return nil, 0, err
-		}
-	}
-
-	sort := "ORDER BY created_at DESC"
-	if filter != nil {
-		switch strings.TrimSpace(strings.ToLower(filter.Sort)) {
-		case "", "created_at_desc":
-			// default
-		case "duration_desc":
-			sort = "ORDER BY duration_ms DESC NULLS LAST, created_at DESC"
-		default:
-			return nil, 0, fmt.Errorf("invalid sort")
-		}
-	}
-
-	listQuery := fmt.Sprintf(`
-%s
-SELECT
-  kind,
-  created_at,
-  request_id,
-  platform,
-  model,
-  duration_ms,
-  status_code,
-  error_id,
-  phase,
-  severity,
-  message,
-  user_id,
-  api_key_id,
-  account_id,
-  group_id,
-  stream
-FROM combined
-%s
-%s
-LIMIT $%d OFFSET $%d
-`, cte, where, sort, len(args)+1, len(args)+2)
-
-	listArgs := append(append([]any{}, args...), pageSize, offset)
-	rows, err := r.db.QueryContext(ctx, listQuery, listArgs...)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	toIntPtr := func(v sql.NullInt64) *int {
-		if !v.Valid {
-			return nil
-		}
-		i := int(v.Int64)
-		return &i
-	}
-	toInt64Ptr := func(v sql.NullInt64) *int64 {
-		if !v.Valid {
-			return nil
-		}
-		i := v.Int64
-		return &i
-	}
-
-	out := make([]*service.OpsRequestDetail, 0, pageSize)
-	for rows.Next() {
-		var (
-			kind      string
-			createdAt time.Time
-			requestID sql.NullString
-			platform  sql.NullString
-			model     sql.NullString
-
-			durationMs sql.NullInt64
-			statusCode sql.NullInt64
-			errorID    sql.NullInt64
-
-			phase    sql.NullString
-			severity sql.NullString
-			message  sql.NullString
-
-			userID    sql.NullInt64
-			apiKeyID  sql.NullInt64
-			accountID sql.NullInt64
-			groupID   sql.NullInt64
-
-			stream bool
-		)
-
-		if err := rows.Scan(
-			&kind,
-			&createdAt,
-			&requestID,
-			&platform,
-			&model,
-			&durationMs,
-			&statusCode,
-			&errorID,
-			&phase,
-			&severity,
-			&message,
-			&userID,
-			&apiKeyID,
-			&accountID,
-			&groupID,
-			&stream,
-		); err != nil {
-			return nil, 0, err
-		}
-
-		item := &service.OpsRequestDetail{
-			Kind:      service.OpsRequestKind(kind),
-			CreatedAt: createdAt,
-			RequestID: strings.TrimSpace(requestID.String),
-			Platform:  strings.TrimSpace(platform.String),
-			Model:     strings.TrimSpace(model.String),
-
-			DurationMs: toIntPtr(durationMs),
-			StatusCode: toIntPtr(statusCode),
-			ErrorID:    toInt64Ptr(errorID),
-			Phase:      phase.String,
-			Severity:   severity.String,
-			Message:    message.String,
-
-			UserID:    toInt64Ptr(userID),
-			APIKeyID:  toInt64Ptr(apiKeyID),
-			AccountID: toInt64Ptr(accountID),
-			GroupID:   toInt64Ptr(groupID),
-
-			Stream: stream,
-		}
-
-		if item.Platform == "" {
-			item.Platform = "unknown"
-		}
-
-		out = append(out, item)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, 0, err
-	}
-
-	return out, total, nil
-}

backend/internal/repository/ops_repo_trends.go

@@ -1,573 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) GetThroughputTrend(ctx context.Context, filter *service.OpsDashboardFilter, bucketSeconds int) (*service.OpsThroughputTrendResponse, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		return nil, fmt.Errorf("nil filter")
-	}
-	if filter.StartTime.IsZero() || filter.EndTime.IsZero() {
-		return nil, fmt.Errorf("start_time/end_time required")
-	}
-
-	if bucketSeconds <= 0 {
-		bucketSeconds = 60
-	}
-	if bucketSeconds != 60 && bucketSeconds != 300 && bucketSeconds != 3600 {
-		// Keep a small, predictable set of supported buckets for now.
-		bucketSeconds = 60
-	}
-
-	start := filter.StartTime.UTC()
-	end := filter.EndTime.UTC()
-
-	usageJoin, usageWhere, usageArgs, next := buildUsageWhere(filter, start, end, 1)
-	errorWhere, errorArgs, _ := buildErrorWhere(filter, start, end, next)
-
-	usageBucketExpr := opsBucketExprForUsage(bucketSeconds)
-	errorBucketExpr := opsBucketExprForError(bucketSeconds)
-
-	q := `
-WITH usage_buckets AS (
-  SELECT ` + usageBucketExpr + ` AS bucket,
-         COUNT(*) AS success_count,
-         COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) AS token_consumed
-  FROM usage_logs ul
-  ` + usageJoin + `
-  ` + usageWhere + `
-  GROUP BY 1
-),
-error_buckets AS (
-  SELECT ` + errorBucketExpr + ` AS bucket,
-         COUNT(*) AS error_count
-  FROM ops_error_logs
-  ` + errorWhere + `
-    AND COALESCE(status_code, 0) >= 400
-  GROUP BY 1
-),
-combined AS (
-  SELECT COALESCE(u.bucket, e.bucket) AS bucket,
-         COALESCE(u.success_count, 0) AS success_count,
-         COALESCE(e.error_count, 0) AS error_count,
-         COALESCE(u.token_consumed, 0) AS token_consumed
-  FROM usage_buckets u
-  FULL OUTER JOIN error_buckets e ON u.bucket = e.bucket
-)
-SELECT
-  bucket,
-  (success_count + error_count) AS request_count,
-  token_consumed
-FROM combined
-ORDER BY bucket ASC`
-
-	args := append(usageArgs, errorArgs...)
-
-	rows, err := r.db.QueryContext(ctx, q, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	points := make([]*service.OpsThroughputTrendPoint, 0, 256)
-	for rows.Next() {
-		var bucket time.Time
-		var requests int64
-		var tokens sql.NullInt64
-		if err := rows.Scan(&bucket, &requests, &tokens); err != nil {
-			return nil, err
-		}
-		tokenConsumed := int64(0)
-		if tokens.Valid {
-			tokenConsumed = tokens.Int64
-		}
-
-		denom := float64(bucketSeconds)
-		if denom <= 0 {
-			denom = 60
-		}
-		qps := roundTo1DP(float64(requests) / denom)
-		tps := roundTo1DP(float64(tokenConsumed) / denom)
-
-		points = append(points, &service.OpsThroughputTrendPoint{
-			BucketStart:   bucket.UTC(),
-			RequestCount:  requests,
-			TokenConsumed: tokenConsumed,
-			QPS:           qps,
-			TPS:           tps,
-		})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	// Fill missing buckets with zeros so charts render continuous timelines.
-	points = fillOpsThroughputBuckets(start, end, bucketSeconds, points)
-
-	var byPlatform []*service.OpsThroughputPlatformBreakdownItem
-	var topGroups []*service.OpsThroughputGroupBreakdownItem
-
-	platform := ""
-	if filter != nil {
-		platform = strings.TrimSpace(strings.ToLower(filter.Platform))
-	}
-	groupID := (*int64)(nil)
-	if filter != nil {
-		groupID = filter.GroupID
-	}
-
-	// Drilldown helpers:
-	// - No platform/group: totals by platform
-	// - Platform selected but no group: top groups in that platform
-	if platform == "" && (groupID == nil || *groupID <= 0) {
-		items, err := r.getThroughputBreakdownByPlatform(ctx, start, end)
-		if err != nil {
-			return nil, err
-		}
-		byPlatform = items
-	} else if platform != "" && (groupID == nil || *groupID <= 0) {
-		items, err := r.getThroughputTopGroupsByPlatform(ctx, start, end, platform, 10)
-		if err != nil {
-			return nil, err
-		}
-		topGroups = items
-	}
-
-	return &service.OpsThroughputTrendResponse{
-		Bucket: opsBucketLabel(bucketSeconds),
-		Points: points,
-
-		ByPlatform: byPlatform,
-		TopGroups:  topGroups,
-	}, nil
-}
-
-func (r *opsRepository) getThroughputBreakdownByPlatform(ctx context.Context, start, end time.Time) ([]*service.OpsThroughputPlatformBreakdownItem, error) {
-	q := `
-WITH usage_totals AS (
-  SELECT COALESCE(NULLIF(g.platform,''), a.platform) AS platform,
-         COUNT(*) AS success_count,
-         COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) AS token_consumed
-  FROM usage_logs ul
-  LEFT JOIN groups g ON g.id = ul.group_id
-  LEFT JOIN accounts a ON a.id = ul.account_id
-  WHERE ul.created_at >= $1 AND ul.created_at < $2
-  GROUP BY 1
-),
-error_totals AS (
-  SELECT platform,
-         COUNT(*) AS error_count
-  FROM ops_error_logs
-  WHERE created_at >= $1 AND created_at < $2
-    AND COALESCE(status_code, 0) >= 400
-    AND is_count_tokens = FALSE  -- 排除 count_tokens 请求的错误
-  GROUP BY 1
-),
-combined AS (
-  SELECT COALESCE(u.platform, e.platform) AS platform,
-         COALESCE(u.success_count, 0) AS success_count,
-         COALESCE(e.error_count, 0) AS error_count,
-         COALESCE(u.token_consumed, 0) AS token_consumed
-  FROM usage_totals u
-  FULL OUTER JOIN error_totals e ON u.platform = e.platform
-)
-SELECT platform, (success_count + error_count) AS request_count, token_consumed
-FROM combined
-WHERE platform IS NOT NULL AND platform <> ''
-ORDER BY request_count DESC`
-
-	rows, err := r.db.QueryContext(ctx, q, start, end)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	items := make([]*service.OpsThroughputPlatformBreakdownItem, 0, 8)
-	for rows.Next() {
-		var platform string
-		var requests int64
-		var tokens sql.NullInt64
-		if err := rows.Scan(&platform, &requests, &tokens); err != nil {
-			return nil, err
-		}
-		tokenConsumed := int64(0)
-		if tokens.Valid {
-			tokenConsumed = tokens.Int64
-		}
-		items = append(items, &service.OpsThroughputPlatformBreakdownItem{
-			Platform:      platform,
-			RequestCount:  requests,
-			TokenConsumed: tokenConsumed,
-		})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-func (r *opsRepository) getThroughputTopGroupsByPlatform(ctx context.Context, start, end time.Time, platform string, limit int) ([]*service.OpsThroughputGroupBreakdownItem, error) {
-	if strings.TrimSpace(platform) == "" {
-		return nil, nil
-	}
-	if limit <= 0 || limit > 100 {
-		limit = 10
-	}
-
-	q := `
-WITH usage_totals AS (
-  SELECT ul.group_id AS group_id,
-         g.name AS group_name,
-         COUNT(*) AS success_count,
-         COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) AS token_consumed
-  FROM usage_logs ul
-  JOIN groups g ON g.id = ul.group_id
-  WHERE ul.created_at >= $1 AND ul.created_at < $2
-    AND g.platform = $3
-  GROUP BY 1, 2
-),
-error_totals AS (
-  SELECT group_id,
-         COUNT(*) AS error_count
-  FROM ops_error_logs
-  WHERE created_at >= $1 AND created_at < $2
-    AND platform = $3
-    AND group_id IS NOT NULL
-    AND COALESCE(status_code, 0) >= 400
-    AND is_count_tokens = FALSE  -- 排除 count_tokens 请求的错误
-  GROUP BY 1
-),
-combined AS (
-  SELECT COALESCE(u.group_id, e.group_id) AS group_id,
-         COALESCE(u.group_name, g2.name, '') AS group_name,
-         COALESCE(u.success_count, 0) AS success_count,
-         COALESCE(e.error_count, 0) AS error_count,
-         COALESCE(u.token_consumed, 0) AS token_consumed
-  FROM usage_totals u
-  FULL OUTER JOIN error_totals e ON u.group_id = e.group_id
-  LEFT JOIN groups g2 ON g2.id = COALESCE(u.group_id, e.group_id)
-)
-SELECT group_id, group_name, (success_count + error_count) AS request_count, token_consumed
-FROM combined
-WHERE group_id IS NOT NULL
-ORDER BY request_count DESC
-LIMIT $4`
-
-	rows, err := r.db.QueryContext(ctx, q, start, end, platform, limit)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	items := make([]*service.OpsThroughputGroupBreakdownItem, 0, limit)
-	for rows.Next() {
-		var groupID int64
-		var groupName sql.NullString
-		var requests int64
-		var tokens sql.NullInt64
-		if err := rows.Scan(&groupID, &groupName, &requests, &tokens); err != nil {
-			return nil, err
-		}
-		tokenConsumed := int64(0)
-		if tokens.Valid {
-			tokenConsumed = tokens.Int64
-		}
-		name := ""
-		if groupName.Valid {
-			name = groupName.String
-		}
-		items = append(items, &service.OpsThroughputGroupBreakdownItem{
-			GroupID:       groupID,
-			GroupName:     name,
-			RequestCount:  requests,
-			TokenConsumed: tokenConsumed,
-		})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-func opsBucketExprForUsage(bucketSeconds int) string {
-	switch bucketSeconds {
-	case 3600:
-		return "date_trunc('hour', ul.created_at)"
-	case 300:
-		// 5-minute buckets in UTC.
-		return "to_timestamp(floor(extract(epoch from ul.created_at) / 300) * 300)"
-	default:
-		return "date_trunc('minute', ul.created_at)"
-	}
-}
-
-func opsBucketExprForError(bucketSeconds int) string {
-	switch bucketSeconds {
-	case 3600:
-		return "date_trunc('hour', created_at)"
-	case 300:
-		return "to_timestamp(floor(extract(epoch from created_at) / 300) * 300)"
-	default:
-		return "date_trunc('minute', created_at)"
-	}
-}
-
-func opsBucketLabel(bucketSeconds int) string {
-	if bucketSeconds <= 0 {
-		return "1m"
-	}
-	if bucketSeconds%3600 == 0 {
-		h := bucketSeconds / 3600
-		if h <= 0 {
-			h = 1
-		}
-		return fmt.Sprintf("%dh", h)
-	}
-	m := bucketSeconds / 60
-	if m <= 0 {
-		m = 1
-	}
-	return fmt.Sprintf("%dm", m)
-}
-
-func opsFloorToBucketStart(t time.Time, bucketSeconds int) time.Time {
-	t = t.UTC()
-	if bucketSeconds <= 0 {
-		bucketSeconds = 60
-	}
-	secs := t.Unix()
-	floored := secs - (secs % int64(bucketSeconds))
-	return time.Unix(floored, 0).UTC()
-}
-
-func fillOpsThroughputBuckets(start, end time.Time, bucketSeconds int, points []*service.OpsThroughputTrendPoint) []*service.OpsThroughputTrendPoint {
-	if bucketSeconds <= 0 {
-		bucketSeconds = 60
-	}
-	if !start.Before(end) {
-		return points
-	}
-
-	endMinus := end.Add(-time.Nanosecond)
-	if endMinus.Before(start) {
-		return points
-	}
-
-	first := opsFloorToBucketStart(start, bucketSeconds)
-	last := opsFloorToBucketStart(endMinus, bucketSeconds)
-	step := time.Duration(bucketSeconds) * time.Second
-
-	existing := make(map[int64]*service.OpsThroughputTrendPoint, len(points))
-	for _, p := range points {
-		if p == nil {
-			continue
-		}
-		existing[p.BucketStart.UTC().Unix()] = p
-	}
-
-	out := make([]*service.OpsThroughputTrendPoint, 0, int(last.Sub(first)/step)+1)
-	for cursor := first; !cursor.After(last); cursor = cursor.Add(step) {
-		if p, ok := existing[cursor.Unix()]; ok && p != nil {
-			out = append(out, p)
-			continue
-		}
-		out = append(out, &service.OpsThroughputTrendPoint{
-			BucketStart:   cursor,
-			RequestCount:  0,
-			TokenConsumed: 0,
-			QPS:           0,
-			TPS:           0,
-		})
-	}
-	return out
-}
-
-func (r *opsRepository) GetErrorTrend(ctx context.Context, filter *service.OpsDashboardFilter, bucketSeconds int) (*service.OpsErrorTrendResponse, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		return nil, fmt.Errorf("nil filter")
-	}
-	if filter.StartTime.IsZero() || filter.EndTime.IsZero() {
-		return nil, fmt.Errorf("start_time/end_time required")
-	}
-
-	if bucketSeconds <= 0 {
-		bucketSeconds = 60
-	}
-	if bucketSeconds != 60 && bucketSeconds != 300 && bucketSeconds != 3600 {
-		bucketSeconds = 60
-	}
-
-	start := filter.StartTime.UTC()
-	end := filter.EndTime.UTC()
-	where, args, _ := buildErrorWhere(filter, start, end, 1)
-	bucketExpr := opsBucketExprForError(bucketSeconds)
-
-	q := `
-SELECT
-  ` + bucketExpr + ` AS bucket,
-  COUNT(*) FILTER (WHERE COALESCE(status_code, 0) >= 400) AS error_total,
-  COUNT(*) FILTER (WHERE COALESCE(status_code, 0) >= 400 AND is_business_limited) AS business_limited,
-  COUNT(*) FILTER (WHERE COALESCE(status_code, 0) >= 400 AND NOT is_business_limited) AS error_sla,
-  COUNT(*) FILTER (WHERE error_owner = 'provider' AND NOT is_business_limited AND COALESCE(upstream_status_code, status_code, 0) NOT IN (429, 529)) AS upstream_excl,
-  COUNT(*) FILTER (WHERE error_owner = 'provider' AND NOT is_business_limited AND COALESCE(upstream_status_code, status_code, 0) = 429) AS upstream_429,
-  COUNT(*) FILTER (WHERE error_owner = 'provider' AND NOT is_business_limited AND COALESCE(upstream_status_code, status_code, 0) = 529) AS upstream_529
-FROM ops_error_logs
-` + where + `
-GROUP BY 1
-ORDER BY 1 ASC`
-
-	rows, err := r.db.QueryContext(ctx, q, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	points := make([]*service.OpsErrorTrendPoint, 0, 256)
-	for rows.Next() {
-		var bucket time.Time
-		var total, businessLimited, sla, upstreamExcl, upstream429, upstream529 int64
-		if err := rows.Scan(&bucket, &total, &businessLimited, &sla, &upstreamExcl, &upstream429, &upstream529); err != nil {
-			return nil, err
-		}
-		points = append(points, &service.OpsErrorTrendPoint{
-			BucketStart: bucket.UTC(),
-
-			ErrorCountTotal:      total,
-			BusinessLimitedCount: businessLimited,
-			ErrorCountSLA:        sla,
-
-			UpstreamErrorCountExcl429529: upstreamExcl,
-			Upstream429Count:             upstream429,
-			Upstream529Count:             upstream529,
-		})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	points = fillOpsErrorTrendBuckets(start, end, bucketSeconds, points)
-
-	return &service.OpsErrorTrendResponse{
-		Bucket: opsBucketLabel(bucketSeconds),
-		Points: points,
-	}, nil
-}
-
-func fillOpsErrorTrendBuckets(start, end time.Time, bucketSeconds int, points []*service.OpsErrorTrendPoint) []*service.OpsErrorTrendPoint {
-	if bucketSeconds <= 0 {
-		bucketSeconds = 60
-	}
-	if !start.Before(end) {
-		return points
-	}
-
-	endMinus := end.Add(-time.Nanosecond)
-	if endMinus.Before(start) {
-		return points
-	}
-
-	first := opsFloorToBucketStart(start, bucketSeconds)
-	last := opsFloorToBucketStart(endMinus, bucketSeconds)
-	step := time.Duration(bucketSeconds) * time.Second
-
-	existing := make(map[int64]*service.OpsErrorTrendPoint, len(points))
-	for _, p := range points {
-		if p == nil {
-			continue
-		}
-		existing[p.BucketStart.UTC().Unix()] = p
-	}
-
-	out := make([]*service.OpsErrorTrendPoint, 0, int(last.Sub(first)/step)+1)
-	for cursor := first; !cursor.After(last); cursor = cursor.Add(step) {
-		if p, ok := existing[cursor.Unix()]; ok && p != nil {
-			out = append(out, p)
-			continue
-		}
-		out = append(out, &service.OpsErrorTrendPoint{
-			BucketStart: cursor,
-
-			ErrorCountTotal:      0,
-			BusinessLimitedCount: 0,
-			ErrorCountSLA:        0,
-
-			UpstreamErrorCountExcl429529: 0,
-			Upstream429Count:             0,
-			Upstream529Count:             0,
-		})
-	}
-	return out
-}
-
-func (r *opsRepository) GetErrorDistribution(ctx context.Context, filter *service.OpsDashboardFilter) (*service.OpsErrorDistributionResponse, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		return nil, fmt.Errorf("nil filter")
-	}
-	if filter.StartTime.IsZero() || filter.EndTime.IsZero() {
-		return nil, fmt.Errorf("start_time/end_time required")
-	}
-
-	start := filter.StartTime.UTC()
-	end := filter.EndTime.UTC()
-	where, args, _ := buildErrorWhere(filter, start, end, 1)
-
-	q := `
-SELECT
-  COALESCE(upstream_status_code, status_code, 0) AS status_code,
-  COUNT(*) AS total,
-  COUNT(*) FILTER (WHERE NOT is_business_limited) AS sla,
-  COUNT(*) FILTER (WHERE is_business_limited) AS business_limited
-FROM ops_error_logs
-` + where + `
-  AND COALESCE(status_code, 0) >= 400
-GROUP BY 1
-ORDER BY total DESC
-LIMIT 20`
-
-	rows, err := r.db.QueryContext(ctx, q, args...)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	items := make([]*service.OpsErrorDistributionItem, 0, 16)
-	var total int64
-	for rows.Next() {
-		var statusCode int
-		var cntTotal, cntSLA, cntBiz int64
-		if err := rows.Scan(&statusCode, &cntTotal, &cntSLA, &cntBiz); err != nil {
-			return nil, err
-		}
-		total += cntTotal
-		items = append(items, &service.OpsErrorDistributionItem{
-			StatusCode:      statusCode,
-			Total:           cntTotal,
-			SLA:             cntSLA,
-			BusinessLimited: cntBiz,
-		})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return &service.OpsErrorDistributionResponse{
-		Total: total,
-		Items: items,
-	}, nil
-}

backend/internal/repository/ops_repo_window_stats.go

@@ -1,50 +0,0 @@
-package repository
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-func (r *opsRepository) GetWindowStats(ctx context.Context, filter *service.OpsDashboardFilter) (*service.OpsWindowStats, error) {
-	if r == nil || r.db == nil {
-		return nil, fmt.Errorf("nil ops repository")
-	}
-	if filter == nil {
-		return nil, fmt.Errorf("nil filter")
-	}
-	if filter.StartTime.IsZero() || filter.EndTime.IsZero() {
-		return nil, fmt.Errorf("start_time/end_time required")
-	}
-
-	start := filter.StartTime.UTC()
-	end := filter.EndTime.UTC()
-	if start.After(end) {
-		return nil, fmt.Errorf("start_time must be <= end_time")
-	}
-	// Bound excessively large windows to prevent accidental heavy queries.
-	if end.Sub(start) > 24*time.Hour {
-		return nil, fmt.Errorf("window too large")
-	}
-
-	successCount, tokenConsumed, err := r.queryUsageCounts(ctx, filter, start, end)
-	if err != nil {
-		return nil, err
-	}
-
-	errorTotal, _, _, _, _, _, err := r.queryErrorCounts(ctx, filter, start, end)
-	if err != nil {
-		return nil, err
-	}
-
-	return &service.OpsWindowStats{
-		StartTime: start,
-		EndTime:   end,
-
-		SuccessCount:    successCount,
-		ErrorCountTotal: errorTotal,
-		TokenConsumed:   tokenConsumed,
-	}, nil
-}

backend/internal/repository/proxy_latency_cache.go

@@ -1,74 +0,0 @@
-package repository
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/redis/go-redis/v9"
-)
-
-const proxyLatencyKeyPrefix = "proxy:latency:"
-
-func proxyLatencyKey(proxyID int64) string {
-	return fmt.Sprintf("%s%d", proxyLatencyKeyPrefix, proxyID)
-}
-
-type proxyLatencyCache struct {
-	rdb *redis.Client
-}
-
-func NewProxyLatencyCache(rdb *redis.Client) service.ProxyLatencyCache {
-	return &proxyLatencyCache{rdb: rdb}
-}
-
-func (c *proxyLatencyCache) GetProxyLatencies(ctx context.Context, proxyIDs []int64) (map[int64]*service.ProxyLatencyInfo, error) {
-	results := make(map[int64]*service.ProxyLatencyInfo)
-	if len(proxyIDs) == 0 {
-		return results, nil
-	}
-
-	keys := make([]string, 0, len(proxyIDs))
-	for _, id := range proxyIDs {
-		keys = append(keys, proxyLatencyKey(id))
-	}
-
-	values, err := c.rdb.MGet(ctx, keys...).Result()
-	if err != nil {
-		return results, err
-	}
-
-	for i, raw := range values {
-		if raw == nil {
-			continue
-		}
-		var payload []byte
-		switch v := raw.(type) {
-		case string:
-			payload = []byte(v)
-		case []byte:
-			payload = v
-		default:
-			continue
-		}
-		var info service.ProxyLatencyInfo
-		if err := json.Unmarshal(payload, &info); err != nil {
-			continue
-		}
-		results[proxyIDs[i]] = &info
-	}
-
-	return results, nil
-}
-
-func (c *proxyLatencyCache) SetProxyLatency(ctx context.Context, proxyID int64, info *service.ProxyLatencyInfo) error {
-	if info == nil {
-		return nil
-	}
-	payload, err := json.Marshal(info)
-	if err != nil {
-		return err
-	}
-	return c.rdb.Set(ctx, proxyLatencyKey(proxyID), payload, 0).Err()
-}

backend/internal/repository/proxy_probe_service.go

@@ -7,7 +7,6 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"strings"
 	"time"
 
 	"github.com/Wei-Shaw/sub2api/internal/config"
@@ -35,10 +34,7 @@ func NewProxyExitInfoProber(cfg *config.Config) service.ProxyExitInfoProber {
 	}
 }
 
-const (
-	defaultIPInfoURL         = "http://ip-api.com/json/?lang=zh-CN"
-	defaultProxyProbeTimeout = 30 * time.Second
-)
+const defaultIPInfoURL = "https://ipinfo.io/json"
 
 type proxyProbeService struct {
 	ipInfoURL          string
@@ -50,7 +46,7 @@ type proxyProbeService struct {
 func (s *proxyProbeService) ProbeProxy(ctx context.Context, proxyURL string) (*service.ProxyExitInfo, int64, error) {
 	client, err := httpclient.GetClient(httpclient.Options{
 		ProxyURL:           proxyURL,
-		Timeout:            defaultProxyProbeTimeout,
+		Timeout:            15 * time.Second,
 		InsecureSkipVerify: s.insecureSkipVerify,
 		ProxyStrict:        true,
 		ValidateResolvedIP: s.validateResolvedIP,
@@ -79,14 +75,10 @@ func (s *proxyProbeService) ProbeProxy(ctx context.Context, proxyURL string) (*s
 	}
 
 	var ipInfo struct {
-		Status      string `json:"status"`
-		Message     string `json:"message"`
-		Query       string `json:"query"`
-		City        string `json:"city"`
-		Region      string `json:"region"`
-		RegionName  string `json:"regionName"`
-		Country     string `json:"country"`
-		CountryCode string `json:"countryCode"`
+		IP      string `json:"ip"`
+		City    string `json:"city"`
+		Region  string `json:"region"`
+		Country string `json:"country"`
 	}
 
 	body, err := io.ReadAll(resp.Body)
@@ -97,22 +89,11 @@ func (s *proxyProbeService) ProbeProxy(ctx context.Context, proxyURL string) (*s
 	if err := json.Unmarshal(body, &ipInfo); err != nil {
 		return nil, latencyMs, fmt.Errorf("failed to parse response: %w", err)
 	}
-	if strings.ToLower(ipInfo.Status) != "success" {
-		if ipInfo.Message == "" {
-			ipInfo.Message = "ip-api request failed"
-		}
-		return nil, latencyMs, fmt.Errorf("ip-api request failed: %s", ipInfo.Message)
-	}
 
-	region := ipInfo.RegionName
-	if region == "" {
-		region = ipInfo.Region
-	}
 	return &service.ProxyExitInfo{
-		IP:          ipInfo.Query,
-		City:        ipInfo.City,
-		Region:      region,
-		Country:     ipInfo.Country,
-		CountryCode: ipInfo.CountryCode,
+		IP:      ipInfo.IP,
+		City:    ipInfo.City,
+		Region:  ipInfo.Region,
+		Country: ipInfo.Country,
 	}, latencyMs, nil
 }

backend/internal/repository/proxy_probe_service_test.go

@@ -21,7 +21,7 @@ type ProxyProbeServiceSuite struct {
 func (s *ProxyProbeServiceSuite) SetupTest() {
 	s.ctx = context.Background()
 	s.prober = &proxyProbeService{
-		ipInfoURL:         "http://ip-api.test/json/?lang=zh-CN",
+		ipInfoURL:         "http://ipinfo.test/json",
 		allowPrivateHosts: true,
 	}
 }
@@ -54,7 +54,7 @@ func (s *ProxyProbeServiceSuite) TestProbeProxy_Success() {
 	s.setupProxyServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		seen <- r.RequestURI
 		w.Header().Set("Content-Type", "application/json")
-		_, _ = io.WriteString(w, `{"status":"success","query":"1.2.3.4","city":"c","regionName":"r","country":"cc","countryCode":"CC"}`)
+		_, _ = io.WriteString(w, `{"ip":"1.2.3.4","city":"c","region":"r","country":"cc"}`)
 	}))
 
 	info, latencyMs, err := s.prober.ProbeProxy(s.ctx, s.proxySrv.URL)
@@ -64,12 +64,11 @@ func (s *ProxyProbeServiceSuite) TestProbeProxy_Success() {
 	require.Equal(s.T(), "c", info.City)
 	require.Equal(s.T(), "r", info.Region)
 	require.Equal(s.T(), "cc", info.Country)
-	require.Equal(s.T(), "CC", info.CountryCode)
 
 	// Verify proxy received the request
 	select {
 	case uri := <-seen:
-		require.Contains(s.T(), uri, "ip-api.test", "expected request to go through proxy")
+		require.Contains(s.T(), uri, "ipinfo.test", "expected request to go through proxy")
 	default:
 		require.Fail(s.T(), "expected proxy to receive request")
 	}

backend/internal/repository/proxy_repo.go

@@ -219,54 +219,12 @@ func (r *proxyRepository) ExistsByHostPortAuth(ctx context.Context, host string,
 // CountAccountsByProxyID returns the number of accounts using a specific proxy
 func (r *proxyRepository) CountAccountsByProxyID(ctx context.Context, proxyID int64) (int64, error) {
 	var count int64
-	if err := scanSingleRow(ctx, r.sql, "SELECT COUNT(*) FROM accounts WHERE proxy_id = $1 AND deleted_at IS NULL", []any{proxyID}, &count); err != nil {
+	if err := scanSingleRow(ctx, r.sql, "SELECT COUNT(*) FROM accounts WHERE proxy_id = $1", []any{proxyID}, &count); err != nil {
 		return 0, err
 	}
 	return count, nil
 }
 
-func (r *proxyRepository) ListAccountSummariesByProxyID(ctx context.Context, proxyID int64) ([]service.ProxyAccountSummary, error) {
-	rows, err := r.sql.QueryContext(ctx, `
-		SELECT id, name, platform, type, notes
-		FROM accounts
-		WHERE proxy_id = $1 AND deleted_at IS NULL
-		ORDER BY id DESC
-	`, proxyID)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = rows.Close() }()
-
-	out := make([]service.ProxyAccountSummary, 0)
-	for rows.Next() {
-		var (
-			id       int64
-			name     string
-			platform string
-			accType  string
-			notes    sql.NullString
-		)
-		if err := rows.Scan(&id, &name, &platform, &accType, &notes); err != nil {
-			return nil, err
-		}
-		var notesPtr *string
-		if notes.Valid {
-			notesPtr = &notes.String
-		}
-		out = append(out, service.ProxyAccountSummary{
-			ID:       id,
-			Name:     name,
-			Platform: platform,
-			Type:     accType,
-			Notes:    notesPtr,
-		})
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 // GetAccountCountsForProxies returns a map of proxy ID to account count for all proxies
 func (r *proxyRepository) GetAccountCountsForProxies(ctx context.Context) (counts map[int64]int64, err error) {
 	rows, err := r.sql.QueryContext(ctx, "SELECT proxy_id, COUNT(*) AS count FROM accounts WHERE proxy_id IS NOT NULL AND deleted_at IS NULL GROUP BY proxy_id")

backend/internal/repository/scheduler_cache.go

@@ -1,276 +0,0 @@
-package repository
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/redis/go-redis/v9"
-)
-
-const (
-	schedulerBucketSetKey       = "sched:buckets"
-	schedulerOutboxWatermarkKey = "sched:outbox:watermark"
-	schedulerAccountPrefix      = "sched:acc:"
-	schedulerActivePrefix       = "sched:active:"
-	schedulerReadyPrefix        = "sched:ready:"
-	schedulerVersionPrefix      = "sched:ver:"
-	schedulerSnapshotPrefix     = "sched:"
-	schedulerLockPrefix         = "sched:lock:"
-)
-
-type schedulerCache struct {
-	rdb *redis.Client
-}
-
-func NewSchedulerCache(rdb *redis.Client) service.SchedulerCache {
-	return &schedulerCache{rdb: rdb}
-}
-
-func (c *schedulerCache) GetSnapshot(ctx context.Context, bucket service.SchedulerBucket) ([]*service.Account, bool, error) {
-	readyKey := schedulerBucketKey(schedulerReadyPrefix, bucket)
-	readyVal, err := c.rdb.Get(ctx, readyKey).Result()
-	if err == redis.Nil {
-		return nil, false, nil
-	}
-	if err != nil {
-		return nil, false, err
-	}
-	if readyVal != "1" {
-		return nil, false, nil
-	}
-
-	activeKey := schedulerBucketKey(schedulerActivePrefix, bucket)
-	activeVal, err := c.rdb.Get(ctx, activeKey).Result()
-	if err == redis.Nil {
-		return nil, false, nil
-	}
-	if err != nil {
-		return nil, false, err
-	}
-
-	snapshotKey := schedulerSnapshotKey(bucket, activeVal)
-	ids, err := c.rdb.ZRange(ctx, snapshotKey, 0, -1).Result()
-	if err != nil {
-		return nil, false, err
-	}
-	if len(ids) == 0 {
-		return []*service.Account{}, true, nil
-	}
-
-	keys := make([]string, 0, len(ids))
-	for _, id := range ids {
-		keys = append(keys, schedulerAccountKey(id))
-	}
-	values, err := c.rdb.MGet(ctx, keys...).Result()
-	if err != nil {
-		return nil, false, err
-	}
-
-	accounts := make([]*service.Account, 0, len(values))
-	for _, val := range values {
-		if val == nil {
-			return nil, false, nil
-		}
-		account, err := decodeCachedAccount(val)
-		if err != nil {
-			return nil, false, err
-		}
-		accounts = append(accounts, account)
-	}
-
-	return accounts, true, nil
-}
-
-func (c *schedulerCache) SetSnapshot(ctx context.Context, bucket service.SchedulerBucket, accounts []service.Account) error {
-	activeKey := schedulerBucketKey(schedulerActivePrefix, bucket)
-	oldActive, _ := c.rdb.Get(ctx, activeKey).Result()
-
-	versionKey := schedulerBucketKey(schedulerVersionPrefix, bucket)
-	version, err := c.rdb.Incr(ctx, versionKey).Result()
-	if err != nil {
-		return err
-	}
-
-	versionStr := strconv.FormatInt(version, 10)
-	snapshotKey := schedulerSnapshotKey(bucket, versionStr)
-
-	pipe := c.rdb.Pipeline()
-	for _, account := range accounts {
-		payload, err := json.Marshal(account)
-		if err != nil {
-			return err
-		}
-		pipe.Set(ctx, schedulerAccountKey(strconv.FormatInt(account.ID, 10)), payload, 0)
-	}
-	if len(accounts) > 0 {
-		// 使用序号作为 score，保持数据库返回的排序语义。
-		members := make([]redis.Z, 0, len(accounts))
-		for idx, account := range accounts {
-			members = append(members, redis.Z{
-				Score:  float64(idx),
-				Member: strconv.FormatInt(account.ID, 10),
-			})
-		}
-		pipe.ZAdd(ctx, snapshotKey, members...)
-	} else {
-		pipe.Del(ctx, snapshotKey)
-	}
-	pipe.Set(ctx, activeKey, versionStr, 0)
-	pipe.Set(ctx, schedulerBucketKey(schedulerReadyPrefix, bucket), "1", 0)
-	pipe.SAdd(ctx, schedulerBucketSetKey, bucket.String())
-	if _, err := pipe.Exec(ctx); err != nil {
-		return err
-	}
-
-	if oldActive != "" && oldActive != versionStr {
-		_ = c.rdb.Del(ctx, schedulerSnapshotKey(bucket, oldActive)).Err()
-	}
-
-	return nil
-}
-
-func (c *schedulerCache) GetAccount(ctx context.Context, accountID int64) (*service.Account, error) {
-	key := schedulerAccountKey(strconv.FormatInt(accountID, 10))
-	val, err := c.rdb.Get(ctx, key).Result()
-	if err == redis.Nil {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	return decodeCachedAccount(val)
-}
-
-func (c *schedulerCache) SetAccount(ctx context.Context, account *service.Account) error {
-	if account == nil || account.ID <= 0 {
-		return nil
-	}
-	payload, err := json.Marshal(account)
-	if err != nil {
-		return err
-	}
-	key := schedulerAccountKey(strconv.FormatInt(account.ID, 10))
-	return c.rdb.Set(ctx, key, payload, 0).Err()
-}
-
-func (c *schedulerCache) DeleteAccount(ctx context.Context, accountID int64) error {
-	if accountID <= 0 {
-		return nil
-	}
-	key := schedulerAccountKey(strconv.FormatInt(accountID, 10))
-	return c.rdb.Del(ctx, key).Err()
-}
-
-func (c *schedulerCache) UpdateLastUsed(ctx context.Context, updates map[int64]time.Time) error {
-	if len(updates) == 0 {
-		return nil
-	}
-
-	keys := make([]string, 0, len(updates))
-	ids := make([]int64, 0, len(updates))
-	for id := range updates {
-		keys = append(keys, schedulerAccountKey(strconv.FormatInt(id, 10)))
-		ids = append(ids, id)
-	}
-
-	values, err := c.rdb.MGet(ctx, keys...).Result()
-	if err != nil {
-		return err
-	}
-
-	pipe := c.rdb.Pipeline()
-	for i, val := range values {
-		if val == nil {
-			continue
-		}
-		account, err := decodeCachedAccount(val)
-		if err != nil {
-			return err
-		}
-		account.LastUsedAt = ptrTime(updates[ids[i]])
-		updated, err := json.Marshal(account)
-		if err != nil {
-			return err
-		}
-		pipe.Set(ctx, keys[i], updated, 0)
-	}
-	_, err = pipe.Exec(ctx)
-	return err
-}
-
-func (c *schedulerCache) TryLockBucket(ctx context.Context, bucket service.SchedulerBucket, ttl time.Duration) (bool, error) {
-	key := schedulerBucketKey(schedulerLockPrefix, bucket)
-	return c.rdb.SetNX(ctx, key, time.Now().UnixNano(), ttl).Result()
-}
-
-func (c *schedulerCache) ListBuckets(ctx context.Context) ([]service.SchedulerBucket, error) {
-	raw, err := c.rdb.SMembers(ctx, schedulerBucketSetKey).Result()
-	if err != nil {
-		return nil, err
-	}
-	out := make([]service.SchedulerBucket, 0, len(raw))
-	for _, entry := range raw {
-		bucket, ok := service.ParseSchedulerBucket(entry)
-		if !ok {
-			continue
-		}
-		out = append(out, bucket)
-	}
-	return out, nil
-}
-
-func (c *schedulerCache) GetOutboxWatermark(ctx context.Context) (int64, error) {
-	val, err := c.rdb.Get(ctx, schedulerOutboxWatermarkKey).Result()
-	if err == redis.Nil {
-		return 0, nil
-	}
-	if err != nil {
-		return 0, err
-	}
-	id, err := strconv.ParseInt(val, 10, 64)
-	if err != nil {
-		return 0, err
-	}
-	return id, nil
-}
-
-func (c *schedulerCache) SetOutboxWatermark(ctx context.Context, id int64) error {
-	return c.rdb.Set(ctx, schedulerOutboxWatermarkKey, strconv.FormatInt(id, 10), 0).Err()
-}
-
-func schedulerBucketKey(prefix string, bucket service.SchedulerBucket) string {
-	return fmt.Sprintf("%s%d:%s:%s", prefix, bucket.GroupID, bucket.Platform, bucket.Mode)
-}
-
-func schedulerSnapshotKey(bucket service.SchedulerBucket, version string) string {
-	return fmt.Sprintf("%s%d:%s:%s:v%s", schedulerSnapshotPrefix, bucket.GroupID, bucket.Platform, bucket.Mode, version)
-}
-
-func schedulerAccountKey(id string) string {
-	return schedulerAccountPrefix + id
-}
-
-func ptrTime(t time.Time) *time.Time {
-	return &t
-}
-
-func decodeCachedAccount(val any) (*service.Account, error) {
-	var payload []byte
-	switch raw := val.(type) {
-	case string:
-		payload = []byte(raw)
-	case []byte:
-		payload = raw
-	default:
-		return nil, fmt.Errorf("unexpected account cache type: %T", val)
-	}
-	var account service.Account
-	if err := json.Unmarshal(payload, &account); err != nil {
-		return nil, err
-	}
-	return &account, nil
-}

backend/internal/repository/scheduler_outbox_repo.go

@@ -1,96 +0,0 @@
-package repository
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-)
-
-type schedulerOutboxRepository struct {
-	db *sql.DB
-}
-
-func NewSchedulerOutboxRepository(db *sql.DB) service.SchedulerOutboxRepository {
-	return &schedulerOutboxRepository{db: db}
-}
-
-func (r *schedulerOutboxRepository) ListAfter(ctx context.Context, afterID int64, limit int) ([]service.SchedulerOutboxEvent, error) {
-	if limit <= 0 {
-		limit = 100
-	}
-	rows, err := r.db.QueryContext(ctx, `
-		SELECT id, event_type, account_id, group_id, payload, created_at
-		FROM scheduler_outbox
-		WHERE id > $1
-		ORDER BY id ASC
-		LIMIT $2
-	`, afterID, limit)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		_ = rows.Close()
-	}()
-
-	events := make([]service.SchedulerOutboxEvent, 0, limit)
-	for rows.Next() {
-		var (
-			payloadRaw []byte
-			accountID  sql.NullInt64
-			groupID    sql.NullInt64
-			event      service.SchedulerOutboxEvent
-		)
-		if err := rows.Scan(&event.ID, &event.EventType, &accountID, &groupID, &payloadRaw, &event.CreatedAt); err != nil {
-			return nil, err
-		}
-		if accountID.Valid {
-			v := accountID.Int64
-			event.AccountID = &v
-		}
-		if groupID.Valid {
-			v := groupID.Int64
-			event.GroupID = &v
-		}
-		if len(payloadRaw) > 0 {
-			var payload map[string]any
-			if err := json.Unmarshal(payloadRaw, &payload); err != nil {
-				return nil, err
-			}
-			event.Payload = payload
-		}
-		events = append(events, event)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return events, nil
-}
-
-func (r *schedulerOutboxRepository) MaxID(ctx context.Context) (int64, error) {
-	var maxID int64
-	if err := r.db.QueryRowContext(ctx, "SELECT COALESCE(MAX(id), 0) FROM scheduler_outbox").Scan(&maxID); err != nil {
-		return 0, err
-	}
-	return maxID, nil
-}
-
-func enqueueSchedulerOutbox(ctx context.Context, exec sqlExecutor, eventType string, accountID *int64, groupID *int64, payload any) error {
-	if exec == nil {
-		return nil
-	}
-	var payloadArg any
-	if payload != nil {
-		encoded, err := json.Marshal(payload)
-		if err != nil {
-			return err
-		}
-		payloadArg = encoded
-	}
-	_, err := exec.ExecContext(ctx, `
-		INSERT INTO scheduler_outbox (event_type, account_id, group_id, payload)
-		VALUES ($1, $2, $3, $4)
-	`, eventType, accountID, groupID, payloadArg)
-	return err
-}

backend/internal/repository/scheduler_snapshot_outbox_integration_test.go

@@ -1,68 +0,0 @@
-//go:build integration
-
-package repository
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/config"
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/stretchr/testify/require"
-)
-
-func TestSchedulerSnapshotOutboxReplay(t *testing.T) {
-	ctx := context.Background()
-	rdb := testRedis(t)
-	client := testEntClient(t)
-
-	_, _ = integrationDB.ExecContext(ctx, "TRUNCATE scheduler_outbox")
-
-	accountRepo := newAccountRepositoryWithSQL(client, integrationDB)
-	outboxRepo := NewSchedulerOutboxRepository(integrationDB)
-	cache := NewSchedulerCache(rdb)
-
-	cfg := &config.Config{
-		RunMode: config.RunModeStandard,
-		Gateway: config.GatewayConfig{
-			Scheduling: config.GatewaySchedulingConfig{
-				OutboxPollIntervalSeconds:  1,
-				FullRebuildIntervalSeconds: 0,
-				DbFallbackEnabled:          true,
-			},
-		},
-	}
-
-	account := &service.Account{
-		Name:        "outbox-replay-" + time.Now().Format("150405.000000"),
-		Platform:    service.PlatformOpenAI,
-		Type:        service.AccountTypeAPIKey,
-		Status:      service.StatusActive,
-		Schedulable: true,
-		Concurrency: 3,
-		Priority:    1,
-		Credentials: map[string]any{},
-		Extra:       map[string]any{},
-	}
-	require.NoError(t, accountRepo.Create(ctx, account))
-	require.NoError(t, cache.SetAccount(ctx, account))
-
-	svc := service.NewSchedulerSnapshotService(cache, outboxRepo, accountRepo, nil, cfg)
-	svc.Start()
-	t.Cleanup(svc.Stop)
-
-	require.NoError(t, accountRepo.UpdateLastUsed(ctx, account.ID))
-	updated, err := accountRepo.GetByID(ctx, account.ID)
-	require.NoError(t, err)
-	require.NotNil(t, updated.LastUsedAt)
-	expectedUnix := updated.LastUsedAt.Unix()
-
-	require.Eventually(t, func() bool {
-		cached, err := cache.GetAccount(ctx, account.ID)
-		if err != nil || cached == nil || cached.LastUsedAt == nil {
-			return false
-		}
-		return cached.LastUsedAt.Unix() == expectedUnix
-	}, 5*time.Second, 100*time.Millisecond)
-}

backend/internal/repository/timeout_counter_cache.go

@@ -1,80 +0,0 @@
-package repository
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/Wei-Shaw/sub2api/internal/service"
-	"github.com/redis/go-redis/v9"
-)
-
-const timeoutCounterPrefix = "timeout_count:account:"
-
-// timeoutCounterIncrScript 使用 Lua 脚本原子性地增加计数并返回当前值
-// 如果 key 不存在，则创建并设置过期时间
-var timeoutCounterIncrScript = redis.NewScript(`
-	local key = KEYS[1]
-	local ttl = tonumber(ARGV[1])
-
-	local count = redis.call('INCR', key)
-	if count == 1 then
-		redis.call('EXPIRE', key, ttl)
-	end
-
-	return count
-`)
-
-type timeoutCounterCache struct {
-	rdb *redis.Client
-}
-
-// NewTimeoutCounterCache 创建超时计数器缓存实例
-func NewTimeoutCounterCache(rdb *redis.Client) service.TimeoutCounterCache {
-	return &timeoutCounterCache{rdb: rdb}
-}
-
-// IncrementTimeoutCount 增加账户的超时计数，返回当前计数值
-// windowMinutes 是计数窗口时间（分钟），超过此时间计数器会自动重置
-func (c *timeoutCounterCache) IncrementTimeoutCount(ctx context.Context, accountID int64, windowMinutes int) (int64, error) {
-	key := fmt.Sprintf("%s%d", timeoutCounterPrefix, accountID)
-
-	ttlSeconds := windowMinutes * 60
-	if ttlSeconds < 60 {
-		ttlSeconds = 60 // 最小1分钟
-	}
-
-	result, err := timeoutCounterIncrScript.Run(ctx, c.rdb, []string{key}, ttlSeconds).Int64()
-	if err != nil {
-		return 0, fmt.Errorf("increment timeout count: %w", err)
-	}
-
-	return result, nil
-}
-
-// GetTimeoutCount 获取账户当前的超时计数
-func (c *timeoutCounterCache) GetTimeoutCount(ctx context.Context, accountID int64) (int64, error) {
-	key := fmt.Sprintf("%s%d", timeoutCounterPrefix, accountID)
-
-	val, err := c.rdb.Get(ctx, key).Int64()
-	if err == redis.Nil {
-		return 0, nil
-	}
-	if err != nil {
-		return 0, fmt.Errorf("get timeout count: %w", err)
-	}
-
-	return val, nil
-}
-
-// ResetTimeoutCount 重置账户的超时计数
-func (c *timeoutCounterCache) ResetTimeoutCount(ctx context.Context, accountID int64) error {
-	key := fmt.Sprintf("%s%d", timeoutCounterPrefix, accountID)
-	return c.rdb.Del(ctx, key).Err()
-}
-
-// GetTimeoutCountTTL 获取计数器剩余过期时间
-func (c *timeoutCounterCache) GetTimeoutCountTTL(ctx context.Context, accountID int64) (time.Duration, error) {
-	key := fmt.Sprintf("%s%d", timeoutCounterPrefix, accountID)
-	return c.rdb.TTL(ctx, key).Result()
-}

backend/internal/repository/usage_log_repo.go

@@ -22,7 +22,7 @@ import (
 	"github.com/lib/pq"
 )
 
-const usageLogSelectColumns = "id, user_id, api_key_id, account_id, request_id, model, group_id, subscription_id, input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens, cache_creation_5m_tokens, cache_creation_1h_tokens, input_cost, output_cost, cache_creation_cost, cache_read_cost, total_cost, actual_cost, rate_multiplier, account_rate_multiplier, billing_type, stream, duration_ms, first_token_ms, user_agent, ip_address, image_count, image_size, created_at"
+const usageLogSelectColumns = "id, user_id, api_key_id, account_id, request_id, model, group_id, subscription_id, input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens, cache_creation_5m_tokens, cache_creation_1h_tokens, input_cost, output_cost, cache_creation_cost, cache_read_cost, total_cost, actual_cost, rate_multiplier, billing_type, stream, duration_ms, first_token_ms, user_agent, ip_address, image_count, image_size, created_at"
 
 type usageLogRepository struct {
 	client *dbent.Client
@@ -105,7 +105,6 @@ func (r *usageLogRepository) Create(ctx context.Context, log *service.UsageLog)
 			total_cost,
 			actual_cost,
 			rate_multiplier,
-			account_rate_multiplier,
 			billing_type,
 			stream,
 			duration_ms,
@@ -121,7 +120,7 @@ func (r *usageLogRepository) Create(ctx context.Context, log *service.UsageLog)
 			$8, $9, $10, $11,
 			$12, $13,
 			$14, $15, $16, $17, $18, $19,
-			$20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30
+			$20, $21, $22, $23, $24, $25, $26, $27, $28, $29
 		)
 		ON CONFLICT (request_id, api_key_id) DO NOTHING
 		RETURNING id, created_at
@@ -161,7 +160,6 @@ func (r *usageLogRepository) Create(ctx context.Context, log *service.UsageLog)
 		log.TotalCost,
 		log.ActualCost,
 		rateMultiplier,
-		log.AccountRateMultiplier,
 		log.BillingType,
 		log.Stream,
 		duration,
@@ -271,60 +269,16 @@ func (r *usageLogRepository) GetUserStats(ctx context.Context, userID int64, sta
 type DashboardStats = usagestats.DashboardStats
 
 func (r *usageLogRepository) GetDashboardStats(ctx context.Context) (*DashboardStats, error) {
-	stats := &DashboardStats{}
-	now := timezone.Now()
-	todayStart := timezone.Today()
+	var stats DashboardStats
+	today := timezone.Today()
+	now := time.Now()
 
-	if err := r.fillDashboardEntityStats(ctx, stats, todayStart, now); err != nil {
-		return nil, err
-	}
-	if err := r.fillDashboardUsageStatsAggregated(ctx, stats, todayStart, now); err != nil {
-		return nil, err
-	}
-
-	rpm, tpm, err := r.getPerformanceStats(ctx, 0)
-	if err != nil {
-		return nil, err
-	}
-	stats.Rpm = rpm
-	stats.Tpm = tpm
-
-	return stats, nil
-}
-
-func (r *usageLogRepository) GetDashboardStatsWithRange(ctx context.Context, start, end time.Time) (*DashboardStats, error) {
-	startUTC := start.UTC()
-	endUTC := end.UTC()
-	if !endUTC.After(startUTC) {
-		return nil, errors.New("统计时间范围无效")
-	}
-
-	stats := &DashboardStats{}
-	now := timezone.Now()
-	todayStart := timezone.Today()
-
-	if err := r.fillDashboardEntityStats(ctx, stats, todayStart, now); err != nil {
-		return nil, err
-	}
-	if err := r.fillDashboardUsageStatsFromUsageLogs(ctx, stats, startUTC, endUTC, todayStart, now); err != nil {
-		return nil, err
-	}
-
-	rpm, tpm, err := r.getPerformanceStats(ctx, 0)
-	if err != nil {
-		return nil, err
-	}
-	stats.Rpm = rpm
-	stats.Tpm = tpm
-
-	return stats, nil
-}
-
-func (r *usageLogRepository) fillDashboardEntityStats(ctx context.Context, stats *DashboardStats, todayUTC, now time.Time) error {
+	// 合并用户统计查询
 	userStatsQuery := `
 		SELECT
 			COUNT(*) as total_users,
-			COUNT(CASE WHEN created_at >= $1 THEN 1 END) as today_new_users
+			COUNT(CASE WHEN created_at >= $1 THEN 1 END) as today_new_users,
+			(SELECT COUNT(DISTINCT user_id) FROM usage_logs WHERE created_at >= $2) as active_users
 		FROM users
 		WHERE deleted_at IS NULL
 	`
@@ -332,13 +286,15 @@ func (r *usageLogRepository) fillDashboardEntityStats(ctx context.Context, stats
 		ctx,
 		r.sql,
 		userStatsQuery,
-		[]any{todayUTC},
+		[]any{today, today},
 		&stats.TotalUsers,
 		&stats.TodayNewUsers,
+		&stats.ActiveUsers,
 	); err != nil {
-		return err
+		return nil, err
 	}
 
+	// 合并API Key统计查询
 	apiKeyStatsQuery := `
 		SELECT
 			COUNT(*) as total_api_keys,
@@ -354,9 +310,10 @@ func (r *usageLogRepository) fillDashboardEntityStats(ctx context.Context, stats
 		&stats.TotalAPIKeys,
 		&stats.ActiveAPIKeys,
 	); err != nil {
-		return err
+		return nil, err
 	}
 
+	// 合并账户统计查询
 	accountStatsQuery := `
 		SELECT
 			COUNT(*) as total_accounts,
@@ -378,26 +335,22 @@ func (r *usageLogRepository) fillDashboardEntityStats(ctx context.Context, stats
 		&stats.RateLimitAccounts,
 		&stats.OverloadAccounts,
 	); err != nil {
-		return err
+		return nil, err
 	}
 
-	return nil
-}
-
-func (r *usageLogRepository) fillDashboardUsageStatsAggregated(ctx context.Context, stats *DashboardStats, todayUTC, now time.Time) error {
+	// 累计 Token 统计
 	totalStatsQuery := `
 		SELECT
-			COALESCE(SUM(total_requests), 0) as total_requests,
+			COUNT(*) as total_requests,
 			COALESCE(SUM(input_tokens), 0) as total_input_tokens,
 			COALESCE(SUM(output_tokens), 0) as total_output_tokens,
 			COALESCE(SUM(cache_creation_tokens), 0) as total_cache_creation_tokens,
 			COALESCE(SUM(cache_read_tokens), 0) as total_cache_read_tokens,
 			COALESCE(SUM(total_cost), 0) as total_cost,
 			COALESCE(SUM(actual_cost), 0) as total_actual_cost,
-			COALESCE(SUM(total_duration_ms), 0) as total_duration_ms
-		FROM usage_dashboard_daily
+			COALESCE(AVG(duration_ms), 0) as avg_duration_ms
+		FROM usage_logs
 	`
-	var totalDurationMs int64
 	if err := scanSingleRow(
 		ctx,
 		r.sql,
@@ -410,100 +363,13 @@ func (r *usageLogRepository) fillDashboardUsageStatsAggregated(ctx context.Conte
 		&stats.TotalCacheReadTokens,
 		&stats.TotalCost,
 		&stats.TotalActualCost,
-		&totalDurationMs,
+		&stats.AverageDurationMs,
 	); err != nil {
-		return err
+		return nil, err
 	}
 	stats.TotalTokens = stats.TotalInputTokens + stats.TotalOutputTokens + stats.TotalCacheCreationTokens + stats.TotalCacheReadTokens
-	if stats.TotalRequests > 0 {
-		stats.AverageDurationMs = float64(totalDurationMs) / float64(stats.TotalRequests)
-	}
 
-	todayStatsQuery := `
-		SELECT
-			total_requests as today_requests,
-			input_tokens as today_input_tokens,
-			output_tokens as today_output_tokens,
-			cache_creation_tokens as today_cache_creation_tokens,
-			cache_read_tokens as today_cache_read_tokens,
-			total_cost as today_cost,
-			actual_cost as today_actual_cost,
-			active_users as active_users
-		FROM usage_dashboard_daily
-		WHERE bucket_date = $1::date
-	`
-	if err := scanSingleRow(
-		ctx,
-		r.sql,
-		todayStatsQuery,
-		[]any{todayUTC},
-		&stats.TodayRequests,
-		&stats.TodayInputTokens,
-		&stats.TodayOutputTokens,
-		&stats.TodayCacheCreationTokens,
-		&stats.TodayCacheReadTokens,
-		&stats.TodayCost,
-		&stats.TodayActualCost,
-		&stats.ActiveUsers,
-	); err != nil {
-		if err != sql.ErrNoRows {
-			return err
-		}
-	}
-	stats.TodayTokens = stats.TodayInputTokens + stats.TodayOutputTokens + stats.TodayCacheCreationTokens + stats.TodayCacheReadTokens
-
-	hourlyActiveQuery := `
-		SELECT active_users
-		FROM usage_dashboard_hourly
-		WHERE bucket_start = $1
-	`
-	hourStart := now.In(timezone.Location()).Truncate(time.Hour)
-	if err := scanSingleRow(ctx, r.sql, hourlyActiveQuery, []any{hourStart}, &stats.HourlyActiveUsers); err != nil {
-		if err != sql.ErrNoRows {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (r *usageLogRepository) fillDashboardUsageStatsFromUsageLogs(ctx context.Context, stats *DashboardStats, startUTC, endUTC, todayUTC, now time.Time) error {
-	totalStatsQuery := `
-		SELECT
-			COUNT(*) as total_requests,
-			COALESCE(SUM(input_tokens), 0) as total_input_tokens,
-			COALESCE(SUM(output_tokens), 0) as total_output_tokens,
-			COALESCE(SUM(cache_creation_tokens), 0) as total_cache_creation_tokens,
-			COALESCE(SUM(cache_read_tokens), 0) as total_cache_read_tokens,
-			COALESCE(SUM(total_cost), 0) as total_cost,
-			COALESCE(SUM(actual_cost), 0) as total_actual_cost,
-			COALESCE(SUM(COALESCE(duration_ms, 0)), 0) as total_duration_ms
-		FROM usage_logs
-		WHERE created_at >= $1 AND created_at < $2
-	`
-	var totalDurationMs int64
-	if err := scanSingleRow(
-		ctx,
-		r.sql,
-		totalStatsQuery,
-		[]any{startUTC, endUTC},
-		&stats.TotalRequests,
-		&stats.TotalInputTokens,
-		&stats.TotalOutputTokens,
-		&stats.TotalCacheCreationTokens,
-		&stats.TotalCacheReadTokens,
-		&stats.TotalCost,
-		&stats.TotalActualCost,
-		&totalDurationMs,
-	); err != nil {
-		return err
-	}
-	stats.TotalTokens = stats.TotalInputTokens + stats.TotalOutputTokens + stats.TotalCacheCreationTokens + stats.TotalCacheReadTokens
-	if stats.TotalRequests > 0 {
-		stats.AverageDurationMs = float64(totalDurationMs) / float64(stats.TotalRequests)
-	}
-
-	todayEnd := todayUTC.Add(24 * time.Hour)
+	// 今日 Token 统计
 	todayStatsQuery := `
 		SELECT
 			COUNT(*) as today_requests,
@@ -514,13 +380,13 @@ func (r *usageLogRepository) fillDashboardUsageStatsFromUsageLogs(ctx context.Co
 			COALESCE(SUM(total_cost), 0) as today_cost,
 			COALESCE(SUM(actual_cost), 0) as today_actual_cost
 		FROM usage_logs
-		WHERE created_at >= $1 AND created_at < $2
+		WHERE created_at >= $1
 	`
 	if err := scanSingleRow(
 		ctx,
 		r.sql,
 		todayStatsQuery,
-		[]any{todayUTC, todayEnd},
+		[]any{today},
 		&stats.TodayRequests,
 		&stats.TodayInputTokens,
 		&stats.TodayOutputTokens,
@@ -529,31 +395,19 @@ func (r *usageLogRepository) fillDashboardUsageStatsFromUsageLogs(ctx context.Co
 		&stats.TodayCost,
 		&stats.TodayActualCost,
 	); err != nil {
-		return err
+		return nil, err
 	}
 	stats.TodayTokens = stats.TodayInputTokens + stats.TodayOutputTokens + stats.TodayCacheCreationTokens + stats.TodayCacheReadTokens
 
-	activeUsersQuery := `
-		SELECT COUNT(DISTINCT user_id) as active_users
-		FROM usage_logs
-		WHERE created_at >= $1 AND created_at < $2
-	`
-	if err := scanSingleRow(ctx, r.sql, activeUsersQuery, []any{todayUTC, todayEnd}, &stats.ActiveUsers); err != nil {
-		return err
+	// 性能指标：RPM 和 TPM（最近1分钟，全局）
+	rpm, tpm, err := r.getPerformanceStats(ctx, 0)
+	if err != nil {
+		return nil, err
 	}
+	stats.Rpm = rpm
+	stats.Tpm = tpm
 
-	hourStart := now.UTC().Truncate(time.Hour)
-	hourEnd := hourStart.Add(time.Hour)
-	hourlyActiveQuery := `
-		SELECT COUNT(DISTINCT user_id) as active_users
-		FROM usage_logs
-		WHERE created_at >= $1 AND created_at < $2
-	`
-	if err := scanSingleRow(ctx, r.sql, hourlyActiveQuery, []any{hourStart, hourEnd}, &stats.HourlyActiveUsers); err != nil {
-		return err
-	}
-
-	return nil
+	return &stats, nil
 }
 
 func (r *usageLogRepository) ListByAccount(ctx context.Context, accountID int64, params pagination.PaginationParams) ([]service.UsageLog, *pagination.PaginationResult, error) {
@@ -837,9 +691,7 @@ func (r *usageLogRepository) GetAccountTodayStats(ctx context.Context, accountID
 		SELECT
 			COUNT(*) as requests,
 			COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) as tokens,
-			COALESCE(SUM(total_cost * COALESCE(account_rate_multiplier, 1)), 0) as cost,
-			COALESCE(SUM(total_cost), 0) as standard_cost,
-			COALESCE(SUM(actual_cost), 0) as user_cost
+			COALESCE(SUM(actual_cost), 0) as cost
 		FROM usage_logs
 		WHERE account_id = $1 AND created_at >= $2
 	`
@@ -853,8 +705,6 @@ func (r *usageLogRepository) GetAccountTodayStats(ctx context.Context, accountID
 		&stats.Requests,
 		&stats.Tokens,
 		&stats.Cost,
-		&stats.StandardCost,
-		&stats.UserCost,
 	); err != nil {
 		return nil, err
 	}
@@ -867,9 +717,7 @@ func (r *usageLogRepository) GetAccountWindowStats(ctx context.Context, accountI
 		SELECT
 			COUNT(*) as requests,
 			COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) as tokens,
-			COALESCE(SUM(total_cost * COALESCE(account_rate_multiplier, 1)), 0) as cost,
-			COALESCE(SUM(total_cost), 0) as standard_cost,
-			COALESCE(SUM(actual_cost), 0) as user_cost
+			COALESCE(SUM(actual_cost), 0) as cost
 		FROM usage_logs
 		WHERE account_id = $1 AND created_at >= $2
 	`
@@ -883,8 +731,6 @@ func (r *usageLogRepository) GetAccountWindowStats(ctx context.Context, accountI
 		&stats.Requests,
 		&stats.Tokens,
 		&stats.Cost,
-		&stats.StandardCost,
-		&stats.UserCost,
 	); err != nil {
 		return nil, err
 	}
@@ -1410,8 +1256,8 @@ func (r *usageLogRepository) GetBatchAPIKeyUsageStats(ctx context.Context, apiKe
 	return result, nil
 }
 
-// GetUsageTrendWithFilters returns usage trend data with optional filters
-func (r *usageLogRepository) GetUsageTrendWithFilters(ctx context.Context, startTime, endTime time.Time, granularity string, userID, apiKeyID, accountID, groupID int64, model string, stream *bool) (results []TrendDataPoint, err error) {
+// GetUsageTrendWithFilters returns usage trend data with optional user/api_key filters
+func (r *usageLogRepository) GetUsageTrendWithFilters(ctx context.Context, startTime, endTime time.Time, granularity string, userID, apiKeyID int64) (results []TrendDataPoint, err error) {
 	dateFormat := "YYYY-MM-DD"
 	if granularity == "hour" {
 		dateFormat = "YYYY-MM-DD HH24:00"
@@ -1440,22 +1286,6 @@ func (r *usageLogRepository) GetUsageTrendWithFilters(ctx context.Context, start
 		query += fmt.Sprintf(" AND api_key_id = $%d", len(args)+1)
 		args = append(args, apiKeyID)
 	}
-	if accountID > 0 {
-		query += fmt.Sprintf(" AND account_id = $%d", len(args)+1)
-		args = append(args, accountID)
-	}
-	if groupID > 0 {
-		query += fmt.Sprintf(" AND group_id = $%d", len(args)+1)
-		args = append(args, groupID)
-	}
-	if model != "" {
-		query += fmt.Sprintf(" AND model = $%d", len(args)+1)
-		args = append(args, model)
-	}
-	if stream != nil {
-		query += fmt.Sprintf(" AND stream = $%d", len(args)+1)
-		args = append(args, *stream)
-	}
 	query += " GROUP BY date ORDER BY date ASC"
 
 	rows, err := r.sql.QueryContext(ctx, query, args...)
@@ -1478,15 +1308,9 @@ func (r *usageLogRepository) GetUsageTrendWithFilters(ctx context.Context, start
 	return results, nil
 }
 
-// GetModelStatsWithFilters returns model statistics with optional filters
-func (r *usageLogRepository) GetModelStatsWithFilters(ctx context.Context, startTime, endTime time.Time, userID, apiKeyID, accountID, groupID int64, stream *bool) (results []ModelStat, err error) {
-	actualCostExpr := "COALESCE(SUM(actual_cost), 0) as actual_cost"
-	// 当仅按 account_id 聚合时，实际费用使用账号倍率（total_cost * account_rate_multiplier）。
-	if accountID > 0 && userID == 0 && apiKeyID == 0 {
-		actualCostExpr = "COALESCE(SUM(total_cost * COALESCE(account_rate_multiplier, 1)), 0) as actual_cost"
-	}
-
-	query := fmt.Sprintf(`
+// GetModelStatsWithFilters returns model statistics with optional user/api_key filters
+func (r *usageLogRepository) GetModelStatsWithFilters(ctx context.Context, startTime, endTime time.Time, userID, apiKeyID, accountID int64) (results []ModelStat, err error) {
+	query := `
 		SELECT
 			model,
 			COUNT(*) as requests,
@@ -1494,10 +1318,10 @@ func (r *usageLogRepository) GetModelStatsWithFilters(ctx context.Context, start
 			COALESCE(SUM(output_tokens), 0) as output_tokens,
 			COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) as total_tokens,
 			COALESCE(SUM(total_cost), 0) as cost,
-			%s
+			COALESCE(SUM(actual_cost), 0) as actual_cost
 		FROM usage_logs
 		WHERE created_at >= $1 AND created_at < $2
-	`, actualCostExpr)
+	`
 
 	args := []any{startTime, endTime}
 	if userID > 0 {
@@ -1512,14 +1336,6 @@ func (r *usageLogRepository) GetModelStatsWithFilters(ctx context.Context, start
 		query += fmt.Sprintf(" AND account_id = $%d", len(args)+1)
 		args = append(args, accountID)
 	}
-	if groupID > 0 {
-		query += fmt.Sprintf(" AND group_id = $%d", len(args)+1)
-		args = append(args, groupID)
-	}
-	if stream != nil {
-		query += fmt.Sprintf(" AND stream = $%d", len(args)+1)
-		args = append(args, *stream)
-	}
 	query += " GROUP BY model ORDER BY total_tokens DESC"
 
 	rows, err := r.sql.QueryContext(ctx, query, args...)
@@ -1627,14 +1443,12 @@ func (r *usageLogRepository) GetStatsWithFilters(ctx context.Context, filters Us
 			COALESCE(SUM(cache_creation_tokens + cache_read_tokens), 0) as total_cache_tokens,
 			COALESCE(SUM(total_cost), 0) as total_cost,
 			COALESCE(SUM(actual_cost), 0) as total_actual_cost,
-			COALESCE(SUM(total_cost * COALESCE(account_rate_multiplier, 1)), 0) as total_account_cost,
 			COALESCE(AVG(duration_ms), 0) as avg_duration_ms
 		FROM usage_logs
 		%s
 	`, buildWhere(conditions))
 
 	stats := &UsageStats{}
-	var totalAccountCost float64
 	if err := scanSingleRow(
 		ctx,
 		r.sql,
@@ -1646,14 +1460,10 @@ func (r *usageLogRepository) GetStatsWithFilters(ctx context.Context, filters Us
 		&stats.TotalCacheTokens,
 		&stats.TotalCost,
 		&stats.TotalActualCost,
-		&totalAccountCost,
 		&stats.AverageDurationMs,
 	); err != nil {
 		return nil, err
 	}
-	if filters.AccountID > 0 {
-		stats.TotalAccountCost = &totalAccountCost
-	}
 	stats.TotalTokens = stats.TotalInputTokens + stats.TotalOutputTokens + stats.TotalCacheTokens
 	return stats, nil
 }
@@ -1680,8 +1490,7 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 			COUNT(*) as requests,
 			COALESCE(SUM(input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens), 0) as tokens,
 			COALESCE(SUM(total_cost), 0) as cost,
-			COALESCE(SUM(total_cost * COALESCE(account_rate_multiplier, 1)), 0) as actual_cost,
-			COALESCE(SUM(actual_cost), 0) as user_cost
+			COALESCE(SUM(actual_cost), 0) as actual_cost
 		FROM usage_logs
 		WHERE account_id = $1 AND created_at >= $2 AND created_at < $3
 		GROUP BY date
@@ -1708,8 +1517,7 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 		var tokens int64
 		var cost float64
 		var actualCost float64
-		var userCost float64
-		if err = rows.Scan(&date, &requests, &tokens, &cost, &actualCost, &userCost); err != nil {
+		if err = rows.Scan(&date, &requests, &tokens, &cost, &actualCost); err != nil {
 			return nil, err
 		}
 		t, _ := time.Parse("2006-01-02", date)
@@ -1720,21 +1528,19 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 			Tokens:     tokens,
 			Cost:       cost,
 			ActualCost: actualCost,
-			UserCost:   userCost,
 		})
 	}
 	if err = rows.Err(); err != nil {
 		return nil, err
 	}
 
-	var totalAccountCost, totalUserCost, totalStandardCost float64
+	var totalActualCost, totalStandardCost float64
 	var totalRequests, totalTokens int64
 	var highestCostDay, highestRequestDay *AccountUsageHistory
 
 	for i := range history {
 		h := &history[i]
-		totalAccountCost += h.ActualCost
-		totalUserCost += h.UserCost
+		totalActualCost += h.ActualCost
 		totalStandardCost += h.Cost
 		totalRequests += h.Requests
 		totalTokens += h.Tokens
@@ -1761,13 +1567,11 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 	summary := AccountUsageSummary{
 		Days:              daysCount,
 		ActualDaysUsed:    actualDaysUsed,
-		TotalCost:         totalAccountCost,
-		TotalUserCost:     totalUserCost,
+		TotalCost:         totalActualCost,
 		TotalStandardCost: totalStandardCost,
 		TotalRequests:     totalRequests,
 		TotalTokens:       totalTokens,
-		AvgDailyCost:      totalAccountCost / float64(actualDaysUsed),
-		AvgDailyUserCost:  totalUserCost / float64(actualDaysUsed),
+		AvgDailyCost:      totalActualCost / float64(actualDaysUsed),
 		AvgDailyRequests:  float64(totalRequests) / float64(actualDaysUsed),
 		AvgDailyTokens:    float64(totalTokens) / float64(actualDaysUsed),
 		AvgDurationMs:     avgDuration,
@@ -1779,13 +1583,11 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 			summary.Today = &struct {
 				Date     string  `json:"date"`
 				Cost     float64 `json:"cost"`
-				UserCost float64 `json:"user_cost"`
 				Requests int64   `json:"requests"`
 				Tokens   int64   `json:"tokens"`
 			}{
 				Date:     history[i].Date,
 				Cost:     history[i].ActualCost,
-				UserCost: history[i].UserCost,
 				Requests: history[i].Requests,
 				Tokens:   history[i].Tokens,
 			}
@@ -1798,13 +1600,11 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 			Date     string  `json:"date"`
 			Label    string  `json:"label"`
 			Cost     float64 `json:"cost"`
-			UserCost float64 `json:"user_cost"`
 			Requests int64   `json:"requests"`
 		}{
 			Date:     highestCostDay.Date,
 			Label:    highestCostDay.Label,
 			Cost:     highestCostDay.ActualCost,
-			UserCost: highestCostDay.UserCost,
 			Requests: highestCostDay.Requests,
 		}
 	}
@@ -1815,17 +1615,15 @@ func (r *usageLogRepository) GetAccountUsageStats(ctx context.Context, accountID
 			Label    string  `json:"label"`
 			Requests int64   `json:"requests"`
 			Cost     float64 `json:"cost"`
-			UserCost float64 `json:"user_cost"`
 		}{
 			Date:     highestRequestDay.Date,
 			Label:    highestRequestDay.Label,
 			Requests: highestRequestDay.Requests,
 			Cost:     highestRequestDay.ActualCost,
-			UserCost: highestRequestDay.UserCost,
 		}
 	}
 
-	models, err := r.GetModelStatsWithFilters(ctx, startTime, endTime, 0, 0, accountID, 0, nil)
+	models, err := r.GetModelStatsWithFilters(ctx, startTime, endTime, 0, 0, accountID)
 	if err != nil {
 		models = []ModelStat{}
 	}
@@ -2052,37 +1850,36 @@ func (r *usageLogRepository) loadSubscriptions(ctx context.Context, ids []int64)
 
 func scanUsageLog(scanner interface{ Scan(...any) error }) (*service.UsageLog, error) {
 	var (
-		id                    int64
-		userID                int64
-		apiKeyID              int64
-		accountID             int64
-		requestID             sql.NullString
-		model                 string
-		groupID               sql.NullInt64
-		subscriptionID        sql.NullInt64
-		inputTokens           int
-		outputTokens          int
-		cacheCreationTokens   int
-		cacheReadTokens       int
-		cacheCreation5m       int
-		cacheCreation1h       int
-		inputCost             float64
-		outputCost            float64
-		cacheCreationCost     float64
-		cacheReadCost         float64
-		totalCost             float64
-		actualCost            float64
-		rateMultiplier        float64
-		accountRateMultiplier sql.NullFloat64
-		billingType           int16
-		stream                bool
-		durationMs            sql.NullInt64
-		firstTokenMs          sql.NullInt64
-		userAgent             sql.NullString
-		ipAddress             sql.NullString
-		imageCount            int
-		imageSize             sql.NullString
-		createdAt             time.Time
+		id                  int64
+		userID              int64
+		apiKeyID            int64
+		accountID           int64
+		requestID           sql.NullString
+		model               string
+		groupID             sql.NullInt64
+		subscriptionID      sql.NullInt64
+		inputTokens         int
+		outputTokens        int
+		cacheCreationTokens int
+		cacheReadTokens     int
+		cacheCreation5m     int
+		cacheCreation1h     int
+		inputCost           float64
+		outputCost          float64
+		cacheCreationCost   float64
+		cacheReadCost       float64
+		totalCost           float64
+		actualCost          float64
+		rateMultiplier      float64
+		billingType         int16
+		stream              bool
+		durationMs          sql.NullInt64
+		firstTokenMs        sql.NullInt64
+		userAgent           sql.NullString
+		ipAddress           sql.NullString
+		imageCount          int
+		imageSize           sql.NullString
+		createdAt           time.Time
 	)
 
 	if err := scanner.Scan(
@@ -2107,7 +1904,6 @@ func scanUsageLog(scanner interface{ Scan(...any) error }) (*service.UsageLog, e
 		&totalCost,
 		&actualCost,
 		&rateMultiplier,
-		&accountRateMultiplier,
 		&billingType,
 		&stream,
 		&durationMs,
@@ -2140,7 +1936,6 @@ func scanUsageLog(scanner interface{ Scan(...any) error }) (*service.UsageLog, e
 		TotalCost:             totalCost,
 		ActualCost:            actualCost,
 		RateMultiplier:        rateMultiplier,
-		AccountRateMultiplier: nullFloat64Ptr(accountRateMultiplier),
 		BillingType:           int8(billingType),
 		Stream:                stream,
 		ImageCount:            imageCount,
@@ -2247,14 +2042,6 @@ func nullInt(v *int) sql.NullInt64 {
 	return sql.NullInt64{Int64: int64(*v), Valid: true}
 }
 
-func nullFloat64Ptr(v sql.NullFloat64) *float64 {
-	if !v.Valid {
-		return nil
-	}
-	out := v.Float64
-	return &out
-}
-
 func nullString(v *string) sql.NullString {
 	if v == nil || *v == "" {
 		return sql.NullString{}

backend/internal/repository/usage_log_repo_integration_test.go

@@ -37,12 +37,6 @@ func TestUsageLogRepoSuite(t *testing.T) {
 	suite.Run(t, new(UsageLogRepoSuite))
 }
 
-// truncateToDayUTC 截断到 UTC 日期边界（测试辅助函数）
-func truncateToDayUTC(t time.Time) time.Time {
-	t = t.UTC()
-	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC)
-}
-
 func (s *UsageLogRepoSuite) createUsageLog(user *service.User, apiKey *service.APIKey, account *service.Account, inputTokens, outputTokens int, cost float64, createdAt time.Time) *service.UsageLog {
 	log := &service.UsageLog{
 		UserID:       user.ID,
@@ -102,34 +96,6 @@ func (s *UsageLogRepoSuite) TestGetByID_NotFound() {
 	s.Require().Error(err, "expected error for non-existent ID")
 }
 
-func (s *UsageLogRepoSuite) TestGetByID_ReturnsAccountRateMultiplier() {
-	user := mustCreateUser(s.T(), s.client, &service.User{Email: "getbyid-mult@test.com"})
-	apiKey := mustCreateApiKey(s.T(), s.client, &service.APIKey{UserID: user.ID, Key: "sk-getbyid-mult", Name: "k"})
-	account := mustCreateAccount(s.T(), s.client, &service.Account{Name: "acc-getbyid-mult"})
-
-	m := 0.5
-	log := &service.UsageLog{
-		UserID:                user.ID,
-		APIKeyID:              apiKey.ID,
-		AccountID:             account.ID,
-		RequestID:             uuid.New().String(),
-		Model:                 "claude-3",
-		InputTokens:           10,
-		OutputTokens:          20,
-		TotalCost:             1.0,
-		ActualCost:            2.0,
-		AccountRateMultiplier: &m,
-		CreatedAt:             timezone.Today().Add(2 * time.Hour),
-	}
-	_, err := s.repo.Create(s.ctx, log)
-	s.Require().NoError(err)
-
-	got, err := s.repo.GetByID(s.ctx, log.ID)
-	s.Require().NoError(err)
-	s.Require().NotNil(got.AccountRateMultiplier)
-	s.Require().InEpsilon(0.5, *got.AccountRateMultiplier, 0.0001)
-}
-
 // --- Delete ---
 
 func (s *UsageLogRepoSuite) TestDelete() {
@@ -232,14 +198,14 @@ func (s *UsageLogRepoSuite) TestListWithFilters() {
 // --- GetDashboardStats ---
 
 func (s *UsageLogRepoSuite) TestDashboardStats_TodayTotalsAndPerformance() {
-	now := time.Now().UTC()
-	todayStart := truncateToDayUTC(now)
+	now := time.Now()
+	todayStart := timezone.Today()
 	baseStats, err := s.repo.GetDashboardStats(s.ctx)
 	s.Require().NoError(err, "GetDashboardStats base")
 
 	userToday := mustCreateUser(s.T(), s.client, &service.User{
 		Email:     "today@example.com",
-		CreatedAt: testMaxTime(todayStart.Add(10*time.Second), now.Add(-10*time.Second)),
+		CreatedAt: maxTime(todayStart.Add(10*time.Second), now.Add(-10*time.Second)),
 		UpdatedAt: now,
 	})
 	userOld := mustCreateUser(s.T(), s.client, &service.User{
@@ -272,7 +238,7 @@ func (s *UsageLogRepoSuite) TestDashboardStats_TodayTotalsAndPerformance() {
 		TotalCost:           1.5,
 		ActualCost:          1.2,
 		DurationMs:          &d1,
-		CreatedAt:           testMaxTime(todayStart.Add(2*time.Minute), now.Add(-2*time.Minute)),
+		CreatedAt:           maxTime(todayStart.Add(2*time.Minute), now.Add(-2*time.Minute)),
 	}
 	_, err = s.repo.Create(s.ctx, logToday)
 	s.Require().NoError(err, "Create logToday")
@@ -307,11 +273,6 @@ func (s *UsageLogRepoSuite) TestDashboardStats_TodayTotalsAndPerformance() {
 	_, err = s.repo.Create(s.ctx, logPerf)
 	s.Require().NoError(err, "Create logPerf")
 
-	aggRepo := newDashboardAggregationRepositoryWithSQL(s.tx)
-	aggStart := todayStart.Add(-2 * time.Hour)
-	aggEnd := now.Add(2 * time.Minute)
-	s.Require().NoError(aggRepo.AggregateRange(s.ctx, aggStart, aggEnd), "AggregateRange")
-
 	stats, err := s.repo.GetDashboardStats(s.ctx)
 	s.Require().NoError(err, "GetDashboardStats")
 
@@ -342,80 +303,6 @@ func (s *UsageLogRepoSuite) TestDashboardStats_TodayTotalsAndPerformance() {
 	s.Require().Equal(wantTpm, stats.Tpm, "Tpm mismatch")
 }
 
-func (s *UsageLogRepoSuite) TestDashboardStatsWithRange_Fallback() {
-	now := time.Now().UTC()
-	todayStart := truncateToDayUTC(now)
-	rangeStart := todayStart.Add(-24 * time.Hour)
-	rangeEnd := now.Add(1 * time.Second)
-
-	user1 := mustCreateUser(s.T(), s.client, &service.User{Email: "range-u1@test.com"})
-	user2 := mustCreateUser(s.T(), s.client, &service.User{Email: "range-u2@test.com"})
-	apiKey1 := mustCreateApiKey(s.T(), s.client, &service.APIKey{UserID: user1.ID, Key: "sk-range-1", Name: "k1"})
-	apiKey2 := mustCreateApiKey(s.T(), s.client, &service.APIKey{UserID: user2.ID, Key: "sk-range-2", Name: "k2"})
-	account := mustCreateAccount(s.T(), s.client, &service.Account{Name: "acc-range"})
-
-	d1, d2, d3 := 100, 200, 300
-	logOutside := &service.UsageLog{
-		UserID:       user1.ID,
-		APIKeyID:     apiKey1.ID,
-		AccountID:    account.ID,
-		Model:        "claude-3",
-		InputTokens:  7,
-		OutputTokens: 8,
-		TotalCost:    0.8,
-		ActualCost:   0.7,
-		DurationMs:   &d3,
-		CreatedAt:    rangeStart.Add(-1 * time.Hour),
-	}
-	_, err := s.repo.Create(s.ctx, logOutside)
-	s.Require().NoError(err)
-
-	logRange := &service.UsageLog{
-		UserID:              user1.ID,
-		APIKeyID:            apiKey1.ID,
-		AccountID:           account.ID,
-		Model:               "claude-3",
-		InputTokens:         10,
-		OutputTokens:        20,
-		CacheCreationTokens: 1,
-		CacheReadTokens:     2,
-		TotalCost:           1.0,
-		ActualCost:          0.9,
-		DurationMs:          &d1,
-		CreatedAt:           rangeStart.Add(2 * time.Hour),
-	}
-	_, err = s.repo.Create(s.ctx, logRange)
-	s.Require().NoError(err)
-
-	logToday := &service.UsageLog{
-		UserID:          user2.ID,
-		APIKeyID:        apiKey2.ID,
-		AccountID:       account.ID,
-		Model:           "claude-3",
-		InputTokens:     5,
-		OutputTokens:    6,
-		CacheReadTokens: 1,
-		TotalCost:       0.5,
-		ActualCost:      0.5,
-		DurationMs:      &d2,
-		CreatedAt:       now,
-	}
-	_, err = s.repo.Create(s.ctx, logToday)
-	s.Require().NoError(err)
-
-	stats, err := s.repo.GetDashboardStatsWithRange(s.ctx, rangeStart, rangeEnd)
-	s.Require().NoError(err)
-	s.Require().Equal(int64(2), stats.TotalRequests)
-	s.Require().Equal(int64(15), stats.TotalInputTokens)
-	s.Require().Equal(int64(26), stats.TotalOutputTokens)
-	s.Require().Equal(int64(1), stats.TotalCacheCreationTokens)
-	s.Require().Equal(int64(3), stats.TotalCacheReadTokens)
-	s.Require().Equal(int64(45), stats.TotalTokens)
-	s.Require().Equal(1.5, stats.TotalCost)
-	s.Require().Equal(1.4, stats.TotalActualCost)
-	s.Require().InEpsilon(150.0, stats.AverageDurationMs, 0.0001)
-}
-
 // --- GetUserDashboardStats ---
 
 func (s *UsageLogRepoSuite) TestGetUserDashboardStats() {
@@ -438,202 +325,12 @@ func (s *UsageLogRepoSuite) TestGetAccountTodayStats() {
 	apiKey := mustCreateApiKey(s.T(), s.client, &service.APIKey{UserID: user.ID, Key: "sk-acctoday", Name: "k"})
 	account := mustCreateAccount(s.T(), s.client, &service.Account{Name: "acc-today"})
 
-	createdAt := timezone.Today().Add(1 * time.Hour)
-
-	m1 := 1.5
-	m2 := 0.0
-	_, err := s.repo.Create(s.ctx, &service.UsageLog{
-		UserID:                user.ID,
-		APIKeyID:              apiKey.ID,
-		AccountID:             account.ID,
-		RequestID:             uuid.New().String(),
-		Model:                 "claude-3",
-		InputTokens:           10,
-		OutputTokens:          20,
-		TotalCost:             1.0,
-		ActualCost:            2.0,
-		AccountRateMultiplier: &m1,
-		CreatedAt:             createdAt,
-	})
-	s.Require().NoError(err)
-	_, err = s.repo.Create(s.ctx, &service.UsageLog{
-		UserID:                user.ID,
-		APIKeyID:              apiKey.ID,
-		AccountID:             account.ID,
-		RequestID:             uuid.New().String(),
-		Model:                 "claude-3",
-		InputTokens:           5,
-		OutputTokens:          5,
-		TotalCost:             0.5,
-		ActualCost:            1.0,
-		AccountRateMultiplier: &m2,
-		CreatedAt:             createdAt,
-	})
-	s.Require().NoError(err)
+	s.createUsageLog(user, apiKey, account, 10, 20, 0.5, time.Now())
 
 	stats, err := s.repo.GetAccountTodayStats(s.ctx, account.ID)
 	s.Require().NoError(err, "GetAccountTodayStats")
-	s.Require().Equal(int64(2), stats.Requests)
-	s.Require().Equal(int64(40), stats.Tokens)
-	// account cost = SUM(total_cost * account_rate_multiplier)
-	s.Require().InEpsilon(1.5, stats.Cost, 0.0001)
-	// standard cost = SUM(total_cost)
-	s.Require().InEpsilon(1.5, stats.StandardCost, 0.0001)
-	// user cost = SUM(actual_cost)
-	s.Require().InEpsilon(3.0, stats.UserCost, 0.0001)
-}
-
-func (s *UsageLogRepoSuite) TestDashboardAggregationConsistency() {
-	now := time.Now().UTC().Truncate(time.Second)
-	// 使用固定的时间偏移确保 hour1 和 hour2 在同一天且都在过去
-	// 选择当天 02:00 和 03:00 作为测试时间点（基于 now 的日期）
-	dayStart := truncateToDayUTC(now)
-	hour1 := dayStart.Add(2 * time.Hour) // 当天 02:00
-	hour2 := dayStart.Add(3 * time.Hour) // 当天 03:00
-	// 如果当前时间早于 hour2，则使用昨天的时间
-	if now.Before(hour2.Add(time.Hour)) {
-		dayStart = dayStart.Add(-24 * time.Hour)
-		hour1 = dayStart.Add(2 * time.Hour)
-		hour2 = dayStart.Add(3 * time.Hour)
-	}
-
-	user1 := mustCreateUser(s.T(), s.client, &service.User{Email: "agg-u1@test.com"})
-	user2 := mustCreateUser(s.T(), s.client, &service.User{Email: "agg-u2@test.com"})
-	apiKey1 := mustCreateApiKey(s.T(), s.client, &service.APIKey{UserID: user1.ID, Key: "sk-agg-1", Name: "k1"})
-	apiKey2 := mustCreateApiKey(s.T(), s.client, &service.APIKey{UserID: user2.ID, Key: "sk-agg-2", Name: "k2"})
-	account := mustCreateAccount(s.T(), s.client, &service.Account{Name: "acc-agg"})
-
-	d1, d2, d3 := 100, 200, 150
-	log1 := &service.UsageLog{
-		UserID:              user1.ID,
-		APIKeyID:            apiKey1.ID,
-		AccountID:           account.ID,
-		Model:               "claude-3",
-		InputTokens:         10,
-		OutputTokens:        20,
-		CacheCreationTokens: 2,
-		CacheReadTokens:     1,
-		TotalCost:           1.0,
-		ActualCost:          0.9,
-		DurationMs:          &d1,
-		CreatedAt:           hour1.Add(5 * time.Minute),
-	}
-	_, err := s.repo.Create(s.ctx, log1)
-	s.Require().NoError(err)
-
-	log2 := &service.UsageLog{
-		UserID:       user1.ID,
-		APIKeyID:     apiKey1.ID,
-		AccountID:    account.ID,
-		Model:        "claude-3",
-		InputTokens:  5,
-		OutputTokens: 5,
-		TotalCost:    0.5,
-		ActualCost:   0.5,
-		DurationMs:   &d2,
-		CreatedAt:    hour1.Add(20 * time.Minute),
-	}
-	_, err = s.repo.Create(s.ctx, log2)
-	s.Require().NoError(err)
-
-	log3 := &service.UsageLog{
-		UserID:       user2.ID,
-		APIKeyID:     apiKey2.ID,
-		AccountID:    account.ID,
-		Model:        "claude-3",
-		InputTokens:  7,
-		OutputTokens: 8,
-		TotalCost:    0.7,
-		ActualCost:   0.7,
-		DurationMs:   &d3,
-		CreatedAt:    hour2.Add(10 * time.Minute),
-	}
-	_, err = s.repo.Create(s.ctx, log3)
-	s.Require().NoError(err)
-
-	aggRepo := newDashboardAggregationRepositoryWithSQL(s.tx)
-	aggStart := hour1.Add(-5 * time.Minute)
-	aggEnd := hour2.Add(time.Hour) // 确保覆盖 hour2 的所有数据
-	s.Require().NoError(aggRepo.AggregateRange(s.ctx, aggStart, aggEnd))
-
-	type hourlyRow struct {
-		totalRequests       int64
-		inputTokens         int64
-		outputTokens        int64
-		cacheCreationTokens int64
-		cacheReadTokens     int64
-		totalCost           float64
-		actualCost          float64
-		totalDurationMs     int64
-		activeUsers         int64
-	}
-	fetchHourly := func(bucketStart time.Time) hourlyRow {
-		var row hourlyRow
-		err := scanSingleRow(s.ctx, s.tx, `
-			SELECT total_requests, input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
-			       total_cost, actual_cost, total_duration_ms, active_users
-			FROM usage_dashboard_hourly
-			WHERE bucket_start = $1
-		`, []any{bucketStart}, &row.totalRequests, &row.inputTokens, &row.outputTokens,
-			&row.cacheCreationTokens, &row.cacheReadTokens, &row.totalCost, &row.actualCost,
-			&row.totalDurationMs, &row.activeUsers,
-		)
-		s.Require().NoError(err)
-		return row
-	}
-
-	hour1Row := fetchHourly(hour1)
-	s.Require().Equal(int64(2), hour1Row.totalRequests)
-	s.Require().Equal(int64(15), hour1Row.inputTokens)
-	s.Require().Equal(int64(25), hour1Row.outputTokens)
-	s.Require().Equal(int64(2), hour1Row.cacheCreationTokens)
-	s.Require().Equal(int64(1), hour1Row.cacheReadTokens)
-	s.Require().Equal(1.5, hour1Row.totalCost)
-	s.Require().Equal(1.4, hour1Row.actualCost)
-	s.Require().Equal(int64(300), hour1Row.totalDurationMs)
-	s.Require().Equal(int64(1), hour1Row.activeUsers)
-
-	hour2Row := fetchHourly(hour2)
-	s.Require().Equal(int64(1), hour2Row.totalRequests)
-	s.Require().Equal(int64(7), hour2Row.inputTokens)
-	s.Require().Equal(int64(8), hour2Row.outputTokens)
-	s.Require().Equal(int64(0), hour2Row.cacheCreationTokens)
-	s.Require().Equal(int64(0), hour2Row.cacheReadTokens)
-	s.Require().Equal(0.7, hour2Row.totalCost)
-	s.Require().Equal(0.7, hour2Row.actualCost)
-	s.Require().Equal(int64(150), hour2Row.totalDurationMs)
-	s.Require().Equal(int64(1), hour2Row.activeUsers)
-
-	var daily struct {
-		totalRequests       int64
-		inputTokens         int64
-		outputTokens        int64
-		cacheCreationTokens int64
-		cacheReadTokens     int64
-		totalCost           float64
-		actualCost          float64
-		totalDurationMs     int64
-		activeUsers         int64
-	}
-	err = scanSingleRow(s.ctx, s.tx, `
-		SELECT total_requests, input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
-		       total_cost, actual_cost, total_duration_ms, active_users
-		FROM usage_dashboard_daily
-		WHERE bucket_date = $1::date
-	`, []any{dayStart}, &daily.totalRequests, &daily.inputTokens, &daily.outputTokens,
-		&daily.cacheCreationTokens, &daily.cacheReadTokens, &daily.totalCost, &daily.actualCost,
-		&daily.totalDurationMs, &daily.activeUsers,
-	)
-	s.Require().NoError(err)
-	s.Require().Equal(int64(3), daily.totalRequests)
-	s.Require().Equal(int64(22), daily.inputTokens)
-	s.Require().Equal(int64(33), daily.outputTokens)
-	s.Require().Equal(int64(2), daily.cacheCreationTokens)
-	s.Require().Equal(int64(1), daily.cacheReadTokens)
-	s.Require().Equal(2.2, daily.totalCost)
-	s.Require().Equal(2.1, daily.actualCost)
-	s.Require().Equal(int64(450), daily.totalDurationMs)
-	s.Require().Equal(int64(2), daily.activeUsers)
+	s.Require().Equal(int64(1), stats.Requests)
+	s.Require().Equal(int64(30), stats.Tokens)
 }
 
 // --- GetBatchUserUsageStats ---
@@ -701,7 +398,7 @@ func (s *UsageLogRepoSuite) TestGetGlobalStats() {
 	s.Require().Equal(int64(45), stats.TotalOutputTokens)
 }
 
-func testMaxTime(a, b time.Time) time.Time {
+func maxTime(a, b time.Time) time.Time {
 	if a.After(b) {
 		return a
 	}
@@ -944,17 +641,17 @@ func (s *UsageLogRepoSuite) TestGetUsageTrendWithFilters() {
 	endTime := base.Add(48 * time.Hour)
 
 	// Test with user filter
-	trend, err := s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "day", user.ID, 0, 0, 0, "", nil)
+	trend, err := s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "day", user.ID, 0)
 	s.Require().NoError(err, "GetUsageTrendWithFilters user filter")
 	s.Require().Len(trend, 2)
 
 	// Test with apiKey filter
-	trend, err = s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "day", 0, apiKey.ID, 0, 0, "", nil)
+	trend, err = s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "day", 0, apiKey.ID)
 	s.Require().NoError(err, "GetUsageTrendWithFilters apiKey filter")
 	s.Require().Len(trend, 2)
 
 	// Test with both filters
-	trend, err = s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "day", user.ID, apiKey.ID, 0, 0, "", nil)
+	trend, err = s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "day", user.ID, apiKey.ID)
 	s.Require().NoError(err, "GetUsageTrendWithFilters both filters")
 	s.Require().Len(trend, 2)
 }
@@ -971,7 +668,7 @@ func (s *UsageLogRepoSuite) TestGetUsageTrendWithFilters_HourlyGranularity() {
 	startTime := base.Add(-1 * time.Hour)
 	endTime := base.Add(3 * time.Hour)
 
-	trend, err := s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "hour", user.ID, 0, 0, 0, "", nil)
+	trend, err := s.repo.GetUsageTrendWithFilters(s.ctx, startTime, endTime, "hour", user.ID, 0)
 	s.Require().NoError(err, "GetUsageTrendWithFilters hourly")
 	s.Require().Len(trend, 2)
 }
@@ -1017,17 +714,17 @@ func (s *UsageLogRepoSuite) TestGetModelStatsWithFilters() {
 	endTime := base.Add(2 * time.Hour)
 
 	// Test with user filter
-	stats, err := s.repo.GetModelStatsWithFilters(s.ctx, startTime, endTime, user.ID, 0, 0, 0, nil)
+	stats, err := s.repo.GetModelStatsWithFilters(s.ctx, startTime, endTime, user.ID, 0, 0)
 	s.Require().NoError(err, "GetModelStatsWithFilters user filter")
 	s.Require().Len(stats, 2)
 
 	// Test with apiKey filter
-	stats, err = s.repo.GetModelStatsWithFilters(s.ctx, startTime, endTime, 0, apiKey.ID, 0, 0, nil)
+	stats, err = s.repo.GetModelStatsWithFilters(s.ctx, startTime, endTime, 0, apiKey.ID, 0)
 	s.Require().NoError(err, "GetModelStatsWithFilters apiKey filter")
 	s.Require().Len(stats, 2)
 
 	// Test with account filter
-	stats, err = s.repo.GetModelStatsWithFilters(s.ctx, startTime, endTime, 0, 0, account.ID, 0, nil)
+	stats, err = s.repo.GetModelStatsWithFilters(s.ctx, startTime, endTime, 0, 0, account.ID)
 	s.Require().NoError(err, "GetModelStatsWithFilters account filter")
 	s.Require().Len(stats, 2)
 }

backend/internal/repository/wire.go

@@ -47,9 +47,7 @@ var ProviderSet = wire.NewSet(
 	NewRedeemCodeRepository,
 	NewPromoCodeRepository,
 	NewUsageLogRepository,
-	NewDashboardAggregationRepository,
 	NewSettingRepository,
-	NewOpsRepository,
 	NewUserSubscriptionRepository,
 	NewUserAttributeDefinitionRepository,
 	NewUserAttributeValueRepository,
@@ -59,17 +57,12 @@ var ProviderSet = wire.NewSet(
 	NewBillingCache,
 	NewAPIKeyCache,
 	NewTempUnschedCache,
-	NewTimeoutCounterCache,
 	ProvideConcurrencyCache,
-	NewDashboardCache,
 	NewEmailCache,
 	NewIdentityCache,
 	NewRedeemCache,
 	NewUpdateCache,
 	NewGeminiTokenCache,
-	NewSchedulerCache,
-	NewSchedulerOutboxRepository,
-	NewProxyLatencyCache,
 
 	// HTTP service ports (DI Strategy A: return interface directly)
 	NewTurnstileVerifier,

backend/internal/server/api_contract_test.go

@@ -239,10 +239,9 @@ func TestAPIContracts(t *testing.T) {
 							"cache_creation_cost": 0,
 							"cache_read_cost": 0,
 							"total_cost": 0.5,
-						"actual_cost": 0.5,
-						"rate_multiplier": 1,
-						"account_rate_multiplier": null,
-						"billing_type": 0,
+							"actual_cost": 0.5,
+							"rate_multiplier": 1,
+							"billing_type": 0,
 							"stream": true,
 							"duration_ms": 100,
 							"first_token_ms": 50,
@@ -288,11 +287,6 @@ func TestAPIContracts(t *testing.T) {
 
 					service.SettingKeyDefaultConcurrency: "5",
 					service.SettingKeyDefaultBalance:     "1.25",
-
-					service.SettingKeyOpsMonitoringEnabled:         "false",
-					service.SettingKeyOpsRealtimeMonitoringEnabled: "true",
-					service.SettingKeyOpsQueryModeDefault:          "auto",
-					service.SettingKeyOpsMetricsIntervalSeconds:    "60",
 				})
 			},
 			method:     http.MethodGet,
@@ -315,17 +309,13 @@ func TestAPIContracts(t *testing.T) {
 					"turnstile_site_key": "site-key",
 					"turnstile_secret_key_configured": true,
 					"linuxdo_connect_enabled": false,
-						"linuxdo_connect_client_id": "",
-						"linuxdo_connect_client_secret_configured": false,
-						"linuxdo_connect_redirect_url": "",
-						"ops_monitoring_enabled": false,
-						"ops_realtime_monitoring_enabled": true,
-						"ops_query_mode_default": "auto",
-						"ops_metrics_interval_seconds": 60,
-						"site_name": "Sub2API",
-						"site_logo": "",
-						"site_subtitle": "Subtitle",
-						"api_base_url": "https://api.example.com",
+					"linuxdo_connect_client_id": "",
+					"linuxdo_connect_client_secret_configured": false,
+					"linuxdo_connect_redirect_url": "",
+					"site_name": "Sub2API",
+					"site_logo": "",
+					"site_subtitle": "Subtitle",
+					"api_base_url": "https://api.example.com",
 					"contact_info": "support",
 					"doc_url": "https://docs.example.com",
 					"default_concurrency": 5,
@@ -341,30 +331,6 @@ func TestAPIContracts(t *testing.T) {
 				}
 			}`,
 		},
-		{
-			name:   "POST /api/v1/admin/accounts/bulk-update",
-			method: http.MethodPost,
-			path:   "/api/v1/admin/accounts/bulk-update",
-			body:   `{"account_ids":[101,102],"schedulable":false}`,
-			headers: map[string]string{
-				"Content-Type": "application/json",
-			},
-			wantStatus: http.StatusOK,
-			wantJSON: `{
-				"code": 0,
-				"message": "success",
-				"data": {
-					"success": 2,
-					"failed": 0,
-					"success_ids": [101, 102],
-					"failed_ids": [],
-					"results": [
-						{"account_id": 101, "success": true},
-						{"account_id": 102, "success": true}
-					]
-				}
-			}`,
-		},
 	}
 
 	for _, tt := range tests {
@@ -416,9 +382,6 @@ func newContractDeps(t *testing.T) *contractDeps {
 	apiKeyCache := stubApiKeyCache{}
 	groupRepo := stubGroupRepo{}
 	userSubRepo := stubUserSubscriptionRepo{}
-	accountRepo := stubAccountRepo{}
-	proxyRepo := stubProxyRepo{}
-	redeemRepo := stubRedeemCodeRepo{}
 
 	cfg := &config.Config{
 		Default: config.DefaultConfig{
@@ -427,21 +390,19 @@ func newContractDeps(t *testing.T) *contractDeps {
 		RunMode: config.RunModeStandard,
 	}
 
-	userService := service.NewUserService(userRepo, nil)
+	userService := service.NewUserService(userRepo)
 	apiKeyService := service.NewAPIKeyService(apiKeyRepo, userRepo, groupRepo, userSubRepo, apiKeyCache, cfg)
 
 	usageRepo := newStubUsageLogRepo()
-	usageService := service.NewUsageService(usageRepo, userRepo, nil, nil)
+	usageService := service.NewUsageService(usageRepo, userRepo, nil)
 
 	settingRepo := newStubSettingRepo()
 	settingService := service.NewSettingService(settingRepo, cfg)
 
-	adminService := service.NewAdminService(userRepo, groupRepo, &accountRepo, proxyRepo, apiKeyRepo, redeemRepo, nil, nil, nil, nil)
 	authHandler := handler.NewAuthHandler(cfg, nil, userService, settingService, nil)
 	apiKeyHandler := handler.NewAPIKeyHandler(apiKeyService)
 	usageHandler := handler.NewUsageHandler(usageService, apiKeyService)
-	adminSettingHandler := adminhandler.NewSettingHandler(settingService, nil, nil, nil)
-	adminAccountHandler := adminhandler.NewAccountHandler(adminService, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+	adminSettingHandler := adminhandler.NewSettingHandler(settingService, nil, nil)
 
 	jwtAuth := func(c *gin.Context) {
 		c.Set(string(middleware.ContextKeyUser), middleware.AuthSubject{
@@ -481,7 +442,6 @@ func newContractDeps(t *testing.T) *contractDeps {
 	v1Admin := v1.Group("/admin")
 	v1Admin.Use(adminAuth)
 	v1Admin.GET("/settings", adminSettingHandler.GetSettings)
-	v1Admin.POST("/accounts/bulk-update", adminAccountHandler.BulkUpdate)
 
 	return &contractDeps{
 		now:         now,
@@ -606,18 +566,6 @@ func (stubApiKeyCache) SetDailyUsageExpiry(ctx context.Context, apiKey string, t
 	return nil
 }
 
-func (stubApiKeyCache) GetAuthCache(ctx context.Context, key string) (*service.APIKeyAuthCacheEntry, error) {
-	return nil, nil
-}
-
-func (stubApiKeyCache) SetAuthCache(ctx context.Context, key string, entry *service.APIKeyAuthCacheEntry, ttl time.Duration) error {
-	return nil
-}
-
-func (stubApiKeyCache) DeleteAuthCache(ctx context.Context, key string) error {
-	return nil
-}
-
 type stubGroupRepo struct{}
 
 func (stubGroupRepo) Create(ctx context.Context, group *service.Group) error {
@@ -672,239 +620,6 @@ func (stubGroupRepo) DeleteAccountGroupsByGroupID(ctx context.Context, groupID i
 	return 0, errors.New("not implemented")
 }
 
-type stubAccountRepo struct {
-	bulkUpdateIDs []int64
-}
-
-func (s *stubAccountRepo) Create(ctx context.Context, account *service.Account) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) GetByID(ctx context.Context, id int64) (*service.Account, error) {
-	return nil, service.ErrAccountNotFound
-}
-
-func (s *stubAccountRepo) GetByIDs(ctx context.Context, ids []int64) ([]*service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ExistsByID(ctx context.Context, id int64) (bool, error) {
-	return false, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) GetByCRSAccountID(ctx context.Context, crsAccountID string) (*service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) Update(ctx context.Context, account *service.Account) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) Delete(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.Account, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, platform, accountType, status, search string) ([]service.Account, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListByGroup(ctx context.Context, groupID int64) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListActive(ctx context.Context) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListByPlatform(ctx context.Context, platform string) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) UpdateLastUsed(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) BatchUpdateLastUsed(ctx context.Context, updates map[int64]time.Time) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) SetError(ctx context.Context, id int64, errorMsg string) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) SetSchedulable(ctx context.Context, id int64, schedulable bool) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) AutoPauseExpiredAccounts(ctx context.Context, now time.Time) (int64, error) {
-	return 0, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) BindGroups(ctx context.Context, accountID int64, groupIDs []int64) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListSchedulable(ctx context.Context) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListSchedulableByGroupID(ctx context.Context, groupID int64) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListSchedulableByPlatform(ctx context.Context, platform string) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListSchedulableByGroupIDAndPlatform(ctx context.Context, groupID int64, platform string) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListSchedulableByPlatforms(ctx context.Context, platforms []string) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ListSchedulableByGroupIDAndPlatforms(ctx context.Context, groupID int64, platforms []string) ([]service.Account, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) SetRateLimited(ctx context.Context, id int64, resetAt time.Time) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) SetAntigravityQuotaScopeLimit(ctx context.Context, id int64, scope service.AntigravityQuotaScope, resetAt time.Time) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) SetOverloaded(ctx context.Context, id int64, until time.Time) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) SetTempUnschedulable(ctx context.Context, id int64, until time.Time, reason string) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ClearTempUnschedulable(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ClearRateLimit(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) ClearAntigravityQuotaScopes(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) UpdateSessionWindow(ctx context.Context, id int64, start, end *time.Time, status string) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) UpdateExtra(ctx context.Context, id int64, updates map[string]any) error {
-	return errors.New("not implemented")
-}
-
-func (s *stubAccountRepo) BulkUpdate(ctx context.Context, ids []int64, updates service.AccountBulkUpdate) (int64, error) {
-	s.bulkUpdateIDs = append([]int64{}, ids...)
-	return int64(len(ids)), nil
-}
-
-type stubProxyRepo struct{}
-
-func (stubProxyRepo) Create(ctx context.Context, proxy *service.Proxy) error {
-	return errors.New("not implemented")
-}
-
-func (stubProxyRepo) GetByID(ctx context.Context, id int64) (*service.Proxy, error) {
-	return nil, service.ErrProxyNotFound
-}
-
-func (stubProxyRepo) Update(ctx context.Context, proxy *service.Proxy) error {
-	return errors.New("not implemented")
-}
-
-func (stubProxyRepo) Delete(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (stubProxyRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.Proxy, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (stubProxyRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, protocol, status, search string) ([]service.Proxy, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (stubProxyRepo) ListWithFiltersAndAccountCount(ctx context.Context, params pagination.PaginationParams, protocol, status, search string) ([]service.ProxyWithAccountCount, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (stubProxyRepo) ListActive(ctx context.Context) ([]service.Proxy, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (stubProxyRepo) ListActiveWithAccountCount(ctx context.Context) ([]service.ProxyWithAccountCount, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (stubProxyRepo) ExistsByHostPortAuth(ctx context.Context, host string, port int, username, password string) (bool, error) {
-	return false, errors.New("not implemented")
-}
-
-func (stubProxyRepo) CountAccountsByProxyID(ctx context.Context, proxyID int64) (int64, error) {
-	return 0, errors.New("not implemented")
-}
-
-func (stubProxyRepo) ListAccountSummariesByProxyID(ctx context.Context, proxyID int64) ([]service.ProxyAccountSummary, error) {
-	return nil, errors.New("not implemented")
-}
-
-type stubRedeemCodeRepo struct{}
-
-func (stubRedeemCodeRepo) Create(ctx context.Context, code *service.RedeemCode) error {
-	return errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) CreateBatch(ctx context.Context, codes []service.RedeemCode) error {
-	return errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) GetByID(ctx context.Context, id int64) (*service.RedeemCode, error) {
-	return nil, service.ErrRedeemCodeNotFound
-}
-
-func (stubRedeemCodeRepo) GetByCode(ctx context.Context, code string) (*service.RedeemCode, error) {
-	return nil, service.ErrRedeemCodeNotFound
-}
-
-func (stubRedeemCodeRepo) Update(ctx context.Context, code *service.RedeemCode) error {
-	return errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) Delete(ctx context.Context, id int64) error {
-	return errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) Use(ctx context.Context, id, userID int64) error {
-	return errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.RedeemCode, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, codeType, status, search string) ([]service.RedeemCode, *pagination.PaginationResult, error) {
-	return nil, nil, errors.New("not implemented")
-}
-
-func (stubRedeemCodeRepo) ListByUser(ctx context.Context, userID int64, limit int) ([]service.RedeemCode, error) {
-	return nil, errors.New("not implemented")
-}
-
 type stubUserSubscriptionRepo struct{}
 
 func (stubUserSubscriptionRepo) Create(ctx context.Context, sub *service.UserSubscription) error {
@@ -1023,12 +738,12 @@ func (r *stubApiKeyRepo) GetByID(ctx context.Context, id int64) (*service.APIKey
 	return &clone, nil
 }
 
-func (r *stubApiKeyRepo) GetKeyAndOwnerID(ctx context.Context, id int64) (string, int64, error) {
+func (r *stubApiKeyRepo) GetOwnerID(ctx context.Context, id int64) (int64, error) {
 	key, ok := r.byID[id]
 	if !ok {
-		return "", 0, service.ErrAPIKeyNotFound
+		return 0, service.ErrAPIKeyNotFound
 	}
-	return key.Key, key.UserID, nil
+	return key.UserID, nil
 }
 
 func (r *stubApiKeyRepo) GetByKey(ctx context.Context, key string) (*service.APIKey, error) {
@@ -1040,10 +755,6 @@ func (r *stubApiKeyRepo) GetByKey(ctx context.Context, key string) (*service.API
 	return &clone, nil
 }
 
-func (r *stubApiKeyRepo) GetByKeyForAuth(ctx context.Context, key string) (*service.APIKey, error) {
-	return r.GetByKey(ctx, key)
-}
-
 func (r *stubApiKeyRepo) Update(ctx context.Context, key *service.APIKey) error {
 	if key == nil {
 		return errors.New("nil key")
@@ -1158,14 +869,6 @@ func (r *stubApiKeyRepo) CountByGroupID(ctx context.Context, groupID int64) (int
 	return 0, errors.New("not implemented")
 }
 
-func (r *stubApiKeyRepo) ListKeysByUserID(ctx context.Context, userID int64) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (r *stubApiKeyRepo) ListKeysByGroupID(ctx context.Context, groupID int64) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
-
 type stubUsageLogRepo struct {
 	userLogs map[int64][]service.UsageLog
 }
@@ -1234,11 +937,11 @@ func (r *stubUsageLogRepo) GetDashboardStats(ctx context.Context) (*usagestats.D
 	return nil, errors.New("not implemented")
 }
 
-func (r *stubUsageLogRepo) GetUsageTrendWithFilters(ctx context.Context, startTime, endTime time.Time, granularity string, userID, apiKeyID, accountID, groupID int64, model string, stream *bool) ([]usagestats.TrendDataPoint, error) {
+func (r *stubUsageLogRepo) GetUsageTrendWithFilters(ctx context.Context, startTime, endTime time.Time, granularity string, userID, apiKeyID int64) ([]usagestats.TrendDataPoint, error) {
 	return nil, errors.New("not implemented")
 }
 
-func (r *stubUsageLogRepo) GetModelStatsWithFilters(ctx context.Context, startTime, endTime time.Time, userID, apiKeyID, accountID, groupID int64, stream *bool) ([]usagestats.ModelStat, error) {
+func (r *stubUsageLogRepo) GetModelStatsWithFilters(ctx context.Context, startTime, endTime time.Time, userID, apiKeyID, accountID int64) ([]usagestats.ModelStat, error) {
 	return nil, errors.New("not implemented")
 }
 

backend/internal/server/http.go

@@ -31,7 +31,6 @@ func ProvideRouter(
 	apiKeyAuth middleware2.APIKeyAuthMiddleware,
 	apiKeyService *service.APIKeyService,
 	subscriptionService *service.SubscriptionService,
-	opsService *service.OpsService,
 	settingService *service.SettingService,
 	redisClient *redis.Client,
 ) *gin.Engine {
@@ -51,7 +50,7 @@ func ProvideRouter(
 		}
 	}
 
-	return SetupRouter(r, handlers, jwtAuth, adminAuth, apiKeyAuth, apiKeyService, subscriptionService, opsService, settingService, cfg, redisClient)
+	return SetupRouter(r, handlers, jwtAuth, adminAuth, apiKeyAuth, apiKeyService, subscriptionService, settingService, cfg, redisClient)
 }
 
 // ProvideHTTPServer 提供 HTTP 服务器

backend/internal/server/middleware/admin_auth.go

@@ -30,20 +30,6 @@ func adminAuth(
 	settingService *service.SettingService,
 ) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		// WebSocket upgrade requests cannot set Authorization headers in browsers.
-		// For admin WebSocket endpoints (e.g. Ops realtime), allow passing the JWT via
-		// Sec-WebSocket-Protocol (subprotocol list) using a prefixed token item:
-		//   Sec-WebSocket-Protocol: sub2api-admin, jwt.<token>
-		if isWebSocketUpgradeRequest(c) {
-			if token := extractJWTFromWebSocketSubprotocol(c); token != "" {
-				if !validateJWTForAdmin(c, token, authService, userService) {
-					return
-				}
-				c.Next()
-				return
-			}
-		}
-
 		// 检查 x-api-key header（Admin API Key 认证）
 		apiKey := c.GetHeader("x-api-key")
 		if apiKey != "" {
@@ -72,44 +58,6 @@ func adminAuth(
 	}
 }
 
-func isWebSocketUpgradeRequest(c *gin.Context) bool {
-	if c == nil || c.Request == nil {
-		return false
-	}
-	// RFC6455 handshake uses:
-	//   Connection: Upgrade
-	//   Upgrade: websocket
-	upgrade := strings.ToLower(strings.TrimSpace(c.GetHeader("Upgrade")))
-	if upgrade != "websocket" {
-		return false
-	}
-	connection := strings.ToLower(c.GetHeader("Connection"))
-	return strings.Contains(connection, "upgrade")
-}
-
-func extractJWTFromWebSocketSubprotocol(c *gin.Context) string {
-	if c == nil {
-		return ""
-	}
-	raw := strings.TrimSpace(c.GetHeader("Sec-WebSocket-Protocol"))
-	if raw == "" {
-		return ""
-	}
-
-	// The header is a comma-separated list of tokens. We reserve the prefix "jwt."
-	// for carrying the admin JWT.
-	for _, part := range strings.Split(raw, ",") {
-		p := strings.TrimSpace(part)
-		if strings.HasPrefix(p, "jwt.") {
-			token := strings.TrimSpace(strings.TrimPrefix(p, "jwt."))
-			if token != "" {
-				return token
-			}
-		}
-	}
-	return ""
-}
-
 // validateAdminAPIKey 验证管理员 API Key
 func validateAdminAPIKey(
 	c *gin.Context,

backend/internal/server/middleware/api_key_auth_google_test.go

@@ -27,8 +27,8 @@ func (f fakeAPIKeyRepo) Create(ctx context.Context, key *service.APIKey) error {
 func (f fakeAPIKeyRepo) GetByID(ctx context.Context, id int64) (*service.APIKey, error) {
 	return nil, errors.New("not implemented")
 }
-func (f fakeAPIKeyRepo) GetKeyAndOwnerID(ctx context.Context, id int64) (string, int64, error) {
-	return "", 0, errors.New("not implemented")
+func (f fakeAPIKeyRepo) GetOwnerID(ctx context.Context, id int64) (int64, error) {
+	return 0, errors.New("not implemented")
 }
 func (f fakeAPIKeyRepo) GetByKey(ctx context.Context, key string) (*service.APIKey, error) {
 	if f.getByKey == nil {
@@ -36,9 +36,6 @@ func (f fakeAPIKeyRepo) GetByKey(ctx context.Context, key string) (*service.APIK
 	}
 	return f.getByKey(ctx, key)
 }
-func (f fakeAPIKeyRepo) GetByKeyForAuth(ctx context.Context, key string) (*service.APIKey, error) {
-	return f.GetByKey(ctx, key)
-}
 func (f fakeAPIKeyRepo) Update(ctx context.Context, key *service.APIKey) error {
 	return errors.New("not implemented")
 }
@@ -69,12 +66,6 @@ func (f fakeAPIKeyRepo) ClearGroupIDByGroupID(ctx context.Context, groupID int64
 func (f fakeAPIKeyRepo) CountByGroupID(ctx context.Context, groupID int64) (int64, error) {
 	return 0, errors.New("not implemented")
 }
-func (f fakeAPIKeyRepo) ListKeysByUserID(ctx context.Context, userID int64) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
-func (f fakeAPIKeyRepo) ListKeysByGroupID(ctx context.Context, groupID int64) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
 
 type googleErrorResponse struct {
 	Error struct {

backend/internal/server/middleware/api_key_auth_test.go

@@ -256,8 +256,8 @@ func (r *stubApiKeyRepo) GetByID(ctx context.Context, id int64) (*service.APIKey
 	return nil, errors.New("not implemented")
 }
 
-func (r *stubApiKeyRepo) GetKeyAndOwnerID(ctx context.Context, id int64) (string, int64, error) {
-	return "", 0, errors.New("not implemented")
+func (r *stubApiKeyRepo) GetOwnerID(ctx context.Context, id int64) (int64, error) {
+	return 0, errors.New("not implemented")
 }
 
 func (r *stubApiKeyRepo) GetByKey(ctx context.Context, key string) (*service.APIKey, error) {
@@ -267,10 +267,6 @@ func (r *stubApiKeyRepo) GetByKey(ctx context.Context, key string) (*service.API
 	return nil, errors.New("not implemented")
 }
 
-func (r *stubApiKeyRepo) GetByKeyForAuth(ctx context.Context, key string) (*service.APIKey, error) {
-	return r.GetByKey(ctx, key)
-}
-
 func (r *stubApiKeyRepo) Update(ctx context.Context, key *service.APIKey) error {
 	return errors.New("not implemented")
 }
@@ -311,14 +307,6 @@ func (r *stubApiKeyRepo) CountByGroupID(ctx context.Context, groupID int64) (int
 	return 0, errors.New("not implemented")
 }
 
-func (r *stubApiKeyRepo) ListKeysByUserID(ctx context.Context, userID int64) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (r *stubApiKeyRepo) ListKeysByGroupID(ctx context.Context, groupID int64) ([]string, error) {
-	return nil, errors.New("not implemented")
-}
-
 type stubUserSubscriptionRepo struct {
 	getActive      func(ctx context.Context, userID, groupID int64) (*service.UserSubscription, error)
 	updateStatus   func(ctx context.Context, subscriptionID int64, status string) error

backend/internal/server/middleware/client_request_id.go

@@ -1,30 +0,0 @@
-package middleware
-
-import (
-	"context"
-
-	"github.com/Wei-Shaw/sub2api/internal/pkg/ctxkey"
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-)
-
-// ClientRequestID ensures every request has a unique client_request_id in request.Context().
-//
-// This is used by the Ops monitoring module for end-to-end request correlation.
-func ClientRequestID() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		if c.Request == nil {
-			c.Next()
-			return
-		}
-
-		if v := c.Request.Context().Value(ctxkey.ClientRequestID); v != nil {
-			c.Next()
-			return
-		}
-
-		id := uuid.New().String()
-		c.Request = c.Request.WithContext(context.WithValue(c.Request.Context(), ctxkey.ClientRequestID, id))
-		c.Next()
-	}
-}

backend/internal/server/router.go

@@ -23,7 +23,6 @@ func SetupRouter(
 	apiKeyAuth middleware2.APIKeyAuthMiddleware,
 	apiKeyService *service.APIKeyService,
 	subscriptionService *service.SubscriptionService,
-	opsService *service.OpsService,
 	settingService *service.SettingService,
 	cfg *config.Config,
 	redisClient *redis.Client,
@@ -47,7 +46,7 @@ func SetupRouter(
 	}
 
 	// 注册路由
-	registerRoutes(r, handlers, jwtAuth, adminAuth, apiKeyAuth, apiKeyService, subscriptionService, opsService, cfg, redisClient)
+	registerRoutes(r, handlers, jwtAuth, adminAuth, apiKeyAuth, apiKeyService, subscriptionService, cfg, redisClient)
 
 	return r
 }
@@ -61,7 +60,6 @@ func registerRoutes(
 	apiKeyAuth middleware2.APIKeyAuthMiddleware,
 	apiKeyService *service.APIKeyService,
 	subscriptionService *service.SubscriptionService,
-	opsService *service.OpsService,
 	cfg *config.Config,
 	redisClient *redis.Client,
 ) {
@@ -75,5 +73,5 @@ func registerRoutes(
 	routes.RegisterAuthRoutes(v1, h, jwtAuth, redisClient)
 	routes.RegisterUserRoutes(v1, h, jwtAuth)
 	routes.RegisterAdminRoutes(v1, h, adminAuth)
-	routes.RegisterGatewayRoutes(r, h, apiKeyAuth, apiKeyService, subscriptionService, opsService, cfg)
+	routes.RegisterGatewayRoutes(r, h, apiKeyAuth, apiKeyService, subscriptionService, cfg)
 }

backend/internal/server/routes/admin.go

@@ -50,9 +50,6 @@ func RegisterAdminRoutes(
 		// 系统设置
 		registerSettingsRoutes(admin, h)
 
-		// 运维监控（Ops）
-		registerOpsRoutes(admin, h)
-
 		// 系统管理
 		registerSystemRoutes(admin, h)
 
@@ -67,85 +64,6 @@ func RegisterAdminRoutes(
 	}
 }
 
-func registerOpsRoutes(admin *gin.RouterGroup, h *handler.Handlers) {
-	ops := admin.Group("/ops")
-	{
-		// Realtime ops signals
-		ops.GET("/concurrency", h.Admin.Ops.GetConcurrencyStats)
-		ops.GET("/account-availability", h.Admin.Ops.GetAccountAvailability)
-		ops.GET("/realtime-traffic", h.Admin.Ops.GetRealtimeTrafficSummary)
-
-		// Alerts (rules + events)
-		ops.GET("/alert-rules", h.Admin.Ops.ListAlertRules)
-		ops.POST("/alert-rules", h.Admin.Ops.CreateAlertRule)
-		ops.PUT("/alert-rules/:id", h.Admin.Ops.UpdateAlertRule)
-		ops.DELETE("/alert-rules/:id", h.Admin.Ops.DeleteAlertRule)
-		ops.GET("/alert-events", h.Admin.Ops.ListAlertEvents)
-		ops.GET("/alert-events/:id", h.Admin.Ops.GetAlertEvent)
-		ops.PUT("/alert-events/:id/status", h.Admin.Ops.UpdateAlertEventStatus)
-		ops.POST("/alert-silences", h.Admin.Ops.CreateAlertSilence)
-
-		// Email notification config (DB-backed)
-		ops.GET("/email-notification/config", h.Admin.Ops.GetEmailNotificationConfig)
-		ops.PUT("/email-notification/config", h.Admin.Ops.UpdateEmailNotificationConfig)
-
-		// Runtime settings (DB-backed)
-		runtime := ops.Group("/runtime")
-		{
-			runtime.GET("/alert", h.Admin.Ops.GetAlertRuntimeSettings)
-			runtime.PUT("/alert", h.Admin.Ops.UpdateAlertRuntimeSettings)
-		}
-
-		// Advanced settings (DB-backed)
-		ops.GET("/advanced-settings", h.Admin.Ops.GetAdvancedSettings)
-		ops.PUT("/advanced-settings", h.Admin.Ops.UpdateAdvancedSettings)
-
-		// Settings group (DB-backed)
-		settings := ops.Group("/settings")
-		{
-			settings.GET("/metric-thresholds", h.Admin.Ops.GetMetricThresholds)
-			settings.PUT("/metric-thresholds", h.Admin.Ops.UpdateMetricThresholds)
-		}
-
-		// WebSocket realtime (QPS/TPS)
-		ws := ops.Group("/ws")
-		{
-			ws.GET("/qps", h.Admin.Ops.QPSWSHandler)
-		}
-
-		// Error logs (legacy)
-		ops.GET("/errors", h.Admin.Ops.GetErrorLogs)
-		ops.GET("/errors/:id", h.Admin.Ops.GetErrorLogByID)
-		ops.GET("/errors/:id/retries", h.Admin.Ops.ListRetryAttempts)
-		ops.POST("/errors/:id/retry", h.Admin.Ops.RetryErrorRequest)
-		ops.PUT("/errors/:id/resolve", h.Admin.Ops.UpdateErrorResolution)
-
-		// Request errors (client-visible failures)
-		ops.GET("/request-errors", h.Admin.Ops.ListRequestErrors)
-		ops.GET("/request-errors/:id", h.Admin.Ops.GetRequestError)
-		ops.GET("/request-errors/:id/upstream-errors", h.Admin.Ops.ListRequestErrorUpstreamErrors)
-		ops.POST("/request-errors/:id/retry-client", h.Admin.Ops.RetryRequestErrorClient)
-		ops.POST("/request-errors/:id/upstream-errors/:idx/retry", h.Admin.Ops.RetryRequestErrorUpstreamEvent)
-		ops.PUT("/request-errors/:id/resolve", h.Admin.Ops.ResolveRequestError)
-
-		// Upstream errors (independent upstream failures)
-		ops.GET("/upstream-errors", h.Admin.Ops.ListUpstreamErrors)
-		ops.GET("/upstream-errors/:id", h.Admin.Ops.GetUpstreamError)
-		ops.POST("/upstream-errors/:id/retry", h.Admin.Ops.RetryUpstreamError)
-		ops.PUT("/upstream-errors/:id/resolve", h.Admin.Ops.ResolveUpstreamError)
-
-		// Request drilldown (success + error)
-		ops.GET("/requests", h.Admin.Ops.ListRequestDetails)
-
-		// Dashboard (vNext - raw path for MVP)
-		ops.GET("/dashboard/overview", h.Admin.Ops.GetDashboardOverview)
-		ops.GET("/dashboard/throughput-trend", h.Admin.Ops.GetDashboardThroughputTrend)
-		ops.GET("/dashboard/latency-histogram", h.Admin.Ops.GetDashboardLatencyHistogram)
-		ops.GET("/dashboard/error-trend", h.Admin.Ops.GetDashboardErrorTrend)
-		ops.GET("/dashboard/error-distribution", h.Admin.Ops.GetDashboardErrorDistribution)
-	}
-}
-
 func registerDashboardRoutes(admin *gin.RouterGroup, h *handler.Handlers) {
 	dashboard := admin.Group("/dashboard")
 	{
@@ -157,7 +75,6 @@ func registerDashboardRoutes(admin *gin.RouterGroup, h *handler.Handlers) {
 		dashboard.GET("/users-trend", h.Admin.Dashboard.GetUserUsageTrend)
 		dashboard.POST("/users-usage", h.Admin.Dashboard.GetBatchUsersUsage)
 		dashboard.POST("/api-keys-usage", h.Admin.Dashboard.GetBatchAPIKeysUsage)
-		dashboard.POST("/aggregation/backfill", h.Admin.Dashboard.BackfillAggregation)
 	}
 }
 
@@ -269,7 +186,6 @@ func registerProxyRoutes(admin *gin.RouterGroup, h *handler.Handlers) {
 		proxies.POST("/:id/test", h.Admin.Proxy.Test)
 		proxies.GET("/:id/stats", h.Admin.Proxy.GetStats)
 		proxies.GET("/:id/accounts", h.Admin.Proxy.GetProxyAccounts)
-		proxies.POST("/batch-delete", h.Admin.Proxy.BatchDelete)
 		proxies.POST("/batch", h.Admin.Proxy.BatchCreate)
 	}
 }
@@ -311,9 +227,6 @@ func registerSettingsRoutes(admin *gin.RouterGroup, h *handler.Handlers) {
 		adminSettings.GET("/admin-api-key", h.Admin.Setting.GetAdminAPIKey)
 		adminSettings.POST("/admin-api-key/regenerate", h.Admin.Setting.RegenerateAdminAPIKey)
 		adminSettings.DELETE("/admin-api-key", h.Admin.Setting.DeleteAdminAPIKey)
-		// 流超时处理配置
-		adminSettings.GET("/stream-timeout", h.Admin.Setting.GetStreamTimeoutSettings)
-		adminSettings.PUT("/stream-timeout", h.Admin.Setting.UpdateStreamTimeoutSettings)
 	}
 }
 

backend/internal/server/routes/auth.go

@@ -27,10 +27,8 @@ func RegisterAuthRoutes(
 		auth.POST("/register", h.Auth.Register)
 		auth.POST("/login", h.Auth.Login)
 		auth.POST("/send-verify-code", h.Auth.SendVerifyCode)
-		// 优惠码验证接口添加速率限制：每分钟最多 10 次（Redis 故障时 fail-close）
-		auth.POST("/validate-promo-code", rateLimiter.LimitWithOptions("validate-promo", 10, time.Minute, middleware.RateLimitOptions{
-			FailureMode: middleware.RateLimitFailClose,
-		}), h.Auth.ValidatePromoCode)
+		// 优惠码验证接口添加速率限制：每分钟最多 10 次
+		auth.POST("/validate-promo-code", rateLimiter.Limit("validate-promo", 10, time.Minute), h.Auth.ValidatePromoCode)
 		auth.GET("/oauth/linuxdo/start", h.Auth.LinuxDoOAuthStart)
 		auth.GET("/oauth/linuxdo/callback", h.Auth.LinuxDoOAuthCallback)
 	}

backend/internal/server/routes/gateway.go

@@ -16,18 +16,13 @@ func RegisterGatewayRoutes(
 	apiKeyAuth middleware.APIKeyAuthMiddleware,
 	apiKeyService *service.APIKeyService,
 	subscriptionService *service.SubscriptionService,
-	opsService *service.OpsService,
 	cfg *config.Config,
 ) {
 	bodyLimit := middleware.RequestBodyLimit(cfg.Gateway.MaxBodySize)
-	clientRequestID := middleware.ClientRequestID()
-	opsErrorLogger := handler.OpsErrorLoggerMiddleware(opsService)
 
 	// API网关（Claude API兼容）
 	gateway := r.Group("/v1")
 	gateway.Use(bodyLimit)
-	gateway.Use(clientRequestID)
-	gateway.Use(opsErrorLogger)
 	gateway.Use(gin.HandlerFunc(apiKeyAuth))
 	{
 		gateway.POST("/messages", h.Gateway.Messages)
@@ -41,8 +36,6 @@ func RegisterGatewayRoutes(
 	// Gemini 原生 API 兼容层（Gemini SDK/CLI 直连）
 	gemini := r.Group("/v1beta")
 	gemini.Use(bodyLimit)
-	gemini.Use(clientRequestID)
-	gemini.Use(opsErrorLogger)
 	gemini.Use(middleware.APIKeyAuthWithSubscriptionGoogle(apiKeyService, subscriptionService, cfg))
 	{
 		gemini.GET("/models", h.Gateway.GeminiV1BetaListModels)
@@ -52,7 +45,7 @@ func RegisterGatewayRoutes(
 	}
 
 	// OpenAI Responses API（不带v1前缀的别名）
-	r.POST("/responses", bodyLimit, clientRequestID, opsErrorLogger, gin.HandlerFunc(apiKeyAuth), h.OpenAIGateway.Responses)
+	r.POST("/responses", bodyLimit, gin.HandlerFunc(apiKeyAuth), h.OpenAIGateway.Responses)
 
 	// Antigravity 模型列表
 	r.GET("/antigravity/models", gin.HandlerFunc(apiKeyAuth), h.Gateway.AntigravityModels)
@@ -60,8 +53,6 @@ func RegisterGatewayRoutes(
 	// Antigravity 专用路由（仅使用 antigravity 账户，不混合调度）
 	antigravityV1 := r.Group("/antigravity/v1")
 	antigravityV1.Use(bodyLimit)
-	antigravityV1.Use(clientRequestID)
-	antigravityV1.Use(opsErrorLogger)
 	antigravityV1.Use(middleware.ForcePlatform(service.PlatformAntigravity))
 	antigravityV1.Use(gin.HandlerFunc(apiKeyAuth))
 	{
@@ -73,8 +64,6 @@ func RegisterGatewayRoutes(
 
 	antigravityV1Beta := r.Group("/antigravity/v1beta")
 	antigravityV1Beta.Use(bodyLimit)
-	antigravityV1Beta.Use(clientRequestID)
-	antigravityV1Beta.Use(opsErrorLogger)
 	antigravityV1Beta.Use(middleware.ForcePlatform(service.PlatformAntigravity))
 	antigravityV1Beta.Use(middleware.APIKeyAuthWithSubscriptionGoogle(apiKeyService, subscriptionService, cfg))
 	{

backend/internal/service/account.go

@@ -9,19 +9,16 @@ import (
 )
 
 type Account struct {
-	ID          int64
-	Name        string
-	Notes       *string
-	Platform    string
-	Type        string
-	Credentials map[string]any
-	Extra       map[string]any
-	ProxyID     *int64
-	Concurrency int
-	Priority    int
-	// RateMultiplier 账号计费倍率（>=0，允许 0 表示该账号计费为 0）。
-	// 使用指针用于兼容旧版本调度缓存（Redis）中缺字段的情况：nil 表示按 1.0 处理。
-	RateMultiplier     *float64
+	ID                 int64
+	Name               string
+	Notes              *string
+	Platform           string
+	Type               string
+	Credentials        map[string]any
+	Extra              map[string]any
+	ProxyID            *int64
+	Concurrency        int
+	Priority           int
 	Status             string
 	ErrorMessage       string
 	LastUsedAt         *time.Time
@@ -60,20 +57,6 @@ func (a *Account) IsActive() bool {
 	return a.Status == StatusActive
 }
 
-// BillingRateMultiplier 返回账号计费倍率。
-// - nil 表示未配置/旧缓存缺字段，按 1.0 处理
-// - 允许 0，表示该账号计费为 0
-// - 负数属于非法数据，出于安全考虑按 1.0 处理
-func (a *Account) BillingRateMultiplier() float64 {
-	if a == nil || a.RateMultiplier == nil {
-		return 1.0
-	}
-	if *a.RateMultiplier < 0 {
-		return 1.0
-	}
-	return *a.RateMultiplier
-}
-
 func (a *Account) IsSchedulable() bool {
 	if !a.IsActive() || !a.Schedulable {
 		return false

backend/internal/service/account_billing_rate_multiplier_test.go

@@ -1,27 +0,0 @@
-package service
-
-import (
-	"encoding/json"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestAccount_BillingRateMultiplier_DefaultsToOneWhenNil(t *testing.T) {
-	var a Account
-	require.NoError(t, json.Unmarshal([]byte(`{"id":1,"name":"acc","status":"active"}`), &a))
-	require.Nil(t, a.RateMultiplier)
-	require.Equal(t, 1.0, a.BillingRateMultiplier())
-}
-
-func TestAccount_BillingRateMultiplier_AllowsZero(t *testing.T) {
-	v := 0.0
-	a := Account{RateMultiplier: &v}
-	require.Equal(t, 0.0, a.BillingRateMultiplier())
-}
-
-func TestAccount_BillingRateMultiplier_NegativeFallsBackToOne(t *testing.T) {
-	v := -1.0
-	a := Account{RateMultiplier: &v}
-	require.Equal(t, 1.0, a.BillingRateMultiplier())
-}

backend/internal/service/account_service.go

@@ -63,15 +63,14 @@ type AccountRepository interface {
 // AccountBulkUpdate describes the fields that can be updated in a bulk operation.
 // Nil pointers mean "do not change".
 type AccountBulkUpdate struct {
-	Name           *string
-	ProxyID        *int64
-	Concurrency    *int
-	Priority       *int
-	RateMultiplier *float64
-	Status         *string
-	Schedulable    *bool
-	Credentials    map[string]any
-	Extra          map[string]any
+	Name        *string
+	ProxyID     *int64
+	Concurrency *int
+	Priority    *int
+	Status      *string
+	Schedulable *bool
+	Credentials map[string]any
+	Extra       map[string]any
 }
 
 // CreateAccountRequest 创建账号请求