(v0.7.3) Automated packaging of release by Packagr

Add support for disabling repeat notifications if the values haven't changed

.github/workflows/ci.yaml

@@ -101,7 +101,7 @@ jobs:
         uses: actions/checkout@v2
       - uses: actions/setup-go@v3
         with:
-          go-version: '^1.18.3'
+          go-version: '^1.20.1'
       - name: Build Binaries
         run: |
           make binary-clean binary-all
@@ -111,4 +111,4 @@ jobs:
           name: binaries.zip
           path: |
             scrutiny-web-*
-            scrutiny-collector-metrics-*
+            scrutiny-collector-metrics-*

.github/workflows/docker-build.yaml

@@ -74,15 +74,6 @@ jobs:
         uses: actions/checkout@v2
       - name: "Populate frontend version information"
         run: "cd webapp/frontend && ./git.version.sh"
-      - name: "Generate frontend"
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:lts
-          options: -v ${{ github.workspace }}:/work
-          run: |
-            cd /work
-            make binary-frontend && echo "print contents of /work/dist" && ls -alt /work/dist
-
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
         with:
@@ -134,16 +125,6 @@ jobs:
         uses: actions/checkout@v2
       - name: "Populate frontend version information"
         run: "cd webapp/frontend && ./git.version.sh"
-      - name: "Generate frontend & version information"
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:lts
-          options: -v ${{ github.workspace }}:/work
-          run: |
-            cd /work
-            make binary-frontend && echo "print contents of /work/dist" && ls -alt /work/dist
-
-
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
         with:
@@ -181,4 +162,4 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
 #          cache-from: type=gha
-#          cache-to: type=gha,mode=max
+#          cache-to: type=gha,mode=max

.github/workflows/docker-nightly.yaml

@@ -19,16 +19,6 @@ jobs:
         uses: actions/checkout@v2
       - name: "Populate frontend version information"
         run: "cd webapp/frontend && ./git.version.sh"
-      - name: "Generate frontend & version information"
-        uses: addnab/docker-run-action@v3
-        with:
-          image: node:lts
-          options: -v ${{ github.workspace }}:/work
-          run: |
-            cd /work
-            make binary-frontend && echo "print contents of /work/dist" && ls -alt /work/dist
-
-
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
         with:

.github/workflows/release.yaml

@@ -96,7 +96,7 @@ jobs:
           name: workspace
       - uses: actions/setup-go@v3
         with:
-          go-version: '1.18.3' # The Go version to download (if necessary) and use.
+          go-version: '1.20.1' # The Go version to download (if necessary) and use.
       - name: Build Binaries
         run: |
           make binary-clean binary-all

.gitignore

@@ -65,4 +65,6 @@ scrutiny_test.db
 scrutiny.yaml
 coverage.txt
 /config
-/influxdb
+/influxdb
+.angular
+web.log

CONTRIBUTING.md

@@ -5,18 +5,18 @@ The Scrutiny repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo)
 - Scrutiny Frontend Angular SPA
 - S.M.A.R.T Collector
 
-Depending on the functionality you are adding, you may need to setup a development environment for 1 or more projects. 
+Depending on the functionality you are adding, you may need to setup a development environment for 1 or more projects.
 
 # Modifying the Scrutiny Backend Server (API)
 
-1. install the [Go runtime](https://go.dev/doc/install) (v1.18+)
+1. install the [Go runtime](https://go.dev/doc/install) (v1.20+)
 2. download the `scrutiny-web-frontend.tar.gz` for
    the [latest release](https://github.com/AnalogJ/scrutiny/releases/latest). Extract to a folder named `dist`
 3. create a `scrutiny.yaml` config file
     ```yaml
     # config file for local development. store as scrutiny.yaml
     version: 1
-    
+
     web:
       listen:
         port: 8080
@@ -29,13 +29,13 @@ Depending on the functionality you are adding, you may need to setup a developme
           path: ./dist
       influxdb:
         retention_policy: false
-    
+
     log:
       file: 'web.log' #absolute or relative paths allowed, eg. web.log
       level: DEBUG
 
     ```
-4. start a InfluxDB docker container. 
+4. start a InfluxDB docker container.
     ```bash
     docker run -p 8086:8086 --rm influxdb:2.2
     ```
@@ -55,21 +55,21 @@ The frontend is written in Angular. If you're working on the frontend and can us
     ```bash
     cd webapp/frontend
     npm install
-    npm run start -- --deploy-url="/web/" --base-href="/web/" --port 4200
+    npm run start -- --serve-path="/web/" --port 4200
     ```
 3. open your browser and visit [http://localhost:4200/web](http://localhost:4200/web)
 
 # Modifying both Scrutiny Backend and Frontend Applications
-If you're developing a feature that requires changes to the backend and the frontend, or a frontend feature that requires real data, 
+If you're developing a feature that requires changes to the backend and the frontend, or a frontend feature that requires real data,
 you'll need to follow the steps below:
 
-1. install the [Go runtime](https://go.dev/doc/install) (v1.18+)
+1. install the [Go runtime](https://go.dev/doc/install) (v1.20+)
 2. install [NodeJS](https://nodejs.org/en/download/)
 3. create a `scrutiny.yaml` config file
     ```yaml
     # config file for local development. store as scrutiny.yaml
     version: 1
-    
+
     web:
       listen:
         port: 8080
@@ -82,7 +82,7 @@ you'll need to follow the steps below:
           path: ./dist
       influxdb:
         retention_policy: false
-    
+
     log:
       file: 'web.log' #absolute or relative paths allowed, eg. web.log
       level: DEBUG
@@ -185,4 +185,4 @@ docker run -p 8086:8086 -d --rm \
 influxdb:2.2
 go test ./...
 
-```
+```

Makefile

@@ -100,7 +100,7 @@ binary-frontend: export NPM_CONFIG_LOGLEVEL = warn
 binary-frontend: export NG_CLI_ANALYTICS = false
 binary-frontend:
 	cd webapp/frontend
-	npm install -g @angular/cli@9.1.4
+	npm install -g @angular/cli@v13-lts
 	mkdir -p $(CURDIR)/dist
 	npm ci
 	npm run build:prod -- --output-path=$(CURDIR)/dist

README.md

@@ -26,7 +26,7 @@ If you run a server with more than a couple of hard drives, you're probably alre
 
 > smartd is a daemon that monitors the Self-Monitoring, Analysis and Reporting Technology (SMART) system built into many ATA, IDE and SCSI-3 hard drives. The purpose of SMART is to monitor the reliability of the hard drive and predict drive failures, and to carry out different types of drive self-tests.
 
-Theses S.M.A.R.T hard drive self-tests can help you detect and replace failing hard drives before they cause permanent data loss. However, there's a couple issues with `smartd`:
+These S.M.A.R.T hard drive self-tests can help you detect and replace failing hard drives before they cause permanent data loss. However, there's a couple issues with `smartd`:
 
 - There are more than a hundred S.M.A.R.T attributes, however `smartd` does not differentiate between critical and informational metrics
 - `smartd` does not record S.M.A.R.T attribute history, so it can be hard to determine if an attribute is degrading slowly over time.
@@ -46,7 +46,7 @@ Scrutiny is a simple but focused application, with a couple of core features:
 - Customized thresholds using real world failure rates
 - Temperature tracking
 - Provided as an all-in-one Docker image (but can be installed manually)
-- Future Configurable Alerting/Notifications via Webhooks
+- Configurable Alerting/Notifications via Webhooks
 - (Future) Hard Drive performance testing & tracking
 
 # Getting Started
@@ -69,7 +69,7 @@ See [docs/TROUBLESHOOTING_DEVICE_COLLECTOR.md](./docs/TROUBLESHOOTING_DEVICE_COL
 
 If you're using Docker, getting started is as simple as running the following command:
 
-> See [docker/example.omnibus.docker-compose.yml](./docker/example.omnibus.docker-compose.yml) for a docker-compose file. 
+> See [docker/example.omnibus.docker-compose.yml](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.omnibus.docker-compose.yml) for a docker-compose file.
 
 ```bash
 docker run -it --rm -p 8080:8080 -p 8086:8086 \
@@ -91,12 +91,16 @@ docker run -it --rm -p 8080:8080 -p 8086:8086 \
 
 ### Hub/Spoke Deployment
 
-In addition to the Omnibus image (available under the `latest` tag) there are 2 other Docker images available:
+In addition to the Omnibus image (available under the `latest` tag) you can deploy in Hub/Spoke mode, which requires 3
+other Docker images:
 
-- `ghcr.io/analogj/scrutiny:master-collector` - Contains the Scrutiny data collector, `smartctl` binary and cron-like scheduler. You can run one collector on each server.
-- `ghcr.io/analogj/scrutiny:master-web` - Contains the Web UI, API and Database. Only one container necessary
+- `ghcr.io/analogj/scrutiny:master-collector` - Contains the Scrutiny data collector, `smartctl` binary and cron-like
+  scheduler. You can run one collector on each server.
+- `ghcr.io/analogj/scrutiny:master-web` - Contains the Web UI and API. Only one container necessary
+- `influxdb:2.2` - InfluxDB image, used by the Web container to persist SMART data. Only one container necessary
+  See [docs/TROUBLESHOOTING_INFLUXDB.md](./docs/TROUBLESHOOTING_INFLUXDB.md)
 
-> See [docker/example.hubspoke.docker-compose.yml](./docker/example.hubspoke.docker-compose.yml) for a docker-compose file.
+> See [docker/example.hubspoke.docker-compose.yml](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.hubspoke.docker-compose.yml) for a docker-compose file.
 
 ```bash
 docker run --rm -p 8086:8086 \
@@ -153,7 +157,7 @@ Neither file is required, however if provided, it allows you to configure how Sc
 
 ## Cron Schedule
 Unfortunately the Cron schedule cannot be configured via the `collector.yaml` (as the collector binary needs to be trigged by a scheduler/cron).
-However, if you are using the official `ghcr.io/analogj/scrutiny:master-collector` or `ghcr.io/analogj/scrutiny:master-omnibus` docker images, 
+However, if you are using the official `ghcr.io/analogj/scrutiny:master-collector` or `ghcr.io/analogj/scrutiny:master-omnibus` docker images,
 you can use the `COLLECTOR_CRON_SCHEDULE` environmental variable to override the default cron schedule (daily @ midnight - `0 0 * * *`).
 
 `docker run -e COLLECTOR_CRON_SCHEDULE="0 0 * * *" ...`
@@ -170,6 +174,7 @@ Scrutiny supports sending SMART device failure notifications via the following s
 - IFTTT
 - Join
 - Mattermost
+- ntfy
 - Pushbullet
 - Pushover
 - Slack
@@ -239,9 +244,9 @@ scrutiny-collector-metrics run --debug --log-file /tmp/collector.log
 | linux-arm-6 | :white_check_mark: |  |
 | linux-arm-7 | :white_check_mark: | web/collector only. see [#236](https://github.com/AnalogJ/scrutiny/issues/236)  |
 | linux-arm64 | :white_check_mark: | :white_check_mark: |
-| freebsd-amd64 | collector only. see [#238](https://github.com/AnalogJ/scrutiny/issues/238) |  | 
-| macos-amd64 |  | :white_check_mark: |
-| macos-arm64 |  | :white_check_mark: |
+| freebsd-amd64 | :white_check_mark: |  |
+| macos-amd64 | :white_check_mark: | :white_check_mark: |
+| macos-arm64 | :white_check_mark: | :white_check_mark: |
 | windows-amd64 | :white_check_mark: | WIP, see [#15](https://github.com/AnalogJ/scrutiny/issues/15) |
 | windows-arm64 | :white_check_mark: |  |
 

collector/cmd/collector-metrics/collector-metrics.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/analogj/scrutiny/collector/pkg/collector"
 	"github.com/analogj/scrutiny/collector/pkg/config"
@@ -29,8 +30,14 @@ func main() {
 		os.Exit(1)
 	}
 
+	configFilePath := "/opt/scrutiny/config/collector.yaml"
+	configFilePathAlternative := "/opt/scrutiny/config/collector.yml"
+	if !utils.FileExists(configFilePath) && utils.FileExists(configFilePathAlternative) {
+		configFilePath = configFilePathAlternative
+	}
+
 	//we're going to load the config file manually, since we need to validate it.
-	err = config.ReadConfig("/opt/scrutiny/config/collector.yaml") // Find and read the config file
+	err = config.ReadConfig(configFilePath) // Find and read the config file
 	if _, ok := err.(errors.ConfigFileMissingError); ok {          // Handle errors reading the config file
 		//ignore "could not find config file"
 	} else if err != nil {
@@ -120,26 +127,16 @@ OPTIONS:
 						config.Set("api.endpoint", apiEndpoint)
 					}
 
-					collectorLogger := logrus.WithFields(logrus.Fields{
-						"type": "metrics",
-					})
-
-					if level, err := logrus.ParseLevel(config.GetString("log.level")); err == nil {
-						logrus.SetLevel(level)
-					} else {
-						logrus.SetLevel(logrus.InfoLevel)
-					}
-
-					if config.IsSet("log.file") && len(config.GetString("log.file")) > 0 {
-						logFile, err := os.OpenFile(config.GetString("log.file"), os.O_CREATE|os.O_WRONLY, 0644)
-						if err != nil {
-							logrus.Errorf("Failed to open log file %s for output: %s", config.GetString("log.file"), err)
-							return err
-						}
+					collectorLogger, logFile, err := CreateLogger(config)
+					if logFile != nil {
 						defer logFile.Close()
-						logrus.SetOutput(io.MultiWriter(os.Stderr, logFile))
+					}
+					if err != nil {
+						return err
 					}
 
+					settingsData, err := json.MarshalIndent(config.AllSettings(), "", "\t")
+					collectorLogger.Debug(string(settingsData), err)
 					metricCollector, err := collector.CreateMetricsCollector(
 						config,
 						collectorLogger,
@@ -192,5 +189,28 @@ OPTIONS:
 	if err != nil {
 		log.Fatal(color.HiRedString("ERROR: %v", err))
 	}
-
+}
+
+func CreateLogger(appConfig config.Interface) (*logrus.Entry, *os.File, error) {
+	logger := logrus.WithFields(logrus.Fields{
+		"type": "metrics",
+	})
+
+	if level, err := logrus.ParseLevel(appConfig.GetString("log.level")); err == nil {
+		logger.Logger.SetLevel(level)
+	} else {
+		logger.Logger.SetLevel(logrus.InfoLevel)
+	}
+
+	var logFile *os.File
+	var err error
+	if appConfig.IsSet("log.file") && len(appConfig.GetString("log.file")) > 0 {
+		logFile, err = os.OpenFile(appConfig.GetString("log.file"), os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			logger.Logger.Errorf("Failed to open log file %s for output: %s", appConfig.GetString("log.file"), err)
+			return nil, logFile, err
+		}
+		logger.Logger.SetOutput(io.MultiWriter(os.Stderr, logFile))
+	}
+	return logger, logFile, nil
 }

collector/pkg/collector/base.go

@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-var httpClient = &http.Client{Timeout: 10 * time.Second}
+var httpClient = &http.Client{Timeout: 60 * time.Second}
 
 type BaseCollector struct {
 	logger *logrus.Entry

collector/pkg/config/config_test.go

@@ -36,6 +36,25 @@ func TestConfiguration_GetScanOverrides_Simple(t *testing.T) {
 	require.Equal(t, []models.ScanOverride{{Device: "/dev/sda", DeviceType: []string{"sat"}, Ignore: false}}, scanOverrides)
 }
 
+// fixes #418
+func TestConfiguration_GetScanOverrides_DeviceTypeComma(t *testing.T) {
+	t.Parallel()
+
+	//setup
+	testConfig, _ := config.Create()
+
+	//test
+	err := testConfig.ReadConfig(path.Join("testdata", "device_type_comma.yaml"))
+	require.NoError(t, err, "should correctly load simple device config")
+	scanOverrides := testConfig.GetDeviceOverrides()
+
+	//assert
+	require.Equal(t, []models.ScanOverride{
+		{Device: "/dev/sda", DeviceType: []string{"sat", "auto"}, Ignore: false},
+		{Device: "/dev/sdb", DeviceType: []string{"sat,auto"}, Ignore: false},
+	}, scanOverrides)
+}
+
 func TestConfiguration_GetScanOverrides_Ignore(t *testing.T) {
 	t.Parallel()
 

collector/pkg/config/testdata/device_type_comma.yaml

@@ -0,0 +1,9 @@
+version: 1
+devices:
+  # the scrutiny config parser will detect `sat,auto` as two separate items in a list. If you want to use `-d sat,auto` you must
+  # set 'sat,auto' in a list (see eg. /dev/sbd)
+  - device: /dev/sda
+    type: 'sat,auto'
+  - device: /dev/sdb
+    type:
+      - sat,auto

collector/pkg/detect/detect.go

@@ -3,13 +3,14 @@ package detect
 import (
 	"encoding/json"
 	"fmt"
+	"os"
+	"strings"
+
 	"github.com/analogj/scrutiny/collector/pkg/common/shell"
 	"github.com/analogj/scrutiny/collector/pkg/config"
 	"github.com/analogj/scrutiny/collector/pkg/models"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
 	"github.com/sirupsen/logrus"
-	"os"
-	"strings"
 )
 
 type Detect struct {
@@ -47,7 +48,7 @@ func (d *Detect) SmartctlScan() ([]models.Device, error) {
 	return detectedDevices, nil
 }
 
-//updates a device model with information from smartctl --scan
+// updates a device model with information from smartctl --scan
 // It has a couple of issues however:
 // - WWN is provided as component data, rather than a "string". We'll have to generate the WWN value ourselves
 // - WWN from smartctl only provided for ATA protocol drives, NVMe and SCSI drives do not include WWN.
@@ -81,8 +82,9 @@ func (d *Detect) SmartCtlInfo(device *models.Device) error {
 	device.SerialNumber = availableDeviceInfo.SerialNumber
 	device.Firmware = availableDeviceInfo.FirmwareVersion
 	device.RotationSpeed = availableDeviceInfo.RotationRate
-	device.Capacity = availableDeviceInfo.UserCapacity.Bytes
+	device.Capacity = availableDeviceInfo.Capacity()
 	device.FormFactor = availableDeviceInfo.FormFactor.Name
+	device.DeviceType = availableDeviceInfo.Device.Type
 	device.DeviceProtocol = availableDeviceInfo.Device.Protocol
 	if len(availableDeviceInfo.Vendor) > 0 {
 		device.Manufacturer = availableDeviceInfo.Vendor

collector/pkg/detect/detect_test.go

@@ -1,19 +1,22 @@
 package detect_test
 
 import (
+	"os"
+	"strings"
+	"testing"
+
 	mock_shell "github.com/analogj/scrutiny/collector/pkg/common/shell/mock"
 	mock_config "github.com/analogj/scrutiny/collector/pkg/config/mock"
 	"github.com/analogj/scrutiny/collector/pkg/detect"
 	"github.com/analogj/scrutiny/collector/pkg/models"
 	"github.com/golang/mock/gomock"
 	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"io/ioutil"
-	"testing"
 )
 
 func TestDetect_SmartctlScan(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -23,7 +26,7 @@ func TestDetect_SmartctlScan(t *testing.T) {
 	fakeConfig.EXPECT().GetString("commands.metrics_scan_args").AnyTimes().Return("--scan --json")
 
 	fakeShell := mock_shell.NewMockInterface(mockCtrl)
-	testScanResults, err := ioutil.ReadFile("testdata/smartctl_scan_simple.json")
+	testScanResults, err := os.ReadFile("testdata/smartctl_scan_simple.json")
 	fakeShell.EXPECT().Command(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(string(testScanResults), err)
 
 	d := detect.Detect{
@@ -32,17 +35,17 @@ func TestDetect_SmartctlScan(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	scannedDevices, err := d.SmartctlScan()
 
-	//assert
+	// assert
 	require.NoError(t, err)
 	require.Equal(t, 7, len(scannedDevices))
 	require.Equal(t, "scsi", scannedDevices[0].DeviceType)
 }
 
 func TestDetect_SmartctlScan_Megaraid(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -52,7 +55,7 @@ func TestDetect_SmartctlScan_Megaraid(t *testing.T) {
 	fakeConfig.EXPECT().GetString("commands.metrics_scan_args").AnyTimes().Return("--scan --json")
 
 	fakeShell := mock_shell.NewMockInterface(mockCtrl)
-	testScanResults, err := ioutil.ReadFile("testdata/smartctl_scan_megaraid.json")
+	testScanResults, err := os.ReadFile("testdata/smartctl_scan_megaraid.json")
 	fakeShell.EXPECT().Command(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(string(testScanResults), err)
 
 	d := detect.Detect{
@@ -61,20 +64,20 @@ func TestDetect_SmartctlScan_Megaraid(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	scannedDevices, err := d.SmartctlScan()
 
-	//assert
+	// assert
 	require.NoError(t, err)
 	require.Equal(t, 2, len(scannedDevices))
 	require.Equal(t, []models.Device{
-		models.Device{DeviceName: "bus/0", DeviceType: "megaraid,0"},
-		models.Device{DeviceName: "bus/0", DeviceType: "megaraid,1"},
+		{DeviceName: "bus/0", DeviceType: "megaraid,0"},
+		{DeviceName: "bus/0", DeviceType: "megaraid,1"},
 	}, scannedDevices)
 }
 
 func TestDetect_SmartctlScan_Nvme(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -84,7 +87,7 @@ func TestDetect_SmartctlScan_Nvme(t *testing.T) {
 	fakeConfig.EXPECT().GetString("commands.metrics_scan_args").AnyTimes().Return("--scan --json")
 
 	fakeShell := mock_shell.NewMockInterface(mockCtrl)
-	testScanResults, err := ioutil.ReadFile("testdata/smartctl_scan_nvme.json")
+	testScanResults, err := os.ReadFile("testdata/smartctl_scan_nvme.json")
 	fakeShell.EXPECT().Command(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes().Return(string(testScanResults), err)
 
 	d := detect.Detect{
@@ -93,19 +96,19 @@ func TestDetect_SmartctlScan_Nvme(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	scannedDevices, err := d.SmartctlScan()
 
-	//assert
+	// assert
 	require.NoError(t, err)
 	require.Equal(t, 1, len(scannedDevices))
 	require.Equal(t, []models.Device{
-		models.Device{DeviceName: "nvme0", DeviceType: "nvme"},
+		{DeviceName: "nvme0", DeviceType: "nvme"},
 	}, scannedDevices)
 }
 
 func TestDetect_TransformDetectedDevices_Empty(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -129,16 +132,16 @@ func TestDetect_TransformDetectedDevices_Empty(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	transformedDevices := d.TransformDetectedDevices(detectedDevices)
 
-	//assert
+	// assert
 	require.Equal(t, "sda", transformedDevices[0].DeviceName)
 	require.Equal(t, "scsi", transformedDevices[0].DeviceType)
 }
 
 func TestDetect_TransformDetectedDevices_Ignore(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -162,15 +165,15 @@ func TestDetect_TransformDetectedDevices_Ignore(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	transformedDevices := d.TransformDetectedDevices(detectedDevices)
 
-	//assert
+	// assert
 	require.Equal(t, []models.Device{}, transformedDevices)
 }
 
 func TestDetect_TransformDetectedDevices_Raid(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -187,7 +190,8 @@ func TestDetect_TransformDetectedDevices_Raid(t *testing.T) {
 			Device:     "/dev/twa0",
 			DeviceType: []string{"3ware,0", "3ware,1", "3ware,2", "3ware,3", "3ware,4", "3ware,5"},
 			Ignore:     false,
-		}})
+		},
+	})
 	detectedDevices := models.Scan{
 		Devices: []models.ScanDevice{
 			{
@@ -203,15 +207,15 @@ func TestDetect_TransformDetectedDevices_Raid(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	transformedDevices := d.TransformDetectedDevices(detectedDevices)
 
-	//assert
+	// assert
 	require.Equal(t, 12, len(transformedDevices))
 }
 
 func TestDetect_TransformDetectedDevices_Simple(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -234,17 +238,17 @@ func TestDetect_TransformDetectedDevices_Simple(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	transformedDevices := d.TransformDetectedDevices(detectedDevices)
 
-	//assert
+	// assert
 	require.Equal(t, 1, len(transformedDevices))
 	require.Equal(t, "sat+megaraid", transformedDevices[0].DeviceType)
 }
 
 // test https://github.com/AnalogJ/scrutiny/issues/255#issuecomment-1164024126
 func TestDetect_TransformDetectedDevices_WithoutDeviceTypeOverride(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -267,16 +271,16 @@ func TestDetect_TransformDetectedDevices_WithoutDeviceTypeOverride(t *testing.T)
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	transformedDevices := d.TransformDetectedDevices(detectedDevices)
 
-	//assert
+	// assert
 	require.Equal(t, 1, len(transformedDevices))
 	require.Equal(t, "scsi", transformedDevices[0].DeviceType)
 }
 
 func TestDetect_TransformDetectedDevices_WhenDeviceNotDetected(t *testing.T) {
-	//setup
+	// setup
 	mockCtrl := gomock.NewController(t)
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
@@ -290,10 +294,69 @@ func TestDetect_TransformDetectedDevices_WhenDeviceNotDetected(t *testing.T) {
 		Config: fakeConfig,
 	}
 
-	//test
+	// test
 	transformedDevices := d.TransformDetectedDevices(detectedDevices)
 
-	//assert
+	// assert
 	require.Equal(t, 1, len(transformedDevices))
 	require.Equal(t, "ata", transformedDevices[0].DeviceType)
 }
+
+func TestDetect_SmartCtlInfo(t *testing.T) {
+	t.Run("should report nvme info", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		const (
+			someArgs = "--info --json"
+
+			// device info
+			someDeviceName           = "some-device-name"
+			someModelName            = "KCD61LUL3T84"
+			someSerialNumber         = "61Q0A05UT7B8"
+			someFirmware             = "8002"
+			someDeviceProtocol       = "NVMe"
+			someDeviceType           = "nvme"
+			someCapacity       int64 = 3840755982336
+		)
+
+		fakeConfig := mock_config.NewMockInterface(ctrl)
+		fakeConfig.EXPECT().
+			GetCommandMetricsInfoArgs("/dev/" + someDeviceName).
+			Return(someArgs)
+		fakeConfig.EXPECT().
+			GetString("commands.metrics_smartctl_bin").
+			Return("smartctl")
+
+		someLogger := logrus.WithFields(logrus.Fields{})
+
+		smartctlInfoResults, err := os.ReadFile("testdata/smartctl_info_nvme.json")
+		require.NoError(t, err)
+
+		fakeShell := mock_shell.NewMockInterface(ctrl)
+		fakeShell.EXPECT().
+			Command(someLogger, "smartctl", append(strings.Split(someArgs, " "), "/dev/"+someDeviceName), "", gomock.Any()).
+			Return(string(smartctlInfoResults), err)
+
+		d := detect.Detect{
+			Logger: someLogger,
+			Shell:  fakeShell,
+			Config: fakeConfig,
+		}
+
+		someDevice := &models.Device{
+			WWN:        "some wwn",
+			DeviceName: someDeviceName,
+		}
+
+		require.NoError(t, d.SmartCtlInfo(someDevice))
+
+		assert.Equal(t, someDeviceName, someDevice.DeviceName)
+		assert.Equal(t, someModelName, someDevice.ModelName)
+		assert.Equal(t, someSerialNumber, someDevice.SerialNumber)
+		assert.Equal(t, someFirmware, someDevice.Firmware)
+		assert.Equal(t, someDeviceProtocol, someDevice.DeviceProtocol)
+		assert.Equal(t, someDeviceType, someDevice.DeviceType)
+		assert.Equal(t, someCapacity, someDevice.Capacity)
+	})
+}

collector/pkg/detect/testdata/smartctl_info_nvme.json

@@ -0,0 +1,48 @@
+{
+  "json_format_version": [
+    1,
+    0
+  ],
+  "smartctl": {
+    "version": [
+      7,
+      2
+    ],
+    "svn_revision": "5155",
+    "platform_info": "x86_64-linux-6.1.69-talos",
+    "build_info": "(local build)",
+    "argv": [
+      "smartctl",
+      "--info",
+      "--json",
+      "/dev/nvme4"
+    ],
+    "exit_status": 0
+  },
+  "device": {
+    "name": "/dev/nvme4",
+    "info_name": "/dev/nvme4",
+    "type": "nvme",
+    "protocol": "NVMe"
+  },
+  "model_name": "KCD61LUL3T84",
+  "serial_number": "61Q0A05UT7B8",
+  "firmware_version": "8002",
+  "nvme_pci_vendor": {
+    "id": 7695,
+    "subsystem_id": 7695
+  },
+  "nvme_ieee_oui_identifier": 9233294,
+  "nvme_total_capacity": 3840755982336,
+  "nvme_unallocated_capacity": 0,
+  "nvme_controller_id": 1,
+  "nvme_version": {
+    "string": "1.4",
+    "value": 66560
+  },
+  "nvme_number_of_namespaces": 16,
+  "local_time": {
+    "time_t": 1706045146,
+    "asctime": "Tue Jan 23 21:25:46 2024 UTC"
+  }
+}

docker/Dockerfile

@@ -1,50 +1,62 @@
+# syntax=docker/dockerfile:1.4
 ########################################################################################################################
 # Omnibus Image
-# NOTE: this image requires the `make binary-frontend` target to have been run before `docker build` The `dist` directory must exist.
 ########################################################################################################################
 
+######## Build the frontend
+FROM --platform=${BUILDPLATFORM} node AS frontendbuild
+WORKDIR /go/src/github.com/analogj/scrutiny
+COPY --link . /go/src/github.com/analogj/scrutiny
 
-########
-FROM golang:1.18-bullseye as backendbuild
+RUN make binary-frontend
+
+
+######## Build the backend
+FROM golang:1.20-bullseye as backendbuild
 
 WORKDIR /go/src/github.com/analogj/scrutiny
-COPY . /go/src/github.com/analogj/scrutiny
+COPY --link . /go/src/github.com/analogj/scrutiny
 RUN make binary-clean binary-all WEB_BINARY_NAME=scrutiny
 
 
-########
+######## Combine build artifacts in runtime image
 FROM debian:bullseye-slim as runtime
 ARG TARGETARCH
 EXPOSE 8080
 WORKDIR /opt/scrutiny
 ENV PATH="/opt/scrutiny/bin:${PATH}"
 ENV INFLUXD_CONFIG_PATH=/opt/scrutiny/influxdb
+ENV S6VER="1.21.8.0"
+ENV INFLUXVER="2.2.0"
 
-RUN apt-get update && apt-get install -y cron smartmontools ca-certificates curl tzdata \
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive \
+    apt-get install -y --no-install-recommends \
+    ca-certificates \
+    cron \
+    curl \
+    smartmontools \
+    tzdata \
     && update-ca-certificates \
     &&  case ${TARGETARCH} in \
             "amd64")  S6_ARCH=amd64  ;; \
             "arm64")  S6_ARCH=aarch64  ;; \
         esac \
-    && curl https://github.com/just-containers/s6-overlay/releases/download/v1.21.8.0/s6-overlay-${S6_ARCH}.tar.gz -L -s --output /tmp/s6-overlay-${S6_ARCH}.tar.gz \
+    && curl https://github.com/just-containers/s6-overlay/releases/download/v${S6VER}/s6-overlay-${S6_ARCH}.tar.gz -L -s --output /tmp/s6-overlay-${S6_ARCH}.tar.gz \
     && tar xzf /tmp/s6-overlay-${S6_ARCH}.tar.gz -C / \
     && rm -rf /tmp/s6-overlay-${S6_ARCH}.tar.gz \
-    && curl -L https://dl.influxdata.com/influxdb/releases/influxdb2-2.2.0-${TARGETARCH}.deb --output /tmp/influxdb2-2.2.0-${TARGETARCH}.deb \
-    && dpkg -i --force-all /tmp/influxdb2-2.2.0-${TARGETARCH}.deb
+    && curl -L https://dl.influxdata.com/influxdb/releases/influxdb2-${INFLUXVER}-${TARGETARCH}.deb --output /tmp/influxdb2-${INFLUXVER}-${TARGETARCH}.deb \
+    && dpkg -i --force-all /tmp/influxdb2-${INFLUXVER}-${TARGETARCH}.deb \
+    && rm -rf /tmp/influxdb2-2.2.0-${TARGETARCH}.deb
 
 COPY /rootfs /
 
-COPY /rootfs/etc/cron.d/scrutiny /etc/cron.d/scrutiny
-COPY --from=backendbuild /go/src/github.com/analogj/scrutiny/scrutiny /opt/scrutiny/bin/
-COPY --from=backendbuild /go/src/github.com/analogj/scrutiny/scrutiny-collector-metrics /opt/scrutiny/bin/
-COPY dist /opt/scrutiny/web
-RUN chmod +x /opt/scrutiny/bin/scrutiny && \
-    chmod +x /opt/scrutiny/bin/scrutiny-collector-metrics && \
-    chmod 0644 /etc/cron.d/scrutiny && \
+COPY --link --from=backendbuild --chmod=755 /go/src/github.com/analogj/scrutiny/scrutiny /opt/scrutiny/bin/
+COPY --link --from=backendbuild --chmod=755 /go/src/github.com/analogj/scrutiny/scrutiny-collector-metrics /opt/scrutiny/bin/
+COPY --link --from=frontendbuild --chmod=644 /go/src/github.com/analogj/scrutiny/dist /opt/scrutiny/web
+RUN chmod 0644 /etc/cron.d/scrutiny && \
     rm -f /etc/cron.daily/* && \
     mkdir -p /opt/scrutiny/web && \
     mkdir -p /opt/scrutiny/config && \
     chmod -R ugo+rwx /opt/scrutiny/config
 
-
 CMD ["/init"]

docker/Dockerfile.collector

@@ -4,7 +4,7 @@
 
 
 ########
-FROM golang:1.18-bullseye as backendbuild
+FROM golang:1.20-bullseye as backendbuild
 
 WORKDIR /go/src/github.com/analogj/scrutiny
 
@@ -14,7 +14,7 @@ RUN make binary-clean binary-collector
 
 ########
 FROM debian:bullseye-slim as runtime
-WORKDIR /scrutiny
+WORKDIR /opt/scrutiny
 ENV PATH="/opt/scrutiny/bin:${PATH}"
 
 RUN apt-get update && apt-get install -y cron smartmontools ca-certificates tzdata && update-ca-certificates

docker/Dockerfile.web

@@ -1,20 +1,25 @@
+# syntax=docker/dockerfile:1.4
 ########################################################################################################################
 # Web Image
-# NOTE: this image requires the `make binary-frontend` target to have been run before `docker build` The `dist` directory must exist.
 ########################################################################################################################
 
+######## Build the frontend
+FROM --platform=${BUILDPLATFORM} node AS frontendbuild
+WORKDIR /go/src/github.com/analogj/scrutiny
+COPY --link . /go/src/github.com/analogj/scrutiny
 
-########
-FROM golang:1.18-bullseye as backendbuild
+RUN make binary-frontend
+
+######## Build the backend
+FROM golang:1.20-bullseye as backendbuild
 
 WORKDIR /go/src/github.com/analogj/scrutiny
-
-COPY . /go/src/github.com/analogj/scrutiny
+COPY --link . /go/src/github.com/analogj/scrutiny
 
 RUN make binary-clean binary-all WEB_BINARY_NAME=scrutiny
 
 
-########
+######## Combine build artifacts in runtime image
 FROM debian:bullseye-slim as runtime
 EXPOSE 8080
 WORKDIR /opt/scrutiny
@@ -22,10 +27,10 @@ ENV PATH="/opt/scrutiny/bin:${PATH}"
 
 RUN apt-get update && apt-get install -y ca-certificates curl tzdata && update-ca-certificates
 
-COPY --from=backendbuild /go/src/github.com/analogj/scrutiny/scrutiny /opt/scrutiny/bin/
-COPY dist /opt/scrutiny/web
-RUN chmod +x /opt/scrutiny/bin/scrutiny && \
-    mkdir -p /opt/scrutiny/web && \
+COPY --link --from=backendbuild --chmod=755 /go/src/github.com/analogj/scrutiny/scrutiny /opt/scrutiny/bin/
+COPY --link --from=frontendbuild --chmod=644 /go/src/github.com/analogj/scrutiny/dist /opt/scrutiny/web
+RUN mkdir -p /opt/scrutiny/web && \
     mkdir -p /opt/scrutiny/config && \
-    chmod -R ugo+rwx /opt/scrutiny/config
+    chmod -R a+rX /opt/scrutiny && \
+    chmod -R a+w /opt/scrutiny/config
 CMD ["/opt/scrutiny/bin/scrutiny", "start"]

docker/entrypoint-collector.sh

@@ -7,6 +7,8 @@
 
 # adding ability to customize the cron schedule.
 COLLECTOR_CRON_SCHEDULE=${COLLECTOR_CRON_SCHEDULE:-"0 0 * * *"}
+COLLECTOR_RUN_STARTUP=${COLLECTOR_RUN_STARTUP:-"false"}
+COLLECTOR_RUN_STARTUP_SLEEP=${COLLECTOR_RUN_STARTUP_SLEEP:-"1"}
 
 # if the cron schedule has been overridden via env variable (eg docker-compose) we should make sure to strip quotes
 [[ "${COLLECTOR_CRON_SCHEDULE}" == \"*\" || "${COLLECTOR_CRON_SCHEDULE}" == \'*\' ]] && COLLECTOR_CRON_SCHEDULE="${COLLECTOR_CRON_SCHEDULE:1:-1}"
@@ -14,6 +16,13 @@ COLLECTOR_CRON_SCHEDULE=${COLLECTOR_CRON_SCHEDULE:-"0 0 * * *"}
 # replace placeholder with correct value
 sed -i 's|{COLLECTOR_CRON_SCHEDULE}|'"${COLLECTOR_CRON_SCHEDULE}"'|g' /etc/cron.d/scrutiny
 
+if [[ "${COLLECTOR_RUN_STARTUP}" == "true" ]]; then
+    sleep ${COLLECTOR_RUN_STARTUP_SLEEP}
+    echo "starting scrutiny collector (run-once mode. subsequent calls will be triggered via cron service)"
+    /opt/scrutiny/bin/scrutiny-collector-metrics run
+fi
+
+
 # now that we have the env start cron in the foreground
 echo "starting cron"
 su -c "cron -f -L 15" root

docker/example.hubspoke.docker-compose.yml

@@ -40,9 +40,10 @@ services:
       - '/run/udev:/run/udev:ro'
     environment:
       COLLECTOR_API_ENDPOINT: 'http://web:8080'
+      COLLECTOR_HOST_ID: 'scrutiny-collector-hostname'
     depends_on:
       web:
         condition: service_healthy
     devices:
       - "/dev/sda"
-      - "/dev/sdb"
+      - "/dev/sdb"

docs/INSTALL_HUB_SPOKE.md

@@ -1 +1,181 @@
-> See [docker/example.hubspoke.docker-compose.yml](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.hubspoke.docker-compose.yml) for a docker-compose file.
+>
+See [docker/example.hubspoke.docker-compose.yml](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.hubspoke.docker-compose.yml)
+for a docker-compose file.
+
+> The following guide was contributed by @TinJoy59 in #417
+> It describes how to deploy the Scrutiny in Hub/Spoke mode, where the Hub is running in Docker, and the Spokes (
+> collectors) are running as binaries.
+> He's using Proxmox & Synology in his guide, however this should be applicable for almost anyone
+
+# S.M.A.R.T. Monitoring with Scrutiny across machines
+
+![drawing-3-1671744407](https://user-images.githubusercontent.com/86809766/209230023-bf1ef9f8-65c4-454e-9e1a-be1293cd737e.png)
+
+### 🤔 The problem:
+
+Scrutiny offers a nice Docker package called "Omnibus" that can monitor HDDs attached to a Docker host with relative
+ease. Scrutiny can also be installed in a Hub-Spoke layout where Web interface, Database and Collector come in 3
+separate packages. The official documentation assumes that the spokes in the "Hub-Spokes layout" run Docker, which is
+not always the case. The third approach is to install Scrutiny manually, entirely outside of Docker.
+
+### 💡 The solution:
+
+This tutorial provides a hybrid configuration where the Hub lives in a Docker instance while the spokes have only
+Scrutiny Collector installed manually. The Collector periodically send data to the Hub. It's not mind-boggling hard to
+understand but someone might struggle with the setup. This is for them.
+
+### 🖥️ My setup:
+
+I have a Proxmox cluster where one VM runs Docker and all monitoring services - Grafana, Prometheus, various exporters,
+InfluxDB and so forth. Another VM runs the NAS - OpenMediaVault v6, where all hard drives reside. The Scrutiny Collector
+is triggered every 30min to collect data on the drives. The data is sent to the Docker VM, running InfluxDB.
+
+## Setting up the Hub
+
+![drawing-3-1671744714](https://user-images.githubusercontent.com/86809766/209230113-c954d834-521b-4555-bcd2-eb6b80f343be.png)
+
+The Hub consists of Scrutiny Web - a web interface for viewing the SMART data. And InfluxDB, where the smartmon data is
+stored.
+
+[🔗This is the official Hub-Spoke layout in docker-compose.](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.hubspoke.docker-compose.yml)
+We are going to reuse parts of it. The ENV variables provide the necessary configuration for the initial setup, both for
+InfluxDB and Scrutiny.
+
+If you are working with and existing InfluxDB instance, you can forgo all the `INIT` variables as they already exist.
+
+The official Scrutiny documentation has a
+sample [scrutiny.yaml ](https://github.com/AnalogJ/scrutiny/blob/master/example.scrutiny.yaml)file that normally
+contains the connection and notification details but I always find it easier to configure as much as possible in the
+docker-compose.
+
+```yaml
+version: "3.4"
+
+networks:
+  monitoring: # A common network for all monitoring services to communicate into
+    external: true
+  notifications: # To Gotify or another Notification service
+    external: true
+
+services:
+  influxdb:
+    container_name: influxdb
+    image: influxdb:2.1-alpine
+    ports:
+      - 8086:8086
+    volumes:
+      - ${DIR_CONFIG}/influxdb2/db:/var/lib/influxdb2
+      - ${DIR_CONFIG}/influxdb2/config:/etc/influxdb2
+    environment:
+      - DOCKER_INFLUXDB_INIT_MODE=setup
+      - DOCKER_INFLUXDB_INIT_USERNAME=Admin
+      - DOCKER_INFLUXDB_INIT_PASSWORD=${PASSWORD}
+      - DOCKER_INFLUXDB_INIT_ORG=homelab
+      - DOCKER_INFLUXDB_INIT_BUCKET=scrutiny
+      - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=your-very-secret-token
+    restart: unless-stopped
+    networks:
+      - monitoring
+
+  scrutiny:
+    container_name: scrutiny
+    image: ghcr.io/analogj/scrutiny:master-web
+    ports:
+      - 8080:8080
+    volumes:
+      - ${DIR_CONFIG}/scrutiny/config:/opt/scrutiny/config
+    environment:
+      - SCRUTINY_WEB_INFLUXDB_HOST=influxdb
+      - SCRUTINY_WEB_INFLUXDB_PORT=8086
+      - SCRUTINY_WEB_INFLUXDB_TOKEN=your-very-secret-token
+      - SCRUTINY_WEB_INFLUXDB_ORG=homelab
+      - SCRUTINY_WEB_INFLUXDB_BUCKET=scrutiny
+      # Optional but highly recommended to notify you in case of a problem
+      - SCRUTINY_NOTIFY_URLS=["http://gotify:80/message?token=a-gotify-token"]
+    depends_on:
+      - influxdb
+    restart: unless-stopped
+    networks:
+      - notifications
+      - monitoring
+```
+
+A freshly initialized Scrutiny instance can be accessed on port 8080, eg. `192.168.0.100:8080`. The interface will be
+empty because no metrics have been collected yet.
+
+## Setting up a Spoke ***without*** Docker
+
+![drawing-3-1671744208](https://user-images.githubusercontent.com/86809766/209230155-386a8644-b506-497f-8245-0d24e15c9063.png)
+
+A spoke consists of the Scrutiny Collector binary that is run on a set interval via crontab and sends the data to the
+Hub. The official
+documentation [describes the manual setup of the Collector](https://github.com/AnalogJ/scrutiny/blob/master/docs/INSTALL_MANUAL.md#collector)
+- dependencies and step by step commands. I have a shortened version that does the same thing but in one line of code.
+
+```bash
+# Installing dependencies
+apt install smartmontools -y 
+
+# 1. Create directory for the binary
+# 2. Download the binary into that directory
+# 3. Make it exacutable
+# 4. List the contents of the library for confirmation
+mkdir -p /opt/scrutiny/bin && \
+curl -L https://github.com/AnalogJ/scrutiny/releases/download/v0.5.0/scrutiny-collector-metrics-linux-amd64 > /opt/scrutiny/bin/scrutiny-collector-metrics-linux-amd64 && \
+chmod +x /opt/scrutiny/bin/scrutiny-collector-metrics-linux-amd64 && \
+ls -lha /opt/scrutiny/bin
+```
+
+<p class="callout warning">When downloading Github Release Assests, make sure that you have the correct version. The provided example is with Release v0.5.0. [The release list can be found here.](https://github.com/analogj/scrutiny/releases) </p>
+
+Once the Collector is installed, you can run it with the following command. Make sure to add the correct address and
+port of your Hub as `--api-endpoint`.
+
+```bash
+/opt/scrutiny/bin/scrutiny-collector-metrics-linux-amd64 run --api-endpoint "http://192.168.0.100:8080"
+```
+
+This will run the Collector once and populate the Web interface of your Scrutiny instance. In order to collect metrics
+for a time series, you need to run the command repeatedly. Here is an example for crontab, running the Collector every
+15min.
+
+```bash
+# open crontab
+crontab -e
+
+# add a line for Scrutiny
+*/15 * * * * /opt/scrutiny/bin/scrutiny-collector-metrics-linux-amd64 run --api-endpoint "http://192.168.0.100:8080"
+```
+
+The Collector has its own independent config file that lives in `/opt/scrutiny/config/collector.yaml` but I did not find
+a need to modify
+it. [A default collector.yaml can be found in the official documentation.](https://github.com/AnalogJ/scrutiny/blob/master/example.collector.yaml)
+
+## Setting up a Spoke ***with*** Docker
+
+![drawing-3-1671744277](https://user-images.githubusercontent.com/86809766/209230176-87c9e55a-4e3e-4f5f-9609-335d41529f3d.png)
+
+Setting up a remote Spoke in Docker requires you to split
+the [official Hub-Spoke layout docker-compose.yml](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.hubspoke.docker-compose.yml)
+. In the following docker-compose you need to provide the `${API_ENDPOINT}`, in my case `http://192.168.0.100:8080`.
+Also all drives that you wish to monitor need to be presented to the container under `devices`.
+
+The image handles the periodic scanning of the drives.
+
+```yaml
+version: "3.4"
+
+services:
+
+  collector:
+    image: 'ghcr.io/analogj/scrutiny:master-collector'
+    cap_add:
+      - SYS_RAWIO
+    volumes:
+      - '/run/udev:/run/udev:ro'
+    environment:
+      COLLECTOR_API_ENDPOINT: ${API_ENDPOINT}
+    devices:
+      - "/dev/sda"
+      - "/dev/sdb"
+```

docs/INSTALL_MANUAL_WINDOWS.md

@@ -0,0 +1,59 @@
+# Manual Windows Install
+
+This guide is specifically for people who are on a Windows machine using [WSL](https://learn.microsoft.com/en-us/windows/wsl/about) with Docker.
+
+Scrutiny is made up of three components: an influxdb Database, a collector and a webapp/api. Docker will be used for
+the influxdb and webapp/API, the collector component will be facilitated by [Windows Task Scheduler](https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page).
+
+> **NOTE:** If you are **NOT** using WSL with docker, then the easiest way to get started with [Scrutiny is the omnibus Docker image](https://github.com/AnalogJ/scrutiny#docker).
+
+## InfluxDB and Webapp/API (Docker)
+
+1. Copy the [example.hubspoke.docker-compose.yml](https://github.com/AnalogJ/scrutiny/blob/master/docker/example.hubspoke.docker-compose.yml) 
+file and delete the collector section near the bottom of the file.
+2. Run `docker-compose up -d` to verify that the DB and webapp are working correctly and once its completed, your webapp
+should be up and running but the dashboard will be empty (default location is `localhost:8080`)
+
+## Collector (Windows Task Scheduler)
+
+1. Download the latest `scrutiny-collector-metrics-windows-amd64.exe` from the [releases page](https://github.com/AnalogJ/scrutiny/releases) (under assets)
+2. On your windows host, open [Windows Task Scheduler](https://www.wikihow.com/Open-Task-Scheduler-in-Windows-10) as **Administrator**
+   1. In the **Start Menu** (Windows key), type `Task Scheduler` and then right click `Run as Administrator` to open
+3. On the status bar (under the `action` tab), click `Create Task...`
+4. A new window should open with the `General` Tab open, enter relevant information into the `Name` and `Description` fields
+   1. Under **Security Options** check:
+      1. **Run whether user is logged on or not**
+      2. **Run with highest privileges**
+5. Next, click the `Triggers` tab and then click `New...` (bottom left-hand side of the window)
+6. Here you can set how often you want this task to run, example settings are the following:
+   1. **Settings:**
+      1. `Daily`, start at `TODAYS_DATE` `12:00:00 AM`, Recur every `1` days,
+   2. **Advanced Settings:**
+      1. Repeat Task every: `1 hour` for a duration of `Indefinitely`
+      2. Stop task if it runs longer than: `30 minutes`
+   3. Click Ok when satisfied with your schedule
+   > **NOTE:** The above settings will trigger the task **every day at midnight** and then **run every hour after that** (modify as needed)
+7. Next, click the `Actions` tab and then click `New...` (bottom left-hand side of the window)
+   1. **Action Settings:**
+      1. In the **Program/Script** field, put: `scrutiny-collector-metrics-windows-amd64.exe`
+      2. In the **Add arguments (optional)** field, put: `run --api-endpoint "http://localhost:8080" --config collector.yaml`
+         > **NOTE:** 
+         > * Make sure that you put the correct port number (as specified in the docker-compose file) for the webapp (default is `8080`)
+         > * The `--config` param is optional and is not needed if you just want to use the default collector config, see 
+      [example.collector.yaml](https://github.com/AnalogJ/scrutiny/blob/master/example.collector.yaml) for more info on the collector config.
+      3. In the **Start in (optional)** field, put: FOLDER_PATH_TO_YOUR `scrutiny-collector-metrics-windows-amd64.exe` file
+          > **NOTE:** Must be exact and do not include `scrutiny-collector-metrics-windows-amd64.exe` in the path
+      4. Click Ok when finished
+8. Next, click the `Conditions` tab and make sure that everything is unchecked (unless you want to specify otherwise)
+9. Next, click the `Settings` tab and check everything except for the last checkbox
+   1. **Examples for the following settings:**
+      1. If the task fails, restart every: `5 minutes`
+      2. Attempt restart up to: `3` times
+      3. Stop the task if it runs longer than `1 hour`
+10. Next, once satisfied with everything, click Ok
+11. Then, find your newly created task (by its name) in the scheduler task list and then manually run it (right click it and then click `Run`)
+12. Finally, refresh your dashboard after a minute or two and your drive information should have populated the webapp dashboard.
+
+
+
+

docs/INSTALL_SYNOLOGY_COLLECTOR.md

@@ -91,9 +91,13 @@ wget https://raw.githubusercontent.com/smartmontools/smartmontools/master/smartm
 ```
 #!/bin/bash
 
-/volume1/\@Entware/scrutiny/bin/scrutiny-collector-metrics-linux-arm64 run --config /volume1/\@Entware/scrutiny/config/collector.yaml
+/volume1/\@Entware/scrutiny/bin/scrutiny-collector-metrics-linux-arm64 run --config /volume1/\@Entware/scrutiny/conf/collector.yaml
 ```
 
+**Make `run_collect.sh` executable**
+
+`chmod +x /volume1/\@Entware/scrutiny/bin/run_collect.sh`
+
 ## Set up Synology to run a scheduled task. 
 
 Log in to DSM and do the following:
@@ -131,4 +135,4 @@ Frequency: <Your desired frequency>
 
 ## Troubleshooting
 
-If you have any issues with your devices being detected, or incorrect data, please take a look at [TROUBLESHOOTING_DEVICE_COLLECTOR.md](./TROUBLESHOOTING_DEVICE_COLLECTOR.md)
+If you have any issues with your devices being detected, or incorrect data, please take a look at [TROUBLESHOOTING_DEVICE_COLLECTOR.md](./TROUBLESHOOTING_DEVICE_COLLECTOR.md)

docs/SUPPORTED_NAS_OS.md

@@ -7,12 +7,16 @@ in `docs/guides/` or elsewhere) it will be linked here.
 - [x] [unraid](./INSTALL_UNRAID.md)
 - [ ] ESXI
 - [ ] Proxmox
-- [x] [Synology](./INSTALL_SYNOLOGY_COLLECTOR.md)
+- [x] Synology 
+  - [Hub/Spoke Deployment - Collector](./INSTALL_SYNOLOGY_COLLECTOR.md)
+  - [Omnibus Deployment](https://drfrankenstein.co.uk/2022/07/28/scrutiny-in-docker-on-a-synology-nas) -  Docker Package
+  - [Omnibus Deployment](https://drfrankenstein.co.uk/scrutiny-in-container-manager-on-a-synology-nas/) -  Container Manager Package
 - [ ] OMV
 - [ ] Amahi
 - [ ] Running in a LXC container
-- [x] [PFSense](./INSTALL_UNRAID.md)
+- [x] [PFSense](./INSTALL_PFSENSE.md)
 - [x] QNAP
 - [x] [RockStor](https://rockstor.com/docs/interface/docker-based-rock-ons/scrutiny.html)
 - [ ] Solaris/OmniOS CE Support
 - [ ] Kubernetes
+- [x] [Windows](./INSTALL_MANUAL_WINDOWS.md)

docs/TROUBLESHOOTING_DEVICE_COLLECTOR.md

@@ -19,6 +19,25 @@ Scrutiny stores and references the devices by their `WWN` which is globally uniq
 As such, passing devices to the Scrutiny collector container using `/dev/disk/by-id/`, `/dev/disk/by-label/`, `/dev/disk/by-path/` and `/dev/disk/by-uuid/`
 paths are unnecessary, unless you'd like to ensure the docker run command never needs to change.
 
+#### Force /dev/disk/by-id paths
+
+Since Scrutiny uses WWN under the hood, it really doesn't care about `/dev/sd*` vs `/dev/disk/by-id/`. The problem is the interaction between docker and smartmontools when using `--device /dev/disk/by-id` paths. 
+
+Basically Scrutiny offloads all device detection to smartmontools, which doesn't seem to detect devices that have been passed into the docker container using `/dev/disk/by-id` paths.
+
+If you must use "static" device references, you can map the host device id/uuid/wwn references to device names within the container:
+
+```
+# --device=<Host Device>:<Container Device Mapping>
+
+docker run ....
+--device=/dev/disk/by-id/wwn-0x5000xxxxx:/dev/sda
+--device=/dev/disk/by-id/wwn-0x5001xxxxx:/dev/sdb
+--device=/dev/disk/by-id/wwn-0x5003xxxxx:/dev/sdc
+...
+```
+
+
 
 ## Device Detection By Smartctl
 
@@ -61,7 +80,8 @@ using a collector config file. See [example.collector.yaml](/example.collector.y
 
 > NOTE: If you use docker, you **must** pass though the RAID virtual disk to the container using `--device` (see below)
 >
-> This device may be in `/dev/*` or `/dev/bus/*`. 
+> This device may be in `/dev/*` or `/dev/bus/*`.
+> If you do not see a virtual device file `/dev/bus/*` you may need to use the `--privileged` flag. See [#366 for more info](https://github.com/AnalogJ/scrutiny/issues/366#issuecomment-1253196407)
 >
 > If you're unsure, run `smartctl --scan` on your host, and pass all listed devices to the container.
 
@@ -92,7 +112,7 @@ devices:
     type:
       - aacraid,0,0,0
       - aacraid,0,0,1
-  
+
   # HPE Smart Array example:  https://github.com/AnalogJ/scrutiny/issues/213
   - device: /dev/sda
     type:
@@ -100,8 +120,11 @@ devices:
       - 'cciss,1'
 ```
 
+>
+
 ### NVMe Drives
-As mentioned in the [README.md](/README.md), NVMe devices require both `--cap-add SYS_RAWIO` and `--cap-add SYS_ADMIN` 
+
+As mentioned in the [README.md](/README.md), NVMe devices require both `--cap-add SYS_RAWIO` and `--cap-add SYS_ADMIN`
 to allow smartctl permission to query your NVMe device SMART data [#26](https://github.com/AnalogJ/scrutiny/issues/26)
 
 When attaching NVMe devices using `--device=/dev/nvme..`, make sure to provide the device controller (`/dev/nvme0`)
@@ -252,10 +275,12 @@ to disable Scrutiny analysis for them. Both are non-critical, and have low-corre
 If this is effecting your drives, you'll need to do the following:
 
 1. Upgrade to v0.4.13+
-2. Reset your drive status using the SQLite script in [#device-failed-but-smart--scrutiny-passed](https://github.com/AnalogJ/scrutiny/blob/master/docs/TROUBLESHOOTING_DEVICE_COLLECTOR.md#device-failed-but-smart--scrutiny-passed)
+2. Reset your drive status using the SQLite script
+   in [#device-failed-but-smart--scrutiny-passed](https://github.com/AnalogJ/scrutiny/blob/master/docs/TROUBLESHOOTING_DEVICE_COLLECTOR.md#device-failed-but-smart--scrutiny-passed)
 3. Wait for (or manually start) the collector.
 
-If you'd like to learn more about how the Seagate Ironwolf SMART attributes work under the hood, and how they differ from
+If you'd like to learn more about how the Seagate Ironwolf SMART attributes work under the hood, and how they differ
+from
 other drives, please read the following:
 
 - http://www.users.on.net/~fzabkar/HDD/Seagate_SER_RRER_HEC.html
@@ -263,10 +288,23 @@ other drives, please read the following:
 
 ## Hub & Spoke model, with multiple Hosts.
 
-When deploying Scrutiny in a hub & spoke model, it can be difficult to determine exactly which node a set of devices are associated with.
-Thankfully the collector has a special `--host-id` flag (or `COLLECTOR_HOST_ID` env variable) that can be used to associate devices with a friendly host name.
+![multiple-host-ids image](multiple-host-ids.png)
 
-See the [docs/INSTALL_HUB_SPOKE.md](/docs/INSTALL_HUB_SPOKE.md) guide for more information. 
+When deploying Scrutiny in a hub & spoke model, it can be difficult to determine exactly which node a set of devices are
+associated with.
+Thankfully the collector has a special `--host-id` flag (or `COLLECTOR_HOST_ID` env variable) that can be used to
+associate devices with a friendly host name.
+
+The host-id is passed from the collector to the web-api when SMART device data is uploaded. There's 3 ways you can set
+the host-id:
+
+- using the collector config
+  file: [master/example.collector.yaml#L19-L22](https://github.com/AnalogJ/scrutiny/blob/master/example.collector.yaml?rgh-link-date=2022-05-25T15%3A08%3A56Z#L19-L22)
+- using the `--host-id` collector CLI
+  argument: [master/collector/cmd/collector-metrics/collector-metrics.go#L180-L185](https://github.com/AnalogJ/scrutiny/blob/master/collector/cmd/collector-metrics/collector-metrics.go?rgh-link-date=2022-05-25T15%3A08%3A56Z#L180-L185)
+- using the `COLLECTOR_HOST_ID` environmental variable.
+
+See the [docs/INSTALL_HUB_SPOKE.md](/docs/INSTALL_HUB_SPOKE.md) guide for more information.
 
 ## Collector DEBUG mode
 
@@ -282,3 +320,20 @@ Or if you're not using docker, you can pass CLI arguments to the collector durin
 ```bash
 scrutiny-collector-metrics run --debug --log-file /tmp/collector.log
 ```
+
+## Collector trigger on startup
+
+When the `omnibus` docker image starts up, it will automatically trigger the collector, which will populate the Scrutiny
+Webui with your disks.
+This is not the case when running the collector docker image in **hub/spoke** mode, as the collector and webui are
+running in different containers (and potentially different host machines), so
+the web container may not be ready for incoming connections. By default the container will only run the collector at the
+time specified in the cron schedule.
+
+You can force the collector to run on startup using the following env variables:
+
+- `-e COLLECTOR_RUN_STARTUP=true` - forces the collector to run on startup (cron will be started after the collector
+  completes)
+- `-e COLLECTOR_RUN_STARTUP_SLEEP=10` - if `COLLECTOR_RUN_STARTUP` is enabled, you can use this env variable to
+  configure the delay before the collector is run (default: `1` second). Used to ensure the web container has started
+  successfully.  

docs/TROUBLESHOOTING_INFLUXDB.md

@@ -1,7 +1,19 @@
 # InfluxDB Troubleshooting
 
-## Installation 
-InfluxDB is a required dependency for Scrutiny v0.4.0+. 
+## Why??
+
+Scrutiny has many features, but the relevant one to this conversation is the "S.M.A.R.T metric tracking for historical
+trends". Basically Scrutiny not only shows you the current SMART values, but how they've changed over weeks, months (or
+even years).
+
+To efficiently handle that data at scale (and to make my life easier as a developer) I decided to add InfluxDB as a
+dependency. It's a dedicated timeseries database, as opposed to the general purpose sqlite DB I used before. I also did
+a bunch of testing and analysis before I made the change. With InfluxDB the memory footprint for Scrutiny (at idle) is ~
+100mb, which is still fairly reasonable.
+
+## Installation
+
+InfluxDB is a required dependency for Scrutiny v0.4.0+.
 
 https://docs.influxdata.com/influxdb/v2.2/install/
 
@@ -70,6 +82,7 @@ this usually related to either:
   variables
   - remove the `SCRUTINY_WEB=true` and `SCRUTINY_COLLECTOR=true` environmental variables. They were used by the LSIO
     image, but are unnecessary and cause issues with the official Scrutiny image.
+  - Change your volume mappings to `/opt/scrutiny` from `/scrutiny`
 - Updated versions of the [LSIO Scrutiny images are broken](https://github.com/linuxserver/docker-scrutiny/issues/22),
   as they have not installed InfluxDB which is a required dependency of Scrutiny v0.4.x
   - You can revert to an earlier version of the LSIO image (`lscr.io/linuxserver/scrutiny:060ac7b8-ls34`), or just
@@ -382,3 +395,32 @@ After running the Curl command above, you'll see a JSON response that looks like
 You must copy the token field from the JSON response, and save it in your `scrutiny.yaml` config file. After that's
 done, you can start the Scrutiny server
 
+## Customize InfluxDB Admin Username & Password
+
+The full set of InfluxDB configuration options are available
+in [code](https://github.com/AnalogJ/scrutiny/blob/master/webapp/backend/pkg/config/config.go?rgh-link-date=2023-01-19T16%3A23%3A40Z#L49-L51)
+.
+
+During first startup Scrutiny will connect to the unprotected InfluxDB server, start the setup process (via API) using a
+username and password of `admin`:`password12345` and then create an API token of `scrutiny-default-admin-token`.
+
+After that's complete, it will use the api token for all subsequent communication with InfluxDB.
+
+You can configure the values for the Admin username, password and token using the config file, or env variables:
+
+#### Config File Example
+
+```yaml
+web:
+  influxdb:
+    token: 'my-custom-token'
+    init_username: 'my-custom-username'
+    init_password: 'my-custom-password'
+```
+
+#### Environmental Variables Example
+
+`SCRUTINY_WEB_INFLUXDB_TOKEN` , `SCRUTINY_WEB_INFLUXDB_INIT_USERNAME` and `SCRUTINY_WEB_INFLUXDB_INIT_PASSWORD`
+
+It's safe to change the InfluxDB Admin username/password after setup has completed, only the API token is used for
+subsequent communication with InfluxDB.

docs/TROUBLESHOOTING_NOTIFICATIONS.md

@@ -21,5 +21,26 @@ SCRUTINY_DEVICE_NAME - eg. /dev/sda
 SCRUTINY_DEVICE_TYPE - ATA/SCSI/NVMe
 SCRUTINY_DEVICE_SERIAL - eg. WDDJ324KSO
 SCRUTINY_MESSAGE - eg. "Scrutiny SMART error notification for device: %s\nFailure Type: %s\nDevice Name: %s\nDevice Serial: %s\nDevice Type: %s\nDate: %s"
+SCRUTINY_HOST_ID - (optional) eg. "my-custom-host-id"
 ```
 
+# Special Characters
+
+`Shoutrrr` supports special characters in the username and password fields, however you'll need to url-encode the
+username and the password separately.
+
+- if your username is: `myname@example.com`
+- if your password is `124@34$1`
+
+Then your `shoutrrr` url will look something like:
+
+- `smtp://myname%40example%2Ecom:124%4034%241@ms.my.domain.com:587`
+
+# Testing Notifications
+
+You can test that your notifications are configured correctly by posting an empty payload to the notifications health
+check API.
+
+```
+curl -X POST http://localhost:8080/api/health/notify
+```

docs/TROUBLESHOOTING_REVERSE_PROXY.md

@@ -103,4 +103,37 @@ You may also configure these values using the following environmental variables
           - "9090:9090"
     ```
 3. run `docker-compose up`
-4. visit [http://localhost:9090/custom/web](http://localhost:9090/custom/web) - access the scrutiny container via caddy reverse proxy
+4. visit [http://localhost:9090/custom/web](http://localhost:9090/custom/web) - access the scrutiny container via caddy reverse proxy
+ 
+## Traefik
+
+Assuming, that you have Traefik up and running with [AutoDiscovery Using Traefik For Docker ](https://doc.traefik.io/traefik/providers/docker/),
+here is an example of a `docker-compose.yml` file, with labels to enable Traefik reverse proxy and basic auth
+```yaml
+version: '3.5'
+services:
+  scrutiny:
+    container_name: scrutiny
+    image: ghcr.io/analogj/scrutiny:master-omnibus
+    cap_add:
+      - SYS_RAWIO
+      - SYS_ADMIN
+    volumes:
+      - /run/udev:/run/udev:ro
+      - ./config:/opt/scrutiny/config
+      - ./influxdb:/opt/scrutiny/influxdb
+    labels:
+      - traefik.enable=true
+      - traefik.http.routers.scrutiny.rule=Host(`example.com`)
+      - traefik.http.services.scrutiny.loadbalancer.server.port=8080
+        # 2 labels below are optional, in case you want basic auth in Traefik:
+      - traefik.http.routers.scrutiny.middlewares=auth
+      - "traefik.http.middlewares.auth.basicauth.users=user:$$2y$$05$$G11Wm/dlWpXHENK..m8se.zxvaE8USJBp1Ws56sSCrOcwWDjsYHni"
+        # Note: when used in docker-compose.yml all dollar signs in the hash need to be doubled for escaping.
+        # To create user:password pair, it's possible to use this command:
+        # echo $(htpasswd -nB user) | sed -e s/\\$/\\$\\$/g
+    devices:
+      - "/dev/sda"
+      - "/dev/sdb"
+      - "/dev/nvme0"
+```

docs/TROUBLESHOOTING_UDEV.md

@@ -0,0 +1,18 @@
+# Operating systems without udev
+
+Some operating systems do not come with `udev` out of the box, for example Alpine Linux. In these instances you will not be able to bind `/run/udev` to the container for sharing device metadata. Some operating systems offer `udev` as a package that can be installed separately, or an alternative (such as `eudev` in the case of Alpine Linux) that provides the same functionality.
+
+To install `eudev` in Alpine Linux (run as root):
+
+```
+apk add eudev
+setup-udev
+```
+
+Once your `udev` implementation is installed, create `/run/udev` with the following command:
+
+```
+udevadm trigger
+```
+
+On Alpine Linux, this also has the benefit of creating symlinks to device serial numbers in `/dev/disk/by-id`.

docs/dbdiagram.io.txt

@@ -1,62 +1,88 @@
 
 // SQLite Table(s)
-Table device {
-  created_at timestamp
 
-  wwn varchar [pk]
+Table Device  {
+	//GORM attributes, see: http://gorm.io/docs/conventions.html
+	CreatedAt time
+	UpdatedAt time
+	DeletedAt time
 
-  //user provided
-  label varchar
-  host_id varchar
+	WWN string
 
-  // smartctl provided
-  device_name varchar
-  manufacturer varchar
-  model_name varchar
-  interface_type varchar
-  interface_speed varchar
-  serial_number varchar
-  firmware varchar
-  rotational_speed varchar
-  capacity varchar
-  form_factor varchar
-  smart_support varchar
-  device_protocol varchar
-  device_type varchar
+	DeviceName     string
+	DeviceUUID     string
+	DeviceSerialID string
+	DeviceLabel    string
 
+	Manufacturer   string
+	ModelName      string
+	InterfaceType  string
+	InterfaceSpeed string
+	SerialNumber   string
+	Firmware       string
+	RotationSpeed  int
+	Capacity       int64
+	FormFactor     string
+	SmartSupport   bool
+	DeviceProtocol string//protocol determines which smart attribute types are available (ATA, NVMe, SCSI)
+	DeviceType     string//device type is used for querying with -d/t flag, should only be used by collector.
+
+	// User provided metadata
+	Label  string
+	HostId string
+
+	// Data set by Scrutiny
+	DeviceStatus enum
+}
+
+Table Setting {
+	//GORM attributes, see: http://gorm.io/docs/conventions.html
+
+	SettingKeyName  string
+    SettingKeyDescription  string
+	SettingDataType string
+
+	SettingValueNumeric int64
+	SettingValueString  string
 }
 
 
 // InfluxDB Tables
-Table device_temperature {
-  //timestamp
-  created_at timestamp
-
-  //tags (indexed & queryable)
-  device_wwn varchar [pk]
-
-  //fields
-  temp bigint
- }
+Table SmartTemperature {
+    Date time
+	DeviceWWN      string //(tag)
+	Temp int64
+}
 
 
-Table smart_ata_results {
-  //timestamp
-  created_at timestamp
+Table Smart {
+    Date           time
+	DeviceWWN      string //(tag)
+	DeviceProtocol string
 
-  //tags (indexed & queryable)
-  device_wwn varchar [pk]
-  smart_status varchar
-  scrutiny_status varchar
+	//Metrics (fields)
+	Temp            int64
+	PowerOnHours    int64
+	PowerCycleCount int64
 
+	//Smart Status
+	Status enum
 
-
-  //fields
-  temp bigint
-  power_on_hours bigint
-  power_cycle_count bigint
-
+	//SMART Attributes (fields)
+	Attr_ID_AttributeId int
+	Attr_ID_Value       int64
+	Attr_ID_Threshold   int64
+	Attr_ID_Worst       int64
+    Attr_ID_RawValue    int64
+	Attr_ID_RawString   string
+	Attr_ID_WhenFailed  string
+	//Generated data
+	Attr_ID_TransformedValue int64
+	Attr_ID_Status           enum
+	Attr_ID_StatusReason     string
+	Attr_ID_FailureRate      float64
 
  }
 
-Ref: device.wwn < smart_ata_results.device_wwn
+Ref: Device.WWN < Smart.DeviceWWN
+Ref: Device.WWN < SmartTemperature.DeviceWWN

example.collector.yaml

@@ -31,6 +31,10 @@ devices:
 #  - device: /dev/sda
 #    type: 'sat'
 #
+#  # example for using `-d sat,auto`, notice the square brackets (workaround for #418)
+#  - device: /dev/sda
+#    type: ['sat,auto']
+#
 #  # example to show how to ignore a specific disk/device.
 #  - device: /dev/sda
 #    ignore: true

example.scrutiny.yaml

@@ -47,6 +47,11 @@ web:
 #    org: 'my-org'
 #    bucket: 'bucket'
     retention_policy: true
+    # if you wish to disable TLS certificate verification,
+    # when using self-signed certificates for example,
+    # then uncomment the lines below and set `insecure_skip_verify: true`
+    # tls:
+    #   insecure_skip_verify: false
 
 log:
   file: '' #absolute or relative paths allowed, eg. web.log
@@ -55,6 +60,10 @@ log:
 
 # Notification "urls" look like the following. For more information about service specific configuration see
 # Shoutrrr's documentation: https://containrrr.dev/shoutrrr/services/overview/
+#
+# note, usernames and passwords containing special characters will need to be urlencoded.
+# if your username is: "myname@example.com" and your password is "124@34$1"
+# your shoutrrr url will look like: "smtp://myname%40example%2Ecom:124%4034%241@ms.my.domain.com:587"
 
 #notify:
 #  urls:
@@ -68,13 +77,12 @@ log:
 #    - "pushbullet://api-token[/device/#channel/email]"
 #    - "ifttt://key/?events=event1[,event2,...]&value1=value1&value2=value2&value3=value3"
 #    - "mattermost://[username@]mattermost-host/token[/channel]"
+#    - "ntfy://username:password@host:port/topic"
 #    - "hangouts://chat.googleapis.com/v1/spaces/FOO/messages?key=bar&token=baz"
 #    - "zulip://bot-mail:bot-key@zulip-domain/?stream=name-or-id&topic=name"
 #    - "join://shoutrrr:api-key@join/?devices=device1[,device2, ...][&icon=icon][&title=title]"
 #    - "script:///file/path/on/disk"
 #    - "https://www.example.com/path"
-#  filter_attributes: 'all' # options: 'all' or  'critical'
-#  level: 'fail' # options: 'fail', 'fail_scrutiny', 'fail_smart'
 
 ########################################################################################################################
 # FEATURES COMING SOON

go.mod

@@ -1,33 +1,33 @@
 module github.com/analogj/scrutiny
 
-go 1.18
+go 1.20
 
 require (
 	github.com/analogj/go-util v0.0.0-20190301173314-5295e364eb14
-	github.com/containrrr/shoutrrr v0.4.4
-	github.com/fatih/color v1.10.0
+	github.com/containrrr/shoutrrr v0.7.1
+	github.com/fatih/color v1.15.0
 	github.com/gin-gonic/gin v1.6.3
 	github.com/glebarez/sqlite v1.4.5
 	github.com/go-gormigrate/gormigrate/v2 v2.0.0
-	github.com/golang/mock v1.4.3
+	github.com/golang/mock v1.6.0
 	github.com/influxdata/influxdb-client-go/v2 v2.9.0
 	github.com/jaypipes/ghw v0.6.1
-	github.com/mitchellh/mapstructure v1.2.2
+	github.com/mitchellh/mapstructure v1.5.0
 	github.com/samber/lo v1.25.0
-	github.com/sirupsen/logrus v1.4.2
-	github.com/spf13/viper v1.7.0
-	github.com/stretchr/testify v1.7.1
+	github.com/sirupsen/logrus v1.6.0
+	github.com/spf13/viper v1.14.0
+	github.com/stretchr/testify v1.8.1
 	github.com/urfave/cli/v2 v2.2.0
-	golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9
+	golang.org/x/sync v0.1.0
 	gorm.io/gorm v1.23.5
 )
 
 require (
 	github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/deepmap/oapi-codegen v1.8.2 // indirect
-	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/glebarez/go-sqlite v1.17.2 // indirect
@@ -35,55 +35,48 @@ require (
 	github.com/go-playground/locales v0.13.0 // indirect
 	github.com/go-playground/universal-translator v0.17.0 // indirect
 	github.com/go-playground/validator/v10 v10.2.0 // indirect
-	github.com/golang/protobuf v1.4.2 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/uuid v1.3.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839 // indirect
 	github.com/jaypipes/pcidb v0.5.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.4 // indirect
-	github.com/json-iterator/go v1.1.9 // indirect
-	github.com/klauspost/compress v1.11.7 // indirect
-	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/konsorten/go-windows-terminal-sequences v1.0.3 // indirect
 	github.com/kvz/logstreamer v0.0.0-20201023134116-02d20f4338f5 // indirect
 	github.com/leodido/go-urn v1.2.0 // indirect
-	github.com/magiconair/properties v1.8.1 // indirect
-	github.com/mattn/go-colorable v0.1.8 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
+	github.com/magiconair/properties v1.8.6 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.18 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.1 // indirect
-	github.com/nxadm/tail v1.4.6 // indirect
-	github.com/onsi/ginkgo v1.14.2 // indirect
-	github.com/pelletier/go-toml v1.7.0 // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml v1.9.5 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	github.com/russross/blackfriday/v2 v2.0.1 // indirect
-	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
-	github.com/spf13/afero v1.2.2 // indirect
-	github.com/spf13/cast v1.3.1 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/spf13/afero v1.9.2 // indirect
+	github.com/spf13/cast v1.5.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/subosito/gotenv v1.2.0 // indirect
+	github.com/subosito/gotenv v1.4.1 // indirect
 	github.com/ugorji/go/codec v1.1.7 // indirect
-	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect
+	golang.org/x/crypto v0.1.0 // indirect
 	golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 // indirect
-	golang.org/x/net v0.0.0-20210119194325-5f4716e94777 // indirect
-	golang.org/x/sys v0.0.0-20220405052023-b1e9470b6e64 // indirect
-	golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 // indirect
-	golang.org/x/text v0.3.5 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	google.golang.org/protobuf v1.23.0 // indirect
-	gopkg.in/ini.v1 v1.55.0 // indirect
-	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
-	gopkg.in/yaml.v2 v2.3.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
-	gosrc.io/xmpp v0.5.1 // indirect
+	golang.org/x/net v0.1.0 // indirect
+	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/term v0.1.0 // indirect
+	golang.org/x/text v0.4.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 	howett.net/plist v0.0.0-20181124034731-591f970eefbb // indirect
 	modernc.org/libc v1.16.8 // indirect
 	modernc.org/mathutil v1.4.1 // indirect
 	modernc.org/memory v1.1.1 // indirect
 	modernc.org/sqlite v1.17.2 // indirect
-	nhooyr.io/websocket v1.8.6 // indirect
 )

webapp/backend/cmd/scrutiny/scrutiny.go

@@ -1,12 +1,15 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/errors"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/version"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/web"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
+	"io"
+	"log"
 	"os"
 	"time"
 
@@ -26,11 +29,18 @@ func main() {
 		os.Exit(1)
 	}
 
+	configFilePath := "/opt/scrutiny/config/scrutiny.yaml"
+	configFilePathAlternative := "/opt/scrutiny/config/scrutiny.yml"
+	if !utils.FileExists(configFilePath) && utils.FileExists(configFilePathAlternative) {
+		configFilePath = configFilePathAlternative
+	}
+
 	//we're going to load the config file manually, since we need to validate it.
-	err = config.ReadConfig("/opt/scrutiny/config/scrutiny.yaml") // Find and read the config file
+	err = config.ReadConfig(configFilePath) // Find and read the config file
 	if _, ok := err.(errors.ConfigFileMissingError); ok {         // Handle errors reading the config file
 		//ignore "could not find config file"
 	} else if err != nil {
+		log.Print(color.HiRedString("CONFIG ERROR: %v", err))
 		os.Exit(1)
 	}
 
@@ -107,7 +117,18 @@ OPTIONS:
 						config.Set("log.file", c.String("log-file"))
 					}
 
-					webServer := web.AppEngine{Config: config}
+					webLogger, logFile, err := CreateLogger(config)
+					if logFile != nil {
+						defer logFile.Close()
+					}
+					if err != nil {
+						return err
+					}
+
+					settingsData, err := json.Marshal(config.AllSettings())
+					webLogger.Debug(string(settingsData), err)
+
+					webServer := web.AppEngine{Config: config, Logger: webLogger}
 
 					return webServer.Start()
 				},
@@ -140,3 +161,27 @@ OPTIONS:
 	}
 
 }
+
+func CreateLogger(appConfig config.Interface) (*logrus.Entry, *os.File, error) {
+	logger := logrus.WithFields(logrus.Fields{
+		"type": "web",
+	})
+	//set default log level
+	if level, err := logrus.ParseLevel(appConfig.GetString("log.level")); err == nil {
+		logger.Logger.SetLevel(level)
+	} else {
+		logger.Logger.SetLevel(logrus.InfoLevel)
+	}
+
+	var logFile *os.File
+	var err error
+	if appConfig.IsSet("log.file") && len(appConfig.GetString("log.file")) > 0 {
+		logFile, err = os.OpenFile(appConfig.GetString("log.file"), os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			logger.Logger.Errorf("Failed to open log file %s for output: %s", appConfig.GetString("log.file"), err)
+			return nil, logFile, err
+		}
+		logger.Logger.SetOutput(io.MultiWriter(os.Stderr, logFile))
+	}
+	return logger, logFile, nil
+}

webapp/backend/pkg/config/config.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"github.com/analogj/go-util/utils"
-	"github.com/analogj/scrutiny/webapp/backend/pkg"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/errors"
 	"github.com/spf13/viper"
 	"log"
@@ -10,6 +9,8 @@ import (
 	"strings"
 )
 
+const DB_USER_SETTINGS_SUBKEY = "user"
+
 // When initializing this class the following methods must be called:
 // Config.New
 // Config.Init
@@ -39,8 +40,6 @@ func (c *configuration) Init() error {
 	c.SetDefault("log.file", "")
 
 	c.SetDefault("notify.urls", []string{})
-	c.SetDefault("notify.filter_attributes", pkg.NotifyFilterAttributesAll)
-	c.SetDefault("notify.level", pkg.NotifyLevelFail)
 
 	c.SetDefault("web.influxdb.scheme", "http")
 	c.SetDefault("web.influxdb.host", "localhost")
@@ -50,22 +49,12 @@ func (c *configuration) Init() error {
 	c.SetDefault("web.influxdb.init_username", "admin")
 	c.SetDefault("web.influxdb.init_password", "password12345")
 	c.SetDefault("web.influxdb.token", "scrutiny-default-admin-token")
+	c.SetDefault("web.influxdb.tls.insecure_skip_verify", false)
 	c.SetDefault("web.influxdb.retention_policy", true)
 
 	//c.SetDefault("disks.include", []string{})
 	//c.SetDefault("disks.exclude", []string{})
 
-	//c.SetDefault("notify.metric.script", "/opt/scrutiny/config/notify-metrics.sh")
-	//c.SetDefault("notify.long.script", "/opt/scrutiny/config/notify-long-test.sh")
-	//c.SetDefault("notify.short.script", "/opt/scrutiny/config/notify-short-test.sh")
-
-	//c.SetDefault("collect.metric.enable", true)
-	//c.SetDefault("collect.metric.command", "-a -o on -S on")
-	//c.SetDefault("collect.long.enable", true)
-	//c.SetDefault("collect.long.command", "-a -o on -S on")
-	//c.SetDefault("collect.short.enable", true)
-	//c.SetDefault("collect.short.command", "-a -o on -S on")
-
 	//if you want to load a non-standard location system config file (~/drawbridge.yml), use ReadConfig
 	c.SetConfigType("yaml")
 	//c.SetConfigName("drawbridge")
@@ -77,7 +66,18 @@ func (c *configuration) Init() error {
 	c.AutomaticEnv()
 
 	//CLI options will be added via the `Set()` function
-	return nil
+	return c.ValidateConfig()
+}
+
+func (c *configuration) SubKeys(key string) []string {
+	return c.Sub(key).AllKeys()
+}
+
+func (c *configuration) Sub(key string) Interface {
+	config := configuration{
+		Viper: c.Viper.Sub(key),
+	}
+	return &config
 }
 
 func (c *configuration) ReadConfig(configFilePath string) error {
@@ -120,24 +120,18 @@ func (c *configuration) ReadConfig(configFilePath string) error {
 // This function ensures that the merged config works correctly.
 func (c *configuration) ValidateConfig() error {
 
-	////deserialize Questions
-	//questionsMap := map[string]Question{}
-	//err := c.UnmarshalKey("questions", &questionsMap)
-	//
-	//if err != nil {
-	//	log.Printf("questions could not be deserialized correctly. %v", err)
-	//	return err
-	//}
-	//
-	//for _, v := range questionsMap {
-	//
-	//	typeContent, ok := v.Schema["type"].(string)
-	//	if !ok || len(typeContent) == 0 {
-	//		return errors.QuestionSyntaxError("`type` is required for questions")
-	//	}
-	//}
-	//
-	//
+	//the following keys are deprecated, and no longer supported
+	/*
+		- notify.filter_attributes (replaced by metrics.status.filter_attributes SETTING)
+		- notify.level (replaced by metrics.notify.level and metrics.status.threshold SETTING)
+	*/
+	//TODO add docs and upgrade doc.
+	if c.IsSet("notify.filter_attributes") {
+		return errors.ConfigValidationError("`notify.filter_attributes` configuration option is deprecated. Replaced by option in Dashboard Settings page")
+	}
+	if c.IsSet("notify.level") {
+		return errors.ConfigValidationError("`notify.level` configuration option is deprecated. Replaced by option in Dashboard Settings page")
+	}
 
 	return nil
 }

webapp/backend/pkg/config/config_test.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_MergeConfigMap(t *testing.T) {
+	//setup
+	testConfig := configuration{
+		Viper: viper.New(),
+	}
+	testConfig.Set("user.dashboard_display", "hello")
+	testConfig.SetDefault("user.layout", "hello")
+
+	mergeSettings := map[string]interface{}{
+		"user": map[string]interface{}{
+			"dashboard_display": "dashboard_display",
+			"layout":            "layout",
+		},
+	}
+	//test
+	err := testConfig.MergeConfigMap(mergeSettings)
+
+	//verify
+	require.NoError(t, err)
+
+	// if using Set, the MergeConfigMap functionality will not override
+	// if using SetDefault, the MergeConfigMap will override correctly
+	require.Equal(t, "hello", testConfig.GetString("user.dashboard_display"))
+	require.Equal(t, "layout", testConfig.GetString("user.layout"))
+
+}

webapp/backend/pkg/config/interface.go

@@ -12,12 +12,17 @@ type Interface interface {
 	WriteConfig() error
 	Set(key string, value interface{})
 	SetDefault(key string, value interface{})
+	MergeConfigMap(cfg map[string]interface{}) error
 
+	Sub(key string) Interface
 	AllSettings() map[string]interface{}
+	AllKeys() []string
+	SubKeys(key string) []string
 	IsSet(key string) bool
 	Get(key string) interface{}
 	GetBool(key string) bool
 	GetInt(key string) int
+	GetInt64(key string) int64
 	GetString(key string) string
 	GetStringSlice(key string) []string
 	UnmarshalKey(key string, rawVal interface{}, decoderOpts ...viper.DecoderConfigOption) error

webapp/backend/pkg/config/mock/mock_config.go

@@ -7,6 +7,7 @@ package mock_config
 import (
 	reflect "reflect"
 
+	config "github.com/analogj/scrutiny/webapp/backend/pkg/config"
 	gomock "github.com/golang/mock/gomock"
 	viper "github.com/spf13/viper"
 )
@@ -34,6 +35,20 @@ func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
 	return m.recorder
 }
 
+// AllKeys mocks base method.
+func (m *MockInterface) AllKeys() []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllKeys")
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// AllKeys indicates an expected call of AllKeys.
+func (mr *MockInterfaceMockRecorder) AllKeys() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllKeys", reflect.TypeOf((*MockInterface)(nil).AllKeys))
+}
+
 // AllSettings mocks base method.
 func (m *MockInterface) AllSettings() map[string]interface{} {
 	m.ctrl.T.Helper()
@@ -90,6 +105,20 @@ func (mr *MockInterfaceMockRecorder) GetInt(key interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInt", reflect.TypeOf((*MockInterface)(nil).GetInt), key)
 }
 
+// GetInt64 mocks base method.
+func (m *MockInterface) GetInt64(key string) int64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetInt64", key)
+	ret0, _ := ret[0].(int64)
+	return ret0
+}
+
+// GetInt64 indicates an expected call of GetInt64.
+func (mr *MockInterfaceMockRecorder) GetInt64(key interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInt64", reflect.TypeOf((*MockInterface)(nil).GetInt64), key)
+}
+
 // GetString mocks base method.
 func (m *MockInterface) GetString(key string) string {
 	m.ctrl.T.Helper()
@@ -146,6 +175,20 @@ func (mr *MockInterfaceMockRecorder) IsSet(key interface{}) *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSet", reflect.TypeOf((*MockInterface)(nil).IsSet), key)
 }
 
+// MergeConfigMap mocks base method.
+func (m *MockInterface) MergeConfigMap(cfg map[string]interface{}) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MergeConfigMap", cfg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// MergeConfigMap indicates an expected call of MergeConfigMap.
+func (mr *MockInterfaceMockRecorder) MergeConfigMap(cfg interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeConfigMap", reflect.TypeOf((*MockInterface)(nil).MergeConfigMap), cfg)
+}
+
 // ReadConfig mocks base method.
 func (m *MockInterface) ReadConfig(configFilePath string) error {
 	m.ctrl.T.Helper()
@@ -184,6 +227,34 @@ func (mr *MockInterfaceMockRecorder) SetDefault(key, value interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefault", reflect.TypeOf((*MockInterface)(nil).SetDefault), key, value)
 }
 
+// Sub mocks base method.
+func (m *MockInterface) Sub(key string) config.Interface {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Sub", key)
+	ret0, _ := ret[0].(config.Interface)
+	return ret0
+}
+
+// Sub indicates an expected call of Sub.
+func (mr *MockInterfaceMockRecorder) Sub(key interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sub", reflect.TypeOf((*MockInterface)(nil).Sub), key)
+}
+
+// SubKeys mocks base method.
+func (m *MockInterface) SubKeys(key string) []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubKeys", key)
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// SubKeys indicates an expected call of SubKeys.
+func (mr *MockInterfaceMockRecorder) SubKeys(key interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubKeys", reflect.TypeOf((*MockInterface)(nil).SubKeys), key)
+}
+
 // UnmarshalKey mocks base method.
 func (m *MockInterface) UnmarshalKey(key string, rawVal interface{}, decoderOpts ...viper.DecoderConfigOption) error {
 	m.ctrl.T.Helper()

webapp/backend/pkg/constants.go

@@ -4,17 +4,11 @@ const DeviceProtocolAta = "ATA"
 const DeviceProtocolScsi = "SCSI"
 const DeviceProtocolNvme = "NVMe"
 
-const NotifyFilterAttributesAll = "all"
-const NotifyFilterAttributesCritical = "critical"
-
-const NotifyLevelFail = "fail"
-const NotifyLevelFailScrutiny = "fail_scrutiny"
-const NotifyLevelFailSmart = "fail_smart"
-
 //go:generate stringer -type=AttributeStatus
+// AttributeStatus bitwise flag, 1,2,4,8,16,32,etc
 type AttributeStatus uint8
+
 const (
-	// AttributeStatusPassed binary, 1,2,4,8,16,32,etc
 	AttributeStatusPassed          AttributeStatus = 0
 	AttributeStatusFailedSmart     AttributeStatus = 1
 	AttributeStatusWarningScrutiny AttributeStatus = 2
@@ -30,9 +24,10 @@ func AttributeStatusToggle(b, flag AttributeStatus) AttributeStatus { return b ^
 func AttributeStatusHas(b, flag AttributeStatus) bool               { return b&flag != 0 }
 
 //go:generate stringer -type=DeviceStatus
+// DeviceStatus bitwise flag, 1,2,4,8,16,32,etc
 type DeviceStatus uint8
+
 const (
-	// DeviceStatusPassed binary, 1,2,4,8,16,32,etc
 	DeviceStatusPassed         DeviceStatus = 0
 	DeviceStatusFailedSmart    DeviceStatus = 1
 	DeviceStatusFailedScrutiny DeviceStatus = 2
@@ -42,3 +37,29 @@ func DeviceStatusSet(b, flag DeviceStatus) DeviceStatus    { return b | flag }
 func DeviceStatusClear(b, flag DeviceStatus) DeviceStatus  { return b &^ flag }
 func DeviceStatusToggle(b, flag DeviceStatus) DeviceStatus { return b ^ flag }
 func DeviceStatusHas(b, flag DeviceStatus) bool            { return b&flag != 0 }
+
+// Metrics Specific Filtering & Threshold Constants
+type MetricsNotifyLevel int64
+
+const (
+	MetricsNotifyLevelWarn MetricsNotifyLevel = 1
+	MetricsNotifyLevelFail MetricsNotifyLevel = 2
+)
+
+type MetricsStatusFilterAttributes int64
+
+const (
+	MetricsStatusFilterAttributesAll      MetricsStatusFilterAttributes = 0
+	MetricsStatusFilterAttributesCritical MetricsStatusFilterAttributes = 1
+)
+
+// MetricsStatusThreshold bitwise flag, 1,2,4,8,16,32,etc
+type MetricsStatusThreshold int64
+
+const (
+	MetricsStatusThresholdSmart    MetricsStatusThreshold = 1
+	MetricsStatusThresholdScrutiny MetricsStatusThreshold = 2
+
+	//shortcut
+	MetricsStatusThresholdBoth MetricsStatusThreshold = 3
+)

webapp/backend/pkg/database/helpers.go

@@ -1,12 +0,0 @@
-package database
-
-import (
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
-	"sort"
-)
-
-func sortSmartMeasurementsDesc(smartResults []measurements.Smart) {
-	sort.SliceStable(smartResults, func(i, j int) bool {
-		return smartResults[i].Date.After(smartResults[j].Date)
-	})
-}

webapp/backend/pkg/database/helpers_test.go

@@ -1,30 +0,0 @@
-package database
-
-import (
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
-	"github.com/stretchr/testify/require"
-	"testing"
-	"time"
-)
-
-func Test_sortSmartMeasurementsDesc_LatestFirst(t *testing.T) {
-	//setup
-	timeNow := time.Now()
-	smartResults := []measurements.Smart{
-		{
-			Date: timeNow.AddDate(0, 0, -2),
-		},
-		{
-			Date: timeNow,
-		},
-		{
-			Date: timeNow.AddDate(0, 0, -1),
-		},
-	}
-
-	//test
-	sortSmartMeasurementsDesc(smartResults)
-
-	//assert
-	require.Equal(t, smartResults[0].Date, timeNow)
-}

webapp/backend/pkg/database/interface.go

@@ -2,17 +2,18 @@ package database
 
 import (
 	"context"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
 )
 
+// Create mock using:
+// mockgen -source=webapp/backend/pkg/database/interface.go -destination=webapp/backend/pkg/database/mock/mock_database.go
 type DeviceRepo interface {
 	Close() error
-
-	//GetSettings()
-	//SaveSetting()
+	HealthCheck(ctx context.Context) error
 
 	RegisterDevice(ctx context.Context, dev models.Device) error
 	GetDevices(ctx context.Context) ([]models.Device, error)
@@ -22,10 +23,13 @@ type DeviceRepo interface {
 	DeleteDevice(ctx context.Context, wwn string) error
 
 	SaveSmartAttributes(ctx context.Context, wwn string, collectorSmartData collector.SmartInfo) (measurements.Smart, error)
-	GetSmartAttributeHistory(ctx context.Context, wwn string, durationKey string, attributes []string) ([]measurements.Smart, error)
+	GetSmartAttributeHistory(ctx context.Context, wwn string, durationKey string, selectEntries int, selectEntriesOffset int, attributes []string) ([]measurements.Smart, error)
 
 	SaveSmartTemperature(ctx context.Context, wwn string, deviceProtocol string, collectorSmartData collector.SmartInfo) error
 
 	GetSummary(ctx context.Context) (map[string]*models.DeviceSummary, error)
 	GetSmartTemperatureHistory(ctx context.Context, durationKey string) (map[string][]measurements.SmartTemperature, error)
+
+	LoadSettings(ctx context.Context) (*models.Settings, error)
+	SaveSettings(ctx context.Context, settings models.Settings) error
 }

webapp/backend/pkg/database/migrations/m20220716214900/setting.go

@@ -0,0 +1,18 @@
+package m20220716214900
+
+import (
+	"gorm.io/gorm"
+)
+
+type Setting struct {
+	//GORM attributes, see: http://gorm.io/docs/conventions.html
+	gorm.Model
+
+	SettingKeyName        string `json:"setting_key_name"`
+	SettingKeyDescription string `json:"setting_key_description"`
+	SettingDataType       string `json:"setting_data_type"`
+
+	SettingValueNumeric int    `json:"setting_value_numeric"`
+	SettingValueString  string `json:"setting_value_string"`
+	SettingValueBool    bool   `json:"setting_value_bool"`
+}

webapp/backend/pkg/database/mock/mock_database.go

@@ -0,0 +1,258 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: webapp/backend/pkg/database/interface.go
+
+// Package mock_database is a generated GoMock package.
+package mock_database
+
+import (
+	context "context"
+	reflect "reflect"
+
+	pkg "github.com/analogj/scrutiny/webapp/backend/pkg"
+	models "github.com/analogj/scrutiny/webapp/backend/pkg/models"
+	collector "github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
+	measurements "github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockDeviceRepo is a mock of DeviceRepo interface.
+type MockDeviceRepo struct {
+	ctrl     *gomock.Controller
+	recorder *MockDeviceRepoMockRecorder
+}
+
+// MockDeviceRepoMockRecorder is the mock recorder for MockDeviceRepo.
+type MockDeviceRepoMockRecorder struct {
+	mock *MockDeviceRepo
+}
+
+// NewMockDeviceRepo creates a new mock instance.
+func NewMockDeviceRepo(ctrl *gomock.Controller) *MockDeviceRepo {
+	mock := &MockDeviceRepo{ctrl: ctrl}
+	mock.recorder = &MockDeviceRepoMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDeviceRepo) EXPECT() *MockDeviceRepoMockRecorder {
+	return m.recorder
+}
+
+// Close mocks base method.
+func (m *MockDeviceRepo) Close() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockDeviceRepoMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDeviceRepo)(nil).Close))
+}
+
+// DeleteDevice mocks base method.
+func (m *MockDeviceRepo) DeleteDevice(ctx context.Context, wwn string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDevice", ctx, wwn)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteDevice indicates an expected call of DeleteDevice.
+func (mr *MockDeviceRepoMockRecorder) DeleteDevice(ctx, wwn interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDevice", reflect.TypeOf((*MockDeviceRepo)(nil).DeleteDevice), ctx, wwn)
+}
+
+// GetDeviceDetails mocks base method.
+func (m *MockDeviceRepo) GetDeviceDetails(ctx context.Context, wwn string) (models.Device, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDeviceDetails", ctx, wwn)
+	ret0, _ := ret[0].(models.Device)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDeviceDetails indicates an expected call of GetDeviceDetails.
+func (mr *MockDeviceRepoMockRecorder) GetDeviceDetails(ctx, wwn interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceDetails", reflect.TypeOf((*MockDeviceRepo)(nil).GetDeviceDetails), ctx, wwn)
+}
+
+// GetDevices mocks base method.
+func (m *MockDeviceRepo) GetDevices(ctx context.Context) ([]models.Device, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDevices", ctx)
+	ret0, _ := ret[0].([]models.Device)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDevices indicates an expected call of GetDevices.
+func (mr *MockDeviceRepoMockRecorder) GetDevices(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevices", reflect.TypeOf((*MockDeviceRepo)(nil).GetDevices), ctx)
+}
+
+// GetSmartAttributeHistory mocks base method.
+func (m *MockDeviceRepo) GetSmartAttributeHistory(ctx context.Context, wwn, durationKey string, selectEntries, selectEntriesOffset int, attributes []string) ([]measurements.Smart, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSmartAttributeHistory", ctx, wwn, durationKey, selectEntries, selectEntriesOffset, attributes)
+	ret0, _ := ret[0].([]measurements.Smart)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSmartAttributeHistory indicates an expected call of GetSmartAttributeHistory.
+func (mr *MockDeviceRepoMockRecorder) GetSmartAttributeHistory(ctx, wwn, durationKey, selectEntries, selectEntriesOffset, attributes interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSmartAttributeHistory", reflect.TypeOf((*MockDeviceRepo)(nil).GetSmartAttributeHistory), ctx, wwn, durationKey, selectEntries, selectEntriesOffset, attributes)
+}
+
+// GetSmartTemperatureHistory mocks base method.
+func (m *MockDeviceRepo) GetSmartTemperatureHistory(ctx context.Context, durationKey string) (map[string][]measurements.SmartTemperature, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSmartTemperatureHistory", ctx, durationKey)
+	ret0, _ := ret[0].(map[string][]measurements.SmartTemperature)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSmartTemperatureHistory indicates an expected call of GetSmartTemperatureHistory.
+func (mr *MockDeviceRepoMockRecorder) GetSmartTemperatureHistory(ctx, durationKey interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSmartTemperatureHistory", reflect.TypeOf((*MockDeviceRepo)(nil).GetSmartTemperatureHistory), ctx, durationKey)
+}
+
+// GetSummary mocks base method.
+func (m *MockDeviceRepo) GetSummary(ctx context.Context) (map[string]*models.DeviceSummary, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSummary", ctx)
+	ret0, _ := ret[0].(map[string]*models.DeviceSummary)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSummary indicates an expected call of GetSummary.
+func (mr *MockDeviceRepoMockRecorder) GetSummary(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSummary", reflect.TypeOf((*MockDeviceRepo)(nil).GetSummary), ctx)
+}
+
+// HealthCheck mocks base method.
+func (m *MockDeviceRepo) HealthCheck(ctx context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HealthCheck", ctx)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// HealthCheck indicates an expected call of HealthCheck.
+func (mr *MockDeviceRepoMockRecorder) HealthCheck(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealthCheck", reflect.TypeOf((*MockDeviceRepo)(nil).HealthCheck), ctx)
+}
+
+// LoadSettings mocks base method.
+func (m *MockDeviceRepo) LoadSettings(ctx context.Context) (*models.Settings, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "LoadSettings", ctx)
+	ret0, _ := ret[0].(*models.Settings)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// LoadSettings indicates an expected call of LoadSettings.
+func (mr *MockDeviceRepoMockRecorder) LoadSettings(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadSettings", reflect.TypeOf((*MockDeviceRepo)(nil).LoadSettings), ctx)
+}
+
+// RegisterDevice mocks base method.
+func (m *MockDeviceRepo) RegisterDevice(ctx context.Context, dev models.Device) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegisterDevice", ctx, dev)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RegisterDevice indicates an expected call of RegisterDevice.
+func (mr *MockDeviceRepoMockRecorder) RegisterDevice(ctx, dev interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDevice", reflect.TypeOf((*MockDeviceRepo)(nil).RegisterDevice), ctx, dev)
+}
+
+// SaveSettings mocks base method.
+func (m *MockDeviceRepo) SaveSettings(ctx context.Context, settings models.Settings) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaveSettings", ctx, settings)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SaveSettings indicates an expected call of SaveSettings.
+func (mr *MockDeviceRepoMockRecorder) SaveSettings(ctx, settings interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSettings", reflect.TypeOf((*MockDeviceRepo)(nil).SaveSettings), ctx, settings)
+}
+
+// SaveSmartAttributes mocks base method.
+func (m *MockDeviceRepo) SaveSmartAttributes(ctx context.Context, wwn string, collectorSmartData collector.SmartInfo) (measurements.Smart, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaveSmartAttributes", ctx, wwn, collectorSmartData)
+	ret0, _ := ret[0].(measurements.Smart)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SaveSmartAttributes indicates an expected call of SaveSmartAttributes.
+func (mr *MockDeviceRepoMockRecorder) SaveSmartAttributes(ctx, wwn, collectorSmartData interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSmartAttributes", reflect.TypeOf((*MockDeviceRepo)(nil).SaveSmartAttributes), ctx, wwn, collectorSmartData)
+}
+
+// SaveSmartTemperature mocks base method.
+func (m *MockDeviceRepo) SaveSmartTemperature(ctx context.Context, wwn, deviceProtocol string, collectorSmartData collector.SmartInfo) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SaveSmartTemperature", ctx, wwn, deviceProtocol, collectorSmartData)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SaveSmartTemperature indicates an expected call of SaveSmartTemperature.
+func (mr *MockDeviceRepoMockRecorder) SaveSmartTemperature(ctx, wwn, deviceProtocol, collectorSmartData interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSmartTemperature", reflect.TypeOf((*MockDeviceRepo)(nil).SaveSmartTemperature), ctx, wwn, deviceProtocol, collectorSmartData)
+}
+
+// UpdateDevice mocks base method.
+func (m *MockDeviceRepo) UpdateDevice(ctx context.Context, wwn string, collectorSmartData collector.SmartInfo) (models.Device, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDevice", ctx, wwn, collectorSmartData)
+	ret0, _ := ret[0].(models.Device)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDevice indicates an expected call of UpdateDevice.
+func (mr *MockDeviceRepoMockRecorder) UpdateDevice(ctx, wwn, collectorSmartData interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDevice", reflect.TypeOf((*MockDeviceRepo)(nil).UpdateDevice), ctx, wwn, collectorSmartData)
+}
+
+// UpdateDeviceStatus mocks base method.
+func (m *MockDeviceRepo) UpdateDeviceStatus(ctx context.Context, wwn string, status pkg.DeviceStatus) (models.Device, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDeviceStatus", ctx, wwn, status)
+	ret0, _ := ret[0].(models.Device)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDeviceStatus indicates an expected call of UpdateDeviceStatus.
+func (mr *MockDeviceRepoMockRecorder) UpdateDeviceStatus(ctx, wwn, status interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeviceStatus", reflect.TypeOf((*MockDeviceRepo)(nil).UpdateDeviceStatus), ctx, wwn, status)
+}

webapp/backend/pkg/database/scrutiny_repository.go

@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"crypto/tls"
 	"encoding/json"
 	"fmt"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
@@ -62,7 +63,20 @@ func NewScrutinyRepository(appConfig config.Interface, globalLogger logrus.Field
 	// Gorm/SQLite setup
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	globalLogger.Infof("Trying to connect to scrutiny sqlite db: %s\n", appConfig.GetString("web.database.location"))
-	database, err := gorm.Open(sqlite.Open(appConfig.GetString("web.database.location")), &gorm.Config{
+
+	// When a transaction cannot lock the database, because it is already locked by another one,
+	// SQLite by default throws an error: database is locked. This behavior is usually not appropriate when
+	// concurrent access is needed, typically when multiple processes write to the same database.
+	// PRAGMA busy_timeout lets you set a timeout or a handler for these events. When setting a timeout,
+	// SQLite will try the transaction multiple times within this timeout.
+	// fixes #341
+	// https://rsqlite.r-dbi.org/reference/sqlitesetbusyhandler
+	// retrying for 30000 milliseconds, 30seconds - this would be unreasonable for a distributed multi-tenant application,
+	// but should be fine for local usage.
+	pragmaStr := sqlitePragmaString(map[string]string{
+		"busy_timeout": "30000",
+	})
+	database, err := gorm.Open(sqlite.Open(appConfig.GetString("web.database.location")+pragmaStr), &gorm.Config{
 		//TODO: figure out how to log database queries again.
 		//Logger: logger
 		DisableForeignKeyConstraintWhenMigrating: true,
@@ -82,11 +96,20 @@ func NewScrutinyRepository(appConfig config.Interface, globalLogger logrus.Field
 	influxdbUrl := fmt.Sprintf("%s://%s:%s", appConfig.GetString("web.influxdb.scheme"), appConfig.GetString("web.influxdb.host"), appConfig.GetString("web.influxdb.port"))
 	globalLogger.Debugf("InfluxDB url: %s", influxdbUrl)
 
-	client := influxdb2.NewClient(influxdbUrl, appConfig.GetString("web.influxdb.token"))
+	tlsConfig := &tls.Config{
+		InsecureSkipVerify: appConfig.GetBool("web.influxdb.tls.insecure_skip_verify"),
+	}
+	globalLogger.Infof("InfluxDB certificate verification: %t\n", !tlsConfig.InsecureSkipVerify)
+
+	client := influxdb2.NewClientWithOptions(
+		influxdbUrl,
+		appConfig.GetString("web.influxdb.token"),
+		influxdb2.DefaultOptions().SetTLSConfig(tlsConfig),
+	)
 
 	//if !appConfig.IsSet("web.influxdb.token") {
 	globalLogger.Debugf("Determine Influxdb setup status...")
-	influxSetupComplete, err := InfluxSetupComplete(influxdbUrl)
+	influxSetupComplete, err := InfluxSetupComplete(influxdbUrl, tlsConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check influxdb setup status - %w", err)
 	}
@@ -182,7 +205,30 @@ func (sr *scrutinyRepository) Close() error {
 	return nil
 }
 
-func InfluxSetupComplete(influxEndpoint string) (bool, error) {
+func (sr *scrutinyRepository) HealthCheck(ctx context.Context) error {
+	//check influxdb
+	status, err := sr.influxClient.Health(ctx)
+	if err != nil {
+		return fmt.Errorf("influxdb healthcheck failed: %w", err)
+	}
+	if status.Status != "pass" {
+		return fmt.Errorf("influxdb healthcheckf failed: status=%s", status.Status)
+	}
+
+	//check sqlite db.
+	database, err := sr.gormClient.DB()
+	if err != nil {
+		return fmt.Errorf("sqlite healthcheck failed: %w", err)
+	}
+	err = database.Ping()
+	if err != nil {
+		return fmt.Errorf("sqlite healthcheck failed during ping: %w", err)
+	}
+	return nil
+
+}
+
+func InfluxSetupComplete(influxEndpoint string, tlsConfig *tls.Config) (bool, error) {
 	influxUri, err := url.Parse(influxEndpoint)
 	if err != nil {
 		return false, err
@@ -192,7 +238,8 @@ func InfluxSetupComplete(influxEndpoint string) (bool, error) {
 		return false, err
 	}
 
-	res, err := http.Get(influxUri.String())
+    client := &http.Client{Transport: &http.Transport{TLSClientConfig: tlsConfig}}
+	res, err := client.Get(influxUri.String())
 	if err != nil {
 		return false, err
 	}
@@ -450,3 +497,16 @@ func (sr *scrutinyRepository) lookupNestedDurationKeys(durationKey string) []str
 	}
 	return []string{DURATION_KEY_WEEK}
 }
+
+func sqlitePragmaString(pragmas map[string]string) string {
+	q := url.Values{}
+	for key, val := range pragmas {
+		q.Add("_pragma", key+"="+val)
+	}
+
+	queryStr := q.Encode()
+	if len(queryStr) > 0 {
+		return "?" + queryStr
+	}
+	return ""
+}

webapp/backend/pkg/database/scrutiny_repository_device_smart_attributes.go

@@ -3,13 +3,14 @@ package database
 import (
 	"context"
 	"fmt"
+	"strings"
+	"time"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
 	influxdb2 "github.com/influxdata/influxdb-client-go/v2"
 	"github.com/influxdata/influxdb-client-go/v2/api"
 	log "github.com/sirupsen/logrus"
-	"strings"
-	"time"
 )
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -30,14 +31,17 @@ func (sr *scrutinyRepository) SaveSmartAttributes(ctx context.Context, wwn strin
 }
 
 // GetSmartAttributeHistory MUST return in sorted order, where newest entries are at the beginning of the list, and oldest are at the end.
-func (sr *scrutinyRepository) GetSmartAttributeHistory(ctx context.Context, wwn string, durationKey string, attributes []string) ([]measurements.Smart, error) {
+// When selectEntries is > 0, only the most recent selectEntries database entries are returned, starting from the selectEntriesOffset entry.
+// For example, with selectEntries = 5, selectEntries = 0, the most recent 5 are returned. With selectEntries = 3, selectEntries = 2, entries
+// 2 to 4 are returned (2 being the third newest, since it is zero-indexed)
+func (sr *scrutinyRepository) GetSmartAttributeHistory(ctx context.Context, wwn string, durationKey string, selectEntries int, selectEntriesOffset int, attributes []string) ([]measurements.Smart, error) {
 	// Get SMartResults from InfluxDB
 
 	//TODO: change the filter startrange to a real number.
 
 	// Get parser flux query result
 	//appConfig.GetString("web.influxdb.bucket")
-	queryStr := sr.aggregateSmartAttributesQuery(wwn, durationKey)
+	queryStr := sr.aggregateSmartAttributesQuery(wwn, durationKey, selectEntries, selectEntriesOffset, attributes)
 	log.Infoln(queryStr)
 
 	smartResults := []measurements.Smart{}
@@ -65,9 +69,6 @@ func (sr *scrutinyRepository) GetSmartAttributeHistory(ctx context.Context, wwn
 		return nil, err
 	}
 
-	//we have to sort the smartResults again, because the `union` command will return multiple 'tables' and only sort the records in each table.
-	sortSmartMeasurementsDesc(smartResults)
-
 	return smartResults, nil
 
 	//if err := device.SquashHistory(); err != nil {
@@ -99,7 +100,7 @@ func (sr *scrutinyRepository) saveDatapoint(influxWriteApi api.WriteAPIBlocking,
 	return influxWriteApi.WritePoint(ctx, p)
 }
 
-func (sr *scrutinyRepository) aggregateSmartAttributesQuery(wwn string, durationKey string) string {
+func (sr *scrutinyRepository) aggregateSmartAttributesQuery(wwn string, durationKey string, selectEntries int, selectEntriesOffset int, attributes []string) string {
 
 	/*
 
@@ -108,28 +109,34 @@ func (sr *scrutinyRepository) aggregateSmartAttributesQuery(wwn string, duration
 		|> range(start: -1w, stop: now())
 		|> filter(fn: (r) => r["_measurement"] == "smart" )
 		|> filter(fn: (r) => r["device_wwn"] == "0x5000c5002df89099" )
+		|> tail(n: 10, offset: 0)
 		|> schema.fieldsAsCols()
 
 		monthData = from(bucket: "metrics_weekly")
 		|> range(start: -1mo, stop: -1w)
 		|> filter(fn: (r) => r["_measurement"] == "smart" )
 		|> filter(fn: (r) => r["device_wwn"] == "0x5000c5002df89099" )
+		|> tail(n: 10, offset: 0)
 		|> schema.fieldsAsCols()
 
 		yearData = from(bucket: "metrics_monthly")
 		|> range(start: -1y, stop: -1mo)
 		|> filter(fn: (r) => r["_measurement"] == "smart" )
 		|> filter(fn: (r) => r["device_wwn"] == "0x5000c5002df89099" )
+		|> tail(n: 10, offset: 0)
 		|> schema.fieldsAsCols()
 
 		foreverData = from(bucket: "metrics_yearly")
 		|> range(start: -10y, stop: -1y)
 		|> filter(fn: (r) => r["_measurement"] == "smart" )
 		|> filter(fn: (r) => r["device_wwn"] == "0x5000c5002df89099" )
+		|> tail(n: 10, offset: 0)
 		|> schema.fieldsAsCols()
 
 		union(tables: [weekData, monthData, yearData, foreverData])
-		|> sort(columns: ["_time"], desc: false)
+		|> group()
+		|> sort(columns: ["_time"], desc: true)
+		|> tail(n: 6, offset: 4)
 		|> yield(name: "last")
 
 	*/
@@ -140,34 +147,57 @@ func (sr *scrutinyRepository) aggregateSmartAttributesQuery(wwn string, duration
 
 	nestedDurationKeys := sr.lookupNestedDurationKeys(durationKey)
 
-	subQueryNames := []string{}
-	for _, nestedDurationKey := range nestedDurationKeys {
-		bucketName := sr.lookupBucketName(nestedDurationKey)
-		durationRange := sr.lookupDuration(nestedDurationKey)
-
-		subQueryNames = append(subQueryNames, fmt.Sprintf(`%sData`, nestedDurationKey))
-		partialQueryStr = append(partialQueryStr, []string{
-			fmt.Sprintf(`%sData = from(bucket: "%s")`, nestedDurationKey, bucketName),
-			fmt.Sprintf(`|> range(start: %s, stop: %s)`, durationRange[0], durationRange[1]),
-			`|> filter(fn: (r) => r["_measurement"] == "smart" )`,
-			fmt.Sprintf(`|> filter(fn: (r) => r["device_wwn"] == "%s" )`, wwn),
-			"|> schema.fieldsAsCols()",
-		}...)
-	}
-
-	if len(subQueryNames) == 1 {
+	if len(nestedDurationKeys) == 1 {
 		//there's only one bucket being queried, no need to union, just aggregate the dataset and return
 		partialQueryStr = append(partialQueryStr, []string{
-			subQueryNames[0],
+			sr.generateSmartAttributesSubquery(wwn, nestedDurationKeys[0], selectEntries, selectEntriesOffset, attributes),
+			fmt.Sprintf(`%sData`, nestedDurationKeys[0]),
+			`|> sort(columns: ["_time"], desc: true)`,
 			`|> yield()`,
 		}...)
-	} else {
-		partialQueryStr = append(partialQueryStr, []string{
-			fmt.Sprintf("union(tables: [%s])", strings.Join(subQueryNames, ", ")),
-			`|> sort(columns: ["_time"], desc: false)`,
-			`|> yield(name: "last")`,
-		}...)
+		return strings.Join(partialQueryStr, "\n")
 	}
 
+	subQueries := []string{}
+	subQueryNames := []string{}
+	for _, nestedDurationKey := range nestedDurationKeys {
+		subQueryNames = append(subQueryNames, fmt.Sprintf(`%sData`, nestedDurationKey))
+		if selectEntries > 0 {
+			// We only need the last `n + offset` # of entries from each table to guarantee we can
+			// get the last `n` # of entries starting from `offset` of the union
+			subQueries = append(subQueries, sr.generateSmartAttributesSubquery(wwn, nestedDurationKey, selectEntries+selectEntriesOffset, 0, attributes))
+		} else {
+			subQueries = append(subQueries, sr.generateSmartAttributesSubquery(wwn, nestedDurationKey, 0, 0, attributes))
+		}
+	}
+	partialQueryStr = append(partialQueryStr, subQueries...)
+	partialQueryStr = append(partialQueryStr, []string{
+		fmt.Sprintf("union(tables: [%s])", strings.Join(subQueryNames, ", ")),
+		`|> group()`,
+		`|> sort(columns: ["_time"], desc: true)`,
+	}...)
+	if selectEntries > 0 {
+		partialQueryStr = append(partialQueryStr, fmt.Sprintf(`|> tail(n: %d, offset: %d)`, selectEntries, selectEntriesOffset))
+	}
+	partialQueryStr = append(partialQueryStr, `|> yield(name: "last")`)
+
+	return strings.Join(partialQueryStr, "\n")
+}
+
+func (sr *scrutinyRepository) generateSmartAttributesSubquery(wwn string, durationKey string, selectEntries int, selectEntriesOffset int, attributes []string) string {
+	bucketName := sr.lookupBucketName(durationKey)
+	durationRange := sr.lookupDuration(durationKey)
+
+	partialQueryStr := []string{
+		fmt.Sprintf(`%sData = from(bucket: "%s")`, durationKey, bucketName),
+		fmt.Sprintf(`|> range(start: %s, stop: %s)`, durationRange[0], durationRange[1]),
+		`|> filter(fn: (r) => r["_measurement"] == "smart" )`,
+		fmt.Sprintf(`|> filter(fn: (r) => r["device_wwn"] == "%s" )`, wwn),
+	}
+	if selectEntries > 0 {
+		partialQueryStr = append(partialQueryStr, fmt.Sprintf(`|> tail(n: %d, offset: %d)`, selectEntries, selectEntriesOffset))
+	}
+	partialQueryStr = append(partialQueryStr, "|> schema.fieldsAsCols()")
+
 	return strings.Join(partialQueryStr, "\n")
 }

webapp/backend/pkg/database/scrutiny_repository_migrations.go

@@ -4,9 +4,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/analogj/scrutiny/webapp/backend/pkg"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/database/migrations/m20201107210306"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/database/migrations/m20220503120000"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/database/migrations/m20220509170100"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/database/migrations/m20220716214900"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
@@ -15,8 +20,6 @@ import (
 	"github.com/influxdata/influxdb-client-go/v2/api/http"
 	log "github.com/sirupsen/logrus"
 	"gorm.io/gorm"
-	"strconv"
-	"time"
 )
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -275,6 +278,113 @@ func (sr *scrutinyRepository) Migrate(ctx context.Context) error {
 				return tx.Where("wwn = ?", "").Delete(&models.Device{}).Error
 			},
 		},
+		{
+			ID: "m20220716214900", // add settings table.
+			Migrate: func(tx *gorm.DB) error {
+
+				// adding the settings table.
+				err := tx.AutoMigrate(m20220716214900.Setting{})
+				if err != nil {
+					return err
+				}
+				//add defaults.
+
+				var defaultSettings = []m20220716214900.Setting{
+					{
+						SettingKeyName:        "theme",
+						SettingKeyDescription: "Frontend theme ('light' | 'dark' | 'system')",
+						SettingDataType:       "string",
+						SettingValueString:    "system", // options: 'light' | 'dark' | 'system'
+					},
+					{
+						SettingKeyName:        "layout",
+						SettingKeyDescription: "Frontend layout ('material')",
+						SettingDataType:       "string",
+						SettingValueString:    "material",
+					},
+					{
+						SettingKeyName:        "dashboard_display",
+						SettingKeyDescription: "Frontend device display title ('name' | 'serial_id' | 'uuid' | 'label')",
+						SettingDataType:       "string",
+						SettingValueString:    "name",
+					},
+					{
+						SettingKeyName:        "dashboard_sort",
+						SettingKeyDescription: "Frontend device sort by ('status' | 'title' | 'age')",
+						SettingDataType:       "string",
+						SettingValueString:    "status",
+					},
+					{
+						SettingKeyName:        "temperature_unit",
+						SettingKeyDescription: "Frontend temperature unit ('celsius' | 'fahrenheit')",
+						SettingDataType:       "string",
+						SettingValueString:    "celsius",
+					},
+					{
+						SettingKeyName:        "file_size_si_units",
+						SettingKeyDescription: "File size in SI units (true | false)",
+						SettingDataType:       "bool",
+						SettingValueBool:      false,
+					},
+					{
+						SettingKeyName:        "line_stroke",
+						SettingKeyDescription: "Temperature chart line stroke ('smooth' | 'straight' | 'stepline')",
+						SettingDataType:       "string",
+						SettingValueString:    "smooth",
+					},
+
+					{
+						SettingKeyName:        "metrics.notify_level",
+						SettingKeyDescription: "Determines which device status will cause a notification (fail or warn)",
+						SettingDataType:       "numeric",
+						SettingValueNumeric:   int(pkg.MetricsNotifyLevelFail), // options: 'fail' or 'warn'
+					},
+					{
+						SettingKeyName:        "metrics.status_filter_attributes",
+						SettingKeyDescription: "Determines which attributes should impact device status",
+						SettingDataType:       "numeric",
+						SettingValueNumeric:   int(pkg.MetricsStatusFilterAttributesAll), // options: 'all' or  'critical'
+					},
+					{
+						SettingKeyName:        "metrics.status_threshold",
+						SettingKeyDescription: "Determines which threshold should impact device status",
+						SettingDataType:       "numeric",
+						SettingValueNumeric:   int(pkg.MetricsStatusThresholdBoth), // options: 'scrutiny', 'smart', 'both'
+					},
+				}
+				return tx.Create(&defaultSettings).Error
+			},
+		},
+		{
+			ID: "m20221115214900", // add line_stroke setting.
+			Migrate: func(tx *gorm.DB) error {
+				//add line_stroke setting default.
+				var defaultSettings = []m20220716214900.Setting{
+					{
+						SettingKeyName:        "line_stroke",
+						SettingKeyDescription: "Temperature chart line stroke ('smooth' | 'straight' | 'stepline')",
+						SettingDataType:       "string",
+						SettingValueString:    "smooth",
+					},
+				}
+				return tx.Create(&defaultSettings).Error
+			},
+		},
+		{
+			ID: "m20231123123300", // add repeat_notifications setting.
+			Migrate: func(tx *gorm.DB) error {
+				//add repeat_notifications setting default.
+				var defaultSettings = []m20220716214900.Setting{
+					{
+						SettingKeyName:        "metrics.repeat_notifications",
+						SettingKeyDescription: "Whether to repeat all notifications or just when values change (true | false)",
+						SettingDataType:       "bool",
+						SettingValueBool:      true,
+					},
+				}
+				return tx.Create(&defaultSettings).Error
+			},
+		},
 	})
 
 	if err := m.Migrate(); err != nil {
@@ -282,6 +392,30 @@ func (sr *scrutinyRepository) Migrate(ctx context.Context) error {
 		return err
 	}
 	sr.logger.Infoln("Database migration completed successfully")
+
+	//these migrations cannot be done within a transaction, so they are done as a separate group, with `UseTransaction = false`
+	sr.logger.Infoln("SQLite global configuration migrations starting. Please wait....")
+	globalMigrateOptions := gormigrate.DefaultOptions
+	globalMigrateOptions.UseTransaction = false
+	gm := gormigrate.New(sr.gormClient, globalMigrateOptions, []*gormigrate.Migration{
+		{
+			ID: "g20220802211500",
+			Migrate: func(tx *gorm.DB) error {
+				//shrink the Database (maybe necessary after 20220503113100)
+				if err := tx.Exec("VACUUM;").Error; err != nil {
+					return err
+				}
+				return nil
+			},
+		},
+	})
+
+	if err := gm.Migrate(); err != nil {
+		sr.logger.Errorf("SQLite global configuration migrations failed with error. \n Please open a github issue at https://github.com/AnalogJ/scrutiny and attach a copy of your scrutiny.db file. \n %v", err)
+		return err
+	}
+	sr.logger.Infoln("SQLite global configuration migrations completed successfully")
+
 	return nil
 }
 

webapp/backend/pkg/database/scrutiny_repository_settings.go

@@ -0,0 +1,85 @@
+package database
+
+import (
+	"context"
+	"fmt"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
+	"github.com/mitchellh/mapstructure"
+	"strings"
+)
+
+// LoadSettings will retrieve settings from the database, store them in the AppConfig object, and return a Settings struct
+func (sr *scrutinyRepository) LoadSettings(ctx context.Context) (*models.Settings, error) {
+	settingsEntries := []models.SettingEntry{}
+	if err := sr.gormClient.WithContext(ctx).Find(&settingsEntries).Error; err != nil {
+		return nil, fmt.Errorf("Could not get settings from DB: %v", err)
+	}
+
+	// store retrieved settings in the AppConfig obj
+	for _, settingsEntry := range settingsEntries {
+		configKey := fmt.Sprintf("%s.%s", config.DB_USER_SETTINGS_SUBKEY, settingsEntry.SettingKeyName)
+
+		if settingsEntry.SettingDataType == "numeric" {
+			sr.appConfig.SetDefault(configKey, settingsEntry.SettingValueNumeric)
+		} else if settingsEntry.SettingDataType == "string" {
+			sr.appConfig.SetDefault(configKey, settingsEntry.SettingValueString)
+		} else if settingsEntry.SettingDataType == "bool" {
+			sr.appConfig.SetDefault(configKey, settingsEntry.SettingValueBool)
+		}
+	}
+
+	// unmarshal the dbsetting object data to a settings object.
+	var settings models.Settings
+	err := sr.appConfig.UnmarshalKey(config.DB_USER_SETTINGS_SUBKEY, &settings)
+	if err != nil {
+		return nil, err
+	}
+	return &settings, nil
+}
+
+// testing
+// curl -d '{"metrics": { "notify_level": 5, "status_filter_attributes": 5, "status_threshold": 5 }}' -H "Content-Type: application/json" -X POST http://localhost:9090/api/settings
+// SaveSettings will update settings in AppConfig object, then save the settings to the database.
+func (sr *scrutinyRepository) SaveSettings(ctx context.Context, settings models.Settings) error {
+	//save the entries to the appconfig
+	settingsMap := &map[string]interface{}{}
+	err := mapstructure.Decode(settings, &settingsMap)
+	if err != nil {
+		return err
+	}
+	settingsWrapperMap := map[string]interface{}{}
+	settingsWrapperMap[config.DB_USER_SETTINGS_SUBKEY] = *settingsMap
+	err = sr.appConfig.MergeConfigMap(settingsWrapperMap)
+	if err != nil {
+		return err
+	}
+	sr.logger.Debugf("after merge settings: %v", sr.appConfig.AllSettings())
+	//retrieve current settings from the database
+	settingsEntries := []models.SettingEntry{}
+	if err := sr.gormClient.WithContext(ctx).Find(&settingsEntries).Error; err != nil {
+		return fmt.Errorf("Could not get settings from DB: %v", err)
+	}
+
+	//update settingsEntries
+	for ndx, settingsEntry := range settingsEntries {
+		configKey := fmt.Sprintf("%s.%s", config.DB_USER_SETTINGS_SUBKEY, strings.ToLower(settingsEntry.SettingKeyName))
+
+		if settingsEntry.SettingDataType == "numeric" {
+			settingsEntries[ndx].SettingValueNumeric = sr.appConfig.GetInt(configKey)
+		} else if settingsEntry.SettingDataType == "string" {
+			settingsEntries[ndx].SettingValueString = sr.appConfig.GetString(configKey)
+		} else if settingsEntry.SettingDataType == "bool" {
+			settingsEntries[ndx].SettingValueBool = sr.appConfig.GetBool(configKey)
+		}
+
+		// store in database.
+		//TODO: this should be `sr.gormClient.Updates(&settingsEntries).Error`
+		err := sr.gormClient.Model(&models.SettingEntry{}).Where([]uint{settingsEntry.ID}).Select("setting_value_numeric", "setting_value_string", "setting_value_bool").Updates(settingsEntries[ndx]).Error
+		if err != nil {
+			return err
+		}
+
+	}
+	return nil
+}

webapp/backend/pkg/database/scrutiny_repository_temperature.go

@@ -17,6 +17,10 @@ func (sr *scrutinyRepository) SaveSmartTemperature(ctx context.Context, wwn stri
 	if len(collectorSmartData.AtaSctTemperatureHistory.Table) > 0 {
 
 		for ndx, temp := range collectorSmartData.AtaSctTemperatureHistory.Table {
+			//temp value may be null, we must skip/ignore them. See #393
+			if temp == 0 {
+				continue
+			}
 
 			minutesOffset := collectorSmartData.AtaSctTemperatureHistory.LoggingIntervalMinutes * int64(ndx) * 60
 			smartTemp := measurements.SmartTemperature{

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

@@ -27,14 +27,11 @@ type SmartInfo struct {
 		Oui uint64 `json:"oui"`
 		ID  uint64 `json:"id"`
 	} `json:"wwn"`
-	FirmwareVersion string `json:"firmware_version"`
-	UserCapacity    struct {
-		Blocks int64 `json:"blocks"`
-		Bytes  int64 `json:"bytes"`
-	} `json:"user_capacity"`
-	LogicalBlockSize  int `json:"logical_block_size"`
-	PhysicalBlockSize int `json:"physical_block_size"`
-	RotationRate      int `json:"rotation_rate"`
+	FirmwareVersion   string       `json:"firmware_version"`
+	UserCapacity      UserCapacity `json:"user_capacity"`
+	LogicalBlockSize  int          `json:"logical_block_size"`
+	PhysicalBlockSize int          `json:"physical_block_size"`
+	RotationRate      int          `json:"rotation_rate"`
 	FormFactor        struct {
 		AtaValue int    `json:"ata_value"`
 		Name     string `json:"name"`
@@ -210,9 +207,10 @@ type SmartInfo struct {
 		ID          int `json:"id"`
 		SubsystemID int `json:"subsystem_id"`
 	} `json:"nvme_pci_vendor"`
-	NvmeIeeeOuiIdentifier  int `json:"nvme_ieee_oui_identifier"`
-	NvmeControllerID       int `json:"nvme_controller_id"`
-	NvmeNumberOfNamespaces int `json:"nvme_number_of_namespaces"`
+	NvmeIeeeOuiIdentifier  int   `json:"nvme_ieee_oui_identifier"`
+	NvmeTotalCapacity      int64 `json:"nvme_total_capacity"`
+	NvmeControllerID       int   `json:"nvme_controller_id"`
+	NvmeNumberOfNamespaces int   `json:"nvme_number_of_namespaces"`
 	NvmeNamespaces         []struct {
 		ID   int `json:"id"`
 		Size struct {
@@ -239,7 +237,23 @@ type SmartInfo struct {
 	ScsiErrorCounterLog ScsiErrorCounterLog `json:"scsi_error_counter_log"`
 }
 
-//Primary Attribute Structs
+// Capacity finds the total capacity of the device in bytes, or 0 if unknown.
+func (s *SmartInfo) Capacity() int64 {
+	switch {
+	case s.NvmeTotalCapacity > 0:
+		return s.NvmeTotalCapacity
+	case s.UserCapacity.Bytes > 0:
+		return s.UserCapacity.Bytes
+	}
+	return 0
+}
+
+type UserCapacity struct {
+	Blocks int64 `json:"blocks"`
+	Bytes  int64 `json:"bytes"`
+}
+
+// Primary Attribute Structs
 type AtaSmartAttributesTableItem struct {
 	ID         int    `json:"id"`
 	Name       string `json:"name"`

webapp/backend/pkg/models/collector/smart_test.go

@@ -0,0 +1,33 @@
+package collector
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSmartInfo_Capacity(t *testing.T) {
+	t.Run("should report nvme capacity", func(t *testing.T) {
+		smartInfo := SmartInfo{
+			UserCapacity: UserCapacity{
+				Bytes: 1234,
+			},
+			NvmeTotalCapacity: 5678,
+		}
+		assert.Equal(t, int64(5678), smartInfo.Capacity())
+	})
+
+	t.Run("should report user capacity", func(t *testing.T) {
+		smartInfo := SmartInfo{
+			UserCapacity: UserCapacity{
+				Bytes: 1234,
+			},
+		}
+		assert.Equal(t, int64(1234), smartInfo.Capacity())
+	})
+
+	t.Run("should report 0 for unknown capacities", func(t *testing.T) {
+		var smartInfo SmartInfo
+		assert.Zero(t, smartInfo.Capacity())
+	})
+}

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

@@ -2,10 +2,11 @@ package measurements
 
 import (
 	"fmt"
-	"github.com/analogj/scrutiny/webapp/backend/pkg"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
 	"strconv"
 	"strings"
+
+	"github.com/analogj/scrutiny/webapp/backend/pkg"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
 )
 
 type SmartAtaAttribute struct {
@@ -24,6 +25,10 @@ type SmartAtaAttribute struct {
 	FailureRate      float64             `json:"failure_rate,omitempty"`
 }
 
+func (sa *SmartAtaAttribute) GetTransformedValue() int64 {
+	return sa.TransformedValue
+}
+
 func (sa *SmartAtaAttribute) GetStatus() pkg.AttributeStatus {
 	return sa.Status
 }

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

@@ -6,4 +6,5 @@ type SmartAttribute interface {
 	Flatten() (fields map[string]interface{})
 	Inflate(key string, val interface{})
 	GetStatus() pkg.AttributeStatus
+	GetTransformedValue() int64
 }

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

@@ -2,9 +2,10 @@ package measurements
 
 import (
 	"fmt"
+	"strings"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
-	"strings"
 )
 
 type SmartNvmeAttribute struct {
@@ -18,6 +19,10 @@ type SmartNvmeAttribute struct {
 	FailureRate      float64             `json:"failure_rate,omitempty"`
 }
 
+func (sa *SmartNvmeAttribute) GetTransformedValue() int64 {
+	return sa.TransformedValue
+}
+
 func (sa *SmartNvmeAttribute) GetStatus() pkg.AttributeStatus {
 	return sa.Status
 }

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

@@ -2,9 +2,10 @@ package measurements
 
 import (
 	"fmt"
+	"strings"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
-	"strings"
 )
 
 type SmartScsiAttribute struct {
@@ -18,6 +19,10 @@ type SmartScsiAttribute struct {
 	FailureRate      float64             `json:"failure_rate,omitempty"`
 }
 
+func (sa *SmartScsiAttribute) GetTransformedValue() int64 {
+	return sa.TransformedValue
+}
+
 func (sa *SmartScsiAttribute) GetStatus() pkg.AttributeStatus {
 	return sa.Status
 }

webapp/backend/pkg/models/setting.go

@@ -1,5 +0,0 @@
-package models
-
-// Temperature Format
-// Date Format
-// Device History window

webapp/backend/pkg/models/setting_entry.go

@@ -0,0 +1,23 @@
+package models
+
+import (
+	"gorm.io/gorm"
+)
+
+// SettingEntry matches a setting row in the database
+type SettingEntry struct {
+	//GORM attributes, see: http://gorm.io/docs/conventions.html
+	gorm.Model
+
+	SettingKeyName        string `json:"setting_key_name" gorm:"unique;not null"`
+	SettingKeyDescription string `json:"setting_key_description"`
+	SettingDataType       string `json:"setting_data_type"`
+
+	SettingValueNumeric int    `json:"setting_value_numeric"`
+	SettingValueString  string `json:"setting_value_string"`
+	SettingValueBool    bool   `json:"setting_value_bool"`
+}
+
+func (s SettingEntry) TableName() string {
+	return "settings"
+}

webapp/backend/pkg/models/settings.go

@@ -0,0 +1,25 @@
+package models
+
+// Settings is made up of parsed SettingEntry objects retrieved from the database
+//type Settings struct {
+//	MetricsNotifyLevel            pkg.MetricsNotifyLevel            `json:"metrics.notify.level" mapstructure:"metrics.notify.level"`
+//	MetricsStatusFilterAttributes pkg.MetricsStatusFilterAttributes `json:"metrics.status.filter_attributes" mapstructure:"metrics.status.filter_attributes"`
+//	MetricsStatusThreshold        pkg.MetricsStatusThreshold        `json:"metrics.status.threshold" mapstructure:"metrics.status.threshold"`
+//}
+
+type Settings struct {
+	Theme            string `json:"theme" mapstructure:"theme"`
+	Layout           string `json:"layout" mapstructure:"layout"`
+	DashboardDisplay string `json:"dashboard_display" mapstructure:"dashboard_display"`
+	DashboardSort    string `json:"dashboard_sort" mapstructure:"dashboard_sort"`
+	TemperatureUnit  string `json:"temperature_unit" mapstructure:"temperature_unit"`
+	FileSizeSIUnits  bool   `json:"file_size_si_units" mapstructure:"file_size_si_units"`
+	LineStroke       string `json:"line_stroke" mapstructure:"line_stroke"`
+
+	Metrics struct {
+		NotifyLevel            int  `json:"notify_level" mapstructure:"notify_level"`
+		StatusFilterAttributes int  `json:"status_filter_attributes" mapstructure:"status_filter_attributes"`
+		StatusThreshold        int  `json:"status_threshold" mapstructure:"status_threshold"`
+		RepeatNotifications    bool `json:"repeat_notifications" mapstructure:"repeat_notifications"`
+	} `json:"metrics" mapstructure:"metrics"`
+}

webapp/backend/pkg/models/testdata/helper.go

@@ -4,13 +4,14 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
 	"io"
 	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
 	"time"
+
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
 )
 
 func main() {
@@ -32,7 +33,7 @@ func main() {
 		log.Fatalf("ERROR %v", err)
 	}
 	defer file.Close()
-	_, err = SendPostRequest("http://localhost:9090/api/devices/register", file)
+	_, err = SendPostRequest("http://localhost:8080/api/devices/register", file)
 	if err != nil {
 		log.Fatalf("ERROR %v", err)
 	}
@@ -46,7 +47,7 @@ func main() {
 					log.Fatalf("ERROR %v", err)
 				}
 
-				_, err = SendPostRequest(fmt.Sprintf("http://localhost:9090/api/device/%s/smart", diskId), smartDataReader)
+				_, err = SendPostRequest(fmt.Sprintf("http://localhost:8080/api/device/%s/smart", diskId), smartDataReader)
 				if err != nil {
 					log.Fatalf("ERROR %v", err)
 				}

webapp/backend/pkg/notify/notify.go

@@ -5,22 +5,25 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/analogj/go-util/utils"
-	"github.com/analogj/scrutiny/webapp/backend/pkg"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
-	"github.com/containrrr/shoutrrr"
-	shoutrrrTypes "github.com/containrrr/shoutrrr/pkg/types"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/sync/errgroup"
 	"net/http"
 	"net/url"
 	"os"
 	"strconv"
 	"strings"
 	"time"
+
+	"github.com/analogj/go-util/utils"
+	"github.com/analogj/scrutiny/webapp/backend/pkg"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
+	"github.com/containrrr/shoutrrr"
+	shoutrrrTypes "github.com/containrrr/shoutrrr/pkg/types"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"golang.org/x/sync/errgroup"
 )
 
 const NotifyFailureTypeEmailTest = "EmailTest"
@@ -29,20 +32,22 @@ const NotifyFailureTypeSmartFailure = "SmartFailure"
 const NotifyFailureTypeScrutinyFailure = "ScrutinyFailure"
 
 // ShouldNotify check if the error Message should be filtered (level mismatch or filtered_attributes)
-func ShouldNotify(device models.Device, smartAttrs measurements.Smart, notifyLevel string, notifyFilterAttributes string) bool {
+func ShouldNotify(logger logrus.FieldLogger, device models.Device, smartAttrs measurements.Smart, statusThreshold pkg.MetricsStatusThreshold, statusFilterAttributes pkg.MetricsStatusFilterAttributes, repeatNotifications bool, c *gin.Context, deviceRepo database.DeviceRepo) bool {
 	// 1. check if the device is healthy
 	if device.DeviceStatus == pkg.DeviceStatusPassed {
 		return false
 	}
 
+	//TODO: cannot check for warning notifyLevel yet.
+
 	// setup constants for comparison
 	var requiredDeviceStatus pkg.DeviceStatus
 	var requiredAttrStatus pkg.AttributeStatus
-	if notifyLevel == pkg.NotifyLevelFail {
+	if statusThreshold == pkg.MetricsStatusThresholdBoth {
 		// either scrutiny or smart failures should trigger an email
 		requiredDeviceStatus = pkg.DeviceStatusSet(pkg.DeviceStatusFailedSmart, pkg.DeviceStatusFailedScrutiny)
 		requiredAttrStatus = pkg.AttributeStatusSet(pkg.AttributeStatusFailedSmart, pkg.AttributeStatusFailedScrutiny)
-	} else if notifyLevel == pkg.NotifyLevelFailSmart {
+	} else if statusThreshold == pkg.MetricsStatusThresholdSmart {
 		//only smart failures
 		requiredDeviceStatus = pkg.DeviceStatusFailedSmart
 		requiredAttrStatus = pkg.AttributeStatusFailedSmart
@@ -51,60 +56,78 @@ func ShouldNotify(device models.Device, smartAttrs measurements.Smart, notifyLev
 		requiredAttrStatus = pkg.AttributeStatusFailedScrutiny
 	}
 
-	// 2. check if the attributes that are failing should be filtered (non-critical)
-	// 3. for any unfiltered attribute, store the failure reason (Smart or Scrutiny)
-	if notifyFilterAttributes == pkg.NotifyFilterAttributesCritical {
-		hasFailingCriticalAttr := false
-		var statusFailingCrtiticalAttr pkg.AttributeStatus
+	// This is the only case where individual attributes need not be considered
+	if statusFilterAttributes == pkg.MetricsStatusFilterAttributesAll && repeatNotifications {
+		return pkg.DeviceStatusHas(device.DeviceStatus, requiredDeviceStatus)
+	}
 
-		for attrId, attrData := range smartAttrs.Attributes {
-			//find failing attribute
-			if attrData.GetStatus() == pkg.AttributeStatusPassed {
-				continue //skip all passing attributes
-			}
+	var failingAttributes []string
+	// Loop through the attributes to find the failing ones
+	for attrId, attrData := range smartAttrs.Attributes {
+		var status pkg.AttributeStatus = attrData.GetStatus()
+		// Skip over passing attributes
+		if status == pkg.AttributeStatusPassed {
+			continue
+		}
 
-			// merge the status's of all critical attributes
-			statusFailingCrtiticalAttr = pkg.AttributeStatusSet(statusFailingCrtiticalAttr, attrData.GetStatus())
-
-			//found a failing attribute, see if its critical
-			if device.IsScsi() && thresholds.ScsiMetadata[attrId].Critical {
-				hasFailingCriticalAttr = true
-			} else if device.IsNvme() && thresholds.NmveMetadata[attrId].Critical {
-				hasFailingCriticalAttr = true
+		// If the user only wants to consider critical attributes, we have to check
+		// if the not-passing attribute is critical or not
+		if statusFilterAttributes == pkg.MetricsStatusFilterAttributesCritical {
+			critical := false
+			if device.IsScsi() {
+				critical = thresholds.ScsiMetadata[attrId].Critical
+			} else if device.IsNvme() {
+				critical = thresholds.NmveMetadata[attrId].Critical
 			} else {
 				//this is ATA
 				attrIdInt, err := strconv.Atoi(attrId)
 				if err != nil {
 					continue
 				}
-				if thresholds.AtaMetadata[attrIdInt].Critical {
-					hasFailingCriticalAttr = true
-				}
+				critical = thresholds.AtaMetadata[attrIdInt].Critical
+			}
+			// Skip non-critical, non-passing attributes when this setting is on
+			if !critical {
+				continue
 			}
-
 		}
 
-		if !hasFailingCriticalAttr {
-			//no critical attributes are failing, and notifyFilterAttributes == "critical"
-			return false
-		} else {
-			// check if any of the critical attributes have a status that we're looking for
-			return pkg.AttributeStatusHas(statusFailingCrtiticalAttr, requiredAttrStatus)
-		}
-
-	} else {
-		// 2. SKIP - we are processing every attribute.
-		// 3. check if the device failure level matches the wanted failure level.
-		return pkg.DeviceStatusHas(device.DeviceStatus, requiredDeviceStatus)
+		// Record any attribute that doesn't get skipped by the above two checks
+		failingAttributes = append(failingAttributes, attrId)
 	}
+
+	// If the user doesn't want repeated notifications when the failing value doesn't change, we need to get the last value from the db
+	var lastPoints []measurements.Smart
+	var err error
+	if !repeatNotifications {
+		lastPoints, err = deviceRepo.GetSmartAttributeHistory(c, c.Param("wwn"), database.DURATION_KEY_FOREVER, 1, 1, failingAttributes)
+		if err == nil || len(lastPoints) < 1 {
+			logger.Warningln("Could not get the most recent data points from the database. This is expected to happen only if this is the very first submission of data for the device.")
+		}
+	}
+	for _, attrId := range failingAttributes {
+		attrStatus := smartAttrs.Attributes[attrId].GetStatus()
+		if pkg.AttributeStatusHas(attrStatus, requiredAttrStatus) {
+			if repeatNotifications {
+				return true
+			}
+			// This is checked again here to avoid repeating the entire for loop in the check above.
+			// Probably unnoticeably worse performance, but cleaner code.
+			if err != nil || len(lastPoints) < 1 || lastPoints[0].Attributes[attrId].GetTransformedValue() != smartAttrs.Attributes[attrId].GetTransformedValue() {
+				return true
+			}
+		}
+	}
+	return false
 }
 
-// TODO: include host and/or user label for device.
+// TODO: include user label for device.
 type Payload struct {
-	DeviceType   string `json:"device_type"`   //ATA/SCSI/NVMe
-	DeviceName   string `json:"device_name"`   //dev/sda
-	DeviceSerial string `json:"device_serial"` //WDDJ324KSO
-	Test         bool   `json:"test"`          // false
+	HostId       string `json:"host_id,omitempty"` //host id (optional)
+	DeviceType   string `json:"device_type"`       //ATA/SCSI/NVMe
+	DeviceName   string `json:"device_name"`       //dev/sda
+	DeviceSerial string `json:"device_serial"`     //WDDJ324KSO
+	Test         bool   `json:"test"`              // false
 
 	//private, populated during init (marked as Public for JSON serialization)
 	Date        string `json:"date"`         //populated by Send function.
@@ -113,8 +136,9 @@ type Payload struct {
 	Message     string `json:"message"`
 }
 
-func NewPayload(device models.Device, test bool) Payload {
+func NewPayload(device models.Device, test bool, currentTime ...time.Time) Payload {
 	payload := Payload{
+		HostId:       strings.TrimSpace(device.HostId),
 		DeviceType:   device.DeviceType,
 		DeviceName:   device.DeviceName,
 		DeviceSerial: device.SerialNumber,
@@ -122,7 +146,13 @@ func NewPayload(device models.Device, test bool) Payload {
 	}
 
 	//validate that the Payload is populated
-	sendDate := time.Now()
+	var sendDate time.Time
+	if currentTime != nil && len(currentTime) > 0 {
+		sendDate = currentTime[0]
+	} else {
+		sendDate = time.Now()
+	}
+
 	payload.Date = sendDate.Format(time.RFC3339)
 	payload.FailureType = payload.GenerateFailureType(device.DeviceStatus)
 	payload.Subject = payload.GenerateSubject()
@@ -146,25 +176,39 @@ func (p *Payload) GenerateFailureType(deviceStatus pkg.DeviceStatus) string {
 
 func (p *Payload) GenerateSubject() string {
 	//generate a detailed failure message
-	return fmt.Sprintf("Scrutiny SMART error (%s) detected on device: %s", p.FailureType, p.DeviceName)
+	var subject string
+	if len(p.HostId) > 0 {
+		subject = fmt.Sprintf("Scrutiny SMART error (%s) detected on [host]device: [%s]%s", p.FailureType, p.HostId, p.DeviceName)
+	} else {
+		subject = fmt.Sprintf("Scrutiny SMART error (%s) detected on device: %s", p.FailureType, p.DeviceName)
+	}
+	return subject
 }
 
 func (p *Payload) GenerateMessage() string {
 	//generate a detailed failure message
-	message := fmt.Sprintf(
-		`Scrutiny SMART error notification for device: %s
-Failure Type: %s
-Device Name: %s
-Device Serial: %s
-Device Type: %s
 
-Date: %s`, p.DeviceName, p.FailureType, p.DeviceName, p.DeviceSerial, p.DeviceType, p.Date)
+	messageParts := []string{}
 
-	if p.Test {
-		message = "TEST NOTIFICATION:\n" + message
+	messageParts = append(messageParts, fmt.Sprintf("Scrutiny SMART error notification for device: %s", p.DeviceName))
+	if len(p.HostId) > 0 {
+		messageParts = append(messageParts, fmt.Sprintf("Host Id: %s", p.HostId))
 	}
 
-	return message
+	messageParts = append(messageParts,
+		fmt.Sprintf("Failure Type: %s", p.FailureType),
+		fmt.Sprintf("Device Name: %s", p.DeviceName),
+		fmt.Sprintf("Device Serial: %s", p.DeviceSerial),
+		fmt.Sprintf("Device Type: %s", p.DeviceType),
+		"",
+		fmt.Sprintf("Date: %s", p.Date),
+	)
+
+	if p.Test {
+		messageParts = append([]string{"TEST NOTIFICATION:"}, messageParts...)
+	}
+
+	return strings.Join(messageParts, "\n")
 }
 
 func New(logger logrus.FieldLogger, appconfig config.Interface, device models.Device, test bool) Notify {
@@ -197,7 +241,7 @@ func (n *Notify) Send() error {
 	notifyScripts := []string{}
 	notifyShoutrrr := []string{}
 
-	for ndx, _ := range configUrls {
+	for ndx := range configUrls {
 		if strings.HasPrefix(configUrls[ndx], "https://") || strings.HasPrefix(configUrls[ndx], "http://") {
 			notifyWebhooks = append(notifyWebhooks, configUrls[ndx])
 		} else if strings.HasPrefix(configUrls[ndx], "script://") {
@@ -285,6 +329,9 @@ func (n *Notify) SendScriptNotification(scriptUrl string) error {
 	copyEnv = append(copyEnv, fmt.Sprintf("SCRUTINY_DEVICE_TYPE=%s", n.Payload.DeviceType))
 	copyEnv = append(copyEnv, fmt.Sprintf("SCRUTINY_DEVICE_SERIAL=%s", n.Payload.DeviceSerial))
 	copyEnv = append(copyEnv, fmt.Sprintf("SCRUTINY_MESSAGE=%s", n.Payload.Message))
+	if len(n.Payload.HostId) > 0 {
+		copyEnv = append(copyEnv, fmt.Sprintf("SCRUTINY_HOST_ID=%s", n.Payload.HostId))
+	}
 	err := utils.CmdExec(scriptPath, []string{}, "", copyEnv, "")
 	if err != nil {
 		n.Logger.Errorf("An error occurred while executing script %s: %v", scriptPath, err)
@@ -359,6 +406,9 @@ func (n *Notify) GenShoutrrrNotificationParams(shoutrrrUrl string) (string, *sho
 	case "join":
 		(*params)["title"] = subject
 		(*params)["icon"] = logoUrl
+	case "ntfy":
+		(*params)["title"] = subject
+		(*params)["icon"] = logoUrl
 	case "opsgenie":
 		(*params)["title"] = subject
 	case "pushbullet":

webapp/backend/pkg/notify/notify_test.go

@@ -1,11 +1,20 @@
 package notify
 
 import (
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
+	mock_database "github.com/analogj/scrutiny/webapp/backend/pkg/database/mock"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/models/measurements"
+	"github.com/gin-gonic/gin"
+	"github.com/golang/mock/gomock"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/require"
-	"testing"
 )
 
 func TestShouldNotify_MustSkipPassingDevices(t *testing.T) {
@@ -15,56 +24,65 @@ func TestShouldNotify_MustSkipPassingDevices(t *testing.T) {
 		DeviceStatus: pkg.DeviceStatusPassed,
 	}
 	smartAttrs := measurements.Smart{}
-	notifyLevel := pkg.NotifyLevelFail
-	notifyFilterAttributes := pkg.NotifyFilterAttributesAll
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
 
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 	//assert
-	require.False(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.False(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyLevelFail_FailingSmartDevice(t *testing.T) {
+func TestShouldNotify_MetricsStatusThresholdBoth_FailingSmartDevice(t *testing.T) {
+	t.Parallel()
+	//setupD
+	device := models.Device{
+		DeviceStatus: pkg.DeviceStatusFailedSmart,
+	}
+	smartAttrs := measurements.Smart{}
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
+	//assert
+	require.True(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
+}
+
+func TestShouldNotify_MetricsStatusThresholdSmart_FailingSmartDevice(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
 		DeviceStatus: pkg.DeviceStatusFailedSmart,
 	}
 	smartAttrs := measurements.Smart{}
-	notifyLevel := pkg.NotifyLevelFail
-	notifyFilterAttributes := pkg.NotifyFilterAttributesAll
-
+	statusThreshold := pkg.MetricsStatusThresholdSmart
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 	//assert
-	require.True(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.True(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyLevelFailSmart_FailingSmartDevice(t *testing.T) {
+func TestShouldNotify_MetricsStatusThresholdScrutiny_FailingSmartDevice(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
 		DeviceStatus: pkg.DeviceStatusFailedSmart,
 	}
 	smartAttrs := measurements.Smart{}
-	notifyLevel := pkg.NotifyLevelFailSmart
-	notifyFilterAttributes := pkg.NotifyFilterAttributesAll
-
+	statusThreshold := pkg.MetricsStatusThresholdScrutiny
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 	//assert
-	require.True(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.False(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyLevelFailScrutiny_FailingSmartDevice(t *testing.T) {
-	t.Parallel()
-	//setup
-	device := models.Device{
-		DeviceStatus: pkg.DeviceStatusFailedSmart,
-	}
-	smartAttrs := measurements.Smart{}
-	notifyLevel := pkg.NotifyLevelFailScrutiny
-	notifyFilterAttributes := pkg.NotifyFilterAttributesAll
-
-	//assert
-	require.False(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
-}
-
-func TestShouldNotify_NotifyFilterAttributesCritical_WithCriticalAttrs(t *testing.T) {
+func TestShouldNotify_MetricsStatusFilterAttributesCritical_WithCriticalAttrs(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
@@ -75,14 +93,17 @@ func TestShouldNotify_NotifyFilterAttributesCritical_WithCriticalAttrs(t *testin
 			Status: pkg.AttributeStatusFailedSmart,
 		},
 	}}
-	notifyLevel := pkg.NotifyLevelFail
-	notifyFilterAttributes := pkg.NotifyFilterAttributesCritical
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesCritical
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 
 	//assert
-	require.True(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.True(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyFilterAttributesCritical_WithMultipleCriticalAttrs(t *testing.T) {
+func TestShouldNotify_MetricsStatusFilterAttributesCritical_WithMultipleCriticalAttrs(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
@@ -96,14 +117,17 @@ func TestShouldNotify_NotifyFilterAttributesCritical_WithMultipleCriticalAttrs(t
 			Status: pkg.AttributeStatusFailedScrutiny,
 		},
 	}}
-	notifyLevel := pkg.NotifyLevelFail
-	notifyFilterAttributes := pkg.NotifyFilterAttributesCritical
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesCritical
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 
 	//assert
-	require.True(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.True(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyFilterAttributesCritical_WithNoCriticalAttrs(t *testing.T) {
+func TestShouldNotify_MetricsStatusFilterAttributesCritical_WithNoCriticalAttrs(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
@@ -114,14 +138,17 @@ func TestShouldNotify_NotifyFilterAttributesCritical_WithNoCriticalAttrs(t *test
 			Status: pkg.AttributeStatusFailedSmart,
 		},
 	}}
-	notifyLevel := pkg.NotifyLevelFail
-	notifyFilterAttributes := pkg.NotifyFilterAttributesCritical
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesCritical
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 
 	//assert
-	require.False(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.False(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyFilterAttributesCritical_WithNoFailingCriticalAttrs(t *testing.T) {
+func TestShouldNotify_MetricsStatusFilterAttributesCritical_WithNoFailingCriticalAttrs(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
@@ -132,14 +159,17 @@ func TestShouldNotify_NotifyFilterAttributesCritical_WithNoFailingCriticalAttrs(
 			Status: pkg.AttributeStatusPassed,
 		},
 	}}
-	notifyLevel := pkg.NotifyLevelFail
-	notifyFilterAttributes := pkg.NotifyFilterAttributesCritical
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesCritical
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 
 	//assert
-	require.False(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.False(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
 }
 
-func TestShouldNotify_NotifyFilterAttributesCritical_NotifyLevelFailSmart_WithCriticalAttrsFailingScrutiny(t *testing.T) {
+func TestShouldNotify_MetricsStatusFilterAttributesCritical_MetricsStatusThresholdSmart_WithCriticalAttrsFailingScrutiny(t *testing.T) {
 	t.Parallel()
 	//setup
 	device := models.Device{
@@ -153,9 +183,158 @@ func TestShouldNotify_NotifyFilterAttributesCritical_NotifyLevelFailSmart_WithCr
 			Status: pkg.AttributeStatusFailedScrutiny,
 		},
 	}}
-	notifyLevel := pkg.NotifyLevelFailSmart
-	notifyFilterAttributes := pkg.NotifyFilterAttributesCritical
+	statusThreshold := pkg.MetricsStatusThresholdSmart
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesCritical
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
 
 	//assert
-	require.False(t, ShouldNotify(device, smartAttrs, notifyLevel, notifyFilterAttributes))
+	require.False(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, true, &gin.Context{}, fakeDatabase))
+}
+func TestShouldNotify_NoRepeat_DatabaseFailure(t *testing.T) {
+	t.Parallel()
+	//setup
+	device := models.Device{
+		DeviceStatus: pkg.DeviceStatusFailedScrutiny,
+	}
+	smartAttrs := measurements.Smart{Attributes: map[string]measurements.SmartAttribute{
+		"5": &measurements.SmartAtaAttribute{
+			Status: pkg.AttributeStatusFailedScrutiny,
+		},
+	}}
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
+	fakeDatabase.EXPECT().GetSmartAttributeHistory(&gin.Context{}, "", database.DURATION_KEY_FOREVER, 1, 1, []string{"5"}).Return([]measurements.Smart{}, errors.New("")).Times(1)
+
+	//assert
+	require.True(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, false, &gin.Context{}, fakeDatabase))
+}
+
+func TestShouldNotify_NoRepeat_NoDatabaseData(t *testing.T) {
+	t.Parallel()
+	//setup
+	device := models.Device{
+		DeviceStatus: pkg.DeviceStatusFailedScrutiny,
+	}
+	smartAttrs := measurements.Smart{Attributes: map[string]measurements.SmartAttribute{
+		"5": &measurements.SmartAtaAttribute{
+			Status: pkg.AttributeStatusFailedScrutiny,
+		},
+	}}
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
+	fakeDatabase.EXPECT().GetSmartAttributeHistory(&gin.Context{}, "", database.DURATION_KEY_FOREVER, 1, 1, []string{"5"}).Return([]measurements.Smart{}, nil).Times(1)
+
+	//assert
+	require.True(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, false, &gin.Context{}, fakeDatabase))
+}
+func TestShouldNotify_NoRepeat(t *testing.T) {
+	t.Parallel()
+	//setup
+	device := models.Device{
+		DeviceStatus: pkg.DeviceStatusFailedScrutiny,
+	}
+	smartAttrs := measurements.Smart{Attributes: map[string]measurements.SmartAttribute{
+		"5": &measurements.SmartAtaAttribute{
+			Status:           pkg.AttributeStatusFailedScrutiny,
+			TransformedValue: 0,
+		},
+	}}
+	statusThreshold := pkg.MetricsStatusThresholdBoth
+	notifyFilterAttributes := pkg.MetricsStatusFilterAttributesAll
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+	fakeDatabase := mock_database.NewMockDeviceRepo(mockCtrl)
+	fakeDatabase.EXPECT().GetSmartAttributeHistory(&gin.Context{}, "", database.DURATION_KEY_FOREVER, 1, 1, []string{"5"}).Return([]measurements.Smart{smartAttrs}, nil).Times(1)
+
+	//assert
+	require.False(t, ShouldNotify(logrus.StandardLogger(), device, smartAttrs, statusThreshold, notifyFilterAttributes, false, &gin.Context{}, fakeDatabase))
+}
+
+func TestNewPayload(t *testing.T) {
+	t.Parallel()
+
+	//setup
+	device := models.Device{
+		SerialNumber: "FAKEWDDJ324KSO",
+		DeviceType:   pkg.DeviceProtocolAta,
+		DeviceName:   "/dev/sda",
+		DeviceStatus: pkg.DeviceStatusFailedScrutiny,
+	}
+	currentTime := time.Now()
+	//test
+
+	payload := NewPayload(device, false, currentTime)
+
+	//assert
+	require.Equal(t, "Scrutiny SMART error (ScrutinyFailure) detected on device: /dev/sda", payload.Subject)
+	require.Equal(t, fmt.Sprintf(`Scrutiny SMART error notification for device: /dev/sda
+Failure Type: ScrutinyFailure
+Device Name: /dev/sda
+Device Serial: FAKEWDDJ324KSO
+Device Type: ATA
+
+Date: %s`, currentTime.Format(time.RFC3339)), payload.Message)
+}
+
+func TestNewPayload_TestMode(t *testing.T) {
+	t.Parallel()
+
+	//setup
+	device := models.Device{
+		SerialNumber: "FAKEWDDJ324KSO",
+		DeviceType:   pkg.DeviceProtocolAta,
+		DeviceName:   "/dev/sda",
+		DeviceStatus: pkg.DeviceStatusFailedScrutiny,
+	}
+	currentTime := time.Now()
+	//test
+
+	payload := NewPayload(device, true, currentTime)
+
+	//assert
+	require.Equal(t, "Scrutiny SMART error (EmailTest) detected on device: /dev/sda", payload.Subject)
+	require.Equal(t, fmt.Sprintf(`TEST NOTIFICATION:
+Scrutiny SMART error notification for device: /dev/sda
+Failure Type: EmailTest
+Device Name: /dev/sda
+Device Serial: FAKEWDDJ324KSO
+Device Type: ATA
+
+Date: %s`, currentTime.Format(time.RFC3339)), payload.Message)
+}
+
+func TestNewPayload_WithHostId(t *testing.T) {
+	t.Parallel()
+
+	//setup
+	device := models.Device{
+		SerialNumber: "FAKEWDDJ324KSO",
+		DeviceType:   pkg.DeviceProtocolAta,
+		DeviceName:   "/dev/sda",
+		DeviceStatus: pkg.DeviceStatusFailedScrutiny,
+		HostId:       "custom-host",
+	}
+	currentTime := time.Now()
+	//test
+
+	payload := NewPayload(device, false, currentTime)
+
+	//assert
+	require.Equal(t, "Scrutiny SMART error (ScrutinyFailure) detected on [host]device: [custom-host]/dev/sda", payload.Subject)
+	require.Equal(t, fmt.Sprintf(`Scrutiny SMART error notification for device: /dev/sda
+Host Id: custom-host
+Failure Type: ScrutinyFailure
+Device Name: /dev/sda
+Device Serial: FAKEWDDJ324KSO
+Device Type: ATA
+
+Date: %s`, currentTime.Format(time.RFC3339)), payload.Message)
 }

webapp/backend/pkg/thresholds/ata_attribute_metadata.go

@@ -1,5 +1,10 @@
 package thresholds
 
+import (
+	"strconv"
+	"strings"
+)
+
 const AtaSmartAttributeDisplayTypeRaw = "raw"
 const AtaSmartAttributeDisplayTypeNormalized = "normalized"
 const AtaSmartAttributeDisplayTypeTransformed = "transformed"
@@ -662,62 +667,84 @@ var AtaMetadata = map[int]AtaAttributeMetadata{
 	188: {
 		ID:          188,
 		DisplayName: "Command Timeout",
-		DisplayType: AtaSmartAttributeDisplayTypeRaw,
+		DisplayType: AtaSmartAttributeDisplayTypeTransformed,
 		Ideal:       ObservedThresholdIdealLow,
 		Critical:    true,
 		Description: "The count of aborted operations due to HDD timeout. Normally this attribute value should be equal to zero.",
+		Transform: func(normValue int64, rawValue int64, rawString string) int64 {
+			// Parse Seagate command timeout values if the string contains 3 pieces
+			// and each piece is less than or equal to the next (as a sanity check)
+			// See https://github.com/AnalogJ/scrutiny/issues/522
+			pieces := strings.Split(rawString, " ")
+			if len(pieces) == 3 {
+				int_pieces := make([]int, len(pieces))
+				var err error
+				for i, s := range pieces {
+					int_pieces[i], err = strconv.Atoi(s)
+					if err != nil {
+						return rawValue
+					}
+				}
+				if int_pieces[2] >= int_pieces[1] && int_pieces[1] >= int_pieces[0] {
+					return int64(int_pieces[2])
+				}
+			}
+			return rawValue
+		},
 		ObservedThresholds: []ObservedThreshold{
 			{
-				Low:               0,
-				High:              0,
+				Low: 0,
+				// This is set arbitrarily to avoid notifications caused by low
+				// historical numbers of command timeouts (e.g. caused by a bad cable)
+				High:              100,
 				AnnualFailureRate: 0.024893587674442153,
 				ErrorInterval:     []float64{0.020857343769186413, 0.0294830350167543},
 			},
 			{
-				Low:               0,
-				High:              13,
+				Low:               100,
+				High:              13000000000,
 				AnnualFailureRate: 0.10044174089362015,
 				ErrorInterval:     []float64{0.0812633664077498, 0.1227848196758574},
 			},
 			{
-				Low:               13,
-				High:              26,
+				Low:               13000000000,
+				High:              26000000000,
 				AnnualFailureRate: 0.334030592234279,
 				ErrorInterval:     []float64{0.2523231196342665, 0.4337665082489293},
 			},
 			{
-				Low:               26,
-				High:              39,
+				Low:               26000000000,
+				High:              39000000000,
 				AnnualFailureRate: 0.36724705400842445,
 				ErrorInterval:     []float64{0.30398009356575617, 0.4397986538328568},
 			},
 			{
-				Low:               39,
-				High:              52,
+				Low:               39000000000,
+				High:              52000000000,
 				AnnualFailureRate: 0.29848155926978354,
 				ErrorInterval:     []float64{0.2509254838615984, 0.35242890006477073},
 			},
 			{
-				Low:               52,
-				High:              65,
+				Low:               52000000000,
+				High:              65000000000,
 				AnnualFailureRate: 0.2203079701535098,
 				ErrorInterval:     []float64{0.18366082845676174, 0.26212468677179274},
 			},
 			{
-				Low:               65,
-				High:              78,
+				Low:               65000000000,
+				High:              78000000000,
 				AnnualFailureRate: 0.3018169948863018,
 				ErrorInterval:     []float64{0.23779746376787655, 0.37776897542831006},
 			},
 			{
-				Low:               78,
-				High:              91,
+				Low:               78000000000,
+				High:              91000000000,
 				AnnualFailureRate: 0.32854928239235887,
 				ErrorInterval:     []float64{0.2301118782147336, 0.4548506948185028},
 			},
 			{
-				Low:               91,
-				High:              104,
+				Low:               91000000000,
+				High:              104000000000,
 				AnnualFailureRate: 0.28488916640649387,
 				ErrorInterval:     []float64{0.1366154288236293, 0.5239213202729072},
 			},

webapp/backend/pkg/version/version.go

@@ -2,4 +2,4 @@ package version
 
 // VERSION is the app-global version string, which will be replaced with a
 // new value during packaging
-const VERSION = "0.4.16"
+const VERSION = "0.7.3"

webapp/backend/pkg/web/handler/delete_device.go

@@ -8,7 +8,7 @@ import (
 )
 
 func DeleteDevice(c *gin.Context) {
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
 
 	err := deviceRepo.DeleteDevice(c, c.Param("wwn"))

webapp/backend/pkg/web/handler/get_device_details.go

@@ -1,15 +1,16 @@
 package handler
 
 import (
+	"net/http"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/thresholds"
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
-	"net/http"
 )
 
 func GetDeviceDetails(c *gin.Context) {
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
 
 	device, err := deviceRepo.GetDeviceDetails(c, c.Param("wwn"))
@@ -24,7 +25,7 @@ func GetDeviceDetails(c *gin.Context) {
 		durationKey = "forever"
 	}
 
-	smartResults, err := deviceRepo.GetSmartAttributeHistory(c, c.Param("wwn"), durationKey, nil)
+	smartResults, err := deviceRepo.GetSmartAttributeHistory(c, c.Param("wwn"), durationKey, 0, 0, nil)
 	if err != nil {
 		logger.Errorln("An error occurred while retrieving device smart results", err)
 		c.JSON(http.StatusInternalServerError, gin.H{"success": false})

webapp/backend/pkg/web/handler/get_devices_summary.go

@@ -8,7 +8,7 @@ import (
 )
 
 func GetDevicesSummary(c *gin.Context) {
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
 
 	summary, err := deviceRepo.GetSummary(c)

webapp/backend/pkg/web/handler/get_devices_summary_temp_history.go

@@ -8,7 +8,7 @@ import (
 )
 
 func GetDevicesSummaryTempHistory(c *gin.Context) {
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
 
 	durationKey, exists := c.GetQuery("duration_key")

webapp/backend/pkg/web/handler/get_settings.go

@@ -0,0 +1,25 @@
+package handler
+
+import (
+	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"net/http"
+)
+
+func GetSettings(c *gin.Context) {
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
+	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
+
+	settings, err := deviceRepo.LoadSettings(c)
+	if err != nil {
+		logger.Errorln("An error occurred while retrieving settings", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"success": false})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success":  true,
+		"settings": settings,
+	})
+}

webapp/backend/pkg/web/handler/health_check.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"net/http"
+)
+
+func HealthCheck(c *gin.Context) {
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
+	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
+	logger.Infof("Checking Influxdb & Sqlite health")
+
+	//check sqlite and influxdb health
+	err := deviceRepo.HealthCheck(c)
+	if err != nil {
+		logger.Errorln("An error occurred during healthcheck", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"success": false, "error": err.Error()})
+		return
+	}
+
+	//TODO:
+	// check if the /web folder is populated.
+
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+	})
+}

webapp/backend/pkg/web/handler/register_devices.go

@@ -13,7 +13,7 @@ import (
 // This function is run everytime a collector is about to start a run. It can be used to update device metadata.
 func RegisterDevices(c *gin.Context) {
 	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 
 	var collectorDeviceWrapper models.DeviceWrapper
 	err := c.BindJSON(&collectorDeviceWrapper)

webapp/backend/pkg/web/handler/save_settings.go

@@ -0,0 +1,34 @@
+package handler
+
+import (
+	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"net/http"
+)
+
+func SaveSettings(c *gin.Context) {
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
+	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
+
+	var settings models.Settings
+	err := c.BindJSON(&settings)
+	if err != nil {
+		logger.Errorln("Cannot parse updated settings", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"success": false})
+		return
+	}
+
+	err = deviceRepo.SaveSettings(c, settings)
+	if err != nil {
+		logger.Errorln("An error occurred while saving settings", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"success": false})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success":  true,
+		"settings": settings,
+	})
+}

webapp/backend/pkg/web/handler/send_test_notification.go

@@ -13,7 +13,7 @@ import (
 // Send test notification
 func SendTestNotification(c *gin.Context) {
 	appConfig := c.MustGet("CONFIG").(config.Interface)
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 
 	testNotify := notify.New(
 		logger,

webapp/backend/pkg/web/handler/upload_device_metrics.go

@@ -1,6 +1,9 @@
 package handler
 
 import (
+	"fmt"
+	"net/http"
+
 	"github.com/analogj/scrutiny/webapp/backend/pkg"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
@@ -8,12 +11,11 @@ import (
 	"github.com/analogj/scrutiny/webapp/backend/pkg/notify"
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
-	"net/http"
 )
 
 func UploadDeviceMetrics(c *gin.Context) {
 	//db := c.MustGet("DB").(*gorm.DB)
-	logger := c.MustGet("LOGGER").(logrus.FieldLogger)
+	logger := c.MustGet("LOGGER").(*logrus.Entry)
 	appConfig := c.MustGet("CONFIG").(config.Interface)
 	//influxWriteDb := c.MustGet("INFLUXDB_WRITE").(*api.WriteAPIBlocking)
 	deviceRepo := c.MustGet("DEVICE_REPOSITORY").(database.DeviceRepo)
@@ -67,7 +69,16 @@ func UploadDeviceMetrics(c *gin.Context) {
 	}
 
 	//check for error
-	if notify.ShouldNotify(updatedDevice, smartData, appConfig.GetString("notify.level"), appConfig.GetString("notify.filter_attributes")) {
+	if notify.ShouldNotify(
+		logger,
+		updatedDevice,
+		smartData,
+		pkg.MetricsStatusThreshold(appConfig.GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY))),
+		pkg.MetricsStatusFilterAttributes(appConfig.GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY))),
+		appConfig.GetBool(fmt.Sprintf("%s.metrics.repeat_notifications", config.DB_USER_SETTINGS_SUBKEY)),
+		c,
+		deviceRepo,
+	) {
 		//send notifications
 
 		liveNotify := notify.New(

webapp/backend/pkg/web/middleware/logger.go

@@ -28,11 +28,11 @@ import (
 var timeFormat = "02/Jan/2006:15:04:05 -0700"
 
 // Logger is the logrus logger handler
-func LoggerMiddleware(logger logrus.FieldLogger) gin.HandlerFunc {
+func LoggerMiddleware(logger *logrus.Entry) gin.HandlerFunc {
 
 	hostname, err := os.Hostname()
 	if err != nil {
-		hostname = "unknow"
+		hostname = "unknown"
 	}
 
 	return func(c *gin.Context) {

webapp/backend/pkg/web/middleware/repository.go

@@ -1,6 +1,7 @@
 package middleware
 
 import (
+	"context"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
 	"github.com/analogj/scrutiny/webapp/backend/pkg/database"
 	"github.com/gin-gonic/gin"
@@ -14,6 +15,14 @@ func RepositoryMiddleware(appConfig config.Interface, globalLogger logrus.FieldL
 		panic(err)
 	}
 
+	// ensure the settings have been loaded into the app config during startup.
+	_, err = deviceRepo.LoadSettings(context.Background())
+	if err != nil {
+		panic(err)
+	}
+
+	//settings.UpdateSettingEntries()
+
 	//TODO: determine where we can call defer deviceRepo.Close()
 	return func(c *gin.Context) {
 		c.Set("DEVICE_REPOSITORY", deviceRepo)

webapp/backend/pkg/web/server.go

@@ -9,18 +9,17 @@ import (
 	"github.com/analogj/scrutiny/webapp/backend/pkg/web/middleware"
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
-	"io"
 	"net/http"
-	"os"
 	"path/filepath"
 	"strings"
 )
 
 type AppEngine struct {
 	Config config.Interface
+	Logger *logrus.Entry
 }
 
-func (ae *AppEngine) Setup(logger logrus.FieldLogger) *gin.Engine {
+func (ae *AppEngine) Setup(logger *logrus.Entry) *gin.Engine {
 	r := gin.New()
 
 	r.Use(middleware.LoggerMiddleware(logger))
@@ -35,11 +34,7 @@ func (ae *AppEngine) Setup(logger logrus.FieldLogger) *gin.Engine {
 	{
 		api := base.Group("/api")
 		{
-			api.GET("/health", func(c *gin.Context) {
-				c.JSON(http.StatusOK, gin.H{
-					"success": true,
-				})
-			})
+			api.GET("/health", handler.HealthCheck)
 			api.POST("/health/notify", handler.SendTestNotification) //check if notifications are configured correctly
 
 			api.POST("/devices/register", handler.RegisterDevices)         //used by Collector to register new devices and retrieve filtered list
@@ -50,6 +45,8 @@ func (ae *AppEngine) Setup(logger logrus.FieldLogger) *gin.Engine {
 			api.GET("/device/:wwn/details", handler.GetDeviceDetails) //used by Details
 			api.DELETE("/device/:wwn", handler.DeleteDevice)          //used by UI to delete device
 
+			api.GET("/settings", handler.GetSettings)   //used to get settings
+			api.POST("/settings", handler.SaveSettings) //used to save settings
 		}
 	}
 
@@ -75,26 +72,6 @@ func (ae *AppEngine) Start() error {
 		gin.SetMode(gin.DebugMode)
 	}
 
-	logger := logrus.New()
-	//set default log level
-	logLevel, err := logrus.ParseLevel(ae.Config.GetString("log.level"))
-	if err != nil {
-		return err
-	}
-	logger.SetLevel(logLevel)
-	//set the log file if present
-	if len(ae.Config.GetString("log.file")) != 0 {
-		logFile, err := os.OpenFile(ae.Config.GetString("log.file"), os.O_CREATE|os.O_WRONLY, 0644)
-		defer logFile.Close()
-		if err != nil {
-			logrus.Errorf("Failed to open log file %s for output: %s", ae.Config.GetString("log.file"), err)
-			return err
-		}
-
-		//configure the logrus default
-		logger.SetOutput(io.MultiWriter(os.Stderr, logFile))
-	}
-
 	//check if the database parent directory exists, fail here rather than in a handler.
 	if !utils.FileExists(filepath.Dir(ae.Config.GetString("web.database.location"))) {
 		return errors.ConfigValidationError(fmt.Sprintf(
@@ -102,7 +79,7 @@ func (ae *AppEngine) Start() error {
 			filepath.Dir(ae.Config.GetString("web.database.location"))))
 	}
 
-	r := ae.Setup(logger)
+	r := ae.Setup(ae.Logger)
 
 	return r.Run(fmt.Sprintf("%s:%s", ae.Config.GetString("web.listen.host"), ae.Config.GetString("web.listen.port")))
 }

webapp/backend/pkg/web/server_test.go

@@ -3,15 +3,7 @@ package web_test
 import (
 	"bytes"
 	"encoding/json"
-	"github.com/analogj/scrutiny/webapp/backend/pkg"
-	mock_config "github.com/analogj/scrutiny/webapp/backend/pkg/config/mock"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
-	"github.com/analogj/scrutiny/webapp/backend/pkg/web"
-	"github.com/golang/mock/gomock"
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
@@ -21,6 +13,17 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/analogj/scrutiny/webapp/backend/pkg"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/config"
+	mock_config "github.com/analogj/scrutiny/webapp/backend/pkg/config/mock"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/models/collector"
+	"github.com/analogj/scrutiny/webapp/backend/pkg/web"
+	"github.com/golang/mock/gomock"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
 )
 
 /*
@@ -89,6 +92,8 @@ func (suite *ServerTestSuite) TestHealthRoute() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").Return(path.Join(parentPath, "scrutiny_test.db")).AnyTimes()
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").Return(parentPath).AnyTimes()
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -99,6 +104,7 @@ func (suite *ServerTestSuite) TestHealthRoute() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -111,7 +117,7 @@ func (suite *ServerTestSuite) TestHealthRoute() {
 		Config: fakeConfig,
 	}
 
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 
 	//test
 	w := httptest.NewRecorder()
@@ -130,6 +136,8 @@ func (suite *ServerTestSuite) TestRegisterDevicesRoute() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").Return(path.Join(parentPath, "scrutiny_test.db")).AnyTimes()
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").Return(parentPath).AnyTimes()
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -139,6 +147,7 @@ func (suite *ServerTestSuite) TestRegisterDevicesRoute() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -150,7 +159,7 @@ func (suite *ServerTestSuite) TestRegisterDevicesRoute() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 	file, err := os.Open("testdata/register-devices-req.json")
 	require.NoError(suite.T(), err)
 
@@ -170,6 +179,8 @@ func (suite *ServerTestSuite) TestUploadDeviceMetricsRoute() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -179,6 +190,8 @@ func (suite *ServerTestSuite) TestUploadDeviceMetricsRoute() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("user.metrics.repeat_notifications").Return(true).AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -186,13 +199,14 @@ func (suite *ServerTestSuite) TestUploadDeviceMetricsRoute() {
 	} else {
 		fakeConfig.EXPECT().GetString("web.influxdb.host").Return("localhost").AnyTimes()
 	}
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
 
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 	devicesfile, err := os.Open("testdata/register-devices-single-req.json")
 	require.NoError(suite.T(), err)
 
@@ -219,10 +233,13 @@ func (suite *ServerTestSuite) TestPopulateMultiple() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	//fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return("testdata/scrutiny_test.db")
 	fakeConfig.EXPECT().GetStringSlice("notify.urls").Return([]string{}).AnyTimes()
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -232,6 +249,8 @@ func (suite *ServerTestSuite) TestPopulateMultiple() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("user.metrics.repeat_notifications").Return(true).AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -243,7 +262,7 @@ func (suite *ServerTestSuite) TestPopulateMultiple() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 	devicesfile, err := os.Open("testdata/register-devices-req.json")
 	require.NoError(suite.T(), err)
 
@@ -319,6 +338,8 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_WebhookFailure() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -328,10 +349,12 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_WebhookFailure() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetStringSlice("notify.urls").AnyTimes().Return([]string{"https://unroutable.domain.example.asdfghj"})
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
 
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -343,7 +366,7 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_WebhookFailure() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 
 	//test
 	wr := httptest.NewRecorder()
@@ -361,6 +384,8 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ScriptFailure() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -370,10 +395,12 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ScriptFailure() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetStringSlice("notify.urls").AnyTimes().Return([]string{"script:///missing/path/on/disk"})
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
 
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -385,7 +412,7 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ScriptFailure() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 
 	//test
 	wr := httptest.NewRecorder()
@@ -403,6 +430,8 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ScriptSuccess() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -412,10 +441,12 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ScriptSuccess() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetStringSlice("notify.urls").AnyTimes().Return([]string{"script:///usr/bin/env"})
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
 
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -427,7 +458,7 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ScriptSuccess() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 
 	//test
 	wr := httptest.NewRecorder()
@@ -445,6 +476,8 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ShoutrrrFailure() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -454,10 +487,12 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ShoutrrrFailure() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetStringSlice("notify.urls").AnyTimes().Return([]string{"discord://invalidtoken@channel"})
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
 
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
@@ -468,7 +503,7 @@ func (suite *ServerTestSuite) TestSendTestNotificationRoute_ShoutrrrFailure() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 
 	//test
 	wr := httptest.NewRecorder()
@@ -486,6 +521,8 @@ func (suite *ServerTestSuite) TestGetDevicesSummaryRoute_Nvme() {
 	mockCtrl := gomock.NewController(suite.T())
 	defer mockCtrl.Finish()
 	fakeConfig := mock_config.NewMockInterface(mockCtrl)
+	fakeConfig.EXPECT().SetDefault(gomock.Any(), gomock.Any()).AnyTimes()
+	fakeConfig.EXPECT().UnmarshalKey(gomock.Any(), gomock.Any()).AnyTimes().Return(nil)
 	fakeConfig.EXPECT().GetString("web.database.location").AnyTimes().Return(path.Join(parentPath, "scrutiny_test.db"))
 	fakeConfig.EXPECT().GetString("web.src.frontend.path").AnyTimes().Return(parentPath)
 	fakeConfig.EXPECT().GetString("web.listen.basepath").Return(suite.Basepath).AnyTimes()
@@ -495,10 +532,14 @@ func (suite *ServerTestSuite) TestGetDevicesSummaryRoute_Nvme() {
 	fakeConfig.EXPECT().GetString("web.influxdb.token").Return("my-super-secret-auth-token").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.org").Return("scrutiny").AnyTimes()
 	fakeConfig.EXPECT().GetString("web.influxdb.bucket").Return("metrics").AnyTimes()
+	fakeConfig.EXPECT().GetBool("user.metrics.repeat_notifications").Return(true).AnyTimes()
+	fakeConfig.EXPECT().GetBool("web.influxdb.tls.insecure_skip_verify").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetBool("web.influxdb.retention_policy").Return(false).AnyTimes()
 	fakeConfig.EXPECT().GetStringSlice("notify.urls").AnyTimes().Return([]string{})
-	fakeConfig.EXPECT().GetString("notify.level").AnyTimes().Return(pkg.NotifyLevelFail)
-	fakeConfig.EXPECT().GetString("notify.filter_attributes").AnyTimes().Return(pkg.NotifyFilterAttributesAll)
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.notify_level", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsNotifyLevelFail))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_filter_attributes", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusFilterAttributesAll))
+	fakeConfig.EXPECT().GetInt(fmt.Sprintf("%s.metrics.status_threshold", config.DB_USER_SETTINGS_SUBKEY)).AnyTimes().Return(int(pkg.MetricsStatusThresholdBoth))
+
 	if _, isGithubActions := os.LookupEnv("GITHUB_ACTIONS"); isGithubActions {
 		// when running test suite in github actions, we run an influxdb service as a sidecar.
 		fakeConfig.EXPECT().GetString("web.influxdb.host").Return("influxdb").AnyTimes()
@@ -509,7 +550,7 @@ func (suite *ServerTestSuite) TestGetDevicesSummaryRoute_Nvme() {
 	ae := web.AppEngine{
 		Config: fakeConfig,
 	}
-	router := ae.Setup(logrus.New())
+	router := ae.Setup(logrus.WithField("test", suite.T().Name()))
 	devicesfile, err := os.Open("testdata/register-devices-req-2.json")
 	require.NoError(suite.T(), err)
 

webapp/frontend/angular.json

@@ -52,7 +52,6 @@
                             "optimization": true,
                             "outputHashing": "all",
                             "sourceMap": false,
-                            "extractCss": true,
                             "namedChunks": false,
                             "extractLicenses": true,
                             "vendorChunk": false,
@@ -91,7 +90,6 @@
                 },
                 "test": {
                     "builder": "@angular-devkit/build-angular:karma",
-                    "defaultConfiguration": "production",
                     "options": {
                         "main": "src/test.ts",
                         "polyfills": "src/polyfills.ts",

webapp/frontend/karma.conf.js

@@ -10,10 +10,10 @@ module.exports = function (config)
             require('karma-jasmine'),
             require('karma-chrome-launcher'),
             require('karma-jasmine-html-reporter'),
-            require('karma-coverage-istanbul-reporter'),
+            require('karma-coverage'),
             require('@angular-devkit/build-angular/plugins/karma')
         ],
-        client                  : {
+        client: {
             clearContext: false // leave Jasmine Spec Runner output visible in browser
         },
         coverageIstanbulReporter: {
@@ -21,13 +21,13 @@ module.exports = function (config)
             reports: ['html', 'lcovonly', 'text-summary'],
             fixWebpackSourcePaths: true
         },
-        reporters               : ['progress', 'kjhtml'],
-        port                    : 9876,
-        colors                  : true,
-        logLevel                : config.LOG_INFO,
-        autoWatch               : true,
-        browsers                : ['Chrome'],
-        singleRun               : false,
-        restartOnFileChange     : true
+        reporters: ['progress', 'kjhtml'],
+        port: 9876,
+        colors: true,
+        logLevel: config.LOG_INFO,
+        autoWatch: true,
+        browsers: ['Chrome'],
+        singleRun: false,
+        restartOnFileChange: true
     });
 };

webapp/frontend/package.json

@@ -7,7 +7,7 @@
         "start": "ng serve --open",
         "start:mem": "node --max_old_space_size=6144 ./node_modules/@angular/cli/bin/ng serve --open",
         "build": "ng build",
-        "build:prod": "ng build --prod",
+        "build:prod": "ng build --configuration production",
         "build:prod:mem": "node --max_old_space_size=6144 ./node_modules/@angular/cli/bin/ng build --prod",
         "test": "ng test",
         "lint": "ng lint",
@@ -20,66 +20,55 @@
     },
     "private": true,
     "dependencies": {
-        "@angular/animations": "9.1.4",
-        "@angular/cdk": "9.2.2",
-        "@angular/common": "9.1.4",
-        "@angular/compiler": "9.1.4",
-        "@angular/core": "9.1.4",
-        "@angular/forms": "9.1.4",
-        "@angular/material": "9.2.2",
-        "@angular/material-moment-adapter": "9.2.2",
-        "@angular/platform-browser": "9.1.4",
-        "@angular/platform-browser-dynamic": "9.1.4",
-        "@angular/router": "9.1.4",
-        "@fullcalendar/angular": "4.4.5-beta",
-        "@fullcalendar/core": "4.4.0",
-        "@fullcalendar/daygrid": "4.4.0",
-        "@fullcalendar/interaction": "4.4.0",
-        "@fullcalendar/list": "4.4.0",
-        "@fullcalendar/moment": "4.4.0",
-        "@fullcalendar/rrule": "4.4.0",
-        "@fullcalendar/timegrid": "4.4.0",
-        "@types/humanize-duration": "^3.18.1",
-        "apexcharts": "3.19.2",
-        "crypto-js": "3.3.0",
-        "highlight.js": "10.0.1",
-        "humanize-duration": "^3.24.0",
-        "lodash": "4.17.15",
-        "moment": "2.24.0",
-        "ng-apexcharts": "1.5.12",
-        "ngx-markdown": "9.0.0",
-        "ngx-quill": "9.1.0",
-        "perfect-scrollbar": "1.5.0",
-        "quill": "1.3.7",
-        "rrule": "2.6.4",
-        "rxjs": "6.5.5",
-        "tslib": "1.11.1",
-        "web-animations-js": "2.3.2",
-        "zone.js": "0.10.3"
+        "@angular/animations": "v13-lts",
+        "@angular/cdk": "v13-lts",
+        "@angular/common": "v13-lts",
+        "@angular/compiler": "v13-lts",
+        "@angular/core": "v13-lts",
+        "@angular/forms": "v13-lts",
+        "@angular/material": "v13-lts",
+        "@angular/material-moment-adapter": "v13-lts",
+        "@angular/platform-browser": "v13-lts",
+        "@angular/platform-browser-dynamic": "v13-lts",
+        "@angular/router": "v13-lts",
+        "@types/humanize-duration": "^3.27.1",
+        "crypto-js": "^4.1.1",
+        "highlight.js": "^11.6.0",
+        "humanize-duration": "^3.27.3",
+        "lodash": "4.17.21",
+        "moment": "^2.29.4",
+        "ng-apexcharts": "^1.7.4",
+        "ngx-markdown": "^13.1.0",
+        "perfect-scrollbar": "^1.5.5",
+        "quill": "^1.3.7",
+        "rrule": "^2.7.1",
+        "rxjs": "^7.5.7",
+        "tslib": "^2.4.1",
+        "web-animations-js": "^2.3.2"
     },
     "devDependencies": {
-        "@angular-devkit/build-angular": "0.901.4",
-        "@angular/cli": "9.1.4",
-        "@angular/compiler-cli": "9.1.4",
-        "@angular/language-service": "9.1.4",
-        "@types/crypto-js": "3.1.45",
-        "@types/highlight.js": "9.12.3",
-        "@types/jasmine": "3.5.10",
-        "@types/jasminewd2": "2.0.8",
-        "@types/lodash": "4.14.150",
-        "@types/node": "12.12.37",
-        "codelyzer": "5.2.2",
-        "jasmine-core": "3.5.0",
-        "jasmine-spec-reporter": "4.2.1",
-        "karma": "5.0.4",
-        "karma-chrome-launcher": "3.1.0",
-        "karma-coverage-istanbul-reporter": "2.1.1",
-        "karma-jasmine": "3.0.3",
-        "karma-jasmine-html-reporter": "1.5.3",
-        "protractor": "5.4.4",
-        "tailwindcss": "1.4.4",
-        "ts-node": "8.3.0",
-        "tslint": "6.1.2",
-        "typescript": "3.8.3"
+        "@angular-devkit/build-angular": "v13-lts",
+        "@angular/cli": "v13-lts",
+        "@angular/compiler-cli": "v13-lts",
+        "@angular/language-service": "v13-lts",
+        "@types/crypto-js": "^4.1.1",
+        "@types/highlight.js": "^10.1.0",
+        "@types/jasmine": "^4.3.0",
+        "@types/jasminewd2": "^2.0.10",
+        "@types/lodash": "^4.14.188",
+        "@types/node": "^18.11.9",
+        "codelyzer": "^6.0.2",
+        "jasmine-core": "^4.5.0",
+        "jasmine-spec-reporter": "^7.0.0",
+        "karma": "^6.4.1",
+        "karma-chrome-launcher": "^3.1.1",
+        "karma-coverage": "^2.2.0",
+        "karma-jasmine": "^5.1.0",
+        "karma-jasmine-html-reporter": "^2.0.0",
+        "protractor": "^7.0.0",
+        "tailwindcss": "^3.2.3",
+        "ts-node": "^10.9.1",
+        "tslint": "^6.1.3",
+        "typescript": "^4.6.4"
     }
 }

webapp/frontend/src/@treo/components/date-range/date-range.component.ts

@@ -56,7 +56,7 @@ export class TreoDateRangeComponent implements ControlValueAccessor, OnInit, OnD
     private _timeFormat: string;
     private _timeRange: boolean;
     private readonly _timeRegExp: RegExp;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/message/message.component.ts

@@ -31,7 +31,7 @@ export class TreoMessageComponent implements OnInit, OnDestroy
     private _dismissed: null | boolean;
     private _showIcon: boolean;
     private _type: TreoMessageType;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/horizontal/components/basic/basic.component.ts

@@ -23,7 +23,7 @@ export class TreoHorizontalNavigationBasicItemComponent implements OnInit, OnDes
 
     // Private
     private _treoHorizontalNavigationComponent: TreoHorizontalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/horizontal/components/branch/branch.component.ts

@@ -32,7 +32,7 @@ export class TreoHorizontalNavigationBranchItemComponent implements OnInit, OnDe
 
     // Private
     private _treoHorizontalNavigationComponent: TreoHorizontalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/horizontal/components/divider/divider.component.ts

@@ -23,7 +23,7 @@ export class TreoHorizontalNavigationDividerItemComponent implements OnInit, OnD
 
     // Private
     private _treoHorizontalNavigationComponent: TreoHorizontalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/horizontal/components/spacer/spacer.component.ts

@@ -23,7 +23,7 @@ export class TreoHorizontalNavigationSpacerItemComponent implements OnInit, OnDe
 
     // Private
     private _treoHorizontalNavigationComponent: TreoHorizontalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/horizontal/horizontal.component.ts

@@ -23,7 +23,7 @@ export class TreoHorizontalNavigationComponent implements OnInit, OnDestroy
 
     // Private
     private _navigation: TreoNavigationItem[];
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/components/aside/aside.component.ts

@@ -35,7 +35,7 @@ export class TreoVerticalNavigationAsideItemComponent implements OnInit, OnDestr
 
     // Private
     private _treoVerticalNavigationComponent: TreoVerticalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/components/basic/basic.component.ts

@@ -23,7 +23,7 @@ export class TreoVerticalNavigationBasicItemComponent implements OnInit, OnDestr
 
     // Private
     private _treoVerticalNavigationComponent: TreoVerticalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/components/collapsable/collapsable.component.ts

@@ -38,7 +38,7 @@ export class TreoVerticalNavigationCollapsableItemComponent implements OnInit, O
 
     // Private
     private _treoVerticalNavigationComponent: TreoVerticalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/components/divider/divider.component.ts

@@ -23,7 +23,7 @@ export class TreoVerticalNavigationDividerItemComponent implements OnInit, OnDes
 
     // Private
     private _treoVerticalNavigationComponent: TreoVerticalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/components/group/group.component.ts

@@ -27,7 +27,7 @@ export class TreoVerticalNavigationGroupItemComponent implements OnInit, OnDestr
 
     // Private
     private _treoVerticalNavigationComponent: TreoVerticalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/components/spacer/spacer.component.ts

@@ -23,7 +23,7 @@ export class TreoVerticalNavigationSpacerItemComponent implements OnInit, OnDest
 
     // Private
     private _treoVerticalNavigationComponent: TreoVerticalNavigationComponent;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/components/navigation/vertical/vertical.component.ts

@@ -65,7 +65,7 @@ export class TreoVerticalNavigationComponent implements OnInit, AfterViewInit, O
     private _position: TreoVerticalNavigationPosition;
     private _scrollStrategy: ScrollStrategy;
     private _transparentOverlay: boolean | '';
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     @HostBinding('class.treo-vertical-navigation-animations-enabled')
     private _animationsEnabled: boolean;

webapp/frontend/src/@treo/directives/autogrow/autogrow.directive.ts

@@ -12,7 +12,7 @@ export class TreoAutogrowDirective implements OnInit, OnDestroy
 
     // Private
     private _padding: number;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor

webapp/frontend/src/@treo/directives/scrollbar/scrollbar.directive.ts

@@ -24,7 +24,7 @@ export class TreoScrollbarDirective implements OnInit, OnDestroy
     private _animation: number | null;
     private _enabled: boolean;
     private _options: any;
-    private _unsubscribeAll: Subject<any>;
+    private _unsubscribeAll: Subject<void>;
 
     /**
      * Constructor