Benson Wong
d3f329f924
Replace container/ring.Ring with a custom circularBuffer that uses a
single contiguous []byte slice. This fixes the original implementation
which created 10,240 ring elements instead of 10KB of storage.
GetHistory is now 139x faster (145μs → 1μs) and uses 117x less memory
(1.2MB → 10KB). Allocations reduced from 2 to 1 per write operation.
Create a LogMonitor per proxy.Process, replacing the usage
of a shared one. The buffer in LogMonitor is lazy allocated on the first
call to Write and freed when the Process is stopped. This reduces
unnecessary memory usage when a model is not active.
The /logs/stream/{model_id} endpoint was added to stream logs from a
specific process.
107 lines
2.3 KiB
Go
107 lines
2.3 KiB
Go
package proxy
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
func (pm *ProxyManager) sendLogsHandlers(c *gin.Context) {
|
|
accept := c.GetHeader("Accept")
|
|
if strings.Contains(accept, "text/html") {
|
|
c.Redirect(http.StatusFound, "/ui/")
|
|
} else {
|
|
c.Header("Content-Type", "text/plain")
|
|
history := pm.muxLogger.GetHistory()
|
|
_, err := c.Writer.Write(history)
|
|
if err != nil {
|
|
c.AbortWithError(http.StatusInternalServerError, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (pm *ProxyManager) streamLogsHandler(c *gin.Context) {
|
|
c.Header("Content-Type", "text/plain")
|
|
c.Header("Transfer-Encoding", "chunked")
|
|
c.Header("X-Content-Type-Options", "nosniff")
|
|
// prevent nginx from buffering streamed logs
|
|
c.Header("X-Accel-Buffering", "no")
|
|
|
|
logMonitorId := c.Param("logMonitorID")
|
|
logger, err := pm.getLogger(logMonitorId)
|
|
if err != nil {
|
|
c.String(http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
flusher, ok := c.Writer.(http.Flusher)
|
|
if !ok {
|
|
c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("streaming unsupported"))
|
|
return
|
|
}
|
|
|
|
_, skipHistory := c.GetQuery("no-history")
|
|
// Send history first if not skipped
|
|
|
|
if !skipHistory {
|
|
history := logger.GetHistory()
|
|
if len(history) != 0 {
|
|
c.Writer.Write(history)
|
|
flusher.Flush()
|
|
}
|
|
}
|
|
|
|
sendChan := make(chan []byte, 10)
|
|
ctx, cancel := context.WithCancel(c.Request.Context())
|
|
defer logger.OnLogData(func(data []byte) {
|
|
select {
|
|
case sendChan <- data:
|
|
case <-ctx.Done():
|
|
return
|
|
default:
|
|
}
|
|
})()
|
|
|
|
for {
|
|
select {
|
|
case <-c.Request.Context().Done():
|
|
cancel()
|
|
return
|
|
case <-pm.shutdownCtx.Done():
|
|
cancel()
|
|
return
|
|
case data := <-sendChan:
|
|
c.Writer.Write(data)
|
|
flusher.Flush()
|
|
}
|
|
}
|
|
}
|
|
|
|
// getLogger searches for the appropriate logger based on the logMonitorId
|
|
func (pm *ProxyManager) getLogger(logMonitorId string) (*LogMonitor, error) {
|
|
switch logMonitorId {
|
|
case "":
|
|
// maintain the default
|
|
return pm.muxLogger, nil
|
|
case "proxy":
|
|
return pm.proxyLogger, nil
|
|
case "upstream":
|
|
return pm.upstreamLogger, nil
|
|
default:
|
|
// search for a models specific logger
|
|
if name, found := pm.config.RealModelName(logMonitorId); found {
|
|
for _, group := range pm.processGroups {
|
|
if process, found := group.GetMember(name); found {
|
|
return process.Logger(), nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil, fmt.Errorf("invalid logger. Use 'proxy' or 'upstream'")
|
|
}
|
|
}
|