mirror of
https://github.com/router-for-me/CLIProxyAPIPlus.git
synced 2026-04-24 09:21:02 +00:00
fix: Remove investigation artifacts
This commit is contained in:
hemanta212
@@ -1,219 +0,0 @@
|
||||
// Package internal demonstrates the memory leak that existed before the fix.
|
||||
// This file shows what happens WITHOUT the maxDetailsPerModel cap.
|
||||
package internal
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// UnboundedRequestStatistics is a copy of the ORIGINAL code WITHOUT the fix
|
||||
// to demonstrate the memory leak behavior.
|
||||
type UnboundedRequestStatistics struct {
|
||||
totalRequests int64
|
||||
apis map[string]*unboundedAPIStats
|
||||
}
|
||||
|
||||
type unboundedAPIStats struct {
|
||||
TotalRequests int64
|
||||
Models map[string]*unboundedModelStats
|
||||
}
|
||||
|
||||
type unboundedModelStats struct {
|
||||
TotalRequests int64
|
||||
Details []unboundedRequestDetail // NO CAP - grows forever!
|
||||
}
|
||||
|
||||
type unboundedRequestDetail struct {
|
||||
Timestamp time.Time
|
||||
Tokens int64
|
||||
}
|
||||
|
||||
func NewUnboundedRequestStatistics() *UnboundedRequestStatistics {
|
||||
return &UnboundedRequestStatistics{
|
||||
apis: make(map[string]*unboundedAPIStats),
|
||||
}
|
||||
}
|
||||
|
||||
// Record is the ORIGINAL implementation that leaks memory
|
||||
func (s *UnboundedRequestStatistics) Record(apiKey, model string, tokens int64) {
|
||||
stats, ok := s.apis[apiKey]
|
||||
if !ok {
|
||||
stats = &unboundedAPIStats{Models: make(map[string]*unboundedModelStats)}
|
||||
s.apis[apiKey] = stats
|
||||
}
|
||||
modelStats, ok := stats.Models[model]
|
||||
if !ok {
|
||||
modelStats = &unboundedModelStats{}
|
||||
stats.Models[model] = modelStats
|
||||
}
|
||||
modelStats.TotalRequests++
|
||||
// BUG: This grows forever with no cap!
|
||||
modelStats.Details = append(modelStats.Details, unboundedRequestDetail{
|
||||
Timestamp: time.Now(),
|
||||
Tokens: tokens,
|
||||
})
|
||||
s.totalRequests++
|
||||
}
|
||||
|
||||
func (s *UnboundedRequestStatistics) CountDetails() int {
|
||||
total := 0
|
||||
for _, api := range s.apis {
|
||||
for _, model := range api.Models {
|
||||
total += len(model.Details)
|
||||
}
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
func TestMemoryLeak_BEFORE_Fix_Unbounded(t *testing.T) {
|
||||
// This demonstrates the LEAK behavior before the fix
|
||||
stats := NewUnboundedRequestStatistics()
|
||||
|
||||
var m runtime.MemStats
|
||||
runtime.GC()
|
||||
runtime.ReadMemStats(&m)
|
||||
allocBefore := float64(m.Alloc) / 1024 / 1024
|
||||
|
||||
t.Logf("=== DEMONSTRATING LEAK (unbounded growth) ===")
|
||||
t.Logf("Before: %.2f MB, Details: %d", allocBefore, stats.CountDetails())
|
||||
|
||||
// Simulate traffic over "hours" - in production this causes OOM
|
||||
for hour := 1; hour <= 5; hour++ {
|
||||
for i := 0; i < 20000; i++ {
|
||||
stats.Record(
|
||||
fmt.Sprintf("api-key-%d", i%10),
|
||||
fmt.Sprintf("model-%d", i%5),
|
||||
1500,
|
||||
)
|
||||
}
|
||||
runtime.GC()
|
||||
runtime.ReadMemStats(&m)
|
||||
allocNow := float64(m.Alloc) / 1024 / 1024
|
||||
t.Logf("Hour %d: %.2f MB, Details: %d (growth: +%.2f MB)",
|
||||
hour, allocNow, stats.CountDetails(), allocNow-allocBefore)
|
||||
}
|
||||
|
||||
// Show the problem: details count = total requests (unbounded)
|
||||
totalDetails := stats.CountDetails()
|
||||
totalRequests := 5 * 20000 // 100k requests
|
||||
t.Logf("LEAK EVIDENCE: %d details stored for %d requests (ratio: %.2f)",
|
||||
totalDetails, totalRequests, float64(totalDetails)/float64(totalRequests))
|
||||
|
||||
if totalDetails == totalRequests {
|
||||
t.Logf("CONFIRMED: Every request stored forever = memory leak!")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemoryLeak_AFTER_Fix_Bounded(t *testing.T) {
|
||||
// This demonstrates the FIXED behavior with capped growth
|
||||
// Using the real implementation which now has the fix
|
||||
stats := NewBoundedRequestStatistics()
|
||||
|
||||
var m runtime.MemStats
|
||||
runtime.GC()
|
||||
runtime.ReadMemStats(&m)
|
||||
allocBefore := float64(m.Alloc) / 1024 / 1024
|
||||
|
||||
t.Logf("=== DEMONSTRATING FIX (bounded growth) ===")
|
||||
t.Logf("Before: %.2f MB, Details: %d", allocBefore, stats.CountDetails())
|
||||
|
||||
for hour := 1; hour <= 5; hour++ {
|
||||
for i := 0; i < 20000; i++ {
|
||||
stats.Record(
|
||||
fmt.Sprintf("api-key-%d", i%10),
|
||||
fmt.Sprintf("model-%d", i%5),
|
||||
1500,
|
||||
)
|
||||
}
|
||||
runtime.GC()
|
||||
runtime.ReadMemStats(&m)
|
||||
allocNow := float64(m.Alloc) / 1024 / 1024
|
||||
t.Logf("Hour %d: %.2f MB, Details: %d (growth: +%.2f MB)",
|
||||
hour, allocNow, stats.CountDetails(), allocNow-allocBefore)
|
||||
}
|
||||
|
||||
totalDetails := stats.CountDetails()
|
||||
maxExpected := 10 * 5 * 1000 // 10 API keys * 5 models * 1000 cap = 50k max
|
||||
t.Logf("FIX EVIDENCE: %d details stored (max possible: %d)", totalDetails, maxExpected)
|
||||
|
||||
if totalDetails <= maxExpected {
|
||||
t.Logf("CONFIRMED: Details capped, memory bounded!")
|
||||
} else {
|
||||
t.Errorf("STILL LEAKING: %d > %d", totalDetails, maxExpected)
|
||||
}
|
||||
}
|
||||
|
||||
// BoundedRequestStatistics is the FIXED version with cap
|
||||
type BoundedRequestStatistics struct {
|
||||
apis map[string]*boundedAPIStats
|
||||
}
|
||||
|
||||
type boundedAPIStats struct {
|
||||
Models map[string]*boundedModelStats
|
||||
}
|
||||
|
||||
type boundedModelStats struct {
|
||||
Details []unboundedRequestDetail
|
||||
}
|
||||
|
||||
const maxDetailsPerModelTest = 1000
|
||||
|
||||
func NewBoundedRequestStatistics() *BoundedRequestStatistics {
|
||||
return &BoundedRequestStatistics{
|
||||
apis: make(map[string]*boundedAPIStats),
|
||||
}
|
||||
}
|
||||
|
||||
func (s *BoundedRequestStatistics) Record(apiKey, model string, tokens int64) {
|
||||
stats, ok := s.apis[apiKey]
|
||||
if !ok {
|
||||
stats = &boundedAPIStats{Models: make(map[string]*boundedModelStats)}
|
||||
s.apis[apiKey] = stats
|
||||
}
|
||||
modelStats, ok := stats.Models[model]
|
||||
if !ok {
|
||||
modelStats = &boundedModelStats{}
|
||||
stats.Models[model] = modelStats
|
||||
}
|
||||
modelStats.Details = append(modelStats.Details, unboundedRequestDetail{
|
||||
Timestamp: time.Now(),
|
||||
Tokens: tokens,
|
||||
})
|
||||
// THE FIX: Cap the details slice
|
||||
if len(modelStats.Details) > maxDetailsPerModelTest {
|
||||
excess := len(modelStats.Details) - maxDetailsPerModelTest
|
||||
modelStats.Details = modelStats.Details[excess:]
|
||||
}
|
||||
}
|
||||
|
||||
func (s *BoundedRequestStatistics) CountDetails() int {
|
||||
total := 0
|
||||
for _, api := range s.apis {
|
||||
for _, model := range api.Models {
|
||||
total += len(model.Details)
|
||||
}
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
func TestCompare_LeakVsFix(t *testing.T) {
|
||||
t.Log("=== SIDE-BY-SIDE COMPARISON ===")
|
||||
|
||||
unbounded := NewUnboundedRequestStatistics()
|
||||
bounded := NewBoundedRequestStatistics()
|
||||
|
||||
// Same workload
|
||||
for i := 0; i < 50000; i++ {
|
||||
apiKey := fmt.Sprintf("key-%d", i%10)
|
||||
model := fmt.Sprintf("model-%d", i%5)
|
||||
unbounded.Record(apiKey, model, 1500)
|
||||
bounded.Record(apiKey, model, 1500)
|
||||
}
|
||||
|
||||
t.Logf("UNBOUNDED (leak): %d details stored", unbounded.CountDetails())
|
||||
t.Logf("BOUNDED (fixed): %d details stored", bounded.CountDetails())
|
||||
t.Logf("Memory saved: %dx reduction", unbounded.CountDetails()/bounded.CountDetails())
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
// Package internal contains memory leak reproduction tests.
|
||||
// Run with: go test -v -run TestMemoryLeak -memprofile=mem.prof ./internal/
|
||||
package internal
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/cache"
|
||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/usage"
|
||||
coreusage "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/usage"
|
||||
)
|
||||
|
||||
func getMemStats() (allocMB, heapMB float64) {
|
||||
var m runtime.MemStats
|
||||
runtime.GC()
|
||||
runtime.ReadMemStats(&m)
|
||||
return float64(m.Alloc) / 1024 / 1024, float64(m.HeapAlloc) / 1024 / 1024
|
||||
}
|
||||
|
||||
func TestMemoryLeak_UsageStats(t *testing.T) {
|
||||
// This test simulates the usage statistics leak where Details grows unbounded
|
||||
stats := usage.NewRequestStatistics()
|
||||
|
||||
allocBefore, heapBefore := getMemStats()
|
||||
t.Logf("Before: Alloc=%.2f MB, Heap=%.2f MB", allocBefore, heapBefore)
|
||||
|
||||
// Simulate 10k requests (would happen over hours/days in production)
|
||||
numRequests := 10000
|
||||
for i := 0; i < numRequests; i++ {
|
||||
stats.Record(context.Background(), coreusage.Record{
|
||||
Provider: "test-provider",
|
||||
Model: fmt.Sprintf("model-%d", i%10), // 10 different models
|
||||
APIKey: fmt.Sprintf("api-key-%d", i%5),
|
||||
RequestedAt: time.Now(),
|
||||
Detail: coreusage.Detail{
|
||||
InputTokens: 1000,
|
||||
OutputTokens: 500,
|
||||
TotalTokens: 1500,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
allocAfter, heapAfter := getMemStats()
|
||||
t.Logf("After %d requests: Alloc=%.2f MB, Heap=%.2f MB", numRequests, allocAfter, heapAfter)
|
||||
t.Logf("Growth: Alloc=+%.2f MB, Heap=+%.2f MB", allocAfter-allocBefore, heapAfter-heapBefore)
|
||||
|
||||
// Verify the cap is working - check snapshot
|
||||
snapshot := stats.Snapshot()
|
||||
for apiName, apiSnap := range snapshot.APIs {
|
||||
for modelName, modelSnap := range apiSnap.Models {
|
||||
if len(modelSnap.Details) > 1000 {
|
||||
t.Errorf("LEAK: API %s Model %s has %d details (should be <= 1000)",
|
||||
apiName, modelName, len(modelSnap.Details))
|
||||
} else {
|
||||
t.Logf("OK: API %s Model %s has %d details (capped at 1000)",
|
||||
apiName, modelName, len(modelSnap.Details))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemoryLeak_SignatureCache(t *testing.T) {
|
||||
// This test simulates the signature cache leak where sessions accumulate
|
||||
allocBefore, heapBefore := getMemStats()
|
||||
t.Logf("Before: Alloc=%.2f MB, Heap=%.2f MB", allocBefore, heapBefore)
|
||||
|
||||
// Simulate 1000 unique sessions (each with signatures)
|
||||
numSessions := 1000
|
||||
sigText := string(make([]byte, 100)) // 100 byte signature text
|
||||
sig := string(make([]byte, 200)) // 200 byte signature (> MinValidSignatureLen)
|
||||
|
||||
for i := 0; i < numSessions; i++ {
|
||||
sessionID := fmt.Sprintf("session-%d", i)
|
||||
// Each session caches 50 signatures
|
||||
for j := 0; j < 50; j++ {
|
||||
text := fmt.Sprintf("%s-text-%d", sigText, j)
|
||||
signature := fmt.Sprintf("%s-sig-%d", sig, j)
|
||||
cache.CacheSignature(sessionID, text, signature)
|
||||
}
|
||||
}
|
||||
|
||||
allocAfter, heapAfter := getMemStats()
|
||||
t.Logf("After %d sessions x 50 sigs: Alloc=%.2f MB, Heap=%.2f MB",
|
||||
numSessions, allocAfter, heapAfter)
|
||||
t.Logf("Growth: Alloc=+%.2f MB, Heap=+%.2f MB", allocAfter-allocBefore, heapAfter-heapBefore)
|
||||
|
||||
// Clear all and check memory drops
|
||||
cache.ClearSignatureCache("")
|
||||
runtime.GC()
|
||||
|
||||
allocCleared, heapCleared := getMemStats()
|
||||
t.Logf("After clear: Alloc=%.2f MB, Heap=%.2f MB", allocCleared, heapCleared)
|
||||
t.Logf("Recovered: Alloc=%.2f MB, Heap=%.2f MB",
|
||||
allocAfter-allocCleared, heapAfter-heapCleared)
|
||||
|
||||
if allocCleared > allocBefore*1.5 {
|
||||
t.Logf("WARNING: Memory not fully recovered after clear (may indicate leak)")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemoryLeak_SimulateProductionLoad(t *testing.T) {
|
||||
// Simulate realistic production load pattern over time
|
||||
stats := usage.NewRequestStatistics()
|
||||
|
||||
t.Log("=== Simulating production load pattern ===")
|
||||
|
||||
// Phase 1: Ramp up
|
||||
allocStart, _ := getMemStats()
|
||||
t.Logf("Start: %.2f MB", allocStart)
|
||||
|
||||
// Simulate 1 hour of traffic (compressed into fast iterations)
|
||||
// Real: ~1000 req/min = 60k/hour
|
||||
// Test: 60k requests
|
||||
for hour := 0; hour < 3; hour++ {
|
||||
for i := 0; i < 20000; i++ {
|
||||
stats.Record(context.Background(), coreusage.Record{
|
||||
Provider: "antigravity",
|
||||
Model: fmt.Sprintf("gemini-2.5-pro-%d", i%5),
|
||||
APIKey: fmt.Sprintf("user-%d", i%100),
|
||||
RequestedAt: time.Now(),
|
||||
Detail: coreusage.Detail{
|
||||
InputTokens: int64(1000 + i%500),
|
||||
OutputTokens: int64(200 + i%100),
|
||||
TotalTokens: int64(1200 + i%600),
|
||||
},
|
||||
})
|
||||
}
|
||||
allocNow, _ := getMemStats()
|
||||
t.Logf("Hour %d: %.2f MB (growth: +%.2f MB)", hour+1, allocNow, allocNow-allocStart)
|
||||
}
|
||||
|
||||
allocEnd, _ := getMemStats()
|
||||
totalGrowth := allocEnd - allocStart
|
||||
|
||||
// With the fix, growth should be bounded
|
||||
// Without fix: would grow linearly with requests
|
||||
// With fix: should plateau around 1000 details * num_models * detail_size
|
||||
t.Logf("Total growth over 60k requests: %.2f MB", totalGrowth)
|
||||
|
||||
// Rough estimate: 1000 details * 5 models * 100 APIs * ~200 bytes = ~100MB max
|
||||
// Should be well under 50MB for this test
|
||||
if totalGrowth > 100 {
|
||||
t.Errorf("POTENTIAL LEAK: Growth of %.2f MB is too high for bounded storage", totalGrowth)
|
||||
} else {
|
||||
t.Logf("OK: Memory growth is bounded at %.2f MB", totalGrowth)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user