mirror of
https://github.com/Finesssee/ProxyPilot.git
synced 2026-11-18 18:04:20 +00:00
101 lines
2.7 KiB
Go
101 lines
2.7 KiB
Go
package routingdebug
|
|
|
|
import (
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
coreauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth"
|
|
)
|
|
|
|
// Entry captures a single routed request for local debugging.
|
|
// It is intentionally small and stored only in memory.
|
|
type Entry struct {
|
|
Timestamp time.Time `json:"timestamp"`
|
|
Method string `json:"method"`
|
|
Path string `json:"path"`
|
|
Client string `json:"client"`
|
|
UserAgent string `json:"user_agent"`
|
|
RequestedModel string `json:"requested_model"`
|
|
ResolvedModel string `json:"resolved_model"`
|
|
ProviderCandidates []string `json:"provider_candidates"`
|
|
SelectedProvider string `json:"selected_provider"`
|
|
SelectedAuthID string `json:"selected_auth_id"`
|
|
SelectedLabel string `json:"selected_label"`
|
|
SelectedAccount string `json:"selected_account"`
|
|
}
|
|
|
|
const maxEntries = 64
|
|
|
|
var (
|
|
mu sync.RWMutex
|
|
entries []Entry
|
|
)
|
|
|
|
// RecordFromContext appends a routing entry based on the Gin context and selection trace.
|
|
// It is safe to call even when ctx or trace are nil.
|
|
func RecordFromContext(c *gin.Context, requestedModel, resolvedModel string, providers []string, trace *coreauth.SelectionTrace) {
|
|
if c == nil {
|
|
return
|
|
}
|
|
|
|
clientIP := strings.TrimSpace(c.ClientIP())
|
|
ua := c.GetHeader("User-Agent")
|
|
method := ""
|
|
path := ""
|
|
if c.Request != nil {
|
|
method = c.Request.Method
|
|
path = c.FullPath()
|
|
if path == "" {
|
|
path = c.Request.URL.Path
|
|
}
|
|
}
|
|
|
|
provider, authID, label, masked := trace.Snapshot()
|
|
|
|
e := Entry{
|
|
Timestamp: time.Now().UTC(),
|
|
Method: method,
|
|
Path: path,
|
|
Client: clientIP,
|
|
UserAgent: ua,
|
|
RequestedModel: strings.TrimSpace(requestedModel),
|
|
ResolvedModel: strings.TrimSpace(resolvedModel),
|
|
ProviderCandidates: append([]string(nil), providers...),
|
|
SelectedProvider: strings.TrimSpace(provider),
|
|
SelectedAuthID: strings.TrimSpace(authID),
|
|
SelectedLabel: strings.TrimSpace(label),
|
|
SelectedAccount: strings.TrimSpace(masked),
|
|
}
|
|
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
|
|
// Append and trim to maxEntries (simple ring-buffer-like behaviour).
|
|
entries = append(entries, e)
|
|
if len(entries) > maxEntries {
|
|
offset := len(entries) - maxEntries
|
|
entries = append([]Entry(nil), entries[offset:]...)
|
|
}
|
|
}
|
|
|
|
// Snapshot returns a copy of the recent routing entries, newest first.
|
|
func Snapshot() []Entry {
|
|
mu.RLock()
|
|
defer mu.RUnlock()
|
|
|
|
if len(entries) == 0 {
|
|
return nil
|
|
}
|
|
|
|
out := make([]Entry, len(entries))
|
|
copy(out, entries)
|
|
|
|
// Reverse in-place so that callers get newest-first ordering.
|
|
for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
|
|
out[i], out[j] = out[j], out[i]
|
|
}
|
|
return out
|
|
}
|