diff options
| -rw-r--r-- | go.mod | 2 | ||||
| -rw-r--r-- | util/sys/sys_darwin.go | 71 | ||||
| -rw-r--r-- | util/sys/sys_linux.go | 100 | ||||
| -rw-r--r-- | util/sys/sys_windows.go | 81 | ||||
| -rw-r--r-- | web/controller/server.go | 32 | ||||
| -rw-r--r-- | web/html/index.html | 262 | ||||
| -rw-r--r-- | web/service/server.go | 150 |
7 files changed, 691 insertions, 7 deletions
@@ -21,6 +21,7 @@ require ( github.com/xtls/xray-core v1.250911.0 go.uber.org/atomic v1.11.0 golang.org/x/crypto v0.42.0 + golang.org/x/sys v0.36.0 golang.org/x/text v0.29.0 google.golang.org/grpc v1.75.1 gorm.io/driver/sqlite v1.6.0 @@ -89,7 +90,6 @@ require ( golang.org/x/mod v0.28.0 // indirect golang.org/x/net v0.44.0 // indirect golang.org/x/sync v0.17.0 // indirect - golang.org/x/sys v0.36.0 // indirect golang.org/x/time v0.13.0 // indirect golang.org/x/tools v0.36.0 // indirect golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 // indirect diff --git a/util/sys/sys_darwin.go b/util/sys/sys_darwin.go index 3f5b2072..6ecc78c0 100644 --- a/util/sys/sys_darwin.go +++ b/util/sys/sys_darwin.go @@ -4,7 +4,12 @@ package sys import ( + "encoding/binary" + "fmt" + "sync" + "github.com/shirou/gopsutil/v4/net" + "golang.org/x/sys/unix" ) func GetTCPCount() (int, error) { @@ -22,3 +27,69 @@ func GetUDPCount() (int, error) { } return len(stats), nil } + +// --- CPU Utilization (macOS native) --- + +// sysctl kern.cp_time returns an array of 5 longs: user, nice, sys, idle, intr. +// We compute utilization deltas without cgo. +var ( + cpuMu sync.Mutex + lastTotals [5]uint64 + hasLastCPUT bool +) + +func CPUPercentRaw() (float64, error) { + raw, err := unix.SysctlRaw("kern.cp_time") + if err != nil { + return 0, err + } + // Expect either 5*8 bytes (uint64) or 5*4 bytes (uint32) + var out [5]uint64 + switch len(raw) { + case 5 * 8: + for i := 0; i < 5; i++ { + out[i] = binary.LittleEndian.Uint64(raw[i*8 : (i+1)*8]) + } + case 5 * 4: + for i := 0; i < 5; i++ { + out[i] = uint64(binary.LittleEndian.Uint32(raw[i*4 : (i+1)*4])) + } + default: + return 0, fmt.Errorf("unexpected kern.cp_time size: %d", len(raw)) + } + + // user, nice, sys, idle, intr + user := out[0] + nice := out[1] + sysv := out[2] + idle := out[3] + intr := out[4] + + cpuMu.Lock() + defer cpuMu.Unlock() + + if !hasLastCPUT { + lastTotals = out + hasLastCPUT = true + return 0, nil + } + + dUser := user - lastTotals[0] + dNice := nice - lastTotals[1] + dSys := sysv - lastTotals[2] + dIdle := idle - lastTotals[3] + dIntr := intr - lastTotals[4] + + lastTotals = out + + totald := dUser + dNice + dSys + dIdle + dIntr + if totald == 0 { + return 0, nil + } + busy := totald - dIdle + pct := float64(busy) / float64(totald) * 100.0 + if pct > 100 { + pct = 100 + } + return pct, nil +} diff --git a/util/sys/sys_linux.go b/util/sys/sys_linux.go index d4e6e8ae..8a494d62 100644 --- a/util/sys/sys_linux.go +++ b/util/sys/sys_linux.go @@ -4,10 +4,14 @@ package sys import ( + "bufio" "bytes" "fmt" "io" "os" + "strconv" + "strings" + "sync" ) func getLinesNum(filename string) (int, error) { @@ -79,3 +83,99 @@ func safeGetLinesNum(path string) (int, error) { } return getLinesNum(path) } + +// --- CPU Utilization (Linux native) --- + +var ( + cpuMu sync.Mutex + lastTotal uint64 + lastIdleAll uint64 + hasLast bool +) + +// CPUPercentRaw returns instantaneous total CPU utilization by reading /proc/stat. +// First call initializes and returns 0; subsequent calls return busy/total * 100. +func CPUPercentRaw() (float64, error) { + f, err := os.Open("/proc/stat") + if err != nil { + return 0, err + } + defer f.Close() + + rd := bufio.NewReader(f) + line, err := rd.ReadString('\n') + if err != nil && err != io.EOF { + return 0, err + } + // Expect line like: cpu user nice system idle iowait irq softirq steal guest guest_nice + fields := strings.Fields(line) + if len(fields) < 5 || fields[0] != "cpu" { + return 0, fmt.Errorf("unexpected /proc/stat format") + } + + var nums []uint64 + for i := 1; i < len(fields); i++ { + v, err := strconv.ParseUint(fields[i], 10, 64) + if err != nil { + break + } + nums = append(nums, v) + } + if len(nums) < 4 { // need at least user,nice,system,idle + return 0, fmt.Errorf("insufficient cpu fields") + } + + // Conform with standard Linux CPU accounting + var user, nice, system, idle, iowait, irq, softirq, steal uint64 + user = nums[0] + if len(nums) > 1 { + nice = nums[1] + } + if len(nums) > 2 { + system = nums[2] + } + if len(nums) > 3 { + idle = nums[3] + } + if len(nums) > 4 { + iowait = nums[4] + } + if len(nums) > 5 { + irq = nums[5] + } + if len(nums) > 6 { + softirq = nums[6] + } + if len(nums) > 7 { + steal = nums[7] + } + + idleAll := idle + iowait + nonIdle := user + nice + system + irq + softirq + steal + total := idleAll + nonIdle + + cpuMu.Lock() + defer cpuMu.Unlock() + + if !hasLast { + lastTotal = total + lastIdleAll = idleAll + hasLast = true + return 0, nil + } + + totald := total - lastTotal + idled := idleAll - lastIdleAll + lastTotal = total + lastIdleAll = idleAll + + if totald == 0 { + return 0, nil + } + busy := totald - idled + pct := float64(busy) / float64(totald) * 100.0 + if pct > 100 { + pct = 100 + } + return pct, nil +} diff --git a/util/sys/sys_windows.go b/util/sys/sys_windows.go index fd51d470..f3eae076 100644 --- a/util/sys/sys_windows.go +++ b/util/sys/sys_windows.go @@ -5,6 +5,9 @@ package sys import ( "errors" + "sync" + "syscall" + "unsafe" "github.com/shirou/gopsutil/v4/net" ) @@ -28,3 +31,81 @@ func GetTCPCount() (int, error) { func GetUDPCount() (int, error) { return GetConnectionCount("udp") } + +// --- CPU Utilization (Windows native) --- + +var ( + modKernel32 = syscall.NewLazyDLL("kernel32.dll") + procGetSystemTimes = modKernel32.NewProc("GetSystemTimes") + + cpuMu sync.Mutex + lastIdle uint64 + lastKernel uint64 + lastUser uint64 + hasLast bool +) + +type filetime struct { + LowDateTime uint32 + HighDateTime uint32 +} + +func ftToUint64(ft filetime) uint64 { + return (uint64(ft.HighDateTime) << 32) | uint64(ft.LowDateTime) +} + +// CPUPercentRaw returns the instantaneous total CPU utilization percentage using +// Windows GetSystemTimes across all logical processors. The first call returns 0 +// as it initializes the baseline. Subsequent calls compute deltas. +func CPUPercentRaw() (float64, error) { + var idleFT, kernelFT, userFT filetime + r1, _, e1 := procGetSystemTimes.Call( + uintptr(unsafe.Pointer(&idleFT)), + uintptr(unsafe.Pointer(&kernelFT)), + uintptr(unsafe.Pointer(&userFT)), + ) + if r1 == 0 { // failure + if e1 != nil { + return 0, e1 + } + return 0, syscall.GetLastError() + } + + idle := ftToUint64(idleFT) + kernel := ftToUint64(kernelFT) + user := ftToUint64(userFT) + + cpuMu.Lock() + defer cpuMu.Unlock() + + if !hasLast { + lastIdle = idle + lastKernel = kernel + lastUser = user + hasLast = true + return 0, nil + } + + idleDelta := idle - lastIdle + kernelDelta := kernel - lastKernel + userDelta := user - lastUser + + // Update for next call + lastIdle = idle + lastKernel = kernel + lastUser = user + + total := kernelDelta + userDelta + if total == 0 { + return 0, nil + } + // On Windows, kernel time includes idle time; busy = total - idle + busy := total - idleDelta + + pct := float64(busy) / float64(total) * 100.0 + // lower bound not needed; ratios of uint64 are non-negative + if pct > 100 { + pct = 100 + } + return pct, nil +} diff --git a/web/controller/server.go b/web/controller/server.go index d5ae688b..3b93afd9 100644 --- a/web/controller/server.go +++ b/web/controller/server.go @@ -4,6 +4,7 @@ import ( "fmt" "net/http" "regexp" + "strconv" "time" "x-ui/web/global" @@ -39,6 +40,7 @@ func NewServerController(g *gin.RouterGroup) *ServerController { func (a *ServerController) initRouter(g *gin.RouterGroup) { g.GET("/status", a.status) + g.GET("/cpuHistory", a.getCpuHistory) g.GET("/getXrayVersion", a.getXrayVersion) g.GET("/getConfigJson", a.getConfigJson) g.GET("/getDb", a.getDb) @@ -61,16 +63,18 @@ func (a *ServerController) initRouter(g *gin.RouterGroup) { func (a *ServerController) refreshStatus() { a.lastStatus = a.serverService.GetStatus(a.lastStatus) + // collect cpu history when status is fresh + if a.lastStatus != nil { + a.serverService.AppendCpuSample(time.Now(), a.lastStatus.Cpu) + } } func (a *ServerController) startTask() { webServer := global.GetWebServer() c := webServer.GetCron() c.AddFunc("@every 2s", func() { - now := time.Now() - if now.Sub(a.lastGetStatusTime) > time.Minute*3 { - return - } + // Always refresh to keep CPU history collected continuously. + // Sampling is lightweight and capped to ~6 hours in memory. a.refreshStatus() }) } @@ -81,6 +85,26 @@ func (a *ServerController) status(c *gin.Context) { jsonObj(c, a.lastStatus, nil) } +// getCpuHistory returns recent CPU utilization points. +// Query param q=minutes (int). Bounds: 1..360 (6 hours). Defaults to 60. +func (a *ServerController) getCpuHistory(c *gin.Context) { + minsStr := c.Query("q") + mins := 60 + if minsStr != "" { + if v, err := strconv.Atoi(minsStr); err == nil { + mins = v + } + } + if mins < 1 { + mins = 1 + } + if mins > 360 { + mins = 360 + } + res := a.serverService.GetCpuHistory(mins) + jsonObj(c, res, nil) +} + func (a *ServerController) getXrayVersion(c *gin.Context) { now := time.Now() if now.Sub(a.lastGetVersionsTime) <= time.Minute { diff --git a/web/html/index.html b/web/html/index.html index 2ff8db3e..b6a9993e 100644 --- a/web/html/index.html +++ b/web/html/index.html @@ -41,6 +41,11 @@ <div><b>{{ i18n "pages.index.frequency" }}:</b> [[ CPUFormatter.cpuSpeedFormat(status.cpuSpeedMhz) ]]</div> </template> </a-tooltip> + <a-tooltip :overlay-class-name="themeSwitcher.currentTheme"> + <a-button size="small" type="default" class="ml-8" @click="openCpuHistory()"> + <a-icon type="history" /> + </a-button> + </a-tooltip> </div> </a-col> <a-col :span="12" class="text-center"> @@ -423,6 +428,36 @@ </a-list-item> </a-list> </a-modal> + <!-- CPU History Modal --> + <a-modal id="cpu-history-modal" + v-model="cpuHistoryModal.visible" + :closable="true" @cancel="() => cpuHistoryModal.visible = false" + :class="themeSwitcher.currentTheme" + width="900px" footer=""> + <template slot="title"> + CPU History + <a-select size="small" v-model="cpuHistoryModal.minutes" class="ml-10" style="width: 120px" @change="loadCpuHistory"> + <a-select-option :value="15">15 min</a-select-option> + <a-select-option :value="60">1 hour</a-select-option> + <a-select-option :value="180">3 hours</a-select-option> + <a-select-option :value="360">6 hours</a-select-option> + </a-select> + </template> + <div style="padding: 8px 0;"> + <sparkline :data="cpuHistoryLong" + :labels="cpuHistoryLabels" + :vb-width="840" + :height="220" + :stroke="status.cpu.color" + :stroke-width="2.2" + :show-grid="true" + :show-axes="true" + :tick-count-x="5" + :fill-opacity="0.18" + :marker-radius="3.2" + :show-tooltip="true" /> + </div> + </a-modal> </a-layout> {{template "page/body_scripts" .}} {{template "component/aSidebar" .}} @@ -430,6 +465,190 @@ {{template "component/aCustomStatistic" .}} {{template "modals/textModal"}} <script> + // Tiny Sparkline component using an inline SVG polyline + Vue.component('sparkline', { + props: { + data: { type: Array, required: true }, + // viewBox width for drawing space; SVG width will be 100% of container + vbWidth: { type: Number, default: 320 }, + height: { type: Number, default: 80 }, + stroke: { type: String, default: '#008771' }, + strokeWidth: { type: Number, default: 2 }, + maxPoints: { type: Number, default: 120 }, + showGrid: { type: Boolean, default: true }, + gridColor: { type: String, default: 'rgba(255,255,255,0.08)' }, + fillOpacity: { type: Number, default: 0.15 }, + showMarker: { type: Boolean, default: true }, + markerRadius: { type: Number, default: 2.8 }, + // New opts for axes/labels/tooltip + labels: { type: Array, default: () => [] }, // same length as data for x labels (e.g., timestamps) + showAxes: { type: Boolean, default: false }, + yTickStep: { type: Number, default: 25 }, // percent ticks + tickCountX: { type: Number, default: 4 }, + paddingLeft: { type: Number, default: 32 }, + paddingRight: { type: Number, default: 6 }, + paddingTop: { type: Number, default: 6 }, + paddingBottom: { type: Number, default: 20 }, + showTooltip: { type: Boolean, default: false }, + }, + data() { + return { + hoverIdx: -1, + } + }, + computed: { + viewBoxAttr() { + return '0 0 ' + this.vbWidth + ' ' + this.height + }, + drawWidth() { + return Math.max(1, this.vbWidth - this.paddingLeft - this.paddingRight) + }, + drawHeight() { + return Math.max(1, this.height - this.paddingTop - this.paddingBottom) + }, + nPoints() { + return Math.min(this.data.length, this.maxPoints) + }, + dataSlice() { + const n = this.nPoints + if (n === 0) return [] + return this.data.slice(this.data.length - n) + }, + labelsSlice() { + const n = this.nPoints + if (!this.labels || this.labels.length === 0 || n === 0) return [] + const start = Math.max(0, this.labels.length - n) + return this.labels.slice(start) + }, + pointsArr() { + const n = this.nPoints + if (n === 0) return [] + const slice = this.dataSlice + const max = 100 + const w = this.drawWidth + const h = this.drawHeight + const dx = n > 1 ? w / (n - 1) : 0 + return slice.map((v, i) => { + const x = Math.round(this.paddingLeft + i * dx) + const y = Math.round(this.paddingTop + (h - (Math.max(0, Math.min(100, v)) / max) * h)) + return [x, y] + }) + }, + points() { + return this.pointsArr.map(p => `${p[0]},${p[1]}`).join(' ') + }, + areaPath() { + if (this.pointsArr.length === 0) return '' + const first = this.pointsArr[0] + const last = this.pointsArr[this.pointsArr.length - 1] + const line = this.points + // Close to bottom to create an area fill + return `M ${first[0]},${this.paddingTop + this.drawHeight} L ${line.replace(/ /g,' L ')} L ${last[0]},${this.paddingTop + this.drawHeight} Z` + }, + gridLines() { + if (!this.showGrid) return [] + const h = this.drawHeight + const w = this.drawWidth + // draw at 25%, 50%, 75% + return [0.25, 0.5, 0.75] + .map(r => Math.round(this.paddingTop + h * r)) + .map(y => ({ x1: this.paddingLeft, y1: y, x2: this.paddingLeft + w, y2: y })) + }, + lastPoint() { + if (this.pointsArr.length === 0) return null + return this.pointsArr[this.pointsArr.length - 1] + }, + yTicks() { + if (!this.showAxes) return [] + const step = Math.max(1, this.yTickStep) + const ticks = [] + for (let p = 0; p <= 100; p += step) { + const y = Math.round(this.paddingTop + (this.drawHeight - (p / 100) * this.drawHeight)) + ticks.push({ y, label: `${p}%` }) + } + return ticks + }, + xTicks() { + if (!this.showAxes) return [] + const labels = this.labelsSlice + const n = this.nPoints + const m = Math.max(2, this.tickCountX) + const ticks = [] + if (n === 0) return ticks + const w = this.drawWidth + const dx = n > 1 ? w / (n - 1) : 0 + const positions = [] + for (let i = 0; i < m; i++) { + const idx = Math.round((i * (n - 1)) / (m - 1)) + positions.push(idx) + } + positions.forEach(idx => { + const label = labels[idx] != null ? String(labels[idx]) : String(idx) + const x = Math.round(this.paddingLeft + idx * dx) + ticks.push({ x, label }) + }) + return ticks + }, + }, + methods: { + onMouseMove(evt) { + if (!this.showTooltip || this.pointsArr.length === 0) return + const rect = evt.currentTarget.getBoundingClientRect() + const px = evt.clientX - rect.left + // translate to viewBox space + const x = (px / rect.width) * this.vbWidth + const n = this.nPoints + const dx = n > 1 ? this.drawWidth / (n - 1) : 0 + const idx = Math.max(0, Math.min(n - 1, Math.round((x - this.paddingLeft) / (dx || 1)))) + this.hoverIdx = idx + }, + onMouseLeave() { + this.hoverIdx = -1 + }, + fmtHoverText() { + const labels = this.labelsSlice + const idx = this.hoverIdx + if (idx < 0 || idx >= this.dataSlice.length) return '' + const val = Math.max(0, Math.min(100, Number(this.dataSlice[idx] || 0))) + const lab = labels[idx] != null ? labels[idx] : '' + return `${val}%${lab ? ' • ' + lab : ''}` + }, + }, + template: ` + <svg width="100%" :height="height" :viewBox="viewBoxAttr" preserveAspectRatio="none" style="display:block" + @mousemove="onMouseMove" @mouseleave="onMouseLeave"> + <defs> + <linearGradient id="spkGrad" x1="0" y1="0" x2="0" y2="1"> + <stop offset="0%" :stop-color="stroke" :stop-opacity="fillOpacity"/> + <stop offset="100%" :stop-color="stroke" stop-opacity="0"/> + </linearGradient> + </defs> + <g v-if="showGrid"> + <line v-for="(g,i) in gridLines" :key="i" :x1="g.x1" :y1="g.y1" :x2="g.x2" :y2="g.y2" :stroke="gridColor" stroke-width="1"/> + </g> + <g v-if="showAxes"> + <!-- Y ticks/labels --> + <g v-for="(t,i) in yTicks" :key="'y'+i"> + <text :x="Math.max(0, paddingLeft - 4)" :y="t.y + 4" text-anchor="end" font-size="10" fill="rgba(200,200,200,0.8)" v-text="t.label"></text> + </g> + <!-- X ticks/labels --> + <g v-for="(t,i) in xTicks" :key="'x'+i"> + <text :x="t.x" :y="paddingTop + drawHeight + 14" text-anchor="middle" font-size="10" fill="rgba(200,200,200,0.8)" v-text="t.label"></text> + </g> + </g> + <path v-if="areaPath" :d="areaPath" fill="url(#spkGrad)" stroke="none" /> + <polyline :points="points" fill="none" :stroke="stroke" :stroke-width="strokeWidth" stroke-linecap="round" stroke-linejoin="round"/> + <circle v-if="showMarker && lastPoint" :cx="lastPoint[0]" :cy="lastPoint[1]" :r="markerRadius" :fill="stroke" /> + <!-- Hover marker/tooltip --> + <g v-if="showTooltip && hoverIdx >= 0"> + <line :x1="pointsArr[hoverIdx][0]" :x2="pointsArr[hoverIdx][0]" :y1="paddingTop" :y2="paddingTop + drawHeight" stroke="rgba(255,255,255,0.25)" stroke-width="1" /> + <circle :cx="pointsArr[hoverIdx][0]" :cy="pointsArr[hoverIdx][1]" r="3.5" :fill="stroke" /> + <text :x="pointsArr[hoverIdx][0]" :y="paddingTop + 12" text-anchor="middle" font-size="11" fill="#fff" style="paint-order: stroke; stroke: rgba(0,0,0,0.35); stroke-width: 3;" v-text="fmtHoverText()"></text> + </g> + </svg> + `, + }) + class CurTotal { constructor(current, total) { @@ -659,6 +878,10 @@ ${dateTime} spinning: false }, status: new Status(), + cpuHistory: [], // keep last N cpu utilization points (0..100) + cpuHistoryLong: [], // long-range history for modal (values) + cpuHistoryLabels: [], // formatted timestamps matching long history + cpuHistoryModal: { visible: false, minutes: 60 }, versionModal, logModal, xraylogModal, @@ -689,7 +912,46 @@ ${dateTime} }, setStatus(data) { this.status = new Status(data); + // Push CPU percent into history (clamped 0..100) + const v = Math.max(0, Math.min(100, Number(data?.cpu ?? 0))) + this.cpuHistory.push(v) + const maxPoints = this.isMobile ? 60 : 120 + if (this.cpuHistory.length > maxPoints) { + this.cpuHistory.splice(0, this.cpuHistory.length - maxPoints) + } }, + openCpuHistory() { + this.cpuHistoryModal.visible = true + this.loadCpuHistory() + }, + async loadCpuHistory() { + const mins = this.cpuHistoryModal.minutes || 60 + try { + const msg = await HttpUtil.get(`/panel/api/server/cpuHistory?q=${mins}`) + if (msg.success && Array.isArray(msg.obj)) { + // msg.obj is array of {t, cpu} + const arr = msg.obj.map(p => Math.max(0, Math.min(100, Number(p.cpu || 0)))) + const labels = msg.obj.map(p => { + const t = p.t + let d + if (typeof t === 'number') { + // Heuristic: if seconds, convert to ms + d = new Date(t < 1e12 ? t * 1000 : t) + } else { + d = new Date(t) + } + if (isNaN(d.getTime())) return '' + const hh = String(d.getHours()).padStart(2, '0') + const mm = String(d.getMinutes()).padStart(2, '0') + return `${hh}:${mm}` + }) + this.cpuHistoryLong = arr + this.cpuHistoryLabels = labels + } + } catch (e) { + console.error('Failed to load CPU history', e) + } + }, async openSelectV2rayVersion() { this.loading(true); const msg = await HttpUtil.get('/panel/api/server/getXrayVersion'); diff --git a/web/service/server.go b/web/service/server.go index 85af5597..de6cc7f5 100644 --- a/web/service/server.go +++ b/web/service/server.go @@ -16,6 +16,7 @@ import ( "runtime" "strconv" "strings" + "sync" "time" "x-ui/config" @@ -98,6 +99,20 @@ type ServerService struct { cachedIPv4 string cachedIPv6 string noIPv6 bool + // CPU utilization smoothing state + mu sync.Mutex + lastCPUTimes cpu.TimesStat + hasLastCPUSample bool + emaCPU float64 + // CPU history buffer (in-memory, protected by mu) + cpuHistory []CPUSample + cpuCapacity int +} + +// CPUSample represents a single CPU utilization sample with timestamp +type CPUSample struct { + T int64 `json:"t"` // unix seconds + Cpu float64 `json:"cpu"` // percent 0..100 } func getPublicIP(url string) string { @@ -139,11 +154,11 @@ func (s *ServerService) GetStatus(lastStatus *Status) *Status { } // CPU stats - percents, err := cpu.Percent(0, false) + util, err := s.sampleCPUUtilization() if err != nil { logger.Warning("get cpu percent failed:", err) } else { - status.Cpu = percents[0] + status.Cpu = util } status.CpuCores, err = cpu.Counts(false) @@ -307,6 +322,137 @@ func (s *ServerService) GetStatus(lastStatus *Status) *Status { return status } +// AppendCpuSample appends a CPU sample into the in-memory history with capacity trimming. +func (s *ServerService) AppendCpuSample(t time.Time, v float64) { + s.mu.Lock() + defer s.mu.Unlock() + if s.cpuCapacity == 0 { + s.cpuCapacity = 10800 // ~6 hours at 2s per sample + } + p := CPUSample{T: t.Unix(), Cpu: v} + s.cpuHistory = append(s.cpuHistory, p) + if len(s.cpuHistory) > s.cpuCapacity { + drop := len(s.cpuHistory) - s.cpuCapacity + s.cpuHistory = s.cpuHistory[drop:] + } +} + +// GetCpuHistory returns samples from the last 'mins' minutes (bounded 1..360). +func (s *ServerService) GetCpuHistory(mins int) []CPUSample { + if mins < 1 { + mins = 1 + } + if mins > 360 { + mins = 360 + } + cutoff := time.Now().Add(-time.Duration(mins) * time.Minute).Unix() + s.mu.Lock() + defer s.mu.Unlock() + if len(s.cpuHistory) == 0 { + return nil + } + // find first index >= cutoff (linear scan from end is fine for these sizes) + i := len(s.cpuHistory) - 1 + for ; i >= 0; i-- { + if s.cpuHistory[i].T < cutoff { + i++ + break + } + } + if i < 0 { + i = 0 + } + // copy to avoid exposing internal slice + out := make([]CPUSample, len(s.cpuHistory)-i) + copy(out, s.cpuHistory[i:]) + return out +} + +// sampleCPUUtilization returns a smoothed total CPU utilization percentage across all logical processors. +// It computes utilization from CPU time deltas (non-blocking) and applies an exponential moving average +// to reduce spikes similar to Task Manager's smoothing. +func (s *ServerService) sampleCPUUtilization() (float64, error) { + // Prefer native Windows API to avoid external deps for CPU percent + if runtime.GOOS == "windows" { + if pct, err := sys.CPUPercentRaw(); err == nil { + s.mu.Lock() + // Smooth with EMA + const alpha = 0.3 + if s.emaCPU == 0 { + s.emaCPU = pct + } else { + s.emaCPU = alpha*pct + (1-alpha)*s.emaCPU + } + val := s.emaCPU + s.mu.Unlock() + return val, nil + } + // If native call fails, fall back to gopsutil times + } + // Read aggregate CPU times (all CPUs combined) + times, err := cpu.Times(false) + if err != nil { + return 0, err + } + if len(times) == 0 { + return 0, fmt.Errorf("no cpu times available") + } + + cur := times[0] + + s.mu.Lock() + defer s.mu.Unlock() + + // If this is the first sample, initialize and return current EMA (0 by default) + if !s.hasLastCPUSample { + s.lastCPUTimes = cur + s.hasLastCPUSample = true + return s.emaCPU, nil + } + + // Compute busy and total deltas + idleDelta := cur.Idle - s.lastCPUTimes.Idle + // Sum of busy deltas (exclude Idle) + busyDelta := (cur.User - s.lastCPUTimes.User) + + (cur.System - s.lastCPUTimes.System) + + (cur.Nice - s.lastCPUTimes.Nice) + + (cur.Iowait - s.lastCPUTimes.Iowait) + + (cur.Irq - s.lastCPUTimes.Irq) + + (cur.Softirq - s.lastCPUTimes.Softirq) + + (cur.Steal - s.lastCPUTimes.Steal) + + (cur.Guest - s.lastCPUTimes.Guest) + + (cur.GuestNice - s.lastCPUTimes.GuestNice) + + totalDelta := busyDelta + idleDelta + + // Update last sample for next time + s.lastCPUTimes = cur + + // Guard against division by zero or negative deltas (e.g., counter resets) + if totalDelta <= 0 { + return s.emaCPU, nil + } + + raw := 100.0 * (busyDelta / totalDelta) + if raw < 0 { + raw = 0 + } + if raw > 100 { + raw = 100 + } + + // Exponential moving average to smooth spikes + const alpha = 0.3 // smoothing factor (0<alpha<=1). Higher = more responsive, lower = smoother + if s.emaCPU == 0 { + // Initialize EMA with the first real reading to avoid long warm-up from zero + s.emaCPU = raw + } else { + s.emaCPU = alpha*raw + (1-alpha)*s.emaCPU + } + + return s.emaCPU, nil +} + func (s *ServerService) GetXrayVersions() ([]string, error) { const ( XrayURL = "https://api.github.com/repos/XTLS/Xray-core/releases" |