feat: add disk usage per app (gauge + chart) from du -sb via background collector

Disk usage collected from du -sb on each app home directory in the
10s background collector alongside existing container stats. The value
is stored in the container_stats table (disk_usage_bytes column) and
served to the UI via two paths:

- Page load: GetStatsOverview reads latest from DB
- Realtime WS: diskTicker (10s) reads latest from DB, no extra SSH call

Changes:
- model.go: add DiskUsageBytes to ContainerStats + StatsOverview
- schema.sql + db.go: add disk_usage_bytes column + ALTER TABLE migration
- repository.go: update all queries + add ContainerStatsDiskHistory
- stats.go: add collectDiskUsage helper, wire into collectors + LiveSnapshot
- service.go: map DiskUsageBytes in GetStatsOverview
- app_stats_ws.go: add diskTicker + disk_usage_bytes in WS JSON payload
- apps_stats_card.html: add disk gauge + SVG chart
- apps_detail.html: add disk to initLiveCharts metrics/lines/onData
- mock.go: add du -sb mock response

Author: coderbuzz

internal/app/model.go

@@ -55,6 +55,7 @@ type ContainerStats struct {
 	BlockIORead    int64     `json:"block_io_read"`
 	BlockIOWrite   int64     `json:"block_io_write"`
 	PIDs           int       `json:"pids"`
+	DiskUsageBytes int64     `json:"disk_usage_bytes"`
 	CreatedAt      time.Time `json:"created_at"`
 }
 
@@ -83,6 +84,7 @@ type StatsOverview struct {
 	BlockIORead    int64   `json:"block_io_read"`
 	BlockIOWrite   int64   `json:"block_io_write"`
 	PIDs           int     `json:"pids"`
+	DiskUsageBytes int64   `json:"disk_usage_bytes"`
 	ContainerName  string  `json:"container_name"`
 }
 

internal/app/repository.go

@@ -576,18 +576,18 @@ func nullInt64(i int64) interface{} {
 
 func (r *Repository) InsertContainerStats(s *ContainerStats) error {
 	_, err := r.db.Exec(`
-		INSERT INTO container_stats (app_id, server_id, container_name, cpu_percent, mem_usage_bytes, mem_limit_bytes, mem_percent, net_io_rx_bytes, net_io_tx_bytes, block_io_read, block_io_write, pids)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-	`, s.AppID, s.ServerID, s.ContainerName, s.CPUPercent, s.MemUsageBytes, s.MemLimitBytes, s.MemPercent, s.NetIORxBytes, s.NetIOTxBytes, s.BlockIORead, s.BlockIOWrite, s.PIDs)
+		INSERT INTO container_stats (app_id, server_id, container_name, cpu_percent, mem_usage_bytes, mem_limit_bytes, mem_percent, net_io_rx_bytes, net_io_tx_bytes, block_io_read, block_io_write, pids, disk_usage_bytes)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+	`, s.AppID, s.ServerID, s.ContainerName, s.CPUPercent, s.MemUsageBytes, s.MemLimitBytes, s.MemPercent, s.NetIORxBytes, s.NetIOTxBytes, s.BlockIORead, s.BlockIOWrite, s.PIDs, s.DiskUsageBytes)
 	return err
 }
 
 func (r *Repository) LatestContainerStats(appID int64) (*ContainerStats, error) {
 	s := &ContainerStats{}
 	err := r.db.QueryRow(`
-		SELECT id, app_id, server_id, container_name, cpu_percent, mem_usage_bytes, mem_limit_bytes, mem_percent, net_io_rx_bytes, net_io_tx_bytes, block_io_read, block_io_write, pids, created_at
+		SELECT id, app_id, server_id, container_name, cpu_percent, mem_usage_bytes, mem_limit_bytes, mem_percent, net_io_rx_bytes, net_io_tx_bytes, block_io_read, block_io_write, pids, disk_usage_bytes, created_at
 		FROM container_stats WHERE app_id = ? ORDER BY created_at DESC LIMIT 1
-	`, appID).Scan(&s.ID, &s.AppID, &s.ServerID, &s.ContainerName, &s.CPUPercent, &s.MemUsageBytes, &s.MemLimitBytes, &s.MemPercent, &s.NetIORxBytes, &s.NetIOTxBytes, &s.BlockIORead, &s.BlockIOWrite, &s.PIDs, &s.CreatedAt)
+	`, appID).Scan(&s.ID, &s.AppID, &s.ServerID, &s.ContainerName, &s.CPUPercent, &s.MemUsageBytes, &s.MemLimitBytes, &s.MemPercent, &s.NetIORxBytes, &s.NetIOTxBytes, &s.BlockIORead, &s.BlockIOWrite, &s.PIDs, &s.DiskUsageBytes, &s.CreatedAt)
 	if err == sql.ErrNoRows {
 		return nil, nil
 	}
@@ -609,7 +609,8 @@ func (r *Repository) LatestAggregatedStats(appID int64) (*ContainerStats, error)
 			SUM(net_io_tx_bytes),
 			SUM(block_io_read),
 			SUM(block_io_write),
-			SUM(pids)
+			SUM(pids),
+			MAX(disk_usage_bytes)
 		FROM container_stats
 		WHERE app_id = ? AND created_at = (
 			SELECT MAX(created_at) FROM container_stats WHERE app_id = ?
@@ -620,7 +621,7 @@ func (r *Repository) LatestAggregatedStats(appID int64) (*ContainerStats, error)
 	var pids sql.NullInt64
 	if err := row.Scan(
 		&s.CPUPercent, &s.MemUsageBytes, &s.MemLimitBytes, &s.MemPercent,
-		&s.NetIORxBytes, &s.NetIOTxBytes, &s.BlockIORead, &s.BlockIOWrite, &pids,
+		&s.NetIORxBytes, &s.NetIOTxBytes, &s.BlockIORead, &s.BlockIOWrite, &pids, &s.DiskUsageBytes,
 	); err == sql.ErrNoRows {
 		return nil, nil
 	} else if err != nil {
@@ -669,6 +670,17 @@ func (r *Repository) ContainerStatsNetHistory(appID int64, since time.Time, buck
 	return r.queryChartPoints(query, appID, since)
 }
 
+func (r *Repository) ContainerStatsDiskHistory(appID int64, since time.Time, bucketMinutes int) ([]ChartPoint, error) {
+	groupBy := fmt.Sprintf("(strftime('%%s', created_at) / %d) * %d", bucketMinutes*60, bucketMinutes*60)
+	query := fmt.Sprintf(`
+		SELECT datetime(%s, 'unixepoch') as bucket, MAX(disk_usage_bytes)
+		FROM container_stats
+		WHERE app_id = ? AND created_at >= ?
+		GROUP BY bucket ORDER BY bucket ASC
+	`, groupBy)
+	return r.queryChartPoints(query, appID, since)
+}
+
 func (r *Repository) queryChartPoints(query string, args ...interface{}) ([]ChartPoint, error) {
 	rows, err := r.db.Query(query, args...)
 	if err != nil {

internal/app/service.go

@@ -699,15 +699,16 @@ func (s *Service) GetStatsOverview(appID int64) *StatsOverview {
 		return nil
 	}
 	return &StatsOverview{
-		CPUPercent:    cs.CPUPercent,
-		MemPercent:    cs.MemPercent,
-		MemUsageBytes: cs.MemUsageBytes,
-		MemLimitBytes: cs.MemLimitBytes,
-		NetIORxBytes:  cs.NetIORxBytes,
-		NetIOTxBytes:  cs.NetIOTxBytes,
-		BlockIORead:   cs.BlockIORead,
-		BlockIOWrite:  cs.BlockIOWrite,
-		PIDs:          cs.PIDs,
+		CPUPercent:     cs.CPUPercent,
+		MemPercent:     cs.MemPercent,
+		MemUsageBytes:  cs.MemUsageBytes,
+		MemLimitBytes:  cs.MemLimitBytes,
+		NetIORxBytes:   cs.NetIORxBytes,
+		NetIOTxBytes:   cs.NetIOTxBytes,
+		BlockIORead:    cs.BlockIORead,
+		BlockIOWrite:   cs.BlockIOWrite,
+		PIDs:           cs.PIDs,
+		DiskUsageBytes: cs.DiskUsageBytes,
 	}
 }
 

internal/app/stats.go

@@ -156,6 +156,7 @@ func (s *Service) collectAllContainerStats(client ssh.Connector, serverID int64,
 		return
 	}
 
+	var parsed []*ContainerStats
 	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
 		line = strings.TrimSpace(line)
 		if line == "" {
@@ -170,15 +171,78 @@ func (s *Service) collectAllContainerStats(client ssh.Connector, serverID int64,
 		if !ok {
 			continue
 		}
-		cs := parseDockerStat(stat, appID, serverID, stat.Name)
-		if cs != nil {
-			if err := s.repo.InsertContainerStats(cs); err != nil {
-				log.Printf("Stats collector: failed to insert stats for %q: %v", stat.Name, err)
-			}
+		if cs := parseDockerStat(stat, appID, serverID, stat.Name); cs != nil {
+			parsed = append(parsed, cs)
+		}
+	}
+
+	if len(parsed) == 0 {
+		return
+	}
+
+	diskSizes := collectDiskUsage(client, apps, containerApp)
+	for _, cs := range parsed {
+		if du, ok := diskSizes[cs.AppID]; ok {
+			cs.DiskUsageBytes = du
+		}
+		if err := s.repo.InsertContainerStats(cs); err != nil {
+			log.Printf("Stats collector: failed to insert stats for %q: %v", cs.ContainerName, err)
 		}
 	}
 }
 
+// collectDiskUsage runs du -sb on each app's home directory in a single SSH
+// round-trip and returns a map of appID -> total bytes.
+func collectDiskUsage(client ssh.Connector, apps []App, containerApp map[string]int64) map[int64]int64 {
+	// Collect unique app IDs that have running containers.
+	seen := make(map[int64]bool)
+	var dirs []string
+	for _, cs := range containerApp {
+		if !seen[cs] {
+			seen[cs] = true
+			dirs = append(dirs, fmt.Sprintf("/opt/dockify/apps/app-%d", cs))
+		}
+	}
+	if len(dirs) == 0 {
+		return nil
+	}
+
+	out, err := client.Exec(fmt.Sprintf("du -sb %s 2>/dev/null", strings.Join(dirs, " ")))
+	if err != nil || strings.TrimSpace(out) == "" {
+		return nil
+	}
+
+	result := make(map[int64]int64, len(dirs))
+	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		parts := strings.Fields(line)
+		if len(parts) < 2 {
+			continue
+		}
+		bytes, err := strconv.ParseInt(parts[0], 10, 64)
+		if err != nil || bytes <= 0 {
+			continue
+		}
+		// Path is /opt/dockify/apps/app-<id>
+		path := parts[1]
+		if !strings.HasPrefix(path, "/opt/dockify/apps/app-") {
+			continue
+		}
+		appIDStr := strings.TrimPrefix(path, "/opt/dockify/apps/app-")
+		appID, err := strconv.ParseInt(appIDStr, 10, 64)
+		if err != nil {
+			continue
+		}
+		if seen[appID] {
+			result[appID] = bytes
+		}
+	}
+	return result
+}
+
 // parseComposeProjectAppID extracts the numeric app id from a compose project
 // name of the form "app-<id>" (the directory name Dockify uses for each app's
 // compose file). Returns 0 if it cannot parse.
@@ -303,7 +367,21 @@ func (s *Service) LiveSnapshot(client ssh.Connector, app *App) (*ContainerStats,
 			parsed = append(parsed, cs)
 		}
 	}
-	return sumStats(parsed), nil
+	agg := sumStats(parsed)
+	if agg == nil {
+		return nil, nil
+	}
+	// Collect disk usage for the app directory.
+	diskDir := fmt.Sprintf("/opt/dockify/apps/app-%d", app.ID)
+	if out, err := client.Exec(fmt.Sprintf("du -sb %s 2>/dev/null", diskDir)); err == nil {
+		fields := strings.Fields(strings.TrimSpace(out))
+		if len(fields) >= 2 {
+			if bytes, err := strconv.ParseInt(fields[0], 10, 64); err == nil && bytes > 0 {
+				agg.DiskUsageBytes = bytes
+			}
+		}
+	}
+	return agg, nil
 }
 
 // StreamStats continuously reads a streaming `docker stats` session for an app's
@@ -608,6 +686,7 @@ func (s *Service) GetStatsHistory(appID int64, duration string) map[string]inter
 	cpu, _ := s.repo.ContainerStatsCPUHistory(appID, since, bucketMins)
 	mem, _ := s.repo.ContainerStatsMemHistory(appID, since, bucketMins)
 	net, _ := s.repo.ContainerStatsNetHistory(appID, since, bucketMins)
+	disk, _ := s.repo.ContainerStatsDiskHistory(appID, since, bucketMins)
 
 	labels := make([]string, len(cpu))
 	for i, p := range cpu {
@@ -618,6 +697,7 @@ func (s *Service) GetStatsHistory(appID int64, duration string) map[string]inter
 		"cpu":    cpu,
 		"memory": mem,
 		"network": net,
+		"disk":   disk,
 		"labels": labels,
 	}
 }

internal/db/db.go

@@ -83,6 +83,7 @@ func Open(path string) (*sql.DB, error) {
 		block_io_read    INTEGER,
 		block_io_write   INTEGER,
 		pids             INTEGER,
+		disk_usage_bytes INTEGER DEFAULT 0,
 		created_at       DATETIME DEFAULT CURRENT_TIMESTAMP
 	)`)
 	db.Exec(`CREATE INDEX IF NOT EXISTS idx_container_stats_app_time ON container_stats(app_id, created_at)`)
@@ -100,6 +101,9 @@ func Open(path string) (*sql.DB, error) {
 	)`)
 	db.Exec(`CREATE INDEX IF NOT EXISTS idx_route_stats_app_time ON route_stats(app_id, created_at)`)
 
+	// Migration: add disk_usage_bytes to container_stats (v0.5.5)
+	db.Exec("ALTER TABLE container_stats ADD COLUMN disk_usage_bytes INTEGER DEFAULT 0")
+
 	// Migration: add server_stats table (v0.13.0)
 	db.Exec(`CREATE TABLE IF NOT EXISTS server_stats (
 		id          INTEGER PRIMARY KEY AUTOINCREMENT,

internal/db/schema.sql

@@ -112,6 +112,7 @@ CREATE TABLE IF NOT EXISTS container_stats (
     block_io_read    INTEGER,
     block_io_write   INTEGER,
     pids             INTEGER,
+    disk_usage_bytes INTEGER DEFAULT 0,
     created_at       DATETIME DEFAULT CURRENT_TIMESTAMP
 );
 CREATE INDEX IF NOT EXISTS idx_container_stats_app_time ON container_stats(app_id, created_at);

internal/http/app_stats_ws.go

@@ -180,6 +180,11 @@ func (h *StatsHandler) ServeLiveAppStats(w http.ResponseWriter, r *http.Request)
 	chartTicker := time.NewTicker(30 * time.Second)
 	defer chartTicker.Stop()
 
+	// Disk usage is collected by the background collector every 10s and stored
+	// in the DB. We read it from the DB at the same cadence — no extra SSH call.
+	diskTicker := time.NewTicker(10 * time.Second)
+	defer diskTicker.Stop()
+
 	// Throttle live emission to ~1/sec (matching the server live stats cadence
 	// and the "per detik" requirement). For multi-container apps, docker stats
 	// streams several lines per interval; we keep only the latest aggregate and
@@ -190,6 +195,7 @@ func (h *StatsHandler) ServeLiveAppStats(w http.ResponseWriter, r *http.Request)
 	var latestSnap *app.ContainerStats
 	var prevNetBytes int64
 	var prevNetTime time.Time
+	var diskUsageBytes int64
 
 	for {
 		select {
@@ -232,6 +238,7 @@ func (h *StatsHandler) ServeLiveAppStats(w http.ResponseWriter, r *http.Request)
 				"net_tx":           cs.NetIOTxBytes,
 				"block_r":          cs.BlockIORead,
 				"block_w":          cs.BlockIOWrite,
+				"disk_usage_bytes": diskUsageBytes,
 				"timestamp":        now.UTC().Format(time.RFC3339),
 			}
 			jsonStr, _ := json.Marshal(data)
@@ -244,6 +251,11 @@ func (h *StatsHandler) ServeLiveAppStats(w http.ResponseWriter, r *http.Request)
 				return
 			}
 
+		case <-diskTicker.C:
+			if stats := h.appSvc.GetStatsOverview(id); stats != nil {
+				diskUsageBytes = stats.DiskUsageBytes
+			}
+
 		case r, ok := <-rangeCh:
 			if !ok {
 				return

internal/http/templates/apps_detail.html

@@ -26,21 +26,22 @@ <h3>Resource Usage</h3>
   <script>
   var appCharts = initLiveCharts({
     wsUrl: 'api/apps/{{.App.ID}}/stats/live',
-    metrics: ['cpu', 'memory', 'network'],
+    metrics: ['cpu', 'memory', 'network', 'disk'],
     gauges: [
       {metric:'cpu', field:'cpu', pctId:'cpu-gauge-pct', fillId:'cpu-gauge-fill'},
       {metric:'memory', field:'memory', pctId:'mem-gauge-pct', fillId:'mem-gauge-fill',
        detailId:'mem-gauge-detail',
        detailFn:function(d){return formatBytes(d.mem_usage_bytes)+' / '+formatBytes(d.mem_limit_bytes);}}
     ],
-    lines: [{metric:'network', field:'network'}],
+    lines: [{metric:'network', field:'network'}, {metric:'disk', field:'disk_usage_bytes'}],
     targetId: 'app-stats-cards',
     liveIndicatorId: 'app-live-indicator',
     onData: function(d) {
       if (d.net_rx !== undefined) { var e=document.getElementById('net-rx'); if(e) e.textContent=formatBytes(d.net_rx)+' RX'; }
       if (d.net_tx !== undefined) { var e=document.getElementById('net-tx'); if(e) e.textContent=formatBytes(d.net_tx)+' TX'; }
       if (d.block_r !== undefined) { var e=document.getElementById('block-r'); if(e) e.textContent=formatBytes(d.block_r)+' R'; }
       if (d.block_w !== undefined) { var e=document.getElementById('block-w'); if(e) e.textContent=formatBytes(d.block_w)+' W'; }
+      if (d.disk_usage_bytes !== undefined) { var e=document.getElementById('disk-usage'); if(e) e.textContent=formatBytes(d.disk_usage_bytes); }
     }
   });
   window.addEventListener('beforeunload', appCharts.disconnect);

internal/http/templates/apps_stats_card.html

@@ -43,6 +43,10 @@ <h3>Resource Usage <span id="app-live-indicator" class="live-badge" style="displ
       <div class="stat-gauge-label">Block I/O</div>
       <div class="stat-gauge-net"><span id="block-r">{{formatBytes .Stats.BlockIORead}} R</span> &middot; <span id="block-w">{{formatBytes .Stats.BlockIOWrite}} W</span></div>
     </div>
+    <div class="stat-gauge">
+      <div class="stat-gauge-label">Disk</div>
+      <div class="stat-gauge-net"><span id="disk-usage">{{formatBytes .Stats.DiskUsageBytes}}</span></div>
+    </div>
   </div>
 
   {{if .ChartData.cpu}}
@@ -82,6 +86,18 @@ <h3>Resource Usage <span id="app-live-indicator" class="live-badge" style="displ
     </svg>
   </div>
   {{end}}
+
+  {{if .ChartData.disk}}
+  {{$diskMax := chartMax .ChartData.disk}}
+  {{if eq $diskMax 0.0}}{{$diskMax = 1.0}}{{end}}
+  <div class="chart-section">
+    <div class="chart-title">Disk Usage</div>
+    <svg class="chart-svg" viewBox="0 0 {{$width}} {{$height}}" preserveAspectRatio="none">
+      <polyline id="disk-chart-line" data-max="{{$diskMax}}" data-points='{{chartPointsJSON .ChartData.disk}}' fill="none" stroke="var(--secondary)" stroke-width="2" stroke-linejoin="round" stroke-linecap="round"
+        points="{{chartPoints .ChartData.disk $width $height $diskMax}}" />
+    </svg>
+  </div>
+  {{end}}
 </div>
 {{else}}
 <div class="card" style="margin-top:1em">

internal/ssh/mock.go

@@ -30,6 +30,7 @@ func NewMockClient() *MockClient {
 			{"NR==2 {gsub(/G/,\"\"); print $2}", "100"},
 			{"NR==2 {gsub(/%/,\"\"); print $5}", "67"},
 			{"head -1 /proc/stat", "23.5"},
+			{"du -sb", "123456789	/opt/dockify/apps/app-16\n987654321	/opt/dockify/apps/app-27"},
 			{"caddy_http_requests_total", mockMetrics()},
 		},
 	}