Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

27.2 KB
Raw Blame
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}
	}
}