[FEAT] Add Support for Human-Readable Data Units in NVMe Attributes

Author: Stancu Florin

docker-compose.dev.yml

@@ -0,0 +1,31 @@
+version: '3.5'
+
+services:
+  scrutiny-dev:
+    build:
+      context: .
+      dockerfile: docker/Dockerfile
+    container_name: scrutiny-dev
+    cap_add:
+      - SYS_RAWIO
+      - SYS_ADMIN  # Required for NVMe drives
+    privileged: true  # Gives access to all devices on the host
+    ports:
+      - "8080:8080"  # Web UI
+      - "8086:8086"  # InfluxDB admin (if needed)
+    volumes:
+      - scrutiny-config:/opt/scrutiny/config
+      - scrutiny-influxdb:/opt/scrutiny/influxdb
+      - go-cache:/go  # Cache Go modules
+      - node-cache:/root/.npm  # Cache npm packages
+    # Uncomment to enable debug mode
+    # environment:
+    #   - DEBUG=true
+    #   - SCRUTINY_LOG_FILE=/tmp/web.log
+    #   - COLLECTOR_LOG_FILE=/tmp/collector.log
+
+volumes:
+  scrutiny-config:
+  scrutiny-influxdb:
+  go-cache:  # Persistent cache for Go modules
+  node-cache:  # Persistent cache for npm packages 

docs/DEVELOPER.md

@@ -0,0 +1,38 @@
+# Scrutiny Developer Guide
+
+This guide is designed for developers who want to make and test changes to Scrutiny using Docker.
+
+## Quick Start with Docker
+
+### Making and Testing Changes
+
+#### 1. Make Your Changes
+
+Make the necessary code changes to implement your feature or fix.
+
+#### 2. Use the Development Docker Compose File
+
+We've provided a unified Docker Compose file that works on all platforms (Linux, macOS, Windows):
+
+```bash
+docker-compose -f docker-compose.dev.yml up --build
+```
+
+This command:
+- Builds a new Docker image with your changes
+- Starts the container
+- Maps the necessary ports and volumes
+
+
+#### 3. Access the Application
+
+Open your browser and navigate to:
+- Web UI: http://localhost:8080
+
+#### 4. Test Your Changes
+
+The collector will run automatically on container startup. To manually trigger the collector:
+
+```bash
+docker exec scrutiny-dev /opt/scrutiny/bin/scrutiny-collector-metrics run
+```

webapp/backend/pkg/models/measurements/smart.go

@@ -163,8 +163,26 @@ func (sm *Smart) ProcessNvmeSmartInfo(nvmeSmartHealthInformationLog collector.Nv
 		"temperature":          (&SmartNvmeAttribute{AttributeId: "temperature", Value: nvmeSmartHealthInformationLog.Temperature, Threshold: -1}).PopulateAttributeStatus(),
 		"available_spare":      (&SmartNvmeAttribute{AttributeId: "available_spare", Value: nvmeSmartHealthInformationLog.AvailableSpare, Threshold: nvmeSmartHealthInformationLog.AvailableSpareThreshold}).PopulateAttributeStatus(),
 		"percentage_used":      (&SmartNvmeAttribute{AttributeId: "percentage_used", Value: nvmeSmartHealthInformationLog.PercentageUsed, Threshold: 100}).PopulateAttributeStatus(),
-		"data_units_read":      (&SmartNvmeAttribute{AttributeId: "data_units_read", Value: nvmeSmartHealthInformationLog.DataUnitsRead, Threshold: -1}).PopulateAttributeStatus(),
-		"data_units_written":   (&SmartNvmeAttribute{AttributeId: "data_units_written", Value: nvmeSmartHealthInformationLog.DataUnitsWritten, Threshold: -1}).PopulateAttributeStatus(),
+		"data_units_read": func() SmartAttribute {
+			transformedValue, valueUnit := TransformDataUnits(nvmeSmartHealthInformationLog.DataUnitsRead)
+			return (&SmartNvmeAttribute{
+				AttributeId:      "data_units_read",
+				Value:            nvmeSmartHealthInformationLog.DataUnitsRead,
+				Threshold:        -1,
+				TransformedValue: transformedValue,
+				ValueUnit:        valueUnit,
+			}).PopulateAttributeStatus()
+		}(),
+		"data_units_written": func() SmartAttribute {
+			transformedValue, valueUnit := TransformDataUnits(nvmeSmartHealthInformationLog.DataUnitsWritten)
+			return (&SmartNvmeAttribute{
+				AttributeId:      "data_units_written",
+				Value:            nvmeSmartHealthInformationLog.DataUnitsWritten,
+				Threshold:        -1,
+				TransformedValue: transformedValue,
+				ValueUnit:        valueUnit,
+			}).PopulateAttributeStatus()
+		}(),
 		"host_reads":           (&SmartNvmeAttribute{AttributeId: "host_reads", Value: nvmeSmartHealthInformationLog.HostReads, Threshold: -1}).PopulateAttributeStatus(),
 		"host_writes":          (&SmartNvmeAttribute{AttributeId: "host_writes", Value: nvmeSmartHealthInformationLog.HostWrites, Threshold: -1}).PopulateAttributeStatus(),
 		"controller_busy_time": (&SmartNvmeAttribute{AttributeId: "controller_busy_time", Value: nvmeSmartHealthInformationLog.ControllerBusyTime, Threshold: -1}).PopulateAttributeStatus(),

webapp/backend/pkg/models/measurements/smart_nvme_attribute.go

@@ -14,6 +14,7 @@ type SmartNvmeAttribute struct {
 	Threshold   int64  `json:"thresh"`
 
 	TransformedValue int64               `json:"transformed_value"`
+	ValueUnit        string              `json:"value_unit,omitempty"` // Unit type (MB/GB/TB/PB)
 	Status           pkg.AttributeStatus `json:"status"`
 	StatusReason     string              `json:"status_reason,omitempty"`
 	FailureRate      float64             `json:"failure_rate,omitempty"`
@@ -35,6 +36,7 @@ func (sa *SmartNvmeAttribute) Flatten() map[string]interface{} {
 
 		//Generated Data
 		fmt.Sprintf("attr.%s.transformed_value", sa.AttributeId): sa.TransformedValue,
+		fmt.Sprintf("attr.%s.value_unit", sa.AttributeId):        sa.ValueUnit,
 		fmt.Sprintf("attr.%s.status", sa.AttributeId):            int64(sa.Status),
 		fmt.Sprintf("attr.%s.status_reason", sa.AttributeId):     sa.StatusReason,
 		fmt.Sprintf("attr.%s.failure_rate", sa.AttributeId):      sa.FailureRate,
@@ -58,6 +60,8 @@ func (sa *SmartNvmeAttribute) Inflate(key string, val interface{}) {
 	//generated
 	case "transformed_value":
 		sa.TransformedValue = val.(int64)
+	case "value_unit":
+		sa.ValueUnit = val.(string)
 	case "status":
 		sa.Status = pkg.AttributeStatus(val.(int64))
 	case "status_reason":

webapp/backend/pkg/models/measurements/smart_utils.go

@@ -0,0 +1,23 @@
+package measurements
+
+// TransformDataUnits converts data units to bytes and determines the appropriate unit (MB, GB, TB, PB)
+// Returns the transformed value and the unit as a string
+func TransformDataUnits(value int64) (int64, string) {
+	// Convert to bytes: value * 1000 * 512 (1000 units of 512 byte data units)
+	// According to NVMe spec: "This value is reported in thousands (i.e., a value of 1 corresponds to 1000 units of 512 bytes read)"
+	bytes := float64(value) * 1000 * 512
+
+	if bytes < 1000*1000*1000 {
+		// Less than 1 GB, show in MB
+		return int64(bytes / 1000 / 1000), "MB"
+	} else if bytes < 1000*1000*1000*1000 {
+		// Less than 1 TB, show in GB
+		return int64(bytes / 1000 / 1000 / 1000), "GB"
+	} else if bytes < 1000*1000*1000*1000*1000 {
+		// Less than 1 PB, show in TB
+		return int64(bytes / 1000 / 1000 / 1000 / 1000), "TB"
+	} else {
+		// Show in PB
+		return int64(bytes / 1000 / 1000 / 1000 / 1000 / 1000), "PB"
+	}
+} 

webapp/backend/pkg/thresholds/nvme_attribute_metadata.go

@@ -52,15 +52,15 @@ var NmveMetadata = map[string]NvmeAttributeMetadata{
 	"data_units_read": {
 		ID:          "data_units_read",
 		DisplayName: "Data Units Read",
-		DisplayType: "",
+		DisplayType: "transformed_with_unit",
 		Ideal:       "",
 		Critical:    false,
 		Description: "Contains the number of 512 byte data units the host has read from the controller; this value does not include metadata. This value is reported in thousands (i.e., a value of 1 corresponds to 1000 units of 512 bytes read) and is rounded up. When the LBA size is a value other than 512 bytes, the controller shall convert the amount of data read to 512 byte units.",
 	},
 	"data_units_written": {
 		ID:          "data_units_written",
 		DisplayName: "Data Units Written",
-		DisplayType: "",
+		DisplayType: "transformed_with_unit",
 		Ideal:       "",
 		Critical:    false,
 		Description: "Contains the number of 512 byte data units the host has written to the controller; this value does not include metadata. This value is reported in thousands (i.e., a value of 1 corresponds to 1000 units of 512 bytes written) and is rounded up. When the LBA size is a value other than 512 bytes, the controller shall convert the amount of data written to 512 byte units.",

webapp/frontend/src/app/core/models/measurements/smart-attribute-model.ts

@@ -11,6 +11,7 @@ export interface SmartAttributeModel {
     when_failed?: string
 
     transformed_value: number
+    value_unit?: string
     status: number
     status_reason?: string
     failure_rate?: number

webapp/frontend/src/app/modules/detail/detail.component.ts

@@ -204,9 +204,18 @@ export class DetailComponent implements OnInit, AfterViewInit, OnDestroy {
         }
     }
 
-    getAttributeValue(attributeData: SmartAttributeModel): number {
+    getAttributeValue(attributeData: SmartAttributeModel): number | string {
+        // Get attribute metadata for any device type
+        const attributeMetadata = this.metadata[attributeData.attribute_id]
+        
+        // Check for transformed_with_unit display type first (for any device type)
+        if (attributeMetadata?.display_type === 'transformed_with_unit' && 
+            attributeData.transformed_value && attributeData.value_unit) {
+            return `${attributeData.transformed_value} ${attributeData.value_unit}`
+        }
+        
+        // Then handle device-specific logic
         if (this.isAta()) {
-            const attributeMetadata = this.metadata[attributeData.attribute_id]
             if (!attributeMetadata) {
                 return attributeData.value
             } else if (attributeMetadata.display_type === 'raw') {