mirror of
https://github.com/EZ-Api/ez-api.git
synced 2026-01-13 17:47:51 +00:00
475 lines
15 KiB
Go
475 lines
15 KiB
Go
package api
|
|
|
|
import (
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ez-api/ez-api/internal/model"
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type LogView struct {
|
|
ID uint `json:"id"`
|
|
CreatedAt int64 `json:"created_at"`
|
|
Group string `json:"group"`
|
|
KeyID uint `json:"key_id"`
|
|
ModelName string `json:"model"`
|
|
ProviderID uint `json:"provider_id"`
|
|
ProviderType string `json:"provider_type"`
|
|
ProviderName string `json:"provider_name"`
|
|
StatusCode int `json:"status_code"`
|
|
LatencyMs int64 `json:"latency_ms"`
|
|
TokensIn int64 `json:"tokens_in"`
|
|
TokensOut int64 `json:"tokens_out"`
|
|
ErrorMessage string `json:"error_message"`
|
|
ClientIP string `json:"client_ip"`
|
|
RequestSize int64 `json:"request_size"`
|
|
ResponseSize int64 `json:"response_size"`
|
|
AuditReason string `json:"audit_reason"`
|
|
}
|
|
|
|
func toLogView(r model.LogRecord) LogView {
|
|
return LogView{
|
|
ID: r.ID,
|
|
CreatedAt: r.CreatedAt.UTC().Unix(),
|
|
Group: r.Group,
|
|
KeyID: r.KeyID,
|
|
ModelName: r.ModelName,
|
|
ProviderID: r.ProviderID,
|
|
ProviderType: r.ProviderType,
|
|
ProviderName: r.ProviderName,
|
|
StatusCode: r.StatusCode,
|
|
LatencyMs: r.LatencyMs,
|
|
TokensIn: r.TokensIn,
|
|
TokensOut: r.TokensOut,
|
|
ErrorMessage: r.ErrorMessage,
|
|
ClientIP: r.ClientIP,
|
|
RequestSize: r.RequestSize,
|
|
ResponseSize: r.ResponseSize,
|
|
AuditReason: r.AuditReason,
|
|
}
|
|
}
|
|
|
|
type MasterLogView struct {
|
|
ID uint `json:"id"`
|
|
CreatedAt int64 `json:"created_at"`
|
|
Group string `json:"group"`
|
|
KeyID uint `json:"key_id"`
|
|
ModelName string `json:"model"`
|
|
StatusCode int `json:"status_code"`
|
|
LatencyMs int64 `json:"latency_ms"`
|
|
TokensIn int64 `json:"tokens_in"`
|
|
TokensOut int64 `json:"tokens_out"`
|
|
ErrorMessage string `json:"error_message"`
|
|
RequestSize int64 `json:"request_size"`
|
|
ResponseSize int64 `json:"response_size"`
|
|
}
|
|
|
|
func toMasterLogView(r model.LogRecord) MasterLogView {
|
|
return MasterLogView{
|
|
ID: r.ID,
|
|
CreatedAt: r.CreatedAt.UTC().Unix(),
|
|
Group: r.Group,
|
|
KeyID: r.KeyID,
|
|
ModelName: r.ModelName,
|
|
StatusCode: r.StatusCode,
|
|
LatencyMs: r.LatencyMs,
|
|
TokensIn: r.TokensIn,
|
|
TokensOut: r.TokensOut,
|
|
ErrorMessage: r.ErrorMessage,
|
|
RequestSize: r.RequestSize,
|
|
ResponseSize: r.ResponseSize,
|
|
}
|
|
}
|
|
|
|
type ListLogsResponse struct {
|
|
Total int64 `json:"total"`
|
|
Limit int `json:"limit"`
|
|
Offset int `json:"offset"`
|
|
Items []LogView `json:"items"`
|
|
}
|
|
|
|
type ListMasterLogsResponse struct {
|
|
Total int64 `json:"total"`
|
|
Limit int `json:"limit"`
|
|
Offset int `json:"offset"`
|
|
Items []MasterLogView `json:"items"`
|
|
}
|
|
|
|
func parseLimitOffset(c *gin.Context) (limit, offset int) {
|
|
limit = 50
|
|
offset = 0
|
|
if raw := strings.TrimSpace(c.Query("limit")); raw != "" {
|
|
if v, err := strconv.Atoi(raw); err == nil && v > 0 {
|
|
limit = v
|
|
}
|
|
}
|
|
if limit > 200 {
|
|
limit = 200
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("offset")); raw != "" {
|
|
if v, err := strconv.Atoi(raw); err == nil && v >= 0 {
|
|
offset = v
|
|
}
|
|
}
|
|
return limit, offset
|
|
}
|
|
|
|
func parseUnixSeconds(raw string) (time.Time, bool) {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return time.Time{}, false
|
|
}
|
|
sec, err := strconv.ParseInt(raw, 10, 64)
|
|
if err != nil || sec <= 0 {
|
|
return time.Time{}, false
|
|
}
|
|
return time.Unix(sec, 0).UTC(), true
|
|
}
|
|
|
|
func (h *MasterHandler) masterLogBase(masterID uint) (*gorm.DB, error) {
|
|
logDB := h.logDBConn()
|
|
if logDB == h.db {
|
|
return logDB.Model(&model.LogRecord{}).
|
|
Joins("JOIN keys ON keys.id = log_records.key_id").
|
|
Where("keys.master_id = ?", masterID), nil
|
|
}
|
|
var keyIDs []uint
|
|
if err := h.db.Model(&model.Key{}).
|
|
Where("master_id = ?", masterID).
|
|
Pluck("id", &keyIDs).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
if len(keyIDs) == 0 {
|
|
return logDB.Model(&model.LogRecord{}).Where("1 = 0"), nil
|
|
}
|
|
return logDB.Model(&model.LogRecord{}).
|
|
Where("log_records.key_id IN ?", keyIDs), nil
|
|
}
|
|
|
|
// ListLogs godoc
|
|
// @Summary List logs (admin)
|
|
// @Description List request logs with basic filtering/pagination
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param limit query int false "limit (default 50, max 200)"
|
|
// @Param offset query int false "offset"
|
|
// @Param since query int false "unix seconds"
|
|
// @Param until query int false "unix seconds"
|
|
// @Param key_id query int false "key id"
|
|
// @Param group query string false "route group"
|
|
// @Param model query string false "model"
|
|
// @Param status_code query int false "status code"
|
|
// @Success 200 {object} ListMasterLogsResponse
|
|
// @Failure 500 {object} gin.H
|
|
// @Router /admin/logs [get]
|
|
func (h *Handler) ListLogs(c *gin.Context) {
|
|
limit, offset := parseLimitOffset(c)
|
|
|
|
q := h.logDBConn().Model(&model.LogRecord{})
|
|
|
|
if t, ok := parseUnixSeconds(c.Query("since")); ok {
|
|
q = q.Where("created_at >= ?", t)
|
|
}
|
|
if t, ok := parseUnixSeconds(c.Query("until")); ok {
|
|
q = q.Where("created_at <= ?", t)
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("key_id")); raw != "" {
|
|
if v, err := strconv.ParseUint(raw, 10, 64); err == nil && v > 0 {
|
|
q = q.Where("key_id = ?", uint(v))
|
|
}
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("group")); raw != "" {
|
|
q = q.Where(`"group" = ?`, raw)
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("model")); raw != "" {
|
|
q = q.Where("model_name = ?", raw)
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("status_code")); raw != "" {
|
|
if v, err := strconv.Atoi(raw); err == nil && v > 0 {
|
|
q = q.Where("status_code = ?", v)
|
|
}
|
|
}
|
|
|
|
var total int64
|
|
if err := q.Count(&total).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count logs", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
var rows []model.LogRecord
|
|
if err := q.Order("id desc").Limit(limit).Offset(offset).Find(&rows).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list logs", "details": err.Error()})
|
|
return
|
|
}
|
|
out := make([]MasterLogView, 0, len(rows))
|
|
for _, r := range rows {
|
|
out = append(out, toMasterLogView(r))
|
|
}
|
|
c.JSON(http.StatusOK, ListMasterLogsResponse{Total: total, Limit: limit, Offset: offset, Items: out})
|
|
}
|
|
|
|
type LogStatsResponse struct {
|
|
Total int64 `json:"total"`
|
|
TokensIn int64 `json:"tokens_in"`
|
|
TokensOut int64 `json:"tokens_out"`
|
|
AvgLatency float64 `json:"avg_latency_ms"`
|
|
ByStatus map[string]int64 `json:"by_status"`
|
|
}
|
|
|
|
type DeleteLogsRequest struct {
|
|
Before string `json:"before"`
|
|
KeyID uint `json:"key_id"`
|
|
Model string `json:"model"`
|
|
}
|
|
|
|
type DeleteLogsResponse struct {
|
|
DeletedCount int64 `json:"deleted_count"`
|
|
}
|
|
|
|
// DeleteLogs godoc
|
|
// @Summary Delete logs (admin)
|
|
// @Description Delete logs before a given timestamp with optional filters
|
|
// @Tags admin
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param request body DeleteLogsRequest true "Delete filters"
|
|
// @Success 200 {object} DeleteLogsResponse
|
|
// @Failure 400 {object} gin.H
|
|
// @Failure 500 {object} gin.H
|
|
// @Router /admin/logs [delete]
|
|
func (h *Handler) DeleteLogs(c *gin.Context) {
|
|
var req DeleteLogsRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body"})
|
|
return
|
|
}
|
|
|
|
before := strings.TrimSpace(req.Before)
|
|
if before == "" {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "before is required"})
|
|
return
|
|
}
|
|
ts, err := time.Parse(time.RFC3339, before)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid before time"})
|
|
return
|
|
}
|
|
|
|
q := h.logDBConn().Unscoped().Where("created_at < ?", ts.UTC())
|
|
if req.KeyID > 0 {
|
|
q = q.Where("key_id = ?", req.KeyID)
|
|
}
|
|
if model := strings.TrimSpace(req.Model); model != "" {
|
|
q = q.Where("model_name = ?", model)
|
|
}
|
|
|
|
res := q.Delete(&model.LogRecord{})
|
|
if res.Error != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete logs", "details": res.Error.Error()})
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, DeleteLogsResponse{DeletedCount: res.RowsAffected})
|
|
}
|
|
|
|
// LogStats godoc
|
|
// @Summary Log stats (admin)
|
|
// @Description Aggregate log stats with basic filtering
|
|
// @Tags admin
|
|
// @Produce json
|
|
// @Security AdminAuth
|
|
// @Param since query int false "unix seconds"
|
|
// @Param until query int false "unix seconds"
|
|
// @Success 200 {object} LogStatsResponse
|
|
// @Failure 500 {object} gin.H
|
|
// @Router /admin/logs/stats [get]
|
|
func (h *Handler) LogStats(c *gin.Context) {
|
|
q := h.logDBConn().Model(&model.LogRecord{})
|
|
if t, ok := parseUnixSeconds(c.Query("since")); ok {
|
|
q = q.Where("created_at >= ?", t)
|
|
}
|
|
if t, ok := parseUnixSeconds(c.Query("until")); ok {
|
|
q = q.Where("created_at <= ?", t)
|
|
}
|
|
|
|
var total int64
|
|
if err := q.Count(&total).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count logs", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
type sums struct {
|
|
TokensIn int64
|
|
TokensOut int64
|
|
AvgLatency float64
|
|
}
|
|
var s sums
|
|
if err := q.Select("COALESCE(SUM(tokens_in),0) as tokens_in, COALESCE(SUM(tokens_out),0) as tokens_out, COALESCE(AVG(latency_ms),0) as avg_latency").Scan(&s).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to aggregate logs", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
type bucket struct {
|
|
StatusCode int
|
|
Cnt int64
|
|
}
|
|
var buckets []bucket
|
|
if err := q.Select("status_code, COUNT(*) as cnt").Group("status_code").Scan(&buckets).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to bucket logs", "details": err.Error()})
|
|
return
|
|
}
|
|
byStatus := make(map[string]int64, len(buckets))
|
|
for _, b := range buckets {
|
|
byStatus[strconv.Itoa(b.StatusCode)] = b.Cnt
|
|
}
|
|
|
|
c.JSON(http.StatusOK, LogStatsResponse{
|
|
Total: total,
|
|
TokensIn: s.TokensIn,
|
|
TokensOut: s.TokensOut,
|
|
AvgLatency: s.AvgLatency,
|
|
ByStatus: byStatus,
|
|
})
|
|
}
|
|
|
|
// ListSelfLogs godoc
|
|
// @Summary List logs (master)
|
|
// @Description List request logs for the authenticated master
|
|
// @Tags master
|
|
// @Produce json
|
|
// @Security MasterAuth
|
|
// @Param limit query int false "limit (default 50, max 200)"
|
|
// @Param offset query int false "offset"
|
|
// @Param since query int false "unix seconds"
|
|
// @Param until query int false "unix seconds"
|
|
// @Param model query string false "model"
|
|
// @Param status_code query int false "status code"
|
|
// @Success 200 {object} ListMasterLogsResponse
|
|
// @Failure 401 {object} gin.H
|
|
// @Failure 500 {object} gin.H
|
|
// @Router /v1/logs [get]
|
|
func (h *MasterHandler) ListSelfLogs(c *gin.Context) {
|
|
master, exists := c.Get("master")
|
|
if !exists {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "master key not found in context"})
|
|
return
|
|
}
|
|
m := master.(*model.Master)
|
|
limit, offset := parseLimitOffset(c)
|
|
|
|
q, err := h.masterLogBase(m.ID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to build log query", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
if t, ok := parseUnixSeconds(c.Query("since")); ok {
|
|
q = q.Where("log_records.created_at >= ?", t)
|
|
}
|
|
if t, ok := parseUnixSeconds(c.Query("until")); ok {
|
|
q = q.Where("log_records.created_at <= ?", t)
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("model")); raw != "" {
|
|
q = q.Where("log_records.model_name = ?", raw)
|
|
}
|
|
if raw := strings.TrimSpace(c.Query("status_code")); raw != "" {
|
|
if v, err := strconv.Atoi(raw); err == nil && v > 0 {
|
|
q = q.Where("log_records.status_code = ?", v)
|
|
}
|
|
}
|
|
|
|
var total int64
|
|
if err := q.Count(&total).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count logs", "details": err.Error()})
|
|
return
|
|
}
|
|
var rows []model.LogRecord
|
|
if err := q.Order("log_records.id desc").Limit(limit).Offset(offset).Find(&rows).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to list logs", "details": err.Error()})
|
|
return
|
|
}
|
|
out := make([]MasterLogView, 0, len(rows))
|
|
for _, r := range rows {
|
|
out = append(out, toMasterLogView(r))
|
|
}
|
|
c.JSON(http.StatusOK, ListMasterLogsResponse{Total: total, Limit: limit, Offset: offset, Items: out})
|
|
}
|
|
|
|
// GetSelfLogStats godoc
|
|
// @Summary Log stats (master)
|
|
// @Description Aggregate request log stats for the authenticated master
|
|
// @Tags master
|
|
// @Produce json
|
|
// @Security MasterAuth
|
|
// @Param since query int false "unix seconds"
|
|
// @Param until query int false "unix seconds"
|
|
// @Success 200 {object} LogStatsResponse
|
|
// @Failure 401 {object} gin.H
|
|
// @Failure 500 {object} gin.H
|
|
// @Router /v1/logs/stats [get]
|
|
func (h *MasterHandler) GetSelfLogStats(c *gin.Context) {
|
|
master, exists := c.Get("master")
|
|
if !exists {
|
|
c.JSON(http.StatusUnauthorized, gin.H{"error": "master key not found in context"})
|
|
return
|
|
}
|
|
m := master.(*model.Master)
|
|
|
|
q, err := h.masterLogBase(m.ID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to build log query", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
if t, ok := parseUnixSeconds(c.Query("since")); ok {
|
|
q = q.Where("log_records.created_at >= ?", t)
|
|
}
|
|
if t, ok := parseUnixSeconds(c.Query("until")); ok {
|
|
q = q.Where("log_records.created_at <= ?", t)
|
|
}
|
|
|
|
var total int64
|
|
if err := q.Count(&total).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to count logs", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
type sums struct {
|
|
TokensIn int64
|
|
TokensOut int64
|
|
AvgLatency float64
|
|
}
|
|
var s sums
|
|
if err := q.Select("COALESCE(SUM(log_records.tokens_in),0) as tokens_in, COALESCE(SUM(log_records.tokens_out),0) as tokens_out, COALESCE(AVG(log_records.latency_ms),0) as avg_latency").Scan(&s).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to aggregate logs", "details": err.Error()})
|
|
return
|
|
}
|
|
|
|
type bucket struct {
|
|
StatusCode int
|
|
Cnt int64
|
|
}
|
|
var buckets []bucket
|
|
if err := q.Select("log_records.status_code as status_code, COUNT(*) as cnt").Group("log_records.status_code").Scan(&buckets).Error; err != nil {
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to bucket logs", "details": err.Error()})
|
|
return
|
|
}
|
|
byStatus := make(map[string]int64, len(buckets))
|
|
for _, b := range buckets {
|
|
byStatus[strconv.Itoa(b.StatusCode)] = b.Cnt
|
|
}
|
|
|
|
c.JSON(http.StatusOK, LogStatsResponse{
|
|
Total: total,
|
|
TokensIn: s.TokensIn,
|
|
TokensOut: s.TokensOut,
|
|
AvgLatency: s.AvgLatency,
|
|
ByStatus: byStatus,
|
|
})
|
|
}
|