Repository: NetApp/harvest
Pull request #1553 (2022-11-28 13:46:24)

feat: remove pass slice from matrix data structure


Patch:
diff --git a/cmd/collectors/ems/ems.go b/cmd/collectors/ems/ems.go
index d2d4bd5c..439b6af3 100644
--- a/cmd/collectors/ems/ems.go
+++ b/cmd/collectors/ems/ems.go
@@ -368,7 +368,7 @@ func (e *Ems) PollInstance() (map[string]*matrix.Matrix, error) {
 							Msg("failed to get metric")
 					}
 					// check instance timestamp and remove it after given resolve_after value
-					if metricTimestamp, ok, _ = metr.GetValueFloat64(instance); ok {
+					if metricTimestamp, ok = metr.GetValueFloat64(instance); ok {
 						if collectors.IsTimestampOlderThanDuration(metricTimestamp, e.resolveAfter) {
 							mx.RemoveInstance(instanceKey)
 						}
@@ -789,7 +789,7 @@ func (e *Ems) updateMatrix() {
 			// set export to false
 			instance.SetExportable(false)
 
-			if val, ok, _ = metr.GetValueFloat64(instance); ok && val == 0 {
+			if val, ok = metr.GetValueFloat64(instance); ok && val == 0 {
 				mx.RemoveInstance(instanceKey)
 			}
 		}
diff --git a/cmd/collectors/rest/plugins/certificate/certificate.go b/cmd/collectors/rest/plugins/certificate/certificate.go
index 3d19a16b..2f8576cd 100644
--- a/cmd/collectors/rest/plugins/certificate/certificate.go
+++ b/cmd/collectors/rest/plugins/certificate/certificate.go
@@ -162,7 +162,7 @@ func (my *Certificate) setCertificateValidity(data *matrix.Matrix, instance *mat
 		return
 	}
 
-	if expiryTime, ok, _ := expiryTimeMetric.GetValueFloat64(instance); ok {
+	if expiryTime, ok := expiryTimeMetric.GetValueFloat64(instance); ok {
 		// convert expiryTime from float64 to int64 and find difference
 
 		timestampDiff := time.Until(time.Unix(int64(expiryTime), 0)).Hours()
diff --git a/cmd/collectors/rest/plugins/sensor/sensor.go b/cmd/collectors/rest/plugins/sensor/sensor.go
index 2d38a319..d2740acf 100644
--- a/cmd/collectors/rest/plugins/sensor/sensor.go
+++ b/cmd/collectors/rest/plugins/sensor/sensor.go
@@ -115,9 +115,9 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				// Handle both the cases here
 				var criticalLowThr float64
 				if criticalLowMetric := data.GetMetric("crit_low"); criticalLowMetric != nil {
-					criticalLowThr, _, _ = criticalLowMetric.GetValueFloat64(instance)
+					criticalLowThr, _ = criticalLowMetric.GetValueFloat64(instance)
 				} else {
-					criticalLowThr, _, _ = data.GetMetric("critical_low_threshold").GetValueFloat64(instance)
+					criticalLowThr, _ = data.GetMetric("critical_low_threshold").GetValueFloat64(instance)
 				}
 				isAmbientMatch := ambientRegex.MatchString(sensorName)
 				isPowerMatch := powerInRegex.MatchString(sensorName)
@@ -136,7 +136,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 					Msg("")
 
 				if sensorType == "thermal" && isAmbientMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						sensorEnvironmentMetricMap[iKey].ambientTemperature = append(sensorEnvironmentMetricMap[iKey].ambientTemperature, value)
 					}
 				}
@@ -144,7 +144,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				if sensorType == "thermal" && !isAmbientMatch {
 					// Exclude temperature sensors that have crit_low=0 and warn_low is missing
 					if !(criticalLowThr == 0.0 && warningLowThr == "") {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							sensorEnvironmentMetricMap[iKey].nonAmbientTemperature = append(sensorEnvironmentMetricMap[iKey].nonAmbientTemperature, value)
 						}
 					} else {
@@ -156,13 +156,13 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				}
 
 				if sensorType == "fan" {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						sensorEnvironmentMetricMap[iKey].fanSpeed = append(sensorEnvironmentMetricMap[iKey].fanSpeed, value)
 					}
 				}
 
 				if isPowerMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						if sensorUnit != "mW" && sensorUnit != "W" {
 							my.Logger.Warn().Str("unit", sensorUnit).Float64("value", value).Msg("unknown power unit")
 						} else {
@@ -175,7 +175,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				}
 
 				if isVoltageMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						if sensorEnvironmentMetricMap[iKey].voltageSensor == nil {
 							sensorEnvironmentMetricMap[iKey].voltageSensor = make(map[string]*sensorValue)
 						}
@@ -184,7 +184,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				}
 
 				if isCurrentMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						if sensorEnvironmentMetricMap[iKey].currentSensor == nil {
 							sensorEnvironmentMetricMap[iKey].currentSensor = make(map[string]*sensorValue)
 						}
diff --git a/cmd/collectors/rest/plugins/shelf/shelf.go b/cmd/collectors/rest/plugins/shelf/shelf.go
index 9221f0b6..2b28b9b4 100644
--- a/cmd/collectors/rest/plugins/shelf/shelf.go
+++ b/cmd/collectors/rest/plugins/shelf/shelf.go
@@ -324,25 +324,25 @@ func (my *Shelf) calculateEnvironmentMetrics(data *matrix.Matrix) error {
 					if mkey == "temperature" {
 						isAmbient := instance.GetLabel("temp_is_ambient")
 						if isAmbient == "true" {
-							if value, ok, _ := metric.GetValueFloat64(instance); ok {
+							if value, ok := metric.GetValueFloat64(instance); ok {
 								shelfEnvironmentMetricMap[iKey].ambientTemperature = append(shelfEnvironmentMetricMap[iKey].ambientTemperature, value)
 							}
 						}
 						if isAmbient == "false" {
-							if value, ok, _ := metric.GetValueFloat64(instance); ok {
+							if value, ok := metric.GetValueFloat64(instance); ok {
 								shelfEnvironmentMetricMap[iKey].nonAmbientTemperature = append(shelfEnvironmentMetricMap[iKey].nonAmbientTemperature, value)
 							}
 						}
 					}
 				} else if o.Object == "shelf_fan" {
 					if mkey == "rpm" {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							shelfEnvironmentMetricMap[iKey].fanSpeed = append(shelfEnvironmentMetricMap[iKey].fanSpeed, value)
 						}
 					}
 				} else if o.Object == "shelf_voltage" {
 					if mkey == "voltage" {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							if shelfEnvironmentMetricMap[iKey].voltageSensor == nil {
 								shelfEnvironmentMetricMap[iKey].voltageSensor = make(map[string]float64, 0)
 							}
@@ -351,7 +351,7 @@ func (my *Shelf) calculateEnvironmentMetrics(data *matrix.Matrix) error {
 					}
 				} else if o.Object == "shelf_sensor" {
 					if mkey == "current" {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							if shelfEnvironmentMetricMap[iKey].currentSensor == nil {
 								shelfEnvironmentMetricMap[iKey].currentSensor = make(map[string]float64, 0)
 							}
diff --git a/cmd/collectors/restperf/plugins/fcp/fcp.go b/cmd/collectors/restperf/plugins/fcp/fcp.go
index 1c301285..5a6a4844 100644
--- a/cmd/collectors/restperf/plugins/fcp/fcp.go
+++ b/cmd/collectors/restperf/plugins/fcp/fcp.go
@@ -69,9 +69,9 @@ func (me *Fcp) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 		if speed != 0 {
 
 			var rxBytes, txBytes, rxPercent, txPercent float64
-			var rxOk, txOk, passRx, passTx bool
+			var rxOk, txOk bool
 
-			if rxBytes, rxOk, passRx = write.GetValueFloat64(instance); rxOk && passRx {
+			if rxBytes, rxOk = write.GetValueFloat64(instance); rxOk {
 				rxPercent = rxBytes / float64(speed)
 				err := rx.SetValueFloat64(instance, rxPercent)
 				if err != nil {
@@ -79,7 +79,7 @@ func (me *Fcp) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 				}
 			}
 
-			if txBytes, txOk, passTx = read.GetValueFloat64(instance); txOk && passTx {
+			if txBytes, txOk = read.GetValueFloat64(instance); txOk {
 				txPercent = txBytes / float64(speed)
 				err := tx.SetValueFloat64(instance, txPercent)
 				if err != nil {
@@ -87,7 +87,7 @@ func (me *Fcp) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 				}
 			}
 
-			if (rxOk || txOk) && (passRx || passTx) {
+			if rxOk || txOk {
 				err := util.SetValueFloat64(instance, math.Max(rxPercent, txPercent))
 				if err != nil {
 					me.Logger.Error().Stack().Err(err).Msg("error")
diff --git a/cmd/collectors/restperf/plugins/nic/nic.go b/cmd/collectors/restperf/plugins/nic/nic.go
index 74225908..5be97cd7 100644
--- a/cmd/collectors/restperf/plugins/nic/nic.go
+++ b/cmd/collectors/restperf/plugins/nic/nic.go
@@ -90,9 +90,9 @@ func (me *Nic) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 			if speed != 0 {
 
 				var rxBytes, txBytes, rxPercent, txPercent float64
-				var rxOk, txOk, passRx, passTx bool
+				var rxOk, txOk bool
 
-				if rxBytes, rxOk, passRx = read.GetValueFloat64(instance); rxOk && passRx {
+				if rxBytes, rxOk = read.GetValueFloat64(instance); rxOk {
 					rxPercent = rxBytes / float64(speed)
 					err := rx.SetValueFloat64(instance, rxPercent)
 					if err != nil {
@@ -100,7 +100,7 @@ func (me *Nic) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					}
 				}
 
-				if txBytes, txOk, passTx = write.GetValueFloat64(instance); txOk && passTx {
+				if txBytes, txOk = write.GetValueFloat64(instance); txOk {
 					txPercent = txBytes / float64(speed)
 					err := tx.SetValueFloat64(instance, txPercent)
 					if err != nil {
@@ -108,7 +108,7 @@ func (me *Nic) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					}
 				}
 
-				if (rxOk || txOk) && (passRx || passTx) {
+				if rxOk || txOk {
 					err := util.SetValueFloat64(instance, math.Max(rxPercent, txPercent))
 					if err != nil {
 						me.Logger.Error().Stack().Err(err).Msg("error")
diff --git a/cmd/collectors/restperf/plugins/volume/volume.go b/cmd/collectors/restperf/plugins/volume/volume.go
index cdd6a184..8ad2c610 100644
--- a/cmd/collectors/restperf/plugins/volume/volume.go
+++ b/cmd/collectors/restperf/plugins/volume/volume.go
@@ -77,9 +77,9 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 
 				me.Logger.Trace().Msgf("(%s) handling metric (%s)", fg.GetLabel("volume"), mkey)
 
-				if value, ok, pass := m.GetValueFloat64(i); ok && pass {
+				if value, ok := m.GetValueFloat64(i); ok {
 
-					fgv, _, _ := fgm.GetValueFloat64(fg)
+					fgv, _ := fgm.GetValueFloat64(fg)
 
 					// non-latency metrics: simple sum
 					if !strings.HasSuffix(m.GetName(), "_latency") {
@@ -89,7 +89,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 							me.Logger.Error().Stack().Err(err).Msg("error")
 						}
 						// just for debugging
-						fgv2, _, _ := fgm.GetValueFloat64(fg)
+						fgv2, _ := fgm.GetValueFloat64(fg)
 
 						me.Logger.Trace().Msgf("   > simple increment %f + %f = %f", fgv, value, fgv2)
 						continue
@@ -103,7 +103,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					me.Logger.Trace().Msgf("    > weighted increment <%s * %s>", mkey, opsKey)
 
 					if ops := data.GetMetric(opsKey); ops != nil {
-						if opsValue, ok, pass := ops.GetValueFloat64(i); ok && pass {
+						if opsValue, ok := ops.GetValueFloat64(i); ok {
 							var tempOpsV float64
 
 							prod := value * opsValue
@@ -118,7 +118,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 								}
 								tempOps.SetExportable(false)
 							} else {
-								tempOpsV, _, _ = tempOps.GetValueFloat64(fg)
+								tempOpsV, _ = tempOps.GetValueFloat64(fg)
 							}
 							// If latency value is 0 then it's ops value is not used in weighted average calculation
 							if value != 0 {
@@ -133,7 +133,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 							}
 
 							// debugging
-							fgv2, _, _ := fgm.GetValueFloat64(fg)
+							fgv2, _ := fgm.GetValueFloat64(fg)
 
 							me.Logger.Trace().Msgf("       %f + (%f * %f) (=%f) = %f", fgv, value, opsValue, prod, fgv2)
 						} else {
@@ -152,7 +152,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 		for mkey, m := range cache.GetMetrics() {
 			if m.IsExportable() && strings.HasSuffix(m.GetName(), "_latency") {
 
-				if value, ok, pass := m.GetValueFloat64(i); ok && pass {
+				if value, ok := m.GetValueFloat64(i); ok {
 
 					opsKey := ""
 					if strings.Contains(mkey, "_latency") {
@@ -161,7 +161,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 
 					if ops := cache.GetMetric(opsKeyPrefix + opsKey); ops != nil {
 
-						if opsValue, ok, pass := ops.GetValueFloat64(i); ok && pass && opsValue != 0 {
+						if opsValue, ok := ops.GetValueFloat64(i); ok && opsValue != 0 {
 							err := m.SetValueFloat64(i, value/opsValue)
 							if err != nil {
 								me.Logger.Error().Stack().Err(err).Msgf("error")
diff --git a/cmd/collectors/storagegrid/plugins/tenant/tenant.go b/cmd/collectors/storagegrid/plugins/tenant/tenant.go
index 00cf484a..b56ad56e 100644
--- a/cmd/collectors/storagegrid/plugins/tenant/tenant.go
+++ b/cmd/collectors/storagegrid/plugins/tenant/tenant.go
@@ -40,13 +40,13 @@ func (t *Tenant) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 	for _, instance := range data.GetInstances() {
 
 		var (
-			usedBytes, quotaBytes, percentage    float64
-			usedOK, usedPass, quotaOK, quotaPass bool
+			usedBytes, quotaBytes, percentage float64
+			usedOK, quotaOK                   bool
 		)
 
-		usedBytes, usedOK, usedPass = used.GetValueFloat64(instance)
-		quotaBytes, quotaOK, quotaPass = quota.GetValueFloat64(instance)
-		if (usedOK || usedPass) && (quotaOK || quotaPass) {
+		usedBytes, usedOK = used.GetValueFloat64(instance)
+		quotaBytes, quotaOK = quota.GetValueFloat64(instance)
+		if usedOK && quotaOK {
 			percentage = usedBytes / quotaBytes * 100
 			if quotaBytes == 0 {
 				percentage = 0
diff --git a/cmd/collectors/zapi/plugins/certificate/certificate.go b/cmd/collectors/zapi/plugins/certificate/certificate.go
index 434892d4..0bcb7f90 100644
--- a/cmd/collectors/zapi/plugins/certificate/certificate.go
+++ b/cmd/collectors/zapi/plugins/certificate/certificate.go
@@ -169,7 +169,7 @@ func (my *Certificate) setCertificateValidity(data *matrix.Matrix, instance *mat
 		return
 	}
 
-	if expiryTime, ok, _ := expiryTimeMetric.GetValueFloat64(instance); ok {
+	if expiryTime, ok := expiryTimeMetric.GetValueFloat64(instance); ok {
 		// convert expiryTime from float64 to int64 and find difference
 		timestampDiff := time.Until(time.Unix(int64(expiryTime), 0)).Hours()
 
diff --git a/cmd/collectors/zapi/plugins/sensor/sensor.go b/cmd/collectors/zapi/plugins/sensor/sensor.go
index a64ac4a0..0e6d348d 100644
--- a/cmd/collectors/zapi/plugins/sensor/sensor.go
+++ b/cmd/collectors/zapi/plugins/sensor/sensor.go
@@ -112,7 +112,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				sensorName := instance.GetLabel("sensor")
 				sensorUnit := instance.GetLabel("unit")
 				warningLowThr := instance.GetLabel("warning_low")
-				criticalLowThr, _, _ := data.GetMetric("environment-sensors-info.critical-low-threshold").GetValueFloat64(instance)
+				criticalLowThr, _ := data.GetMetric("environment-sensors-info.critical-low-threshold").GetValueFloat64(instance)
 				isAmbientMatch := ambientRegex.MatchString(sensorName)
 				isPowerMatch := powerInRegex.MatchString(sensorName)
 				isVoltageMatch := voltageRegex.MatchString(sensorName)
@@ -130,14 +130,14 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 					Msg("")
 
 				if sensorType == "thermal" && isAmbientMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						sensorEnvironmentMetricMap[iKey].ambientTemperature = append(sensorEnvironmentMetricMap[iKey].ambientTemperature, value)
 					}
 				}
 
 				if sensorType == "thermal" && !isAmbientMatch {
 					// Exclude temperature sensors that contains sensor name `Margin` and value < 0
-					value, ok, _ := metric.GetValueFloat64(instance)
+					value, ok := metric.GetValueFloat64(instance)
 					if value > 0 && !strings.Contains(sensorName, "Margin") {
 						if ok {
 							sensorEnvironmentMetricMap[iKey].nonAmbientTemperature = append(sensorEnvironmentMetricMap[iKey].nonAmbientTemperature, value)
@@ -151,13 +151,13 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				}
 
 				if sensorType == "fan" {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						sensorEnvironmentMetricMap[iKey].fanSpeed = append(sensorEnvironmentMetricMap[iKey].fanSpeed, value)
 					}
 				}
 
 				if isPowerMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						if sensorUnit != "mW" && sensorUnit != "W" {
 							my.Logger.Warn().Str("unit", sensorUnit).Float64("value", value).Msg("unknown power unit")
 						} else {
@@ -170,7 +170,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				}
 
 				if isVoltageMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						if sensorEnvironmentMetricMap[iKey].voltageSensor == nil {
 							sensorEnvironmentMetricMap[iKey].voltageSensor = make(map[string]*sensorValue)
 						}
@@ -179,7 +179,7 @@ func (my *Sensor) calculateEnvironmentMetrics(data *matrix.Matrix) ([]*matrix.Ma
 				}
 
 				if isCurrentMatch {
-					if value, ok, _ := metric.GetValueFloat64(instance); ok {
+					if value, ok := metric.GetValueFloat64(instance); ok {
 						if sensorEnvironmentMetricMap[iKey].currentSensor == nil {
 							sensorEnvironmentMetricMap[iKey].currentSensor = make(map[string]*sensorValue)
 						}
diff --git a/cmd/collectors/zapi/plugins/shelf/shelf.go b/cmd/collectors/zapi/plugins/shelf/shelf.go
index 168684b7..8c12ca18 100644
--- a/cmd/collectors/zapi/plugins/shelf/shelf.go
+++ b/cmd/collectors/zapi/plugins/shelf/shelf.go
@@ -218,25 +218,25 @@ func (my *Shelf) calculateEnvironmentMetrics(data *matrix.Matrix) error {
 					if mkey == "temp-sensor-reading" {
 						isAmbient := instance.GetLabel("temp_is_ambient")
 						if isAmbient == "true" {
-							if value, ok, _ := metric.GetValueFloat64(instance); ok {
+							if value, ok := metric.GetValueFloat64(instance); ok {
 								shelfEnvironmentMetricMap[iKey].ambientTemperature = append(shelfEnvironmentMetricMap[iKey].ambientTemperature, value)
 							}
 						}
 						if isAmbient == "false" {
-							if value, ok, _ := metric.GetValueFloat64(instance); ok {
+							if value, ok := metric.GetValueFloat64(instance); ok {
 								shelfEnvironmentMetricMap[iKey].nonAmbientTemperature = append(shelfEnvironmentMetricMap[iKey].nonAmbientTemperature, value)
 							}
 						}
 					}
 				} else if o.Object == "shelf_fan" {
 					if mkey == "fan-rpm" {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							shelfEnvironmentMetricMap[iKey].fanSpeed = append(shelfEnvironmentMetricMap[iKey].fanSpeed, value)
 						}
 					}
 				} else if o.Object == "shelf_voltage" {
 					if mkey == "voltage-sensor-reading" {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							if shelfEnvironmentMetricMap[iKey].voltageSensor == nil {
 								shelfEnvironmentMetricMap[iKey].voltageSensor = make(map[string]float64, 0)
 							}
@@ -245,7 +245,7 @@ func (my *Shelf) calculateEnvironmentMetrics(data *matrix.Matrix) error {
 					}
 				} else if o.Object == "shelf_sensor" {
 					if mkey == "current-sensor-reading" {
-						if value, ok, _ := metric.GetValueFloat64(instance); ok {
+						if value, ok := metric.GetValueFloat64(instance); ok {
 							if shelfEnvironmentMetricMap[iKey].currentSensor == nil {
 								shelfEnvironmentMetricMap[iKey].currentSensor = make(map[string]float64, 0)
 							}
diff --git a/cmd/collectors/zapiperf/plugins/fcp/fcp.go b/cmd/collectors/zapiperf/plugins/fcp/fcp.go
index 68398379..8537be9f 100644
--- a/cmd/collectors/zapiperf/plugins/fcp/fcp.go
+++ b/cmd/collectors/zapiperf/plugins/fcp/fcp.go
@@ -78,9 +78,9 @@ func (me *Fcp) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 		if speed != 0 {
 
 			var rxBytes, txBytes, rxPercent, txPercent float64
-			var rxOk, txOk, passRx, passTx bool
+			var rxOk, txOk bool
 
-			if rxBytes, rxOk, passRx = write.GetValueFloat64(instance); rxOk && passRx {
+			if rxBytes, rxOk = write.GetValueFloat64(instance); rxOk {
 				rxPercent = rxBytes / float64(speed)
 				err := rx.SetValueFloat64(instance, rxPercent)
 				if err != nil {
@@ -88,7 +88,7 @@ func (me *Fcp) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 				}
 			}
 
-			if txBytes, txOk, passTx = read.GetValueFloat64(instance); txOk && passTx {
+			if txBytes, txOk = read.GetValueFloat64(instance); txOk {
 				txPercent = txBytes / float64(speed)
 				err := tx.SetValueFloat64(instance, txPercent)
 				if err != nil {
@@ -96,7 +96,7 @@ func (me *Fcp) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 				}
 			}
 
-			if (rxOk || txOk) && (passRx || passTx) {
+			if rxOk || txOk {
 				err := util.SetValueFloat64(instance, math.Max(rxPercent, txPercent))
 				if err != nil {
 					me.Logger.Error().Stack().Err(err).Msg("error")
diff --git a/cmd/collectors/zapiperf/plugins/nic/nic.go b/cmd/collectors/zapiperf/plugins/nic/nic.go
index 340f4f7a..4287c244 100644
--- a/cmd/collectors/zapiperf/plugins/nic/nic.go
+++ b/cmd/collectors/zapiperf/plugins/nic/nic.go
@@ -93,9 +93,9 @@ func (me *Nic) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 
 			if speed != 0 {
 				var rxBytes, txBytes, rxPercent, txPercent float64
-				var rxOk, txOk, passRx, passTx bool
+				var rxOk, txOk bool
 
-				if rxBytes, rxOk, passRx = read.GetValueFloat64(instance); rxOk && passRx {
+				if rxBytes, rxOk = read.GetValueFloat64(instance); rxOk {
 					rxPercent = rxBytes / float64(speed)
 					err := rx.SetValueFloat64(instance, rxPercent)
 					if err != nil {
@@ -103,7 +103,7 @@ func (me *Nic) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					}
 				}
 
-				if txBytes, txOk, passTx = write.GetValueFloat64(instance); txOk && passTx {
+				if txBytes, txOk = write.GetValueFloat64(instance); txOk {
 					txPercent = txBytes / float64(speed)
 					err := tx.SetValueFloat64(instance, txPercent)
 					if err != nil {
@@ -111,7 +111,7 @@ func (me *Nic) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					}
 				}
 
-				if (rxOk || txOk) && (passRx || passTx) {
+				if rxOk || txOk {
 					err := util.SetValueFloat64(instance, math.Max(rxPercent, txPercent))
 					if err != nil {
 						me.Logger.Error().Stack().Err(err).Msg("error")
diff --git a/cmd/collectors/zapiperf/plugins/volume/volume.go b/cmd/collectors/zapiperf/plugins/volume/volume.go
index 948da372..64ce6ef6 100644
--- a/cmd/collectors/zapiperf/plugins/volume/volume.go
+++ b/cmd/collectors/zapiperf/plugins/volume/volume.go
@@ -84,9 +84,9 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 
 				me.Logger.Trace().Msgf("(%s) handling metric (%s)", fg.GetLabel("volume"), mkey)
 
-				if value, ok, pass := m.GetValueFloat64(i); ok && pass {
+				if value, ok := m.GetValueFloat64(i); ok {
 
-					fgv, _, _ := fgm.GetValueFloat64(fg)
+					fgv, _ := fgm.GetValueFloat64(fg)
 
 					// non-latency metrics: simple sum
 					if !strings.HasSuffix(m.GetName(), "_latency") {
@@ -96,7 +96,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 							me.Logger.Error().Stack().Err(err).Msg("error")
 						}
 						// just for debugging
-						fgv2, _, _ := fgm.GetValueFloat64(fg)
+						fgv2, _ := fgm.GetValueFloat64(fg)
 
 						me.Logger.Trace().Msgf("   > simple increment %f + %f = %f", fgv, value, fgv2)
 						continue
@@ -110,7 +110,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					me.Logger.Trace().Msgf("    > weighted increment <%s * %s>", mkey, opsKey)
 
 					if ops := data.GetMetric(opsKey); ops != nil {
-						if opsValue, ok, pass := ops.GetValueFloat64(i); ok && pass {
+						if opsValue, ok := ops.GetValueFloat64(i); ok {
 							var tempOpsV float64
 
 							prod := value * opsValue
@@ -125,7 +125,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 								}
 								tempOps.SetExportable(false)
 							} else {
-								tempOpsV, _, _ = tempOps.GetValueFloat64(fg)
+								tempOpsV, _ = tempOps.GetValueFloat64(fg)
 							}
 							// If latency value is 0 then it's ops value is not used in weighted average calculation
 							if value != 0 {
@@ -140,7 +140,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 							}
 
 							// debugging
-							fgv2, _, _ := fgm.GetValueFloat64(fg)
+							fgv2, _ := fgm.GetValueFloat64(fg)
 
 							me.Logger.Trace().Msgf("       %f + (%f * %f) (=%f) = %f", fgv, value, opsValue, prod, fgv2)
 						} else {
@@ -157,7 +157,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 		for mkey, m := range cache.GetMetrics() {
 			if m.IsExportable() && strings.HasSuffix(m.GetName(), "_latency") {
 
-				if value, ok, pass := m.GetValueFloat64(i); ok && pass {
+				if value, ok := m.GetValueFloat64(i); ok {
 
 					opsKey := ""
 					if strings.Contains(mkey, "_latency") {
@@ -167,7 +167,7 @@ func (me *Volume) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					// fetch from temp metrics
 					if ops := cache.GetMetric(opsKeyPrefix + opsKey); ops != nil {
 
-						if opsValue, ok, pass := ops.GetValueFloat64(i); ok && pass && opsValue != 0 {
+						if opsValue, ok := ops.GetValueFloat64(i); ok && opsValue != 0 {
 							err := m.SetValueFloat64(i, value/opsValue)
 							if err != nil {
 								me.Logger.Error().Stack().Err(err).Msgf("error")
diff --git a/cmd/collectors/zapiperf/plugins/vscan/vscan.go b/cmd/collectors/zapiperf/plugins/vscan/vscan.go
index 26669e4b..b0509e78 100644
--- a/cmd/collectors/zapiperf/plugins/vscan/vscan.go
+++ b/cmd/collectors/zapiperf/plugins/vscan/vscan.go
@@ -101,8 +101,8 @@ func (v *Vscan) aggregatePerScanner(data *matrix.Matrix) ([]*matrix.Matrix, erro
 				continue
 			}
 			v.Logger.Trace().Str("scanner", scanner).Str("metric", mKey).Msg("Handling scanner metric")
-			if value, ok, pass := m.GetValueFloat64(i); ok && pass {
-				fv, _, _ := psm.GetValueFloat64(ps)
+			if value, ok := m.GetValueFloat64(i); ok {
+				fv, _ := psm.GetValueFloat64(ps)
 
 				// sum for scan_request_dispatched_rate
 				if mKey == "scan_request_dispatched_rate" {
@@ -112,7 +112,7 @@ func (v *Vscan) aggregatePerScanner(data *matrix.Matrix) ([]*matrix.Matrix, erro
 							Msg("Error setting metric value")
 					}
 					// for tracing
-					fgv2, _, _ := psm.GetValueFloat64(ps)
+					fgv2, _ := psm.GetValueFloat64(ps)
 					v.Logger.Trace().Float64("fv", fv).
 						Float64("value", value).
 						Float64("fgv2", fgv2).
@@ -121,8 +121,8 @@ func (v *Vscan) aggregatePerScanner(data *matrix.Matrix) ([]*matrix.Matrix, erro
 				} else if strings.HasSuffix(mKey, "_used") {
 					// these need averaging
 					counts[scanner][mKey]++
-					runningTotal, _, _ := psm.GetValueFloat64(ps)
-					value, _, _ := m.GetValueFloat64(ps)
+					runningTotal, _ := psm.GetValueFloat64(ps)
+					value, _ := m.GetValueFloat64(ps)
 					err := psm.SetValueFloat64(ps, runningTotal+value)
 					if err != nil {
 						v.Logger.Error().Err(err).Str("mKey", mKey).Msg("Failed to set value")
@@ -137,8 +137,8 @@ func (v *Vscan) aggregatePerScanner(data *matrix.Matrix) ([]*matrix.Matrix, erro
 		for mKey, m := range cache.GetMetrics() {
 			if m.IsExportable() && strings.HasSuffix(m.GetName(), "_used") {
 				count := counts[scanner][mKey]
-				value, ok, pass := m.GetValueFloat64(i)
-				if !ok || !pass {
+				value, ok := m.GetValueFloat64(i)
+				if !ok {
 					continue
 				}
 				if err := m.SetValueFloat64(i, value/float64(count)); err != nil {
diff --git a/cmd/exporters/influxdb/influxdb.go b/cmd/exporters/influxdb/influxdb.go
index 265135aa..a3e60416 100644
--- a/cmd/exporters/influxdb/influxdb.go
+++ b/cmd/exporters/influxdb/influxdb.go
@@ -310,9 +310,9 @@ func (e *InfluxDB) Render(data *matrix.Matrix) ([][]byte, error) {
 				continue
 			}
 
-			value, ok, pass := metric.GetValueString(instance)
+			value, ok := metric.GetValueString(instance)
 
-			if !ok || !pass {
+			if !ok {
 				continue
 			}
 
diff --git a/cmd/exporters/prometheus/prometheus.go b/cmd/exporters/prometheus/prometheus.go
index 3f4b3c66..4b1136b1 100644
--- a/cmd/exporters/prometheus/prometheus.go
+++ b/cmd/exporters/prometheus/prometheus.go
@@ -417,7 +417,7 @@ func (p *Prometheus) render(data *matrix.Matrix) ([][]byte, error) {
 
 			p.Logger.Trace().Msgf("rendering metric [%s]", mkey)
 
-			if value, ok, pass := metric.GetValueString(instance); ok && pass {
+			if value, ok := metric.GetValueString(instance); ok {
 
 				// metric is array, determine if this is a plain array or histogram
 				if metric.HasLabels() {
diff --git a/cmd/poller/collector/collector.go b/cmd/poller/collector/collector.go
index 2a07b326..7a8556c1 100644
--- a/cmd/poller/collector/collector.go
+++ b/cmd/poller/collector/collector.go
@@ -471,7 +471,7 @@ func (c *AbstractCollector) logMetadata() {
 			// don't log these since they're covered by other durations
 			continue
 		}
-		value, _, _ := metric.GetValueFloat64(dataInstance)
+		value, _ := metric.GetValueFloat64(dataInstance)
 		if strings.HasSuffix(mName, "_time") {
 			// convert microseconds to milliseconds and names ending with _time into -> *Ms
 			v := int64(math.Round(value / 1000))
diff --git a/cmd/poller/plugin/aggregator/aggregator.go b/cmd/poller/plugin/aggregator/aggregator.go
index ccf062ee..b1d4e2e2 100644
--- a/cmd/poller/plugin/aggregator/aggregator.go
+++ b/cmd/poller/plugin/aggregator/aggregator.go
@@ -139,7 +139,6 @@ func (a *Aggregator) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 		objMetric       matrix.Metric
 		value           float64
 		ok              bool
-		pass            bool
 		err             error
 	)
 
@@ -201,7 +200,7 @@ func (a *Aggregator) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 
 			for key, metric := range data.GetMetrics() {
 
-				if value, ok, pass = metric.GetValueFloat64(instance); !ok || !pass {
+				if value, ok = metric.GetValueFloat64(instance); !ok {
 					continue
 				}
 
@@ -248,7 +247,7 @@ func (a *Aggregator) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 
 			for key, instance := range m.GetInstances() {
 
-				if value, ok, pass = metric.GetValueFloat64(instance); !ok || !pass {
+				if value, ok = metric.GetValueFloat64(instance); !ok {
 					continue
 				}
 
diff --git a/cmd/poller/plugin/max/max.go b/cmd/poller/plugin/max/max.go
index c0fc283e..687b2ead 100644
--- a/cmd/poller/plugin/max/max.go
+++ b/cmd/poller/plugin/max/max.go
@@ -148,7 +148,6 @@ func (m *Max) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 		objMetric       matrix.Metric
 		value           float64
 		ok              bool
-		pass            bool
 		err             error
 	)
 
@@ -193,7 +192,7 @@ func (m *Max) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					}
 				}
 
-				if value, ok, pass = metric.GetValueFloat64(instance); !ok || !pass {
+				if value, ok = metric.GetValueFloat64(instance); !ok {
 					continue
 				}
 
@@ -202,7 +201,7 @@ func (m *Max) Run(data *matrix.Matrix) ([]*matrix.Matrix, error) {
 					continue
 				}
 
-				v, _, _ := objMetric.GetValueFloat64(objInstance)
+				v, _ := objMetric.GetValueFloat64(objInstance)
 
 				if value > v {
 					if err = objMetric.SetValueFloat64(objInstance, value); err != nil {
diff --git a/cmd/poller/plugin/metricagent/metric_agent.go b/cmd/poller/plugin/metricagent/metric_agent.go
index a55b7676..63fe74d0 100644
--- a/cmd/poller/plugin/metricagent/metric_agent.go
+++ b/cmd/poller/plugin/metricagent/metric_agent.go
@@ -77,7 +77,7 @@ func (a *MetricAgent) computeMetrics(m *matrix.Matrix) error {
 
 			// Parse first operand and store in result for further processing
 			if firstMetricVal = m.GetMetric(r.metricNames[0]); firstMetricVal != nil {
-				if val, ok, pass := firstMetricVal.GetValueFloat64(instance); ok && pass {
+				if val, ok := firstMetricVal.GetValueFloat64(instance); ok {
 					result = val
 				} else {
 					continue
@@ -94,7 +94,7 @@ func (a *MetricAgent) computeMetrics(m *matrix.Matrix) error {
 				} else {
 					metricVal = m.GetMetric(r.metricNames[i])
 					if metricVal != nil {
-						v, _, _ = metricVal.GetValueFloat64(instance)
+						v, _ = metricVal.GetValueFloat64(instance)
 					} else {
 						a.Logger.Warn().Err(err).Str("metricName", r.metricNames[i]).Msg("computeMetrics: metric not found")
 						return nil
diff --git a/pkg/matrix/lazy.go b/pkg/matrix/lazy.go
index 829190f9..d0ccf6f4 100644
--- a/pkg/matrix/lazy.go
+++ b/pkg/matrix/lazy.go
@@ -20,17 +20,17 @@ func (m *Matrix) LazySetValueInt64(mkey, ikey string, v int64) error {
 	return errs.New(ErrInvalidInstanceKey, ikey)
 }
 
-func (m *Matrix) LazyGetValueInt64(key, i string) (int64, bool, bool) {
+func (m *Matrix) LazyGetValueInt64(key, i string) (int64, bool) {
 	if metric := m.GetMetric(key); metric != nil {
 		if instance := m.GetInstance(i); instance != nil {
 			return metric.GetValueInt64(instance)
 		}
 	}
-	return 0, false, false
+	return 0, false
 }
 
 func (m *Matrix) LazyValueInt64(key, i string) int64 {
-	valueInt64, _, _ := m.LazyGetValueInt64(key, i)
+	valueInt64, _ := m.LazyGetValueInt64(key, i)
 	return valueInt64
 }
 
@@ -74,16 +74,16 @@ func (m *Matrix) LazySetValueFloat64(mkey, ikey string, v float64) error {
 	return errs.New(ErrInvalidInstanceKey, ikey)
 }
 
-func (m *Matrix) LazyGetValueFloat64(key, i string) (float64, bool, bool) {
+func (m *Matrix) LazyGetValueFloat64(key, i string) (float64, bool) {
 	if metric := m.GetMetric(key); metric != nil {
 		if instance := m.GetInstance(i); instance != nil {
 			return metric.GetValueFloat64(instance)
 		}
 	}
-	return 0.0, false, false
+	return 0.0, false
 }
 
 func (m *Matrix) LazyValueFloat64(key, i string) float64 {
-	valueFloat64, _, _ := m.LazyGetValueFloat64(key, i)
+	valueFloat64, _ := m.LazyGetValueFloat64(key, i)
 	return valueFloat64
 }
diff --git a/pkg/matrix/math.go b/pkg/matrix/math.go
index 324df7d1..46869963 100644
--- a/pkg/matrix/math.go
+++ b/pkg/matrix/math.go
@@ -7,8 +7,8 @@ package matrix
 func (m *Matrix) InstanceWiseAdditionUint64(toInstance, fromInstance *Instance, fromData *Matrix) {
 	for key, fromMetric := range fromData.GetMetrics() {
 		if toMetric := m.GetMetric(key); toMetric != nil {
-			fromValue, _, _ := fromMetric.GetValueUint64(fromInstance)
-			toValue, _, _ := toMetric.GetValueUint64(toInstance)
+			fromValue, _ := fromMetric.GetValueUint64(fromInstance)
+			toValue, _ := toMetric.GetValueUint64(toInstance)
 			_ = toMetric.SetValueUint64(toInstance, fromValue+toValue)
 		}
 	}
diff --git a/pkg/matrix/metric.go b/pkg/matrix/metric.go
index 441517d1..fcba68d6 100644
--- a/pkg/matrix/metric.go
+++ b/pkg/matrix/metric.go
@@ -67,15 +67,14 @@ type Metric interface {
 	SetValueNAN(*Instance)
 	// methods for reading from metric storage
 
-	GetValueInt(*Instance) (int, bool, bool)
-	GetValueInt64(*Instance) (int64, bool, bool)
-	GetValueUint8(*Instance) (uint8, bool, bool)
-	GetValueUint64(*Instance) (uint64, bool, bool)
-	GetValueFloat64(*Instance) (float64, bool, bool)
-	GetValueString(*Instance) (string, bool, bool)
-	GetValueBytes(*Instance) ([]byte, bool, bool)
+	GetValueInt(*Instance) (int, bool)
+	GetValueInt64(*Instance) (int64, bool)
+	GetValueUint8(*Instance) (uint8, bool)
+	GetValueUint64(*Instance) (uint64, bool)
+	GetValueFloat64(*Instance) (float64, bool)
+	GetValueString(*Instance) (string, bool)
+	GetValueBytes(*Instance) ([]byte, bool)
 	GetRecords() []bool
-	GetPass() []bool
 	GetValuesFloat64() []float64
 
 	// methods for doing vector arithmetics
@@ -100,7 +99,6 @@ type AbstractMetric struct {
 	labels     *dict.Dict
 	buckets    *[]string
 	record     []bool
-	pass       []bool
 }
 
 func (m *AbstractMetric) Clone(deep bool) *AbstractMetric {
@@ -122,10 +120,6 @@ func (m *AbstractMetric) Clone(deep bool) *AbstractMetric {
 			clone.record = make([]bool, len(m.record))
 			copy(clone.record, m.record)
 		}
-		if len(m.pass) != 0 {
-			clone.pass = make([]bool, len(m.pass))
-			copy(clone.pass, m.pass)
-		}
 	}
 	return &clone
 }
@@ -220,10 +214,6 @@ func (m *AbstractMetric) GetRecords() []bool {
 	return m.record
 }
 
-func (m *AbstractMetric) GetPass() []bool {
-	return m.pass
-}
-
 func (m *AbstractMetric) SetValueNAN(i *Instance) {
 	m.record[i.index] = false
 }
diff --git a/pkg/matrix/metric_float64.go b/pkg/matrix/metric_float64.go
index 484cc873..d97cc421 100644
--- a/pkg/matrix/metric_float64.go
+++ b/pkg/matrix/metric_float64.go
@@ -30,13 +30,11 @@ func (m *MetricFloat64) Clone(deep bool) Metric {
 
 func (m *MetricFloat64) Reset(size int) {
 	m.record = make([]bool, size)
-	m.pass = make([]bool, size)
 	m.values = make([]float64, size)
 }
 
 func (m *MetricFloat64) Append() {
 	m.record = append(m.record, false)
-	m.pass = append(m.pass, false)
 	m.values = append(m.values, 0)
 }
 
@@ -44,11 +42,9 @@ func (m *MetricFloat64) Append() {
 func (m *MetricFloat64) Remove(index int) {
 	for i := index; i < len(m.values)-1; i++ {
 		m.record[i] = m.record[i+1]
-		m.pass[i] = m.pass[i+1]
 		m.values[i] = m.values[i+1]
 	}
 	m.record = m.record[:len(m.record)-1]
-	m.pass = m.pass[:len(m.pass)-1]
 	m.values = m.values[:len(m.values)-1]
 }
 
@@ -56,28 +52,24 @@ func (m *MetricFloat64) Remove(index int) {
 
 func (m *MetricFloat64) SetValueInt64(i *Instance, v int64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = float64(v)
 	return nil
 }
 
 func (m *MetricFloat64) SetValueUint8(i *Instance, v uint8) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = float64(v)
 	return nil
 }
 
 func (m *MetricFloat64) SetValueUint64(i *Instance, v uint64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = float64(v)
 	return nil
 }
 
 func (m *MetricFloat64) SetValueFloat64(i *Instance, v float64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = v
 	return nil
 }
@@ -87,7 +79,6 @@ func (m *MetricFloat64) SetValueString(i *Instance, v string) error {
 	var err error
 	if x, err = strconv.ParseFloat(v, 64); err == nil {
 		m.record[i.index] = true
-		m.pass[i.index] = true
 		m.values[i.index] = x
 		return nil
 	}
@@ -99,22 +90,22 @@ func (m *MetricFloat64) SetValueBytes(i *Instance, v []byte) error {
 }
 
 func (m *MetricFloat64) AddValueInt64(i *Instance, n int64) error {
-	v, _, _ := m.GetValueInt64(i)
+	v, _ := m.GetValueInt64(i)
 	return m.SetValueInt64(i, v+n)
 }
 
 func (m *MetricFloat64) AddValueUint8(i *Instance, n uint8) error {
-	v, _, _ := m.GetValueUint8(i)
+	v, _ := m.GetValueUint8(i)
 	return m.SetValueUint8(i, v+n)
 }
 
 func (m *MetricFloat64) AddValueUint64(i *Instance, n uint64) error {
-	v, _, _ := m.GetValueUint64(i)
+	v, _ := m.GetValueUint64(i)
 	return m.SetValueUint64(i, v+n)
 }
 
 func (m *MetricFloat64) AddValueFloat64(i *Instance, n float64) error {
-	v, _, _ := m.GetValueFloat64(i)
+	v, _ := m.GetValueFloat64(i)
 	return m.SetValueFloat64(i, v+n)
 }
 
@@ -127,7 +118,7 @@ func (m *MetricFloat64) AddValueString(i *Instance, v string) error {
 	if x, err = strconv.ParseFloat(v, 64); err != nil {
 		return err
 	}
-	if n, has, _ = m.GetValueFloat64(i); has {
+	if n, has = m.GetValueFloat64(i); has {
 		return m.SetValueFloat64(i, x+n)
 	}
 	return m.SetValueFloat64(i, x)
@@ -135,33 +126,33 @@ func (m *MetricFloat64) AddValueString(i *Instance, v string) error {
 
 // Read methods
 
-func (m *MetricFloat64) GetValueInt(i *Instance) (int, bool, bool) {
-	return int(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricFloat64) GetValueInt(i *Instance) (int, bool) {
+	return int(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricFloat64) GetValueInt64(i *Instance) (int64, bool, bool) {
-	return int64(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricFloat64) GetValueInt64(i *Instance) (int64, bool) {
+	return int64(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricFloat64) GetValueUint8(i *Instance) (uint8, bool, bool) {
-	return uint8(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricFloat64) GetValueUint8(i *Instance) (uint8, bool) {
+	return uint8(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricFloat64) GetValueUint64(i *Instance) (uint64, bool, bool) {
-	return uint64(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricFloat64) GetValueUint64(i *Instance) (uint64, bool) {
+	return uint64(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricFloat64) GetValueFloat64(i *Instance) (float64, bool, bool) {
-	return m.values[i.index], m.record[i.index], m.pass[i.index]
+func (m *MetricFloat64) GetValueFloat64(i *Instance) (float64, bool) {
+	return m.values[i.index], m.record[i.index]
 }
 
-func (m *MetricFloat64) GetValueString(i *Instance) (string, bool, bool) {
-	return strconv.FormatFloat(m.values[i.index], 'f', -1, 64), m.record[i.index], m.pass[i.index]
+func (m *MetricFloat64) GetValueString(i *Instance) (string, bool) {
+	return strconv.FormatFloat(m.values[i.index], 'f', -1, 64), m.record[i.index]
 }
 
-func (m *MetricFloat64) GetValueBytes(i *Instance) ([]byte, bool, bool) {
-	s, ok, pass := m.GetValueString(i)
-	return []byte(s), ok, pass
+func (m *MetricFloat64) GetValueBytes(i *Instance) ([]byte, bool) {
+	s, ok := m.GetValueString(i)
+	return []byte(s), ok
 }
 
 // vector arithmetics
@@ -174,22 +165,19 @@ func (m *MetricFloat64) Delta(s Metric, logger *logging.Logger) (int, error) {
 	var skips int
 	prevRaw := s.GetValuesFloat64()
 	sRecord := s.GetRecords()
-	pass := m.GetPass()
-	if len(m.values) != len(prevRaw) || len(pass) != len(prevRaw) {
+	if len(m.values) != len(prevRaw) {
 		return 0, errs.New(ErrUnequalVectors, fmt.Sprintf("minuend=%d, subtrahend=%d", len(m.values), len(prevRaw)))
 	}
 	for i := range m.values {
 		if m.record[i] && sRecord[i] {
 			curRaw := m.values[i]
-			// reset pass
-			pass[i] = true
 			m.values[i] -= prevRaw[i]
 			// Sometimes ONTAP sends spurious zeroes or values less than the previous poll.
 			// Detect and don't publish negative deltas or the subsequent poll will show a large spike.
 			isInvalidZero := (curRaw == 0 || prevRaw[i] == 0) && m.values[i] != 0
 			isNegative := m.values[i] < 0
 			if isInvalidZero || isNegative {
-				pass[i] = false
+				m.record[i] = false
 				skips++
 				logger.Trace().
 					Str("metric", m.GetName()).
@@ -207,19 +195,16 @@ func (m *MetricFloat64) Divide(s Metric, logger *logging.Logger) (int, error) {
 	var skips int
 	sValues := s.GetValuesFloat64()
 	sRecord := s.GetRecords()
-	pass := m.GetPass()
-	if len(m.values) != len(sValues) || len(pass) != len(sValues) {
+	if len(m.values) != len(sValues) {
 		return 0, errs.New(ErrUnequalVectors, fmt.Sprintf("numerator=%d, denominator=%d", len(m.values), len(sValues)))
 	}
 	for i := 0; i < len(m.values); i++ {
 		if m.record[i] && sRecord[i] {
 			if sValues[i] != 0 {
-				// reset pass
-				pass[i] = true
 				// Don't pass along the value if the numerator or denominator is < 0
 				// A denominator of zero is fine
 				if m.values[i] < 0 || sValues[i] < 0 {
-					pass[i] = false
+					m.record[i] = false
 					skips++
 					logger.Trace().
 						Str("metric", m.GetName()).
@@ -241,18 +226,15 @@ func (m *MetricFloat64) DivideWithThreshold(s Metric, t int, logger *logging.Log
 	x := float64(t)
 	sValues := s.GetValuesFloat64()
 	sRecord := s.GetRecords()
-	pass := m.GetPass()
-	if len(m.values) != len(sValues) || len(pass) != len(sValues) {
+	if len(m.values) != len(sValues) {
 		return 0, errs.New(ErrUnequalVectors, fmt.Sprintf("numerator=%d, denominator=%d", len(m.values), len(sValues)))
 	}
 	for i := 0; i < len(m.values); i++ {
 		v := m.values[i]
-		// reset pass
-		pass[i] = true
 		// Don't pass along the value if the numerator or denominator is < 0
 		// It's important to check sValues[i] < 0 and allow a zero so pass=true and m.values[i] remains unchanged
 		if m.values[i] < 0 || sValues[i] < 0 {
-			pass[i] = false
+			m.record[i] = false
 			skips++
 			logger.Trace().
 				Str("metric", m.GetName()).
@@ -272,14 +254,11 @@ func (m *MetricFloat64) DivideWithThreshold(s Metric, t int, logger *logging.Log
 func (m *MetricFloat64) MultiplyByScalar(s uint, logger *logging.Logger) (int, error) {
 	var skips int
 	x := float64(s)
-	pass := m.GetPass()
 	for i := 0; i < len(m.values); i++ {
 		if m.record[i] {
-			// reset pass
-			pass[i] = true
 			// if current is <= 0
 			if m.values[i] < 0 {
-				pass[i] = false
+				m.record[i] = false
 				skips++
 				logger.Trace().
 					Str("metric", m.GetName()).
@@ -295,7 +274,7 @@ func (m *MetricFloat64) MultiplyByScalar(s uint, logger *logging.Logger) (int, e
 
 func (m *MetricFloat64) Print() {
 	for i := range m.values {
-		if m.record[i] && m.pass[i] {
+		if m.record[i] {
 			fmt.Printf("%s%v%s ", color.Green, m.values[i], color.End)
 		} else {
 			fmt.Printf("%s%v%s ", color.Red, m.values[i], color.End)
diff --git a/pkg/matrix/metric_int64.go b/pkg/matrix/metric_int64.go
index 13ae985c..f083f870 100644
--- a/pkg/matrix/metric_int64.go
+++ b/pkg/matrix/metric_int64.go
@@ -28,13 +28,11 @@ func (m *MetricInt64) Clone(deep bool) Metric {
 
 func (m *MetricInt64) Reset(size int) {
 	m.record = make([]bool, size)
-	m.pass = make([]bool, size)
 	m.values = make([]int64, size)
 }
 
 func (m *MetricInt64) Append() {
 	m.record = append(m.record, false)
-	m.pass = append(m.pass, false)
 	m.values = append(m.values, 0)
 }
 
@@ -42,11 +40,9 @@ func (m *MetricInt64) Append() {
 func (m *MetricInt64) Remove(index int) {
 	for i := index; i < len(m.values)-1; i++ {
 		m.record[i] = m.record[i+1]
-		m.pass[i] = m.pass[i+1]
 		m.values[i] = m.values[i+1]
 	}
 	m.record = m.record[:len(m.record)-1]
-	m.pass = m.pass[:len(m.pass)-1]
 	m.values = m.values[:len(m.values)-1]
 }
 
@@ -54,28 +50,24 @@ func (m *MetricInt64) Remove(index int) {
 
 func (m *MetricInt64) SetValueInt64(i *Instance, v int64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = v
 	return nil
 }
 
 func (m *MetricInt64) SetValueUint8(i *Instance, v uint8) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = int64(v)
 	return nil
 }
 
 func (m *MetricInt64) SetValueUint64(i *Instance, v uint64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = int64(v)
 	return nil
 }
 
 func (m *MetricInt64) SetValueFloat64(i *Instance, v float64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = int64(v)
 	return nil
 }
@@ -85,7 +77,6 @@ func (m *MetricInt64) SetValueString(i *Instance, v string) error {
 	var err error
 	if x, err = strconv.ParseInt(v, 10, 64); err == nil {
 		m.record[i.index] = true
-		m.pass[i.index] = true
 		m.values[i.index] = x
 		return nil
 	}
@@ -97,54 +88,54 @@ func (m *MetricInt64) SetValueBytes(i *Instance, v []byte) error {
 }
 
 func (m *MetricInt64) AddValueInt64(i *Instance, n int64) error {
-	v, _, _ := m.GetValueInt64(i)
+	v, _ := m.GetValueInt64(i)
 	return m.SetValueInt64(i, v+n)
 }
 
 func (m *MetricInt64) AddValueUint8(i *Instance, n uint8) error {
-	v, _, _ := m.GetValueUint8(i)
+	v, _ := m.GetValueUint8(i)
 	return m.SetValueUint8(i, v+n)
 }
 
 func (m *MetricInt64) AddValueUint64(i *Instance, n uint64) error {
-	v, _, _ := m.GetValueUint64(i)
+	v, _ := m.GetValueUint64(i)
 	return m.SetValueUint64(i, v+n)
 }
 
 func (m *MetricInt64) AddValueFloat64(i *Instance, n float64) error {
-	v, _, _ := m.GetValueFloat64(i)
+	v, _ := m.GetValueFloat64(i)
 	return m.SetValueFloat64(i, v+n)
 }
 
 // Read methods
 
-func (m *MetricInt64) GetValueInt(i *Instance) (int, bool, bool) {
-	return int(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricInt64) GetValueInt(i *Instance) (int, bool) {
+	return int(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricInt64) GetValueInt64(i *Instance) (int64, bool, bool) {
-	return m.values[i.index], m.record[i.index], m.pass[i.index]
+func (m *MetricInt64) GetValueInt64(i *Instance) (int64, bool) {
+	return m.values[i.index], m.record[i.index]
 }
 
-func (m *MetricInt64) GetValueUint8(i *Instance) (uint8, bool, bool) {
-	return uint8(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricInt64) GetValueUint8(i *Instance) (uint8, bool) {
+	return uint8(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricInt64) GetValueUint64(i *Instance) (uint64, bool, bool) {
-	return uint64(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricInt64) GetValueUint64(i *Instance) (uint64, bool) {
+	return uint64(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricInt64) GetValueFloat64(i *Instance) (float64, bool, bool) {
-	return float64(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricInt64) GetValueFloat64(i *Instance) (float64, bool) {
+	return float64(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricInt64) GetValueString(i *Instance) (string, bool, bool) {
-	return strconv.FormatInt(m.values[i.index], 10), m.record[i.index], m.pass[i.index]
+func (m *MetricInt64) GetValueString(i *Instance) (string, bool) {
+	return strconv.FormatInt(m.values[i.index], 10), m.record[i.index]
 }
 
-func (m *MetricInt64) GetValueBytes(i *Instance) ([]byte, bool, bool) {
-	s, ok, pass := m.GetValueString(i)
-	return []byte(s), ok, pass
+func (m *MetricInt64) GetValueBytes(i *Instance) ([]byte, bool) {
+	s, ok := m.GetValueString(i)
+	return []byte(s), ok
 }
 
 // vector arithmetics
@@ -161,7 +152,7 @@ func (m *MetricInt64) GetValuesFloat64() []float64 {
 
 func (m *MetricInt64) Print() {
 	for i := range m.values {
-		if m.record[i] && m.pass[i] {
+		if m.record[i] {
 			fmt.Printf("%s%v%s ", color.Green, m.values[i], color.End)
 		} else {
 			fmt.Printf("%s%v%s ", color.Red, m.values[i], color.End)
diff --git a/pkg/matrix/metric_uint64.go b/pkg/matrix/metric_uint64.go
index a6a61de7..10f9d75a 100644
--- a/pkg/matrix/metric_uint64.go
+++ b/pkg/matrix/metric_uint64.go
@@ -29,13 +29,11 @@ func (m *MetricUint64) Clone(deep bool) Metric {
 
 func (m *MetricUint64) Reset(size int) {
 	m.record = make([]bool, size)
-	m.pass = make([]bool, size)
 	m.values = make([]uint64, size)
 }
 
 func (m *MetricUint64) Append() {
 	m.record = append(m.record, false)
-	m.pass = append(m.pass, false)
 	m.values = append(m.values, 0)
 }
 
@@ -43,11 +41,9 @@ func (m *MetricUint64) Append() {
 func (m *MetricUint64) Remove(index int) {
 	for i := index; i < len(m.values)-1; i++ {
 		m.record[i] = m.record[i+1]
-		m.pass[i] = m.pass[i+1]
 		m.values[i] = m.values[i+1]
 	}
 	m.record = m.record[:len(m.record)-1]
-	m.pass = m.pass[:len(m.pass)-1]
 	m.values = m.values[:len(m.values)-1]
 }
 
@@ -56,7 +52,6 @@ func (m *MetricUint64) Remove(index int) {
 func (m *MetricUint64) SetValueInt64(i *Instance, v int64) error {
 	if v >= 0 {
 		m.record[i.index] = true
-		m.pass[i.index] = true
 		m.values[i.index] = uint64(v)
 		return nil
 	}
@@ -65,14 +60,12 @@ func (m *MetricUint64) SetValueInt64(i *Instance, v int64) error {
 
 func (m *MetricUint64) SetValueUint8(i *Instance, v uint8) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = uint64(v)
 	return nil
 }
 
 func (m *MetricUint64) SetValueUint64(i *Instance, v uint64) error {
 	m.record[i.index] = true
-	m.pass[i.index] = true
 	m.values[i.index] = v
 	return nil
 }
@@ -80,7 +73,6 @@ func (m *MetricUint64) SetValueUint64(i *Instance, v uint64) error {
 func (m *MetricUint64) SetValueFloat64(i *Instance, v float64) error {
 	if v >= 0 {
 		m.record[i.index] = true
-		m.pass[i.index] = true
 		m.values[i.index] = uint64(v)
 		return nil
 	}
@@ -92,7 +84,6 @@ func (m *MetricUint64) SetValueString(i *Instance, v string) error {
 	var err error
 	if x, err = strconv.ParseUint(v, 10, 64); err == nil {
 		m.record[i.index] = true
-		m.pass[i.index] = true
 		m.values[i.index] = x
 		return nil
 	}
@@ -104,54 +95,54 @@ func (m *MetricUint64) SetValueBytes(i *Instance, v []byte) error {
 }
 
 func (m *MetricUint64) AddValueInt64(i *Instance, n int64) error {
-	v, _, _ := m.GetValueInt64(i)
+	v, _ := m.GetValueInt64(i)
 	return m.SetValueInt64(i, v+n)
 }
 
 func (m *MetricUint64) AddValueUint8(i *Instance, n uint8) error {
-	v, _, _ := m.GetValueUint8(i)
+	v, _ := m.GetValueUint8(i)
 	return m.SetValueUint8(i, v+n)
 }
 
 func (m *MetricUint64) AddValueUint64(i *Instance, n uint64) error {
-	v, _, _ := m.GetValueUint64(i)
+	v, _ := m.GetValueUint64(i)
 	return m.SetValueUint64(i, v+n)
 }
 
 func (m *MetricUint64) AddValueFloat64(i *Instance, n float64) error {
-	v, _, _ := m.GetValueFloat64(i)
+	v, _ := m.GetValueFloat64(i)
 	return m.SetValueFloat64(i, v+n)
 }
 
 // Read methods
 
-func (m *MetricUint64) GetValueInt(i *Instance) (int, bool, bool) {
-	return int(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricUint64) GetValueInt(i *Instance) (int, bool) {
+	return int(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricUint64) GetValueInt64(i *Instance) (int64, bool, bool) {
-	return int64(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricUint64) GetValueInt64(i *Instance) (int64, bool) {
+	return int64(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricUint64) GetValueUint8(i *Instance) (uint8, bool, bool) {
-	return uint8(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricUint64) GetValueUint8(i *Instance) (uint8, bool) {
+	return uint8(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricUint64) GetValueUint64(i *Instance) (uint64, bool, bool) {
-	return m.values[i.index], m.record[i.index], m.pass[i.index]
+func (m *MetricUint64) GetValueUint64(i *Instance) (uint64, bool) {
+	return m.values[i.index], m.record[i.index]
 }
 
-func (m *MetricUint64) GetValueFloat64(i *Instance) (float64, bool, bool) {
-	return float64(m.values[i.index]), m.record[i.index], m.pass[i.index]
+func (m *MetricUint64) GetValueFloat64(i *Instance) (float64, bool) {
+	return float64(m.values[i.index]), m.record[i.index]
 }
 
-func (m *MetricUint64) GetValueString(i *Instance) (string, bool, bool) {
-	return strconv.FormatUint(m.values[i.index], 10), m.record[i.index], m.pass[i.index]
+func (m *MetricUint64) GetValueString(i *Instance) (string, bool) {
+	return strconv.FormatUint(m.values[i.index], 10), m.record[i.index]
 }
 
-func (m *MetricUint64) GetValueBytes(i *Instance) ([]byte, bool, bool) {
-	s, ok, pass := m.GetValueString(i)
-	return []byte(s), ok, pass
+func (m *MetricUint64) GetValueBytes(i *Instance) ([]byte, bool) {
+	s, ok := m.GetValueString(i)
+	return []byte(s), ok
 }
 
 // vector arithmetics
@@ -168,7 +159,7 @@ func (m *MetricUint64) GetValuesFloat64() []float64 {
 
 func (m *MetricUint64) Print() {
 	for i := range m.values {
-		if m.record[i] && m.pass[i] {
+		if m.record[i] {
 			fmt.Printf("%s%v%s ", color.Green, m.values[i], color.End)
 		} else {
 			fmt.Printf("%s%v%s ", color.Red, m.values[i], color.End)
diff --git a/pkg/matrix/metric_uint8.go b/pkg/matrix/metric_uint8.go
index 3099d76e..831faffb 100644
--- a/pkg/matrix/metric_uint8.go
+++ b/pkg/matrix/metric_uint8.go
@@ -29,13 +29,11 @@ func (u *MetricUint8) Clone(deep bool) Metric {
 
 func (u *MetricUint8) Reset(size int) {
 	u.record = make([]bool, size)
-	u.pass = make([]bool, size)
 	u.values = make([]uint8, size)
 }
 
 func (u *MetricUint8) Append() {
 	u.record = append(u.record, false)
-	u.pass = append(u.pass, false)
 	u.values = append(u.values, 0)
 }
 
@@ -43,11 +41,9 @@ func (u *MetricUint8) Append() {
 func (u *MetricUint8) Remove(index int) {
 	for i := index; i < len(u.values)-1; i++ {
 		u.record[i] = u.record[i+1]
-		u.pass[i] = u.pass[i+1]
 		u.values[i] = u.values[i+1]
 	}
 	u.record = u.record[:len(u.record)-1]
-	u.pass = u.pass[:len(u.pass)-1]
 	u.values = u.values[:len(u.values)-1]
 }
 
@@ -56,7 +52,6 @@ func (u *MetricUint8) Remove(index int) {
 func (u *MetricUint8) SetValueInt64(i *Instance, v int64) error {
 	if v >= 0 {
 		u.record[i.index] = true
-		u.pass[i.index] = true
 		u.values[i.index] = uint8(v)
 		return nil
 	}
@@ -65,7 +60,6 @@ func (u *MetricUint8) SetValueInt64(i *Instance, v int64) error {
 
 func (u *MetricUint8) SetValueBool(i *Instance, v bool) error {
 	u.record[i.index] = true
-	u.pass[i.index] = true
 	if v {
 		u.values[i.index] = 1
 	} else {
@@ -76,14 +70,12 @@ func (u *MetricUint8) SetValueBool(i *Instance, v bool) error {
 
 func (u *MetricUint8) SetValueUint8(i *Instance, v uint8) error {
 	u.record[i.index] = true
-	u.pass[i.index] = true
 	u.values[i.index] = v
 	return nil
 }
 
 func (u *MetricUint8) SetValueUint64(i *Instance, v uint64) error {
 	u.record[i.index] = true
-	u.pass[i.index] = true
 	u.values[i.index] = uint8(v)
 	return nil
 }
@@ -91,7 +83,6 @@ func (u *MetricUint8) SetValueUint64(i *Instance, v uint64) error {
 func (u *MetricUint8) SetValueFloat64(i *Instance, v float64) error {
 	if v >= 0 {
 		u.record[i.index] = true
-		u.pass[i.index] = true
 		u.values[i.index] = uint8(v)
 		return nil
 	}
@@ -103,7 +94,6 @@ func (u *MetricUint8) SetValueString(i *Instance, v string) error {
 	var err error
 	if x, err = strconv.ParseUint(v, 10, 8); err == nil {
 		u.record[i.index] = true
-		u.pass[i.index] = true
 		u.values[i.index] = uint8(x)
 		return nil
 	}
@@ -115,54 +105,54 @@ func (u *MetricUint8) SetValueBytes(i *Instance, v []byte) error {
 }
 
 func (u *MetricUint8) AddValueInt64(i *Instance, n int64) error {
-	m, _, _ := u.GetValueInt64(i)
+	m, _ := u.GetValueInt64(i)
 	return u.SetValueInt64(i, m+n)
 }
 
 func (u *MetricUint8) AddValueUint8(i *Instance, n uint8) error {
-	m, _, _ := u.GetValueUint8(i)
+	m, _ := u.GetValueUint8(i)
 	return u.SetValueUint8(i, m+n)
 }
 
 func (u *MetricUint8) AddValueUint64(i *Instance, n uint64) error {
-	m, _, _ := u.GetValueUint64(i)
+	m, _ := u.GetValueUint64(i)
 	return u.SetValueUint64(i, m+n)
 }
 
 func (u *MetricUint8) AddValueFloat64(i *Instance, n float64) error {
-	m, _, _ := u.GetValueFloat64(i)
+	m, _ := u.GetValueFloat64(i)
 	return u.SetValueFloat64(i, m+n)
 }
 
 // Read methods
 
-func (u *MetricUint8) GetValueInt(i *Instance) (int, bool, bool) {
-	return int(u.values[i.index]), u.record[i.index], u.pass[i.index]
+func (u *MetricUint8) GetValueInt(i *Instance) (int, bool) {
+	return int(u.values[i.index]), u.record[i.index]
 }
 
-func (u *MetricUint8) GetValueInt64(i *Instance) (int64, bool, bool) {
-	return int64(u.values[i.index]), u.record[i.index], u.pass[i.index]
+func (u *MetricUint8) GetValueInt64(i *Instance) (int64, bool) {
+	return int64(u.values[i.index]), u.record[i.index]
 }
 
-func (u *MetricUint8) GetValueUint8(i *Instance) (uint8, bool, bool) {
-	return u.values[i.index], u.record[i.index], u.pass[i.index]
+func (u *MetricUint8) GetValueUint8(i *Instance) (uint8, bool) {
+	return u.values[i.index], u.record[i.index]
 }
 
-func (u *MetricUint8) GetValueUint64(i *Instance) (uint64, bool, bool) {
-	return uint64(u.values[i.index]), u.record[i.index], u.pass[i.index]
+func (u *MetricUint8) GetValueUint64(i *Instance) (uint64, bool) {
+	return uint64(u.values[i.index]), u.record[i.index]
 }
 
-func (u *MetricUint8) GetValueFloat64(i *Instance) (float64, bool, bool) {
-	return float64(u.values[i.index]), u.record[i.index], u.pass[i.index]
+func (u *MetricUint8) GetValueFloat64(i *Instance) (float64, bool) {
+	return float64(u.values[i.index]), u.record[i.index]
 }
 
-func (u *MetricUint8) GetValueString(i *Instance) (string, bool, bool) {
-	return strconv.FormatUint(uint64(u.values[i.index]), 10), u.record[i.index], u.pass[i.index]
+func (u *MetricUint8) GetValueString(i *Instance) (string, bool) {
+	return strconv.FormatUint(uint64(u.values[i.index]), 10), u.record[i.index]
 }
 
-func (u *MetricUint8) GetValueBytes(i *Instance) ([]byte, bool, bool) {
-	s, ok, pass := u.GetValueString(i)
-	return []byte(s), ok, pass
+func (u *MetricUint8) GetValueBytes(i *Instance) ([]byte, bool) {
+	s, ok := u.GetValueString(i)
+	return []byte(s), ok
 }
 
 // vector arithmetics
@@ -179,7 +169,7 @@ func (u *MetricUint8) GetValuesFloat64() []float64 {
 
 func (u *MetricUint8) Print() {
 	for i := range u.values {
-		if u.record[i] && u.pass[i] {
+		if u.record[i] {
 			fmt.Printf("%s%v%s ", color.Green, u.values[i], color.End)
 		} else {
 			fmt.Printf("%s%v%s ", color.Red, u.values[i], color.End)


Test patch:
diff --git a/cmd/collectors/zapi/plugins/sensor/sensor_test.go b/cmd/collectors/zapi/plugins/sensor/sensor_test.go
index cd956f78..c6aaa79d 100644
--- a/cmd/collectors/zapi/plugins/sensor/sensor_test.go
+++ b/cmd/collectors/zapi/plugins/sensor/sensor_test.go
@@ -131,7 +131,7 @@ func TestSensor_Run(t *testing.T) {
 	for _, k := range eMetrics {
 		metrics := omat[0].GetMetrics()
 		for iKey, v := range omat[0].GetInstances() {
-			got, _, _ := metrics[k].GetValueFloat64(v)
+			got, _ := metrics[k].GetValueFloat64(v)
 			exp := expected[k][iKey]
 			if got != exp {
 				t.Errorf("instance %s metrics %s expected: = %v, got: %v", iKey, k, exp, got)
diff --git a/cmd/poller/plugin/aggregator/aggregator_test.go b/cmd/poller/plugin/aggregator/aggregator_test.go
index 93a1991e..36c1806b 100644
--- a/cmd/poller/plugin/aggregator/aggregator_test.go
+++ b/cmd/poller/plugin/aggregator/aggregator_test.go
@@ -97,7 +97,7 @@ func TestRuleSimpleAggregation(t *testing.T) {
 		t.Fatal("Metric [metricB] missing")
 	}
 
-	if value, ok, _ := metricA.GetValueUint8(instanceA); !ok {
+	if value, ok := metricA.GetValueUint8(instanceA); !ok {
 		t.Error("Value [metricA] missing")
 	} else if value != 20 {
 		t.Errorf("Value [metricA] = (%d) incorrect", value)
@@ -105,7 +105,7 @@ func TestRuleSimpleAggregation(t *testing.T) {
 		t.Logf("Value [metricA] = (%d) correct!", value)
 	}
 
-	if value, ok, _ := metricB.GetValueUint8(instanceA); !ok {
+	if value, ok := metricB.GetValueUint8(instanceA); !ok {
 		t.Error("Value [metricB] missing")
 	} else if value != 10 {
 		t.Errorf("Value [metricB] = (%d) incorrect", value)
@@ -288,7 +288,7 @@ func TestComplexRuleRegex(t *testing.T) {
 		} else {
 			t.Errorf("instance has not expected labels: %v", instance.GetLabels())
 		}
-		if v, ok, _ := metricA.GetValueUint8(instance); !ok {
+		if v, ok := metricA.GetValueUint8(instance); !ok {
 			t.Errorf("value [metricA] not set")
 		} else if v != expected {
 			t.Errorf("value [metricA] = %d, expected %d", v, expected)
@@ -309,7 +309,7 @@ func TestComplexRuleRegex(t *testing.T) {
 			t.Errorf("instance has not expected labels: %v", instance.GetLabels())
 		}
 
-		if v, ok, _ := metricA.GetValueUint8(instance); !ok {
+		if v, ok := metricA.GetValueUint8(instance); !ok {
 			t.Errorf("value [metricA] not set")
 		} else if v != expected {
 			t.Errorf("value [metricA] = %d, expected %d", v, expected)
diff --git a/cmd/poller/plugin/labelagent/label_agent_test.go b/cmd/poller/plugin/labelagent/label_agent_test.go
index ed608aa8..b62605cd 100644
--- a/cmd/poller/plugin/labelagent/label_agent_test.go
+++ b/cmd/poller/plugin/labelagent/label_agent_test.go
@@ -347,7 +347,7 @@ func TestValueToNumRule(t *testing.T) {
 
 	// check "status" for instanceA
 	expected = 1
-	if v, ok, _ = status.GetValueUint8(instanceA); !ok {
+	if v, ok = status.GetValueUint8(instanceA); !ok {
 		t.Error("metric [status]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [status]: value for InstanceA is %d, expected %d", v, expected)
@@ -356,7 +356,7 @@ func TestValueToNumRule(t *testing.T) {
 	}
 
 	// check "status" for instanceB
-	if v, ok, _ = status.GetValueUint8(instanceB); !ok {
+	if v, ok = status.GetValueUint8(instanceB); !ok {
 		t.Log("OK - metric [status]: value for InstanceB not set")
 	} else {
 		t.Errorf("metric [status]: value for InstanceB is %d, should not be set", v)
@@ -364,7 +364,7 @@ func TestValueToNumRule(t *testing.T) {
 
 	// check "stage" for instanceA
 	expected = 1
-	if v, ok, _ = stage.GetValueUint8(instanceA); !ok {
+	if v, ok = stage.GetValueUint8(instanceA); !ok {
 		t.Error("metric [stage]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [stage]: value for InstanceA is %d, expected %d", v, expected)
@@ -374,7 +374,7 @@ func TestValueToNumRule(t *testing.T) {
 
 	// check "stage" for instanceB
 	expected = 4
-	if v, ok, _ = stage.GetValueUint8(instanceB); !ok {
+	if v, ok = stage.GetValueUint8(instanceB); !ok {
 		t.Error("metric [stage]: value for InstanceB not set")
 	} else if v != expected {
 		t.Errorf("metric [stage]: value for InstanceB is %d, expected %d", v, expected)
@@ -384,7 +384,7 @@ func TestValueToNumRule(t *testing.T) {
 
 	// check "outage" for instanceA
 	expected = 1
-	if v, ok, _ = outage.GetValueUint8(instanceA); !ok {
+	if v, ok = outage.GetValueUint8(instanceA); !ok {
 		t.Error("metric [outage]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [outage]: value for InstanceA is %d, expected %d", v, expected)
@@ -394,7 +394,7 @@ func TestValueToNumRule(t *testing.T) {
 
 	// check "outage" for instanceB
 	expected = 0
-	if v, ok, _ = outage.GetValueUint8(instanceB); !ok {
+	if v, ok = outage.GetValueUint8(instanceB); !ok {
 		t.Error("metric [outage]: value for InstanceB not set")
 	} else if v != expected {
 		t.Errorf("metric [outage]: value for InstanceB is %d, expected %d", v, expected)
@@ -447,7 +447,7 @@ func TestValueToNumRegexRule(t *testing.T) {
 
 	// check "status" for instanceA
 	expected = 1
-	if v, ok, _ = status.GetValueUint8(instanceA); !ok {
+	if v, ok = status.GetValueUint8(instanceA); !ok {
 		t.Error("metric [status]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [status]: value for InstanceA is %d, expected %d", v, expected)
@@ -457,7 +457,7 @@ func TestValueToNumRegexRule(t *testing.T) {
 
 	// check "status" for instanceB
 	expected = 0
-	if v, ok, _ = status.GetValueUint8(instanceB); !ok {
+	if v, ok = status.GetValueUint8(instanceB); !ok {
 		t.Log("metric [status]: value for InstanceB not set")
 	} else if v != expected {
 		t.Errorf("metric [status]: value for InstanceB is %d, expected %d", v, expected)
@@ -467,7 +467,7 @@ func TestValueToNumRegexRule(t *testing.T) {
 
 	// check "output" for instanceA
 	expected = 4
-	if v, ok, _ = output.GetValueUint8(instanceA); !ok {
+	if v, ok = output.GetValueUint8(instanceA); !ok {
 		t.Error("metric [stage]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [stage]: value for InstanceA is %d, expected %d", v, expected)
@@ -477,7 +477,7 @@ func TestValueToNumRegexRule(t *testing.T) {
 
 	// check "output" for instanceB
 	expected = 1
-	if v, ok, _ = output.GetValueUint8(instanceB); !ok {
+	if v, ok = output.GetValueUint8(instanceB); !ok {
 		t.Error("metric [stage]: value for InstanceB not set")
 	} else if v != expected {
 		t.Errorf("metric [stage]: value for InstanceB is %d, expected %d", v, expected)
@@ -487,7 +487,7 @@ func TestValueToNumRegexRule(t *testing.T) {
 
 	// check "result" for instanceA
 	expected = 1
-	if v, ok, _ = result.GetValueUint8(instanceA); !ok {
+	if v, ok = result.GetValueUint8(instanceA); !ok {
 		t.Error("metric [outage]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [outage]: value for InstanceA is %d, expected %d", v, expected)
@@ -497,7 +497,7 @@ func TestValueToNumRegexRule(t *testing.T) {
 
 	// check "result" for instanceB
 	expected = 4
-	if v, ok, _ = result.GetValueUint8(instanceB); !ok {
+	if v, ok = result.GetValueUint8(instanceB); !ok {
 		t.Error("metric [outage]: value for InstanceB not set")
 	} else if v != expected {
 		t.Errorf("metric [outage]: value for InstanceB is %d, expected %d", v, expected)
diff --git a/cmd/poller/plugin/metricagent/metric_agent_test.go b/cmd/poller/plugin/metricagent/metric_agent_test.go
index ce45d8de..97158d85 100644
--- a/cmd/poller/plugin/metricagent/metric_agent_test.go
+++ b/cmd/poller/plugin/metricagent/metric_agent_test.go
@@ -132,7 +132,7 @@ func TestComputeMetricsRule(t *testing.T) {
 	// check "space_total" for instanceA
 	expected = 6060606060
 	if metricTotal = m.GetMetric("space_total"); metricTotal != nil {
-		if metricTotalVal, ok, pass := metricTotal.GetValueFloat64(instanceA); !ok || !pass {
+		if metricTotalVal, ok := metricTotal.GetValueFloat64(instanceA); !ok {
 			t.Error("metric [space_total]: value for InstanceA not set")
 		} else if metricTotalVal != expected {
 			t.Errorf("metric [space_total]: value for InstanceA is %f, expected %f", metricTotalVal, expected)
@@ -146,7 +146,7 @@ func TestComputeMetricsRule(t *testing.T) {
 	// check "disk_count" for instanceB
 	expected = 22
 	if metricDiskTotal = m.GetMetric("disk_count"); metricDiskTotal != nil {
-		if metricDiskTotalVal, ok, pass := metricDiskTotal.GetValueFloat64(instanceB); !ok || !pass {
+		if metricDiskTotalVal, ok := metricDiskTotal.GetValueFloat64(instanceB); !ok {
 			t.Error("metric [disk_count]: value for InstanceB not set")
 		} else if metricDiskTotalVal != expected {
 			t.Errorf("metric [disk_count]: value for InstanceB is %f, expected %f", metricDiskTotalVal, expected)
@@ -160,7 +160,7 @@ func TestComputeMetricsRule(t *testing.T) {
 	// check "files_available" for instanceA
 	expected = 808
 	if metricFilesAvailable = m.GetMetric("files_available"); metricFilesAvailable != nil {
-		if metricFilesAvailableVal, ok, pass := metricFilesAvailable.GetValueFloat64(instanceA); !ok || !pass {
+		if metricFilesAvailableVal, ok := metricFilesAvailable.GetValueFloat64(instanceA); !ok {
 			t.Error("metric [files_available]: value for InstanceA not set")
 		} else if metricFilesAvailableVal != expected {
 			t.Errorf("metric [files_available]: value for InstanceA is %f, expected %f", metricFilesAvailableVal, expected)
@@ -174,7 +174,7 @@ func TestComputeMetricsRule(t *testing.T) {
 	// check "total_bytes" for instanceB
 	expected = 120000
 	if metricTotalBytes = m.GetMetric("total_bytes"); metricTotalBytes != nil {
-		if metricTotalBytesVal, ok, pass := metricTotalBytes.GetValueFloat64(instanceB); !ok || !pass {
+		if metricTotalBytesVal, ok := metricTotalBytes.GetValueFloat64(instanceB); !ok {
 			t.Error("metric [total_bytes]: value for InstanceB not set")
 		} else if metricTotalBytesVal != expected {
 			t.Errorf("metric [total_bytes]: value for InstanceB is %f, expected %f", metricTotalBytesVal, expected)
@@ -188,7 +188,7 @@ func TestComputeMetricsRule(t *testing.T) {
 	// check "transmission_rate" for instanceB
 	expected = 2500
 	if metricTransmissionRate = m.GetMetric("transmission_rate"); metricTransmissionRate != nil {
-		if metricTransmissionRateVal, ok, pass := metricTransmissionRate.GetValueFloat64(instanceB); !ok || !pass {
+		if metricTransmissionRateVal, ok := metricTransmissionRate.GetValueFloat64(instanceB); !ok {
 			t.Error("metric [transmission_rate]: value for InstanceB not set")
 		} else if metricTransmissionRateVal != expected {
 			t.Errorf("metric [transmission_rate]: value for InstanceB is %f, expected %f", metricTransmissionRateVal, expected)
diff --git a/cmd/poller/plugin/test/plugin_test.go b/cmd/poller/plugin/test/plugin_test.go
index c7f60984..66e694b7 100644
--- a/cmd/poller/plugin/test/plugin_test.go
+++ b/cmd/poller/plugin/test/plugin_test.go
@@ -119,7 +119,7 @@ func TestMultipleRule(t *testing.T) {
 	}
 
 	expected = 1
-	if v, ok, pass := status.GetValueUint8(instanceA); !ok || !pass {
+	if v, ok := status.GetValueUint8(instanceA); !ok {
 		t.Error("metric [status]: value for InstanceA not set")
 	} else if v != expected {
 		t.Errorf("metric [status]: value for InstanceA is %d, expected %d", v, expected)
diff --git a/pkg/matrix/metric_float64_test.go b/pkg/matrix/metric_float64_test.go
index 2a464d85..6e04c3f6 100644
--- a/pkg/matrix/metric_float64_test.go
+++ b/pkg/matrix/metric_float64_test.go
@@ -33,16 +33,16 @@ type test struct {
 	threshold int
 	scalar    uint
 	skips     int
-	passes    bool
+	record    bool
 }
 
 func TestMetricFloat64_Delta(t *testing.T) {
 	tests := []test{
-		{curRaw: 10, prevRaw: 10, cooked: 0, skips: 0, passes: true, name: "no increase"},
-		{curRaw: 20, prevRaw: 10, cooked: 10, skips: 0, passes: true, name: "normal increase"},
-		{curRaw: 10, prevRaw: 20, cooked: -10, skips: 1, passes: false, name: "bug negative"},
-		{curRaw: 10, prevRaw: 0, cooked: 10, skips: 1, passes: false, name: "bug zeroPrev"},
-		{curRaw: 0, prevRaw: 10, cooked: -10, skips: 1, passes: false, name: "bug zeroCur"},
+		{curRaw: 10, prevRaw: 10, cooked: 0, skips: 0, record: true, name: "no increase"},
+		{curRaw: 20, prevRaw: 10, cooked: 10, skips: 0, record: true, name: "normal increase"},
+		{curRaw: 10, prevRaw: 20, cooked: -10, skips: 1, record: false, name: "bug negative"},
+		{curRaw: 10, prevRaw: 0, cooked: 10, skips: 1, record: false, name: "bug zeroPrev"},
+		{curRaw: 0, prevRaw: 10, cooked: -10, skips: 1, record: false, name: "bug zeroCur"},
 	}
 
 	for _, tt := range tests {
@@ -56,12 +56,12 @@ func TestMetricFloat64_Delta(t *testing.T) {
 
 func TestMetricFloat64_Divide(t *testing.T) {
 	tests := []test{
-		{prevRaw: 20, curRaw: 10, cooked: 2, skips: 0, passes: true, name: "normal"},
-		{prevRaw: -20, curRaw: 10, cooked: -2, skips: 1, passes: false, name: "bug negative num"},
-		{prevRaw: 20, curRaw: -10, cooked: -2, skips: 1, passes: false, name: "bug negative den"},
-		{prevRaw: -20, curRaw: -10, cooked: 2, skips: 1, passes: false, name: "bug negative both"},
-		{prevRaw: 20, curRaw: 0, cooked: 0, skips: 0, passes: true, name: "allow zero den"},
-		{prevRaw: 0, curRaw: 0, cooked: 0, skips: 0, passes: true, name: "allow zero both"},
+		{prevRaw: 20, curRaw: 10, cooked: 2, skips: 0, record: true, name: "normal"},
+		{prevRaw: -20, curRaw: 10, cooked: -2, skips: 1, record: false, name: "bug negative num"},
+		{prevRaw: 20, curRaw: -10, cooked: -2, skips: 1, record: false, name: "bug negative den"},
+		{prevRaw: -20, curRaw: -10, cooked: 2, skips: 1, record: false, name: "bug negative both"},
+		{prevRaw: 20, curRaw: 0, cooked: 0, skips: 0, record: true, name: "allow zero den"},
+		{prevRaw: 0, curRaw: 0, cooked: 0, skips: 0, record: true, name: "allow zero both"},
 	}
 
 	for _, tt := range tests {
@@ -75,12 +75,12 @@ func TestMetricFloat64_Divide(t *testing.T) {
 
 func TestMetricFloat64_DivideWithThreshold(t *testing.T) {
 	tests := []test{
-		{prevRaw: 20, curRaw: 10, threshold: 5, cooked: 2, skips: 0, passes: true, name: "normal"},
-		{prevRaw: 20, curRaw: 10, threshold: 15, cooked: 0, skips: 0, passes: true, name: "normal < threshold"},
-		{prevRaw: 20, curRaw: -10, threshold: 5, cooked: 0, skips: 1, passes: false, name: "bug negative den"},
-		{prevRaw: -20, curRaw: -10, threshold: 5, cooked: 0, skips: 1, passes: false, name: "bug negative both"},
-		{prevRaw: 20, curRaw: 0, threshold: 0, cooked: math.Inf(1), skips: 0, passes: true, name: "allow no threshold"},
-		{prevRaw: 0, curRaw: 0, threshold: 5, cooked: 0, skips: 0, passes: true, name: "allow zero both"},
+		{prevRaw: 20, curRaw: 10, threshold: 5, cooked: 2, skips: 0, record: true, name: "normal"},
+		{prevRaw: 20, curRaw: 10, threshold: 15, cooked: 0, skips: 0, record: true, name: "normal < threshold"},
+		{prevRaw: 20, curRaw: -10, threshold: 5, cooked: 0, skips: 1, record: false, name: "bug negative den"},
+		{prevRaw: -20, curRaw: -10, threshold: 5, cooked: 0, skips: 1, record: false, name: "bug negative both"},
+		{prevRaw: 20, curRaw: 0, threshold: 0, cooked: math.Inf(1), skips: 0, record: true, name: "allow no threshold"},
+		{prevRaw: 0, curRaw: 0, threshold: 5, cooked: 0, skips: 0, record: true, name: "allow zero both"},
 	}
 
 	for _, tt := range tests {
@@ -95,8 +95,8 @@ func TestMetricFloat64_DivideWithThreshold(t *testing.T) {
 
 func TestMetricFloat64_MultiplyByScalar(t *testing.T) {
 	tests := []test{
-		{prevRaw: 10, curRaw: 10, scalar: 5, cooked: 50, skips: 0, passes: true, name: "normal"},
-		{prevRaw: 10, curRaw: -10, scalar: 5, cooked: -50, skips: 1, passes: false, name: "bug negative"},
+		{prevRaw: 10, curRaw: 10, scalar: 5, cooked: 50, skips: 0, record: true, name: "normal"},
+		{prevRaw: 10, curRaw: -10, scalar: 5, cooked: -50, skips: 1, record: false, name: "bug negative"},
 	}
 
 	for _, tt := range tests {
@@ -120,9 +120,9 @@ func matrixTest(t *testing.T, tt test, cur *Matrix, skips int, err error) {
 	if cooked != tt.cooked {
 		t.Errorf("cooked expected = %v, got %v", tt.cooked, cooked)
 	}
-	passes := cur.GetMetric("speed").GetPass()[0]
-	if passes != tt.passes {
-		t.Errorf("passes expected = %t, got %t", tt.passes, passes)
+	record := cur.GetMetric("speed").GetRecords()[0]
+	if record != tt.record {
+		t.Errorf("record expected = %t, got %t", tt.record, record)
 	}
 }
 
@@ -132,7 +132,7 @@ func TestMetricReset(t *testing.T) {
 	_, _ = m.NewMetricInt64("poll_time")
 	_ = m.LazySetValueInt64("poll_time", "task1", 10)
 	m.ResetInstance("task1")
-	_, pass, _ := m.LazyGetValueInt64("poll_time", "task1")
+	_, pass := m.LazyGetValueInt64("poll_time", "task1")
 	if pass {
 		t.Errorf("expected metric to be skipped but passed")
 	}