Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package unifiedresources
import (
"hash/fnv"
"math"
"math/rand"
"strings"
"time"
"github.com/rcourtman/pulse-go-rewrite/internal/mockmode"
"github.com/rcourtman/pulse-go-rewrite/internal/models"
)
func metricsFromProxmoxNode(node models.Node) *ResourceMetrics {
metrics := &ResourceMetrics{}
cpuPercent := percentFromUsage(node.CPU)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: SourceProxmox}
if node.Memory.Total > 0 && node.Memory.HasKnownUsage() {
percent := percentFromUsage(node.Memory.Usage)
metrics.Memory = &MetricValue{Used: &node.Memory.Used, Total: &node.Memory.Total, Percent: percent, Unit: "bytes", Source: SourceProxmox}
}
if hasObservedDiskUsage(node.Disk) {
percent := percentFromUsage(node.Disk.Usage)
metrics.Disk = &MetricValue{Used: &node.Disk.Used, Total: &node.Disk.Total, Percent: percent, Unit: "bytes", Source: SourceProxmox}
}
return metrics
}
// hasObservedDiskUsage prevents unavailable legacy disk observations from
// becoming a negative percentage or a clamped, apparently idle measurement in
// the canonical resource model. Capacity alone does not establish used space.
func hasObservedDiskUsage(disk models.Disk) bool {
return disk.Total > 0 && disk.Used >= 0 && disk.Used <= disk.Total &&
disk.Usage >= 0 && disk.Usage <= 100 && !math.IsNaN(disk.Usage) && !math.IsInf(disk.Usage, 0)
}
func metricsFromHost(host models.Host) *ResourceMetrics {
// Author freshness from server-owned report receipt time, never from a
// guest row refreshed by another source or an agent-supplied annotation.
memory := host.Memory
memory.Observation = models.MemoryObservation{State: "current", Source: "agent", ObservedAt: host.LastSeen}
if host.Status != "online" || host.LastSeen.IsZero() || host.LastSeen.After(time.Now()) {
memory.Observation.State = "last-known"
if host.LastSeen.After(time.Now()) {
memory.Observation.ObservedAt = time.Time{}
}
}
return buildHostMetricPayload(
host.CPUUsage,
memory,
host.Disks,
host.NetInRate,
host.NetOutRate,
host.DiskReadRate,
host.DiskWriteRate,
SourceAgent,
)
}
func metricsFromUnraidStorage(host models.Host) *ResourceMetrics {
metrics := &ResourceMetrics{}
total, used, _, percent := unraidStorageCapacity(host)
if total > 0 {
metrics.Disk = unraidDiskMetric(total, used, percent)
}
return metrics
}
func metricsFromUnraidDiskCapacity(total, used int64, percent float64) *ResourceMetrics {
metrics := &ResourceMetrics{}
if total > 0 {
metrics.Disk = unraidDiskMetric(total, used, percent)
}
return metrics
}
func unraidDiskMetric(total, used int64, percent float64) *MetricValue {
return &MetricValue{
Used: &used,
Total: &total,
Percent: percent,
Unit: "bytes",
Source: SourceAgent,
}
}
func metricsFromDockerHost(host models.DockerHost) *ResourceMetrics {
return buildHostMetricPayload(
host.CPUUsage,
host.Memory,
host.Disks,
host.NetInRate,
host.NetOutRate,
host.DiskReadRate,
host.DiskWriteRate,
SourceDocker,
)
}
func buildHostMetricPayload(
cpuUsage float64,
memory models.Memory,
disks []models.Disk,
netInRate, netOutRate, diskReadRate, diskWriteRate float64,
source DataSource,
) *ResourceMetrics {
metrics := &ResourceMetrics{}
cpuPercent := percentFromReportedPercent(cpuUsage)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: source}
if memory.Total > 0 && memory.HasKnownUsage() {
percent := percentFromReportedPercent(memory.Usage)
metrics.Memory = &MetricValue{Used: &memory.Used, Total: &memory.Total, Percent: percent, Unit: "bytes", Source: source, Observation: memory.Observation}
}
if percent, ok := HostDiskUsagePercent(disks); ok {
disk := disks[0]
metrics.Disk = &MetricValue{Used: &disk.Used, Total: &disk.Total, Percent: percent, Unit: "bytes", Source: source}
}
setNetworkAndDiskIOMetricsHost(metrics, netInRate, netOutRate, diskReadRate, diskWriteRate, source)
return metrics
}
func metricsFromPBSInstance(instance models.PBSInstance) *ResourceMetrics {
metrics := &ResourceMetrics{}
cpuPercent := percentFromUsage(instance.CPU)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: SourcePBS}
if instance.MemoryTotal > 0 {
percent := percentFromUsage(instance.Memory)
metrics.Memory = &MetricValue{
Used: &instance.MemoryUsed,
Total: &instance.MemoryTotal,
Percent: percent,
Unit: "bytes",
Source: SourcePBS,
}
}
return metrics
}
func metricsFromPBSDatastore(datastore models.PBSDatastore) *ResourceMetrics {
metrics := &ResourceMetrics{}
if datastore.Total <= 0 {
return metrics
}
used := datastore.Used
total := datastore.Total
percent := percentFromUsage(datastore.Usage)
if percent == 0 && total > 0 {
percent = clampMetricValue((float64(used)/float64(total))*100, 0, 100)
}
metrics.Disk = &MetricValue{
Used: &used,
Total: &total,
Percent: percent,
Unit: "bytes",
Source: SourcePBS,
}
return metrics
}
func metricsFromPMGInstance(instance models.PMGInstance) *ResourceMetrics {
// PMG currently exposes aggregate queue/mail counters, not point-in-time
// throughput rates. Return an empty metrics object to avoid mislabeling
// aggregate totals as realtime I/O.
return &ResourceMetrics{}
}
func metricsFromVM(vm models.VM) *ResourceMetrics {
return buildVMMetricPayload(
vm.CPU,
vm.Memory,
vm.Disk,
vm.NetworkIn,
vm.NetworkOut,
vm.DiskRead,
vm.DiskWrite,
vm.IORateValidity,
SourceProxmox,
)
}
func metricsFromContainer(ct models.Container) *ResourceMetrics {
return buildVMMetricPayload(
ct.CPU,
ct.Memory,
ct.Disk,
ct.NetworkIn,
ct.NetworkOut,
ct.DiskRead,
ct.DiskWrite,
ct.IORateValidity,
SourceProxmox,
)
}
func buildVMMetricPayload(
cpu float64,
memory models.Memory,
disk models.Disk,
netIn, netOut, diskRead, diskWrite int64,
rateValidity models.IORateValidity,
source DataSource,
) *ResourceMetrics {
metrics := &ResourceMetrics{}
cpuPercent := ProxmoxGuestCPUPercent(cpu)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: source}
if memory.Total > 0 && memory.HasKnownUsage() {
percent := percentFromUsage(memory.Usage)
metrics.Memory = &MetricValue{Used: &memory.Used, Total: &memory.Total, Percent: percent, Unit: "bytes", Source: source, Observation: memory.Observation}
}
if hasObservedDiskUsage(disk) {
percent := percentFromUsage(disk.Usage)
metrics.Disk = &MetricValue{Used: &disk.Used, Total: &disk.Total, Percent: percent, Unit: "bytes", Source: source}
}
setNetworkAndDiskIOMetricsVM(metrics, netIn, netOut, diskRead, diskWrite, rateValidity, source)
return metrics
}
func metricsFromStorage(storage models.Storage) *ResourceMetrics {
metrics := &ResourceMetrics{}
if storage.Total <= 0 {
return metrics
}
used := storage.Used
total := storage.Total
percent := percentFromUsage(storage.Usage)
if percent == 0 && total > 0 {
percent = clampMetricValue((float64(used)/float64(total))*100, 0, 100)
}
metrics.Disk = &MetricValue{
Used: &used,
Total: &total,
Percent: percent,
Unit: "bytes",
Source: SourceProxmox,
}
return metrics
}
func metricsFromCephCluster(cluster models.CephCluster) *ResourceMetrics {
metrics := &ResourceMetrics{}
if cluster.TotalBytes > 0 {
used := cluster.UsedBytes
total := cluster.TotalBytes
percent := clampMetricValue(cluster.UsagePercent, 0, 100)
if percent == 0 && total > 0 {
percent = clampMetricValue((float64(used)/float64(total))*100, 0, 100)
}
metrics.Disk = &MetricValue{
Used: &used,
Total: &total,
Percent: percent,
Unit: "bytes",
Source: SourceProxmox,
}
}
return metrics
}
func metricsFromPhysicalDisk(disk models.PhysicalDisk) *ResourceMetrics {
metrics := &ResourceMetrics{}
if disk.Size > 0 {
used := int64(0)
total := disk.Size
metrics.Disk = &MetricValue{
Used: &used,
Total: &total,
Unit: "bytes",
Source: SourceProxmox,
}
}
return metrics
}
func metricsFromDockerContainer(ct models.DockerContainer, hostCPUs ...int) *ResourceMetrics {
metrics := &ResourceMetrics{}
cpuCapacity := 0
if len(hostCPUs) > 0 {
cpuCapacity = hostCPUs[0]
}
cpuPercent := percentFromReportedPercent(models.DockerContainerCPUCapacityPercent(ct, cpuCapacity))
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: SourceDocker}
if ct.MemoryLimit > 0 {
percent := percentFromReportedPercent(ct.MemoryPercent)
metrics.Memory = &MetricValue{Used: &ct.MemoryUsage, Total: &ct.MemoryLimit, Percent: percent, Unit: "bytes", Source: SourceDocker}
}
// Writable and root layer sizes are image metadata, not used/total
// filesystem capacity. Docker does not supply a capacity observation here.
if ct.NetInRate > 0 {
metrics.NetIn = &MetricValue{Value: ct.NetInRate, Unit: "bytes/s", Source: SourceDocker}
}
if ct.NetOutRate > 0 {
metrics.NetOut = &MetricValue{Value: ct.NetOutRate, Unit: "bytes/s", Source: SourceDocker}
}
if ct.BlockIO != nil {
if ct.BlockIO.ReadRateBytesPerSecond != nil && *ct.BlockIO.ReadRateBytesPerSecond >= 0 && !math.IsInf(*ct.BlockIO.ReadRateBytesPerSecond, 0) {
metrics.DiskRead = &MetricValue{Value: *ct.BlockIO.ReadRateBytesPerSecond, Unit: "bytes/s", Source: SourceDocker}
}
if ct.BlockIO.WriteRateBytesPerSecond != nil && *ct.BlockIO.WriteRateBytesPerSecond >= 0 && !math.IsInf(*ct.BlockIO.WriteRateBytesPerSecond, 0) {
metrics.DiskWrite = &MetricValue{Value: *ct.BlockIO.WriteRateBytesPerSecond, Unit: "bytes/s", Source: SourceDocker}
}
}
if mockmode.IsEnabled() && (metrics.NetIn == nil || metrics.NetOut == nil || metrics.DiskRead == nil || metrics.DiskWrite == nil) {
synthetic := syntheticDockerContainerIOMetrics(ct)
if metrics.NetIn == nil {
metrics.NetIn = &MetricValue{Value: synthetic.NetIn, Unit: "bytes/s", Source: SourceDocker}
}
if metrics.NetOut == nil {
metrics.NetOut = &MetricValue{Value: synthetic.NetOut, Unit: "bytes/s", Source: SourceDocker}
}
if metrics.DiskRead == nil {
metrics.DiskRead = &MetricValue{Value: synthetic.DiskRead, Unit: "bytes/s", Source: SourceDocker}
}
if metrics.DiskWrite == nil {
metrics.DiskWrite = &MetricValue{Value: synthetic.DiskWrite, Unit: "bytes/s", Source: SourceDocker}
}
}
return metrics
}
func metricsFromKubernetesCluster(cluster models.KubernetesCluster, linkedHosts []*models.Host) *ResourceMetrics {
metrics := &ResourceMetrics{}
var cpuSum float64
var cpuCount int
var memoryUsed int64
var memoryTotal int64
var diskUsed int64
var diskTotal int64
var netIn float64
var netOut float64
var diskRead float64
var diskWrite float64
var hasNetIn bool
var hasNetOut bool
var hasDiskRead bool
var hasDiskWrite bool
linkedNodeNames := make(map[string]struct{}, len(linkedHosts)*2)
for _, host := range linkedHosts {
if host == nil {
continue
}
cpuSum += percentFromReportedPercent(host.CPUUsage)
cpuCount++
hostName := strings.TrimSpace(host.Hostname)
if hostName != "" {
linkedNodeNames[strings.ToLower(hostName)] = struct{}{}
linkedNodeNames[strings.ToLower(NormalizeHostname(hostName))] = struct{}{}
}
if host.Memory.Total > 0 {
memoryTotal += host.Memory.Total
memoryUsed += host.Memory.Used
}
if len(host.Disks) > 0 {
disk := host.Disks[0]
if hasObservedDiskUsage(disk) {
diskTotal += disk.Total
diskUsed += disk.Used
}
}
if host.NetInRate > 0 {
netIn += host.NetInRate
hasNetIn = true
}
if host.NetOutRate > 0 {
netOut += host.NetOutRate
hasNetOut = true
}
if host.DiskReadRate > 0 {
diskRead += host.DiskReadRate
hasDiskRead = true
}
if host.DiskWriteRate > 0 {
diskWrite += host.DiskWriteRate
hasDiskWrite = true
}
}
// Fall back to Kubernetes metrics API usage for nodes without a linked agent host.
for _, node := range cluster.Nodes {
nodeName := strings.TrimSpace(node.Name)
normalized := strings.ToLower(NormalizeHostname(nodeName))
if _, linked := linkedNodeNames[strings.ToLower(nodeName)]; linked {
continue
}
if normalized != "" {
if _, linked := linkedNodeNames[normalized]; linked {
continue
}
}
if node.UsageCPUPercent > 0 {
cpuSum += clampMetricValue(node.UsageCPUPercent, 0, 100)
cpuCount++
}
if node.UsageMemoryBytes > 0 {
total := node.AllocMemoryBytes
if total <= 0 {
total = node.CapacityMemoryBytes
}
if total > 0 {
memoryUsed += node.UsageMemoryBytes
memoryTotal += total
}
}
}
if cpuCount > 0 {
cpuPercent := clampMetricValue(cpuSum/float64(cpuCount), 0, 100)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: SourceAgent}
}
if memoryTotal > 0 {
percent := clampMetricValue((float64(memoryUsed)/float64(memoryTotal))*100, 0, 100)
metrics.Memory = &MetricValue{Used: &memoryUsed, Total: &memoryTotal, Percent: percent, Unit: "bytes", Source: SourceAgent}
}
if diskTotal > 0 {
percent := clampMetricValue((float64(diskUsed)/float64(diskTotal))*100, 0, 100)
metrics.Disk = &MetricValue{Used: &diskUsed, Total: &diskTotal, Percent: percent, Unit: "bytes", Source: SourceAgent}
}
if hasNetIn {
metrics.NetIn = &MetricValue{Value: netIn, Unit: "bytes/s", Source: SourceAgent}
}
if hasNetOut {
metrics.NetOut = &MetricValue{Value: netOut, Unit: "bytes/s", Source: SourceAgent}
}
if hasDiskRead {
metrics.DiskRead = &MetricValue{Value: diskRead, Unit: "bytes/s", Source: SourceAgent}
}
if hasDiskWrite {
metrics.DiskWrite = &MetricValue{Value: diskWrite, Unit: "bytes/s", Source: SourceAgent}
}
return metrics
}
func metricsFromKubernetesNode(_ models.KubernetesCluster, node models.KubernetesNode, linkedHost *models.Host) *ResourceMetrics {
// Kubernetes node usage comes from the pulse-agent host module when running on the
// same infrastructure node (unified agent). If no linked host exists, use
// Kubernetes metrics API usage fields when available.
if linkedHost != nil {
return metricsFromHost(*linkedHost)
}
metrics := &ResourceMetrics{}
if node.UsageCPUPercent > 0 {
cpuPercent := clampMetricValue(node.UsageCPUPercent, 0, 100)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: SourceK8s}
}
if node.UsageMemoryBytes > 0 {
total := node.AllocMemoryBytes
if total <= 0 {
total = node.CapacityMemoryBytes
}
if total > 0 {
used := node.UsageMemoryBytes
percent := clampMetricValue((float64(used)/float64(total))*100, 0, 100)
metrics.Memory = &MetricValue{Used: &used, Total: &total, Percent: percent, Unit: "bytes", Source: SourceK8s}
}
}
return metrics
}
// metricsFromKubernetesDeployment projects deployment-level metrics so the
// platform-page Deployments table stops rendering dashes for CPU / Memory /
// Disk. Real upstream Deployments do not natively expose resource metrics —
// they are scheduling abstractions over their controlled pods — so this
// helper currently synthesises mock-mode values from the deployment's
// replica state. Production deployments without aggregated pod metrics
// still return nil here; once the canonical adapter learns how to roll up
// pod metrics into the owning deployment, swap the synthetic branch for the
// real aggregate while keeping the synthetic fallback for mock mode.
func metricsFromKubernetesDeployment(cluster models.KubernetesCluster, deployment models.KubernetesDeployment) *ResourceMetrics {
if !mockmode.IsEnabled() {
return nil
}
values := syntheticKubernetesDeploymentMetrics(cluster, deployment)
return &ResourceMetrics{
CPU: &MetricValue{Value: values.CPU, Percent: values.CPU, Unit: "percent", Source: SourceK8s},
Memory: &MetricValue{Value: values.Memory, Percent: values.Memory, Unit: "percent", Source: SourceK8s},
Disk: &MetricValue{Value: values.Disk, Percent: values.Disk, Unit: "percent", Source: SourceK8s},
NetIn: &MetricValue{Value: values.NetIn, Unit: "bytes/s", Source: SourceK8s},
NetOut: &MetricValue{Value: values.NetOut, Unit: "bytes/s", Source: SourceK8s},
DiskRead: &MetricValue{Value: values.DiskRead, Unit: "bytes/s", Source: SourceK8s},
DiskWrite: &MetricValue{Value: values.DiskWrite, Unit: "bytes/s", Source: SourceK8s},
}
}
type kubernetesDeploymentSyntheticMetrics struct {
CPU float64
Memory float64
Disk float64
NetIn float64
NetOut float64
DiskRead float64
DiskWrite float64
}
func syntheticKubernetesDeploymentMetrics(cluster models.KubernetesCluster, deployment models.KubernetesDeployment) kubernetesDeploymentSyntheticMetrics {
seed := hashMetricsSeed(
cluster.ID,
cluster.Name,
cluster.DisplayName,
deployment.UID,
deployment.Namespace,
deployment.Name,
)
rng := rand.New(rand.NewSource(int64(seed)))
desired := float64(deployment.DesiredReplicas)
if desired <= 0 {
desired = 1
}
ready := float64(deployment.ReadyReplicas)
if ready < 0 {
ready = 0
}
if ready > desired {
ready = desired
}
available := float64(deployment.AvailableReplicas)
if available < 0 {
available = 0
}
if available > desired {
available = desired
}
readiness := ready / desired
availability := available / desired
// Healthy deployments cluster around moderate utilisation; degraded
// deployments (ready < desired) read as elevated CPU / memory pressure
// because the surviving pods absorb the dropped replicas' load.
pressure := 1.0 + (1.0-readiness)*0.85
scale := math.Min(1.0+desired*0.05, 1.6)
cpu := (24 + rng.Float64()*18) * pressure * scale
memory := (38 + rng.Float64()*22) * pressure * scale
disk := (12 + rng.Float64()*16) * scale
netIn := (12_000 + rng.Float64()*60_000) * scale * availability
netOut := (9_000 + rng.Float64()*48_000) * scale * availability
diskRead := (4_000 + rng.Float64()*32_000) * scale * availability
diskWrite := (3_000 + rng.Float64()*24_000) * scale * availability
return kubernetesDeploymentSyntheticMetrics{
CPU: clampMetricValue(cpu, 0, 100),
Memory: clampMetricValue(memory, 0, 100),
Disk: clampMetricValue(disk, 0, 100),
NetIn: netIn,
NetOut: netOut,
DiskRead: diskRead,
DiskWrite: diskWrite,
}
}
func metricsFromKubernetesPod(cluster models.KubernetesCluster, pod models.KubernetesPod) *ResourceMetrics {
metrics := &ResourceMetrics{}
if pod.UsageCPUPercent > 0 {
cpuPercent := clampMetricValue(pod.UsageCPUPercent, 0, 100)
metrics.CPU = &MetricValue{Value: cpuPercent, Percent: cpuPercent, Unit: "percent", Source: SourceK8s}
}
if pod.UsageMemoryBytes > 0 {
total := kubernetesPodMemoryTotalBytes(cluster, pod)
if total > 0 {
used := pod.UsageMemoryBytes
percent := clampMetricValue((float64(used)/float64(total))*100, 0, 100)
metrics.Memory = &MetricValue{Used: &used, Total: &total, Percent: percent, Unit: "bytes", Source: SourceK8s}
} else if pod.UsageMemoryPercent > 0 {
memPercent := clampMetricValue(pod.UsageMemoryPercent, 0, 100)
metrics.Memory = &MetricValue{Value: memPercent, Percent: memPercent, Unit: "percent", Source: SourceK8s}
}
}
if pod.DiskUsagePercent > 0 {
diskPercent := clampMetricValue(pod.DiskUsagePercent, 0, 100)
metrics.Disk = &MetricValue{Value: diskPercent, Percent: diskPercent, Unit: "percent", Source: SourceK8s}
}
if pod.NetInRate > 0 {
metrics.NetIn = &MetricValue{Value: pod.NetInRate, Unit: "bytes/s", Source: SourceK8s}
}
if pod.NetOutRate > 0 {
metrics.NetOut = &MetricValue{Value: pod.NetOutRate, Unit: "bytes/s", Source: SourceK8s}
}
if !mockmode.IsEnabled() {
return metrics
}
values := syntheticKubernetesPodMetrics(cluster, pod)
if metrics.CPU == nil {
metrics.CPU = &MetricValue{Value: values.CPU, Percent: values.CPU, Unit: "percent", Source: SourceK8s}
}
if metrics.Memory == nil {
metrics.Memory = &MetricValue{Value: values.Memory, Percent: values.Memory, Unit: "percent", Source: SourceK8s}
}
if metrics.Disk == nil {
metrics.Disk = &MetricValue{Value: values.Disk, Percent: values.Disk, Unit: "percent", Source: SourceK8s}
}
if metrics.NetIn == nil {
metrics.NetIn = &MetricValue{Value: values.NetIn, Unit: "bytes/s", Source: SourceK8s}
}
if metrics.NetOut == nil {
metrics.NetOut = &MetricValue{Value: values.NetOut, Unit: "bytes/s", Source: SourceK8s}
}
return metrics
}
func kubernetesPodMemoryTotalBytes(cluster models.KubernetesCluster, pod models.KubernetesPod) int64 {
nodeName := strings.TrimSpace(pod.NodeName)
if nodeName == "" {
return 0
}
for _, node := range cluster.Nodes {
if !strings.EqualFold(strings.TrimSpace(node.Name), nodeName) {
continue
}
if node.AllocMemoryBytes > 0 {
return node.AllocMemoryBytes
}
if node.CapacityMemoryBytes > 0 {
return node.CapacityMemoryBytes
}
return 0
}
return 0
}
type kubernetesPodSyntheticMetrics struct {
CPU float64
Memory float64
Disk float64
NetIn float64
NetOut float64
DiskRead float64
DiskWrite float64
}
type dockerContainerSyntheticIOMetrics struct {
NetIn float64
NetOut float64
DiskRead float64
DiskWrite float64
}
func syntheticDockerContainerIOMetrics(ct models.DockerContainer) dockerContainerSyntheticIOMetrics {
seed := hashMetricsSeed(ct.ID, ct.Name, ct.Image, ct.State)
rng := rand.New(rand.NewSource(int64(seed)))
state := strings.ToLower(strings.TrimSpace(ct.State))
running := state == "running" || state == "restarting"
cpuActivity := percentFromReportedPercent(models.DockerContainerCPUCapacityPercent(ct, 0))
memoryActivity := percentFromReportedPercent(ct.MemoryPercent)
activity := clampMetricValue((cpuActivity+memoryActivity)/180.0, 0.12, 1.25)
if !running {
activity = clampMetricValue(activity*0.32, 0.05, 0.45)
}
restartMultiplier := 1 + math.Min(float64(ct.RestartCount)*0.08, 0.55)
netIn := (28 + activity*540 + rng.Float64()*210) * restartMultiplier
netOut := (22 + activity*470 + rng.Float64()*180) * restartMultiplier
diskRead := (16 + activity*320 + rng.Float64()*140) * restartMultiplier
diskWrite := (14 + activity*300 + rng.Float64()*130) * restartMultiplier
return dockerContainerSyntheticIOMetrics{
NetIn: clampMetricValue(netIn, 4, 3200),
NetOut: clampMetricValue(netOut, 3, 2800),
DiskRead: clampMetricValue(diskRead, 2, 2400),
DiskWrite: clampMetricValue(diskWrite, 2, 2200),
}
}
func syntheticKubernetesPodMetrics(cluster models.KubernetesCluster, pod models.KubernetesPod) kubernetesPodSyntheticMetrics {
seed := hashMetricsSeed(
cluster.ID,
cluster.Name,
cluster.DisplayName,
pod.UID,
pod.Namespace,
pod.Name,
)
rng := rand.New(rand.NewSource(int64(seed)))
phase := strings.ToLower(strings.TrimSpace(pod.Phase))
totalContainers := len(pod.Containers)
if totalContainers <= 0 {
totalContainers = 1
}
readyContainers := 0
for _, container := range pod.Containers {
if container.Ready {
readyContainers++
}
}
readiness := float64(readyContainers) / float64(totalContainers)
if readiness <= 0 && phase == "running" {
readiness = 0.35
}
restarts := float64(pod.Restarts)
if restarts < 0 {
restarts = 0
}
restartFactor := math.Min(restarts*1.6, 16)
cpu := 0.0
memory := 0.0
disk := 0.0
netIn := 0.0
netOut := 0.0
diskRead := 0.0
diskWrite := 0.0
switch phase {
case "running":
cpu = 7 + readiness*52 + rng.Float64()*14 - restartFactor*0.35
memory = 26 + readiness*46 + rng.Float64()*14 + restartFactor*0.25
disk = 17 + readiness*42 + rng.Float64()*16
netIn = 14 + readiness*220 + rng.Float64()*70 + restarts*2
netOut = 10 + readiness*180 + rng.Float64()*55 + restarts*1.6
diskRead = 8 + readiness*75 + rng.Float64()*32 + restarts*1.8
diskWrite = 6 + readiness*68 + rng.Float64()*28 + restarts*1.6
case "pending":
cpu = 2 + rng.Float64()*7
memory = 14 + rng.Float64()*16
disk = 8 + rng.Float64()*14
netIn = 1 + rng.Float64()*10
netOut = 1 + rng.Float64()*8
diskRead = 1 + rng.Float64()*8
diskWrite = 1 + rng.Float64()*8
case "failed", "unknown":
cpu = 1 + rng.Float64()*8
memory = 9 + rng.Float64()*15 + restartFactor*0.5
disk = 7 + rng.Float64()*16
netIn = 1 + rng.Float64()*14 + restarts*1.4
netOut = 1 + rng.Float64()*11 + restarts*1.2
diskRead = 1 + rng.Float64()*10 + restarts*1.2
diskWrite = 1 + rng.Float64()*10 + restarts*1.1
default:
cpu = 1 + rng.Float64()*6
memory = 8 + rng.Float64()*12
disk = 6 + rng.Float64()*12
netIn = 1 + rng.Float64()*7
netOut = 1 + rng.Float64()*6
diskRead = 1 + rng.Float64()*6
diskWrite = 1 + rng.Float64()*6
}
if totalContainers > 1 {
multi := 1 + math.Min(float64(totalContainers-1)*0.08, 0.6)
cpu *= multi
memory *= 1 + math.Min(float64(totalContainers-1)*0.1, 0.8)
disk *= 1 + math.Min(float64(totalContainers-1)*0.07, 0.5)
netIn *= 1 + math.Min(float64(totalContainers-1)*0.09, 0.7)
netOut *= 1 + math.Min(float64(totalContainers-1)*0.08, 0.65)
diskRead *= 1 + math.Min(float64(totalContainers-1)*0.11, 0.8)
diskWrite *= 1 + math.Min(float64(totalContainers-1)*0.1, 0.7)
}
return kubernetesPodSyntheticMetrics{
CPU: clampMetricValue(cpu, 0, 100),
Memory: clampMetricValue(memory, 0, 100),
Disk: clampMetricValue(disk, 0, 100),
NetIn: clampMetricValue(netIn, 0, math.Max(1800, netIn+50)),
NetOut: clampMetricValue(netOut, 0, math.Max(1700, netOut+40)),
DiskRead: clampMetricValue(diskRead, 0, math.Max(1200, diskRead+30)),
DiskWrite: clampMetricValue(diskWrite, 0, math.Max(1200, diskWrite+30)),
}
}
func hashMetricsSeed(parts ...string) uint64 {
h := fnv.New64a()
for _, p := range parts {
_, _ = h.Write([]byte(p))
_, _ = h.Write([]byte{0})
}
return h.Sum64()
}
func clampMetricValue(value, min, max float64) float64 {
if math.IsNaN(value) || math.IsInf(value, 0) {
return min
}
if value < min {
return min
}
if value > max {
return max
}
return value
}
func percentFromUsage(value float64) float64 {
if value <= 1.0 {
return value * 100
}
return value
}
// ProxmoxGuestCPUPercent converts the Proxmox guest capacity ratio to the
// canonical 0..100 percent unit shared by live state, alerts, and history.
// Values already expressed as percent are retained for compatibility with
// normalized fixtures and read-state adapters. Guest CPU is not divided by
// the configured core count: Proxmox already reports capacity utilization.
func ProxmoxGuestCPUPercent(value float64) float64 {
return percentFromUsage(value)
}
func percentFromReportedPercent(value float64) float64 {
return clampMetricValue(value, 0, 100)
}
func setNetworkAndDiskIOMetricsHost(metrics *ResourceMetrics, netIn, netOut, diskRead, diskWrite float64, source DataSource) {
if netIn > 0 {
metrics.NetIn = &MetricValue{Value: netIn, Unit: "bytes/s", Source: source}
}
if netOut > 0 {
metrics.NetOut = &MetricValue{Value: netOut, Unit: "bytes/s", Source: source}
}
if diskRead > 0 {
metrics.DiskRead = &MetricValue{Value: diskRead, Unit: "bytes/s", Source: source}
}
if diskWrite > 0 {
metrics.DiskWrite = &MetricValue{Value: diskWrite, Unit: "bytes/s", Source: source}
}
}
func setNetworkAndDiskIOMetricsVM(metrics *ResourceMetrics, netIn, netOut, diskRead, diskWrite int64, validity models.IORateValidity, source DataSource) {
effective := validity.EffectiveForRates(diskRead, diskWrite, netIn, netOut)
if effective.NetworkIn {
metrics.NetIn = &MetricValue{Value: float64(netIn), Unit: "bytes/s", Source: source}
}
if effective.NetworkOut {
metrics.NetOut = &MetricValue{Value: float64(netOut), Unit: "bytes/s", Source: source}
}
if effective.DiskRead {
metrics.DiskRead = &MetricValue{Value: float64(diskRead), Unit: "bytes/s", Source: source}
}
if effective.DiskWrite {
metrics.DiskWrite = &MetricValue{Value: float64(diskWrite), Unit: "bytes/s", Source: source}
}
}