issue-143 - fix: Net and Disc Metrics

Author: vladimirvivien

docs/images/ktop.png

@@ -135,6 +135,11 @@ func (m *MetricsServerSource) GetMetricsForPod(ctx context.Context, pod metav1.O
 	return m.GetPodMetrics(ctx, pod.GetNamespace(), pod.GetName())
 }
 
+// GetPodNetworkDiskMetrics returns zero values - metrics-server doesn't provide network/disk metrics
+func (m *MetricsServerSource) GetPodNetworkDiskMetrics(ctx context.Context, namespace, podName string) (netRx, netTx, diskRead, diskWrite float64, err error) {
+	return 0, 0, 0, 0, nil
+}
+
 // GetAllPodMetrics retrieves metrics for all pods.
 func (m *MetricsServerSource) GetAllPodMetrics(ctx context.Context) ([]*metrics.PodMetrics, error) {
 	// Call Metrics Server API directly

metrics/k8s/metrics_server_source.go

@@ -435,6 +435,44 @@ func (p *PromMetricsSource) GetPodMetrics(ctx context.Context, namespace, podNam
 	return podMetrics, nil
 }
 
+// GetPodNetworkDiskMetrics retrieves network and disk I/O rates for a specific pod.
+// Network metrics are at the pod level (shared network namespace via pause container).
+// Disk metrics are aggregated across containers in the pod.
+// Returns zero values if metrics are not available.
+// Note: Pod-level network metrics are not available on containerd-based clusters.
+func (p *PromMetricsSource) GetPodNetworkDiskMetrics(ctx context.Context, namespace, podName string) (netRx, netTx, diskRead, diskWrite float64, err error) {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	if !p.isHealthyLocked() {
+		return 0, 0, 0, 0, fmt.Errorf("prometheus source is not healthy")
+	}
+
+	if p.store == nil {
+		return 0, 0, 0, 0, nil
+	}
+
+	// Pod-level metrics: filter by pod and namespace
+	labelMatchers := map[string]string{
+		"pod":       podName,
+		"namespace": namespace,
+	}
+
+	// Query Disk Read rate from cAdvisor
+	if rate, calcErr := p.calculateCPURate("container_fs_reads_bytes_total", labelMatchers, 40*time.Second); calcErr == nil {
+		diskRead = rate
+	}
+
+	// Query Disk Write rate from cAdvisor
+	if rate, calcErr := p.calculateCPURate("container_fs_writes_bytes_total", labelMatchers, 40*time.Second); calcErr == nil {
+		diskWrite = rate
+	}
+
+	// Note: netRx and netTx remain 0 - pod-level network metrics are not available
+	// on containerd-based Kubernetes clusters (cAdvisor only exports node-level network)
+	return netRx, netTx, diskRead, diskWrite, nil
+}
+
 // GetMetricsForPod retrieves metrics for a specific pod object
 func (p *PromMetricsSource) GetMetricsForPod(ctx context.Context, pod metav1.Object) (*metrics.PodMetrics, error) {
 	// Extract namespace and name from pod object

metrics/prom/prom_source.go

@@ -20,6 +20,12 @@ type MetricsSource interface {
 	// Returns PodMetrics containing per-container resource usage.
 	GetPodMetrics(ctx context.Context, namespace, podName string) (*PodMetrics, error)
 
+	// GetPodNetworkDiskMetrics retrieves network and disk I/O rates for a specific pod.
+	// Network metrics are at the pod level (shared network namespace).
+	// Disk metrics are aggregated across containers in the pod.
+	// Returns zero values if metrics are not available (e.g., for metrics-server source).
+	GetPodNetworkDiskMetrics(ctx context.Context, namespace, podName string) (netRx, netTx, diskRead, diskWrite float64, err error)
+
 	// GetMetricsForPod retrieves metrics for a specific pod object.
 	// This method exists for compatibility with existing code that passes v1.Pod objects.
 	// Implementations may delegate to GetPodMetrics(pod.GetNamespace(), pod.GetName()).

metrics/source.go

@@ -24,6 +24,12 @@ type NodeDetailData struct {
 	// MetricsSourceType indicates the active metrics source ("prometheus", "metrics-server", or "")
 	// Used by detail panels to determine which metrics visualizations to show
 	MetricsSourceType string
+
+	// Network/Disk I/O rates for this specific node (Prometheus only)
+	NetworkRxRate float64
+	NetworkTxRate float64
+	DiskReadRate  float64
+	DiskWriteRate float64
 }
 
 // MetricSample represents a single point in time for metrics history

views/model/node_detail_data.go

@@ -26,6 +26,12 @@ type PodDetailData struct {
 	// MetricsSourceType indicates the active metrics source ("prometheus", "metrics-server", or "")
 	// Used by detail panels to determine which metrics visualizations to show
 	MetricsSourceType string
+
+	// Network/Disk I/O rates for this pod (Prometheus only)
+	NetworkRxRate float64
+	NetworkTxRate float64
+	DiskReadRate  float64
+	DiskWriteRate float64
 }
 
 // ContainerUsage holds formatted CPU and memory usage strings for a container

views/model/pod_detail_data.go

@@ -62,6 +62,10 @@ type DetailPanel struct {
 	onPodSelected         NodeSelectedCallback
 	onBack                func()
 	onFooterContextChange func(focusedPanel string)
+
+	// Adaptive scaling for Net/Disk sparklines
+	peakNetRate  float64
+	peakDiskRate float64
 }
 
 // NewDetailPanel creates a new node detail panel
@@ -256,6 +260,8 @@ func (p *DetailPanel) DrawBody(data interface{}) {
 	}
 	if newNodeName != p.currentNodeName {
 		p.resetSparklines()
+		p.peakNetRate = 0  // Reset adaptive scaling peaks
+		p.peakDiskRate = 0
 		p.currentNodeName = newNodeName
 
 		// Populate sparklines from history if available
@@ -394,8 +400,45 @@ func (p *DetailPanel) drawSparklines() {
 
 	// Update network/disk sparklines in prometheus mode
 	if prometheusMode {
-		p.sparklineRow.UpdateNET(0.01, " NET [gray]↓n/a ↑n/a[-] ")
-		p.sparklineRow.UpdateDisk(0.01, " DISK [gray]R:n/a W:n/a[-] ")
+		// Network sparkline with adaptive scaling
+		netTitle := fmt.Sprintf(" Net ↓%s ↑%s ",
+			ui.FormatBytesRate(p.data.NetworkRxRate),
+			ui.FormatBytesRate(p.data.NetworkTxRate))
+		combinedNetRate := p.data.NetworkRxRate + p.data.NetworkTxRate
+
+		// Adaptive scaling: track peak, use minimum 512 KB/s baseline
+		if combinedNetRate > p.peakNetRate {
+			p.peakNetRate = combinedNetRate
+		}
+		effectiveNetMax := p.peakNetRate
+		if effectiveNetMax < 512*1024 {
+			effectiveNetMax = 512 * 1024
+		}
+		netNormalized := combinedNetRate / effectiveNetMax
+		if netNormalized > 1 {
+			netNormalized = 1
+		}
+		p.sparklineRow.UpdateNET(netNormalized, netTitle)
+
+		// Disk sparkline with adaptive scaling
+		diskTitle := fmt.Sprintf(" Disk R:%s W:%s ",
+			ui.FormatBytesRate(p.data.DiskReadRate),
+			ui.FormatBytesRate(p.data.DiskWriteRate))
+		combinedDiskRate := p.data.DiskReadRate + p.data.DiskWriteRate
+
+		// Adaptive scaling: track peak, use minimum 512 KB/s baseline
+		if combinedDiskRate > p.peakDiskRate {
+			p.peakDiskRate = combinedDiskRate
+		}
+		effectiveDiskMax := p.peakDiskRate
+		if effectiveDiskMax < 512*1024 {
+			effectiveDiskMax = 512 * 1024
+		}
+		diskNormalized := combinedDiskRate / effectiveDiskMax
+		if diskNormalized > 1 {
+			diskNormalized = 1
+		}
+		p.sparklineRow.UpdateDisk(diskNormalized, diskTitle)
 	}
 }
 

views/node/detail.go

@@ -934,6 +934,15 @@ func (p *MainPanel) buildNodeDetailData(ctx context.Context, nodeName string, no
 	// Set metrics source type for conditional display in detail panel
 	if p.metricsSource != nil {
 		detailData.MetricsSourceType = p.metricsSource.GetSourceInfo().Type
+
+		// Fetch per-node network/disk rates for sparklines (Prometheus only)
+		// GetNodeMetrics uses label filter {node: nodeName} to get only this node's metrics
+		if nodeMetrics, err := p.metricsSource.GetNodeMetrics(ctx, nodeName); err == nil && nodeMetrics != nil {
+			detailData.NetworkRxRate = nodeMetrics.NetworkRxRate
+			detailData.NetworkTxRate = nodeMetrics.NetworkTxRate
+			detailData.DiskReadRate = nodeMetrics.DiskReadRate
+			detailData.DiskWriteRate = nodeMetrics.DiskWriteRate
+		}
 	}
 
 	// Fetch metrics history for sparklines (if available)
@@ -1019,6 +1028,14 @@ func (p *MainPanel) buildPodDetailData(ctx context.Context, podKey string, podMo
 	// Set metrics source type for conditional display in detail panel
 	if p.metricsSource != nil {
 		detailData.MetricsSourceType = p.metricsSource.GetSourceInfo().Type
+
+		// Fetch pod-level network/disk rates for sparklines (Prometheus only)
+		if netRx, netTx, diskRead, diskWrite, err := p.metricsSource.GetPodNetworkDiskMetrics(ctx, namespace, podName); err == nil {
+			detailData.NetworkRxRate = netRx
+			detailData.NetworkTxRate = netTx
+			detailData.DiskReadRate = diskRead
+			detailData.DiskWriteRate = diskWrite
+		}
 	}
 
 	// Fetch metrics history for sparklines (if available)

views/overview/main_panel.go

@@ -30,6 +30,10 @@ type clusterSummaryPanel struct {
 
 	// Dynamic layout tracking
 	lastTerminalHeight int
+
+	// Adaptive scaling for Net/Disk sparklines
+	peakNetRate  float64
+	peakDiskRate float64
 }
 
 func NewClusterSummaryPanel(app *application.Application, title string) ui.Panel {
@@ -239,23 +243,41 @@ func (p *clusterSummaryPanel) DrawBody(data interface{}) {
 
 		// === Prometheus-only: Network, Disk, Enhanced Stats ===
 		if p.prometheusMode {
-			// Network sparkline
+			// Network sparkline with adaptive scaling
 			netTitle := fmt.Sprintf(" Net ↓%s ↑%s ",
 				ui.FormatBytesRate(summary.NetworkRxRate),
 				ui.FormatBytesRate(summary.NetworkTxRate))
 			combinedNetRate := summary.NetworkRxRate + summary.NetworkTxRate
-			netNormalized := combinedNetRate / (128 * 1024 * 1024) // 128 MB/s baseline
+
+			// Adaptive scaling: track peak, use minimum 512 KB/s baseline
+			if combinedNetRate > p.peakNetRate {
+				p.peakNetRate = combinedNetRate
+			}
+			effectiveNetMax := p.peakNetRate
+			if effectiveNetMax < 512*1024 { // Min 512 KB/s baseline
+				effectiveNetMax = 512 * 1024
+			}
+			netNormalized := combinedNetRate / effectiveNetMax
 			if netNormalized > 1 {
 				netNormalized = 1
 			}
 			p.sparklineRow.UpdateNET(netNormalized, netTitle)
 
-			// Disk sparkline
+			// Disk sparkline with adaptive scaling
 			diskTitle := fmt.Sprintf(" Disk R:%s W:%s ",
 				ui.FormatBytesRate(summary.DiskReadRate),
 				ui.FormatBytesRate(summary.DiskWriteRate))
 			combinedDiskRate := summary.DiskReadRate + summary.DiskWriteRate
-			diskNormalized := combinedDiskRate / (500 * 1024 * 1024) // 500 MB/s baseline
+
+			// Adaptive scaling: track peak, use minimum 512 KB/s baseline
+			if combinedDiskRate > p.peakDiskRate {
+				p.peakDiskRate = combinedDiskRate
+			}
+			effectiveDiskMax := p.peakDiskRate
+			if effectiveDiskMax < 512*1024 { // Min 512 KB/s baseline
+				effectiveDiskMax = 512 * 1024
+			}
+			diskNormalized := combinedDiskRate / effectiveDiskMax
 			if diskNormalized > 1 {
 				diskNormalized = 1
 			}

views/overview/summary_panel.go

@@ -61,6 +61,9 @@ type DetailPanel struct {
 	// Sparkline row component for metrics visualization
 	sparklineRow *ui.SparklineRow
 
+	// Adaptive scaling for Disk sparkline
+	peakDiskRate float64
+
 	// Callbacks
 	onNodeNavigate        NodeNavigationCallback
 	onContainerSelected   ContainerSelectedCallback
@@ -324,6 +327,7 @@ func (p *DetailPanel) DrawBody(data interface{}) {
 	}
 	if newPodKey != p.currentPodKey {
 		p.resetSparklines()
+		p.peakDiskRate = 0 // Reset adaptive scaling peak
 		p.currentPodKey = newPodKey
 
 		// Populate sparklines from history if available
@@ -460,8 +464,28 @@ func (p *DetailPanel) drawSparklines() {
 
 	// Update network/disk sparklines in prometheus mode
 	if prometheusMode {
-		p.sparklineRow.UpdateNET(0.01, " NET [gray]↓n/a ↑n/a[-] ")
-		p.sparklineRow.UpdateDisk(0.01, " DISK [gray]R:n/a W:n/a[-] ")
+		// Network sparkline - pod-level network metrics unavailable on containerd
+		p.sparklineRow.UpdateNET(0, " Net [gray](unavailable)[-] ")
+
+		// Disk sparkline with adaptive scaling
+		diskTitle := fmt.Sprintf(" Disk R:%s W:%s ",
+			ui.FormatBytesRate(p.data.DiskReadRate),
+			ui.FormatBytesRate(p.data.DiskWriteRate))
+		combinedDiskRate := p.data.DiskReadRate + p.data.DiskWriteRate
+
+		// Adaptive scaling: track peak, use minimum 512 KB/s baseline
+		if combinedDiskRate > p.peakDiskRate {
+			p.peakDiskRate = combinedDiskRate
+		}
+		effectiveDiskMax := p.peakDiskRate
+		if effectiveDiskMax < 512*1024 { // Min 512 KB/s baseline
+			effectiveDiskMax = 512 * 1024
+		}
+		diskNormalized := combinedDiskRate / effectiveDiskMax
+		if diskNormalized > 1 {
+			diskNormalized = 1
+		}
+		p.sparklineRow.UpdateDisk(diskNormalized, diskTitle)
 	}
 }