diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..3ee9c8d
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,23 @@
+name: Test
+
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: stable
+
+      - name: Run unit tests
+        run: make test
+
+      - name: Run integration tests
+        run: make test-it
diff --git a/app/services/metrics/metrics.go b/app/services/metrics/metrics.go
index 287f2c6..1d68d7b 100644
--- a/app/services/metrics/metrics.go
+++ b/app/services/metrics/metrics.go
@@ -14,6 +14,7 @@ import (
 	"hostlink/internal/crypto"
 	"hostlink/internal/networkmetrics"
 	"hostlink/internal/pgmetrics"
+	"hostlink/internal/storagemetrics"
 	"hostlink/internal/sysmetrics"
 )
 
@@ -26,13 +27,14 @@ type Pusher interface {
 }
 
 type metricspusher struct {
-	apiserver        apiserver.MetricsOperations
-	agentstate       agentstate.Operations
-	metricscollector pgmetrics.Collector
-	syscollector     sysmetrics.Collector
-	netcollector     networkmetrics.Collector
-	crypto           crypto.Service
-	privateKeyPath   string
+	apiserver         apiserver.MetricsOperations
+	agentstate        agentstate.Operations
+	metricscollector  pgmetrics.Collector
+	syscollector      sysmetrics.Collector
+	netcollector      networkmetrics.Collector
+	storagecollector  storagemetrics.Collector
+	crypto            crypto.Service
+	privateKeyPath    string
 }
 
 func NewWithConf() (*metricspusher, error) {
@@ -51,6 +53,7 @@ func NewWithConf() (*metricspusher, error) {
 		metricscollector: pgmetrics.New(),
 		syscollector:     sysmetrics.New(),
 		netcollector:     networkmetrics.New(),
+		storagecollector: storagemetrics.New(),
 		crypto:           crypto.NewService(),
 		privateKeyPath:   appconf.AgentPrivateKeyPath(),
 	}, nil
@@ -67,6 +70,7 @@ func NewWithDependencies(
 	pgcollector pgmetrics.Collector,
 	syscollector sysmetrics.Collector,
 	netcollector networkmetrics.Collector,
+	storagecollector storagemetrics.Collector,
 	crypto crypto.Service,
 	privateKeyPath string,
 ) *metricspusher {
@@ -76,6 +80,7 @@ func NewWithDependencies(
 		metricscollector: pgcollector,
 		syscollector:     syscollector,
 		netcollector:     netcollector,
+		storagecollector: storagecollector,
 		crypto:           crypto,
 		privateKeyPath:   privateKeyPath,
 	}
@@ -157,6 +162,24 @@ func (mp *metricspusher) Push(cred credential.Credential) error {
 		})
 	}
 
+	storageMetrics, err := mp.storagecollector.Collect(ctx)
+	if err != nil {
+		collectionErrors = append(collectionErrors, fmt.Errorf("storage metrics: %w", err))
+	} else {
+		for _, sm := range storageMetrics {
+			metricSets = append(metricSets, domainmetrics.MetricSet{
+				Type: domainmetrics.MetricTypeStorage,
+				Attributes: map[string]any{
+					"mount_point":     sm.Attributes.MountPoint,
+					"device":          sm.Attributes.Device,
+					"filesystem_type": sm.Attributes.FilesystemType,
+					"is_read_only":    sm.Attributes.IsReadOnly,
+				},
+				Metrics: sm.Metrics,
+			})
+		}
+	}
+
 	if len(metricSets) == 0 {
 		return fmt.Errorf("all metrics collection failed: %v", collectionErrors)
 	}
diff --git a/app/services/metrics/metrics_test.go b/app/services/metrics/metrics_test.go
index 8babdce..5f797ee 100644
--- a/app/services/metrics/metrics_test.go
+++ b/app/services/metrics/metrics_test.go
@@ -9,6 +9,7 @@ import (
 
 	"hostlink/domain/credential"
 	domainmetrics "hostlink/domain/metrics"
+	"hostlink/internal/storagemetrics"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -90,6 +91,18 @@ func (m *MockNetCollector) Collect(ctx context.Context) (domainmetrics.NetworkMe
 	return args.Get(0).(domainmetrics.NetworkMetrics), args.Error(1)
 }
 
+type MockStorageCollector struct {
+	mock.Mock
+}
+
+func (m *MockStorageCollector) Collect(ctx context.Context) ([]storagemetrics.StorageMetricSet, error) {
+	args := m.Called(ctx)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).([]storagemetrics.StorageMetricSet), args.Error(1)
+}
+
 type MockCrypto struct {
 	mock.Mock
 }
@@ -169,22 +182,24 @@ func (m *MockCrypto) DecryptWithPrivateKey(ciphertextBase64 string, privateKey *
 
 // Test helpers
 type testMocks struct {
-	apiserver    *MockAPIServer
-	agentstate   *MockAgentState
-	collector    *MockCollector
-	syscollector *MockSysCollector
-	netcollector *MockNetCollector
-	crypto       *MockCrypto
+	apiserver        *MockAPIServer
+	agentstate       *MockAgentState
+	collector        *MockCollector
+	syscollector     *MockSysCollector
+	netcollector     *MockNetCollector
+	storagecollector *MockStorageCollector
+	crypto           *MockCrypto
 }
 
 func setupTestMetricsPusher() (*metricspusher, *testMocks) {
 	mocks := &testMocks{
-		apiserver:    new(MockAPIServer),
-		agentstate:   new(MockAgentState),
-		collector:    new(MockCollector),
-		syscollector: new(MockSysCollector),
-		netcollector: new(MockNetCollector),
-		crypto:       new(MockCrypto),
+		apiserver:        new(MockAPIServer),
+		agentstate:       new(MockAgentState),
+		collector:        new(MockCollector),
+		syscollector:     new(MockSysCollector),
+		netcollector:     new(MockNetCollector),
+		storagecollector: new(MockStorageCollector),
+		crypto:           new(MockCrypto),
 	}
 
 	mp := NewWithDependencies(
@@ -193,6 +208,7 @@ func setupTestMetricsPusher() (*metricspusher, *testMocks) {
 		mocks.collector,
 		mocks.syscollector,
 		mocks.netcollector,
+		mocks.storagecollector,
 		mocks.crypto,
 		"/test/key/path",
 	)
@@ -441,11 +457,13 @@ func TestPush_SystemMetricsFailure_StillPushesDbMetrics(t *testing.T) {
 	mocks.syscollector.On("Collect", mock.Anything).
 		Return(domainmetrics.SystemMetrics{}, errors.New("collection failed"))
 	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
 	mocks.collector.On("Collect", testCred).
 		Return(domainmetrics.PostgreSQLDatabaseMetrics{ConnectionsTotal: 5}, nil)
 	mocks.apiserver.On("PushMetrics", mock.Anything, mock.MatchedBy(func(p domainmetrics.MetricPayload) bool {
 		hasNetwork := false
 		hasDb := false
+		hasStorage := false
 		for _, ms := range p.MetricSets {
 			if ms.Type == domainmetrics.MetricTypeNetwork {
 				hasNetwork = true
@@ -453,8 +471,11 @@ func TestPush_SystemMetricsFailure_StillPushesDbMetrics(t *testing.T) {
 			if ms.Type == domainmetrics.MetricTypePostgreSQLDatabase {
 				hasDb = true
 			}
+			if ms.Type == domainmetrics.MetricTypeStorage {
+				hasStorage = true
+			}
 		}
-		return len(p.MetricSets) == 2 && hasNetwork && hasDb
+		return hasNetwork && hasDb && hasStorage
 	})).Return(nil)
 
 	err := mp.Push(testCred)
@@ -473,11 +494,13 @@ func TestPush_DatabaseMetricsFailure_StillPushesSystemMetrics(t *testing.T) {
 	mocks.agentstate.On("GetAgentID").Return("agent-123")
 	setupSysCollectorMocks(mocks.syscollector)
 	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
 	mocks.collector.On("Collect", testCred).
 		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, collectErr)
 	mocks.apiserver.On("PushMetrics", mock.Anything, mock.MatchedBy(func(p domainmetrics.MetricPayload) bool {
 		hasSys := false
 		hasNetwork := false
+		hasStorage := false
 		for _, ms := range p.MetricSets {
 			if ms.Type == domainmetrics.MetricTypeSystem {
 				hasSys = true
@@ -485,8 +508,11 @@ func TestPush_DatabaseMetricsFailure_StillPushesSystemMetrics(t *testing.T) {
 			if ms.Type == domainmetrics.MetricTypeNetwork {
 				hasNetwork = true
 			}
+			if ms.Type == domainmetrics.MetricTypeStorage {
+				hasStorage = true
+			}
 		}
-		return len(p.MetricSets) == 2 && hasSys && hasNetwork
+		return hasSys && hasNetwork && hasStorage
 	})).Return(nil)
 
 	err := mp.Push(testCred)
@@ -506,6 +532,8 @@ func TestPush_AllCollectionsFail(t *testing.T) {
 		Return(domainmetrics.SystemMetrics{}, errors.New("collection failed"))
 	mocks.netcollector.On("Collect", mock.Anything).
 		Return(domainmetrics.NetworkMetrics{}, errors.New("network failed"))
+	mocks.storagecollector.On("Collect", mock.Anything).
+		Return(nil, errors.New("storage failed"))
 	mocks.collector.On("Collect", testCred).
 		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, errors.New("connection refused"))
 
@@ -524,6 +552,7 @@ func TestPush_APIServerPushFailure(t *testing.T) {
 	mocks.agentstate.On("GetAgentID").Return("agent-123")
 	setupSysCollectorMocks(mocks.syscollector)
 	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
 	mocks.collector.On("Collect", testCred).
 		Return(domainmetrics.PostgreSQLDatabaseMetrics{ConnectionsTotal: 5}, nil)
 	mocks.apiserver.On("PushMetrics", mock.Anything, mock.Anything).
@@ -547,6 +576,7 @@ func TestPush_Success_ValidatesPayloadSchema(t *testing.T) {
 	mocks.agentstate.On("GetAgentID").Return("agent-123")
 	setupSysCollectorMocks(mocks.syscollector)
 	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
 	mocks.collector.On("Collect", testCred).
 		Return(domainmetrics.PostgreSQLDatabaseMetrics{
 			ConnectionsTotal:      10,
@@ -571,7 +601,7 @@ func TestPush_Success_ValidatesPayloadSchema(t *testing.T) {
 		if p.Resource.HostName == "" {
 			return false
 		}
-		if len(p.MetricSets) != 3 {
+		if len(p.MetricSets) != 4 {
 			return false
 		}
 
@@ -663,6 +693,7 @@ func TestPush_ContextPropagation(t *testing.T) {
 	mocks.agentstate.On("GetAgentID").Return("agent-123")
 	setupSysCollectorMocks(mocks.syscollector)
 	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
 	mocks.collector.On("Collect", testCred).
 		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, nil)
 	mocks.apiserver.On("PushMetrics", mock.MatchedBy(func(ctx context.Context) bool {
@@ -705,6 +736,7 @@ func TestPush_CredentialPassedCorrectly(t *testing.T) {
 	mocks.agentstate.On("GetAgentID").Return("agent-456")
 	setupSysCollectorMocks(mocks.syscollector)
 	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
 	mocks.collector.On("Collect", mock.MatchedBy(func(c credential.Credential) bool {
 		return c.Host == testCred.Host &&
 			c.Port == testCred.Port &&
@@ -739,3 +771,173 @@ func setupNetCollectorMocks(collector *MockNetCollector) {
 		SentBytesPerSec: 500.0,
 	}, nil)
 }
+
+func setupStorageCollectorMocks(collector *MockStorageCollector) {
+	collector.On("Collect", mock.Anything).Return([]storagemetrics.StorageMetricSet{
+		{
+			Attributes: domainmetrics.StorageAttributes{
+				MountPoint:     "/",
+				Device:         "/dev/sda1",
+				FilesystemType: "ext4",
+				IsReadOnly:     false,
+			},
+			Metrics: domainmetrics.StorageMetrics{
+				DiskTotalBytes:          100000000000,
+				DiskUsedBytes:           60000000000,
+				DiskFreeBytes:           40000000000,
+				DiskUsedPercent:         60.0,
+				DiskFreePercent:         40.0,
+				TotalUtilizationPercent: 25.0,
+			},
+		},
+	}, nil)
+}
+
+// Verifies storage metrics are included in the payload
+func TestPush_IncludesStorageMetrics(t *testing.T) {
+	mp, mocks := setupTestMetricsPusher()
+	testCred := credential.Credential{DataDirectory: "/data"}
+
+	mocks.agentstate.On("GetAgentID").Return("agent-123")
+	setupSysCollectorMocks(mocks.syscollector)
+	setupNetCollectorMocks(mocks.netcollector)
+	setupStorageCollectorMocks(mocks.storagecollector)
+	mocks.collector.On("Collect", testCred).
+		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, nil)
+	mocks.apiserver.On("PushMetrics", mock.Anything, mock.MatchedBy(func(p domainmetrics.MetricPayload) bool {
+		hasStorage := false
+		for _, ms := range p.MetricSets {
+			if ms.Type == domainmetrics.MetricTypeStorage {
+				hasStorage = true
+			}
+		}
+		return hasStorage
+	})).Return(nil)
+
+	err := mp.Push(testCred)
+
+	assert.NoError(t, err)
+	mocks.storagecollector.AssertExpectations(t)
+	mocks.apiserver.AssertExpectations(t)
+}
+
+// Verifies when storage collection fails, other metrics still pushed
+func TestPush_StorageMetricsFailure_StillPushesOtherMetrics(t *testing.T) {
+	mp, mocks := setupTestMetricsPusher()
+	testCred := credential.Credential{DataDirectory: "/data"}
+
+	mocks.agentstate.On("GetAgentID").Return("agent-123")
+	setupSysCollectorMocks(mocks.syscollector)
+	setupNetCollectorMocks(mocks.netcollector)
+	mocks.storagecollector.On("Collect", mock.Anything).
+		Return(nil, errors.New("storage collection failed"))
+	mocks.collector.On("Collect", testCred).
+		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, nil)
+	mocks.apiserver.On("PushMetrics", mock.Anything, mock.MatchedBy(func(p domainmetrics.MetricPayload) bool {
+		hasSys := false
+		hasNet := false
+		hasDb := false
+		for _, ms := range p.MetricSets {
+			if ms.Type == domainmetrics.MetricTypeSystem {
+				hasSys = true
+			}
+			if ms.Type == domainmetrics.MetricTypeNetwork {
+				hasNet = true
+			}
+			if ms.Type == domainmetrics.MetricTypePostgreSQLDatabase {
+				hasDb = true
+			}
+		}
+		return hasSys && hasNet && hasDb
+	})).Return(nil)
+
+	err := mp.Push(testCred)
+
+	assert.NoError(t, err)
+	mocks.apiserver.AssertExpectations(t)
+}
+
+// Verifies each mount becomes a separate MetricSet
+func TestPush_StorageMetricsMultipleMounts(t *testing.T) {
+	mp, mocks := setupTestMetricsPusher()
+	testCred := credential.Credential{DataDirectory: "/data"}
+
+	mocks.agentstate.On("GetAgentID").Return("agent-123")
+	setupSysCollectorMocks(mocks.syscollector)
+	setupNetCollectorMocks(mocks.netcollector)
+	mocks.storagecollector.On("Collect", mock.Anything).Return([]storagemetrics.StorageMetricSet{
+		{
+			Attributes: domainmetrics.StorageAttributes{MountPoint: "/", Device: "/dev/sda1"},
+			Metrics:    domainmetrics.StorageMetrics{DiskUsedPercent: 50.0},
+		},
+		{
+			Attributes: domainmetrics.StorageAttributes{MountPoint: "/home", Device: "/dev/sda2"},
+			Metrics:    domainmetrics.StorageMetrics{DiskUsedPercent: 75.0},
+		},
+	}, nil)
+	mocks.collector.On("Collect", testCred).
+		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, nil)
+	mocks.apiserver.On("PushMetrics", mock.Anything, mock.MatchedBy(func(p domainmetrics.MetricPayload) bool {
+		storageCount := 0
+		for _, ms := range p.MetricSets {
+			if ms.Type == domainmetrics.MetricTypeStorage {
+				storageCount++
+			}
+		}
+		return storageCount == 2
+	})).Return(nil)
+
+	err := mp.Push(testCred)
+
+	assert.NoError(t, err)
+	mocks.apiserver.AssertExpectations(t)
+}
+
+// Verifies attributes are set correctly
+func TestPush_StorageMetricsWithAttributes(t *testing.T) {
+	mp, mocks := setupTestMetricsPusher()
+	testCred := credential.Credential{DataDirectory: "/data"}
+
+	mocks.agentstate.On("GetAgentID").Return("agent-123")
+	setupSysCollectorMocks(mocks.syscollector)
+	setupNetCollectorMocks(mocks.netcollector)
+	mocks.storagecollector.On("Collect", mock.Anything).Return([]storagemetrics.StorageMetricSet{
+		{
+			Attributes: domainmetrics.StorageAttributes{
+				MountPoint:     "/data",
+				Device:         "/dev/nvme0n1p1",
+				FilesystemType: "xfs",
+				IsReadOnly:     true,
+			},
+			Metrics: domainmetrics.StorageMetrics{DiskUsedPercent: 80.0},
+		},
+	}, nil)
+	mocks.collector.On("Collect", testCred).
+		Return(domainmetrics.PostgreSQLDatabaseMetrics{}, nil)
+	mocks.apiserver.On("PushMetrics", mock.Anything, mock.MatchedBy(func(p domainmetrics.MetricPayload) bool {
+		for _, ms := range p.MetricSets {
+			if ms.Type == domainmetrics.MetricTypeStorage {
+				attrs := ms.Attributes
+				if attrs["mount_point"] != "/data" {
+					return false
+				}
+				if attrs["device"] != "/dev/nvme0n1p1" {
+					return false
+				}
+				if attrs["filesystem_type"] != "xfs" {
+					return false
+				}
+				if attrs["is_read_only"] != true {
+					return false
+				}
+				return true
+			}
+		}
+		return false
+	})).Return(nil)
+
+	err := mp.Push(testCred)
+
+	assert.NoError(t, err)
+	mocks.apiserver.AssertExpectations(t)
+}
diff --git a/docs/spec-storage-metrics.md b/docs/spec-storage-metrics.md
new file mode 100644
index 0000000..8cfd4cf
--- /dev/null
+++ b/docs/spec-storage-metrics.md
@@ -0,0 +1,1002 @@
+# Storage Metrics Collector - Technical Specification
+
+## Overview
+
+The storage metrics collector gathers disk and filesystem metrics from Linux systems and sends them to an API endpoint. Each mount point generates a separate metric set entry.
+
+## Data Sources
+
+### Primary Sources
+
+| Source | Purpose |
+|--------|---------|
+| `/proc/self/mountinfo` | Mount point enumeration (preferred) |
+| `/proc/self/mounts` | Fallback mount enumeration |
+| `/etc/mtab` | Secondary fallback mount enumeration |
+| `/proc/diskstats` | I/O statistics (utilization, throughput, IOPS) |
+| `statfs()` syscall | Space and inode metrics |
+| `/proc/partitions` | Device major:minor resolution |
+
+### Mount Info File Formats
+
+**`/proc/self/mountinfo` format:**
+```
+36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
+```
+- Field 5 (index 4): mount point (`/mnt2`)
+- After `-` separator: filesystem type (`ext3`), device (`/dev/root`)
+- Mount options in field 6
+
+**`/proc/self/mounts` and `/etc/mtab` format:**
+```
+/dev/sda1 / ext4 rw,relatime 0 0
+```
+- Field 1 (index 0): device
+- Field 2 (index 1): mount point
+- Field 3 (index 2): filesystem type
+- Field 4 (index 3): mount options
+
+### `/proc/diskstats` Format
+
+```
+   8       0 sda 12345 1234 567890 12345 ...
+```
+
+| Field | Index | Description | Unit |
+|-------|-------|-------------|------|
+| 1 | 0 | Major number | - |
+| 2 | 1 | Minor number | - |
+| 3 | 2 | Device name | string |
+| 4 | 3 | Reads completed | count |
+| 5 | 4 | Reads merged | count |
+| 6 | 5 | Sectors read | sectors |
+| 7 | 6 | Read time | ms |
+| 8 | 7 | Writes completed | count |
+| 9 | 8 | Writes merged | count |
+| 10 | 9 | Sectors written | sectors |
+| 11 | 10 | Write time | ms |
+| 12 | 11 | I/Os in progress | count |
+| 13 | 12 | I/O time | ms |
+| 14 | 13 | Weighted I/O time | ms |
+
+---
+
+## Field Definitions
+
+### Static Labels (per mount point)
+
+| Field | Type | Source | Extraction Method |
+|-------|------|--------|-------------------|
+| `mount_point` | string | mountinfo/mounts | Field index 4 (mountinfo) or 1 (mounts) |
+| `device` | string | mountinfo/mounts | After `-` separator (mountinfo) or field 0 (mounts) |
+| `filesystem_type` | string | mountinfo/mounts | After device in mountinfo, or field 2 in mounts |
+| `is_read_only` | bool | mount options | `true` if "ro" present in options, else `false` |
+
+**Supported Filesystem Types:**
+Only collect metrics for: `xfs`, `btrfs`, `ext`, `ext2`, `ext3`, `ext4`, `hfs`, `vxfs`, `reiserfs`
+
+Skip mount points with unsupported filesystem types.
+
+**Skipped Filesystem Types:**
+- Virtual filesystems: `proc`, `sysfs`, `devtmpfs`, `tmpfs`, `devpts`, `cgroup`, `cgroup2`, `securityfs`, `debugfs`, `tracefs`, `configfs`, `fusectl`, `mqueue`, `hugetlbfs`, `pstore`, `bpf`
+- Container filesystems: `overlay`, `overlayfs`, `aufs`, `shiftfs`
+- Network filesystems (if not explicitly enabled): `nfs`, `nfs4`, `cifs`, `smb`, `fuse.sshfs`
+
+### Space Metrics (from statfs syscall)
+
+| Field | Type | Formula |
+|-------|------|---------|
+| `disk_total_bytes` | float64 | `f_blocks * f_bsize` |
+| `disk_free_bytes` | float64 | `f_bavail * f_bsize` (available to non-root) |
+| `disk_used_bytes` | float64 | `(f_blocks - f_bfree) * f_bsize` |
+| `disk_used_percent` | float64 | `disk_used_bytes / (disk_used_bytes + disk_free_bytes) * 100` |
+| `disk_free_percent` | float64 | `100 - disk_used_percent` |
+
+**Note:** `disk_used_percent` uses `disk_free_bytes` (available space) not total free space. This excludes reserved blocks and accurately reflects what users can actually use.
+
+### Inode Metrics (from statfs syscall)
+
+| Field | Type | Formula |
+|-------|------|---------|
+| `inodes_total` | uint64 | `f_files` |
+| `inodes_free` | uint64 | `f_ffree` |
+| `inodes_used` | uint64 | `f_files - f_ffree` |
+| `inodes_used_percent` | float64 | `inodes_used / inodes_total * 100` |
+
+### I/O Utilization Metrics (from /proc/diskstats)
+
+| Field | Type | Formula |
+|-------|------|---------|
+| `total_utilization_percent` | float64 | `(current_io_time - previous_io_time) / elapsed_ms * 100` (capped at 100%) |
+| `read_utilization_percent` | float64 | `total_utilization_percent * (read_time_delta / (read_time_delta + write_time_delta))` |
+| `write_utilization_percent` | float64 | `total_utilization_percent * (write_time_delta / (read_time_delta + write_time_delta))` |
+
+Where:
+- `io_time`: diskstats field 13 (index 12)
+- `read_time`: diskstats field 7 (index 6)
+- `write_time`: diskstats field 11 (index 10)
+- `elapsed_ms`: time since last collection in milliseconds
+
+### Throughput Metrics (from /proc/diskstats)
+
+| Field | Type | Formula |
+|-------|------|---------|
+| `read_bytes_per_second` | float64 | `(current_sectors_read - previous_sectors_read) * 512 / elapsed_seconds` |
+| `write_bytes_per_second` | float64 | `(current_sectors_written - previous_sectors_written) * 512 / elapsed_seconds` |
+| `read_write_bytes_per_second` | float64 | `read_bytes_per_second + write_bytes_per_second` |
+
+Where:
+- `sectors_read`: diskstats field 6 (index 5)
+- `sectors_written`: diskstats field 10 (index 9)
+- Sector size: 512 bytes (Linux standard)
+
+### IOPS Metrics (from /proc/diskstats)
+
+| Field | Type | Formula |
+|-------|------|---------|
+| `read_io_per_second` | float64 | `(current_reads_completed - previous_reads_completed) / elapsed_seconds` |
+| `write_io_per_second` | float64 | `(current_writes_completed - previous_writes_completed) / elapsed_seconds` |
+
+Where:
+- `reads_completed`: diskstats field 4 (index 3)
+- `writes_completed`: diskstats field 8 (index 7)
+
+---
+
+## Device Mapping Rules
+
+### Device Resolution Strategy
+
+| Device Type | Mount File Pattern | Diskstats Key | Resolution Method |
+|-------------|-------------------|---------------|-------------------|
+| Regular | `/dev/sda1` | `sda1` | Strip `/dev/` prefix |
+| LVM | `/dev/mapper/vg-lv` | `dm-X` | Resolve via major:minor from mountinfo |
+| Root pseudo | `/dev/root` | varies | Resolve via `/proc/partitions` using major:minor |
+
+### LVM Device Resolution
+
+1. Parse major:minor from mountinfo (field 3, format `major:minor`)
+2. Read `/proc/diskstats` to find matching `dm-X` device
+3. Use the `dm-X` name for diskstats lookups
+
+### /dev/root Resolution
+
+1. Get major:minor for `/dev/root` from mountinfo
+2. Read `/proc/partitions` to find device name matching major:minor
+3. Use resolved device name for diskstats lookups
+
+---
+
+## API Contract
+
+### Endpoint
+
+```
+POST /api/v1/agents/{agent_id}/metrics
+```
+
+### Headers
+
+```
+Content-Type: application/json
+```
+
+### Payload Structure
+
+```json
+{
+  "version": "1.0",
+  "timestamp_ms": 1703001234567,
+  "resource": {
+    "agent_id": "agent-123-abc"
+  },
+  "metric_sets": [
+    {
+      "type": "storage",
+      "attributes": {
+        "mount_point": "/",
+        "device": "/dev/sda1",
+        "filesystem_type": "ext4",
+        "is_read_only": false
+      },
+      "metrics": {
+        "disk_used_bytes": 50000000000.0,
+        "disk_free_bytes": 50000000000.0,
+        "disk_total_bytes": 100000000000.0,
+        "disk_used_percent": 50.0,
+        "disk_free_percent": 50.0,
+        "total_utilization_percent": 25.5,
+        "read_utilization_percent": 15.2,
+        "write_utilization_percent": 10.3,
+        "read_bytes_per_second": 5242880.0,
+        "write_bytes_per_second": 2097152.0,
+        "read_write_bytes_per_second": 7340032.0,
+        "read_io_per_second": 150.5,
+        "write_io_per_second": 80.3,
+        "inodes_used": 500000,
+        "inodes_free": 9500000,
+        "inodes_total": 10000000,
+        "inodes_used_percent": 5.0
+      }
+    },
+    {
+      "type": "storage",
+      "attributes": {
+        "mount_point": "/data",
+        "device": "/dev/sdb1",
+        "filesystem_type": "xfs",
+        "is_read_only": false
+      },
+      "metrics": { ... }
+    }
+  ]
+}
+```
+
+### Type Constant
+
+Add to `domain/metrics/metrics.go`:
+```go
+MetricTypeStorage = "storage"
+```
+
+---
+
+## Edge Cases and Error Handling
+
+### Bind Mounts and Shared Devices
+
+Report each mount point as a separate metric set, with shared I/O metrics across mounts of the same device.
+
+**Rationale:**
+
+| Concern | Decision |
+|---------|----------|
+| Capacity metrics | Unique per mount — users monitor specific paths for disk space alerts (e.g., /var/log at 90%) |
+| I/O metrics | Shared across mounts — block-level operations occur at the device layer, not per path |
+| Deduplication | Not performed — would lose visibility into individual mount point usage |
+
+**Metric Classification:**
+
+| Category | Metrics | Source | Unique Per Mount? |
+|----------|---------|--------|-------------------|
+| Identity | mount_point, device, filesystem_type, is_read_only | Mount info | Yes |
+| Capacity | disk_used/free/total_bytes, disk_used/free_percent | statfs() | Yes |
+| Inodes | inodes_used/free/total, inodes_used_percent | statfs() | Yes |
+| Throughput | read/write/read_write_bytes_per_second | /proc/diskstats | No (shared) |
+| IOPS | read/write_io_per_second | /proc/diskstats | No (shared) |
+| Utilization | total/read/write_utilization_percent | /proc/diskstats | No (shared) |
+
+**Algorithm:**
+
+1. Parse mount info and group mount points by underlying device
+2. For each mount point, query statfs() independently (capacity + inodes)
+3. For each unique device, read /proc/diskstats and calculate deltas
+4. For each mount point: attach capacity metrics (unique) + I/O metrics from parent device (shared)
+
+**Bind Mount Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Bind mount of subdirectory | Report as separate mount; capacity reflects subdirectory view |
+| Read-only remount | Report with is_read_only: true; I/O metrics still shared with writable mount |
+| Device unmounted mid-collection | Skip mount point; log warning |
+| No previous I/O sample | Return 0.0 for I/O metrics on first collection cycle |
+
+### Mount Disappear/Reappear
+
+A mount can disappear between samples (unmounted, failed, container stopped) and later reappear. Delta calculations must handle stale previous values, counter resets after remount, and time gaps.
+
+**Decision:** Track per-device "last seen" timestamp. Skip delta calculation if device was absent in previous sample.
+
+**Algorithm:**
+
+1. Maintain two maps:
+   - `lastStats[device]` → I/O counters
+   - `lastSeen[device]` → sample timestamp
+
+2. On each sample, for each device:
+   - If device NOT in lastSeen OR lastSeen[device] != previousSampleTime:
+     - Device is new or was missing last sample
+     - Emit capacity metrics only (no I/O deltas)
+   - Else:
+     - Device was present in previous sample
+     - Calculate deltas normally with counter wrap check
+   - Update lastSeen[device] = currentTime
+   - Update lastStats[device] = currentCounters
+
+3. Cleanup: Remove stale entries to prevent unbounded memory growth
+
+**State Cleanup:**
+
+Devices that disappear leave orphaned entries in `lastStats` and `lastSeen` maps. Periodic cleanup removes entries not seen for N consecutive samples.
+
+```go
+const staleThreshold = 3  // Remove after missing 3 samples
+
+func cleanupStaleEntries(currentDevices map[string]bool) {
+    for device := range lastSeen {
+        if !currentDevices[device] {
+            missedSamples[device]++
+            if missedSamples[device] >= staleThreshold {
+                delete(lastStats, device)
+                delete(lastSeen, device)
+                delete(missedSamples, device)
+            }
+        } else {
+            missedSamples[device] = 0
+        }
+    }
+}
+```
+
+**Why not immediate removal?**
+- Device might be temporarily unavailable (slow NFS mount)
+- Brief unmount/remount cycles shouldn't lose state
+- 3-sample threshold balances memory vs resilience
+
+**Output Behavior:**
+
+| Scenario | Capacity Metrics | I/O Metrics |
+|----------|------------------|-------------|
+| Normal sample | ✓ Reported | ✓ Reported |
+| First sample ever | ✓ Reported | Return 0.0 |
+| Device new this sample | ✓ Reported | Return 0.0 |
+| Device missing last sample, back now | ✓ Reported | Return 0.0 |
+| Device present consecutively | ✓ Reported | ✓ Reported |
+| Counter reset detected | ✓ Reported | Return 0.0 |
+
+**Example Timeline:**
+
+```
+T0: /dev/sdb1 at /data     → { capacity: ✓, io: 0.0 (first sample) }
+T1: /dev/sdb1 at /data     → { capacity: ✓, io: ✓ }
+T2: /data unmounted        → (nothing for /data)
+T3: /data remounted        → { capacity: ✓, io: 0.0 (gap detected) }
+T4: /dev/sdb1 at /data     → { capacity: ✓, io: ✓ }
+```
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Device remounted with different name | Treated as new device |
+| Same device, different mount point | Both mounts share I/O stats |
+| Very long unmount (hours) | Cleanup removes stale entries; treated as new on return |
+| Rapid mount/unmount flapping | Each reappearance returns 0.0 for I/O for one sample |
+
+### Partition vs Whole Disk Stats
+
+`/proc/diskstats` contains entries for both whole disks (sda) and partitions (sda1, sda2). When `/dev/sda1` is mounted, the collector must decide which stats to use.
+
+**Decision:** Always use partition-level stats that match the mounted device.
+
+**Rationale:**
+
+| Concern | Decision |
+|---------|----------|
+| Accuracy | Partition stats reflect only that partition's I/O |
+| Consistency | Matches the capacity metrics which are partition-scoped |
+| Whole disk mounted | Rare case; use sda stats (correct for that scenario) |
+| Aggregation | Users can sum partitions if they need disk-level totals |
+
+**Mapping Rules:**
+
+| Mount Path Pattern | Diskstats Key | Example |
+|--------------------|---------------|---------|
+| /dev/sdXN | sdXN | /dev/sda1 → sda1 |
+| /dev/sdX (whole disk) | sdX | /dev/sdb → sdb |
+| /dev/nvme* | Full name | /dev/nvme0n1p1 → nvme0n1p1 |
+| /dev/mapper/* | dm-N | Resolve via major:minor |
+| /dev/root | Resolved name | Lookup in /proc/partitions |
+
+**Algorithm:**
+
+```
+func getDiskstatsKey(mountDevice):
+    if isLVM(mountDevice):
+        # /dev/mapper/vg-lv -> dm-X
+        majorMinor = lookupMajorMinor(mountDevice)
+        return "dm-" + minor
+
+    if isRootDevice(mountDevice):
+        # /dev/root -> resolve actual device
+        majorMinor = lookupMajorMinor(mountDevice)
+        return lookupDeviceName(majorMinor)
+
+    # /dev/sda1 -> sda1, /dev/nvme0n1p1 -> nvme0n1p1
+    return strings.TrimPrefix(mountDevice, "/dev/")
+```
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Whole disk mounted (/dev/sda) | Use sda stats (unusual but valid) |
+| NVMe partition (/dev/nvme0n1p1) | Use nvme0n1p1 stats |
+| Software RAID (/dev/md0) | Use md0 stats |
+| Loop device (/dev/loop0) | Use loop0 stats (if supported FS) |
+| No matching diskstats entry | Return 0.0 for I/O metrics, log warning |
+
+**Example:**
+
+System with `/dev/sda1` at `/` and `/dev/sda2` at `/home`:
+
+```
+/proc/diskstats:
+   sda   - 1000 reads, 800 writes (aggregate)
+   sda1  - 600 reads, 500 writes
+   sda2  - 400 reads, 300 writes
+
+Output:
+  { mount_point: "/",     device: "/dev/sda1", read_io: <from sda1> }
+  { mount_point: "/home", device: "/dev/sda2", read_io: <from sda2> }
+```
+
+Note: `sda` aggregate stats are never used unless `/dev/sda` itself is mounted as a filesystem (uncommon).
+
+### Symlink Device Paths
+
+Devices can be mounted using stable symlinks:
+- `/dev/disk/by-uuid/<uuid>`
+- `/dev/disk/by-label/<label>`
+- `/dev/disk/by-id/<id>`
+- `/dev/disk/by-path/<path>`
+
+These are symlinks to actual block devices (`/dev/sda1`). Without resolution, device mapping fails and I/O metrics are unavailable.
+
+**Decision:** Resolve symlinks before device mapping. Report original path in output.
+
+**Implementation:**
+
+```go
+func resolveDevicePath(devicePath string) string {
+    resolved, err := filepath.EvalSymlinks(devicePath)
+    if err != nil {
+        return devicePath  // Not a symlink or error; use original
+    }
+    return resolved
+}
+```
+
+**Resolution Examples:**
+
+| Mount Device | Symlink Target | Diskstats Key |
+|--------------|----------------|---------------|
+| /dev/disk/by-uuid/abc-123 | /dev/sda1 | sda1 |
+| /dev/disk/by-label/DATA | /dev/nvme0n1p2 | nvme0n1p2 |
+| /dev/disk/by-id/ata-WD... | /dev/sdb | sdb |
+| /dev/sda1 (not symlink) | — | sda1 |
+
+**Output Behavior:**
+
+Report original path (user-facing), use resolved path internally for diskstats lookup:
+
+```json
+{
+  "mount_point": "/data",
+  "device": "/dev/disk/by-uuid/abcd-1234",
+  "read_bytes_per_second": 1048576
+}
+```
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Broken symlink | EvalSymlinks fails; use original path; return 0.0 for I/O |
+| Nested symlinks | EvalSymlinks resolves fully |
+| Symlink to LVM | Resolved to /dev/dm-X; existing LVM logic handles |
+| Symlink to NVMe | Resolved to /dev/nvme0n1p1; standard path handling |
+
+### Btrfs Subvolumes
+
+Btrfs subvolumes present unique challenges:
+1. Multiple mount points share one device
+2. `statfs()` returns pool-level capacity (not per-subvolume)
+3. With quotas, `statfs()` returns quota limits instead
+4. No way to get true per-subvolume usage via standard syscalls
+
+**Current Behavior:**
+
+| Feature | Behavior |
+|---------|----------|
+| Detection | ✓ btrfs in supported filesystems |
+| Separate samples | ✓ One per subvolume mount |
+| Capacity via statfs | ⚠️ Pool-level or quota-level, not subvolume-level |
+| I/O metrics | ✓ Shared (correct — all subvolumes use same device) |
+| Per-subvolume usage | ✗ Not available via statfs |
+
+**Capacity Interpretation:**
+
+| Scenario | statfs() Reports | Meaning |
+|----------|------------------|---------|
+| No quotas | Pool total/free | All subvolumes show same values |
+| With qgroup quota | Quota limit as total | Per-subvolume quota, not pool |
+| Mixed | Varies per subvolume | Depends on quota assignment |
+
+**Design Decision:** Report statfs as-is. Do not implement btrfs-specific sampling (high complexity, requires root).
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Nested subvolumes | Each mount gets separate sample |
+| Subvolume without quota | Reports pool capacity |
+| Subvolume with quota | Reports quota as total |
+| Snapshot subvolumes | Reported if mounted; capacity shared with source |
+| btrfs RAID (multiple devices) | All devices in pool; I/O per-device in diskstats |
+
+**User Guidance:**
+
+- Capacity alerts may trigger on all subvolumes simultaneously (same pool)
+- I/O metrics are identical across subvolumes (expected — same device)
+- For true per-subvolume usage, use `btrfs filesystem du` outside of agent
+- Enable qgroups if per-subvolume quota limits are needed
+
+### Zero Block Size (f_bsize == 0)
+
+The `statfs()` syscall may return `f_bsize == 0`, causing all byte calculations to produce zero and percentage calculations to produce NaN.
+
+**When This Occurs:**
+
+| Scenario | Cause |
+|----------|-------|
+| Pseudo-filesystem slipped through filter | procfs, sysfs not properly excluded |
+| FUSE filesystem bug | Backend returns invalid block size |
+| Network filesystem timeout | Stale mount returns zeroed struct |
+| Unmounting in progress | Race condition during sample |
+
+**Failure Modes Without Protection:**
+
+| Calculation | Result | Problem |
+|-------------|--------|---------|
+| total = blocks * 0 | 0 | Looks like empty filesystem |
+| used_percent = 0 / (0 + 0) | NaN | Invalid JSON, crashes parsers |
+
+**Algorithm:**
+
+```go
+func collectCapacityMetrics(mountPath string) *CapacityMetrics {
+    stats := statfs(mountPath)
+
+    // Layer 1: Block size check
+    if stats.Bsize == 0 {
+        log.Warnf("Invalid block size (0) for %s, skipping capacity", mountPath)
+        return nil
+    }
+
+    total := uint64(stats.Blocks) * uint64(stats.Bsize)
+    free := uint64(stats.Bavail) * uint64(stats.Bsize)
+    used := (uint64(stats.Blocks) - uint64(stats.Bfree)) * uint64(stats.Bsize)
+
+    // Layer 2: Zero result check
+    if total == 0 && free == 0 && used == 0 {
+        log.Warnf("All capacity values zero for %s, skipping", mountPath)
+        return nil
+    }
+
+    // Layer 3: Safe percentage calculation
+    var usedPercent, freePercent float64
+    denominator := used + free
+    if denominator > 0 {
+        usedPercent = float64(used) / float64(denominator) * 100
+        freePercent = 100 - usedPercent
+    }
+
+    return &CapacityMetrics{...}
+}
+```
+
+**Defense Layers:**
+
+| Layer | Check | Action |
+|-------|-------|--------|
+| 1. Filesystem filter | Exclude known pseudo-filesystems | Skip mount entirely |
+| 2. Block size check | f_bsize == 0 | Skip capacity metrics |
+| 3. Zero result check | total == free == used == 0 | Skip capacity metrics |
+| 4. Division guard | denominator == 0 | Return 0.0 for percentages |
+| 5. Float validation | isNaN() or isInf() | Return 0.0 |
+
+**Legitimate Empty Filesystem:**
+
+A newly created filesystem may have `f_bavail == f_blocks` (100% free). This is valid:
+
+```
+f_bsize = 4096, f_blocks = 1000, f_bfree = 1000
+total = 4096000, free = 4096000, used = 0
+used_percent = 0%  # Valid — do not filter
+```
+
+Only filter when `f_bsize == 0` or all calculated values are zero.
+
+### Device Name Changes
+
+Linux device names are not stable:
+- `/dev/sda` can become `/dev/sdb` after reboot (depends on probe order)
+- Hot-swap or udev rules can rename devices at runtime
+- State keyed by device name becomes invalid after rename
+
+**Decision:** Use in-memory state only. Accept one-sample gap after device name changes.
+
+**Rationale:**
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| In-memory, name-keyed (chosen) | Simple, no persistence complexity | One-sample gap after rename |
+| Persistent state, name-keyed | Survives restart | Stale data after reboot rename |
+| Persistent state, major:minor-keyed | Stable across renames | major:minor can also change; adds complexity |
+| Persistent state, UUID/serial-keyed | Most stable | Requires additional lookups; not all devices have UUIDs |
+
+**Behavioral Specification:**
+
+| Event | Behavior |
+|-------|----------|
+| Agent start | Empty state; return 0.0 for I/O on first sample |
+| Device name changes (reboot) | Agent restart clears state; treated as fresh start |
+| Device name changes (runtime) | Old name orphaned; new name treated as new device; one-sample gap |
+| Device disappears | Remains in state until cleanup (see Mount Disappear/Reappear) |
+
+**State Management:**
+
+```
+State:
+    lastStats: map[deviceName] -> ioCounters  # in-memory only
+
+Lifecycle:
+    Agent Start  → lastStats = {}
+    Each Sample  → lastStats[device] = currentCounters
+    Agent Stop   → lastStats discarded (not persisted)
+```
+
+**Why Not Use major:minor for State Key?**
+
+1. major:minor can also change — not guaranteed stable across reboots
+2. Adds lookup overhead — must resolve name→major:minor each sample
+3. Diminishing returns — reboot already clears state anyway
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| sda→sdb after reboot | Agent restarts; fresh state; no issue |
+| sda→sdb during runtime | sda orphaned; sdb treated as new; one-sample gap |
+| Same physical disk, new partition table | New partition names; treated as new devices |
+| LVM rename | dm-X number may change; one-sample gap |
+| NVMe namespace change | New name; one-sample gap |
+
+**Example Timeline:**
+
+```
+T0: Boot, /dev/sda1 at /
+    Agent starts, lastStats = {}
+    Output: { device: "/dev/sda1", io_metrics: 0.0 }
+
+T1: Normal sample
+    lastStats["sda1"] = { reads: 1000 }
+    Output: { device: "/dev/sda1", read_io_per_second: 50 }
+
+-- Reboot, sda1 becomes sdb1 --
+
+T2: Boot, /dev/sdb1 at /
+    Agent starts, lastStats = {}
+    Output: { device: "/dev/sdb1", io_metrics: 0.0 }
+
+T3: Normal sample
+    lastStats["sdb1"] = { reads: 500 }
+    Output: { device: "/dev/sdb1", read_io_per_second: 25 }
+```
+
+### Clock Adjustments
+
+System clock can change due to NTP synchronization (step or slew), DST transitions, manual adjustment, or VM time sync after suspend/resume. This affects elapsed time calculations.
+
+**Decision:** Use monotonic clock for elapsed time calculation. Return 0.0 for rates if elapsed time is invalid.
+
+**Rationale:**
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| Wall clock | Simple | Affected by NTP/DST |
+| Monotonic clock (chosen) | Immune to adjustments | Not affected by suspend on some systems |
+| Hybrid | Best of both | More complex |
+
+**Behavioral Specification:**
+
+| Condition | Behavior |
+|-----------|----------|
+| elapsed <= 0 | Return 0.0 for all rate metrics |
+| elapsed > 2 × sample_interval | Log warning; return 0.0 for rate metrics |
+| Normal elapsed | Calculate rates normally |
+
+**Go Implementation Notes:**
+
+`time.Now()` in Go 1.9+ contains both wall clock and monotonic readings. Subtraction uses monotonic automatically:
+
+```go
+t1 := time.Now()
+// ... NTP adjustment happens ...
+t2 := time.Now()
+elapsed := t2.Sub(t1)  // Uses monotonic readings, ignores wall clock change
+```
+
+**Recommended Protection:**
+
+```go
+const (
+    maxExpectedInterval = sampleInterval * 2
+)
+
+func calculateElapsed(now, last time.Time) time.Duration {
+    elapsed := now.Sub(last)  // Uses monotonic in Go 1.9+
+
+    if elapsed <= 0 {
+        log.Warn("Negative or zero elapsed time, skipping deltas")
+        return 0
+    }
+
+    if elapsed > maxExpectedInterval {
+        log.Warnf("Unusually large elapsed time: %v, skipping deltas", elapsed)
+        return 0
+    }
+
+    return elapsed
+}
+```
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Clock jumps backward (NTP) | elapsed <= 0 → rates = 0.0 |
+| Clock jumps forward (NTP) | Large elapsed → skip sample |
+| VM suspend/resume | Large elapsed → skip sample |
+| Leap second | 1-second error → negligible impact |
+| DST (wall clock only) | Using monotonic → no impact |
+
+**Example: VM Suspend/Resume**
+
+```
+T0 (mono: 1000): Sample, counters = 5000
+T1 (mono: 1010): Sample, counters = 5100, rate = 100/10 = 10/sec
+T2 (mono: 5000): VM resumed after suspend, counters = 5200
+    - Mono elapsed = 3990 seconds (suspicious!)
+    - Skip deltas, return 0.0, log warning
+T3 (mono: 5010): Normal sample resumes
+```
+
+### Large Filesystem Values
+
+Very large filesystems can cause integer overflow (if 32-bit intermediates are used) or precision loss (when converting to float64).
+
+**Decision:** Use uint64 for all intermediate calculations. Accept float64 precision loss for display (sub-byte accuracy not required).
+
+**Rationale:**
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| uint64 → float64 (chosen) | Simple; sufficient for monitoring | Precision loss > 8 PB |
+| Keep as uint64 | Full precision | JSON numbers may lose precision in parsers |
+| Use string representation | Full precision | Complicates downstream processing |
+| Use big.Int | Unlimited precision | Overkill; performance overhead |
+
+**Precision Loss by Filesystem Size:**
+
+| Filesystem Size | Behavior |
+|-----------------|----------|
+| < 8 PB | Exact byte values |
+| 8 PB - 16 PB | ±1-2 byte precision loss |
+| 16 PB - 16 EB | ±4+ byte precision loss |
+| > 16 EB | uint64 overflow (theoretical) |
+
+Sub-byte precision loss is irrelevant for capacity monitoring.
+
+**Implementation Requirements:**
+
+1. All intermediate calculations MUST use uint64 or larger
+   - NEVER use int32, uint32, or int for byte counts
+
+2. Multiplication order doesn't matter for uint64
+   - `blocks * blockSize` is safe in uint64
+
+3. Final conversion to float64 is acceptable
+   - Precision loss at petabyte scale is negligible for monitoring
+
+4. Sector calculations MUST use uint64
+   - `sectors * 512` in uint64 space
+
+**Validation for Invalid Values:**
+
+```go
+func asValidFloat(value float64) float64 {
+    if math.IsNaN(value) || math.IsInf(value, 0) {
+        return 0  // Protect against invalid values
+    }
+    return value
+}
+```
+
+**Edge Cases:**
+
+| Case | Behavior |
+|------|----------|
+| Filesystem > 8 PB | Minor precision loss (~bytes) |
+| Clustered filesystem > 100 PB | Precision loss (~KB), still usable |
+| Counter overflow in diskstats | Kernel wraps at 2^64; return 0.0 for delta |
+| Division by zero (0 blocks) | Protected by returning 0.0 for NaN/Inf |
+
+**Example: 10 PB Filesystem**
+
+```
+Actual bytes:     11,258,999,068,426,240
+uint64:           11,258,999,068,426,240 (exact)
+float64:          11,258,999,068,426,240 (exact - within 53-bit mantissa)
+
+Actual bytes:     11,258,999,068,426,241
+float64:          11,258,999,068,426,240 (off by 1 byte - acceptable)
+```
+
+### Escaped Characters in Mount Paths
+
+Mount points and device paths in `/proc/self/mountinfo` and `/proc/self/mounts` use octal escape sequences for special characters:
+
+| Character | Octal Escape |
+|-----------|--------------|
+| Space | `\040` |
+| Tab | `\011` |
+| Newline | `\012` |
+| Backslash | `\134` |
+
+**Example:**
+```
+# Actual mount point: /mnt/My Documents
+# In mountinfo:       /mnt/My\040Documents
+```
+
+**Handling:** Parse and unescape octal sequences (`\NNN`) in both mount point and device path fields before using them. The unescaped values should be used in the API response.
+
+### First Sample Behavior
+
+Delta-based metrics require two samples. On first collection:
+
+| Metric Category | First Sample Value |
+|-----------------|-------------------|
+| Utilization (total, read, write) | `0.0` |
+| Throughput (bytes/sec) | `0.0` |
+| IOPS (io/sec) | `0.0` |
+| Space metrics | Actual values (not delta-based) |
+| Inode metrics | Actual values (not delta-based) |
+
+Store the first sample and return zeros for delta-based metrics. Second and subsequent collections return calculated values.
+
+### Counter Wraps
+
+Linux counters are 64-bit unsigned integers. Handle wrap-around:
+
+```go
+if current < previous {
+    // Counter wrapped, use current as new baseline
+    delta = 0  // or: delta = current (assume wrap from 0)
+}
+```
+
+For a 15-second collection interval, 64-bit counters will not wrap under normal conditions.
+
+### Division by Zero
+
+| Scenario | Handling |
+|----------|----------|
+| `elapsed_seconds == 0` | Return `0.0` for rate metrics |
+| `inodes_total == 0` | Return `0.0` for `inodes_used_percent` |
+| `read_time_delta + write_time_delta == 0` | Return `0.0` for read/write utilization split |
+| `disk_used + disk_free == 0` | Return `0.0` for percent metrics |
+
+### Mount Point Filtering
+
+Skip mount points that:
+- Have unsupported filesystem types
+- Are virtual filesystems (proc, sysfs, devtmpfs, tmpfs, etc.)
+- Fail statfs() call (permission denied, disconnected NFS, etc.)
+- Cannot be mapped to a diskstats device
+
+### Device Not Found in Diskstats
+
+If a mount's device cannot be found in `/proc/diskstats`:
+- Include the mount point in output
+- Set all I/O metrics (utilization, throughput, IOPS) to `0.0`
+- Space and inode metrics remain populated from statfs()
+
+### Permission Errors
+
+- statfs() failures: Skip the mount point entirely
+- `/proc/diskstats` unreadable: Set all I/O metrics to `0.0`
+- `/proc/self/mountinfo` unreadable: Fall back to `/proc/self/mounts`, then `/etc/mtab`
+
+### Utilization Capping
+
+```go
+if total_utilization_percent > 100.0 {
+    total_utilization_percent = 100.0
+}
+```
+
+Utilization can exceed 100% due to timing granularity in the kernel. Cap at 100%.
+
+---
+
+## Collector State
+
+The collector must maintain state between collections:
+
+```go
+type DiskIOStats struct {
+    IOTimeMs       uint64  // field 13
+    ReadTimeMs     uint64  // field 7
+    WriteTimeMs    uint64  // field 11
+    SectorsRead    uint64  // field 6
+    SectorsWritten uint64  // field 10
+    ReadsCompleted uint64  // field 4
+    WritesCompleted uint64 // field 8
+}
+
+type collector struct {
+    lastDiskStats map[string]DiskIOStats  // key: device name
+    lastTime      time.Time
+}
+```
+
+---
+
+## Implementation Patterns
+
+Follow existing collector patterns in the codebase:
+
+1. **Interface abstraction** for testability (see `sysmetrics.SystemCollector`)
+2. **Config struct** for dependency injection
+3. **Constructor pattern**: `New()` and `NewWithConfig(cfg *Config)`
+4. **Delta calculation** with elapsed time (see `networkmetrics.Collect`)
+5. **Graceful degradation** - don't fail entire collection for partial errors
+
+### Package Location
+
+```
+internal/storagemetrics/
+├── collector.go       # Main collector implementation
+├── collector_test.go  # Unit tests with mock interfaces
+├── mountinfo.go       # Mount parsing logic
+├── diskstats.go       # Diskstats parsing logic
+└── doc.go             # Package documentation
+```
+
+### Domain Types Location
+
+Add to `domain/metrics/metrics.go`:
+
+```go
+type StorageMetrics struct {
+    DiskUsedBytes           float64 `json:"disk_used_bytes"`
+    DiskFreeBytes           float64 `json:"disk_free_bytes"`
+    DiskTotalBytes          float64 `json:"disk_total_bytes"`
+    DiskUsedPercent         float64 `json:"disk_used_percent"`
+    DiskFreePercent         float64 `json:"disk_free_percent"`
+    TotalUtilizationPercent float64 `json:"total_utilization_percent"`
+    ReadUtilizationPercent  float64 `json:"read_utilization_percent"`
+    WriteUtilizationPercent float64 `json:"write_utilization_percent"`
+    ReadBytesPerSecond      float64 `json:"read_bytes_per_second"`
+    WriteBytesPerSecond     float64 `json:"write_bytes_per_second"`
+    ReadWriteBytesPerSecond float64 `json:"read_write_bytes_per_second"`
+    ReadIOPerSecond         float64 `json:"read_io_per_second"`
+    WriteIOPerSecond        float64 `json:"write_io_per_second"`
+    InodesUsed              uint64  `json:"inodes_used"`
+    InodesFree              uint64  `json:"inodes_free"`
+    InodesTotal             uint64  `json:"inodes_total"`
+    InodesUsedPercent       float64 `json:"inodes_used_percent"`
+}
+
+type StorageAttributes struct {
+    MountPoint     string `json:"mount_point"`
+    Device         string `json:"device"`
+    FilesystemType string `json:"filesystem_type"`
+    IsReadOnly     bool   `json:"is_read_only"`
+}
+```
diff --git a/domain/metrics/metrics.go b/domain/metrics/metrics.go
index 69836c9..d2d28d7 100644
--- a/domain/metrics/metrics.go
+++ b/domain/metrics/metrics.go
@@ -5,6 +5,7 @@ const (
 	MetricTypeSystem             = "system"
 	MetricTypeNetwork            = "network"
 	MetricTypePostgreSQLDatabase = "postgresql.database"
+	MetricTypeStorage            = "storage"
 )
 
 type MetricPayload struct {
@@ -50,3 +51,30 @@ type PostgreSQLDatabaseMetrics struct {
 	BlocksReadPerSecond   float64 `json:"blocks_read_per_second"`
 	ReplicationLagSeconds int     `json:"replication_lag_seconds"`
 }
+
+type StorageMetrics struct {
+	DiskUsedBytes           float64 `json:"disk_used_bytes"`
+	DiskFreeBytes           float64 `json:"disk_free_bytes"`
+	DiskTotalBytes          float64 `json:"disk_total_bytes"`
+	DiskUsedPercent         float64 `json:"disk_used_percent"`
+	DiskFreePercent         float64 `json:"disk_free_percent"`
+	TotalUtilizationPercent float64 `json:"total_utilization_percent"`
+	ReadUtilizationPercent  float64 `json:"read_utilization_percent"`
+	WriteUtilizationPercent float64 `json:"write_utilization_percent"`
+	ReadBytesPerSecond      float64 `json:"read_bytes_per_second"`
+	WriteBytesPerSecond     float64 `json:"write_bytes_per_second"`
+	ReadWriteBytesPerSecond float64 `json:"read_write_bytes_per_second"`
+	ReadIOPerSecond         float64 `json:"read_io_per_second"`
+	WriteIOPerSecond        float64 `json:"write_io_per_second"`
+	InodesUsed              uint64  `json:"inodes_used"`
+	InodesFree              uint64  `json:"inodes_free"`
+	InodesTotal             uint64  `json:"inodes_total"`
+	InodesUsedPercent       float64 `json:"inodes_used_percent"`
+}
+
+type StorageAttributes struct {
+	MountPoint     string `json:"mount_point"`
+	Device         string `json:"device"`
+	FilesystemType string `json:"filesystem_type"`
+	IsReadOnly     bool   `json:"is_read_only"`
+}
diff --git a/internal/storagemetrics/collector.go b/internal/storagemetrics/collector.go
new file mode 100644
index 0000000..25089c0
--- /dev/null
+++ b/internal/storagemetrics/collector.go
@@ -0,0 +1,353 @@
+package storagemetrics
+
+import (
+	"context"
+	"log"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"hostlink/domain/metrics"
+)
+
+const (
+	staleThreshold     = 3
+	minElapsedSeconds  = 0.1 // 100ms minimum
+	maxElapsedSeconds  = 300 // 5 minutes
+)
+
+func asValidFloat(value float64) float64 {
+	if math.IsNaN(value) || math.IsInf(value, 0) {
+		return 0
+	}
+	return value
+}
+
+type MountInfo struct {
+	MountPoint     string
+	Device         string
+	FilesystemType string
+	IsReadOnly     bool
+	MajorMinor     string
+}
+
+type DiskIOStats struct {
+	IOTimeMs        uint64
+	ReadTimeMs      uint64
+	WriteTimeMs     uint64
+	SectorsRead     uint64
+	SectorsWritten  uint64
+	ReadsCompleted  uint64
+	WritesCompleted uint64
+}
+
+type StatfsResult struct {
+	Bsize  int64
+	Blocks uint64
+	Bfree  uint64
+	Bavail uint64
+	Files  uint64
+	Ffree  uint64
+}
+
+type MountInfoReader interface {
+	ReadMounts() ([]MountInfo, error)
+}
+
+type DiskStatsReader interface {
+	ReadDiskStats() (map[string]DiskIOStats, error)
+}
+
+type StatfsProvider interface {
+	Statfs(path string) (StatfsResult, error)
+}
+
+type StorageMetricSet struct {
+	Attributes metrics.StorageAttributes
+	Metrics    metrics.StorageMetrics
+}
+
+type Collector interface {
+	Collect(ctx context.Context) ([]StorageMetricSet, error)
+}
+
+type Config struct {
+	MountReader MountInfoReader
+	StatsReader DiskStatsReader
+	Statfs      StatfsProvider
+}
+
+type collector struct {
+	mountReader           MountInfoReader
+	statsReader           DiskStatsReader
+	statfs                StatfsProvider
+	lastStats             map[string]DiskIOStats
+	lastSeen              map[string]time.Time
+	missedSamples         map[string]int
+	lastTime              time.Time
+	previousSampleDevices map[string]bool
+}
+
+func New() Collector {
+	return NewWithConfig(&Config{
+		MountReader: NewMountInfoReader(),
+		StatsReader: NewDiskStatsReader(),
+		Statfs:      NewStatfsProvider(),
+	})
+}
+
+func NewWithConfig(cfg *Config) Collector {
+	c := &collector{
+		lastStats:             make(map[string]DiskIOStats),
+		lastSeen:              make(map[string]time.Time),
+		missedSamples:         make(map[string]int),
+		previousSampleDevices: make(map[string]bool),
+	}
+	if cfg != nil {
+		c.mountReader = cfg.MountReader
+		c.statsReader = cfg.StatsReader
+		c.statfs = cfg.Statfs
+	}
+	return c
+}
+
+func (c *collector) Collect(ctx context.Context) ([]StorageMetricSet, error) {
+	mounts, err := c.mountReader.ReadMounts()
+	if err != nil {
+		return nil, err
+	}
+
+	diskStats, err := c.statsReader.ReadDiskStats()
+	if err != nil {
+		diskStats = make(map[string]DiskIOStats)
+	}
+
+	now := time.Now()
+	elapsed := now.Sub(c.lastTime).Seconds()
+	elapsedMs := now.Sub(c.lastTime).Seconds() * 1000
+
+	isFirstSample := c.lastTime.IsZero()
+	isElapsedValid := elapsed >= minElapsedSeconds && elapsed < maxElapsedSeconds
+
+	if !isFirstSample && !isElapsedValid {
+		if elapsed < minElapsedSeconds {
+			log.Printf("[WARN] storagemetrics: Negative or zero elapsed time (%.3fs), skipping deltas", elapsed)
+		} else {
+			log.Printf("[WARN] storagemetrics: Unusually large elapsed time: %.1fs, skipping deltas", elapsed)
+		}
+	}
+
+	ioMetricsCache := make(map[string]metrics.StorageMetrics)
+	currentDevices := make(map[string]bool)
+
+	var results []StorageMetricSet
+
+	for _, mount := range mounts {
+		statfsResult, err := c.statfs.Statfs(mount.MountPoint)
+		if err != nil {
+			continue
+		}
+
+		// Check for invalid statfs results
+		if statfsResult.Bsize == 0 && statfsResult.Blocks == 0 && statfsResult.Files == 0 {
+			log.Printf("[WARN] storagemetrics: All capacity values zero for %s, skipping", mount.MountPoint)
+			continue
+		}
+		if statfsResult.Bsize == 0 {
+			log.Printf("[WARN] storagemetrics: Invalid block size (0) for %s, skipping capacity", mount.MountPoint)
+		}
+
+		var m metrics.StorageMetrics
+
+		if statfsResult.Bsize > 0 {
+			total := uint64(statfsResult.Blocks) * uint64(statfsResult.Bsize)
+			free := uint64(statfsResult.Bavail) * uint64(statfsResult.Bsize)
+			used := (uint64(statfsResult.Blocks) - uint64(statfsResult.Bfree)) * uint64(statfsResult.Bsize)
+
+			m.DiskTotalBytes = asValidFloat(float64(total))
+			m.DiskFreeBytes = asValidFloat(float64(free))
+			m.DiskUsedBytes = asValidFloat(float64(used))
+
+			denominator := used + free
+			if denominator > 0 {
+				m.DiskUsedPercent = asValidFloat(float64(used) / float64(denominator) * 100)
+				m.DiskFreePercent = asValidFloat(100 - m.DiskUsedPercent)
+			}
+		}
+
+		m.InodesTotal = statfsResult.Files
+		m.InodesFree = statfsResult.Ffree
+		m.InodesUsed = statfsResult.Files - statfsResult.Ffree
+		if statfsResult.Files > 0 {
+			m.InodesUsedPercent = asValidFloat(float64(m.InodesUsed) / float64(statfsResult.Files) * 100)
+		}
+
+		deviceKey := c.resolveDeviceKey(mount, diskStats)
+		currentDevices[deviceKey] = true
+
+		if cachedIO, ok := ioMetricsCache[deviceKey]; ok {
+			m.TotalUtilizationPercent = cachedIO.TotalUtilizationPercent
+			m.ReadUtilizationPercent = cachedIO.ReadUtilizationPercent
+			m.WriteUtilizationPercent = cachedIO.WriteUtilizationPercent
+			m.ReadBytesPerSecond = cachedIO.ReadBytesPerSecond
+			m.WriteBytesPerSecond = cachedIO.WriteBytesPerSecond
+			m.ReadWriteBytesPerSecond = cachedIO.ReadWriteBytesPerSecond
+			m.ReadIOPerSecond = cachedIO.ReadIOPerSecond
+			m.WriteIOPerSecond = cachedIO.WriteIOPerSecond
+		} else {
+			currentStats, hasStats := diskStats[deviceKey]
+			canCalculateDelta := hasStats && !isFirstSample && isElapsedValid && c.wasSeenLastSample(deviceKey)
+
+			if canCalculateDelta {
+				lastStats, hadPrevious := c.lastStats[deviceKey]
+				if hadPrevious && !c.hasCounterWrap(currentStats, lastStats) {
+					ioTimeDelta := currentStats.IOTimeMs - lastStats.IOTimeMs
+					readTimeDelta := currentStats.ReadTimeMs - lastStats.ReadTimeMs
+					writeTimeDelta := currentStats.WriteTimeMs - lastStats.WriteTimeMs
+
+					totalUtil := asValidFloat(float64(ioTimeDelta) / elapsedMs * 100)
+					if totalUtil > 100 {
+						totalUtil = 100
+					}
+					m.TotalUtilizationPercent = totalUtil
+
+					totalTimeDelta := readTimeDelta + writeTimeDelta
+					if totalTimeDelta > 0 {
+						m.ReadUtilizationPercent = asValidFloat(totalUtil * (float64(readTimeDelta) / float64(totalTimeDelta)))
+						m.WriteUtilizationPercent = asValidFloat(totalUtil * (float64(writeTimeDelta) / float64(totalTimeDelta)))
+					}
+
+					sectorsReadDelta := currentStats.SectorsRead - lastStats.SectorsRead
+					sectorsWrittenDelta := currentStats.SectorsWritten - lastStats.SectorsWritten
+					m.ReadBytesPerSecond = asValidFloat(float64(sectorsReadDelta*512) / elapsed)
+					m.WriteBytesPerSecond = asValidFloat(float64(sectorsWrittenDelta*512) / elapsed)
+					m.ReadWriteBytesPerSecond = asValidFloat(m.ReadBytesPerSecond + m.WriteBytesPerSecond)
+
+					readsDelta := currentStats.ReadsCompleted - lastStats.ReadsCompleted
+					writesDelta := currentStats.WritesCompleted - lastStats.WritesCompleted
+					m.ReadIOPerSecond = asValidFloat(float64(readsDelta) / elapsed)
+					m.WriteIOPerSecond = asValidFloat(float64(writesDelta) / elapsed)
+				}
+			}
+
+			if hasStats {
+				c.lastStats[deviceKey] = currentStats
+				c.lastSeen[deviceKey] = now
+			}
+
+			ioMetricsCache[deviceKey] = metrics.StorageMetrics{
+				TotalUtilizationPercent: m.TotalUtilizationPercent,
+				ReadUtilizationPercent:  m.ReadUtilizationPercent,
+				WriteUtilizationPercent: m.WriteUtilizationPercent,
+				ReadBytesPerSecond:      m.ReadBytesPerSecond,
+				WriteBytesPerSecond:     m.WriteBytesPerSecond,
+				ReadWriteBytesPerSecond: m.ReadWriteBytesPerSecond,
+				ReadIOPerSecond:         m.ReadIOPerSecond,
+				WriteIOPerSecond:        m.WriteIOPerSecond,
+			}
+		}
+
+		results = append(results, StorageMetricSet{
+			Attributes: metrics.StorageAttributes{
+				MountPoint:     mount.MountPoint,
+				Device:         mount.Device,
+				FilesystemType: mount.FilesystemType,
+				IsReadOnly:     mount.IsReadOnly,
+			},
+			Metrics: m,
+		})
+	}
+
+	c.cleanupStaleEntries(currentDevices)
+	c.previousSampleDevices = currentDevices
+	c.lastTime = now
+
+	return results, nil
+}
+
+func (c *collector) resolveDeviceKey(mount MountInfo, diskStats map[string]DiskIOStats) string {
+	device := mount.Device
+
+	// Resolve /dev/root using major:minor from /proc/partitions
+	if device == "/dev/root" && mount.MajorMinor != "" {
+		if resolved := resolveDevRoot(mount.MajorMinor); resolved != "" {
+			device = "/dev/" + resolved
+		}
+	}
+
+	// Resolve symlinks (e.g., /dev/disk/by-uuid/... -> /dev/sda1)
+	if resolved, err := filepath.EvalSymlinks(device); err == nil {
+		device = resolved
+	}
+
+	// Try LVM resolution via major:minor
+	if strings.HasPrefix(device, "/dev/mapper/") && mount.MajorMinor != "" {
+		parts := strings.Split(mount.MajorMinor, ":")
+		if len(parts) == 2 {
+			dmKey := "dm-" + parts[1]
+			if _, ok := diskStats[dmKey]; ok {
+				return dmKey
+			}
+		}
+	}
+
+	return strings.TrimPrefix(device, "/dev/")
+}
+
+func resolveDevRoot(majorMinor string) string {
+	content, err := os.ReadFile("/proc/partitions")
+	if err != nil {
+		return ""
+	}
+	return ParsePartitionsForDevice(string(content), majorMinor)
+}
+
+func ParsePartitionsForDevice(content, majorMinor string) string {
+	parts := strings.Split(majorMinor, ":")
+	if len(parts) != 2 {
+		return ""
+	}
+	targetMajor, targetMinor := parts[0], parts[1]
+
+	lines := strings.Split(content, "\n")
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) < 4 {
+			continue
+		}
+		major, minor, name := fields[0], fields[1], fields[3]
+		if major == targetMajor && minor == targetMinor {
+			return name
+		}
+	}
+	return ""
+}
+
+func (c *collector) wasSeenLastSample(deviceKey string) bool {
+	return c.previousSampleDevices[deviceKey]
+}
+
+func (c *collector) hasCounterWrap(current, previous DiskIOStats) bool {
+	return current.ReadsCompleted < previous.ReadsCompleted ||
+		current.WritesCompleted < previous.WritesCompleted ||
+		current.SectorsRead < previous.SectorsRead ||
+		current.SectorsWritten < previous.SectorsWritten ||
+		current.IOTimeMs < previous.IOTimeMs
+}
+
+func (c *collector) cleanupStaleEntries(currentDevices map[string]bool) {
+	for device := range c.lastSeen {
+		if !currentDevices[device] {
+			c.missedSamples[device]++
+			if c.missedSamples[device] >= staleThreshold {
+				delete(c.lastStats, device)
+				delete(c.lastSeen, device)
+				delete(c.missedSamples, device)
+			}
+		} else {
+			c.missedSamples[device] = 0
+		}
+	}
+}
diff --git a/internal/storagemetrics/collector_test.go b/internal/storagemetrics/collector_test.go
new file mode 100644
index 0000000..321a310
--- /dev/null
+++ b/internal/storagemetrics/collector_test.go
@@ -0,0 +1,1577 @@
+package storagemetrics
+
+import (
+	"context"
+	"math"
+	"os"
+	"testing"
+	"time"
+)
+
+func approxEqual(a, b, tolerance float64) bool {
+	return math.Abs(a-b) <= tolerance
+}
+
+// Mock implementations
+
+type mockMountReader struct {
+	mounts []MountInfo
+	err    error
+}
+
+func (m *mockMountReader) ReadMounts() ([]MountInfo, error) {
+	return m.mounts, m.err
+}
+
+type mockDiskStatsReader struct {
+	stats map[string]DiskIOStats
+	err   error
+}
+
+func (m *mockDiskStatsReader) ReadDiskStats() (map[string]DiskIOStats, error) {
+	return m.stats, m.err
+}
+
+type mockStatfsProvider struct {
+	results map[string]StatfsResult
+	err     error
+}
+
+func (m *mockStatfsProvider) Statfs(path string) (StatfsResult, error) {
+	if m.err != nil {
+		return StatfsResult{}, m.err
+	}
+	return m.results[path], nil
+}
+
+// Mount parsing tests
+
+// Parses a basic ext4 mount from /proc/self/mountinfo format
+func TestParseMountInfo_ParsesBasicMount(t *testing.T) {
+	content := `36 35 8:1 / / rw,relatime shared:1 - ext4 /dev/sda1 rw`
+
+	mounts, err := ParseMountInfo(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+
+	m := mounts[0]
+	if m.MountPoint != "/" {
+		t.Errorf("expected mount point '/', got %q", m.MountPoint)
+	}
+	if m.Device != "/dev/sda1" {
+		t.Errorf("expected device '/dev/sda1', got %q", m.Device)
+	}
+	if m.FilesystemType != "ext4" {
+		t.Errorf("expected filesystem 'ext4', got %q", m.FilesystemType)
+	}
+	if m.IsReadOnly {
+		t.Error("expected read-write mount")
+	}
+}
+
+// Filters out unsupported filesystems like tmpfs, proc, sysfs
+func TestParseMountInfo_FiltersUnsupportedFilesystems(t *testing.T) {
+	content := `22 1 0:21 / /proc rw,nosuid,nodev,noexec,relatime - proc proc rw
+23 1 0:22 / /sys rw,nosuid,nodev,noexec,relatime - sysfs sysfs rw
+24 1 0:5 / /dev rw,nosuid,relatime - devtmpfs devtmpfs rw
+25 1 0:23 / /run rw,nosuid,nodev - tmpfs tmpfs rw
+36 35 8:1 / / rw,relatime shared:1 - ext4 /dev/sda1 rw`
+
+	mounts, err := ParseMountInfo(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount (only ext4), got %d", len(mounts))
+	}
+	if mounts[0].FilesystemType != "ext4" {
+		t.Errorf("expected ext4, got %q", mounts[0].FilesystemType)
+	}
+}
+
+// Detects read-only mounts from mount options
+func TestParseMountInfo_DetectsReadOnlyMounts(t *testing.T) {
+	content := `36 35 8:1 / /mnt/readonly ro,relatime shared:1 - ext4 /dev/sda1 ro`
+
+	mounts, err := ParseMountInfo(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+	if !mounts[0].IsReadOnly {
+		t.Error("expected read-only mount")
+	}
+}
+
+// Parses /proc/mounts format correctly
+func TestParseMounts_ParsesBasicMount(t *testing.T) {
+	content := `/dev/sda1 / ext4 rw,relatime 0 1`
+
+	mounts, err := ParseMounts(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+	m := mounts[0]
+	if m.Device != "/dev/sda1" {
+		t.Errorf("expected device /dev/sda1, got %s", m.Device)
+	}
+	if m.MountPoint != "/" {
+		t.Errorf("expected mount point /, got %s", m.MountPoint)
+	}
+	if m.FilesystemType != "ext4" {
+		t.Errorf("expected filesystem ext4, got %s", m.FilesystemType)
+	}
+	if m.IsReadOnly {
+		t.Error("expected read-write mount")
+	}
+}
+
+// Detects read-only mounts in /proc/mounts format
+func TestParseMounts_DetectsReadOnlyMounts(t *testing.T) {
+	content := `/dev/sda1 /mnt/backup ext4 ro,noexec 0 0`
+
+	mounts, err := ParseMounts(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+	if !mounts[0].IsReadOnly {
+		t.Error("expected read-only mount")
+	}
+}
+
+// Mount source fallback tests
+
+// Uses /proc/self/mountinfo when available
+func TestReadMounts_UsesMountInfoFirst(t *testing.T) {
+	readFile := func(path string) ([]byte, error) {
+		if path == "/proc/self/mountinfo" {
+			return []byte(`36 35 8:1 / / rw,relatime shared:1 - ext4 /dev/sda1 rw`), nil
+		}
+		return nil, os.ErrNotExist
+	}
+
+	mounts, err := readMountsWithReader(readFile)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+	if mounts[0].MajorMinor != "8:1" {
+		t.Error("expected MajorMinor from mountinfo format")
+	}
+}
+
+// Falls back to /proc/self/mounts when mountinfo fails
+func TestReadMounts_FallsBackToMounts(t *testing.T) {
+	readFile := func(path string) ([]byte, error) {
+		if path == "/proc/self/mountinfo" {
+			return nil, os.ErrNotExist
+		}
+		if path == "/proc/self/mounts" {
+			return []byte(`/dev/fake-test-device / ext4 rw,relatime 0 1`), nil
+		}
+		return nil, os.ErrNotExist
+	}
+
+	mounts, err := readMountsWithReader(readFile)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+	if mounts[0].MajorMinor != "" {
+		t.Error("expected empty MajorMinor from mounts format")
+	}
+}
+
+// Falls back to /etc/mtab when both mountinfo and mounts fail
+func TestReadMounts_FallsBackToMtab(t *testing.T) {
+	readFile := func(path string) ([]byte, error) {
+		if path == "/proc/self/mountinfo" {
+			return nil, os.ErrNotExist
+		}
+		if path == "/proc/self/mounts" {
+			return nil, os.ErrNotExist
+		}
+		if path == "/etc/mtab" {
+			return []byte(`/dev/fake-test-device / ext4 rw,relatime 0 1`), nil
+		}
+		return nil, os.ErrNotExist
+	}
+
+	mounts, err := readMountsWithReader(readFile)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(mounts) != 1 {
+		t.Fatalf("expected 1 mount, got %d", len(mounts))
+	}
+}
+
+// Returns error when all mount sources fail
+func TestReadMounts_AllSourcesFail(t *testing.T) {
+	readFile := func(path string) ([]byte, error) {
+		return nil, os.ErrNotExist
+	}
+
+	_, err := readMountsWithReader(readFile)
+	if err == nil {
+		t.Error("expected error when all sources fail")
+	}
+}
+
+// Diskstats tests
+
+// Parses standard device like sda1 from /proc/diskstats
+func TestParseDiskStats_ParsesStandardDevice(t *testing.T) {
+	content := `   8       1 sda1 12345 1234 567890 12000 54321 4321 234567 8000 0 15000 20000`
+
+	stats, err := ParseDiskStats(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	s, ok := stats["sda1"]
+	if !ok {
+		t.Fatal("expected sda1 in stats")
+	}
+	if s.ReadsCompleted != 12345 {
+		t.Errorf("expected reads 12345, got %d", s.ReadsCompleted)
+	}
+	if s.SectorsRead != 567890 {
+		t.Errorf("expected sectors read 567890, got %d", s.SectorsRead)
+	}
+	if s.WritesCompleted != 54321 {
+		t.Errorf("expected writes 54321, got %d", s.WritesCompleted)
+	}
+	if s.SectorsWritten != 234567 {
+		t.Errorf("expected sectors written 234567, got %d", s.SectorsWritten)
+	}
+	if s.IOTimeMs != 15000 {
+		t.Errorf("expected io time 15000, got %d", s.IOTimeMs)
+	}
+}
+
+// Parses NVMe device like nvme0n1p1 from /proc/diskstats
+func TestParseDiskStats_ParsesNVMeDevice(t *testing.T) {
+	content := ` 259       1 nvme0n1p1 5000 500 100000 5000 3000 300 60000 3000 0 8000 8000`
+
+	stats, err := ParseDiskStats(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	s, ok := stats["nvme0n1p1"]
+	if !ok {
+		t.Fatal("expected nvme0n1p1 in stats")
+	}
+	if s.ReadsCompleted != 5000 {
+		t.Errorf("expected reads 5000, got %d", s.ReadsCompleted)
+	}
+}
+
+// Parses LVM device like dm-0 from /proc/diskstats
+func TestParseDiskStats_ParsesLVMDevice(t *testing.T) {
+	content := ` 253       0 dm-0 8000 0 160000 4000 6000 0 120000 3000 0 7000 7000`
+
+	stats, err := ParseDiskStats(content)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	s, ok := stats["dm-0"]
+	if !ok {
+		t.Fatal("expected dm-0 in stats")
+	}
+	if s.ReadsCompleted != 8000 {
+		t.Errorf("expected reads 8000, got %d", s.ReadsCompleted)
+	}
+}
+
+// Partitions parsing tests
+
+// Resolves device name from /proc/partitions by major:minor
+func TestParsePartitionsForDevice_FindsDevice(t *testing.T) {
+	content := `major minor  #blocks  name
+
+   8        0  500107608 sda
+   8        1     512000 sda1
+   8        2  499594240 sda2
+ 253        0  104857600 dm-0
+ 253        1  394735616 dm-1`
+
+	name := ParsePartitionsForDevice(content, "8:1")
+	if name != "sda1" {
+		t.Errorf("expected sda1, got %s", name)
+	}
+}
+
+// Returns empty string when device not found
+func TestParsePartitionsForDevice_NotFound(t *testing.T) {
+	content := `major minor  #blocks  name
+
+   8        0  500107608 sda`
+
+	name := ParsePartitionsForDevice(content, "9:0")
+	if name != "" {
+		t.Errorf("expected empty string, got %s", name)
+	}
+}
+
+// Returns empty string for invalid major:minor format
+func TestParsePartitionsForDevice_InvalidFormat(t *testing.T) {
+	content := `major minor  #blocks  name
+
+   8        0  500107608 sda`
+
+	name := ParsePartitionsForDevice(content, "invalid")
+	if name != "" {
+		t.Errorf("expected empty string, got %s", name)
+	}
+}
+
+// Capacity tests
+
+// Returns capacity metrics from statfs for a mount point
+func TestCollect_ReturnsCapacityMetrics(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{
+				MountPoint:     "/",
+				Device:         "/dev/sda1",
+				FilesystemType: "ext4",
+			}},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{"sda1": {}},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000000, Bfree: 400000, Bavail: 350000, Files: 100000, Ffree: 90000},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+
+	m := results[0].Metrics
+	expectedTotal := float64(1000000 * 4096)
+	expectedFree := float64(350000 * 4096)
+	expectedUsed := float64((1000000 - 400000) * 4096)
+
+	if m.DiskTotalBytes != expectedTotal {
+		t.Errorf("expected total %v, got %v", expectedTotal, m.DiskTotalBytes)
+	}
+	if m.DiskFreeBytes != expectedFree {
+		t.Errorf("expected free %v, got %v", expectedFree, m.DiskFreeBytes)
+	}
+	if m.DiskUsedBytes != expectedUsed {
+		t.Errorf("expected used %v, got %v", expectedUsed, m.DiskUsedBytes)
+	}
+}
+
+// Calculates used percent as used/(used+available)*100
+func TestCollect_CalculatesUsedPercent(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	used := float64((1000 - 400) * 4096)
+	free := float64(300 * 4096)
+	expectedPercent := used / (used + free) * 100
+
+	if m.DiskUsedPercent != expectedPercent {
+		t.Errorf("expected used percent %v, got %v", expectedPercent, m.DiskUsedPercent)
+	}
+}
+
+// Calculates free percent as 100 - used_percent
+func TestCollect_CalculatesFreePercent(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	expectedFreePercent := 100 - m.DiskUsedPercent
+
+	if !approxEqual(m.DiskFreePercent, expectedFreePercent, 0.0001) {
+		t.Errorf("expected free percent %v, got %v", expectedFreePercent, m.DiskFreePercent)
+	}
+}
+
+// Calculates inode metrics from statfs
+func TestCollect_CalculatesInodeMetrics(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 10000, Ffree: 8000},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.InodesTotal != 10000 {
+		t.Errorf("expected inodes total 10000, got %d", m.InodesTotal)
+	}
+	if m.InodesFree != 8000 {
+		t.Errorf("expected inodes free 8000, got %d", m.InodesFree)
+	}
+	if m.InodesUsed != 2000 {
+		t.Errorf("expected inodes used 2000, got %d", m.InodesUsed)
+	}
+	expectedPercent := float64(2000) / float64(10000) * 100
+	if m.InodesUsedPercent != expectedPercent {
+		t.Errorf("expected inodes used percent %v, got %v", expectedPercent, m.InodesUsedPercent)
+	}
+}
+
+// I/O metrics tests
+
+// Returns zero for I/O metrics on first sample (no delta available)
+func TestCollect_ReturnsZeroOnFirstSample(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{
+				"sda1": {ReadsCompleted: 1000, WritesCompleted: 500, SectorsRead: 20000, SectorsWritten: 10000, IOTimeMs: 5000},
+			},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.ReadIOPerSecond != 0 {
+		t.Errorf("expected read IOPS 0 on first sample, got %v", m.ReadIOPerSecond)
+	}
+	if m.WriteIOPerSecond != 0 {
+		t.Errorf("expected write IOPS 0 on first sample, got %v", m.WriteIOPerSecond)
+	}
+	if m.ReadBytesPerSecond != 0 {
+		t.Errorf("expected read bytes/sec 0 on first sample, got %v", m.ReadBytesPerSecond)
+	}
+	if m.TotalUtilizationPercent != 0 {
+		t.Errorf("expected utilization 0 on first sample, got %v", m.TotalUtilizationPercent)
+	}
+}
+
+// Calculates delta-based I/O metrics on second sample
+func TestCollect_CalculatesDeltaOnSecondSample(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500, SectorsRead: 20000, SectorsWritten: 10000, IOTimeMs: 5000, ReadTimeMs: 3000, WriteTimeMs: 2000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 1100, WritesCompleted: 550, SectorsRead: 22000, SectorsWritten: 11000, IOTimeMs: 6000, ReadTimeMs: 3600, WriteTimeMs: 2400},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.ReadIOPerSecond == 0 {
+		t.Error("expected non-zero read IOPS on second sample")
+	}
+	if m.WriteIOPerSecond == 0 {
+		t.Error("expected non-zero write IOPS on second sample")
+	}
+}
+
+// Calculates utilization percent from io_time delta
+func TestCollect_CalculatesUtilizationPercent(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {IOTimeMs: 5000, ReadTimeMs: 3000, WriteTimeMs: 2000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {IOTimeMs: 6000, ReadTimeMs: 3600, WriteTimeMs: 2400},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	expectedUtil := float64(1000) / float64(10000) * 100
+	if !approxEqual(m.TotalUtilizationPercent, expectedUtil, 0.01) {
+		t.Errorf("expected utilization %v%%, got %v%%", expectedUtil, m.TotalUtilizationPercent)
+	}
+}
+
+// Splits total utilization into read/write based on time ratio
+func TestCollect_CalculatesReadWriteUtilizationSplit(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {IOTimeMs: 5000, ReadTimeMs: 3000, WriteTimeMs: 2000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {IOTimeMs: 6000, ReadTimeMs: 3600, WriteTimeMs: 2400},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	totalUtil := m.TotalUtilizationPercent
+	readTimeDelta := float64(600)
+	writeTimeDelta := float64(400)
+	totalTimeDelta := readTimeDelta + writeTimeDelta
+	expectedReadUtil := totalUtil * (readTimeDelta / totalTimeDelta)
+	expectedWriteUtil := totalUtil * (writeTimeDelta / totalTimeDelta)
+
+	if m.ReadUtilizationPercent != expectedReadUtil {
+		t.Errorf("expected read utilization %v%%, got %v%%", expectedReadUtil, m.ReadUtilizationPercent)
+	}
+	if m.WriteUtilizationPercent != expectedWriteUtil {
+		t.Errorf("expected write utilization %v%%, got %v%%", expectedWriteUtil, m.WriteUtilizationPercent)
+	}
+}
+
+// Calculates throughput in bytes per second from sectors delta
+func TestCollect_CalculatesThroughput(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {SectorsRead: 20000, SectorsWritten: 10000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {SectorsRead: 22000, SectorsWritten: 11000},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	expectedReadBytes := float64(2000*512) / 10.0
+	expectedWriteBytes := float64(1000*512) / 10.0
+
+	if !approxEqual(m.ReadBytesPerSecond, expectedReadBytes, 1.0) {
+		t.Errorf("expected read bytes/sec %v, got %v", expectedReadBytes, m.ReadBytesPerSecond)
+	}
+	if !approxEqual(m.WriteBytesPerSecond, expectedWriteBytes, 1.0) {
+		t.Errorf("expected write bytes/sec %v, got %v", expectedWriteBytes, m.WriteBytesPerSecond)
+	}
+}
+
+// Calculates total throughput as sum of read + write bytes per second
+func TestCollect_CalculatesTotalThroughput(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {SectorsRead: 20000, SectorsWritten: 10000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {SectorsRead: 22000, SectorsWritten: 11000},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	expectedTotal := m.ReadBytesPerSecond + m.WriteBytesPerSecond
+
+	if m.ReadWriteBytesPerSecond != expectedTotal {
+		t.Errorf("expected total bytes/sec %v, got %v", expectedTotal, m.ReadWriteBytesPerSecond)
+	}
+}
+
+// Calculates IOPS from reads/writes completed delta
+func TestCollect_CalculatesIOPS(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 1100, WritesCompleted: 550},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	expectedReadIOPS := float64(100) / 10.0
+	expectedWriteIOPS := float64(50) / 10.0
+
+	if !approxEqual(m.ReadIOPerSecond, expectedReadIOPS, 0.01) {
+		t.Errorf("expected read IOPS %v, got %v", expectedReadIOPS, m.ReadIOPerSecond)
+	}
+	if !approxEqual(m.WriteIOPerSecond, expectedWriteIOPS, 0.01) {
+		t.Errorf("expected write IOPS %v, got %v", expectedWriteIOPS, m.WriteIOPerSecond)
+	}
+}
+
+// Multiple mounts tests
+
+// Reports each mount point as a separate metric set
+func TestCollect_ReportsEachMountSeparately(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{
+				{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"},
+				{MountPoint: "/home", Device: "/dev/sda2", FilesystemType: "ext4"},
+			},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{
+				"sda1": {},
+				"sda2": {},
+			},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/":     {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+				"/home": {Bsize: 4096, Blocks: 2000, Bfree: 1000, Bavail: 900, Files: 2000, Ffree: 1800},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(results) != 2 {
+		t.Fatalf("expected 2 results, got %d", len(results))
+	}
+
+	mountPoints := make(map[string]bool)
+	for _, r := range results {
+		mountPoints[r.Attributes.MountPoint] = true
+	}
+
+	if !mountPoints["/"] {
+		t.Error("expected / mount point in results")
+	}
+	if !mountPoints["/home"] {
+		t.Error("expected /home mount point in results")
+	}
+}
+
+// Shares I/O metrics for multiple mounts on same device
+func TestCollect_SharesIOMetricsForSameDevice(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500, SectorsRead: 20000, SectorsWritten: 10000, IOTimeMs: 5000, ReadTimeMs: 3000, WriteTimeMs: 2000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{
+				{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"},
+				{MountPoint: "/var", Device: "/dev/sda1", FilesystemType: "ext4"},
+			},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/":    {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+				"/var": {Bsize: 4096, Blocks: 500, Bfree: 200, Bavail: 150, Files: 500, Ffree: 450},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 1100, WritesCompleted: 550, SectorsRead: 22000, SectorsWritten: 11000, IOTimeMs: 6000, ReadTimeMs: 3600, WriteTimeMs: 2400},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(results) != 2 {
+		t.Fatalf("expected 2 results, got %d", len(results))
+	}
+
+	if results[0].Metrics.ReadIOPerSecond != results[1].Metrics.ReadIOPerSecond {
+		t.Error("expected same read IOPS for both mounts on same device")
+	}
+	if results[0].Metrics.WriteIOPerSecond != results[1].Metrics.WriteIOPerSecond {
+		t.Error("expected same write IOPS for both mounts on same device")
+	}
+
+	if results[0].Metrics.DiskTotalBytes == results[1].Metrics.DiskTotalBytes {
+		t.Error("expected different capacity metrics for different mount points")
+	}
+}
+
+// Edge case tests
+
+// Unescapes octal sequences like \040 to space in mount paths
+func TestUnescapeMountPath_UnescapesSpace(t *testing.T) {
+	input := `/mnt/My\040Documents`
+	expected := `/mnt/My Documents`
+
+	result := UnescapeMountPath(input)
+	if result != expected {
+		t.Errorf("expected %q, got %q", expected, result)
+	}
+}
+
+// Unescapes multiple octal sequences in a single path
+func TestUnescapeMountPath_UnescapesMultipleSequences(t *testing.T) {
+	input := `/mnt/My\040Documents\040And\011Tabs`
+	expected := "/mnt/My Documents And\tTabs"
+
+	result := UnescapeMountPath(input)
+	if result != expected {
+		t.Errorf("expected %q, got %q", expected, result)
+	}
+}
+
+// Leaves paths without escape sequences unchanged
+func TestUnescapeMountPath_LeavesNormalPathUnchanged(t *testing.T) {
+	input := `/mnt/normal/path`
+	expected := `/mnt/normal/path`
+
+	result := UnescapeMountPath(input)
+	if result != expected {
+		t.Errorf("expected %q, got %q", expected, result)
+	}
+}
+
+// Resolves symlink device paths to actual device for diskstats lookup
+func TestCollect_ResolvesSymlinkDevicePath(t *testing.T) {
+	// Note: This test requires DeviceResolver interface to be added to Config
+	// For now, test that symlink-style paths without diskstats entry return 0 I/O
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{
+				MountPoint:     "/data",
+				Device:         "/dev/disk/by-uuid/abcd-1234",
+				FilesystemType: "ext4",
+			}},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{
+				"sda1": {ReadsCompleted: 1000},
+			},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/data": {Bsize: 4096, Blocks: 1000, Bfree: 500, Bavail: 400, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+
+	// Device path preserved in output
+	if results[0].Attributes.Device != "/dev/disk/by-uuid/abcd-1234" {
+		t.Errorf("expected original device path, got %q", results[0].Attributes.Device)
+	}
+}
+
+// Returns zero for I/O metrics when counter wraps (current < previous)
+func TestCollect_HandlesCounterWrap(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500, SectorsRead: 20000, SectorsWritten: 10000, IOTimeMs: 5000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	// Counter wraps: current < previous
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 100, WritesCompleted: 50, SectorsRead: 2000, SectorsWritten: 1000, IOTimeMs: 500},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.ReadIOPerSecond != 0 {
+		t.Errorf("expected 0 for wrapped counter, got %v", m.ReadIOPerSecond)
+	}
+	if m.WriteIOPerSecond != 0 {
+		t.Errorf("expected 0 for wrapped counter, got %v", m.WriteIOPerSecond)
+	}
+}
+
+// Skips I/O delta calculation when mount was missing in previous sample
+func TestCollect_SkipsIOOnMountReappear(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500},
+		},
+	}
+	mountReader := &mockMountReader{
+		mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+	}
+
+	cfg := &Config{
+		MountReader: mountReader,
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+
+	// First sample
+	c.Collect(context.Background())
+
+	// Mount disappears
+	mountReader.mounts = []MountInfo{}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+	c.Collect(context.Background())
+
+	// Mount reappears with new counters
+	mountReader.mounts = []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}}
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 2000, WritesCompleted: 1000},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	// Should return 0 because mount was missing in previous sample
+	if m.ReadIOPerSecond != 0 {
+		t.Errorf("expected 0 after mount reappear, got %v", m.ReadIOPerSecond)
+	}
+}
+
+// Removes stale device entries after missing 3 consecutive samples
+func TestCollect_CleansUpStaleDeviceState(t *testing.T) {
+	mountReader := &mockMountReader{
+		mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+	}
+
+	cfg := &Config{
+		MountReader: mountReader,
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{"sda1": {ReadsCompleted: 1000}},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	if _, ok := c.lastStats["sda1"]; !ok {
+		t.Fatal("expected sda1 in lastStats after first sample")
+	}
+
+	// Device disappears for 3 samples
+	mountReader.mounts = []MountInfo{}
+	for range 3 {
+		c.lastTime = time.Now().Add(-10 * time.Second)
+		c.Collect(context.Background())
+	}
+
+	// State should be cleaned up
+	if _, ok := c.lastStats["sda1"]; ok {
+		t.Error("expected sda1 to be removed from lastStats after 3 missed samples")
+	}
+}
+
+// Returns zero for rates when elapsed time is zero or negative
+func TestCollect_HandlesZeroElapsedTime(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 1100, WritesCompleted: 550},
+	}
+	// Set lastTime to now (zero elapsed)
+	c.lastTime = time.Now()
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.ReadIOPerSecond != 0 {
+		t.Errorf("expected 0 for zero elapsed time, got %v", m.ReadIOPerSecond)
+	}
+}
+
+// Returns zero for rates when elapsed time exceeds threshold
+func TestCollect_HandlesLargeElapsedTime(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {ReadsCompleted: 1000, WritesCompleted: 500},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {ReadsCompleted: 1100, WritesCompleted: 550},
+	}
+	// Set lastTime to 1 hour ago (exceeds reasonable threshold)
+	c.lastTime = time.Now().Add(-1 * time.Hour)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.ReadIOPerSecond != 0 {
+		t.Errorf("expected 0 for large elapsed time, got %v", m.ReadIOPerSecond)
+	}
+}
+
+// Skips capacity metrics when block size is zero
+func TestCollect_SkipsCapacityOnZeroBlockSize(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 0, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+
+	m := results[0].Metrics
+	if m.DiskTotalBytes != 0 {
+		t.Errorf("expected 0 for zero block size, got %v", m.DiskTotalBytes)
+	}
+	if m.DiskUsedPercent != 0 {
+		t.Errorf("expected 0 for zero block size, got %v", m.DiskUsedPercent)
+	}
+}
+
+// Returns zero percent when denominator is zero (division protection)
+func TestCollect_HandlesDivisionByZero(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				// Bfree == Blocks means used = 0, and Bavail = 0 means free = 0
+				// So denominator (used + free) = 0
+				"/": {Bsize: 4096, Blocks: 100, Bfree: 100, Bavail: 0, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	// Should not panic or return NaN
+	if m.DiskUsedPercent != 0 {
+		t.Errorf("expected 0 for zero denominator, got %v", m.DiskUsedPercent)
+	}
+}
+
+// Caps utilization at 100% when calculation exceeds 100
+func TestCollect_CapsUtilizationAt100Percent(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {IOTimeMs: 0},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	// IOTimeMs delta exceeds elapsed time (should result in >100% without capping)
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {IOTimeMs: 20000}, // 20 seconds of IO time
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second) // But only 10 seconds elapsed
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.TotalUtilizationPercent > 100 {
+		t.Errorf("expected utilization capped at 100, got %v", m.TotalUtilizationPercent)
+	}
+	if m.TotalUtilizationPercent != 100 {
+		t.Errorf("expected utilization to be 100, got %v", m.TotalUtilizationPercent)
+	}
+}
+
+// Returns zero I/O metrics when device is not found in diskstats
+func TestCollect_ReturnsZeroIOWhenDeviceNotInDiskstats(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{
+				"sdb1": {ReadsCompleted: 1000}, // Different device
+			},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+
+	// Capacity should still be reported
+	if results[0].Metrics.DiskTotalBytes == 0 {
+		t.Error("expected capacity metrics to be reported")
+	}
+
+	// I/O should be zero
+	if results[0].Metrics.ReadIOPerSecond != 0 {
+		t.Errorf("expected 0 I/O when device not in diskstats, got %v", results[0].Metrics.ReadIOPerSecond)
+	}
+}
+
+// Resolves LVM device path to dm-X using major:minor from mountinfo
+func TestCollect_ResolvesLVMDeviceViaMajorMinor(t *testing.T) {
+	// LVM device with major:minor that maps to dm-0
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{
+				MountPoint:     "/",
+				Device:         "/dev/mapper/vg-lv",
+				FilesystemType: "ext4",
+				MajorMinor:     "253:0",
+			}},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{
+				"dm-0": {ReadsCompleted: 1000, WritesCompleted: 500},
+			},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	// Verify dm-0 was tracked
+	if _, ok := c.lastStats["dm-0"]; !ok {
+		t.Error("expected dm-0 to be tracked in lastStats for LVM device")
+	}
+}
+
+// Handles petabyte-scale filesystem values without overflow
+func TestCollect_HandlesLargeFilesystemValues(t *testing.T) {
+	// 1 PB filesystem: 1024^5 bytes = 1,125,899,906,842,624 bytes
+	// With 4096 byte blocks: ~274,877,906,944 blocks
+	blocks := uint64(274877906944)
+	bsize := int64(4096)
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: bsize, Blocks: blocks, Bfree: blocks / 2, Bavail: blocks / 2, Files: 1000000000, Ffree: 900000000},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	expectedTotal := float64(blocks) * float64(bsize)
+
+	if m.DiskTotalBytes != expectedTotal {
+		t.Errorf("expected total %v, got %v", expectedTotal, m.DiskTotalBytes)
+	}
+
+	// Verify no overflow (value should be approximately 1 PB)
+	onePB := float64(1125899906842624)
+	if m.DiskTotalBytes < onePB*0.99 || m.DiskTotalBytes > onePB*1.01 {
+		t.Errorf("expected approximately 1 PB, got %v", m.DiskTotalBytes)
+	}
+}
+
+// Returns zero percent when inodes_total is zero
+func TestCollect_HandlesZeroInodeTotal(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 0, Ffree: 0},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	if m.InodesUsedPercent != 0 {
+		t.Errorf("expected 0 for zero inode total, got %v", m.InodesUsedPercent)
+	}
+}
+
+// Returns zero for read/write utilization split when time deltas are zero
+func TestCollect_HandlesZeroReadWriteTimeDelta(t *testing.T) {
+	statsReader := &mockDiskStatsReader{
+		stats: map[string]DiskIOStats{
+			"sda1": {IOTimeMs: 5000, ReadTimeMs: 3000, WriteTimeMs: 2000},
+		},
+	}
+
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: statsReader,
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg).(*collector)
+	c.Collect(context.Background())
+
+	// Same read/write time (zero delta) but different IO time
+	statsReader.stats = map[string]DiskIOStats{
+		"sda1": {IOTimeMs: 6000, ReadTimeMs: 3000, WriteTimeMs: 2000},
+	}
+	c.lastTime = time.Now().Add(-10 * time.Second)
+
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+	// Total utilization should still be calculated
+	if m.TotalUtilizationPercent == 0 {
+		t.Error("expected non-zero total utilization")
+	}
+	// But read/write split should be zero (no way to split)
+	if m.ReadUtilizationPercent != 0 {
+		t.Errorf("expected 0 for read utilization with zero time delta, got %v", m.ReadUtilizationPercent)
+	}
+	if m.WriteUtilizationPercent != 0 {
+		t.Errorf("expected 0 for write utilization with zero time delta, got %v", m.WriteUtilizationPercent)
+	}
+}
+
+// Returns zero for NaN or Inf float values
+func TestCollect_HandlesNaNAndInfValues(t *testing.T) {
+	// This test verifies the collector doesn't produce NaN/Inf
+	// by testing edge cases that could cause them
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"}},
+		},
+		StatsReader: &mockDiskStatsReader{stats: map[string]DiskIOStats{"sda1": {}}},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				// All zeros - could produce NaN in percentage calculations
+				"/": {Bsize: 4096, Blocks: 0, Bfree: 0, Bavail: 0, Files: 0, Ffree: 0},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	m := results[0].Metrics
+
+	// Verify no NaN or Inf values
+	if math.IsNaN(m.DiskUsedPercent) || math.IsInf(m.DiskUsedPercent, 0) {
+		t.Error("DiskUsedPercent is NaN or Inf")
+	}
+	if math.IsNaN(m.DiskFreePercent) || math.IsInf(m.DiskFreePercent, 0) {
+		t.Error("DiskFreePercent is NaN or Inf")
+	}
+	if math.IsNaN(m.InodesUsedPercent) || math.IsInf(m.InodesUsedPercent, 0) {
+		t.Error("InodesUsedPercent is NaN or Inf")
+	}
+}
+
+// Skips mount point entirely when statfs fails
+func TestCollect_SkipsWhenStatfsFails(t *testing.T) {
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{
+				{MountPoint: "/", Device: "/dev/sda1", FilesystemType: "ext4"},
+				{MountPoint: "/data", Device: "/dev/sdb1", FilesystemType: "ext4"},
+			},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{"sda1": {}, "sdb1": {}},
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+				// /data not in results - simulates statfs failure
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Should only have 1 result (/ succeeded, /data failed)
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+	if results[0].Attributes.MountPoint != "/" {
+		t.Errorf("expected / mount point, got %q", results[0].Attributes.MountPoint)
+	}
+}
+
+// Returns zero I/O when device symlink is broken
+func TestCollect_HandlesBrokenSymlink(t *testing.T) {
+	// Broken symlink results in device not found in diskstats
+	// Same behavior as device not in diskstats
+	cfg := &Config{
+		MountReader: &mockMountReader{
+			mounts: []MountInfo{{
+				MountPoint:     "/data",
+				Device:         "/dev/disk/by-uuid/nonexistent",
+				FilesystemType: "ext4",
+			}},
+		},
+		StatsReader: &mockDiskStatsReader{
+			stats: map[string]DiskIOStats{}, // Empty - device not found
+		},
+		Statfs: &mockStatfsProvider{
+			results: map[string]StatfsResult{
+				"/data": {Bsize: 4096, Blocks: 1000, Bfree: 400, Bavail: 300, Files: 1000, Ffree: 900},
+			},
+		},
+	}
+
+	c := NewWithConfig(cfg)
+	results, err := c.Collect(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(results) != 1 {
+		t.Fatalf("expected 1 result, got %d", len(results))
+	}
+
+	// Capacity should still be reported
+	if results[0].Metrics.DiskTotalBytes == 0 {
+		t.Error("expected capacity metrics to be reported")
+	}
+
+	// I/O should be zero
+	if results[0].Metrics.ReadIOPerSecond != 0 {
+		t.Errorf("expected 0 I/O for broken symlink, got %v", results[0].Metrics.ReadIOPerSecond)
+	}
+}
diff --git a/internal/storagemetrics/diskstats.go b/internal/storagemetrics/diskstats.go
new file mode 100644
index 0000000..7541015
--- /dev/null
+++ b/internal/storagemetrics/diskstats.go
@@ -0,0 +1,60 @@
+package storagemetrics
+
+import (
+	"os"
+	"strconv"
+	"strings"
+)
+
+type diskStatsReader struct{}
+
+func NewDiskStatsReader() DiskStatsReader {
+	return &diskStatsReader{}
+}
+
+func (r *diskStatsReader) ReadDiskStats() (map[string]DiskIOStats, error) {
+	content, err := os.ReadFile("/proc/diskstats")
+	if err != nil {
+		return nil, err
+	}
+	return ParseDiskStats(string(content))
+}
+
+func ParseDiskStats(content string) (map[string]DiskIOStats, error) {
+	stats := make(map[string]DiskIOStats)
+
+	lines := strings.Split(content, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		fields := strings.Fields(line)
+		if len(fields) < 14 {
+			continue
+		}
+
+		deviceName := fields[2]
+
+		readsCompleted, _ := strconv.ParseUint(fields[3], 10, 64)
+		sectorsRead, _ := strconv.ParseUint(fields[5], 10, 64)
+		readTimeMs, _ := strconv.ParseUint(fields[6], 10, 64)
+		writesCompleted, _ := strconv.ParseUint(fields[7], 10, 64)
+		sectorsWritten, _ := strconv.ParseUint(fields[9], 10, 64)
+		writeTimeMs, _ := strconv.ParseUint(fields[10], 10, 64)
+		ioTimeMs, _ := strconv.ParseUint(fields[12], 10, 64)
+
+		stats[deviceName] = DiskIOStats{
+			ReadsCompleted:  readsCompleted,
+			SectorsRead:     sectorsRead,
+			ReadTimeMs:      readTimeMs,
+			WritesCompleted: writesCompleted,
+			SectorsWritten:  sectorsWritten,
+			WriteTimeMs:     writeTimeMs,
+			IOTimeMs:        ioTimeMs,
+		}
+	}
+
+	return stats, nil
+}
diff --git a/internal/storagemetrics/mountinfo.go b/internal/storagemetrics/mountinfo.go
new file mode 100644
index 0000000..c81d5ae
--- /dev/null
+++ b/internal/storagemetrics/mountinfo.go
@@ -0,0 +1,197 @@
+package storagemetrics
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+var supportedFilesystems = map[string]bool{
+	"xfs":      true,
+	"btrfs":    true,
+	"ext":      true,
+	"ext2":     true,
+	"ext3":     true,
+	"ext4":     true,
+	"hfs":      true,
+	"vxfs":     true,
+	"reiserfs": true,
+}
+
+type mountInfoReader struct {
+	readFile func(string) ([]byte, error)
+}
+
+func NewMountInfoReader() MountInfoReader {
+	return &mountInfoReader{readFile: os.ReadFile}
+}
+
+func (r *mountInfoReader) ReadMounts() ([]MountInfo, error) {
+	return readMountsWithReader(r.readFile)
+}
+
+func readMountsWithReader(readFile func(string) ([]byte, error)) ([]MountInfo, error) {
+	content, err := readFile("/proc/self/mountinfo")
+	if err == nil {
+		return ParseMountInfo(string(content))
+	}
+
+	content, err = readFile("/proc/self/mounts")
+	if err == nil {
+		return ParseMounts(string(content))
+	}
+
+	content, err = readFile("/etc/mtab")
+	if err == nil {
+		return ParseMounts(string(content))
+	}
+
+	return nil, err
+}
+
+func ParseMountInfo(content string) ([]MountInfo, error) {
+	var mounts []MountInfo
+
+	lines := strings.Split(content, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		mount, ok := parseMountInfoLine(line)
+		if !ok {
+			continue
+		}
+
+		if !supportedFilesystems[mount.FilesystemType] {
+			continue
+		}
+
+		mounts = append(mounts, mount)
+	}
+
+	return mounts, nil
+}
+
+func ParseMounts(content string) ([]MountInfo, error) {
+	var mounts []MountInfo
+
+	lines := strings.Split(content, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		mount, ok := parseMountsLine(line)
+		if !ok {
+			continue
+		}
+
+		if !supportedFilesystems[mount.FilesystemType] {
+			continue
+		}
+
+		mounts = append(mounts, mount)
+	}
+
+	return mounts, nil
+}
+
+func parseMountsLine(line string) (MountInfo, bool) {
+	fields := strings.Fields(line)
+	if len(fields) < 4 {
+		return MountInfo{}, false
+	}
+
+	device := fields[0]
+	mountPoint := UnescapeMountPath(fields[1])
+	fsType := fields[2]
+	options := fields[3]
+
+	isReadOnly := false
+	for _, opt := range strings.Split(options, ",") {
+		if opt == "ro" {
+			isReadOnly = true
+			break
+		}
+	}
+
+	majorMinor := getDeviceMajorMinor(device)
+
+	return MountInfo{
+		MountPoint:     mountPoint,
+		Device:         device,
+		FilesystemType: fsType,
+		IsReadOnly:     isReadOnly,
+		MajorMinor:     majorMinor,
+	}, true
+}
+
+func getDeviceMajorMinor(device string) string {
+	var stat syscall.Stat_t
+	if err := syscall.Stat(device, &stat); err != nil {
+		return ""
+	}
+	major := (stat.Rdev >> 8) & 0xff
+	minor := stat.Rdev & 0xff
+	return fmt.Sprintf("%d:%d", major, minor)
+}
+
+func parseMountInfoLine(line string) (MountInfo, bool) {
+	parts := strings.Split(line, " - ")
+	if len(parts) != 2 {
+		return MountInfo{}, false
+	}
+
+	beforeDash := strings.Fields(parts[0])
+	afterDash := strings.Fields(parts[1])
+
+	if len(beforeDash) < 6 || len(afterDash) < 2 {
+		return MountInfo{}, false
+	}
+
+	mountPoint := UnescapeMountPath(beforeDash[4])
+	mountOptions := beforeDash[5]
+	majorMinor := beforeDash[2]
+
+	fsType := afterDash[0]
+	device := afterDash[1]
+
+	isReadOnly := false
+	for _, opt := range strings.Split(mountOptions, ",") {
+		if opt == "ro" {
+			isReadOnly = true
+			break
+		}
+	}
+
+	return MountInfo{
+		MountPoint:     mountPoint,
+		Device:         device,
+		FilesystemType: fsType,
+		IsReadOnly:     isReadOnly,
+		MajorMinor:     majorMinor,
+	}, true
+}
+
+func UnescapeMountPath(path string) string {
+	var result strings.Builder
+	i := 0
+	for i < len(path) {
+		if path[i] == '\\' && i+3 < len(path) {
+			octal := path[i+1 : i+4]
+			if val, err := strconv.ParseInt(octal, 8, 32); err == nil {
+				result.WriteByte(byte(val))
+				i += 4
+				continue
+			}
+		}
+		result.WriteByte(path[i])
+		i++
+	}
+	return result.String()
+}
diff --git a/internal/storagemetrics/statfs.go b/internal/storagemetrics/statfs.go
new file mode 100644
index 0000000..95f9e1a
--- /dev/null
+++ b/internal/storagemetrics/statfs.go
@@ -0,0 +1,24 @@
+package storagemetrics
+
+import "syscall"
+
+type statfsProvider struct{}
+
+func NewStatfsProvider() StatfsProvider {
+	return &statfsProvider{}
+}
+
+func (p *statfsProvider) Statfs(path string) (StatfsResult, error) {
+	var stat syscall.Statfs_t
+	if err := syscall.Statfs(path, &stat); err != nil {
+		return StatfsResult{}, err
+	}
+	return StatfsResult{
+		Bsize:  int64(stat.Bsize),
+		Blocks: stat.Blocks,
+		Bfree:  stat.Bfree,
+		Bavail: stat.Bavail,
+		Files:  stat.Files,
+		Ffree:  stat.Ffree,
+	}, nil
+}
diff --git a/test/integration/storagemetrics_linux_test.go b/test/integration/storagemetrics_linux_test.go
new file mode 100644
index 0000000..3491a32
--- /dev/null
+++ b/test/integration/storagemetrics_linux_test.go
@@ -0,0 +1,120 @@
+//go:build integration && linux
+
+package integration
+
+import (
+	"context"
+	"math"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"hostlink/internal/storagemetrics"
+)
+
+func TestStorageMetricsCollector_NewDoesNotPanic(t *testing.T) {
+	collector := storagemetrics.New()
+	require.NotNil(t, collector)
+}
+
+func TestStorageMetricsCollector_CollectReturnsResults(t *testing.T) {
+	collector := storagemetrics.New()
+	results, err := collector.Collect(context.Background())
+
+	require.NoError(t, err)
+	require.NotEmpty(t, results, "expected at least one mount point")
+}
+
+func TestStorageMetricsCollector_AttributesArePopulated(t *testing.T) {
+	collector := storagemetrics.New()
+	results, err := collector.Collect(context.Background())
+	require.NoError(t, err)
+
+	for _, r := range results {
+		assert.NotEmpty(t, r.Attributes.MountPoint)
+		assert.NotEmpty(t, r.Attributes.Device)
+		assert.NotEmpty(t, r.Attributes.FilesystemType)
+	}
+}
+
+func TestStorageMetricsCollector_CapacityMetricsAreSensible(t *testing.T) {
+	collector := storagemetrics.New()
+	results, err := collector.Collect(context.Background())
+	require.NoError(t, err)
+
+	for _, r := range results {
+		m := r.Metrics
+		assert.Greater(t, m.DiskTotalBytes, float64(0))
+		assert.GreaterOrEqual(t, m.DiskUsedBytes, float64(0))
+		assert.GreaterOrEqual(t, m.DiskFreeBytes, float64(0))
+	}
+}
+
+func TestStorageMetricsCollector_PercentagesAreInValidRange(t *testing.T) {
+	collector := storagemetrics.New()
+	results, err := collector.Collect(context.Background())
+	require.NoError(t, err)
+
+	for _, r := range results {
+		m := r.Metrics
+		assert.GreaterOrEqual(t, m.DiskUsedPercent, float64(0))
+		assert.LessOrEqual(t, m.DiskUsedPercent, float64(100))
+		assert.GreaterOrEqual(t, m.DiskFreePercent, float64(0))
+		assert.LessOrEqual(t, m.DiskFreePercent, float64(100))
+		assert.GreaterOrEqual(t, m.InodesUsedPercent, float64(0))
+		assert.LessOrEqual(t, m.InodesUsedPercent, float64(100))
+	}
+}
+
+func TestStorageMetricsCollector_SecondCallProducesIOMetrics(t *testing.T) {
+	collector := storagemetrics.New()
+
+	_, err := collector.Collect(context.Background())
+	require.NoError(t, err)
+
+	time.Sleep(150 * time.Millisecond)
+
+	results, err := collector.Collect(context.Background())
+	require.NoError(t, err)
+
+	for _, r := range results {
+		m := r.Metrics
+		assert.LessOrEqual(t, m.TotalUtilizationPercent, float64(100))
+		assert.GreaterOrEqual(t, m.ReadBytesPerSecond, float64(0))
+		assert.GreaterOrEqual(t, m.WriteBytesPerSecond, float64(0))
+	}
+}
+
+func TestStorageMetricsCollector_NoNaNOrInfValues(t *testing.T) {
+	collector := storagemetrics.New()
+
+	_, _ = collector.Collect(context.Background())
+	time.Sleep(150 * time.Millisecond)
+	results, err := collector.Collect(context.Background())
+	require.NoError(t, err)
+
+	for _, r := range results {
+		m := r.Metrics
+		assertStorageValidFloat(t, m.DiskTotalBytes, "DiskTotalBytes")
+		assertStorageValidFloat(t, m.DiskFreeBytes, "DiskFreeBytes")
+		assertStorageValidFloat(t, m.DiskUsedBytes, "DiskUsedBytes")
+		assertStorageValidFloat(t, m.DiskUsedPercent, "DiskUsedPercent")
+		assertStorageValidFloat(t, m.DiskFreePercent, "DiskFreePercent")
+		assertStorageValidFloat(t, m.InodesUsedPercent, "InodesUsedPercent")
+		assertStorageValidFloat(t, m.TotalUtilizationPercent, "TotalUtilizationPercent")
+		assertStorageValidFloat(t, m.ReadUtilizationPercent, "ReadUtilizationPercent")
+		assertStorageValidFloat(t, m.WriteUtilizationPercent, "WriteUtilizationPercent")
+		assertStorageValidFloat(t, m.ReadBytesPerSecond, "ReadBytesPerSecond")
+		assertStorageValidFloat(t, m.WriteBytesPerSecond, "WriteBytesPerSecond")
+		assertStorageValidFloat(t, m.ReadWriteBytesPerSecond, "ReadWriteBytesPerSecond")
+		assertStorageValidFloat(t, m.ReadIOPerSecond, "ReadIOPerSecond")
+		assertStorageValidFloat(t, m.WriteIOPerSecond, "WriteIOPerSecond")
+	}
+}
+
+func assertStorageValidFloat(t *testing.T, value float64, name string) {
+	assert.False(t, math.IsNaN(value), "%s should not be NaN", name)
+	assert.False(t, math.IsInf(value, 0), "%s should not be Inf", name)
+}