update debug log locations

release 0.6.0
update alert notification titles
2026-03-22 21:46:18 +01:00 · 2024-10-16 18:12:43 -04:00 · 2024-10-16 18:02:53 -04:00 · 2024-10-16 18:02:38 -04:00 · 2024-10-16 17:46:42 -04:00 · 2024-10-16 17:39:56 -04:00
55 changed files with 8317 additions and 2578 deletions
--- a/.github/workflows/docker-images.yml
+++ b/.github/workflows/docker-images.yml
@@ -3,7 +3,7 @@ name: Make docker images
 on:
  push:
    tags:
-      - '*'
+      - 'v*'

 jobs:
  build:
@@ -71,5 +71,3 @@ jobs:
          push: ${{ github.ref_type == 'tag' }}
          tags: ${{ steps.metadata.outputs.tags }}
          labels: ${{ steps.metadata.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha
--- a/.gitignore
+++ b/.gitignore
@@ -11,4 +11,3 @@ dist
 beszel/cmd/hub/hub
 beszel/cmd/agent/agent
 node_modules
-package-lock.json
--- a/beszel/cmd/agent/agent.go
+++ b/beszel/cmd/agent/agent.go
@@ -3,7 +3,6 @@ package main
 import (
 	"beszel"
 	"beszel/internal/agent"
-	"beszel/internal/update"
 	"fmt"
 	"log"
 	"os"
@@ -17,7 +16,7 @@ func main() {
 		case "-v":
 			fmt.Println(beszel.AppName+"-agent", beszel.Version)
 		case "update":
-			update.UpdateBeszelAgent()
+			agent.Update()
 		}
 		os.Exit(0)
 	}
@@ -38,5 +37,5 @@ func main() {
 		addr = portEnvVar
 	}

-	agent.NewAgent(pubKey, addr).Run()
+	agent.NewAgent().Run(pubKey, addr)
 }
--- a/beszel/cmd/hub/hub.go
+++ b/beszel/cmd/hub/hub.go
@@ -3,7 +3,6 @@ package main
 import (
 	"beszel"
 	"beszel/internal/hub"
-	"beszel/internal/update"
 	_ "beszel/migrations"

 	"github.com/pocketbase/pocketbase"
@@ -22,7 +21,7 @@ func main() {
 	app.RootCmd.AddCommand(&cobra.Command{
 		Use:   "update",
 		Short: "Update " + beszel.AppName + " to the latest version",
-		Run:   func(_ *cobra.Command, _ []string) { update.UpdateBeszel() },
+		Run:   hub.Update,
 	})

 	hub.NewHub(app).Run()
--- a/beszel/go.mod
+++ b/beszel/go.mod
@@ -9,9 +9,9 @@ require (
 	github.com/goccy/go-json v0.10.3
 	github.com/labstack/echo/v5 v5.0.0-20230722203903-ec5b858dab61
 	github.com/pocketbase/dbx v1.10.1
-	github.com/pocketbase/pocketbase v0.22.20
+	github.com/pocketbase/pocketbase v0.22.21
 	github.com/rhysd/go-github-selfupdate v1.2.3
-	github.com/shirou/gopsutil/v4 v4.24.8
+	github.com/shirou/gopsutil/v4 v4.24.9
 	github.com/spf13/cobra v1.8.1
 	golang.org/x/crypto v0.27.0
 )
@@ -20,29 +20,30 @@ require (
 	github.com/AlecAivazis/survey/v2 v2.3.7 // indirect
 	github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
-	github.com/aws/aws-sdk-go-v2 v1.30.5 // indirect
-	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.4 // indirect
-	github.com/aws/aws-sdk-go-v2/config v1.27.33 // indirect
-	github.com/aws/aws-sdk-go-v2/credentials v1.17.32 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.13 // indirect
-	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.18 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.17 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.17 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.31.0 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.5 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.27.39 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.37 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.26 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect
-	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.17 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.4 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.19 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.19 // indirect
-	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.17 // indirect
-	github.com/aws/aws-sdk-go-v2/service/s3 v1.61.2 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sso v1.22.7 // indirect
-	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.7 // indirect
-	github.com/aws/aws-sdk-go-v2/service/sts v1.30.7 // indirect
-	github.com/aws/smithy-go v1.20.4 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.18 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.5 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.20 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.20 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.18 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.64.0 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.23.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.27.3 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.31.3 // indirect
+	github.com/aws/smithy-go v1.21.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/disintegration/imaging v1.6.2 // indirect
 	github.com/domodwyer/mailyak/v3 v3.6.2 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/ebitengine/purego v0.8.0 // indirect
 	github.com/fatih/color v1.17.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.5 // indirect
 	github.com/ganigeorgiev/fexpr v0.4.1 // indirect
@@ -67,7 +68,6 @@ require (
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/shoenig/go-m1cpu v0.1.6 // indirect
 	github.com/spf13/cast v1.7.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/tcnksm/go-gitconfig v0.1.2 // indirect
@@ -89,9 +89,9 @@ require (
 	golang.org/x/text v0.18.0 // indirect
 	golang.org/x/time v0.6.0 // indirect
 	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
-	google.golang.org/api v0.197.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 // indirect
-	google.golang.org/grpc v1.66.2 // indirect
+	google.golang.org/api v0.199.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240930140551-af27646dc61f // indirect
+	google.golang.org/grpc v1.67.1 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect
 	modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a // indirect
 	modernc.org/libc v1.61.0 // indirect
--- a/beszel/go.sum
+++ b/beszel/go.sum
@@ -1,13 +1,13 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.115.1 h1:Jo0SM9cQnSkYfp44+v+NQXHpcHqlnRJk2qxh6yvxxxQ=
 cloud.google.com/go v0.115.1/go.mod h1:DuujITeaufu3gL68/lOFIirVNJwQeyf5UXyi+Wbgknc=
-cloud.google.com/go/auth v0.9.3 h1:VOEUIAADkkLtyfr3BLa3R8Ed/j6w1jTBmARx+wb5w5U=
-cloud.google.com/go/auth v0.9.3/go.mod h1:7z6VY+7h3KUdRov5F1i8NDP5ZzWKYmEPO842BgCsmTk=
+cloud.google.com/go/auth v0.9.5 h1:4CTn43Eynw40aFVr3GpPqsQponx2jv0BQpjvajsbbzw=
+cloud.google.com/go/auth v0.9.5/go.mod h1:Xo0n7n66eHyOWWCnitop6870Ilwo3PiZyodVkkH1xWM=
 cloud.google.com/go/auth/oauth2adapt v0.2.4 h1:0GWE/FUsXhf6C+jAkWgYm7X9tK8cuEIfy19DBn6B6bY=
 cloud.google.com/go/auth/oauth2adapt v0.2.4/go.mod h1:jC/jOpwFP6JBxhB3P5Rr0a9HLMC/Pe3eaL4NmdvqPtc=
 cloud.google.com/go/compute v1.14.0 h1:hfm2+FfxVmnRlh6LpB7cg1ZNU+5edAHmW679JePztk0=
-cloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY=
-cloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY=
+cloud.google.com/go/compute/metadata v0.5.2 h1:UxK4uu/Tn+I3p2dYWTfiX4wva7aYlKixAHn3fyqngqo=
+cloud.google.com/go/compute/metadata v0.5.2/go.mod h1:C66sj2AluDcIqakBq/M8lw8/ybHgOZqin2obFxa/E5k=
 cloud.google.com/go/iam v1.1.13 h1:7zWBXG9ERbMLrzQBRhFliAV+kjcRToDTgQT3CTwYyv4=
 cloud.google.com/go/iam v1.1.13/go.mod h1:K8mY0uSXwEXS30KrnVb+j54LB/ntfZu1dr+4zFMNbus=
 cloud.google.com/go/storage v1.43.0 h1:CcxnSohZwizt4LCzQHWvBf1/kvtHUn7gk9QERXPyXFs=
@@ -26,44 +26,44 @@ github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3d
 github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
 github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
 github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
-github.com/aws/aws-sdk-go-v2 v1.30.5 h1:mWSRTwQAb0aLE17dSzztCVJWI9+cRMgqebndjwDyK0g=
-github.com/aws/aws-sdk-go-v2 v1.30.5/go.mod h1:CT+ZPWXbYrci8chcARI3OmI/qgd+f6WtuLOoaIA8PR0=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.4 h1:70PVAiL15/aBMh5LThwgXdSQorVr91L127ttckI9QQU=
-github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.4/go.mod h1:/MQxMqci8tlqDH+pjmoLu1i0tbWCUP1hhyMRuFxpQCw=
-github.com/aws/aws-sdk-go-v2/config v1.27.33 h1:Nof9o/MsmH4oa0s2q9a0k7tMz5x/Yj5k06lDODWz3BU=
-github.com/aws/aws-sdk-go-v2/config v1.27.33/go.mod h1:kEqdYzRb8dd8Sy2pOdEbExTTF5v7ozEXX0McgPE7xks=
-github.com/aws/aws-sdk-go-v2/credentials v1.17.32 h1:7Cxhp/BnT2RcGy4VisJ9miUPecY+lyE9I8JvcZofn9I=
-github.com/aws/aws-sdk-go-v2/credentials v1.17.32/go.mod h1:P5/QMF3/DCHbXGEGkdbilXHsyTBX5D3HSwcrSc9p20I=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.13 h1:pfQ2sqNpMVK6xz2RbqLEL0GH87JOwSxPV2rzm8Zsb74=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.13/go.mod h1:NG7RXPUlqfsCLLFfi0+IpKN4sCB9D9fw/qTaSB+xRoU=
-github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.18 h1:9DIp7vhmOPmueCDwpXa45bEbLHHTt1kcxChdTJWWxvI=
-github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.18/go.mod h1:aJv/Fwz8r56ozwYFRC4bzoeL1L17GYQYemfblOBux1M=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.17 h1:pI7Bzt0BJtYA0N/JEC6B8fJ4RBrEMi1LBrkMdFYNSnQ=
-github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.17/go.mod h1:Dh5zzJYMtxfIjYW+/evjQ8uj2OyR/ve2KROHGHlSFqE=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.17 h1:Mqr/V5gvrhA2gvgnF42Zh5iMiQNcOYthFYwCyrnuWlc=
-github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.17/go.mod h1:aLJpZlCmjE+V+KtN1q1uyZkfnUWpQGpbsn89XPKyzfU=
+github.com/aws/aws-sdk-go-v2 v1.31.0 h1:3V05LbxTSItI5kUqNwhJrrrY1BAXxXt0sN0l72QmG5U=
+github.com/aws/aws-sdk-go-v2 v1.31.0/go.mod h1:ztolYtaEUtdpf9Wftr31CJfLVjOnD/CVRkKOOYgF8hA=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.5 h1:xDAuZTn4IMm8o1LnBZvmrL8JA1io4o3YWNXgohbf20g=
+github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.5/go.mod h1:wYSv6iDS621sEFLfKvpPE2ugjTuGlAG7iROg0hLOkfc=
+github.com/aws/aws-sdk-go-v2/config v1.27.39 h1:FCylu78eTGzW1ynHcongXK9YHtoXD5AiiUqq3YfJYjU=
+github.com/aws/aws-sdk-go-v2/config v1.27.39/go.mod h1:wczj2hbyskP4LjMKBEZwPRO1shXY+GsQleab+ZXT2ik=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.37 h1:G2aOH01yW8X373JK419THj5QVqu9vKEwxSEsGxihoW0=
+github.com/aws/aws-sdk-go-v2/credentials v1.17.37/go.mod h1:0ecCjlb7htYCptRD45lXJ6aJDQac6D2NlKGpZqyTG6A=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14 h1:C/d03NAmh8C4BZXhuRNboF/DqhBkBCeDiJDcaqIT5pA=
+github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.14/go.mod h1:7I0Ju7p9mCIdlrfS+JCgqcYD0VXz/N4yozsox+0o078=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.26 h1:BTfwWNFVGLxW2bih/V2xhgCsYDQwG1cAWhWoW9Jx7wE=
+github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.26/go.mod h1:LA1/FxoEFFmv7XpkB8KKqLAUz8AePdK9H0Ec7PUKazs=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18 h1:kYQ3H1u0ANr9KEKlGs/jTLrBFPo8P8NaH/w7A01NeeM=
+github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.18/go.mod h1:r506HmK5JDUh9+Mw4CfGJGSSoqIiLCndAuqXuhbv67Y=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18 h1:Z7IdFUONvTcvS7YuhtVxN99v2cCoHRXOS4mTr0B/pUc=
+github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.18/go.mod h1:DkKMmksZVVyat+Y+r1dEOgJEfUeA7UngIHWeKsi0yNc=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 h1:VaRN3TlFdd6KxX1x3ILT5ynH6HvKgqdiXoTxAF4HQcQ=
 github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1/go.mod h1:FbtygfRFze9usAadmnGJNc8KsP346kEe+y2/oyhGAGc=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.17 h1:Roo69qTpfu8OlJ2Tb7pAYVuF0CpuUMB0IYWwYP/4DZM=
-github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.17/go.mod h1:NcWPxQzGM1USQggaTVwz6VpqMZPX1CvDJLDh6jnOCa4=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.4 h1:KypMCbLPPHEmf9DgMGw51jMj77VfGPAN2Kv4cfhlfgI=
-github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.4/go.mod h1:Vz1JQXliGcQktFTN/LN6uGppAIRoLBR2bMvIMP0gOjc=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.19 h1:FLMkfEiRjhgeDTCjjLoc3URo/TBkgeQbocA78lfkzSI=
-github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.19/go.mod h1:Vx+GucNSsdhaxs3aZIKfSUjKVGsxN25nX2SRcdhuw08=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.19 h1:rfprUlsdzgl7ZL2KlXiUAoJnI/VxfHCvDFr2QDFj6u4=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.19/go.mod h1:SCWkEdRq8/7EK60NcvvQ6NXKuTcchAD4ROAsC37VEZE=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.17 h1:u+EfGmksnJc/x5tq3A+OD7LrMbSSR/5TrKLvkdy/fhY=
-github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.17/go.mod h1:VaMx6302JHax2vHJWgRo+5n9zvbacs3bLU/23DNQrTY=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.61.2 h1:Kp6PWAlXwP1UvIflkIP6MFZYBNDCa4mFCGtxrpICVOg=
-github.com/aws/aws-sdk-go-v2/service/s3 v1.61.2/go.mod h1:5FmD/Dqq57gP+XwaUnd5WFPipAuzrf0HmupX27Gvjvc=
-github.com/aws/aws-sdk-go-v2/service/sso v1.22.7 h1:pIaGg+08llrP7Q5aiz9ICWbY8cqhTkyy+0SHvfzQpTc=
-github.com/aws/aws-sdk-go-v2/service/sso v1.22.7/go.mod h1:eEygMHnTKH/3kNp9Jr1n3PdejuSNcgwLe1dWgQtO0VQ=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.7 h1:/Cfdu0XV3mONYKaOt1Gr0k1KvQzkzPyiKUdlWJqy+J4=
-github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.7/go.mod h1:bCbAxKDqNvkHxRaIMnyVPXPo+OaPRwvmgzMxbz1VKSA=
-github.com/aws/aws-sdk-go-v2/service/sts v1.30.7 h1:NKTa1eqZYw8tiHSRGpP0VtTdub/8KNk8sDkNPFaOKDE=
-github.com/aws/aws-sdk-go-v2/service/sts v1.30.7/go.mod h1:NXi1dIAGteSaRLqYgarlhP/Ij0cFT+qmCwiJqWh/U5o=
-github.com/aws/smithy-go v1.20.4 h1:2HK1zBdPgRbjFOHlfeQZfpC4r72MOb9bZkiFwggKO+4=
-github.com/aws/smithy-go v1.20.4/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.18 h1:OWYvKL53l1rbsUmW7bQyJVsYU/Ii3bbAAQIIFNbM0Tk=
+github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.18/go.mod h1:CUx0G1v3wG6l01tUB+j7Y8kclA8NSqK4ef0YG79a4cg=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.5 h1:QFASJGfT8wMXtuP3D5CRmMjARHv9ZmzFUMJznHDOY3w=
+github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.5/go.mod h1:QdZ3OmoIjSX+8D1OPAzPxDfjXASbBMDsz9qvtyIhtik=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.20 h1:rTWjG6AvWekO2B1LHeM3ktU7MqyX9rzWQ7hgzneZW7E=
+github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.20/go.mod h1:RGW2DDpVc8hu6Y6yG8G5CHVmVOAn1oV8rNKOHRJyswg=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.20 h1:Xbwbmk44URTiHNx6PNo0ujDE6ERlsCKJD3u1zfnzAPg=
+github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.20/go.mod h1:oAfOFzUB14ltPZj1rWwRc3d/6OgD76R8KlvU3EqM9Fg=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.18 h1:eb+tFOIl9ZsUe2259/BKPeniKuz4/02zZFH/i4Nf8Rg=
+github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.18/go.mod h1:GVCC2IJNJTmdlyEsSmofEy7EfJncP7DNnXDzRjJ5Keg=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.64.0 h1:I0p8knB/IDYSQ3dbanaCr4UhiYQ96bvKRhGYxvLyiD8=
+github.com/aws/aws-sdk-go-v2/service/s3 v1.64.0/go.mod h1:NLTqRLe3pUNu3nTEHI6XlHLKYmc8fbHUdMxAB6+s41Q=
+github.com/aws/aws-sdk-go-v2/service/sso v1.23.3 h1:rs4JCczF805+FDv2tRhZ1NU0RB2H6ryAvsWPanAr72Y=
+github.com/aws/aws-sdk-go-v2/service/sso v1.23.3/go.mod h1:XRlMvmad0ZNL+75C5FYdMvbbLkd6qiqz6foR1nA1PXY=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.27.3 h1:S7EPdMVZod8BGKQQPTBK+FcX9g7bKR7c4+HxWqHP7Vg=
+github.com/aws/aws-sdk-go-v2/service/ssooidc v1.27.3/go.mod h1:FnvDM4sfa+isJ3kDXIzAB9GAwVSzFzSy97uZ3IsHo4E=
+github.com/aws/aws-sdk-go-v2/service/sts v1.31.3 h1:VzudTFrDCIDakXtemR7l6Qzt2+JYsVqo2MxBPt5k8T8=
+github.com/aws/aws-sdk-go-v2/service/sts v1.31.3/go.mod h1:yMWe0F+XG0DkRZK5ODZhG7BEFYhLXi2dqGsv6tX0cgI=
+github.com/aws/smithy-go v1.21.0 h1:H7L8dtDRk0P1Qm6y0ji7MCYMQObJ5R9CRpyPhRUkLYA=
+github.com/aws/smithy-go v1.21.0/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
 github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
 github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
@@ -84,6 +84,8 @@ github.com/domodwyer/mailyak/v3 v3.6.2 h1:x3tGMsyFhTCaxp6ycgR0FE/bu5QiNp+hetUuCO
 github.com/domodwyer/mailyak/v3 v3.6.2/go.mod h1:lOm/u9CyCVWHeaAmHIdF4RiKVxKUT/H5XX10lIKAL6c=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/ebitengine/purego v0.8.0 h1:JbqvnEzRvPpxhCJzJJ2y0RbiZ8nyjccVUrSM3q+GvvE=
+github.com/ebitengine/purego v0.8.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -215,8 +217,8 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pocketbase/dbx v1.10.1 h1:cw+vsyfCJD8YObOVeqb93YErnlxwYMkNZ4rwN0G0AaA=
 github.com/pocketbase/dbx v1.10.1/go.mod h1:xXRCIAKTHMgUCyCKZm55pUOdvFziJjQfXaWKhu2vhMs=
-github.com/pocketbase/pocketbase v0.22.20 h1:yUkhO5bTPWlzD4ZK6EQlS4R3AcHKDlBD+DxxU2BR83I=
-github.com/pocketbase/pocketbase v0.22.20/go.mod h1:Cw5E4uoGhKItBIE2lJL3NfmiUr9Syk2xaNJ2G7Dssow=
+github.com/pocketbase/pocketbase v0.22.21 h1:DGPCxn6co8VuTV0mton4NFO/ON49XiFMszRr+Mysy48=
+github.com/pocketbase/pocketbase v0.22.21/go.mod h1:Cw5E4uoGhKItBIE2lJL3NfmiUr9Syk2xaNJ2G7Dssow=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
 github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -227,12 +229,8 @@ github.com/rhysd/go-github-selfupdate v1.2.3/go.mod h1:mp/N8zj6jFfBQy/XMYoWsmfzx
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shirou/gopsutil/v4 v4.24.8 h1:pVQjIenQkIhqO81mwTaXjTzOMT7d3TZkf43PlVFHENI=
-github.com/shirou/gopsutil/v4 v4.24.8/go.mod h1:wE0OrJtj4dG+hYkxqDH3QiBICdKSf04/npcvLLc/oRg=
-github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
-github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
-github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
-github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
+github.com/shirou/gopsutil/v4 v4.24.9 h1:KIV+/HaHD5ka5f570RZq+2SaeFsb/pq+fp2DGNWYoOI=
+github.com/shirou/gopsutil/v4 v4.24.9/go.mod h1:3fkaHNeYsUFCGZ8+9vZVWtbyM1k2eRnlL+bWO8Bxa/Q=
 github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w=
 github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
 github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
@@ -366,8 +364,8 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da h1:noIWHXmPHxILtqtCOPIhSt0ABwskkZKjD3bXGnZGpNY=
 golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
-google.golang.org/api v0.197.0 h1:x6CwqQLsFiA5JKAiGyGBjc2bNtHtLddhJCE2IKuhhcQ=
-google.golang.org/api v0.197.0/go.mod h1:AuOuo20GoQ331nq7DquGHlU6d+2wN2fZ8O0ta60nRNw=
+google.golang.org/api v0.199.0 h1:aWUXClp+VFJmqE0JPvpZOK3LDQMyFKYIow4etYd9qxs=
+google.golang.org/api v0.199.0/go.mod h1:ohG4qSztDJmZdjK/Ar6MhbAmb/Rpi4JHOqagsh90K28=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
@@ -377,17 +375,17 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20240903143218-8af14fe29dc1 h1:BulPr26Jqjnd4eYDVe+YvyR7Yc2vJGkO5/0UxD0/jZU=
 google.golang.org/genproto v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:hL97c3SYopEHblzpxRL4lSs523++l8DYxGM1FQiYmb4=
-google.golang.org/genproto/googleapis/api v0.0.0-20240812133136-8ffd90a71988 h1:+/tmTy5zAieooKIXfzDm9KiA3Bv6JBwriRN9LY+yayk=
-google.golang.org/genproto/googleapis/api v0.0.0-20240812133136-8ffd90a71988/go.mod h1:4+X6GvPs+25wZKbQq9qyAXrwIRExv7w0Ea6MgZLZiDM=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1 h1:pPJltXNxVzT4pK9yD8vR9X75DaWYYmLGMsEvBfFQZzQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
+google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 h1:wKguEg1hsxI2/L3hUYrpo1RVi48K+uTyzKqprwLXsb8=
+google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240930140551-af27646dc61f h1:cUMEy+8oS78BWIH9OWazBkzbr090Od9tWBNtZHkOhf0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240930140551-af27646dc61f/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.66.2 h1:3QdXkuq3Bkh7w+ywLdLvM56cmGvQHUMZpiCzt6Rqaoo=
-google.golang.org/grpc v1.66.2/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y=
+google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E=
+google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
--- a/beszel/internal/agent/agent.go
+++ b/beszel/internal/agent/agent.go
@@ -2,395 +2,94 @@
 package agent

 import (
-	"beszel"
-	"beszel/internal/entities/container"
 	"beszel/internal/entities/system"
-	"bytes"
 	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"math"
-	"net"
-	"net/http"
-	"net/url"
+	"log/slog"
 	"os"
-	"path/filepath"
-	"strconv"
 	"strings"
-	"sync"
-	"time"

 	"github.com/shirou/gopsutil/v4/common"
-	"github.com/shirou/gopsutil/v4/cpu"
-	"github.com/shirou/gopsutil/v4/disk"
-	"github.com/shirou/gopsutil/v4/host"
-	"github.com/shirou/gopsutil/v4/mem"
-	"github.com/shirou/gopsutil/v4/sensors"
-
-	sshServer "github.com/gliderlabs/ssh"
-	psutilNet "github.com/shirou/gopsutil/v4/net"
 )

 type Agent struct {
-	addr                string
-	pubKey              []byte
-	sem                 chan struct{}
-	containerStatsMap   map[string]*container.PrevContainerStats
-	containerStatsMutex *sync.Mutex
-	fsNames             []string
-	fsStats             map[string]*system.FsStats
-	netInterfaces       map[string]struct{}
-	netIoStats          *system.NetIoStats
-	dockerClient        *http.Client
-	sensorsContext      context.Context
-	bufferPool          *sync.Pool
+	debug            bool                       // true if LOG_LEVEL is set to debug
+	zfs              bool                       // true if system has arcstats
+	memCalc          string                     // Memory calculation formula
+	fsNames          []string                   // List of filesystem device names being monitored
+	fsStats          map[string]*system.FsStats // Keeps track of disk stats for each filesystem
+	netInterfaces    map[string]struct{}        // Stores all valid network interfaces
+	netIoStats       system.NetIoStats          // Keeps track of bandwidth usage
+	dockerManager    *dockerManager             // Manages Docker API requests
+	sensorsContext   context.Context            // Sensors context to override sys location
+	sensorsWhitelist map[string]struct{}        // List of sensors to monitor
+	systemInfo       system.Info                // Host system info
 }

-func NewAgent(pubKey []byte, addr string) *Agent {
+func NewAgent() *Agent {
 	return &Agent{
-		addr:                addr,
-		pubKey:              pubKey,
-		sem:                 make(chan struct{}, 15),
-		containerStatsMap:   make(map[string]*container.PrevContainerStats),
-		containerStatsMutex: &sync.Mutex{},
-		netIoStats:          &system.NetIoStats{},
-		dockerClient:        newDockerClient(),
-		sensorsContext:      context.Background(),
-		bufferPool: &sync.Pool{
-			New: func() interface{} {
-				return new(bytes.Buffer)
-			},
-		},
+		sensorsContext: context.Background(),
+		memCalc:        os.Getenv("MEM_CALC"),
+		fsStats:        make(map[string]*system.FsStats),
 	}
 }

-func (a *Agent) acquireSemaphore() {
-	a.sem <- struct{}{}
-}
-
-func (a *Agent) releaseSemaphore() {
-	<-a.sem
-}
-
-func (a *Agent) getSystemStats() (system.Info, system.Stats) {
-	systemStats := system.Stats{}
-
-	// cpu percent
-	cpuPct, err := cpu.Percent(0, false)
-	if err != nil {
-		log.Println("Error getting cpu percent:", err)
-	} else if len(cpuPct) > 0 {
-		systemStats.Cpu = twoDecimals(cpuPct[0])
-	}
-
-	// memory
-	if v, err := mem.VirtualMemory(); err == nil {
-		systemStats.Mem = bytesToGigabytes(v.Total)
-		systemStats.MemUsed = bytesToGigabytes(v.Used)
-		systemStats.MemBuffCache = bytesToGigabytes(v.Total - v.Free - v.Used)
-		systemStats.MemPct = twoDecimals(v.UsedPercent)
-		systemStats.Swap = bytesToGigabytes(v.SwapTotal)
-		systemStats.SwapUsed = bytesToGigabytes(v.SwapTotal - v.SwapFree)
-	}
-
-	// disk usage
-	for _, stats := range a.fsStats {
-		// log.Println("Reading filesystem:", fs.Mountpoint)
-		if d, err := disk.Usage(stats.Mountpoint); err == nil {
-			stats.DiskTotal = bytesToGigabytes(d.Total)
-			stats.DiskUsed = bytesToGigabytes(d.Used)
-			if stats.Root {
-				systemStats.DiskTotal = bytesToGigabytes(d.Total)
-				systemStats.DiskUsed = bytesToGigabytes(d.Used)
-				systemStats.DiskPct = twoDecimals(d.UsedPercent)
-			}
-		} else {
-			// reset stats if error (likely unmounted)
-			log.Printf("Error reading %s: %+v\n", stats.Mountpoint, err)
-			stats.DiskTotal = 0
-			stats.DiskUsed = 0
-			stats.TotalRead = 0
-			stats.TotalWrite = 0
+func (a *Agent) Run(pubKey []byte, addr string) {
+	// Set up slog with a log level determined by the LOG_LEVEL env var
+	if logLevelStr, exists := os.LookupEnv("LOG_LEVEL"); exists {
+		switch strings.ToLower(logLevelStr) {
+		case "debug":
+			a.debug = true
+			slog.SetLogLoggerLevel(slog.LevelDebug)
+		case "warn":
+			slog.SetLogLoggerLevel(slog.LevelWarn)
+		case "error":
+			slog.SetLogLoggerLevel(slog.LevelError)
 		}
 	}

-	// disk i/o
-	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
-		for _, d := range ioCounters {
-			stats := a.fsStats[d.Name]
-			if stats == nil {
-				continue
-			}
-			secondsElapsed := time.Since(stats.Time).Seconds()
-			readPerSecond := float64(d.ReadBytes-stats.TotalRead) / secondsElapsed
-			writePerSecond := float64(d.WriteBytes-stats.TotalWrite) / secondsElapsed
-			stats.Time = time.Now()
-			stats.DiskReadPs = bytesToMegabytes(readPerSecond)
-			stats.DiskWritePs = bytesToMegabytes(writePerSecond)
-			stats.TotalRead = d.ReadBytes
-			stats.TotalWrite = d.WriteBytes
-			// if root filesystem, update system stats
-			if stats.Root {
-				systemStats.DiskReadPs = stats.DiskReadPs
-				systemStats.DiskWritePs = stats.DiskWritePs
-			}
+	// Set sensors context (allows overriding sys location for sensors)
+	if sysSensors, exists := os.LookupEnv("SYS_SENSORS"); exists {
+		slog.Info("SYS_SENSORS", "path", sysSensors)
+		a.sensorsContext = context.WithValue(a.sensorsContext,
+			common.EnvKey, common.EnvMap{common.HostSysEnvKey: sysSensors},
+		)
+	}
+
+	// Set sensors whitelist
+	if sensors, exists := os.LookupEnv("SENSORS"); exists {
+		a.sensorsWhitelist = make(map[string]struct{})
+		for _, sensor := range strings.Split(sensors, ",") {
+			a.sensorsWhitelist[sensor] = struct{}{}
 		}
 	}

-	// network stats
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		secondsElapsed := time.Since(a.netIoStats.Time).Seconds()
-		a.netIoStats.Time = time.Now()
-		bytesSent := uint64(0)
-		bytesRecv := uint64(0)
-		// sum all bytes sent and received
-		for _, v := range netIO {
-			// skip if not in valid network interfaces list
-			if _, exists := a.netInterfaces[v.Name]; !exists {
-				continue
-			}
-			// log.Printf("%+v: %+v recv, %+v sent\n", v.Name, v.BytesRecv, v.BytesSent)
-			bytesSent += v.BytesSent
-			bytesRecv += v.BytesRecv
-		}
-		// add to systemStats
-		sentPerSecond := float64(bytesSent-a.netIoStats.BytesSent) / secondsElapsed
-		recvPerSecond := float64(bytesRecv-a.netIoStats.BytesRecv) / secondsElapsed
-		networkSentPs := bytesToMegabytes(sentPerSecond)
-		networkRecvPs := bytesToMegabytes(recvPerSecond)
-		// add check for issue (#150) where sent is a massive number
-		if networkSentPs > 10_000 || networkRecvPs > 10_000 {
-			log.Printf("Warning: network sent/recv is %.2f/%.2f MB/s. Resetting stats.\n", networkSentPs, networkRecvPs)
-			for _, v := range netIO {
-				if _, exists := a.netInterfaces[v.Name]; !exists {
-					continue
-				}
-				log.Printf("%+s: %v recv, %v sent\n", v.Name, v.BytesRecv, v.BytesSent)
-			}
-			// reset network I/O stats
-			a.initializeNetIoStats()
-		} else {
-			systemStats.NetworkSent = networkSentPs
-			systemStats.NetworkRecv = networkRecvPs
-			// update netIoStats
-			a.netIoStats.BytesSent = bytesSent
-			a.netIoStats.BytesRecv = bytesRecv
-		}
+	// initialize system info / docker manager
+	a.initializeSystemInfo()
+	a.initializeDiskInfo()
+	a.initializeNetIoStats()
+	a.dockerManager = newDockerManager()
+
+	// if debugging, print stats
+	if a.debug {
+		slog.Debug("Stats", "data", a.gatherStats())
 	}

-	// temperatures
-	if temps, err := sensors.TemperaturesWithContext(a.sensorsContext); err == nil {
-		systemStats.Temperatures = make(map[string]float64)
-		// log.Printf("Temperatures: %+v\n", temps)
-		for i, temp := range temps {
-			if _, ok := systemStats.Temperatures[temp.SensorKey]; ok {
-				// if key already exists, append int to key
-				systemStats.Temperatures[temp.SensorKey+"_"+strconv.Itoa(i)] = twoDecimals(temp.Temperature)
-			} else {
-				systemStats.Temperatures[temp.SensorKey] = twoDecimals(temp.Temperature)
-			}
-		}
-		// log.Printf("Temperature map: %+v\n", systemStats.Temperatures)
-	}
-
-	systemInfo := system.Info{
-		Cpu:          systemStats.Cpu,
-		MemPct:       systemStats.MemPct,
-		DiskPct:      systemStats.DiskPct,
-		AgentVersion: beszel.Version,
-	}
-
-	// add host info
-	if info, err := host.Info(); err == nil {
-		systemInfo.Uptime = info.Uptime
-		systemInfo.Hostname = info.Hostname
-	}
-	// add cpu stats
-	if info, err := cpu.Info(); err == nil && len(info) > 0 {
-		systemInfo.CpuModel = info[0].ModelName
-	}
-	if cores, err := cpu.Counts(false); err == nil {
-		systemInfo.Cores = cores
-	}
-	if threads, err := cpu.Counts(true); err == nil {
-		systemInfo.Threads = threads
-	}
-
-	return systemInfo, systemStats
-}
-
-func (a *Agent) getDockerStats() ([]container.Stats, error) {
-	resp, err := a.dockerClient.Get("http://localhost/containers/json")
-	if err != nil {
-		a.closeIdleConnections(err)
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var containers []container.ApiInfo
-	if err := json.NewDecoder(resp.Body).Decode(&containers); err != nil {
-		log.Printf("Error decoding containers: %+v\n", err)
-		return nil, err
-	}
-
-	containerStats := make([]container.Stats, 0, len(containers))
-	containerStatsMutex := sync.Mutex{}
-
-	// store valid ids to clean up old container ids from map
-	validIds := make(map[string]struct{}, len(containers))
-
-	var wg sync.WaitGroup
-
-	for _, ctr := range containers {
-		ctr.IdShort = ctr.Id[:12]
-		validIds[ctr.IdShort] = struct{}{}
-		// check if container is less than 1 minute old (possible restart)
-		// note: can't use Created field because it's not updated on restart
-		if strings.Contains(ctr.Status, "second") {
-			// if so, remove old container data
-			a.deleteContainerStatsSync(ctr.IdShort)
-		}
-		wg.Add(1)
-		a.acquireSemaphore()
-		go func() {
-			defer a.releaseSemaphore()
-			defer wg.Done()
-			cstats, err := a.getContainerStats(ctr)
-			if err != nil {
-				// close idle connections if error is a network timeout
-				isTimeout := a.closeIdleConnections(err)
-				// delete container from map if not a timeout
-				if !isTimeout {
-					a.deleteContainerStatsSync(ctr.IdShort)
-				}
-				// retry once
-				cstats, err = a.getContainerStats(ctr)
-				if err != nil {
-					log.Printf("Error getting container stats: %+v\n", err)
-					return
-				}
-			}
-			containerStatsMutex.Lock()
-			defer containerStatsMutex.Unlock()
-			containerStats = append(containerStats, cstats)
-		}()
-	}
-
-	wg.Wait()
-
-	for id := range a.containerStatsMap {
-		if _, exists := validIds[id]; !exists {
-			// log.Printf("Removing container cpu map entry: %+v\n", id)
-			delete(a.containerStatsMap, id)
-		}
-	}
-
-	return containerStats, nil
-}
-
-func (a *Agent) getContainerStats(ctr container.ApiInfo) (container.Stats, error) {
-	cStats := container.Stats{}
-
-	resp, err := a.dockerClient.Get("http://localhost/containers/" + ctr.IdShort + "/stats?stream=0&one-shot=1")
-	if err != nil {
-		return cStats, err
-	}
-	defer resp.Body.Close()
-
-	// use a pooled buffer to store the response body
-	buf := a.bufferPool.Get().(*bytes.Buffer)
-	defer a.bufferPool.Put(buf)
-	buf.Reset()
-	_, err = io.Copy(buf, resp.Body)
-	if err != nil {
-		return cStats, err
-	}
-
-	// unmarshal the json data from the buffer
-	var statsJson container.ApiStats
-	if err := json.Unmarshal(buf.Bytes(), &statsJson); err != nil {
-		return cStats, err
-	}
-
-	name := ctr.Names[0][1:]
-
-	// check if container has valid data, otherwise may be in restart loop (#103)
-	if statsJson.MemoryStats.Usage == 0 {
-		return cStats, fmt.Errorf("%s - invalid data", name)
-	}
-
-	// memory (https://docs.docker.com/reference/cli/docker/container/stats/)
-	memCache := statsJson.MemoryStats.Stats["inactive_file"]
-	if memCache == 0 {
-		memCache = statsJson.MemoryStats.Stats["cache"]
-	}
-	usedMemory := statsJson.MemoryStats.Usage - memCache
-
-	a.containerStatsMutex.Lock()
-	defer a.containerStatsMutex.Unlock()
-
-	// add empty values if they doesn't exist in map
-	stats, initialized := a.containerStatsMap[ctr.IdShort]
-	if !initialized {
-		stats = &container.PrevContainerStats{}
-		a.containerStatsMap[ctr.IdShort] = stats
-	}
-
-	// cpu
-	cpuDelta := statsJson.CPUStats.CPUUsage.TotalUsage - stats.Cpu[0]
-	systemDelta := statsJson.CPUStats.SystemUsage - stats.Cpu[1]
-	cpuPct := float64(cpuDelta) / float64(systemDelta) * 100
-	if cpuPct > 100 {
-		return cStats, fmt.Errorf("%s cpu pct greater than 100: %+v", name, cpuPct)
-	}
-	stats.Cpu = [2]uint64{statsJson.CPUStats.CPUUsage.TotalUsage, statsJson.CPUStats.SystemUsage}
-
-	// network
-	var total_sent, total_recv uint64
-	for _, v := range statsJson.Networks {
-		total_sent += v.TxBytes
-		total_recv += v.RxBytes
-	}
-	var sent_delta, recv_delta float64
-	// prevent first run from sending all prev sent/recv bytes
-	if initialized {
-		secondsElapsed := time.Since(stats.Net.Time).Seconds()
-		sent_delta = float64(total_sent-stats.Net.Sent) / secondsElapsed
-		recv_delta = float64(total_recv-stats.Net.Recv) / secondsElapsed
-		// log.Printf("sent delta: %+v, recv delta: %+v\n", sent_delta, recv_delta)
-	}
-	stats.Net.Sent = total_sent
-	stats.Net.Recv = total_recv
-	stats.Net.Time = time.Now()
-
-	// cStats := a.containerStatsPool.Get().(*container.Stats)
-	cStats.Name = name
-	cStats.Cpu = twoDecimals(cpuPct)
-	cStats.Mem = bytesToMegabytes(float64(usedMemory))
-	cStats.NetworkSent = bytesToMegabytes(sent_delta)
-	cStats.NetworkRecv = bytesToMegabytes(recv_delta)
-
-	return cStats, nil
-}
-
-// delete container stats from map using mutex
-func (a *Agent) deleteContainerStatsSync(id string) {
-	a.containerStatsMutex.Lock()
-	defer a.containerStatsMutex.Unlock()
-	delete(a.containerStatsMap, id)
+	a.startServer(pubKey, addr)
 }

 func (a *Agent) gatherStats() system.CombinedData {
-	systemInfo, systemStats := a.getSystemStats()
+	slog.Debug("Getting stats")
 	systemData := system.CombinedData{
-		Stats: systemStats,
-		Info:  systemInfo,
+		Stats: a.getSystemStats(),
+		Info:  a.systemInfo,
 	}
+	slog.Debug("System stats", "data", systemData)
 	// add docker stats
-	if containerStats, err := a.getDockerStats(); err == nil {
+	if containerStats, err := a.dockerManager.getDockerStats(); err == nil {
 		systemData.Containers = containerStats
+		slog.Debug("Docker stats", "data", systemData.Containers)
+	} else {
+		slog.Debug("Error getting docker stats", "err", err)
 	}
 	// add extra filesystems
 	systemData.Stats.ExtraFs = make(map[string]*system.FsStats)
@@ -399,296 +98,6 @@ func (a *Agent) gatherStats() system.CombinedData {
 			systemData.Stats.ExtraFs[name] = stats
 		}
 	}
-	// log.Printf("%+v\n", systemData)
+	slog.Debug("Extra filesystems", "data", systemData.Stats.ExtraFs)
 	return systemData
 }
-
-func (a *Agent) startServer() {
-	sshServer.Handle(a.handleSession)
-
-	log.Printf("Starting SSH server on %s", a.addr)
-	if err := sshServer.ListenAndServe(a.addr, nil, sshServer.NoPty(),
-		sshServer.PublicKeyAuth(func(ctx sshServer.Context, key sshServer.PublicKey) bool {
-			allowed, _, _, _, _ := sshServer.ParseAuthorizedKey(a.pubKey)
-			return sshServer.KeysEqual(key, allowed)
-		}),
-	); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func (a *Agent) handleSession(s sshServer.Session) {
-	stats := a.gatherStats()
-	encoder := json.NewEncoder(s)
-	if err := encoder.Encode(stats); err != nil {
-		log.Println("Error encoding stats:", err.Error())
-		s.Exit(1)
-		return
-	}
-	s.Exit(0)
-}
-
-func (a *Agent) Run() {
-	a.fsStats = make(map[string]*system.FsStats)
-
-	// set sensors context (allows overriding sys location for sensors)
-	if sysSensors, exists := os.LookupEnv("SYS_SENSORS"); exists {
-		// log.Println("Using sys location for sensors:", sysSensors)
-		a.sensorsContext = context.WithValue(a.sensorsContext,
-			common.EnvKey, common.EnvMap{common.HostSysEnvKey: sysSensors},
-		)
-	}
-
-	a.initializeDiskInfo()
-	a.initializeDiskIoStats()
-	a.initializeNetIoStats()
-
-	// log.Printf("Filesystems: %+v\n", a.fsStats)
-	a.startServer()
-}
-
-// Sets up the filesystems to monitor for disk usage and I/O.
-func (a *Agent) initializeDiskInfo() error {
-	filesystem := os.Getenv("FILESYSTEM")
-	hasRoot := false
-
-	// add values from EXTRA_FILESYSTEMS env var to fsStats
-	if extraFilesystems, exists := os.LookupEnv("EXTRA_FILESYSTEMS"); exists {
-		for _, filesystem := range strings.Split(extraFilesystems, ",") {
-			a.fsStats[filepath.Base(filesystem)] = &system.FsStats{}
-		}
-	}
-
-	partitions, err := disk.Partitions(false)
-	if err != nil {
-		return err
-	}
-
-	// if FILESYSTEM env var is set, use it to find root filesystem
-	if filesystem != "" {
-		for _, v := range partitions {
-			// use filesystem env var if matching partition is found
-			if strings.HasSuffix(v.Device, filesystem) || v.Mountpoint == filesystem {
-				a.fsStats[filepath.Base(v.Device)] = &system.FsStats{Root: true, Mountpoint: v.Mountpoint}
-				hasRoot = true
-				break
-			}
-		}
-		if !hasRoot {
-			// if no match, log available partition details
-			log.Printf("Partition details not found for %s:\n", filesystem)
-			for _, v := range partitions {
-				fmt.Printf("%+v\n", v)
-			}
-		}
-	}
-
-	for _, v := range partitions {
-		// binary root fallback - use root mountpoint
-		if !hasRoot && v.Mountpoint == "/" {
-			a.fsStats[filepath.Base(v.Device)] = &system.FsStats{Root: true, Mountpoint: "/"}
-			hasRoot = true
-		}
-		// docker root fallback - use /etc/hosts device if not mapped
-		if !hasRoot && v.Mountpoint == "/etc/hosts" && strings.HasPrefix(v.Device, "/dev") && !strings.Contains(v.Device, "mapper") {
-			a.fsStats[filepath.Base(v.Device)] = &system.FsStats{Root: true, Mountpoint: "/"}
-			hasRoot = true
-		}
-		// check if device is in /extra-filesystem
-		if strings.HasPrefix(v.Mountpoint, "/extra-filesystem") {
-			// add to fsStats if not already there
-			if _, exists := a.fsStats[filepath.Base(v.Device)]; !exists {
-				a.fsStats[filepath.Base(v.Device)] = &system.FsStats{Mountpoint: v.Mountpoint}
-			}
-			continue
-		}
-		// set mountpoints for extra filesystems if passed in via env var
-		for name, stats := range a.fsStats {
-			if strings.HasSuffix(v.Device, name) {
-				stats.Mountpoint = v.Mountpoint
-				break
-			}
-		}
-	}
-
-	// remove extra filesystems that don't have a mountpoint
-	for name, stats := range a.fsStats {
-		if stats.Root {
-			log.Println("Detected root fs:", name)
-		}
-		if stats.Mountpoint == "" {
-			log.Printf("Ignoring %s. No mountpoint found.\n", name)
-			delete(a.fsStats, name)
-		}
-	}
-
-	// if no root filesystem set, use most read device in /proc/diskstats
-	if !hasRoot {
-		rootDevice := findFallbackIoDevice(filepath.Base(filesystem))
-		log.Printf("Using / as mountpoint and %s for I/O\n", rootDevice)
-		a.fsStats[rootDevice] = &system.FsStats{Root: true, Mountpoint: "/"}
-	}
-
-	return nil
-}
-
-// Sets start values for disk I/O stats.
-func (a *Agent) initializeDiskIoStats() {
-	// create slice of fs names to pass to disk.IOCounters
-	a.fsNames = make([]string, 0, len(a.fsStats))
-	for name := range a.fsStats {
-		a.fsNames = append(a.fsNames, name)
-	}
-
-	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
-		for _, d := range ioCounters {
-			if a.fsStats[d.Name] == nil {
-				continue
-			}
-			a.fsStats[d.Name].Time = time.Now()
-			a.fsStats[d.Name].TotalRead = d.ReadBytes
-			a.fsStats[d.Name].TotalWrite = d.WriteBytes
-		}
-	}
-}
-
-func (a *Agent) initializeNetIoStats() {
-	// reset valid network interfaces
-	a.netInterfaces = make(map[string]struct{}, 0)
-
-	// map of network interface names passed in via NICS env var
-	var nicsMap map[string]struct{}
-	nics, nicsEnvExists := os.LookupEnv("NICS")
-	if nicsEnvExists {
-		nicsMap = make(map[string]struct{}, 0)
-		for _, nic := range strings.Split(nics, ",") {
-			nicsMap[nic] = struct{}{}
-		}
-	}
-
-	// reset network I/O stats
-	a.netIoStats.BytesSent = 0
-	a.netIoStats.BytesRecv = 0
-
-	// get intial network I/O stats
-	if netIO, err := psutilNet.IOCounters(true); err == nil {
-		a.netIoStats.Time = time.Now()
-		for _, v := range netIO {
-			switch {
-			// skip if nics exists and the interface is not in the list
-			case nicsEnvExists:
-				if _, nameInNics := nicsMap[v.Name]; !nameInNics {
-					continue
-				}
-			// otherwise run the interface name through the skipNetworkInterface function
-			default:
-				if a.skipNetworkInterface(v) {
-					continue
-				}
-			}
-			log.Printf("Detected network interface: %+v (%+v recv, %+v sent)\n", v.Name, v.BytesRecv, v.BytesSent)
-			a.netIoStats.BytesSent += v.BytesSent
-			a.netIoStats.BytesRecv += v.BytesRecv
-			// store as a valid network interface
-			a.netInterfaces[v.Name] = struct{}{}
-		}
-	}
-}
-
-func bytesToMegabytes(b float64) float64 {
-	return twoDecimals(b / 1048576)
-}
-
-func bytesToGigabytes(b uint64) float64 {
-	return twoDecimals(float64(b) / 1073741824)
-}
-
-func twoDecimals(value float64) float64 {
-	return math.Round(value*100) / 100
-}
-
-func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
-	switch {
-	case strings.HasPrefix(v.Name, "lo"),
-		strings.HasPrefix(v.Name, "docker"),
-		strings.HasPrefix(v.Name, "br-"),
-		strings.HasPrefix(v.Name, "veth"),
-		v.BytesRecv == 0,
-		v.BytesSent == 0:
-		return true
-	default:
-		return false
-	}
-}
-
-func newDockerClient() *http.Client {
-	dockerHost := "unix:///var/run/docker.sock"
-	if dockerHostEnv, exists := os.LookupEnv("DOCKER_HOST"); exists {
-		dockerHost = dockerHostEnv
-	}
-
-	parsedURL, err := url.Parse(dockerHost)
-	if err != nil {
-		log.Fatal("Error parsing DOCKER_HOST: " + err.Error())
-	}
-
-	transport := &http.Transport{
-		ForceAttemptHTTP2:   false,
-		IdleConnTimeout:     90 * time.Second,
-		DisableCompression:  true,
-		MaxConnsPerHost:     20,
-		MaxIdleConnsPerHost: 20,
-		DisableKeepAlives:   false,
-	}
-
-	switch parsedURL.Scheme {
-	case "unix":
-		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
-			return (&net.Dialer{}).DialContext(ctx, "unix", parsedURL.Path)
-		}
-	case "tcp", "http", "https":
-		log.Println("Using DOCKER_HOST: " + dockerHost)
-		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
-			return (&net.Dialer{}).DialContext(ctx, "tcp", parsedURL.Host)
-		}
-	default:
-		log.Fatal("Unsupported DOCKER_HOST: " + parsedURL.Scheme)
-	}
-
-	return &http.Client{
-		Timeout:   time.Second,
-		Transport: transport,
-	}
-}
-
-// closes idle connections on timeouts to prevent reuse of stale connections
-func (a *Agent) closeIdleConnections(err error) (isTimeout bool) {
-	if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-		log.Printf("Closing idle connections. Error: %+v\n", err)
-		a.dockerClient.Transport.(*http.Transport).CloseIdleConnections()
-		return true
-	}
-	return false
-}
-
-// Returns the device with the most reads in /proc/diskstats,
-// or the device specified by the filesystem argument if it exists
-// (fallback in case the root device is not supplied or detected)
-func findFallbackIoDevice(filesystem string) string {
-	var maxReadBytes uint64
-	maxReadDevice := "/"
-	counters, err := disk.IOCounters()
-	if err != nil {
-		return maxReadDevice
-	}
-	for _, d := range counters {
-		if d.Name == filesystem {
-			return d.Name
-		}
-		if d.ReadBytes > maxReadBytes {
-			maxReadBytes = d.ReadBytes
-			maxReadDevice = d.Name
-		}
-	}
-	return maxReadDevice
-}
--- a/beszel/internal/agent/disk.go
+++ b/beszel/internal/agent/disk.go
@@ -0,0 +1,169 @@
+package agent
+
+import (
+	"beszel/internal/entities/system"
+	"log/slog"
+	"time"
+
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/shirou/gopsutil/v4/disk"
+)
+
+// Sets up the filesystems to monitor for disk usage and I/O.
+func (a *Agent) initializeDiskInfo() {
+	filesystem := os.Getenv("FILESYSTEM")
+	efPath := "/extra-filesystems"
+	hasRoot := false
+
+	partitions, err := disk.Partitions(false)
+	if err != nil {
+		slog.Error("Error getting disk partitions", "err", err)
+	}
+	slog.Debug("Disk", "partitions", partitions)
+
+	// ioContext := context.WithValue(a.sensorsContext,
+	// 	common.EnvKey, common.EnvMap{common.HostProcEnvKey: "/tmp/testproc"},
+	// )
+	// diskIoCounters, err := disk.IOCountersWithContext(ioContext)
+
+	diskIoCounters, err := disk.IOCounters()
+	if err != nil {
+		slog.Error("Error getting diskstats", "err", err)
+	}
+	slog.Debug("Disk I/O", "diskstats", diskIoCounters)
+
+	// Helper function to add a filesystem to fsStats if it doesn't exist
+	addFsStat := func(device, mountpoint string, root bool) {
+		key := filepath.Base(device)
+		if _, exists := a.fsStats[key]; !exists {
+			if root {
+				slog.Info("Detected root device", "name", key)
+				// check if root device is in /proc/diskstats, use fallback if not
+				if _, exists := diskIoCounters[key]; !exists {
+					slog.Warn("Device not found in diskstats", "name", key)
+					key = findFallbackIoDevice(filesystem, diskIoCounters, a.fsStats)
+					slog.Info("Using I/O fallback", "name", key)
+				}
+			}
+			a.fsStats[key] = &system.FsStats{Root: root, Mountpoint: mountpoint}
+		}
+	}
+
+	// Use FILESYSTEM env var to find root filesystem
+	if filesystem != "" {
+		for _, p := range partitions {
+			if strings.HasSuffix(p.Device, filesystem) || p.Mountpoint == filesystem {
+				addFsStat(p.Device, p.Mountpoint, true)
+				hasRoot = true
+				break
+			}
+		}
+		if !hasRoot {
+			slog.Warn("Partition details not found", "filesystem", filesystem)
+		}
+	}
+
+	// Add EXTRA_FILESYSTEMS env var values to fsStats
+	if extraFilesystems, exists := os.LookupEnv("EXTRA_FILESYSTEMS"); exists {
+		for _, fs := range strings.Split(extraFilesystems, ",") {
+			found := false
+			for _, p := range partitions {
+				if strings.HasSuffix(p.Device, fs) || p.Mountpoint == fs {
+					addFsStat(p.Device, p.Mountpoint, false)
+					found = true
+					break
+				}
+			}
+			// if not in partitions, test if we can get disk usage
+			if !found {
+				if _, err := disk.Usage(fs); err == nil {
+					addFsStat(filepath.Base(fs), fs, false)
+				} else {
+					slog.Error("Invalid filesystem", "name", fs, "err", err)
+				}
+			}
+		}
+	}
+
+	// Process partitions for various mount points
+	for _, p := range partitions {
+		// fmt.Println(p.Device, p.Mountpoint)
+		// Binary root fallback or docker root fallback
+		if !hasRoot && (p.Mountpoint == "/" || (p.Mountpoint == "/etc/hosts" && strings.HasPrefix(p.Device, "/dev") && !strings.Contains(p.Device, "mapper"))) {
+			addFsStat(p.Device, "/", true)
+			hasRoot = true
+		}
+
+		// Check if device is in /extra-filesystems
+		if strings.HasPrefix(p.Mountpoint, efPath) {
+			addFsStat(p.Device, p.Mountpoint, false)
+		}
+	}
+
+	// Check all folders in /extra-filesystems and add them if not already present
+	if folders, err := os.ReadDir(efPath); err == nil {
+		existingMountpoints := make(map[string]bool)
+		for _, stats := range a.fsStats {
+			existingMountpoints[stats.Mountpoint] = true
+		}
+		for _, folder := range folders {
+			if folder.IsDir() {
+				mountpoint := filepath.Join(efPath, folder.Name())
+				slog.Debug("/extra-filesystems", "mountpoint", mountpoint)
+				if !existingMountpoints[mountpoint] {
+					a.fsStats[folder.Name()] = &system.FsStats{Mountpoint: mountpoint}
+				}
+			}
+		}
+	}
+
+	// If no root filesystem set, use fallback
+	if !hasRoot {
+		rootDevice := findFallbackIoDevice(filepath.Base(filesystem), diskIoCounters, a.fsStats)
+		slog.Info("Root disk", "mountpoint", "/", "io", rootDevice)
+		a.fsStats[rootDevice] = &system.FsStats{Root: true, Mountpoint: "/"}
+	}
+
+	a.initializeDiskIoStats(diskIoCounters)
+}
+
+// Returns the device with the most reads in /proc/diskstats,
+// or the device specified by the filesystem argument if it exists
+func findFallbackIoDevice(filesystem string, diskIoCounters map[string]disk.IOCountersStat, fsStats map[string]*system.FsStats) string {
+	var maxReadBytes uint64
+	maxReadDevice := "/"
+	for _, d := range diskIoCounters {
+		if d.Name == filesystem {
+			return d.Name
+		}
+		if d.ReadBytes > maxReadBytes {
+			// don't use if device already exists in fsStats
+			if _, exists := fsStats[d.Name]; !exists {
+				maxReadBytes = d.ReadBytes
+				maxReadDevice = d.Name
+			}
+		}
+	}
+	return maxReadDevice
+}
+
+// Sets start values for disk I/O stats.
+func (a *Agent) initializeDiskIoStats(diskIoCounters map[string]disk.IOCountersStat) {
+	for device, stats := range a.fsStats {
+		// skip if not in diskIoCounters
+		d, exists := diskIoCounters[device]
+		if !exists {
+			slog.Warn("Device not found in diskstats", "name", device)
+			continue
+		}
+		// populate initial values
+		stats.Time = time.Now()
+		stats.TotalRead = d.ReadBytes
+		stats.TotalWrite = d.WriteBytes
+		// add to list of valid io device names
+		a.fsNames = append(a.fsNames, device)
+	}
+}
--- a/beszel/internal/agent/docker.go
+++ b/beszel/internal/agent/docker.go
@@ -0,0 +1,254 @@
+package agent
+
+import (
+	"beszel/internal/entities/container"
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/blang/semver"
+)
+
+type dockerManager struct {
+	client              *http.Client                // Client to query Docker API
+	wg                  sync.WaitGroup              // WaitGroup to wait for all goroutines to finish
+	sem                 chan struct{}               // Semaphore to limit concurrent container requests
+	containerStatsMutex sync.RWMutex                // Mutex to prevent concurrent access to containerStatsMap
+	apiContainerList    *[]container.ApiInfo        // List of containers from Docker API
+	containerStatsMap   map[string]*container.Stats // Keeps track of container stats
+	validIds            map[string]struct{}         // Map of valid container ids, used to prune invalid containers from containerStatsMap
+}
+
+// Add goroutine to the queue
+func (d *dockerManager) queue() {
+	d.sem <- struct{}{}
+	d.wg.Add(1)
+}
+
+// Remove goroutine from the queue
+func (d *dockerManager) dequeue() {
+	<-d.sem
+	d.wg.Done()
+}
+
+// Returns stats for all running containers
+func (dm *dockerManager) getDockerStats() ([]*container.Stats, error) {
+	resp, err := dm.client.Get("http://localhost/containers/json")
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if err := json.NewDecoder(resp.Body).Decode(&dm.apiContainerList); err != nil {
+		return nil, err
+	}
+
+	containersLength := len(*dm.apiContainerList)
+
+	// store valid ids to clean up old container ids from map
+	if dm.validIds == nil {
+		dm.validIds = make(map[string]struct{}, containersLength)
+	} else {
+		clear(dm.validIds)
+	}
+
+	for _, ctr := range *dm.apiContainerList {
+		ctr.IdShort = ctr.Id[:12]
+		dm.validIds[ctr.IdShort] = struct{}{}
+		// check if container is less than 1 minute old (possible restart)
+		// note: can't use Created field because it's not updated on restart
+		if strings.Contains(ctr.Status, "second") {
+			// if so, remove old container data
+			dm.deleteContainerStatsSync(ctr.IdShort)
+		}
+		dm.queue()
+		go func() {
+			defer dm.dequeue()
+			err := dm.updateContainerStats(ctr)
+			if err != nil {
+				dm.deleteContainerStatsSync(ctr.IdShort)
+				// retry once
+				err = dm.updateContainerStats(ctr)
+				if err != nil {
+					slog.Error("Error getting container stats", "err", err)
+				}
+			}
+		}()
+	}
+
+	dm.wg.Wait()
+
+	// populate final stats and remove old / invalid container stats
+	stats := make([]*container.Stats, 0, containersLength)
+	for id, v := range dm.containerStatsMap {
+		if _, exists := dm.validIds[id]; !exists {
+			delete(dm.containerStatsMap, id)
+		} else {
+			stats = append(stats, v)
+		}
+	}
+
+	return stats, nil
+}
+
+// Updates stats for individual container
+func (dm *dockerManager) updateContainerStats(ctr container.ApiInfo) error {
+	name := ctr.Names[0][1:]
+
+	resp, err := dm.client.Get("http://localhost/containers/" + ctr.IdShort + "/stats?stream=0&one-shot=1")
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	dm.containerStatsMutex.Lock()
+	defer dm.containerStatsMutex.Unlock()
+
+	// add empty values if they doesn't exist in map
+	stats, initialized := dm.containerStatsMap[ctr.IdShort]
+	if !initialized {
+		stats = &container.Stats{Name: name}
+		dm.containerStatsMap[ctr.IdShort] = stats
+	}
+
+	// reset current stats
+	stats.Cpu = 0
+	stats.Mem = 0
+	stats.NetworkSent = 0
+	stats.NetworkRecv = 0
+
+	// docker host container stats response
+	var res container.ApiStats
+	if err := json.NewDecoder(resp.Body).Decode(&res); err != nil {
+		return err
+	}
+
+	// check if container has valid data, otherwise may be in restart loop (#103)
+	if res.MemoryStats.Usage == 0 {
+		return fmt.Errorf("%s - no memory stats - see https://github.com/henrygd/beszel/issues/144", name)
+	}
+
+	// memory (https://docs.docker.com/reference/cli/docker/container/stats/)
+	memCache := res.MemoryStats.Stats.InactiveFile
+	if memCache == 0 {
+		memCache = res.MemoryStats.Stats.Cache
+	}
+	usedMemory := res.MemoryStats.Usage - memCache
+
+	// cpu
+	cpuDelta := res.CPUStats.CPUUsage.TotalUsage - stats.PrevCpu[0]
+	systemDelta := res.CPUStats.SystemUsage - stats.PrevCpu[1]
+	cpuPct := float64(cpuDelta) / float64(systemDelta) * 100
+	if cpuPct > 100 {
+		return fmt.Errorf("%s cpu pct greater than 100: %+v", name, cpuPct)
+	}
+	stats.PrevCpu = [2]uint64{res.CPUStats.CPUUsage.TotalUsage, res.CPUStats.SystemUsage}
+
+	// network
+	var total_sent, total_recv uint64
+	for _, v := range res.Networks {
+		total_sent += v.TxBytes
+		total_recv += v.RxBytes
+	}
+	var sent_delta, recv_delta float64
+	// prevent first run from sending all prev sent/recv bytes
+	if initialized {
+		secondsElapsed := time.Since(stats.PrevNet.Time).Seconds()
+		sent_delta = float64(total_sent-stats.PrevNet.Sent) / secondsElapsed
+		recv_delta = float64(total_recv-stats.PrevNet.Recv) / secondsElapsed
+	}
+	stats.PrevNet.Sent = total_sent
+	stats.PrevNet.Recv = total_recv
+	stats.PrevNet.Time = time.Now()
+
+	stats.Cpu = twoDecimals(cpuPct)
+	stats.Mem = bytesToMegabytes(float64(usedMemory))
+	stats.NetworkSent = bytesToMegabytes(sent_delta)
+	stats.NetworkRecv = bytesToMegabytes(recv_delta)
+
+	return nil
+}
+
+// Delete container stats from map using mutex
+func (dm *dockerManager) deleteContainerStatsSync(id string) {
+	dm.containerStatsMutex.Lock()
+	defer dm.containerStatsMutex.Unlock()
+	delete(dm.containerStatsMap, id)
+}
+
+// Creates a new http client for Docker API
+func newDockerManager() *dockerManager {
+	dockerHost := "unix:///var/run/docker.sock"
+	if dockerHostEnv, exists := os.LookupEnv("DOCKER_HOST"); exists {
+		slog.Info("DOCKER_HOST", "host", dockerHostEnv)
+		dockerHost = dockerHostEnv
+	}
+
+	parsedURL, err := url.Parse(dockerHost)
+	if err != nil {
+		slog.Error("Error parsing DOCKER_HOST", "err", err)
+		os.Exit(1)
+	}
+
+	transport := &http.Transport{
+		DisableCompression: true,
+		MaxConnsPerHost:    0,
+	}
+
+	switch parsedURL.Scheme {
+	case "unix":
+		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
+			return (&net.Dialer{}).DialContext(ctx, "unix", parsedURL.Path)
+		}
+	case "tcp", "http", "https":
+		transport.DialContext = func(ctx context.Context, proto, addr string) (net.Conn, error) {
+			return (&net.Dialer{}).DialContext(ctx, "tcp", parsedURL.Host)
+		}
+	default:
+		slog.Error("Invalid DOCKER_HOST", "scheme", parsedURL.Scheme)
+		os.Exit(1)
+	}
+
+	dockerClient := &dockerManager{
+		client: &http.Client{
+			Timeout:   time.Second * 8,
+			Transport: transport,
+		},
+		containerStatsMap: make(map[string]*container.Stats),
+	}
+
+	// Make sure sem is initialized
+	concurrency := 200
+	defer func() { dockerClient.sem = make(chan struct{}, concurrency) }()
+
+	// Check docker version
+	// (versions before 25.0.0 have a bug with one-shot which requires all requests to be made in one batch)
+	var versionInfo struct {
+		Version string `json:"Version"`
+	}
+	resp, err := dockerClient.client.Get("http://localhost/version")
+	if err != nil {
+		return dockerClient
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&versionInfo); err != nil {
+		return dockerClient
+	}
+
+	// if version > 24, one-shot works correctly and we can limit concurrent operations
+	if dockerVersion, err := semver.Parse(versionInfo.Version); err == nil && dockerVersion.Major > 24 {
+		concurrency = 5
+		dockerClient.client.Timeout = time.Millisecond * 1100
+	}
+	slog.Debug("Docker", "version", versionInfo.Version, "concurrency", concurrency)
+
+	return dockerClient
+}
--- a/beszel/internal/agent/network.go
+++ b/beszel/internal/agent/network.go
@@ -0,0 +1,67 @@
+package agent
+
+import (
+	"log/slog"
+	"os"
+	"strings"
+	"time"
+
+	psutilNet "github.com/shirou/gopsutil/v4/net"
+)
+
+func (a *Agent) initializeNetIoStats() {
+	// reset valid network interfaces
+	a.netInterfaces = make(map[string]struct{}, 0)
+
+	// map of network interface names passed in via NICS env var
+	var nicsMap map[string]struct{}
+	nics, nicsEnvExists := os.LookupEnv("NICS")
+	if nicsEnvExists {
+		nicsMap = make(map[string]struct{}, 0)
+		for _, nic := range strings.Split(nics, ",") {
+			nicsMap[nic] = struct{}{}
+		}
+	}
+
+	// reset network I/O stats
+	a.netIoStats.BytesSent = 0
+	a.netIoStats.BytesRecv = 0
+
+	// get intial network I/O stats
+	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		a.netIoStats.Time = time.Now()
+		for _, v := range netIO {
+			switch {
+			// skip if nics exists and the interface is not in the list
+			case nicsEnvExists:
+				if _, nameInNics := nicsMap[v.Name]; !nameInNics {
+					continue
+				}
+			// otherwise run the interface name through the skipNetworkInterface function
+			default:
+				if a.skipNetworkInterface(v) {
+					continue
+				}
+			}
+			slog.Info("Detected network interface", "name", v.Name, "sent", v.BytesSent, "recv", v.BytesRecv)
+			a.netIoStats.BytesSent += v.BytesSent
+			a.netIoStats.BytesRecv += v.BytesRecv
+			// store as a valid network interface
+			a.netInterfaces[v.Name] = struct{}{}
+		}
+	}
+}
+
+func (a *Agent) skipNetworkInterface(v psutilNet.IOCountersStat) bool {
+	switch {
+	case strings.HasPrefix(v.Name, "lo"),
+		strings.HasPrefix(v.Name, "docker"),
+		strings.HasPrefix(v.Name, "br-"),
+		strings.HasPrefix(v.Name, "veth"),
+		v.BytesRecv == 0,
+		v.BytesSent == 0:
+		return true
+	default:
+		return false
+	}
+}
--- a/beszel/internal/agent/server.go
+++ b/beszel/internal/agent/server.go
@@ -0,0 +1,34 @@
+package agent
+
+import (
+	"encoding/json"
+	"log/slog"
+	"os"
+
+	sshServer "github.com/gliderlabs/ssh"
+)
+
+func (a *Agent) startServer(pubKey []byte, addr string) {
+	sshServer.Handle(a.handleSession)
+
+	slog.Info("Starting SSH server", "address", addr)
+	if err := sshServer.ListenAndServe(addr, nil, sshServer.NoPty(),
+		sshServer.PublicKeyAuth(func(ctx sshServer.Context, key sshServer.PublicKey) bool {
+			allowed, _, _, _, _ := sshServer.ParseAuthorizedKey(pubKey)
+			return sshServer.KeysEqual(key, allowed)
+		}),
+	); err != nil {
+		slog.Error("Error starting SSH server", "err", err)
+		os.Exit(1)
+	}
+}
+
+func (a *Agent) handleSession(s sshServer.Session) {
+	stats := a.gatherStats()
+	if err := json.NewEncoder(s).Encode(stats); err != nil {
+		slog.Error("Error encoding stats", "err", err)
+		s.Exit(1)
+		return
+	}
+	s.Exit(0)
+}
--- a/beszel/internal/agent/system.go
+++ b/beszel/internal/agent/system.go
@@ -0,0 +1,240 @@
+package agent
+
+import (
+	"beszel"
+	"beszel/internal/entities/system"
+	"bufio"
+	"fmt"
+	"log/slog"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/disk"
+	"github.com/shirou/gopsutil/v4/host"
+	"github.com/shirou/gopsutil/v4/mem"
+	psutilNet "github.com/shirou/gopsutil/v4/net"
+	"github.com/shirou/gopsutil/v4/sensors"
+)
+
+// Sets initial / non-changing values about the host system
+func (a *Agent) initializeSystemInfo() {
+	a.systemInfo.AgentVersion = beszel.Version
+	a.systemInfo.Hostname, _ = os.Hostname()
+	a.systemInfo.KernelVersion, _ = host.KernelVersion()
+
+	// cpu model
+	if info, err := cpu.Info(); err == nil && len(info) > 0 {
+		a.systemInfo.CpuModel = info[0].ModelName
+	}
+	// cores / threads
+	a.systemInfo.Cores, _ = cpu.Counts(false)
+	if threads, err := cpu.Counts(true); err == nil {
+		if threads > 0 && threads < a.systemInfo.Cores {
+			// in lxc logical cores reflects container limits, so use that as cores if lower
+			a.systemInfo.Cores = threads
+		} else {
+			a.systemInfo.Threads = threads
+		}
+	}
+
+	// zfs
+	if _, err := getARCSize(); err == nil {
+		a.zfs = true
+	} else {
+		slog.Debug("Not monitoring ZFS ARC", "err", err)
+	}
+}
+
+// Returns current info, stats about the host system
+func (a *Agent) getSystemStats() system.Stats {
+	systemStats := system.Stats{}
+
+	// cpu percent
+	cpuPct, err := cpu.Percent(0, false)
+	if err != nil {
+		slog.Error("Error getting cpu percent", "err", err)
+	} else if len(cpuPct) > 0 {
+		systemStats.Cpu = twoDecimals(cpuPct[0])
+	}
+
+	// memory
+	if v, err := mem.VirtualMemory(); err == nil {
+		// swap
+		systemStats.Swap = bytesToGigabytes(v.SwapTotal)
+		systemStats.SwapUsed = bytesToGigabytes(v.SwapTotal - v.SwapFree - v.SwapCached)
+		// cache + buffers value for default mem calculation
+		cacheBuff := v.Total - v.Free - v.Used
+		// htop memory calculation overrides
+		if a.memCalc == "htop" {
+			// note: gopsutil automatically adds SReclaimable to v.Cached
+			cacheBuff = v.Cached + v.Buffers - v.Shared
+			v.Used = v.Total - (v.Free + cacheBuff)
+			v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
+		}
+		// subtract ZFS ARC size from used memory and add as its own category
+		if a.zfs {
+			if arcSize, _ := getARCSize(); arcSize > 0 && arcSize < v.Used {
+				v.Used = v.Used - arcSize
+				v.UsedPercent = float64(v.Used) / float64(v.Total) * 100.0
+				systemStats.MemZfsArc = bytesToGigabytes(arcSize)
+			}
+		}
+		systemStats.Mem = bytesToGigabytes(v.Total)
+		systemStats.MemBuffCache = bytesToGigabytes(cacheBuff)
+		systemStats.MemUsed = bytesToGigabytes(v.Used)
+		systemStats.MemPct = twoDecimals(v.UsedPercent)
+	}
+
+	// disk usage
+	for _, stats := range a.fsStats {
+		if d, err := disk.Usage(stats.Mountpoint); err == nil {
+			stats.DiskTotal = bytesToGigabytes(d.Total)
+			stats.DiskUsed = bytesToGigabytes(d.Used)
+			if stats.Root {
+				systemStats.DiskTotal = bytesToGigabytes(d.Total)
+				systemStats.DiskUsed = bytesToGigabytes(d.Used)
+				systemStats.DiskPct = twoDecimals(d.UsedPercent)
+			}
+		} else {
+			// reset stats if error (likely unmounted)
+			slog.Error("Error getting disk stats", "name", stats.Mountpoint, "err", err)
+			stats.DiskTotal = 0
+			stats.DiskUsed = 0
+			stats.TotalRead = 0
+			stats.TotalWrite = 0
+		}
+	}
+
+	// disk i/o
+	if ioCounters, err := disk.IOCounters(a.fsNames...); err == nil {
+		for _, d := range ioCounters {
+			stats := a.fsStats[d.Name]
+			if stats == nil {
+				continue
+			}
+			secondsElapsed := time.Since(stats.Time).Seconds()
+			readPerSecond := float64(d.ReadBytes-stats.TotalRead) / secondsElapsed
+			writePerSecond := float64(d.WriteBytes-stats.TotalWrite) / secondsElapsed
+			stats.Time = time.Now()
+			stats.DiskReadPs = bytesToMegabytes(readPerSecond)
+			stats.DiskWritePs = bytesToMegabytes(writePerSecond)
+			stats.TotalRead = d.ReadBytes
+			stats.TotalWrite = d.WriteBytes
+			// if root filesystem, update system stats
+			if stats.Root {
+				systemStats.DiskReadPs = stats.DiskReadPs
+				systemStats.DiskWritePs = stats.DiskWritePs
+			}
+		}
+	}
+
+	// network stats
+	if netIO, err := psutilNet.IOCounters(true); err == nil {
+		secondsElapsed := time.Since(a.netIoStats.Time).Seconds()
+		a.netIoStats.Time = time.Now()
+		bytesSent := uint64(0)
+		bytesRecv := uint64(0)
+		// sum all bytes sent and received
+		for _, v := range netIO {
+			// skip if not in valid network interfaces list
+			if _, exists := a.netInterfaces[v.Name]; !exists {
+				continue
+			}
+			bytesSent += v.BytesSent
+			bytesRecv += v.BytesRecv
+		}
+		// add to systemStats
+		sentPerSecond := float64(bytesSent-a.netIoStats.BytesSent) / secondsElapsed
+		recvPerSecond := float64(bytesRecv-a.netIoStats.BytesRecv) / secondsElapsed
+		networkSentPs := bytesToMegabytes(sentPerSecond)
+		networkRecvPs := bytesToMegabytes(recvPerSecond)
+		// add check for issue (#150) where sent is a massive number
+		if networkSentPs > 10_000 || networkRecvPs > 10_000 {
+			slog.Warn("Invalid network stats. Resetting.", "sent", networkSentPs, "recv", networkRecvPs)
+			for _, v := range netIO {
+				if _, exists := a.netInterfaces[v.Name]; !exists {
+					continue
+				}
+				slog.Info(v.Name, "recv", v.BytesRecv, "sent", v.BytesSent)
+			}
+			// reset network I/O stats
+			a.initializeNetIoStats()
+		} else {
+			systemStats.NetworkSent = networkSentPs
+			systemStats.NetworkRecv = networkRecvPs
+			// update netIoStats
+			a.netIoStats.BytesSent = bytesSent
+			a.netIoStats.BytesRecv = bytesRecv
+		}
+	}
+
+	// temperatures
+	temps, err := sensors.TemperaturesWithContext(a.sensorsContext)
+	if err != nil && a.debug {
+		err.(*sensors.Warnings).Verbose = true
+		slog.Debug("Sensor error", "errs", err)
+	}
+	if len(temps) > 0 {
+		slog.Debug("Temperatures", "data", temps)
+		systemStats.Temperatures = make(map[string]float64, len(temps))
+		for i, sensor := range temps {
+			// skip if temperature is 0
+			if sensor.Temperature <= 0 || sensor.Temperature >= 200 {
+				continue
+			}
+			if _, ok := systemStats.Temperatures[sensor.SensorKey]; ok {
+				// if key already exists, append int to key
+				systemStats.Temperatures[sensor.SensorKey+"_"+strconv.Itoa(i)] = twoDecimals(sensor.Temperature)
+			} else {
+				systemStats.Temperatures[sensor.SensorKey] = twoDecimals(sensor.Temperature)
+			}
+		}
+		// remove sensors from systemStats if whitelist exists and sensor is not in whitelist
+		// (do this here instead of in initial loop so we have correct keys if int was appended)
+		if a.sensorsWhitelist != nil {
+			for key := range systemStats.Temperatures {
+				if _, nameInWhitelist := a.sensorsWhitelist[key]; !nameInWhitelist {
+					delete(systemStats.Temperatures, key)
+				}
+			}
+		}
+	}
+
+	// update base system info
+	a.systemInfo.Cpu = systemStats.Cpu
+	a.systemInfo.MemPct = systemStats.MemPct
+	a.systemInfo.DiskPct = systemStats.DiskPct
+	a.systemInfo.Uptime, _ = host.Uptime()
+	a.systemInfo.Bandwidth = twoDecimals(systemStats.NetworkSent + systemStats.NetworkRecv)
+
+	return systemStats
+}
+
+// Returns the size of the ZFS ARC memory cache in bytes
+func getARCSize() (uint64, error) {
+	file, err := os.Open("/proc/spl/kstat/zfs/arcstats")
+	if err != nil {
+		return 0, err
+	}
+	defer file.Close()
+
+	// Scan the lines
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "size") {
+			// Example line: size 4 15032385536
+			fields := strings.Fields(line)
+			if len(fields) < 3 {
+				return 0, err
+			}
+			// Return the size as uint64
+			return strconv.ParseUint(fields[2], 10, 64)
+		}
+	}
+
+	return 0, fmt.Errorf("failed to parse size field")
+}
--- a/beszel/internal/update/update.go
+++ b/beszel/internal/update/update.go
@@ -1,5 +1,4 @@
-// Package update handles updating beszel and beszel-agent.
-package update
+package agent

 import (
 	"beszel"
@@ -11,51 +10,8 @@ import (
 	"github.com/rhysd/go-github-selfupdate/selfupdate"
 )

-func UpdateBeszel() {
-	var latest *selfupdate.Release
-	var found bool
-	var err error
-	currentVersion := semver.MustParse(beszel.Version)
-	fmt.Println("beszel", currentVersion)
-	fmt.Println("Checking for updates...")
-	updater, _ := selfupdate.NewUpdater(selfupdate.Config{
-		Filters: []string{"beszel_"},
-	})
-	latest, found, err = updater.DetectLatest("henrygd/beszel")
-
-	if err != nil {
-		fmt.Println("Error checking for updates:", err)
-		os.Exit(1)
-	}
-
-	if !found {
-		fmt.Println("No updates found")
-		os.Exit(0)
-	}
-
-	fmt.Println("Latest version:", latest.Version)
-
-	if latest.Version.LTE(currentVersion) {
-		fmt.Println("You are up to date")
-		return
-	}
-
-	var binaryPath string
-	fmt.Printf("Updating from %s to %s...\n", currentVersion, latest.Version)
-	binaryPath, err = os.Executable()
-	if err != nil {
-		fmt.Println("Error getting binary path:", err)
-		os.Exit(1)
-	}
-	err = selfupdate.UpdateTo(latest.AssetURL, binaryPath)
-	if err != nil {
-		fmt.Println("Please try rerunning with sudo. Error:", err)
-		os.Exit(1)
-	}
-	fmt.Printf("Successfully updated to %s\n\n%s\n", latest.Version, strings.TrimSpace(latest.ReleaseNotes))
-}
-
-func UpdateBeszelAgent() {
+// Update updates beszel-agent to the latest version
+func Update() {
 	var latest *selfupdate.Release
 	var found bool
 	var err error
--- a/beszel/internal/agent/utils.go
+++ b/beszel/internal/agent/utils.go
@@ -0,0 +1,15 @@
+package agent
+
+import "math"
+
+func bytesToMegabytes(b float64) float64 {
+	return twoDecimals(b / 1048576)
+}
+
+func bytesToGigabytes(b uint64) float64 {
+	return twoDecimals(float64(b) / 1073741824)
+}
+
+func twoDecimals(value float64) float64 {
+	return math.Round(value*100) / 100
+}
--- a/beszel/internal/alerts/alerts.go
+++ b/beszel/internal/alerts/alerts.go
@@ -6,21 +6,26 @@ import (
 	"fmt"
 	"net/mail"
 	"net/url"
+	"strings"
+	"time"

 	"github.com/containrrr/shoutrrr"
+	"github.com/goccy/go-json"
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/models"
 	"github.com/pocketbase/pocketbase/tools/mailer"
+	"github.com/pocketbase/pocketbase/tools/types"
+	"github.com/spf13/cast"
 )

 type AlertManager struct {
 	app *pocketbase.PocketBase
 }

-type AlertData struct {
+type AlertMessageData struct {
 	UserID   string
 	Title    string
 	Message  string
@@ -33,83 +38,304 @@ type UserNotificationSettings struct {
 	Webhooks []string `json:"webhooks"`
 }

+type SystemAlertStats struct {
+	Cpu          float64            `json:"cpu"`
+	Mem          float64            `json:"mp"`
+	Disk         float64            `json:"dp"`
+	NetSent      float64            `json:"ns"`
+	NetRecv      float64            `json:"nr"`
+	Temperatures map[string]float32 `json:"t"`
+}
+
+type SystemAlertData struct {
+	systemRecord *models.Record
+	alertRecord  *models.Record
+	name         string
+	unit         string
+	val          float64
+	threshold    float64
+	triggered    bool
+	time         time.Time
+	count        uint8
+	min          uint8
+	mapSums      map[string]float32
+	descriptor   string // override descriptor in notification body (for temp sensor, disk partition, etc)
+}
+
 func NewAlertManager(app *pocketbase.PocketBase) *AlertManager {
 	return &AlertManager{
 		app: app,
 	}
 }

-func (am *AlertManager) HandleSystemAlerts(newStatus string, newRecord *models.Record, oldRecord *models.Record) {
+func (am *AlertManager) HandleSystemAlerts(systemRecord *models.Record, systemInfo system.Info, temperatures map[string]float64, extraFs map[string]*system.FsStats) error {
+	// start := time.Now()
+	// defer func() {
+	// 	log.Println("alert stats took", time.Since(start))
+	// }()
 	alertRecords, err := am.app.Dao().FindRecordsByExpr("alerts",
-		dbx.NewExp("system = {:system}", dbx.Params{"system": oldRecord.GetId()}),
+		dbx.NewExp("system={:system}", dbx.Params{"system": systemRecord.Id}),
 	)
 	if err != nil || len(alertRecords) == 0 {
 		// log.Println("no alerts found for system")
-		return
+		return nil
 	}
-	// log.Println("found alerts", len(alertRecords))
-	var systemInfo *system.Info
+
+	var validAlerts []SystemAlertData
+	now := systemRecord.Updated.Time().UTC()
+	oldestTime := now
+
 	for _, alertRecord := range alertRecords {
 		name := alertRecord.GetString("name")
+		var val float64
+		unit := "%"
+
 		switch name {
-		case "Status":
-			am.handleStatusAlerts(newStatus, oldRecord, alertRecord)
-		case "CPU", "Memory", "Disk":
-			if newStatus != "up" {
+		case "CPU":
+			val = systemInfo.Cpu
+		case "Memory":
+			val = systemInfo.MemPct
+		case "Bandwidth":
+			val = systemInfo.Bandwidth
+			unit = " MB/s"
+		case "Disk":
+			maxUsedPct := systemInfo.DiskPct
+			for _, fs := range extraFs {
+				usedPct := fs.DiskUsed / fs.DiskTotal * 100
+				if usedPct > maxUsedPct {
+					maxUsedPct = usedPct
+				}
+			}
+			val = maxUsedPct
+		case "Temperature":
+			if temperatures == nil {
 				continue
 			}
-			if systemInfo == nil {
-				systemInfo = getSystemInfo(newRecord)
+			for _, temp := range temperatures {
+				if temp > val {
+					val = temp
+				}
 			}
-			if name == "CPU" {
-				am.handleSlidingValueAlert(newRecord, alertRecord, name, systemInfo.Cpu)
-			} else if name == "Memory" {
-				am.handleSlidingValueAlert(newRecord, alertRecord, name, systemInfo.MemPct)
-			} else if name == "Disk" {
-				am.handleSlidingValueAlert(newRecord, alertRecord, name, systemInfo.DiskPct)
+			unit = "°C"
+		}
+
+		triggered := alertRecord.GetBool("triggered")
+		threshold := alertRecord.GetFloat("value")
+
+		// CONTINUE
+		// IF alert is not triggered and curValue is less than threshold
+		// OR alert is triggered and curValue is greater than threshold
+		if (!triggered && val <= threshold) || (triggered && val > threshold) {
+			// log.Printf("Skipping alert %s: val %f | threshold %f | triggered %v\n", name, val, threshold, triggered)
+			continue
+		}
+
+		min := max(1, cast.ToUint8(alertRecord.Get("min")))
+		// add time to alert time to make sure it's slighty after record creation
+		time := now.Add(-time.Duration(min) * time.Minute)
+		if time.Before(oldestTime) {
+			oldestTime = time
+		}
+
+		validAlerts = append(validAlerts, SystemAlertData{
+			systemRecord: systemRecord,
+			alertRecord:  alertRecord,
+			name:         name,
+			unit:         unit,
+			val:          val,
+			threshold:    threshold,
+			triggered:    triggered,
+			time:         time,
+			min:          min,
+		})
+	}
+
+	systemStats := []struct {
+		Stats   []byte         `db:"stats"`
+		Created types.DateTime `db:"created"`
+	}{}
+
+	err = am.app.Dao().DB().
+		Select("stats", "created").
+		From("system_stats").
+		Where(dbx.NewExp(
+			"system={:system} AND type='1m' AND created > {:created}",
+			dbx.Params{
+				"system": systemRecord.Id,
+				// subtract some time to give us a bit of buffer
+				"created": oldestTime.Add(-time.Second * 90),
+			},
+		)).
+		OrderBy("created").
+		All(&systemStats)
+
+	if err != nil {
+		return err
+	}
+
+	// get oldest record creation time from first record in the slice
+	oldestRecordTime := systemStats[0].Created.Time()
+	// log.Println("oldestRecordTime", oldestRecordTime.String())
+
+	// delete from validAlerts if time is older than oldestRecord
+	for i := 0; i < len(validAlerts); i++ {
+		if validAlerts[i].time.Before(oldestRecordTime) {
+			// log.Println("deleting alert - time is older than oldestRecord", validAlerts[i].name, oldestRecordTime, validAlerts[i].time)
+			validAlerts = append(validAlerts[:i], validAlerts[i+1:]...)
+		}
+	}
+
+	if len(validAlerts) == 0 {
+		// log.Println("no valid alerts found")
+		return nil
+	}
+
+	var stats SystemAlertStats
+
+	// we can skip the latest systemStats record since it's the current value
+	for i := 0; i < len(systemStats); i++ {
+		stat := systemStats[i]
+		// subtract 10 seconds to give a small time buffer
+		systemStatsCreation := stat.Created.Time().Add(-time.Second * 10)
+		if err := json.Unmarshal(stat.Stats, &stats); err != nil {
+			return err
+		}
+		// log.Println("stats", stats)
+		for j := range validAlerts {
+			alert := &validAlerts[j]
+			// reset alert val on first iteration
+			if i == 0 {
+				alert.val = 0
+			}
+			// continue if system_stats is older than alert time range
+			if systemStatsCreation.Before(alert.time) {
+				continue
+			}
+			// add to alert value
+			switch alert.name {
+			case "CPU":
+				alert.val += stats.Cpu
+			case "Memory":
+				alert.val += stats.Mem
+			case "Bandwidth":
+				alert.val += stats.NetSent + stats.NetRecv
+			case "Disk":
+				if alert.mapSums == nil {
+					alert.mapSums = make(map[string]float32, len(extraFs)+1)
+				}
+				// add root disk
+				if _, ok := alert.mapSums["root"]; !ok {
+					alert.mapSums["root"] = 0.0
+				}
+				alert.mapSums["root"] += float32(stats.Disk)
+				// add extra disks
+				for key, fs := range extraFs {
+					if _, ok := alert.mapSums[key]; !ok {
+						alert.mapSums[key] = 0.0
+					}
+					alert.mapSums[key] += float32(fs.DiskUsed / fs.DiskTotal * 100)
+				}
+			case "Temperature":
+				if alert.mapSums == nil {
+					alert.mapSums = make(map[string]float32, len(stats.Temperatures))
+				}
+				for key, temp := range stats.Temperatures {
+					if _, ok := alert.mapSums[key]; !ok {
+						alert.mapSums[key] = float32(0)
+					}
+					alert.mapSums[key] += temp
+				}
+			default:
+				continue
+			}
+			alert.count++
+		}
+	}
+	// sum up vals for each alert
+	for _, alert := range validAlerts {
+		switch alert.name {
+		case "Disk":
+			maxPct := float32(0)
+			for key, value := range alert.mapSums {
+				sumPct := float32(value)
+				if sumPct > maxPct {
+					maxPct = sumPct
+					alert.descriptor = fmt.Sprintf("Usage of %s", key)
+				}
+			}
+			alert.val = float64(maxPct / float32(alert.count))
+		case "Temperature":
+			maxTemp := float32(0)
+			for key, value := range alert.mapSums {
+				sumTemp := float32(value) / float32(alert.count)
+				if sumTemp > maxTemp {
+					maxTemp = sumTemp
+					alert.descriptor = fmt.Sprintf("Highest sensor %s", key)
+				}
+			}
+			alert.val = float64(maxTemp)
+		default:
+			alert.val = alert.val / float64(alert.count)
+		}
+		minCount := float32(alert.min) / 1.2
+		// log.Println("alert", alert.name, "val", alert.val, "threshold", alert.threshold, "triggered", alert.triggered)
+		// log.Printf("%s: val %f | count %d | min-count %f | threshold %f\n", alert.name, alert.val, alert.count, minCount, alert.threshold)
+		// pass through alert if count is greater than or equal to minCount
+		if float32(alert.count) >= minCount {
+			if !alert.triggered && alert.val > alert.threshold {
+				alert.triggered = true
+				am.sendSystemAlert(alert)
+			} else if alert.triggered && alert.val <= alert.threshold {
+				alert.triggered = false
+				am.sendSystemAlert(alert)
 			}
 		}
 	}
+	return nil
 }

-func getSystemInfo(record *models.Record) *system.Info {
-	var SystemInfo system.Info
-	record.UnmarshalJSONField("info", &SystemInfo)
-	return &SystemInfo
-}
+func (am *AlertManager) sendSystemAlert(alert SystemAlertData) {
+	// log.Printf("Sending alert %s: val %f | count %d | threshold %f\n", alert.name, alert.val, alert.count, alert.threshold)
+	systemName := alert.systemRecord.GetString("name")

-func (am *AlertManager) handleSlidingValueAlert(newRecord *models.Record, alertRecord *models.Record, name string, curValue float64) {
-	triggered := alertRecord.GetBool("triggered")
-	threshold := alertRecord.GetFloat("value")
-	// fmt.Println(name, curValue, "threshold", threshold, "triggered", triggered)
-	var subject string
-	var body string
-	var systemName string
-	if !triggered && curValue > threshold {
-		alertRecord.Set("triggered", true)
-		systemName = newRecord.GetString("name")
-		subject = fmt.Sprintf("%s usage above threshold on %s", name, systemName)
-		body = fmt.Sprintf("%s usage on %s is %.1f%%.", name, systemName, curValue)
-	} else if triggered && curValue <= threshold {
-		alertRecord.Set("triggered", false)
-		systemName = newRecord.GetString("name")
-		subject = fmt.Sprintf("%s usage below threshold on %s", name, systemName)
-		body = fmt.Sprintf("%s usage on %s is below threshold at %.1f%%.", name, systemName, curValue)
-	} else {
-		// fmt.Println(name, "not triggered")
-		return
+	// change Disk to Disk usage
+	if alert.name == "Disk" {
+		alert.name += " usage"
 	}
-	if err := am.app.Dao().SaveRecord(alertRecord); err != nil {
+
+	// make title alert name lowercase if not CPU
+	titleAlertName := alert.name
+	if titleAlertName != "CPU" {
+		titleAlertName = strings.ToLower(titleAlertName)
+	}
+
+	var subject string
+	if alert.triggered {
+		subject = fmt.Sprintf("%s %s above threshold", systemName, titleAlertName)
+	} else {
+		subject = fmt.Sprintf("%s %s below threshold", systemName, titleAlertName)
+	}
+	minutesLabel := "minute"
+	if alert.min > 1 {
+		minutesLabel += "s"
+	}
+	if alert.descriptor == "" {
+		alert.descriptor = alert.name
+	}
+	body := fmt.Sprintf("%s averaged %.2f%s for the previous %v %s.", alert.descriptor, alert.val, alert.unit, alert.min, minutesLabel)
+
+	alert.alertRecord.Set("triggered", alert.triggered)
+	if err := am.app.Dao().SaveRecord(alert.alertRecord); err != nil {
 		// app.Logger().Error("failed to save alert record", "err", err.Error())
 		return
 	}
 	// expand the user relation and send the alert
-	if errs := am.app.Dao().ExpandRecord(alertRecord, []string{"user"}, nil); len(errs) > 0 {
+	if errs := am.app.Dao().ExpandRecord(alert.alertRecord, []string{"user"}, nil); len(errs) > 0 {
 		// app.Logger().Error("failed to expand user relation", "errs", errs)
 		return
 	}
-	if user := alertRecord.ExpandedOne("user"); user != nil {
-		am.sendAlert(AlertData{
+	if user := alert.alertRecord.ExpandedOne("user"); user != nil {
+		am.sendAlert(AlertMessageData{
 			UserID:   user.GetId(),
 			Title:    subject,
 			Message:  body,
@@ -119,46 +345,59 @@ func (am *AlertManager) handleSlidingValueAlert(newRecord *models.Record, alertR
 	}
 }

-func (am *AlertManager) handleStatusAlerts(newStatus string, oldRecord *models.Record, alertRecord *models.Record) error {
+func (am *AlertManager) HandleStatusAlerts(newStatus string, oldSystemRecord *models.Record) error {
 	var alertStatus string
 	switch newStatus {
 	case "up":
-		if oldRecord.GetString("status") == "down" {
+		if oldSystemRecord.GetString("status") == "down" {
 			alertStatus = "up"
 		}
 	case "down":
-		if oldRecord.GetString("status") == "up" {
+		if oldSystemRecord.GetString("status") == "up" {
 			alertStatus = "down"
 		}
 	}
 	if alertStatus == "" {
 		return nil
 	}
-	// expand the user relation
-	if errs := am.app.Dao().ExpandRecord(alertRecord, []string{"user"}, nil); len(errs) > 0 {
-		return fmt.Errorf("failed to expand: %v", errs)
-	}
-	user := alertRecord.ExpandedOne("user")
-	if user == nil {
+	// check if use
+	alertRecords, err := am.app.Dao().FindRecordsByExpr("alerts",
+		dbx.HashExp{
+			"system": oldSystemRecord.GetId(),
+			"name":   "Status",
+		},
+	)
+	if err != nil || len(alertRecords) == 0 {
+		// log.Println("no alerts found for system")
 		return nil
 	}
-	emoji := "\U0001F534"
-	if alertStatus == "up" {
-		emoji = "\u2705"
+	for _, alertRecord := range alertRecords {
+		// expand the user relation
+		if errs := am.app.Dao().ExpandRecord(alertRecord, []string{"user"}, nil); len(errs) > 0 {
+			return fmt.Errorf("failed to expand: %v", errs)
+		}
+		user := alertRecord.ExpandedOne("user")
+		if user == nil {
+			return nil
+		}
+		emoji := "\U0001F534"
+		if alertStatus == "up" {
+			emoji = "\u2705"
+		}
+		// send alert
+		systemName := oldSystemRecord.GetString("name")
+		am.sendAlert(AlertMessageData{
+			UserID:   user.GetId(),
+			Title:    fmt.Sprintf("Connection to %s is %s %v", systemName, alertStatus, emoji),
+			Message:  fmt.Sprintf("Connection to %s is %s", systemName, alertStatus),
+			Link:     am.app.Settings().Meta.AppUrl + "/system/" + url.QueryEscape(systemName),
+			LinkText: "View " + systemName,
+		})
 	}
-	// send alert
-	systemName := oldRecord.GetString("name")
-	am.sendAlert(AlertData{
-		UserID:   user.GetId(),
-		Title:    fmt.Sprintf("Connection to %s is %s %v", systemName, alertStatus, emoji),
-		Message:  fmt.Sprintf("Connection to %s is %s", systemName, alertStatus),
-		Link:     am.app.Settings().Meta.AppUrl + "/system/" + url.QueryEscape(systemName),
-		LinkText: "View " + systemName,
-	})
 	return nil
 }

-func (am *AlertManager) sendAlert(data AlertData) {
+func (am *AlertManager) sendAlert(data AlertMessageData) {
 	// get user settings
 	record, err := am.app.Dao().FindFirstRecordByFilter(
 		"user_settings", "user={:user}",
--- a/beszel/internal/entities/container/container.go
+++ b/beszel/internal/entities/container/container.go
@@ -85,15 +85,13 @@ type CPUUsage struct {
 }

 type MemoryStats struct {
-
 	// current res_counter usage for memory
 	Usage uint64 `json:"usage,omitempty"`
-	Cache uint64 `json:"cache,omitempty"`
+	// all the stats exported via memory.stat.
+	Stats MemoryStatsStats `json:"stats,omitempty"`
 	// maximum usage ever recorded.
 	// MaxUsage uint64 `json:"max_usage,omitempty"`
 	// TODO(vishh): Export these as stronger types.
-	// all the stats exported via memory.stat.
-	Stats map[string]uint64 `json:"stats,omitempty"`
 	// number of times memory usage hits limits.
 	// Failcnt uint64 `json:"failcnt,omitempty"`
 	// Limit   uint64 `json:"limit,omitempty"`
@@ -106,6 +104,11 @@ type MemoryStats struct {
 	// PrivateWorkingSet uint64 `json:"privateworkingset,omitempty"`
 }

+type MemoryStatsStats struct {
+	Cache        uint64 `json:"cache,omitempty"`
+	InactiveFile uint64 `json:"inactive_file,omitempty"`
+}
+
 type NetworkStats struct {
 	// Bytes received. Windows and Linux.
 	RxBytes uint64 `json:"rx_bytes"`
@@ -113,21 +116,19 @@ type NetworkStats struct {
 	TxBytes uint64 `json:"tx_bytes"`
 }

-// Container stats to return to the hub
-type Stats struct {
-	Name        string  `json:"n"`
-	Cpu         float64 `json:"c"`
-	Mem         float64 `json:"m"`
-	NetworkSent float64 `json:"ns"`
-	NetworkRecv float64 `json:"nr"`
+type prevNetStats struct {
+	Sent uint64
+	Recv uint64
+	Time time.Time
 }

-// Keeps track of container stats from previous run
-type PrevContainerStats struct {
-	Cpu [2]uint64
-	Net struct {
-		Sent uint64
-		Recv uint64
-		Time time.Time
-	}
+// Docker container stats
+type Stats struct {
+	Name        string       `json:"n"`
+	Cpu         float64      `json:"c"`
+	Mem         float64      `json:"m"`
+	NetworkSent float64      `json:"ns"`
+	NetworkRecv float64      `json:"nr"`
+	PrevCpu     [2]uint64    `json:"-"`
+	PrevNet     prevNetStats `json:"-"`
 }
--- a/beszel/internal/entities/system/system.go
+++ b/beszel/internal/entities/system/system.go
@@ -6,35 +6,42 @@ import (
 )

 type Stats struct {
-	Cpu          float64             `json:"cpu"`
-	Mem          float64             `json:"m"`
-	MemUsed      float64             `json:"mu"`
-	MemPct       float64             `json:"mp"`
-	MemBuffCache float64             `json:"mb"`
-	Swap         float64             `json:"s,omitempty"`
-	SwapUsed     float64             `json:"su,omitempty"`
-	DiskTotal    float64             `json:"d"`
-	DiskUsed     float64             `json:"du"`
-	DiskPct      float64             `json:"dp"`
-	DiskReadPs   float64             `json:"dr"`
-	DiskWritePs  float64             `json:"dw"`
-	NetworkSent  float64             `json:"ns"`
-	NetworkRecv  float64             `json:"nr"`
-	Temperatures map[string]float64  `json:"t,omitempty"`
-	ExtraFs      map[string]*FsStats `json:"efs,omitempty"`
+	Cpu            float64             `json:"cpu"`
+	MaxCpu         float64             `json:"cpum,omitempty"`
+	Mem            float64             `json:"m"`
+	MemUsed        float64             `json:"mu"`
+	MemPct         float64             `json:"mp"`
+	MemBuffCache   float64             `json:"mb"`
+	MemZfsArc      float64             `json:"mz,omitempty"` // ZFS ARC memory
+	Swap           float64             `json:"s,omitempty"`
+	SwapUsed       float64             `json:"su,omitempty"`
+	DiskTotal      float64             `json:"d"`
+	DiskUsed       float64             `json:"du"`
+	DiskPct        float64             `json:"dp"`
+	DiskReadPs     float64             `json:"dr"`
+	DiskWritePs    float64             `json:"dw"`
+	MaxDiskReadPs  float64             `json:"drm,omitempty"`
+	MaxDiskWritePs float64             `json:"dwm,omitempty"`
+	NetworkSent    float64             `json:"ns"`
+	NetworkRecv    float64             `json:"nr"`
+	MaxNetworkSent float64             `json:"nsm,omitempty"`
+	MaxNetworkRecv float64             `json:"nrm,omitempty"`
+	Temperatures   map[string]float64  `json:"t,omitempty"`
+	ExtraFs        map[string]*FsStats `json:"efs,omitempty"`
 }

 type FsStats struct {
-	Time        time.Time `json:"-"`
-	Device      string    `json:"-"`
-	Root        bool      `json:"-"`
-	Mountpoint  string    `json:"-"`
-	DiskTotal   float64   `json:"d"`
-	DiskUsed    float64   `json:"du"`
-	TotalRead   uint64    `json:"-"`
-	TotalWrite  uint64    `json:"-"`
-	DiskWritePs float64   `json:"w"`
-	DiskReadPs  float64   `json:"r"`
+	Time           time.Time `json:"-"`
+	Root           bool      `json:"-"`
+	Mountpoint     string    `json:"-"`
+	DiskTotal      float64   `json:"d"`
+	DiskUsed       float64   `json:"du"`
+	TotalRead      uint64    `json:"-"`
+	TotalWrite     uint64    `json:"-"`
+	DiskReadPs     float64   `json:"r"`
+	DiskWritePs    float64   `json:"w"`
+	MaxDiskReadPS  float64   `json:"rm,omitempty"`
+	MaxDiskWritePS float64   `json:"wm,omitempty"`
 }

 type NetIoStats struct {
@@ -45,22 +52,22 @@ type NetIoStats struct {
 }

 type Info struct {
-	Hostname string `json:"h"`
-
-	Cores    int    `json:"c"`
-	Threads  int    `json:"t"`
-	CpuModel string `json:"m"`
-	// Os       string  `json:"o"`
-	Uptime       uint64  `json:"u"`
-	Cpu          float64 `json:"cpu"`
-	MemPct       float64 `json:"mp"`
-	DiskPct      float64 `json:"dp"`
-	AgentVersion string  `json:"v"`
+	Hostname      string  `json:"h"`
+	KernelVersion string  `json:"k,omitempty"`
+	Cores         int     `json:"c"`
+	Threads       int     `json:"t,omitempty"`
+	CpuModel      string  `json:"m"`
+	Uptime        uint64  `json:"u"`
+	Cpu           float64 `json:"cpu"`
+	MemPct        float64 `json:"mp"`
+	DiskPct       float64 `json:"dp"`
+	Bandwidth     float64 `json:"b"`
+	AgentVersion  string  `json:"v"`
 }

 // Final data structure to return to the hub
 type CombinedData struct {
-	Stats      Stats             `json:"stats"`
-	Info       Info              `json:"info"`
-	Containers []container.Stats `json:"container"`
+	Stats      Stats              `json:"stats"`
+	Info       Info               `json:"info"`
+	Containers []*container.Stats `json:"container"`
 }
--- a/beszel/internal/hub/hub.go
+++ b/beszel/internal/hub/hub.go
@@ -8,6 +8,7 @@ import (
 	"beszel/internal/records"
 	"beszel/internal/users"
 	"beszel/site"
+
 	"context"
 	"crypto/ed25519"
 	"encoding/pem"
@@ -22,7 +23,6 @@ import (
 	"time"

 	"github.com/goccy/go-json"
-
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
@@ -39,6 +39,9 @@ type Hub struct {
 	systemConnections map[string]*ssh.Client
 	sshClientConfig   *ssh.ClientConfig
 	pubKey            string
+	am                *alerts.AlertManager
+	um                *users.UserManager
+	rm                *records.RecordManager
 }

 func NewHub(app *pocketbase.PocketBase) *Hub {
@@ -46,13 +49,16 @@ func NewHub(app *pocketbase.PocketBase) *Hub {
 		app:               app,
 		connectionLock:    &sync.Mutex{},
 		systemConnections: make(map[string]*ssh.Client),
+		am:                alerts.NewAlertManager(app),
+		um:                users.NewUserManager(app),
+		rm:                records.NewRecordManager(app),
 	}
 }

 func (h *Hub) Run() {
-	rm := records.NewRecordManager(h.app)
-	am := alerts.NewAlertManager(h.app)
-	um := users.NewUserManager(h.app)
+	// rm := records.NewRecordManager(h.app)
+	// am := alerts.NewAlertManager(h.app)
+	// um := users.NewUserManager(h.app)

 	// loosely check if it was executed using "go run"
 	isGoRun := strings.HasPrefix(os.Args[0], os.TempDir())
@@ -90,7 +96,7 @@ func (h *Hub) Run() {
 		return nil
 	})

-	// serve site
+	// serve web ui
 	h.app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
 		switch isGoRun {
 		case true:
@@ -98,12 +104,17 @@ func (h *Hub) Run() {
 				Scheme: "http",
 				Host:   "localhost:5173",
 			})
-			e.Router.GET("/static/*", apis.StaticDirectoryHandler(os.DirFS("../../site/public/static"), false))
 			e.Router.Any("/*", echo.WrapHandler(proxy))
-			// e.Router.Any("/", echo.WrapHandler(proxy))
 		default:
-			e.Router.GET("/static/*", apis.StaticDirectoryHandler(site.Static, false))
-			e.Router.Any("/*", apis.StaticDirectoryHandler(site.Dist, true))
+			csp, cspExists := os.LookupEnv("CSP")
+			e.Router.Any("/*", func(c echo.Context) error {
+				if cspExists {
+					c.Response().Header().Del("X-Frame-Options")
+					c.Response().Header().Set("Content-Security-Policy", csp)
+				}
+				indexFallback := !strings.HasPrefix(c.Request().URL.Path, "/static/")
+				return apis.StaticDirectoryHandler(site.Dist, indexFallback)(c)
+			})
 		}
 		return nil
 	})
@@ -115,9 +126,9 @@ func (h *Hub) Run() {
 		// set up cron jobs
 		scheduler := cron.New()
 		// delete old records once every hour
-		scheduler.MustAdd("delete old records", "8 * * * *", rm.DeleteOldRecords)
+		scheduler.MustAdd("delete old records", "8 * * * *", h.rm.DeleteOldRecords)
 		// create longer records every 10 minutes
-		scheduler.MustAdd("create longer records", "*/10 * * * *", rm.CreateLongerRecords)
+		scheduler.MustAdd("create longer records", "*/10 * * * *", h.rm.CreateLongerRecords)
 		scheduler.Start()
 		return nil
 	})
@@ -141,7 +152,7 @@ func (h *Hub) Run() {
 			return c.JSON(http.StatusOK, map[string]bool{"firstRun": adminNum == 0})
 		})
 		// send test notification
-		e.Router.GET("/api/beszel/send-test-notification", am.SendTestNotification)
+		e.Router.GET("/api/beszel/send-test-notification", h.am.SendTestNotification)
 		return nil
 	})

@@ -160,8 +171,16 @@ func (h *Hub) Run() {
 	})

 	// handle default values for user / user_settings creation
-	h.app.OnModelBeforeCreate("users").Add(um.InitializeUserRole)
-	h.app.OnModelBeforeCreate("user_settings").Add(um.InitializeUserSettings)
+	h.app.OnModelBeforeCreate("users").Add(h.um.InitializeUserRole)
+	h.app.OnModelBeforeCreate("user_settings").Add(h.um.InitializeUserSettings)
+
+	// empty info for systems that are paused
+	h.app.OnModelBeforeUpdate("systems").Add(func(e *core.ModelEvent) error {
+		if e.Model.(*models.Record).GetString("status") == "paused" {
+			e.Model.(*models.Record).Set("info", system.Info{})
+		}
+		return nil
+	})

 	// do things after a systems record is updated
 	h.app.OnModelAfterUpdate("systems").Add(func(e *core.ModelEvent) error {
@@ -177,10 +196,11 @@ func (h *Hub) Run() {
 		// if system is set to pending (unpause), try to connect immediately
 		if newStatus == "pending" {
 			go h.updateSystem(newRecord)
+		} else {
+			h.am.HandleStatusAlerts(newStatus, oldRecord)
+
 		}

-		// alerts
-		am.HandleSystemAlerts(newStatus, newRecord, oldRecord)
 		return nil
 	})

@@ -256,7 +276,7 @@ func (h *Hub) updateSystem(record *models.Record) {
 	}
 	// get system stats from agent
 	var systemData system.CombinedData
-	if err := requestJsonFromAgent(client, &systemData); err != nil {
+	if err := h.requestJsonFromAgent(client, &systemData); err != nil {
 		if err.Error() == "bad client" {
 			// if previous connection was closed, try again
 			h.app.Logger().Error("Existing SSH connection closed. Retrying...", "host", record.GetString("host"), "port", record.GetString("port"))
@@ -294,6 +314,10 @@ func (h *Hub) updateSystem(record *models.Record) {
 			h.app.Logger().Error("Failed to save record: ", "err", err.Error())
 		}
 	}
+	// system info alerts (todo: extra fs alerts)
+	if err := h.am.HandleSystemAlerts(record, systemData.Info, systemData.Stats.Temperatures, systemData.Stats.ExtraFs); err != nil {
+		h.app.Logger().Error("System alerts error", "err", err.Error())
+	}
 }

 // set system to specified status and save record
@@ -349,7 +373,8 @@ func (h *Hub) createSSHClientConfig() error {
 	return nil
 }

-func requestJsonFromAgent(client *ssh.Client, systemData *system.CombinedData) error {
+// Fetches system stats from the agent and decodes the json data into the provided struct
+func (h *Hub) requestJsonFromAgent(client *ssh.Client, systemData *system.CombinedData) error {
 	session, err := newSessionWithTimeout(client, 5*time.Second)
 	if err != nil {
 		return fmt.Errorf("bad client")
--- a/beszel/internal/hub/update.go
+++ b/beszel/internal/hub/update.go
@@ -0,0 +1,57 @@
+package hub
+
+import (
+	"beszel"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/blang/semver"
+	"github.com/rhysd/go-github-selfupdate/selfupdate"
+	"github.com/spf13/cobra"
+)
+
+// Update updates beszel to the latest version
+func Update(_ *cobra.Command, _ []string) {
+	var latest *selfupdate.Release
+	var found bool
+	var err error
+	currentVersion := semver.MustParse(beszel.Version)
+	fmt.Println("beszel", currentVersion)
+	fmt.Println("Checking for updates...")
+	updater, _ := selfupdate.NewUpdater(selfupdate.Config{
+		Filters: []string{"beszel_"},
+	})
+	latest, found, err = updater.DetectLatest("henrygd/beszel")
+
+	if err != nil {
+		fmt.Println("Error checking for updates:", err)
+		os.Exit(1)
+	}
+
+	if !found {
+		fmt.Println("No updates found")
+		os.Exit(0)
+	}
+
+	fmt.Println("Latest version:", latest.Version)
+
+	if latest.Version.LTE(currentVersion) {
+		fmt.Println("You are up to date")
+		return
+	}
+
+	var binaryPath string
+	fmt.Printf("Updating from %s to %s...\n", currentVersion, latest.Version)
+	binaryPath, err = os.Executable()
+	if err != nil {
+		fmt.Println("Error getting binary path:", err)
+		os.Exit(1)
+	}
+	err = selfupdate.UpdateTo(latest.AssetURL, binaryPath)
+	if err != nil {
+		fmt.Println("Please try rerunning with sudo. Error:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully updated to %s\n\n%s\n", latest.Version, strings.TrimSpace(latest.ReleaseNotes))
+}
--- a/beszel/internal/records/records.go
+++ b/beszel/internal/records/records.go
@@ -8,10 +8,12 @@ import (
 	"math"
 	"time"

+	"github.com/goccy/go-json"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/daos"
 	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/tools/types"
 )

 type RecordManager struct {
@@ -30,6 +32,10 @@ type RecordDeletionData struct {
 	retention  time.Duration
 }

+type RecordStats []*struct {
+	Stats []byte `db:"stats"`
+}
+
 func NewRecordManager(app *pocketbase.PocketBase) *RecordManager {
 	return &RecordManager{app}
 }
@@ -72,6 +78,7 @@ func (rm *RecordManager) CreateLongerRecords() {
 			return err
 		}

+		// need *models.Collection to create a new record with models.NewRecord
 		collections := map[string]*models.Collection{}
 		for _, collectionName := range []string{"system_stats", "container_stats"} {
 			collection, _ := txDao.FindCollectionByNameOrId(collectionName)
@@ -103,31 +110,44 @@ func (rm *RecordManager) CreateLongerRecords() {
 						}
 					}
 					// get shorter records from the past x minutes
-					allShorterRecords, err := txDao.FindRecordsByExpr(
-						collection.Id,
-						dbx.NewExp(
-							"type = {:type} AND system = {:system} AND created > {:created}",
-							dbx.Params{"type": recordData.shorterType, "system": system.Id, "created": shorterRecordPeriod},
-						),
-					)
+					var stats RecordStats
+
+					// allShorterRecords, err := txDao.FindRecordsByExpr(
+					// 	collection,
+					// 	dbx.NewExp(
+					// 		"type = {:type} AND system = {:system} AND created > {:created}",
+					// 		dbx.Params{"type": recordData.shorterType, "system": system.Id, "created": shorterRecordPeriod},
+					// 	),
+					// )
+
+					err := txDao.DB().
+						Select("stats").
+						From(collection.Name).
+						AndWhere(dbx.NewExp(
+							"type={:type} AND system={:system} AND created > {:created}",
+							dbx.Params{
+								"type":    recordData.shorterType,
+								"system":  system.Id,
+								"created": shorterRecordPeriod,
+							},
+						)).
+						All(&stats)

 					// continue if not enough shorter records
-					if err != nil || len(allShorterRecords) < recordData.minShorterRecords {
+					if err != nil || len(stats) < recordData.minShorterRecords {
 						// log.Println("not enough shorter records. continue.", len(allShorterRecords), recordData.expectedShorterRecords)
 						continue
 					}
 					// average the shorter records and create longer record
-					var stats interface{}
-					switch collection.Name {
-					case "system_stats":
-						stats = rm.AverageSystemStats(allShorterRecords)
-					case "container_stats":
-						stats = rm.AverageContainerStats(allShorterRecords)
-					}
 					longerRecord := models.NewRecord(collection)
 					longerRecord.Set("system", system.Id)
-					longerRecord.Set("stats", stats)
 					longerRecord.Set("type", recordData.longerType)
+					switch collection.Name {
+					case "system_stats":
+						longerRecord.Set("stats", rm.AverageSystemStats(stats))
+					case "container_stats":
+						longerRecord.Set("stats", rm.AverageContainerStats(stats))
+					}
 					if err := txDao.SaveRecord(longerRecord); err != nil {
 						log.Println("failed to save longer record", "err", err.Error())
 					}
@@ -142,10 +162,11 @@ func (rm *RecordManager) CreateLongerRecords() {
 }

 // Calculate the average stats of a list of system_stats records without reflect
-func (rm *RecordManager) AverageSystemStats(records []*models.Record) system.Stats {
-	var sum system.Stats
-	sum.Temperatures = make(map[string]float64)
-	sum.ExtraFs = make(map[string]*system.FsStats)
+func (rm *RecordManager) AverageSystemStats(records RecordStats) system.Stats {
+	sum := system.Stats{
+		Temperatures: make(map[string]float64),
+		ExtraFs:      make(map[string]*system.FsStats),
+	}

 	count := float64(len(records))
 	// use different counter for temps in case some records don't have them
@@ -153,12 +174,13 @@ func (rm *RecordManager) AverageSystemStats(records []*models.Record) system.Sta

 	var stats system.Stats
 	for _, record := range records {
-		record.UnmarshalJSONField("stats", &stats)
+		json.Unmarshal(record.Stats, &stats)
 		sum.Cpu += stats.Cpu
 		sum.Mem += stats.Mem
 		sum.MemUsed += stats.MemUsed
 		sum.MemPct += stats.MemPct
 		sum.MemBuffCache += stats.MemBuffCache
+		sum.MemZfsArc += stats.MemZfsArc
 		sum.Swap += stats.Swap
 		sum.SwapUsed += stats.SwapUsed
 		sum.DiskTotal += stats.DiskTotal
@@ -168,6 +190,12 @@ func (rm *RecordManager) AverageSystemStats(records []*models.Record) system.Sta
 		sum.DiskWritePs += stats.DiskWritePs
 		sum.NetworkSent += stats.NetworkSent
 		sum.NetworkRecv += stats.NetworkRecv
+		// set peak values
+		sum.MaxCpu = max(sum.MaxCpu, stats.MaxCpu, stats.Cpu)
+		sum.MaxNetworkSent = max(sum.MaxNetworkSent, stats.MaxNetworkSent, stats.NetworkSent)
+		sum.MaxNetworkRecv = max(sum.MaxNetworkRecv, stats.MaxNetworkRecv, stats.NetworkRecv)
+		sum.MaxDiskReadPs = max(sum.MaxDiskReadPs, stats.MaxDiskReadPs, stats.DiskReadPs)
+		sum.MaxDiskWritePs = max(sum.MaxDiskWritePs, stats.MaxDiskWritePs, stats.DiskWritePs)
 		// add temps to sum
 		if stats.Temperatures != nil {
 			tempCount++
@@ -188,42 +216,53 @@ func (rm *RecordManager) AverageSystemStats(records []*models.Record) system.Sta
 				sum.ExtraFs[key].DiskUsed += value.DiskUsed
 				sum.ExtraFs[key].DiskWritePs += value.DiskWritePs
 				sum.ExtraFs[key].DiskReadPs += value.DiskReadPs
+				// peak values
+				sum.ExtraFs[key].MaxDiskReadPS = max(sum.ExtraFs[key].MaxDiskReadPS, value.MaxDiskReadPS, value.DiskReadPs)
+				sum.ExtraFs[key].MaxDiskWritePS = max(sum.ExtraFs[key].MaxDiskWritePS, value.MaxDiskWritePS, value.DiskWritePs)
 			}
 		}
 	}

 	stats = system.Stats{
-		Cpu:          twoDecimals(sum.Cpu / count),
-		Mem:          twoDecimals(sum.Mem / count),
-		MemUsed:      twoDecimals(sum.MemUsed / count),
-		MemPct:       twoDecimals(sum.MemPct / count),
-		MemBuffCache: twoDecimals(sum.MemBuffCache / count),
-		Swap:         twoDecimals(sum.Swap / count),
-		SwapUsed:     twoDecimals(sum.SwapUsed / count),
-		DiskTotal:    twoDecimals(sum.DiskTotal / count),
-		DiskUsed:     twoDecimals(sum.DiskUsed / count),
-		DiskPct:      twoDecimals(sum.DiskPct / count),
-		DiskReadPs:   twoDecimals(sum.DiskReadPs / count),
-		DiskWritePs:  twoDecimals(sum.DiskWritePs / count),
-		NetworkSent:  twoDecimals(sum.NetworkSent / count),
-		NetworkRecv:  twoDecimals(sum.NetworkRecv / count),
+		Cpu:            twoDecimals(sum.Cpu / count),
+		Mem:            twoDecimals(sum.Mem / count),
+		MemUsed:        twoDecimals(sum.MemUsed / count),
+		MemPct:         twoDecimals(sum.MemPct / count),
+		MemBuffCache:   twoDecimals(sum.MemBuffCache / count),
+		MemZfsArc:      twoDecimals(sum.MemZfsArc / count),
+		Swap:           twoDecimals(sum.Swap / count),
+		SwapUsed:       twoDecimals(sum.SwapUsed / count),
+		DiskTotal:      twoDecimals(sum.DiskTotal / count),
+		DiskUsed:       twoDecimals(sum.DiskUsed / count),
+		DiskPct:        twoDecimals(sum.DiskPct / count),
+		DiskReadPs:     twoDecimals(sum.DiskReadPs / count),
+		DiskWritePs:    twoDecimals(sum.DiskWritePs / count),
+		NetworkSent:    twoDecimals(sum.NetworkSent / count),
+		NetworkRecv:    twoDecimals(sum.NetworkRecv / count),
+		MaxCpu:         sum.MaxCpu,
+		MaxDiskReadPs:  sum.MaxDiskReadPs,
+		MaxDiskWritePs: sum.MaxDiskWritePs,
+		MaxNetworkSent: sum.MaxNetworkSent,
+		MaxNetworkRecv: sum.MaxNetworkRecv,
 	}

 	if len(sum.Temperatures) != 0 {
-		stats.Temperatures = make(map[string]float64)
+		stats.Temperatures = make(map[string]float64, len(sum.Temperatures))
 		for key, value := range sum.Temperatures {
 			stats.Temperatures[key] = twoDecimals(value / tempCount)
 		}
 	}

 	if len(sum.ExtraFs) != 0 {
-		stats.ExtraFs = make(map[string]*system.FsStats)
+		stats.ExtraFs = make(map[string]*system.FsStats, len(sum.ExtraFs))
 		for key, value := range sum.ExtraFs {
 			stats.ExtraFs[key] = &system.FsStats{
-				DiskTotal:   twoDecimals(value.DiskTotal / count),
-				DiskUsed:    twoDecimals(value.DiskUsed / count),
-				DiskWritePs: twoDecimals(value.DiskWritePs / count),
-				DiskReadPs:  twoDecimals(value.DiskReadPs / count),
+				DiskTotal:      twoDecimals(value.DiskTotal / count),
+				DiskUsed:       twoDecimals(value.DiskUsed / count),
+				DiskWritePs:    twoDecimals(value.DiskWritePs / count),
+				DiskReadPs:     twoDecimals(value.DiskReadPs / count),
+				MaxDiskReadPS:  value.MaxDiskReadPS,
+				MaxDiskWritePS: value.MaxDiskWritePS,
 			}
 		}
 	}
@@ -232,16 +271,20 @@ func (rm *RecordManager) AverageSystemStats(records []*models.Record) system.Sta
 }

 // Calculate the average stats of a list of container_stats records
-func (rm *RecordManager) AverageContainerStats(records []*models.Record) (stats []container.Stats) {
+func (rm *RecordManager) AverageContainerStats(records RecordStats) []container.Stats {
 	sums := make(map[string]*container.Stats)
 	count := float64(len(records))

 	var containerStats []container.Stats
 	for _, record := range records {
-		record.UnmarshalJSONField("stats", &containerStats)
+		// Reset the slice length to 0, but keep the capacity
+		containerStats = containerStats[:0]
+		if err := json.Unmarshal(record.Stats, &containerStats); err != nil {
+			return []container.Stats{}
+		}
 		for _, stat := range containerStats {
 			if _, ok := sums[stat.Name]; !ok {
-				sums[stat.Name] = &container.Stats{Name: stat.Name, Cpu: 0, Mem: 0}
+				sums[stat.Name] = &container.Stats{Name: stat.Name}
 			}
 			sums[stat.Name].Cpu += stat.Cpu
 			sums[stat.Name].Mem += stat.Mem
@@ -250,8 +293,9 @@ func (rm *RecordManager) AverageContainerStats(records []*models.Record) (stats
 		}
 	}

+	result := make([]container.Stats, 0, len(sums))
 	for _, value := range sums {
-		stats = append(stats, container.Stats{
+		result = append(result, container.Stats{
 			Name:        value.Name,
 			Cpu:         twoDecimals(value.Cpu / count),
 			Mem:         twoDecimals(value.Mem / count),
@@ -259,11 +303,11 @@ func (rm *RecordManager) AverageContainerStats(records []*models.Record) (stats
 			NetworkRecv: twoDecimals(value.NetworkRecv / count),
 		})
 	}
-	return stats
+	return result
 }

+// Deletes records older than what is displayed in the UI
 func (rm *RecordManager) DeleteOldRecords() {
-	// start := time.Now()
 	collections := []string{"system_stats", "container_stats"}
 	recordData := []RecordDeletionData{
 		{
@@ -287,29 +331,17 @@ func (rm *RecordManager) DeleteOldRecords() {
 			retention:  30 * 24 * time.Hour,
 		},
 	}
-	rm.app.Dao().RunInTransaction(func(txDao *daos.Dao) error {
-		for _, recordData := range recordData {
-			exp := dbx.NewExp(
-				"type = {:type} AND created < {:created}",
-				dbx.Params{"type": recordData.recordType, "created": time.Now().UTC().Add(-recordData.retention)},
-			)
-			for _, collectionSlug := range collections {
-				collectionRecords, err := txDao.FindRecordsByExpr(collectionSlug, exp)
-				if err != nil {
-					return err
-				}
-				for _, record := range collectionRecords {
-					err := txDao.DeleteRecord(record)
-					if err != nil {
-						rm.app.Logger().Error("Failed to delete records", "err", err.Error())
-						return err
-					}
-				}
+	db := rm.app.Dao().NonconcurrentDB()
+	for _, recordData := range recordData {
+		for _, collectionSlug := range collections {
+			formattedDate := time.Now().UTC().Add(-recordData.retention).Format(types.DefaultDateLayout)
+			expr := dbx.NewExp("[[created]] < {:date} AND [[type]] = {:type}", dbx.Params{"date": formattedDate, "type": recordData.recordType})
+			_, err := db.Delete(collectionSlug, expr).Execute()
+			if err != nil {
+				rm.app.Logger().Error("Failed to delete records", "err", err.Error())
 			}
 		}
-		return nil
-	})
-	// log.Println("finished deleting old records", "time (ms)", time.Since(start).Milliseconds())
+	}
 }

 /* Round float to two decimals */
--- a/beszel/migrations/1728772062_collections_snapshot.go
+++ b/beszel/migrations/1728772062_collections_snapshot.go
@@ -15,7 +15,7 @@ func init() {
 			{
 				"id": "2hz5ncl8tizk5nx",
 				"created": "2024-07-07 16:08:20.979Z",
-				"updated": "2024-07-28 17:14:24.492Z",
+				"updated": "2024-10-12 18:55:51.623Z",
 				"name": "systems",
 				"type": "base",
 				"system": false,
@@ -120,7 +120,7 @@ func init() {
 			{
 				"id": "ej9oowivz8b2mht",
 				"created": "2024-07-07 16:09:09.179Z",
-				"updated": "2024-07-28 17:14:24.492Z",
+				"updated": "2024-10-12 18:55:51.623Z",
 				"name": "system_stats",
 				"type": "base",
 				"system": false,
@@ -186,7 +186,7 @@ func init() {
 			{
 				"id": "juohu4jipgc13v7",
 				"created": "2024-07-07 16:09:57.976Z",
-				"updated": "2024-07-28 17:14:24.492Z",
+				"updated": "2024-10-12 18:55:51.623Z",
 				"name": "container_stats",
 				"type": "base",
 				"system": false,
@@ -250,7 +250,7 @@ func init() {
 			{
 				"id": "_pb_users_auth_",
 				"created": "2024-07-14 16:25:18.226Z",
-				"updated": "2024-09-12 23:19:36.280Z",
+				"updated": "2024-10-12 22:27:19.081Z",
 				"name": "users",
 				"type": "auth",
 				"system": false,
@@ -316,7 +316,7 @@ func init() {
 			{
 				"id": "elngm8x1l60zi2v",
 				"created": "2024-07-15 01:16:04.044Z",
-				"updated": "2024-07-28 17:14:24.492Z",
+				"updated": "2024-10-12 22:27:29.128Z",
 				"name": "alerts",
 				"type": "base",
 				"system": false,
@@ -367,7 +367,9 @@ func init() {
 								"Status",
 								"CPU",
 								"Memory",
-								"Disk"
+								"Disk",
+								"Temperature",
+								"Bandwidth"
 							]
 						}
 					},
@@ -385,6 +387,20 @@ func init() {
 							"noDecimal": false
 						}
 					},
+					{
+						"system": false,
+						"id": "fstdehcq",
+						"name": "min",
+						"type": "number",
+						"required": false,
+						"presentable": false,
+						"unique": false,
+						"options": {
+							"min": null,
+							"max": 60,
+							"noDecimal": true
+						}
+					},
 					{
 						"system": false,
 						"id": "6hgdf6hs",
@@ -407,7 +423,7 @@ func init() {
 			{
 				"id": "4afacsdnlu8q8r2",
 				"created": "2024-09-12 17:42:55.324Z",
-				"updated": "2024-09-12 21:19:59.114Z",
+				"updated": "2024-10-12 18:55:51.624Z",
 				"name": "user_settings",
 				"type": "base",
 				"system": false,
--- a/beszel/site/bun.lockb
+++ b/beszel/site/bun.lockb
--- a/beszel/site/embed.go
+++ b/beszel/site/embed.go
@@ -11,5 +11,3 @@ import (
 var assets embed.FS

 var Dist = echo.MustSubFS(assets, "dist")
-
-var Static = echo.MustSubFS(assets, "dist/static")
--- a/beszel/site/package-lock.json
+++ b/beszel/site/package-lock.json
--- a/beszel/site/package.json
+++ b/beszel/site/package.json
@@ -1,5 +1,5 @@
 {
-	"name": "site",
+	"name": "beszel",
 	"private": true,
 	"version": "0.0.0",
 	"type": "module",
@@ -11,43 +11,41 @@
 	"dependencies": {
 		"@nanostores/react": "^0.7.3",
 		"@nanostores/router": "^0.15.1",
-		"@radix-ui/react-alert-dialog": "^1.1.1",
-		"@radix-ui/react-dialog": "^1.1.1",
-		"@radix-ui/react-dropdown-menu": "^2.1.1",
+		"@radix-ui/react-alert-dialog": "^1.1.2",
+		"@radix-ui/react-dialog": "^1.1.2",
+		"@radix-ui/react-dropdown-menu": "^2.1.2",
 		"@radix-ui/react-label": "^2.1.0",
-		"@radix-ui/react-select": "^2.1.1",
+		"@radix-ui/react-select": "^2.1.2",
 		"@radix-ui/react-separator": "^1.1.0",
-		"@radix-ui/react-slider": "^1.2.0",
+		"@radix-ui/react-slider": "^1.2.1",
 		"@radix-ui/react-slot": "^1.1.0",
-		"@radix-ui/react-switch": "^1.1.0",
-		"@radix-ui/react-toast": "^1.2.1",
-		"@radix-ui/react-tooltip": "^1.1.2",
+		"@radix-ui/react-switch": "^1.1.1",
+		"@radix-ui/react-toast": "^1.2.2",
+		"@radix-ui/react-tooltip": "^1.1.3",
 		"@tanstack/react-table": "^8.20.5",
-		"@vitejs/plugin-react": "^4.3.1",
+		"@vitejs/plugin-react": "^4.3.2",
 		"class-variance-authority": "^0.7.0",
 		"clsx": "^2.1.1",
 		"cmdk": "^1.0.0",
-		"d3-scale": "^4.0.2",
 		"d3-time": "^3.1.0",
-		"lucide-react": "^0.407.0",
+		"lucide-react": "^0.452.0",
 		"nanostores": "^0.10.3",
 		"pocketbase": "^0.21.5",
 		"react": "^18.3.1",
 		"react-dom": "^18.3.1",
-		"recharts": "^2.13.0-alpha.4",
-		"tailwind-merge": "^2.5.2",
+		"recharts": "^2.13.0",
+		"tailwind-merge": "^2.5.4",
 		"tailwindcss-animate": "^1.0.7",
-		"use-is-in-viewport": "^1.0.9",
 		"valibot": "^0.36.0"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.1.8",
-		"@types/react": "^18.3.5",
-		"@types/react-dom": "^18.3.0",
+		"@types/bun": "^1.1.11",
+		"@types/react": "^18.3.11",
+		"@types/react-dom": "^18.3.1",
 		"autoprefixer": "^10.4.20",
-		"postcss": "^8.4.44",
-		"tailwindcss": "^3.4.10",
-		"typescript": "^5.5.4",
-		"vite": "^5.4.2"
+		"postcss": "^8.4.47",
+		"tailwindcss": "^3.4.14",
+		"typescript": "^5.6.3",
+		"vite": "^5.4.9"
 	}
 }
--- a/beszel/site/src/components/charts/area-chart.tsx
+++ b/beszel/site/src/components/charts/area-chart.tsx
@@ -0,0 +1,134 @@
+import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
+
+import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
+import {
+	useYAxisWidth,
+	chartTimeData,
+	cn,
+	formatShortDate,
+	toFixedWithoutTrailingZeros,
+	decimalString,
+	chartMargin,
+} from '@/lib/utils'
+// import Spinner from '../spinner'
+import { ChartData } from '@/types'
+import { memo, useMemo } from 'react'
+
+/** [label, key, color, opacity] */
+type DataKeys = [string, string, number, number]
+
+const getNestedValue = (path: string, max = false, data: any): number | null => {
+	// fallback value (obj?.stats?.cpum ? 0 : null) should only come into play when viewing
+	// a max value which doesn't exist, or the value was zero and omitted from the stats object.
+	// so we check if cpum is present. if so, return 0 to make sure the zero value is displayed.
+	// if not, return null - there is no max data so do not display anything.
+	return `stats.${path}${max ? 'm' : ''}`
+		.split('.')
+		.reduce((acc: any, key: string) => acc?.[key] ?? (data.stats?.cpum ? 0 : null), data)
+}
+
+export default memo(function AreaChartDefault({
+	maxToggled = false,
+	unit = ' MB/s',
+	chartName,
+	chartData,
+}: {
+	maxToggled?: boolean
+	unit?: string
+	chartName: string
+	chartData: ChartData
+}) {
+	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
+
+	const { chartTime } = chartData
+
+	const showMax = chartTime !== '1h' && maxToggled
+
+	const dataKeys: DataKeys[] = useMemo(() => {
+		// [label, key, color, opacity]
+		if (chartName === 'CPU Usage') {
+			return [[chartName, 'cpu', 1, 0.4]]
+		} else if (chartName === 'dio') {
+			return [
+				['Write', 'dw', 3, 0.3],
+				['Read', 'dr', 1, 0.3],
+			]
+		} else if (chartName === 'bw') {
+			return [
+				['Sent', 'ns', 5, 0.2],
+				['Received', 'nr', 2, 0.2],
+			]
+		} else if (chartName.startsWith('efs')) {
+			return [
+				['Write', `${chartName}.w`, 3, 0.3],
+				['Read', `${chartName}.r`, 1, 0.3],
+			]
+		}
+		return []
+	}, [])
+
+	// console.log('Rendered at', new Date())
+
+	return (
+		<div>
+			<ChartContainer
+				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
+					'opacity-100': yAxisWidth,
+				})}
+			>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
+					<CartesianGrid vertical={false} />
+					<YAxis
+						className="tracking-tighter"
+						width={yAxisWidth}
+						tickFormatter={(value) => {
+							const val = toFixedWithoutTrailingZeros(value, 2) + unit
+							return updateYAxisWidth(val)
+						}}
+						tickLine={false}
+						axisLine={false}
+					/>
+					<XAxis
+						dataKey="created"
+						domain={chartData.domain}
+						ticks={chartData.ticks}
+						allowDataOverflow
+						type="number"
+						scale="time"
+						minTickGap={30}
+						tickMargin={8}
+						axisLine={false}
+						tickFormatter={chartTimeData[chartTime].format}
+					/>
+					<ChartTooltip
+						animationEasing="ease-out"
+						animationDuration={150}
+						content={
+							<ChartTooltipContent
+								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
+								contentFormatter={(item) => decimalString(item.value) + unit}
+								// indicator="line"
+							/>
+						}
+					/>
+					{dataKeys.map((key, i) => {
+						const color = `hsl(var(--chart-${key[2]}))`
+						return (
+							<Area
+								key={i}
+								dataKey={getNestedValue.bind(null, key[1], showMax)}
+								name={key[0]}
+								type="monotoneX"
+								fill={color}
+								fillOpacity={key[3]}
+								stroke={color}
+								isAnimationActive={false}
+							/>
+						)
+					})}
+					{/* <ChartLegend content={<ChartLegendContent />} /> */}
+				</AreaChart>
+			</ChartContainer>
+		</div>
+	)
+})
--- a/beszel/site/src/components/charts/bandwidth-chart.tsx
+++ b/beszel/site/src/components/charts/bandwidth-chart.tsx
@@ -1,105 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-
-import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
-import {
-	useYAxisWidth,
-	chartTimeData,
-	cn,
-	formatShortDate,
-	toFixedWithoutTrailingZeros,
-	twoDecimalString,
-} from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
-
-export default function BandwidthChart({
-	ticks,
-	systemData,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-}) {
-	const chartTime = useStore($chartTime)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	return (
-		<div>
-			{/* {!yAxisSet && <Spinner />} */}
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{
-						left: 0,
-						right: 0,
-						top: 10,
-						bottom: 0,
-					}}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						width={yAxisWidth}
-						// domain={[0, (max: number) => (max <= 0.4 ? 0.4 : Math.ceil(max))]}
-						tickFormatter={(value) => {
-							const val = toFixedWithoutTrailingZeros(value, 2) + ' MB/s'
-							return updateYAxisWidth(val)
-						}}
-						tickLine={false}
-						axisLine={false}
-						// unit={' MB/s'}
-					/>
-					<XAxis
-						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						animationEasing="ease-out"
-						animationDuration={150}
-						content={
-							<ChartTooltipContent
-								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' MB/s'}
-								indicator="line"
-							/>
-						}
-					/>
-					<Area
-						dataKey="stats.ns"
-						name="Sent"
-						type="monotoneX"
-						fill="hsl(var(--chart-5))"
-						fillOpacity={0.2}
-						stroke="hsl(var(--chart-5))"
-						// animationDuration={1200}
-						isAnimationActive={false}
-					/>
-					<Area
-						dataKey="stats.nr"
-						name="Received"
-						type="monotoneX"
-						fill="hsl(var(--chart-2))"
-						fillOpacity={0.2}
-						stroke="hsl(var(--chart-2))"
-						// animationDuration={1200}
-						isAnimationActive={false}
-					/>
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/container-chart.tsx
+++ b/beszel/site/src/components/charts/container-chart.tsx
@@ -0,0 +1,200 @@
+import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
+import {
+	ChartConfig,
+	ChartContainer,
+	ChartTooltip,
+	ChartTooltipContent,
+} from '@/components/ui/chart'
+import { memo, useMemo } from 'react'
+import {
+	useYAxisWidth,
+	chartTimeData,
+	cn,
+	formatShortDate,
+	decimalString,
+	chartMargin,
+	toFixedFloat,
+	getSizeAndUnit,
+	toFixedWithoutTrailingZeros,
+} from '@/lib/utils'
+// import Spinner from '../spinner'
+import { useStore } from '@nanostores/react'
+import { $containerFilter } from '@/lib/stores'
+import { ChartData } from '@/types'
+import { Separator } from '../ui/separator'
+
+export default memo(function ContainerChart({
+	dataKey,
+	chartData,
+	chartName,
+	unit = '%',
+}: {
+	dataKey: string
+	chartData: ChartData
+	chartName: string
+	unit?: string
+}) {
+	const filter = useStore($containerFilter)
+	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
+
+	const { containerData, ticks, domain, chartTime } = chartData
+
+	const isNetChart = chartName === 'net'
+
+	const chartConfig = useMemo(() => {
+		let config = {} as Record<
+			string,
+			{
+				label: string
+				color: string
+			}
+		>
+		const totalUsage = {} as Record<string, number>
+		for (let stats of containerData) {
+			for (let key in stats) {
+				if (!key || key === 'created') {
+					continue
+				}
+				if (!(key in totalUsage)) {
+					totalUsage[key] = 0
+				}
+				if (isNetChart) {
+					totalUsage[key] += (stats[key]?.nr ?? 0) + (stats[key]?.ns ?? 0)
+				} else {
+					// @ts-ignore
+					totalUsage[key] += stats[key]?.[dataKey] ?? 0
+				}
+			}
+		}
+		let keys = Object.keys(totalUsage)
+		keys.sort((a, b) => (totalUsage[a] > totalUsage[b] ? -1 : 1))
+		const length = keys.length
+		for (let i = 0; i < length; i++) {
+			const key = keys[i]
+			const hue = ((i * 360) / length) % 360
+			config[key] = {
+				label: key,
+				color: `hsl(${hue}, 60%, 55%)`,
+			}
+		}
+		return config satisfies ChartConfig
+	}, [chartData])
+
+	const { toolTipFormatter, dataFunction, tickFormatter } = useMemo(() => {
+		const obj = {} as {
+			toolTipFormatter: (item: any, key: string) => React.ReactNode | string
+			dataFunction: (key: string, data: any) => number | null
+			tickFormatter: (value: any) => string
+		}
+		// tick formatter
+		if (chartName === 'cpu') {
+			obj.tickFormatter = (value) => {
+				const val = toFixedWithoutTrailingZeros(value, 2) + unit
+				return updateYAxisWidth(val)
+			}
+		} else {
+			obj.tickFormatter = (value) => {
+				const { v, u } = getSizeAndUnit(value, false)
+				return updateYAxisWidth(`${toFixedFloat(v, 2)}${u}${isNetChart ? '/s' : ''}`)
+			}
+		}
+		// tooltip formatter
+		if (isNetChart) {
+			obj.toolTipFormatter = (item: any, key: string) => {
+				try {
+					const sent = item?.payload?.[key]?.ns ?? 0
+					const received = item?.payload?.[key]?.nr ?? 0
+					return (
+						<span className="flex">
+							{decimalString(received)} MB/s
+							<span className="opacity-70 ml-0.5"> rx </span>
+							<Separator orientation="vertical" className="h-3 mx-1.5 bg-primary/40" />
+							{decimalString(sent)} MB/s
+							<span className="opacity-70 ml-0.5"> tx</span>
+						</span>
+					)
+				} catch (e) {
+					return null
+				}
+			}
+		} else {
+			obj.toolTipFormatter = (item: any) => decimalString(item.value) + unit
+		}
+		// data function
+		if (isNetChart) {
+			obj.dataFunction = (key: string, data: any) => (data[key]?.nr ?? 0) + (data[key]?.ns ?? 0)
+		} else {
+			obj.dataFunction = (key: string, data: any) => data[key]?.[dataKey] ?? 0
+		}
+		return obj
+	}, [])
+
+	// console.log('rendered at', new Date())
+
+	return (
+		<div>
+			<ChartContainer
+				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
+					'opacity-100': yAxisWidth,
+				})}
+			>
+				<AreaChart
+					accessibilityLayer
+					// syncId={'cpu'}
+					data={containerData}
+					margin={chartMargin}
+					reverseStackOrder={true}
+				>
+					<CartesianGrid vertical={false} />
+					<YAxis
+						className="tracking-tighter"
+						width={yAxisWidth}
+						tickFormatter={tickFormatter}
+						tickLine={false}
+						axisLine={false}
+					/>
+					<XAxis
+						dataKey="created"
+						domain={domain}
+						allowDataOverflow
+						ticks={ticks}
+						type="number"
+						scale="time"
+						minTickGap={35}
+						tickMargin={8}
+						axisLine={false}
+						tickFormatter={chartTimeData[chartTime].format}
+					/>
+					<ChartTooltip
+						animationEasing="ease-out"
+						animationDuration={150}
+						labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
+						// @ts-ignore
+						itemSorter={(a, b) => b.value - a.value}
+						content={<ChartTooltipContent filter={filter} contentFormatter={toolTipFormatter} />}
+					/>
+					{Object.keys(chartConfig).map((key) => {
+						const filtered = filter && !key.includes(filter)
+						let fillOpacity = filtered ? 0.05 : 0.4
+						let strokeOpacity = filtered ? 0.1 : 1
+						return (
+							<Area
+								key={key}
+								isAnimationActive={false}
+								dataKey={dataFunction.bind(null, key)}
+								name={key}
+								type="monotoneX"
+								fill={chartConfig[key].color}
+								fillOpacity={fillOpacity}
+								stroke={chartConfig[key].color}
+								strokeOpacity={strokeOpacity}
+								activeDot={{ opacity: filtered ? 0 : 1 }}
+								stackId="a"
+							/>
+						)
+					})}
+				</AreaChart>
+			</ChartContainer>
+		</div>
+	)
+})
--- a/beszel/site/src/components/charts/container-cpu-chart.tsx
+++ b/beszel/site/src/components/charts/container-cpu-chart.tsx
@@ -1,143 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-import {
-	ChartConfig,
-	ChartContainer,
-	ChartTooltip,
-	ChartTooltipContent,
-} from '@/components/ui/chart'
-import { useMemo } from 'react'
-import { useYAxisWidth, chartTimeData, cn, formatShortDate, twoDecimalString } from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime, $containerFilter } from '@/lib/stores'
-
-export default function ContainerCpuChart({
-	chartData,
-	ticks,
-}: {
-	chartData: Record<string, number | string>[]
-	ticks: number[]
-}) {
-	const chartTime = useStore($chartTime)
-	const filter = useStore($containerFilter)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	const chartConfig = useMemo(() => {
-		let config = {} as Record<
-			string,
-			{
-				label: string
-				color: string
-			}
-		>
-		const totalUsage = {} as Record<string, number>
-		for (let stats of chartData) {
-			for (let key in stats) {
-				if (key === 'time') {
-					continue
-				}
-				if (!(key in totalUsage)) {
-					totalUsage[key] = 0
-				}
-				// @ts-ignore
-				totalUsage[key] += stats[key]
-			}
-		}
-		let keys = Object.keys(totalUsage)
-		keys.sort((a, b) => (totalUsage[a] > totalUsage[b] ? -1 : 1))
-		const length = keys.length
-		for (let i = 0; i < length; i++) {
-			const key = keys[i]
-			const hue = ((i * 360) / length) % 360
-			config[key] = {
-				label: key,
-				color: `hsl(${hue}, 60%, 55%)`,
-			}
-		}
-		return config satisfies ChartConfig
-	}, [chartData])
-
-	// if (!chartData.length || !ticks.length) {
-	// 	return <Spinner />
-	// }
-
-	return (
-		<div>
-			{/* {!yAxisSet && <Spinner />} */}
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					// syncId={'cpu'}
-					data={chartData}
-					margin={{
-						top: 10,
-					}}
-					reverseStackOrder={true}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						// domain={[0, (max: number) => Math.max(Math.ceil(max), 0.4)]}
-						width={yAxisWidth}
-						tickLine={false}
-						axisLine={false}
-						tickFormatter={(x) => {
-							const val = (x % 1 === 0 ? x : x.toFixed(1)) + '%'
-							return updateYAxisWidth(val)
-						}}
-					/>
-					<XAxis
-						dataKey="time"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						// cursor={false}
-						animationEasing="ease-out"
-						animationDuration={150}
-						labelFormatter={(_, data) => formatShortDate(data[0].payload.time)}
-						// @ts-ignore
-						itemSorter={(a, b) => b.value - a.value}
-						content={
-							<ChartTooltipContent
-								filter={filter}
-								contentFormatter={(item) => twoDecimalString(item.value) + '%'}
-								indicator="line"
-							/>
-						}
-					/>
-					{Object.keys(chartConfig).map((key) => {
-						const filtered = filter && !key.includes(filter)
-						let fillOpacity = filtered ? 0.05 : 0.4
-						let strokeOpacity = filtered ? 0.1 : 1
-						return (
-							<Area
-								key={key}
-								isAnimationActive={false}
-								dataKey={key}
-								type="monotoneX"
-								fill={chartConfig[key].color}
-								fillOpacity={fillOpacity}
-								stroke={chartConfig[key].color}
-								strokeOpacity={strokeOpacity}
-								activeDot={{ opacity: filtered ? 0 : 1 }}
-								stackId="a"
-							/>
-						)
-					})}
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/container-mem-chart.tsx
+++ b/beszel/site/src/components/charts/container-mem-chart.tsx
@@ -1,149 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-import {
-	ChartConfig,
-	ChartContainer,
-	ChartTooltip,
-	ChartTooltipContent,
-} from '@/components/ui/chart'
-import { useMemo } from 'react'
-import {
-	useYAxisWidth,
-	chartTimeData,
-	cn,
-	formatShortDate,
-	toFixedWithoutTrailingZeros,
-	twoDecimalString,
-} from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime, $containerFilter } from '@/lib/stores'
-
-export default function ContainerMemChart({
-	chartData,
-	ticks,
-}: {
-	chartData: Record<string, number | string>[]
-	ticks: number[]
-}) {
-	const chartTime = useStore($chartTime)
-	const filter = useStore($containerFilter)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	const chartConfig = useMemo(() => {
-		let config = {} as Record<
-			string,
-			{
-				label: string
-				color: string
-			}
-		>
-		const totalUsage = {} as Record<string, number>
-		for (let stats of chartData) {
-			for (let key in stats) {
-				if (key === 'time') {
-					continue
-				}
-				if (!(key in totalUsage)) {
-					totalUsage[key] = 0
-				}
-				// @ts-ignore
-				totalUsage[key] += stats[key]
-			}
-		}
-		let keys = Object.keys(totalUsage)
-		keys.sort((a, b) => (totalUsage[a] > totalUsage[b] ? -1 : 1))
-		const length = keys.length
-		for (let i = 0; i < length; i++) {
-			const key = keys[i]
-			const hue = ((i * 360) / length) % 360
-			config[key] = {
-				label: key,
-				color: `hsl(${hue}, 60%, 55%)`,
-			}
-		}
-		return config satisfies ChartConfig
-	}, [chartData])
-
-	// if (!chartData.length || !ticks.length) {
-	// 	return <Spinner />
-	// }
-
-	return (
-		<div>
-			{/* {!yAxisSet && <Spinner />} */}
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={chartData}
-					reverseStackOrder={true}
-					margin={{
-						top: 10,
-					}}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						// domain={[0, (max: number) => Math.ceil(max)]}
-						tickLine={false}
-						axisLine={false}
-						width={yAxisWidth}
-						tickFormatter={(value) => {
-							const val = toFixedWithoutTrailingZeros(value / 1024, 2) + ' GB'
-							return updateYAxisWidth(val)
-						}}
-					/>
-					<XAxis
-						dataKey="time"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						// cursor={false}
-						animationEasing="ease-out"
-						animationDuration={150}
-						labelFormatter={(_, data) => formatShortDate(data[0].payload.time)}
-						// @ts-ignore
-						itemSorter={(a, b) => b.value - a.value}
-						content={
-							<ChartTooltipContent
-								filter={filter}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' MB'}
-								indicator="line"
-							/>
-						}
-					/>
-					{Object.keys(chartConfig).map((key) => {
-						const filtered = filter && !key.includes(filter)
-						let fillOpacity = filtered ? 0.05 : 0.4
-						let strokeOpacity = filtered ? 0.1 : 1
-						return (
-							<Area
-								key={key}
-								isAnimationActive={false}
-								dataKey={key}
-								type="monotoneX"
-								fill={chartConfig[key].color}
-								strokeOpacity={strokeOpacity}
-								fillOpacity={fillOpacity}
-								stroke={chartConfig[key].color}
-								activeDot={filtered ? false : {}}
-								stackId="a"
-							/>
-						)
-					})}
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/container-net-chart.tsx
+++ b/beszel/site/src/components/charts/container-net-chart.tsx
@@ -1,166 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-import {
-	ChartConfig,
-	ChartContainer,
-	ChartTooltip,
-	ChartTooltipContent,
-} from '@/components/ui/chart'
-import { useMemo } from 'react'
-import {
-	useYAxisWidth,
-	chartTimeData,
-	cn,
-	formatShortDate,
-	toFixedWithoutTrailingZeros,
-	twoDecimalString,
-} from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime, $containerFilter } from '@/lib/stores'
-import { Separator } from '@/components/ui/separator'
-
-export default function ContainerCpuChart({
-	chartData,
-	ticks,
-}: {
-	chartData: Record<string, number | number[]>[]
-	ticks: number[]
-}) {
-	const chartTime = useStore($chartTime)
-	const filter = useStore($containerFilter)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	const chartConfig = useMemo(() => {
-		let config = {} as Record<
-			string,
-			{
-				label: string
-				color: string
-			}
-		>
-		const totalUsage = {} as Record<string, number>
-		for (let stats of chartData) {
-			for (let key in stats) {
-				if (!Array.isArray(stats[key])) {
-					continue
-				}
-				if (!(key in totalUsage)) {
-					totalUsage[key] = 0
-				}
-				totalUsage[key] += stats[key][2] ?? 0
-			}
-		}
-		let keys = Object.keys(totalUsage)
-		keys.sort((a, b) => (totalUsage[a] > totalUsage[b] ? -1 : 1))
-		const length = keys.length
-		for (let i = 0; i < length; i++) {
-			const key = keys[i]
-			const hue = ((i * 360) / length) % 360
-			config[key] = {
-				label: key,
-				color: `hsl(${hue}, 60%, 55%)`,
-			}
-		}
-		return config satisfies ChartConfig
-	}, [chartData])
-
-	// if (!chartData.length || !ticks.length) {
-	// 	return <Spinner />
-	// }
-
-	return (
-		<div>
-			{/* {!yAxisSet && <Spinner />} */}
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={chartData}
-					margin={{
-						top: 10,
-					}}
-					reverseStackOrder={true}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						// domain={[0, (max: number) => Math.max(Math.ceil(max), 0.4)]}
-						width={yAxisWidth}
-						tickLine={false}
-						axisLine={false}
-						tickFormatter={(value) => {
-							const val = toFixedWithoutTrailingZeros(value, 2) + ' MB/s'
-							return updateYAxisWidth(val)
-						}}
-					/>
-					<XAxis
-						dataKey="time"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						// cursor={false}
-						animationEasing="ease-out"
-						animationDuration={150}
-						labelFormatter={(_, data) => formatShortDate(data[0].payload.time)}
-						// @ts-ignore
-						itemSorter={(a, b) => b.value - a.value}
-						content={
-							<ChartTooltipContent
-								filter={filter}
-								indicator="line"
-								contentFormatter={(item, key) => {
-									try {
-										const sent = item?.payload?.[key][0] ?? 0
-										const received = item?.payload?.[key][1] ?? 0
-										return (
-											<span className="flex">
-												{twoDecimalString(received)} MB/s
-												<span className="opacity-70 ml-0.5"> rx </span>
-												<Separator orientation="vertical" className="h-3 mx-1.5 bg-primary/40" />
-												{twoDecimalString(sent)} MB/s<span className="opacity-70 ml-0.5"> tx</span>
-											</span>
-										)
-									} catch (e) {
-										return null
-									}
-								}}
-							/>
-						}
-					/>
-					{Object.keys(chartConfig).map((key) => {
-						const filtered = filter && !key.includes(filter)
-						let fillOpacity = filtered ? 0.05 : 0.4
-						let strokeOpacity = filtered ? 0.1 : 1
-						return (
-							<Area
-								key={key}
-								name={key}
-								// animationDuration={1200}
-								isAnimationActive={false}
-								dataKey={(data) => data?.[key]?.[2] ?? 0}
-								type="monotoneX"
-								fill={chartConfig[key].color}
-								fillOpacity={fillOpacity}
-								stroke={chartConfig[key].color}
-								strokeOpacity={strokeOpacity}
-								activeDot={{ opacity: filtered ? 0 : 1 }}
-								stackId="a"
-							/>
-						)
-					})}
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/cpu-chart.tsx
+++ b/beszel/site/src/components/charts/cpu-chart.tsx
@@ -1,81 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-
-import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
-import { useYAxisWidth, chartTimeData, cn, formatShortDate, twoDecimalString } from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
-
-export default function CpuChart({
-	ticks,
-	systemData,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-}) {
-	const chartTime = useStore($chartTime)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	return (
-		<div>
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{ top: 10 }}
-					// syncId={'cpu'}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						// domain={[0, (max: number) => Math.ceil(max)]}
-						width={yAxisWidth}
-						tickLine={false}
-						axisLine={false}
-						tickFormatter={(value) => updateYAxisWidth(value + '%')}
-					/>
-					<XAxis
-						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						animationEasing="ease-out"
-						animationDuration={150}
-						content={
-							<ChartTooltipContent
-								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + '%'}
-								indicator="line"
-							/>
-						}
-					/>
-					<Area
-						dataKey="stats.cpu"
-						name="CPU Usage"
-						type="monotoneX"
-						fill="hsl(var(--chart-1))"
-						fillOpacity={0.4}
-						stroke="hsl(var(--chart-1))"
-						isAnimationActive={false}
-						// animationEasing="ease-out"
-						// animationDuration={1200}
-						// animateNewValues={true}
-					/>
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/disk-chart.tsx
+++ b/beszel/site/src/components/charts/disk-chart.tsx
@@ -1,46 +1,40 @@
 import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'

 import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
-import { useYAxisWidth, chartTimeData, cn, formatShortDate, twoDecimalString } from '@/lib/utils'
-import { useMemo } from 'react'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
+import {
+	useYAxisWidth,
+	chartTimeData,
+	cn,
+	formatShortDate,
+	decimalString,
+	toFixedFloat,
+	chartMargin,
+	getSizeAndUnit,
+} from '@/lib/utils'
+import { ChartData } from '@/types'
+import { memo } from 'react'

-export default function DiskChart({
-	ticks,
-	systemData,
+export default memo(function DiskChart({
+	dataKey,
+	diskSize,
+	chartData,
 }: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
+	dataKey: string
+	diskSize: number
+	chartData: ChartData
 }) {
-	const chartTime = useStore($chartTime)
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()

-	const diskSize = useMemo(() => {
-		return Math.round(systemData.at(-1)?.stats.d ?? NaN)
-	}, [systemData])
+	// console.log('rendered at', new Date())

 	return (
 		<div>
-			{/* {!yAxisSet && <Spinner />} */}
 			<ChartContainer
-				config={{}}
 				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
 					'opacity-100': yAxisWidth,
 				})}
 			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{
-						left: 0,
-						right: 0,
-						top: 10,
-						bottom: 0,
-					}}
-				>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
 					<CartesianGrid vertical={false} />
 					<YAxis
 						className="tracking-tighter"
@@ -50,18 +44,22 @@ export default function DiskChart({
 						minTickGap={6}
 						tickLine={false}
 						axisLine={false}
-						tickFormatter={(value) => updateYAxisWidth(value + ' GB')}
+						tickFormatter={(value) => {
+							const { v, u } = getSizeAndUnit(value)
+							return updateYAxisWidth(toFixedFloat(v, 2) + u)
+						}}
 					/>
 					<XAxis
 						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
+						domain={chartData.domain}
+						ticks={chartData.ticks}
+						allowDataOverflow
 						type="number"
-						scale={'time'}
-						minTickGap={35}
+						scale="time"
+						minTickGap={30}
 						tickMargin={8}
 						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
+						tickFormatter={chartTimeData[chartData.chartTime].format}
 					/>
 					<ChartTooltip
 						animationEasing="ease-out"
@@ -69,13 +67,15 @@ export default function DiskChart({
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' GB'}
-								indicator="line"
+								contentFormatter={({ value }) => {
+									const { v, u } = getSizeAndUnit(value)
+									return decimalString(v) + u
+								}}
 							/>
 						}
 					/>
 					<Area
-						dataKey="stats.du"
+						dataKey={dataKey}
 						name="Disk Usage"
 						type="monotoneX"
 						fill="hsl(var(--chart-4))"
@@ -88,4 +88,4 @@ export default function DiskChart({
 			</ChartContainer>
 		</div>
 	)
-}
+})
--- a/beszel/site/src/components/charts/disk-io-chart.tsx
+++ b/beszel/site/src/components/charts/disk-io-chart.tsx
@@ -1,104 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-
-import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
-import {
-	useYAxisWidth,
-	chartTimeData,
-	cn,
-	formatShortDate,
-	toFixedWithoutTrailingZeros,
-	twoDecimalString,
-} from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
-
-export default function DiskIoChart({
-	ticks,
-	systemData,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-}) {
-	const chartTime = useStore($chartTime)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	return (
-		<div>
-			{/* {!yAxisSet && <Spinner />} */}
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{
-						left: 0,
-						right: 0,
-						top: 10,
-						bottom: 0,
-					}}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						width={yAxisWidth}
-						// domain={[0, (max: number) => (max <= 0.4 ? 0.4 : Math.ceil(max))]}
-						tickFormatter={(value) => {
-							const val = toFixedWithoutTrailingZeros(value, 2) + ' MB/s'
-							return updateYAxisWidth(val)
-						}}
-						tickLine={false}
-						axisLine={false}
-					/>
-					<XAxis
-						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						animationEasing="ease-out"
-						animationDuration={150}
-						content={
-							<ChartTooltipContent
-								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' MB/s'}
-								indicator="line"
-							/>
-						}
-					/>
-					<Area
-						dataKey="stats.dw"
-						name="Write"
-						type="monotoneX"
-						fill="hsl(var(--chart-3))"
-						fillOpacity={0.3}
-						stroke="hsl(var(--chart-3))"
-						// animationDuration={1200}
-						isAnimationActive={false}
-					/>
-					<Area
-						dataKey="stats.dr"
-						name="Read"
-						type="monotoneX"
-						fill="hsl(var(--chart-1))"
-						fillOpacity={0.3}
-						stroke="hsl(var(--chart-1))"
-						// animationDuration={1200}
-						isAnimationActive={false}
-					/>
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/extra-fs-disk-chart.tsx
+++ b/beszel/site/src/components/charts/extra-fs-disk-chart.tsx
@@ -1,89 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-
-import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
-import { useYAxisWidth, chartTimeData, cn, formatShortDate, twoDecimalString } from '@/lib/utils'
-import { useMemo } from 'react'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
-
-export default function ExFsDiskChart({
-	ticks,
-	systemData,
-	fs,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-	fs: string
-}) {
-	const chartTime = useStore($chartTime)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	const diskSize = useMemo(() => {
-		const size = systemData.at(-1)?.stats.efs?.[fs].d ?? 0
-		return size > 10 ? Math.round(size) : size
-	}, [systemData])
-
-	return (
-		<div>
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{
-						top: 10,
-					}}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						width={yAxisWidth}
-						domain={[0, diskSize]}
-						tickCount={9}
-						minTickGap={6}
-						tickLine={false}
-						axisLine={false}
-						tickFormatter={(value) => updateYAxisWidth(value + ' GB')}
-					/>
-					<XAxis
-						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						animationEasing="ease-out"
-						animationDuration={150}
-						content={
-							<ChartTooltipContent
-								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' GB'}
-								indicator="line"
-							/>
-						}
-					/>
-					<Area
-						dataKey={`stats.efs.${fs}.du`}
-						name="Disk Usage"
-						type="monotoneX"
-						fill="hsl(var(--chart-4))"
-						fillOpacity={0.4}
-						stroke="hsl(var(--chart-4))"
-						isAnimationActive={false}
-					/>
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/extra-fs-disk-io-chart.tsx
+++ b/beszel/site/src/components/charts/extra-fs-disk-io-chart.tsx
@@ -1,106 +0,0 @@
-import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from 'recharts'
-
-import { ChartContainer, ChartTooltip, ChartTooltipContent } from '@/components/ui/chart'
-import {
-	useYAxisWidth,
-	chartTimeData,
-	cn,
-	formatShortDate,
-	toFixedWithoutTrailingZeros,
-	twoDecimalString,
-} from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
-
-export default function ExFsDiskIoChart({
-	ticks,
-	systemData,
-	fs,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-	fs: string
-}) {
-	const chartTime = useStore($chartTime)
-	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()
-
-	return (
-		<div>
-			{/* {!yAxisSet && <Spinner />} */}
-			<ChartContainer
-				config={{}}
-				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
-					'opacity-100': yAxisWidth,
-				})}
-			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{
-						left: 0,
-						right: 0,
-						top: 10,
-						bottom: 0,
-					}}
-				>
-					<CartesianGrid vertical={false} />
-					<YAxis
-						className="tracking-tighter"
-						width={yAxisWidth}
-						// domain={[0, (max: number) => (max <= 0.4 ? 0.4 : Math.ceil(max))]}
-						tickFormatter={(value) => {
-							const val = toFixedWithoutTrailingZeros(value, 2)
-							return updateYAxisWidth(val + ' MB/s')
-						}}
-						tickLine={false}
-						axisLine={false}
-					/>
-					<XAxis
-						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
-						type="number"
-						scale={'time'}
-						minTickGap={35}
-						tickMargin={8}
-						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
-					/>
-					<ChartTooltip
-						animationEasing="ease-out"
-						animationDuration={150}
-						content={
-							<ChartTooltipContent
-								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' MB/s'}
-								indicator="line"
-							/>
-						}
-					/>
-					<Area
-						dataKey={`stats.efs.${fs}.w`}
-						name="Write"
-						type="monotoneX"
-						fill="hsl(var(--chart-3))"
-						fillOpacity={0.3}
-						stroke="hsl(var(--chart-3))"
-						// animationDuration={1200}
-						isAnimationActive={false}
-					/>
-					<Area
-						dataKey={`stats.efs.${fs}.r`}
-						name="Read"
-						type="monotoneX"
-						fill="hsl(var(--chart-1))"
-						fillOpacity={0.3}
-						stroke="hsl(var(--chart-1))"
-						// animationDuration={1200}
-						isAnimationActive={false}
-					/>
-				</AreaChart>
-			</ChartContainer>
-		</div>
-	)
-}
--- a/beszel/site/src/components/charts/mem-chart.tsx
+++ b/beszel/site/src/components/charts/mem-chart.tsx
@@ -5,46 +5,30 @@ import {
 	useYAxisWidth,
 	chartTimeData,
 	cn,
-	formatShortDate,
 	toFixedFloat,
-	twoDecimalString,
+	decimalString,
+	formatShortDate,
+	chartMargin,
 } from '@/lib/utils'
-import { useMemo } from 'react'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
+import { memo } from 'react'
+import { ChartData } from '@/types'

-export default function MemChart({
-	ticks,
-	systemData,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-}) {
-	const chartTime = useStore($chartTime)
+export default memo(function MemChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()

-	const totalMem = useMemo(() => {
-		return toFixedFloat(systemData.at(-1)?.stats.m ?? 0, 1)
-	}, [systemData])
+	const totalMem = toFixedFloat(chartData.systemStats.at(-1)?.stats.m ?? 0, 1)
+
+	// console.log('rendered at', new Date())

 	return (
 		<div>
 			{/* {!yAxisSet && <Spinner />} */}
 			<ChartContainer
-				config={{}}
 				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
 					'opacity-100': yAxisWidth,
 				})}
 			>
-				<AreaChart
-					accessibilityLayer
-					data={systemData}
-					margin={{
-						top: 10,
-					}}
-				>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
 					<CartesianGrid vertical={false} />
 					{totalMem && (
 						<YAxis
@@ -63,14 +47,15 @@ export default function MemChart({
 					)}
 					<XAxis
 						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
+						domain={chartData.domain}
+						ticks={chartData.ticks}
+						allowDataOverflow
 						type="number"
-						scale={'time'}
-						minTickGap={35}
+						scale="time"
+						minTickGap={30}
 						tickMargin={8}
 						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
+						tickFormatter={chartTimeData[chartData.chartTime].format}
 					/>
 					<ChartTooltip
 						// cursor={false}
@@ -79,16 +64,17 @@ export default function MemChart({
 						content={
 							<ChartTooltipContent
 								// @ts-ignore
-								itemSorter={(a, b) => a.name.localeCompare(b.name)}
+								itemSorter={(a, b) => a.order - b.order}
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' GB'}
-								indicator="line"
+								contentFormatter={(item) => decimalString(item.value) + ' GB'}
+								// indicator="line"
 							/>
 						}
 					/>
 					<Area
-						dataKey="stats.mu"
 						name="Used"
+						order={3}
+						dataKey="stats.mu"
 						type="monotoneX"
 						fill="hsl(var(--chart-2))"
 						fillOpacity={0.4}
@@ -96,14 +82,28 @@ export default function MemChart({
 						stackId="1"
 						isAnimationActive={false}
 					/>
+					{chartData.systemStats.at(-1)?.stats.mz && (
+						<Area
+							name="ZFS ARC"
+							order={2}
+							dataKey="stats.mz"
+							type="monotoneX"
+							fill="hsla(175 60% 45% / 0.8)"
+							fillOpacity={0.5}
+							stroke="hsla(175 60% 45% / 0.8)"
+							stackId="1"
+							isAnimationActive={false}
+						/>
+					)}
 					<Area
-						dataKey="stats.mb"
 						name="Cache / Buffers"
+						order={1}
+						dataKey="stats.mb"
 						type="monotoneX"
-						fill="hsl(var(--chart-2))"
-						fillOpacity={0.2}
-						strokeOpacity={0.3}
-						stroke="hsl(var(--chart-2))"
+						fill="hsla(160 60% 45% / 0.5)"
+						fillOpacity={0.4}
+						// strokeOpacity={1}
+						stroke="hsla(160 60% 45% / 0.5)"
 						stackId="1"
 						isAnimationActive={false}
 					/>
@@ -111,4 +111,4 @@ export default function MemChart({
 			</ChartContainer>
 		</div>
 	)
-}
+})
--- a/beszel/site/src/components/charts/swap-chart.tsx
+++ b/beszel/site/src/components/charts/swap-chart.tsx
@@ -7,36 +7,30 @@ import {
 	cn,
 	formatShortDate,
 	toFixedWithoutTrailingZeros,
-	twoDecimalString,
+	decimalString,
+	chartMargin,
 } from '@/lib/utils'
-// import Spinner from '../spinner'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
+import { ChartData } from '@/types'
+import { memo } from 'react'

-export default function SwapChart({
-	ticks,
-	systemData,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-}) {
-	const chartTime = useStore($chartTime)
+export default memo(function SwapChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()

 	return (
 		<div>
 			<ChartContainer
-				config={{}}
 				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
 					'opacity-100': yAxisWidth,
 				})}
 			>
-				<AreaChart accessibilityLayer data={systemData} margin={{ top: 10 }}>
+				<AreaChart accessibilityLayer data={chartData.systemStats} margin={chartMargin}>
 					<CartesianGrid vertical={false} />
 					<YAxis
 						className="tracking-tighter"
-						domain={[0, () => toFixedWithoutTrailingZeros(systemData.at(-1)?.stats.s ?? 0.04, 2)]}
+						domain={[
+							0,
+							() => toFixedWithoutTrailingZeros(chartData.systemStats.at(-1)?.stats.s ?? 0.04, 2),
+						]}
 						width={yAxisWidth}
 						tickLine={false}
 						axisLine={false}
@@ -44,14 +38,15 @@ export default function SwapChart({
 					/>
 					<XAxis
 						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
+						domain={chartData.domain}
+						ticks={chartData.ticks}
+						allowDataOverflow
 						type="number"
-						scale={'time'}
-						minTickGap={35}
+						scale="time"
+						minTickGap={30}
 						tickMargin={8}
 						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
+						tickFormatter={chartTimeData[chartData.chartTime].format}
 					/>
 					<ChartTooltip
 						animationEasing="ease-out"
@@ -59,8 +54,8 @@ export default function SwapChart({
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' GB'}
-								indicator="line"
+								contentFormatter={(item) => decimalString(item.value) + ' GB'}
+								// indicator="line"
 							/>
 						}
 					/>
@@ -77,4 +72,4 @@ export default function SwapChart({
 			</ChartContainer>
 		</div>
 	)
-}
+})
--- a/beszel/site/src/components/charts/temperature-chart.tsx
+++ b/beszel/site/src/components/charts/temperature-chart.tsx
@@ -13,31 +13,23 @@ import {
 	cn,
 	formatShortDate,
 	toFixedWithoutTrailingZeros,
-	twoDecimalString,
+	decimalString,
+	chartMargin,
 } from '@/lib/utils'
-import { useStore } from '@nanostores/react'
-import { $chartTime } from '@/lib/stores'
-import { SystemStatsRecord } from '@/types'
-import { useMemo } from 'react'
+import { ChartData } from '@/types'
+import { memo, useMemo } from 'react'

-export default function TemperatureChart({
-	ticks,
-	systemData,
-}: {
-	ticks: number[]
-	systemData: SystemStatsRecord[]
-}) {
-	const chartTime = useStore($chartTime)
+export default memo(function TemperatureChart({ chartData }: { chartData: ChartData }) {
 	const { yAxisWidth, updateYAxisWidth } = useYAxisWidth()

 	/** Format temperature data for chart and assign colors */
 	const newChartData = useMemo(() => {
-		const chartData = { data: [], colors: {} } as {
+		const newChartData = { data: [], colors: {} } as {
 			data: Record<string, number | string>[]
 			colors: Record<string, string>
 		}
 		const tempSums = {} as Record<string, number>
-		for (let data of systemData) {
+		for (let data of chartData.systemStats) {
 			let newData = { created: data.created } as Record<string, number | string>
 			let keys = Object.keys(data.stats?.t ?? {})
 			for (let i = 0; i < keys.length; i++) {
@@ -45,37 +37,31 @@ export default function TemperatureChart({
 				newData[key] = data.stats.t![key]
 				tempSums[key] = (tempSums[key] ?? 0) + newData[key]
 			}
-			chartData.data.push(newData)
+			newChartData.data.push(newData)
 		}
 		const keys = Object.keys(tempSums).sort((a, b) => tempSums[b] - tempSums[a])
 		for (let key of keys) {
-			chartData.colors[key] = `hsl(${((keys.indexOf(key) * 360) / keys.length) % 360}, 60%, 55%)`
+			newChartData.colors[key] = `hsl(${((keys.indexOf(key) * 360) / keys.length) % 360}, 60%, 55%)`
 		}
-		return chartData
-	}, [systemData])
+		return newChartData
+	}, [chartData])
+
+	const colors = Object.keys(newChartData.colors)
+
+	// console.log('rendered at', new Date())

 	return (
 		<div>
-			{/* {!yAxisSet && <Spinner />} */}
 			<ChartContainer
-				config={{}}
 				className={cn('h-full w-full absolute aspect-auto bg-card opacity-0 transition-opacity', {
 					'opacity-100': yAxisWidth,
 				})}
 			>
-				<LineChart
-					accessibilityLayer
-					data={newChartData.data}
-					margin={{
-						left: 0,
-						right: 0,
-						top: 10,
-						bottom: 0,
-					}}
-				>
+				<LineChart accessibilityLayer data={newChartData.data} margin={chartMargin}>
 					<CartesianGrid vertical={false} />
 					<YAxis
 						className="tracking-tighter"
+						domain={[0, 'auto']}
 						width={yAxisWidth}
 						tickFormatter={(value) => {
 							const val = toFixedWithoutTrailingZeros(value, 2)
@@ -86,14 +72,15 @@ export default function TemperatureChart({
 					/>
 					<XAxis
 						dataKey="created"
-						domain={[ticks[0], ticks.at(-1)!]}
-						ticks={ticks}
+						domain={chartData.domain}
+						ticks={chartData.ticks}
+						allowDataOverflow
 						type="number"
-						scale={'time'}
-						minTickGap={35}
+						scale="time"
+						minTickGap={30}
 						tickMargin={8}
 						axisLine={false}
-						tickFormatter={chartTimeData[chartTime].format}
+						tickFormatter={chartTimeData[chartData.chartTime].format}
 					/>
 					<ChartTooltip
 						animationEasing="ease-out"
@@ -103,12 +90,12 @@ export default function TemperatureChart({
 						content={
 							<ChartTooltipContent
 								labelFormatter={(_, data) => formatShortDate(data[0].payload.created)}
-								contentFormatter={(item) => twoDecimalString(item.value) + ' °C'}
-								indicator="line"
+								contentFormatter={(item) => decimalString(item.value) + ' °C'}
+								// indicator="line"
 							/>
 						}
 					/>
-					{Object.keys(newChartData.colors).map((key) => (
+					{colors.map((key) => (
 						<Line
 							key={key}
 							dataKey={key}
@@ -120,9 +107,9 @@ export default function TemperatureChart({
 							isAnimationActive={false}
 						/>
 					))}
-					<ChartLegend content={<ChartLegendContent />} />
+					{colors.length < 12 && <ChartLegend content={<ChartLegendContent />} />}
 				</LineChart>
 			</ChartContainer>
 		</div>
 	)
-}
+})
--- a/beszel/site/src/components/command-palette.tsx
+++ b/beszel/site/src/components/command-palette.tsx
@@ -143,7 +143,7 @@ export default function CommandPalette() {
 								}}
 							>
 								<DatabaseBackupIcon className="mr-2 h-4 w-4" />
-								<span>Database backups</span>
+								<span>Backups</span>
 								<CommandShortcut>Admin</CommandShortcut>
 							</CommandItem>
 							<CommandItem
--- a/beszel/site/src/components/routes/home.tsx
+++ b/beszel/site/src/components/routes/home.tsx
@@ -1,18 +1,35 @@
-import { Suspense, lazy, useEffect, useState } from 'react'
+import { Suspense, lazy, useEffect, useMemo, useState } from 'react'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '../ui/card'
 import { $alerts, $hubVersion, $systems, pb } from '@/lib/stores'
 import { useStore } from '@nanostores/react'
 import { GithubIcon } from 'lucide-react'
 import { Separator } from '../ui/separator'
-import { updateRecordList, updateSystemList } from '@/lib/utils'
+import { alertInfo, updateRecordList, updateSystemList } from '@/lib/utils'
 import { AlertRecord, SystemRecord } from '@/types'
 import { Input } from '../ui/input'
+import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
+import { Link } from '../router'

 const SystemsTable = lazy(() => import('../systems-table/systems-table'))

 export default function () {
 	const hubVersion = useStore($hubVersion)
 	const [filter, setFilter] = useState<string>()
+	const alerts = useStore($alerts)
+	const systems = useStore($systems)
+
+	// todo: maybe remove active alert if changed
+	const activeAlerts = useMemo(() => {
+		const activeAlerts = alerts.filter((alert) => {
+			const active = alert.triggered && alert.name in alertInfo
+			if (!active) {
+				return false
+			}
+			alert.sysname = systems.find((system) => system.id === alert.system)?.name
+			return true
+		})
+		return activeAlerts
+	}, [alerts])

 	useEffect(() => {
 		document.title = 'Dashboard / Beszel'
@@ -24,17 +41,57 @@ export default function () {
 		pb.collection<SystemRecord>('systems').subscribe('*', (e) => {
 			updateRecordList(e, $systems)
 		})
+		// todo: add toast if new triggered alert comes in
 		pb.collection<AlertRecord>('alerts').subscribe('*', (e) => {
 			updateRecordList(e, $alerts)
 		})
 		return () => {
 			pb.collection('systems').unsubscribe('*')
-			pb.collection('alerts').unsubscribe('*')
+			// pb.collection('alerts').unsubscribe('*')
 		}
 	}, [])

 	return (
 		<>
+			{/* show active alerts */}
+			{activeAlerts.length > 0 && (
+				<Card className="mb-4">
+					<CardHeader className="pb-4 px-2 sm:px-6 max-sm:pt-5 max-sm:pb-1">
+						<div className="px-2 sm:px-1">
+							<CardTitle>Active Alerts</CardTitle>
+						</div>
+					</CardHeader>
+					<CardContent className="max-sm:p-2">
+						{activeAlerts.length > 0 && (
+							<div className="grid sm:grid-cols-2 lg:grid-cols-3 2xl:grid-cols-4 gap-3">
+								{activeAlerts.map((alert) => {
+									const info = alertInfo[alert.name as keyof typeof alertInfo]
+									return (
+										<Alert
+											key={alert.id}
+											className="hover:-translate-y-[1px] duration-200 bg-transparent border-foreground/10  hover:shadow-md shadow-black"
+										>
+											<info.icon className="h-4 w-4" />
+											<AlertTitle className="mb-2">
+												{alert.sysname} {info.name}
+											</AlertTitle>
+											<AlertDescription>
+												Exceeds {alert.value}
+												{info.unit} average in last {alert.min} min
+											</AlertDescription>
+											<Link
+												href={`/system/${encodeURIComponent(alert.sysname!)}`}
+												className="absolute inset-0 w-full h-full"
+												aria-label="View system"
+											></Link>
+										</Alert>
+									)
+								})}
+							</div>
+						)}
+					</CardContent>
+				</Card>
+			)}
 			<Card>
 				<CardHeader className="pb-5 px-2 sm:px-6 max-sm:pt-5 max-sm:pb-1">
 					<div className="grid md:flex gap-3 w-full items-end">
@@ -61,6 +118,7 @@ export default function () {
 					</Suspense>
 				</CardContent>
 			</Card>
+
 			{hubVersion && (
 				<div className="flex gap-1.5 justify-end items-center pr-3 sm:pr-6 mt-3.5 text-xs opacity-80">
 					<a
--- a/beszel/site/src/components/routes/settings/general.tsx
+++ b/beszel/site/src/components/routes/settings/general.tsx
@@ -71,7 +71,11 @@ export default function SettingsProfilePage({ userSettings }: { userSettings: Us
 					<Label className="block" htmlFor="chartTime">
 						Default time period
 					</Label>
-					<Select name="chartTime" defaultValue={userSettings.chartTime}>
+					<Select
+						name="chartTime"
+						key={userSettings.chartTime}
+						defaultValue={userSettings.chartTime}
+					>
 						<SelectTrigger id="chartTime">
 							<SelectValue />
 						</SelectTrigger>
--- a/beszel/site/src/components/routes/settings/notifications.tsx
+++ b/beszel/site/src/components/routes/settings/notifications.tsx
@@ -5,7 +5,7 @@ import { pb } from '@/lib/stores'
 import { Separator } from '@/components/ui/separator'
 import { Card } from '@/components/ui/card'
 import { BellIcon, LoaderCircleIcon, PlusIcon, SaveIcon, Trash2Icon } from 'lucide-react'
-import { ChangeEventHandler, useState } from 'react'
+import { ChangeEventHandler, useEffect, useState } from 'react'
 import { toast } from '@/components/ui/use-toast'
 import { InputTags } from '@/components/ui/input-tags'
 import { UserSettings } from '@/types'
@@ -29,7 +29,13 @@ const SettingsNotificationsPage = ({ userSettings }: { userSettings: UserSetting
 	const [emails, setEmails] = useState<string[]>(userSettings.emails ?? [])
 	const [isLoading, setIsLoading] = useState(false)

-	const addWebhook = () => {
+	// update values when userSettings changes
+	useEffect(() => {
+		setWebhooks(userSettings.webhooks ?? [])
+		setEmails(userSettings.emails ?? [])
+	}, [userSettings])
+
+	function addWebhook() {
 		setWebhooks([...webhooks, ''])
 		// focus on the new input
 		queueMicrotask(() => {
@@ -39,7 +45,7 @@ const SettingsNotificationsPage = ({ userSettings }: { userSettings: UserSetting
 	}
 	const removeWebhook = (index: number) => setWebhooks(webhooks.filter((_, i) => i !== index))

-	const updateWebhook = (index: number, value: string) => {
+	function updateWebhook(index: number, value: string) {
 		const newWebhooks = [...webhooks]
 		newWebhooks[index] = value
 		setWebhooks(newWebhooks)
--- a/beszel/site/src/components/routes/system.tsx
+++ b/beszel/site/src/components/routes/system.tsx
@@ -1,83 +1,139 @@
 import { $systems, pb, $chartTime, $containerFilter, $userSettings } from '@/lib/stores'
-import { ContainerStatsRecord, SystemRecord, SystemStatsRecord } from '@/types'
-import { Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { Card, CardHeader, CardTitle, CardDescription, CardContent } from '../ui/card'
+import {
+	ChartData,
+	ChartTimes,
+	ContainerStatsRecord,
+	SystemRecord,
+	SystemStatsRecord,
+} from '@/types'
+import React, { Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { Card, CardHeader, CardTitle, CardDescription } from '../ui/card'
 import { useStore } from '@nanostores/react'
 import Spinner from '../spinner'
-import {
-	ClockArrowUp,
-	CpuIcon,
-	GlobeIcon,
-	LayoutGridIcon,
-	MonitorIcon,
-	StretchHorizontalIcon,
-	XIcon,
-} from 'lucide-react'
+import { ClockArrowUp, CpuIcon, GlobeIcon, LayoutGridIcon, MonitorIcon, XIcon } from 'lucide-react'
 import ChartTimeSelect from '../charts/chart-time-select'
-import {
-	chartTimeData,
-	cn,
-	getPbTimestamp,
-	useClampedIsInViewport,
-	useLocalStorage,
-} from '@/lib/utils'
+import { chartTimeData, cn, getPbTimestamp, useLocalStorage } from '@/lib/utils'
 import { Separator } from '../ui/separator'
-import { scaleTime } from 'd3-scale'
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../ui/tooltip'
-import { Button, buttonVariants } from '../ui/button'
+import { Button } from '../ui/button'
 import { Input } from '../ui/input'
+import { ChartAverage, ChartMax, Rows, TuxIcon } from '../ui/icons'
+import { useIntersectionObserver } from '@/lib/use-intersection-observer'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../ui/select'
+import { timeTicks } from 'd3-time'

-const CpuChart = lazy(() => import('../charts/cpu-chart'))
-const ContainerCpuChart = lazy(() => import('../charts/container-cpu-chart'))
+const AreaChartDefault = lazy(() => import('../charts/area-chart'))
+const ContainerChart = lazy(() => import('../charts/container-chart'))
 const MemChart = lazy(() => import('../charts/mem-chart'))
-const ContainerMemChart = lazy(() => import('../charts/container-mem-chart'))
 const DiskChart = lazy(() => import('../charts/disk-chart'))
-const DiskIoChart = lazy(() => import('../charts/disk-io-chart'))
-const BandwidthChart = lazy(() => import('../charts/bandwidth-chart'))
-const ContainerNetChart = lazy(() => import('../charts/container-net-chart'))
 const SwapChart = lazy(() => import('../charts/swap-chart'))
 const TemperatureChart = lazy(() => import('../charts/temperature-chart'))
-const ExFsDiskChart = lazy(() => import('../charts/extra-fs-disk-chart'))
-const ExFsDiskIoChart = lazy(() => import('../charts/extra-fs-disk-io-chart'))
+
+const cache = new Map<string, any>()
+
+// create ticks and domain for charts
+function getTimeData(chartTime: ChartTimes, lastCreated: number) {
+	const cached = cache.get('td')
+	if (cached && cached.chartTime === chartTime) {
+		if (!lastCreated || cached.time >= lastCreated) {
+			return cached.data
+		}
+	}
+
+	const now = new Date()
+	const startTime = chartTimeData[chartTime].getOffset(now)
+	const ticks = timeTicks(startTime, now, chartTimeData[chartTime].ticks ?? 12).map((date) =>
+		date.getTime()
+	)
+	const data = {
+		ticks,
+		domain: [chartTimeData[chartTime].getOffset(now).getTime(), now.getTime()],
+	}
+	cache.set('td', { time: now.getTime(), data, chartTime })
+	return data
+}
+
+// add empty values between records to make gaps if interval is too large
+function addEmptyValues<T extends SystemStatsRecord | ContainerStatsRecord>(
+	prevRecords: T[],
+	newRecords: T[],
+	expectedInterval: number
+) {
+	const modifiedRecords: T[] = []
+	let prevTime = (prevRecords.at(-1)?.created ?? 0) as number
+	for (let i = 0; i < newRecords.length; i++) {
+		const record = newRecords[i]
+		record.created = new Date(record.created).getTime()
+		if (prevTime) {
+			const interval = record.created - prevTime
+			// if interval is too large, add a null record
+			if (interval > expectedInterval / 2 + expectedInterval) {
+				// @ts-ignore
+				modifiedRecords.push({ created: null, stats: null })
+			}
+		}
+		prevTime = record.created
+		modifiedRecords.push(record)
+	}
+	return modifiedRecords
+}
+
+async function getStats<T>(
+	collection: string,
+	system: SystemRecord,
+	chartTime: ChartTimes
+): Promise<T[]> {
+	const lastCached = cache.get(`${system.id}_${chartTime}_${collection}`)?.at(-1)?.created as number
+	return await pb.collection<T>(collection).getFullList({
+		filter: pb.filter('system={:id} && created > {:created} && type={:type}', {
+			id: system.id,
+			created: getPbTimestamp(chartTime, lastCached ? new Date(lastCached + 1000) : undefined),
+			type: chartTimeData[chartTime].type,
+		}),
+		fields: 'created,stats',
+		sort: 'created',
+	})
+}

 export default function SystemDetail({ name }: { name: string }) {
 	const systems = useStore($systems)
 	const chartTime = useStore($chartTime)
+	/** Max CPU toggle value */
+	const cpuMaxStore = useState(false)
+	const bandwidthMaxStore = useState(false)
+	const diskIoMaxStore = useState(false)
 	const [grid, setGrid] = useLocalStorage('grid', true)
-	const [ticks, setTicks] = useState([] as number[])
 	const [system, setSystem] = useState({} as SystemRecord)
 	const [systemStats, setSystemStats] = useState([] as SystemStatsRecord[])
-	const [hasDockerStats, setHasDocker] = useState(false)
+	const [containerData, setContainerData] = useState([] as ChartData['containerData'])
 	const netCardRef = useRef<HTMLDivElement>(null)
-	const [dockerCpuChartData, setDockerCpuChartData] = useState<Record<string, number | string>[]>(
-		[]
-	)
-	const [dockerMemChartData, setDockerMemChartData] = useState<Record<string, number | string>[]>(
-		[]
-	)
-	const [dockerNetChartData, setDockerNetChartData] = useState<Record<string, number | number[]>[]>(
-		[]
-	)
+	const [containerFilterBar, setContainerFilterBar] = useState(null as null | JSX.Element)
+	const [bottomSpacing, setBottomSpacing] = useState(0)
+	const isLongerChart = chartTime !== '1h'

 	useEffect(() => {
 		document.title = `${name} / Beszel`
 		return () => {
-			resetCharts()
 			$chartTime.set($userSettings.get().chartTime)
+			// resetCharts()
+			setSystemStats([])
+			setContainerData([])
+			setContainerFilterBar(null)
 			$containerFilter.set('')
-			setHasDocker(false)
+			cpuMaxStore[1](false)
+			bandwidthMaxStore[1](false)
+			diskIoMaxStore[1](false)
 		}
 	}, [name])

-	function resetCharts() {
-		setSystemStats([])
-		setDockerCpuChartData([])
-		setDockerMemChartData([])
-		setDockerNetChartData([])
-	}
+	// function resetCharts() {
+	// 	setSystemStats([])
+	// 	setContainerData([])
+	// }

-	useEffect(resetCharts, [chartTime])
+	// useEffect(resetCharts, [chartTime])

+	// find matching system
 	useEffect(() => {
 		if (system.id && system.name === name) {
 			return
@@ -101,41 +157,18 @@ export default function SystemDetail({ name }: { name: string }) {
 		}
 	}, [system])

-	async function getStats<T>(collection: string): Promise<T[]> {
-		return await pb.collection<T>(collection).getFullList({
-			filter: pb.filter('system={:id} && created > {:created} && type={:type}', {
-				id: system.id,
-				created: getPbTimestamp(chartTime),
-				type: chartTimeData[chartTime].type,
-			}),
-			fields: 'created,stats',
-			sort: 'created',
-		})
-	}
-
-	// add empty values between records to make gaps if interval is too large
-	function addEmptyValues<T extends SystemStatsRecord | ContainerStatsRecord>(
-		records: T[],
-		expectedInterval: number
-	) {
-		const modifiedRecords: T[] = []
-		let prevTime = 0
-		for (let i = 0; i < records.length; i++) {
-			const record = records[i]
-			record.created = new Date(record.created).getTime()
-			if (prevTime) {
-				const interval = record.created - prevTime
-				// if interval is too large, add a null record
-				if (interval > expectedInterval / 2 + expectedInterval) {
-					// @ts-ignore
-					modifiedRecords.push({ created: null, stats: null })
-				}
-			}
-			prevTime = record.created
-			modifiedRecords.push(record)
+	const chartData: ChartData = useMemo(() => {
+		const lastCreated = Math.max(
+			(systemStats.at(-1)?.created as number) ?? 0,
+			(containerData.at(-1)?.created as number) ?? 0
+		)
+		return {
+			systemStats,
+			containerData,
+			chartTime,
+			...getTimeData(chartTime, lastCreated),
 		}
-		return modifiedRecords
-	}
+	}, [systemStats, containerData])

 	// get stats
 	useEffect(() => {
@@ -143,82 +176,113 @@ export default function SystemDetail({ name }: { name: string }) {
 			return
 		}
 		Promise.allSettled([
-			getStats<SystemStatsRecord>('system_stats'),
-			getStats<ContainerStatsRecord>('container_stats'),
+			getStats<SystemStatsRecord>('system_stats', system, chartTime),
+			getStats<ContainerStatsRecord>('container_stats', system, chartTime),
 		]).then(([systemStats, containerStats]) => {
-			const expectedInterval = chartTimeData[chartTime].expectedInterval
+			const { expectedInterval } = chartTimeData[chartTime]
+			// make new system stats
+			const ss_cache_key = `${system.id}_${chartTime}_system_stats`
+			let systemData = (cache.get(ss_cache_key) || []) as SystemStatsRecord[]
+			if (systemStats.status === 'fulfilled' && systemStats.value.length) {
+				systemData = systemData.concat(
+					addEmptyValues(systemData, systemStats.value, expectedInterval)
+				)
+				if (systemData.length > 120) {
+					systemData = systemData.slice(-100)
+				}
+				cache.set(ss_cache_key, systemData)
+			}
+			setSystemStats(systemData)
+			// make new container stats
+			const cs_cache_key = `${system.id}_${chartTime}_container_stats`
+			let containerData = (cache.get(cs_cache_key) || []) as ContainerStatsRecord[]
 			if (containerStats.status === 'fulfilled' && containerStats.value.length) {
-				makeContainerData(addEmptyValues(containerStats.value, expectedInterval))
-				setHasDocker(true)
+				containerData = containerData.concat(
+					addEmptyValues(containerData, containerStats.value, expectedInterval)
+				)
+				if (containerData.length > 120) {
+					containerData = containerData.slice(-100)
+				}
+				cache.set(cs_cache_key, containerData)
 			}
-			if (systemStats.status === 'fulfilled') {
-				setSystemStats(addEmptyValues(systemStats.value, expectedInterval))
+			if (containerData.length) {
+				!containerFilterBar && setContainerFilterBar(<ContainerFilterBar />)
+			} else if (containerFilterBar) {
+				setContainerFilterBar(null)
 			}
+			makeContainerData(containerData)
 		})
 	}, [system, chartTime])

-	useEffect(() => {
-		if (!systemStats.length) {
-			return
-		}
-		const now = new Date()
-		const startTime = chartTimeData[chartTime].getOffset(now)
-		const scale = scaleTime([startTime.getTime(), now], [0, systemStats.length])
-		setTicks(scale.ticks(chartTimeData[chartTime].ticks).map((d) => d.getTime()))
-	}, [chartTime, systemStats])
-
 	// make container stats for charts
 	const makeContainerData = useCallback((containers: ContainerStatsRecord[]) => {
-		// console.log('containers', containers)
-		const dockerCpuData = []
-		const dockerMemData = []
-		const dockerNetData = []
+		const containerData = [] as ChartData['containerData']
 		for (let { created, stats } of containers) {
 			if (!created) {
-				let nullData = { time: null } as unknown
-				dockerCpuData.push(nullData as Record<string, number | string>)
-				dockerMemData.push(nullData as Record<string, number | string>)
-				dockerNetData.push(nullData as Record<string, number | number[]>)
+				// @ts-ignore add null value for gaps
+				containerData.push({ created: null })
 				continue
 			}
-			const time = new Date(created).getTime()
-			let cpuData = { time } as Record<string, number | string>
-			let memData = { time } as Record<string, number | string>
-			let netData = { time } as Record<string, number | number[]>
+			created = new Date(created).getTime()
+			// @ts-ignore not dealing with this rn
+			let containerStats: ChartData['containerData'][0] = { created }
 			for (let container of stats) {
-				cpuData[container.n] = container.c
-				memData[container.n] = container.m
-				netData[container.n] = [container.ns, container.nr, container.ns + container.nr] // sent, received, total
+				containerStats[container.n] = container
 			}
-			dockerCpuData.push(cpuData)
-			dockerMemData.push(memData)
-			dockerNetData.push(netData)
+			containerData.push(containerStats)
 		}
-		setDockerCpuChartData(dockerCpuData)
-		setDockerMemChartData(dockerMemData)
-		setDockerNetChartData(dockerNetData)
+		setContainerData(containerData)
 	}, [])

-	const uptime = useMemo(() => {
-		let uptime = system.info?.u || 0
-		if (uptime < 172800) {
-			return `${Math.trunc(uptime / 3600)} hours`
+	// values for system info bar
+	const systemInfo = useMemo(() => {
+		if (!system.info) {
+			return []
 		}
-		return `${Math.trunc(system.info?.u / 86400)} days`
-	}, [system.info?.u])
+		let uptime: number | string = system.info.u
+		if (system.info.u < 172800) {
+			const hours = Math.trunc(uptime / 3600)
+			uptime = `${hours} hour${hours == 1 ? '' : 's'}`
+		} else {
+			uptime = `${Math.trunc(system.info?.u / 86400)} days`
+		}
+		return [
+			{ value: system.host, Icon: GlobeIcon },
+			{
+				value: system.info.h,
+				Icon: MonitorIcon,
+				label: 'Hostname',
+				// hide if hostname is same as host or name
+				hide: system.info.h === system.host || system.info.h === system.name,
+			},
+			{ value: uptime, Icon: ClockArrowUp, label: 'Uptime' },
+			{ value: system.info.k, Icon: TuxIcon, label: 'Kernel' },
+			{
+				value: `${system.info.m} (${system.info.c}c${system.info.t ? `/${system.info.t}t` : ''})`,
+				Icon: CpuIcon,
+				hide: !system.info.m,
+			},
+		] as {
+			value: string | number | undefined
+			label?: string
+			Icon: any
+			hide?: boolean
+		}[]
+	}, [system.info])

 	/** Space for tooltip if more than 12 containers */
-	const bottomSpacing = useMemo(() => {
-		if (!netCardRef.current || !dockerNetChartData.length) {
-			return 0
+	useEffect(() => {
+		if (!netCardRef.current || !containerData.length) {
+			setBottomSpacing(0)
+			return
 		}
-		const tooltipHeight = (Object.keys(dockerNetChartData[0]).length - 11) * 17.8 - 40
+		const tooltipHeight = (Object.keys(containerData[0]).length - 11) * 17.8 - 40
 		const wrapperEl = document.getElementById('chartwrap') as HTMLDivElement
 		const wrapperRect = wrapperEl.getBoundingClientRect()
 		const chartRect = netCardRef.current.getBoundingClientRect()
 		const distanceToBottom = wrapperRect.bottom - chartRect.bottom
-		return tooltipHeight - distanceToBottom
-	}, [netCardRef.current, dockerNetChartData])
+		setBottomSpacing(tooltipHeight - distanceToBottom)
+	}, [netCardRef, containerData])

 	if (!system.id) {
 		return null
@@ -226,10 +290,10 @@ export default function SystemDetail({ name }: { name: string }) {

 	return (
 		<>
-			<div id="chartwrap" className="grid gap-4 mb-10">
+			<div id="chartwrap" className="grid gap-4 mb-10 overflow-x-clip">
 				{/* system info */}
 				<Card>
-					<div className="grid lg:flex items-center gap-4 px-4 sm:px-6 pt-3 sm:pt-4 pb-5">
+					<div className="grid lg:flex gap-4 px-4 sm:px-6 pt-3 sm:pt-4 pb-5">
 						<div>
 							<h1 className="text-[1.6rem] font-semibold mb-1.5">{system.name}</h1>
 							<div className="flex flex-wrap items-center gap-3 gap-y-2 text-sm opacity-90">
@@ -252,46 +316,31 @@ export default function SystemDetail({ name }: { name: string }) {
 									</span>
 									{system.status}
 								</div>
-								<Separator orientation="vertical" className="h-4 bg-primary/30" />
-								<div className="flex gap-1.5 items-center">
-									<GlobeIcon className="h-4 w-4" /> {system.host}
-								</div>
-								{/* show hostname if it's different than host or name */}
-								{system.info?.h && system.info.h != system.host && system.info.h != system.name && (
-									<TooltipProvider>
-										<Tooltip delayDuration={150}>
-											<Separator orientation="vertical" className="h-4 bg-primary/30" />
-											<TooltipTrigger asChild>
-												<div className="flex gap-1.5 items-center">
-													<MonitorIcon className="h-4 w-4" /> {system.info.h}
-												</div>
-											</TooltipTrigger>
-											<TooltipContent>Hostname</TooltipContent>
-										</Tooltip>
-									</TooltipProvider>
-								)}
-								{system.info?.u && (
-									<TooltipProvider>
-										<Tooltip delayDuration={150}>
-											<Separator orientation="vertical" className="h-4 bg-primary/30" />
-											<TooltipTrigger asChild>
-												<div className="flex gap-1.5 items-center">
-													<ClockArrowUp className="h-4 w-4" /> {uptime}
-												</div>
-											</TooltipTrigger>
-											<TooltipContent>Uptime</TooltipContent>
-										</Tooltip>
-									</TooltipProvider>
-								)}
-								{system.info?.m && (
-									<>
-										<Separator orientation="vertical" className="h-4 bg-primary/30" />
+								{systemInfo.map(({ value, label, Icon, hide }, i) => {
+									if (hide || !value) {
+										return null
+									}
+									const content = (
 										<div className="flex gap-1.5 items-center">
-											<CpuIcon className="h-4 w-4" />
-											{system.info.m} ({system.info.c}c/{system.info.t}t)
+											<Icon className="h-4 w-4" /> {value}
 										</div>
-									</>
-								)}
+									)
+									return (
+										<div key={i} className="contents">
+											<Separator orientation="vertical" className="h-4 bg-primary/30" />
+											{label ? (
+												<TooltipProvider>
+													<Tooltip delayDuration={150}>
+														<TooltipTrigger asChild>{content}</TooltipTrigger>
+														<TooltipContent>{label}</TooltipContent>
+													</Tooltip>
+												</TooltipProvider>
+											) : (
+												content
+											)}
+										</div>
+									)
+								})}
 							</div>
 						</div>
 						<div className="lg:ml-auto flex items-center gap-2 max-sm:-mb-1">
@@ -301,16 +350,15 @@ export default function SystemDetail({ name }: { name: string }) {
 									<TooltipTrigger asChild>
 										<Button
 											aria-label="Toggle grid"
-											className={cn(
-												buttonVariants({ variant: 'outline', size: 'icon' }),
-												'hidden lg:flex p-0 text-primary'
-											)}
+											variant="outline"
+											size="icon"
+											className="hidden lg:flex p-0 text-primary"
 											onClick={() => setGrid(!grid)}
 										>
 											{grid ? (
 												<LayoutGridIcon className="h-[1.2rem] w-[1.2rem] opacity-85" />
 											) : (
-												<StretchHorizontalIcon className="h-[1.2rem] w-[1.2rem] opacity-85" />
+												<Rows className="h-[1.3rem] w-[1.3rem] opacity-85" />
 											)}
 										</Button>
 									</TooltipTrigger>
@@ -326,19 +374,27 @@ export default function SystemDetail({ name }: { name: string }) {
 					<ChartCard
 						grid={grid}
 						title="Total CPU Usage"
-						description="Average system-wide CPU utilization"
+						description={`${
+							cpuMaxStore[0] && isLongerChart ? 'Max 1 min ' : 'Average'
+						} system-wide CPU utilization`}
+						cornerEl={isLongerChart ? <SelectAvgMax store={cpuMaxStore} /> : null}
 					>
-						<CpuChart ticks={ticks} systemData={systemStats} />
+						<AreaChartDefault
+							chartData={chartData}
+							chartName="CPU Usage"
+							maxToggled={cpuMaxStore[0]}
+							unit="%"
+						/>
 					</ChartCard>

-					{hasDockerStats && (
+					{containerFilterBar && (
 						<ChartCard
 							grid={grid}
 							title="Docker CPU Usage"
-							description="CPU utilization of docker containers"
-							isContainerChart={true}
+							description="Average CPU utilization of containers"
+							cornerEl={containerFilterBar}
 						>
-							<ContainerCpuChart chartData={dockerCpuChartData} ticks={ticks} />
+							<ContainerChart chartData={chartData} dataKey="c" chartName="cpu" />
 						</ChartCard>
 					)}

@@ -347,43 +403,55 @@ export default function SystemDetail({ name }: { name: string }) {
 						title="Total Memory Usage"
 						description="Precise utilization at the recorded time"
 					>
-						<MemChart ticks={ticks} systemData={systemStats} />
+						<MemChart chartData={chartData} />
 					</ChartCard>

-					{hasDockerStats && (
+					{containerFilterBar && (
 						<ChartCard
 							grid={grid}
 							title="Docker Memory Usage"
 							description="Memory usage of docker containers"
-							isContainerChart={true}
+							cornerEl={containerFilterBar}
 						>
-							<ContainerMemChart chartData={dockerMemChartData} ticks={ticks} />
-						</ChartCard>
-					)}
-
-					{(systemStats.at(-1)?.stats.s ?? 0) > 0 && (
-						<ChartCard grid={grid} title="Swap Usage" description="Swap space used by the system">
-							<SwapChart ticks={ticks} systemData={systemStats} />
+							<ContainerChart chartData={chartData} chartName="mem" dataKey="m" unit=" MB" />
 						</ChartCard>
 					)}

 					<ChartCard grid={grid} title="Disk Space" description="Usage of root partition">
-						<DiskChart ticks={ticks} systemData={systemStats} />
+						<DiskChart
+							chartData={chartData}
+							dataKey="stats.du"
+							diskSize={Math.round(systemStats.at(-1)?.stats.d ?? NaN)}
+						/>
 					</ChartCard>

-					<ChartCard grid={grid} title="Disk I/O" description="Throughput of root filesystem">
-						<DiskIoChart ticks={ticks} systemData={systemStats} />
+					<ChartCard
+						grid={grid}
+						title="Disk I/O"
+						description="Throughput of root filesystem"
+						cornerEl={isLongerChart ? <SelectAvgMax store={diskIoMaxStore} /> : null}
+					>
+						<AreaChartDefault
+							chartData={chartData}
+							maxToggled={diskIoMaxStore[0]}
+							chartName="dio"
+						/>
 					</ChartCard>

 					<ChartCard
 						grid={grid}
 						title="Bandwidth"
+						cornerEl={isLongerChart ? <SelectAvgMax store={bandwidthMaxStore} /> : null}
 						description="Network traffic of public interfaces"
 					>
-						<BandwidthChart ticks={ticks} systemData={systemStats} />
+						<AreaChartDefault
+							chartData={chartData}
+							maxToggled={bandwidthMaxStore[0]}
+							chartName="bw"
+						/>
 					</ChartCard>

-					{hasDockerStats && dockerNetChartData.length > 0 && (
+					{containerFilterBar && containerData.length > 0 && (
 						<div
 							ref={netCardRef}
 							className={cn({
@@ -393,16 +461,23 @@ export default function SystemDetail({ name }: { name: string }) {
 							<ChartCard
 								title="Docker Network I/O"
 								description="Includes traffic between internal services"
-								isContainerChart={true}
+								cornerEl={containerFilterBar}
 							>
-								<ContainerNetChart chartData={dockerNetChartData} ticks={ticks} />
+								{/* @ts-ignore */}
+								<ContainerChart chartData={chartData} chartName="net" dataKey="n" />
 							</ChartCard>
 						</div>
 					)}

+					{(systemStats.at(-1)?.stats.su ?? 0) > 0 && (
+						<ChartCard grid={grid} title="Swap Usage" description="Swap space used by the system">
+							<SwapChart chartData={chartData} />
+						</ChartCard>
+					)}
+
 					{systemStats.at(-1)?.stats.t && (
 						<ChartCard grid={grid} title="Temperature" description="Temperatures of system sensors">
-							<TemperatureChart ticks={ticks} systemData={systemStats} />
+							<TemperatureChart chartData={chartData} />
 						</ChartCard>
 					)}
 				</div>
@@ -418,14 +493,23 @@ export default function SystemDetail({ name }: { name: string }) {
 										title={`${extraFsName} Usage`}
 										description={`Disk usage of ${extraFsName}`}
 									>
-										<ExFsDiskChart ticks={ticks} systemData={systemStats} fs={extraFsName} />
+										<DiskChart
+											chartData={chartData}
+											dataKey={`stats.efs.${extraFsName}.du`}
+											diskSize={Math.round(systemStats.at(-1)?.stats.efs?.[extraFsName].d ?? NaN)}
+										/>
 									</ChartCard>
 									<ChartCard
 										grid={grid}
 										title={`${extraFsName} I/O`}
-										description={`Throughput of of ${extraFsName}`}
+										description={`Throughput of ${extraFsName}`}
+										cornerEl={isLongerChart ? <SelectAvgMax store={diskIoMaxStore} /> : null}
 									>
-										<ExFsDiskIoChart ticks={ticks} systemData={systemStats} fs={extraFsName} />
+										<AreaChartDefault
+											chartData={chartData}
+											maxToggled={diskIoMaxStore[0]}
+											chartName={`efs.${extraFsName}`}
+										/>
 									</ChartCard>
 								</div>
 							)
@@ -445,10 +529,10 @@ function ContainerFilterBar() {

 	const handleChange = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
 		$containerFilter.set(e.target.value)
-	}, []) // Use an empty dependency array to prevent re-creation
+	}, [])

 	return (
-		<div className="relative py-1 block sm:w-44 sm:absolute sm:top-2.5 sm:right-3.5">
+		<>
 			<Input
 				placeholder="Filter..."
 				className="pl-4 pr-8"
@@ -467,7 +551,33 @@ function ContainerFilterBar() {
 					<XIcon className="h-4 w-4" />
 				</Button>
 			)}
-		</div>
+		</>
+	)
+}
+
+function SelectAvgMax({
+	store,
+}: {
+	store: [boolean, React.Dispatch<React.SetStateAction<boolean>>]
+}) {
+	const [max, setMax] = store
+	const Icon = max ? ChartMax : ChartAverage
+
+	return (
+		<Select value={max ? 'max' : 'avg'} onValueChange={(e) => setMax(e === 'max')}>
+			<SelectTrigger className="relative pl-10 pr-5">
+				<Icon className="h-4 w-4 absolute left-4 top-1/2 -translate-y-1/2 opacity-85" />
+				<SelectValue />
+			</SelectTrigger>
+			<SelectContent>
+				<SelectItem key="avg" value="avg">
+					Average
+				</SelectItem>
+				<SelectItem key="max" value="max">
+					Max 1 min
+				</SelectItem>
+			</SelectContent>
+		</Select>
 	)
 }

@@ -476,31 +586,34 @@ function ChartCard({
 	description,
 	children,
 	grid,
-	isContainerChart,
+	cornerEl,
 }: {
 	title: string
 	description: string
 	children: React.ReactNode
 	grid?: boolean
-	isContainerChart?: boolean
+	cornerEl?: JSX.Element | null
 }) {
-	const target = useRef<HTMLDivElement>(null)
-	const [isInViewport, wrappedTargetRef] = useClampedIsInViewport({ target: target })
+	const { isIntersecting, ref } = useIntersectionObserver()

 	return (
 		<Card
 			className={cn('pb-2 sm:pb-4 odd:last-of-type:col-span-full', { 'col-span-full': !grid })}
-			ref={wrappedTargetRef}
+			ref={ref}
 		>
 			<CardHeader className="pb-5 pt-4 relative space-y-1 max-sm:py-3 max-sm:px-4">
 				<CardTitle className="text-xl sm:text-2xl">{title}</CardTitle>
 				<CardDescription>{description}</CardDescription>
-				{isContainerChart && <ContainerFilterBar />}
+				{cornerEl && (
+					<div className="relative py-1 block sm:w-44 sm:absolute sm:top-2.5 sm:right-3.5">
+						{cornerEl}
+					</div>
+				)}
 			</CardHeader>
-			<CardContent className="pl-0 w-[calc(100%-1.6em)] h-52 relative">
+			<div className="pl-0 w-[calc(100%-1.6em)] h-52 relative">
 				{<Spinner />}
-				{isInViewport && <Suspense>{children}</Suspense>}
-			</CardContent>
+				{isIntersecting && <Suspense>{children}</Suspense>}
+			</div>
 		</Card>
 	)
 }
--- a/beszel/site/src/components/systems-table/systems-table.tsx
+++ b/beszel/site/src/components/systems-table/systems-table.tsx
@@ -44,30 +44,31 @@ import {

 import { SystemRecord } from '@/types'
 import {
-	MoreHorizontal,
-	ArrowUpDown,
-	Server,
-	Cpu,
-	MemoryStick,
-	HardDrive,
+	MoreHorizontalIcon,
+	ArrowUpDownIcon,
+	MemoryStickIcon,
 	CopyIcon,
 	PauseCircleIcon,
 	PlayCircleIcon,
 	Trash2Icon,
 	WifiIcon,
+	HardDriveIcon,
+	ServerIcon,
+	CpuIcon,
 } from 'lucide-react'
 import { useEffect, useMemo, useState } from 'react'
 import { $hubVersion, $systems, pb } from '@/lib/stores'
 import { useStore } from '@nanostores/react'
-import { cn, copyToClipboard, isReadOnlyUser } from '@/lib/utils'
+import { cn, copyToClipboard, decimalString, isReadOnlyUser } from '@/lib/utils'
 import AlertsButton from '../table-alerts'
 import { navigate } from '../router'
+import { EthernetIcon } from '../ui/icons'

 function CellFormatter(info: CellContext<SystemRecord, unknown>) {
 	const val = info.getValue() as number
 	return (
 		<div className="flex gap-1 items-center tabular-nums tracking-tight">
-			<span className="min-w-[3.5em]">{val.toFixed(1)}%</span>
+			<span className="min-w-[3.5em]">{decimalString(val, 1)}%</span>
 			<span className="grow min-w-10 block bg-muted h-[1em] relative rounded-sm overflow-hidden">
 				<span
 					className={cn(
@@ -95,7 +96,7 @@ function sortableHeader(
 		>
 			<Icon className="mr-2 h-4 w-4" />
 			{name}
-			{!hideSortIcon && <ArrowUpDown className="ml-2 h-4 w-4" />}
+			{!hideSortIcon && <ArrowUpDownIcon className="ml-2 h-4 w-4" />}
 		</Button>
 	)
 }
@@ -112,7 +113,7 @@ export default function SystemsTable({ filter }: { filter?: string }) {
 		}
 	}, [filter])

-	const columns: ColumnDef<SystemRecord>[] = useMemo(() => {
+	const columns = useMemo(() => {
 		return [
 			{
 				// size: 200,
@@ -144,26 +145,46 @@ export default function SystemsTable({ filter }: { filter?: string }) {
 						</span>
 					)
 				},
-				header: ({ column }) => sortableHeader(column, 'System', Server),
+				header: ({ column }) => sortableHeader(column, 'System', ServerIcon),
 			},
 			{
 				accessorKey: 'info.cpu',
+				invertSorting: true,
 				cell: CellFormatter,
-				header: ({ column }) => sortableHeader(column, 'CPU', Cpu),
+				header: ({ column }) => sortableHeader(column, 'CPU', CpuIcon),
 			},
 			{
 				accessorKey: 'info.mp',
+				invertSorting: true,
 				cell: CellFormatter,
-				header: ({ column }) => sortableHeader(column, 'Memory', MemoryStick),
+				header: ({ column }) => sortableHeader(column, 'Memory', MemoryStickIcon),
 			},
 			{
 				accessorKey: 'info.dp',
+				invertSorting: true,
 				cell: CellFormatter,
-				header: ({ column }) => sortableHeader(column, 'Disk', HardDrive),
+				header: ({ column }) => sortableHeader(column, 'Disk', HardDriveIcon),
+			},
+			{
+				accessorFn: (originalRow) => originalRow.info.b || 0,
+				id: 'n',
+				invertSorting: true,
+				size: 115,
+				header: ({ column }) => sortableHeader(column, 'Net', EthernetIcon),
+				cell: (info) => {
+					const val = info.getValue() as number
+					return (
+						<span className="tabular-nums whitespace-nowrap pl-1">
+							{decimalString(val, val >= 100 ? 1 : 2)} MB/s
+						</span>
+					)
+				},
 			},
 			{
 				accessorKey: 'info.v',
+				invertSorting: true,
 				size: 50,
+				header: ({ column }) => sortableHeader(column, 'Agent', WifiIcon, true),
 				cell: (info) => {
 					const version = info.getValue() as string
 					if (!version || !hubVersion) {
@@ -182,7 +203,6 @@ export default function SystemsTable({ filter }: { filter?: string }) {
 						</span>
 					)
 				},
-				header: ({ column }) => sortableHeader(column, 'Agent', WifiIcon, true),
 			},
 			{
 				id: 'actions',
@@ -198,7 +218,7 @@ export default function SystemsTable({ filter }: { filter?: string }) {
 									<DropdownMenuTrigger asChild>
 										<Button variant="ghost" size={'icon'} data-nolink>
 											<span className="sr-only">Open menu</span>
-											<MoreHorizontal className="w-5" />
+											<MoreHorizontalIcon className="w-5" />
 										</Button>
 									</DropdownMenuTrigger>
 									<DropdownMenuContent align="end">
@@ -259,7 +279,7 @@ export default function SystemsTable({ filter }: { filter?: string }) {
 					)
 				},
 			},
-		]
+		] as ColumnDef<SystemRecord>[]
 	}, [hubVersion])

 	const table = useReactTable({
--- a/beszel/site/src/components/table-alerts.tsx
+++ b/beszel/site/src/components/table-alerts.tsx
@@ -8,8 +8,8 @@ import {
 	DialogHeader,
 	DialogTitle,
 } from '@/components/ui/dialog'
-import { BellIcon } from 'lucide-react'
-import { cn } from '@/lib/utils'
+import { BellIcon, ServerIcon } from 'lucide-react'
+import { alertInfo, cn } from '@/lib/utils'
 import { Button } from '@/components/ui/button'
 import { Switch } from '@/components/ui/switch'
 import { AlertRecord, SystemRecord } from '@/types'
@@ -28,19 +28,22 @@ const failedUpdateToast = () =>

 export default function AlertsButton({ system }: { system: SystemRecord }) {
 	const alerts = useStore($alerts)
+	const [opened, setOpened] = useState(false)

-	const active = useMemo(() => {
-		return alerts.find((alert) => alert.system === system.id)
-	}, [alerts, system])
+	const systemAlerts = alerts.filter((alert) => alert.system === system.id) as AlertRecord[]

-	const systemAlerts = useMemo(() => {
-		return alerts.filter((alert) => alert.system === system.id) as AlertRecord[]
-	}, [alerts, system])
+	const active = systemAlerts.length > 0

 	return (
 		<Dialog>
 			<DialogTrigger asChild>
-				<Button variant="ghost" size={'icon'} aria-label="Alerts" data-nolink>
+				<Button
+					variant="ghost"
+					size={'icon'}
+					aria-label="Alerts"
+					data-nolink
+					onClick={() => setOpened(true)}
+				>
 					<BellIcon
 						className={cn('h-[1.2em] w-[1.2em] pointer-events-none', {
 							'fill-foreground': active,
@@ -48,41 +51,42 @@ export default function AlertsButton({ system }: { system: SystemRecord }) {
 					/>
 				</Button>
 			</DialogTrigger>
-			<DialogContent className="max-h-full overflow-auto">
-				<DialogHeader>
-					<DialogTitle className="text-xl">{system.name} alerts</DialogTitle>
-					<DialogDescription className="mb-1">
-						See{' '}
-						<Link href="/settings/notifications" className="link">
-							notification settings
-						</Link>{' '}
-						to configure how you receive alerts.
-					</DialogDescription>
-				</DialogHeader>
-				<div className="grid gap-3">
-					<AlertStatus system={system} alerts={systemAlerts} />
-					<AlertWithSlider
-						system={system}
-						alerts={systemAlerts}
-						name="CPU"
-						title="CPU Usage"
-						description="Triggers when CPU usage exceeds a threshold."
-					/>
-					<AlertWithSlider
-						system={system}
-						alerts={systemAlerts}
-						name="Memory"
-						title="Memory Usage"
-						description="Triggers when memory usage exceeds a threshold."
-					/>
-					<AlertWithSlider
-						system={system}
-						alerts={systemAlerts}
-						name="Disk"
-						title="Disk Usage"
-						description="Triggers when root usage exceeds a threshold."
-					/>
-				</div>
+			<DialogContent
+				className="max-h-full overflow-auto max-w-[35rem]"
+				// onCloseAutoFocus={() => setOpened(false)}
+			>
+				{opened && (
+					<>
+						<DialogHeader>
+							<DialogTitle className="text-xl">{system.name} alerts</DialogTitle>
+							<DialogDescription className="mb-1">
+								See{' '}
+								<Link href="/settings/notifications" className="link">
+									notification settings
+								</Link>{' '}
+								to configure how you receive alerts.
+							</DialogDescription>
+						</DialogHeader>
+						<div className="grid gap-3">
+							<AlertStatus system={system} alerts={systemAlerts} />
+							{Object.keys(alertInfo).map((key) => {
+								const alert = alertInfo[key as keyof typeof alertInfo]
+								return (
+									<AlertWithSlider
+										key={key}
+										system={system}
+										alerts={systemAlerts}
+										name={key}
+										title={alert.name}
+										description={alert.desc}
+										unit={alert.unit}
+										Icon={alert.icon}
+									/>
+								)
+							})}
+						</div>
+					</>
+				)}
 			</DialogContent>
 		</Dialog>
 	)
@@ -91,18 +95,18 @@ export default function AlertsButton({ system }: { system: SystemRecord }) {
 function AlertStatus({ system, alerts }: { system: SystemRecord; alerts: AlertRecord[] }) {
 	const [pendingChange, setPendingChange] = useState(false)

-	const alert = useMemo(() => {
-		return alerts.find((alert) => alert.name === 'Status')
-	}, [alerts])
+	const alert = alerts.find((alert) => alert.name === 'Status')

 	return (
 		<label
 			htmlFor="alert-status"
-			className="flex flex-row items-center justify-between gap-4 rounded-lg border p-4 cursor-pointer"
+			className="flex flex-row items-center justify-between gap-4 rounded-lg border border-muted-foreground/15 hover:border-muted-foreground/20 transition-colors duration-100 p-4 cursor-pointer"
 		>
 			<div className="grid gap-1 select-none">
-				<p className="font-semibold">System Status</p>
-				<span className="block text-sm text-foreground opacity-80">
+				<p className="font-semibold flex gap-3 items-center">
+					<ServerIcon className="h-4 w-4 opacity-85" /> System status
+				</p>
+				<span className="block text-sm text-muted-foreground">
 					Triggers when status switches between up and down.
 				</span>
 			</div>
@@ -143,38 +147,50 @@ function AlertWithSlider({
 	name,
 	title,
 	description,
+	unit = '%',
+	max = 99,
+	Icon,
 }: {
 	system: SystemRecord
 	alerts: AlertRecord[]
 	name: string
 	title: string
 	description: string
+	unit?: string
+	max?: number
+	Icon: React.FC<React.SVGProps<SVGSVGElement>>
 }) {
 	const [pendingChange, setPendingChange] = useState(false)
-	const [liveValue, setLiveValue] = useState(50)
+	const [liveValue, setLiveValue] = useState(80)
+	const [liveMinutes, setLiveMinutes] = useState(10)
+
+	const key = name.replaceAll(' ', '-')

 	const alert = useMemo(() => {
 		const alert = alerts.find((alert) => alert.name === name)
 		if (alert) {
 			setLiveValue(alert.value)
+			setLiveMinutes(alert.min || 1)
 		}
 		return alert
 	}, [alerts])

 	return (
-		<div className="rounded-lg border">
+		<div className="rounded-lg border border-muted-foreground/15 hover:border-muted-foreground/20 transition-colors duration-100 group">
 			<label
-				htmlFor={`alert-${name}`}
+				htmlFor={`s${key}`}
 				className={cn('flex flex-row items-center justify-between gap-4 cursor-pointer p-4', {
 					'pb-0': !!alert,
 				})}
 			>
 				<div className="grid gap-1 select-none">
-					<p className="font-semibold">{title}</p>
-					<span className="block text-sm text-foreground opacity-80">{description}</span>
+					<p className="font-semibold flex gap-3 items-center">
+						<Icon className="h-4 w-4 opacity-85" /> {title}
+					</p>
+					{!alert && <span className="block text-sm text-muted-foreground">{description}</span>}
 				</div>
 				<Switch
-					id={`alert-${name}`}
+					id={`s${key}`}
 					className={cn('transition-opacity', pendingChange && 'opacity-40')}
 					checked={!!alert}
 					value={!!alert ? 'on' : 'off'}
@@ -192,6 +208,7 @@ function AlertWithSlider({
 									user: pb.authStore.model!.id,
 									name,
 									value: liveValue,
+									min: liveMinutes,
 								})
 							}
 						} catch (e) {
@@ -203,24 +220,52 @@ function AlertWithSlider({
 				/>
 			</label>
 			{alert && (
-				<div className="flex mt-2 mb-3 gap-3 px-4">
-					<Suspense>
-						<Slider
-							defaultValue={[liveValue]}
-							onValueCommit={(val) => {
-								pb.collection('alerts').update(alert.id, {
-									value: val[0],
-								})
-							}}
-							onValueChange={(val) => {
-								setLiveValue(val[0])
-							}}
-							min={10}
-							max={99}
-							// step={1}
-						/>
+				<div className="grid sm:grid-cols-2 mt-1.5 gap-5 px-4 pb-5 tabular-nums text-muted-foreground">
+					<Suspense fallback={<div className="h-10" />}>
+						<div>
+							<p id={`v${key}`} className="text-sm block h-8">
+								Average exceeds{' '}
+								<strong className="text-foreground">
+									{liveValue}
+									{unit}
+								</strong>
+							</p>
+							<div className="flex gap-3">
+								<Slider
+									aria-labelledby={`v${key}`}
+									defaultValue={[liveValue]}
+									onValueCommit={(val) => {
+										pb.collection('alerts').update(alert.id, {
+											value: val[0],
+										})
+									}}
+									onValueChange={(val) => setLiveValue(val[0])}
+									min={1}
+									max={max}
+								/>
+							</div>
+						</div>
+						<div>
+							<p id={`t${key}`} className="text-sm block h-8">
+								For <strong className="text-foreground">{liveMinutes}</strong> minute
+								{liveMinutes > 1 && 's'}
+							</p>
+							<div className="flex gap-3">
+								<Slider
+									aria-labelledby={`v${key}`}
+									defaultValue={[liveMinutes]}
+									onValueCommit={(val) => {
+										pb.collection('alerts').update(alert.id, {
+											min: val[0],
+										})
+									}}
+									onValueChange={(val) => setLiveMinutes(val[0])}
+									min={1}
+									max={60}
+								/>
+							</div>
+						</div>
 					</Suspense>
-					<span className="tabular-nums tracking-tighter text-[.92em]">{liveValue}%</span>
 				</div>
 			)}
 		</div>
--- a/beszel/site/src/components/ui/alert.tsx
+++ b/beszel/site/src/components/ui/alert.tsx
@@ -0,0 +1,59 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const alertVariants = cva(
+  "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        destructive:
+          "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+const Alert = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
+>(({ className, variant, ...props }, ref) => (
+  <div
+    ref={ref}
+    role="alert"
+    className={cn(alertVariants({ variant }), className)}
+    {...props}
+  />
+))
+Alert.displayName = "Alert"
+
+const AlertTitle = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
+>(({ className, ...props }, ref) => (
+  <h5
+    ref={ref}
+    className={cn("mb-1 font-medium leading-none tracking-tight", className)}
+    {...props}
+  />
+))
+AlertTitle.displayName = "AlertTitle"
+
+const AlertDescription = React.forwardRef<
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("text-sm [&_p]:leading-relaxed", className)}
+    {...props}
+  />
+))
+AlertDescription.displayName = "AlertDescription"
+
+export { Alert, AlertTitle, AlertDescription }
--- a/beszel/site/src/components/ui/chart.tsx
+++ b/beszel/site/src/components/ui/chart.tsx
@@ -16,77 +16,77 @@ export type ChartConfig = {
 	)
 }

-type ChartContextProps = {
-	config: ChartConfig
-}
+// type ChartContextProps = {
+// 	config: ChartConfig
+// }

-const ChartContext = React.createContext<ChartContextProps | null>(null)
+// const ChartContext = React.createContext<ChartContextProps | null>(null)

-function useChart() {
-	const context = React.useContext(ChartContext)
+// function useChart() {
+// 	const context = React.useContext(ChartContext)

-	if (!context) {
-		throw new Error('useChart must be used within a <ChartContainer />')
-	}
+// 	if (!context) {
+// 		throw new Error('useChart must be used within a <ChartContainer />')
+// 	}

-	return context
-}
+// 	return context
+// }

 const ChartContainer = React.forwardRef<
 	HTMLDivElement,
 	React.ComponentProps<'div'> & {
-		config: ChartConfig
+		// config: ChartConfig
 		children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children']
 	}
->(({ id, className, children, config, ...props }, ref) => {
+>(({ id, className, children, ...props }, ref) => {
 	const uniqueId = React.useId()
 	const chartId = `chart-${id || uniqueId.replace(/:/g, '')}`

 	return (
-		<ChartContext.Provider value={{ config }}>
-			<div
-				data-chart={chartId}
-				ref={ref}
-				className={cn(
-					"flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line-line]:stroke-border [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
-					className
-				)}
-				{...props}
-			>
-				<ChartStyle id={chartId} config={config} />
-				<RechartsPrimitive.ResponsiveContainer>{children}</RechartsPrimitive.ResponsiveContainer>
-			</div>
-		</ChartContext.Provider>
+		//<ChartContext.Provider value={{ config }}>
+		<div
+			data-chart={chartId}
+			ref={ref}
+			className={cn(
+				"text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line-line]:stroke-border [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
+				className
+			)}
+			{...props}
+		>
+			{/* <ChartStyle id={chartId} config={config} /> */}
+			<RechartsPrimitive.ResponsiveContainer>{children}</RechartsPrimitive.ResponsiveContainer>
+		</div>
+		//</ChartContext.Provider>
 	)
 })
 ChartContainer.displayName = 'Chart'

-const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
-	const colorConfig = Object.entries(config).filter(([_, config]) => config.theme || config.color)
+// const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
+// 	const colorConfig = Object.entries(config).filter(([_, config]) => config.theme || config.color)

-	if (!colorConfig.length) {
-		return null
-	}
+// 	if (!colorConfig.length) {
+// 		return null
+// 	}

-	return (
-		<style
-			dangerouslySetInnerHTML={{
-				__html: Object.entries(THEMES).map(
-					([theme, prefix]) => `
-${prefix} [data-chart=${id}] {
-${colorConfig
-	.map(([key, itemConfig]) => {
-		const color = itemConfig.theme?.[theme as keyof typeof itemConfig.theme] || itemConfig.color
-		return color ? `  --color-${key}: ${color};` : null
-	})
-	.join('\n')}
-}
-`
-				),
-			}}
-		/>
-	)
-}
+// 	return (
+// 		<style
+// 			dangerouslySetInnerHTML={{
+// 				__html: Object.entries(THEMES).map(
+// 					([theme, prefix]) => `
+// ${prefix} [data-chart=${id}] {
+// ${colorConfig
+// 	.map(([key, itemConfig]) => {
+// 		const color = itemConfig.theme?.[theme as keyof typeof itemConfig.theme] || itemConfig.color
+// 		return color ? `  --color-${key}: ${color};` : null
+// 	})
+// 	.join('\n')}
+// }
+// `
+// 				),
+// 			}}
+// 		/>
+// 	)
+// }

 const ChartTooltip = RechartsPrimitive.Tooltip

@@ -95,7 +95,6 @@ const ChartTooltipContent = React.forwardRef<
 	React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
 		React.ComponentProps<'div'> & {
 			hideLabel?: boolean
-			hideIndicator?: boolean
 			indicator?: 'line' | 'dot' | 'dashed'
 			nameKey?: string
 			labelKey?: string
@@ -109,9 +108,8 @@ const ChartTooltipContent = React.forwardRef<
 			active,
 			payload,
 			className,
-			indicator = 'dot',
+			indicator = 'line',
 			hideLabel = false,
-			hideIndicator = false,
 			label,
 			labelFormatter,
 			labelClassName,
@@ -126,7 +124,8 @@ const ChartTooltipContent = React.forwardRef<
 		},
 		ref
 	) => {
-		const { config } = useChart()
+		// const { config } = useChart()
+		const config = {}

 		React.useMemo(() => {
 			if (filter) {
@@ -144,12 +143,9 @@ const ChartTooltipContent = React.forwardRef<
 			}

 			const [item] = payload
-			const key = `${labelKey || item.dataKey || item.name || 'value'}`
+			const key = `${labelKey || item.name || 'value'}`
 			const itemConfig = getPayloadConfigFromPayload(config, item, key)
-			const value =
-				!labelKey && typeof label === 'string'
-					? config[label as keyof typeof config]?.label || label
-					: itemConfig?.label
+			const value = !labelKey && typeof label === 'string' ? label : itemConfig?.label

 			if (labelFormatter) {
 				return (
@@ -168,7 +164,8 @@ const ChartTooltipContent = React.forwardRef<
 			return null
 		}

-		const nestLabel = payload.length === 1 && indicator !== 'dot'
+		// const nestLabel = payload.length === 1 && indicator !== 'dot'
+		const nestLabel = false

 		return (
 			<div
@@ -200,26 +197,24 @@ const ChartTooltipContent = React.forwardRef<
 										{itemConfig?.icon ? (
 											<itemConfig.icon />
 										) : (
-											!hideIndicator && (
-												<div
-													className={cn(
-														'shrink-0 rounded-[2px] border-[--color-border] bg-[--color-bg]',
-														{
-															'h-2.5 w-2.5': indicator === 'dot',
-															'w-1': indicator === 'line',
-															'w-0 border-[1.5px] border-dashed bg-transparent':
-																indicator === 'dashed',
-															'my-0.5': nestLabel && indicator === 'dashed',
-														}
-													)}
-													style={
-														{
-															'--color-bg': indicatorColor,
-															'--color-border': indicatorColor,
-														} as React.CSSProperties
+											<div
+												className={cn(
+													'shrink-0 rounded-[2px] border-[--color-border] bg-[--color-bg]',
+													{
+														'h-2.5 w-2.5': indicator === 'dot',
+														'w-1': indicator === 'line',
+														'w-0 border-[1.5px] border-dashed bg-transparent':
+															indicator === 'dashed',
+														'my-0.5': nestLabel && indicator === 'dashed',
 													}
-												/>
-											)
+												)}
+												style={
+													{
+														'--color-bg': indicatorColor,
+														'--color-border': indicatorColor,
+													} as React.CSSProperties
+												}
+											/>
 										)}
 										<div
 											className={cn(
@@ -262,7 +257,7 @@ const ChartLegendContent = React.forwardRef<
 			hideIcon?: boolean
 			nameKey?: string
 		}
->(({ className, hideIcon = false, payload, verticalAlign = 'bottom', nameKey }, ref) => {
+>(({ className, payload, verticalAlign = 'bottom' }, ref) => {
 	// const { config } = useChart()

 	if (!payload?.length) {
@@ -342,5 +337,5 @@ export {
 	ChartTooltipContent,
 	ChartLegend,
 	ChartLegendContent,
-	ChartStyle,
+	// ChartStyle,
 }
--- a/beszel/site/src/components/ui/icons.tsx
+++ b/beszel/site/src/components/ui/icons.tsx
@@ -0,0 +1,72 @@
+import { SVGProps } from 'react'
+
+// linux-logo-bold from https://github.com/phosphor-icons/core (MIT license)
+export function TuxIcon(props: SVGProps<SVGSVGElement>) {
+	return (
+		<svg viewBox="0 0 256 256" {...props}>
+			<path
+				fill="currentColor"
+				d="M231 217a12 12 0 0 1-16-2c-2-1-35-44-35-127a52 52 0 1 0-104 0c0 83-33 126-35 127a12 12 0 0 1-18-14c0-1 29-39 29-113a76 76 0 1 1 152 0c0 74 29 112 29 113a12 12 0 0 1-2 16m-127-97a16 16 0 1 0-16-16 16 16 0 0 0 16 16m64-16a16 16 0 1 0-16 16 16 16 0 0 0 16-16m-73 51 28 12a12 12 0 0 0 10 0l28-12a12 12 0 0 0-10-22l-23 10-23-10a12 12 0 0 0-10 22m33 29a57 57 0 0 0-39 15 12 12 0 0 0 17 18 33 33 0 0 1 44 0 12 12 0 1 0 17-18 57 57 0 0 0-39-15"
+			/>
+		</svg>
+	)
+}
+
+// MingCute Apache License 2.0 https://github.com/Richard9394/MingCute
+export function Rows(props: SVGProps<SVGSVGElement>) {
+	return (
+		<svg viewBox="0 0 24 24" {...props}>
+			<path
+				fill="currentColor"
+				d="M5 3a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2zm0 2h14v4H5zm0 8a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2zm0 2h14v4H5z"
+			/>
+		</svg>
+	)
+}
+
+// IconPark Apache License 2.0 https://github.com/bytedance/IconPark
+export function ChartAverage(props: SVGProps<SVGSVGElement>) {
+	return (
+		<svg fill="none" viewBox="0 0 48 48" stroke="currentColor" {...props}>
+			<path strokeWidth="3" d="M4 4v40h40" />
+			<path strokeWidth="3" d="M10 38S15.3 4 27 4s17 34 17 34" />
+			<path strokeWidth="4" d="M10 24h34" />
+		</svg>
+	)
+}
+
+// IconPark Apache License 2.0 https://github.com/bytedance/IconPark
+export function ChartMax(props: SVGProps<SVGSVGElement>) {
+	return (
+		<svg fill="none" viewBox="0 0 48 48" stroke="currentColor" {...props}>
+			<path strokeWidth="3" d="M4 4v40h40" />
+			<path strokeWidth="3" d="M10 38S15.3 4 27 4s17 34 17 34" />
+			<path strokeWidth="4" d="M10 4h34" />
+		</svg>
+	)
+}
+
+// Lucide https://github.com/lucide-icons/lucide (not in package for some reason)
+export function EthernetIcon(props: SVGProps<SVGSVGElement>) {
+	return (
+		<svg
+			fill="none"
+			stroke="currentColor"
+			strokeLinecap="round"
+			strokeWidth="2"
+			viewBox="0 0 24 24"
+			{...props}
+		>
+			<path d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3zM6 8v1m4-1v1m4-1v1m4-1v1" />
+		</svg>
+	)
+}
+
+// Phosphor MIT https://github.com/phosphor-icons/core
+export function ThermometerIcon(props: SVGProps<SVGSVGElement>) {
+	return (
+		<svg viewBox="0 0 256 256" {...props} fill="currentColor">
+			<path d="M212 56a28 28 0 1 0 28 28 28 28 0 0 0-28-28m0 40a12 12 0 1 1 12-12 12 12 0 0 1-12 12m-60 50V40a32 32 0 0 0-64 0v106a56 56 0 1 0 64 0m-16-42h-32V40a16 16 0 0 1 32 0Z" />
+		</svg>
+	)
+}
--- a/beszel/site/src/lib/use-intersection-observer.ts
+++ b/beszel/site/src/lib/use-intersection-observer.ts
@@ -0,0 +1,169 @@
+import { useEffect, useRef, useState } from 'react'
+
+// adapted from usehooks-ts/use-intersection-observer
+
+/** The hook internal state. */
+type State = {
+	/** A boolean indicating if the element is intersecting. */
+	isIntersecting: boolean
+	/** The intersection observer entry. */
+	entry?: IntersectionObserverEntry
+}
+
+/** Represents the options for configuring the Intersection Observer. */
+type UseIntersectionObserverOptions = {
+	/**
+	 * The element that is used as the viewport for checking visibility of the target.
+	 * @default null
+	 */
+	root?: Element | Document | null
+	/**
+	 * A margin around the root.
+	 * @default '0%'
+	 */
+	rootMargin?: string
+	/**
+	 * A threshold indicating the percentage of the target's visibility needed to trigger the callback.
+	 * @default 0
+	 */
+	threshold?: number | number[]
+	/**
+	 * If true, freezes the intersection state once the element becomes visible.
+	 * @default true
+	 */
+	freeze?: boolean
+	/**
+	 * A callback function to be invoked when the intersection state changes.
+	 * @param {boolean} isIntersecting - A boolean indicating if the element is intersecting.
+	 * @param {IntersectionObserverEntry} entry - The intersection observer Entry.
+	 * @default undefined
+	 */
+	onChange?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void
+	/**
+	 * The initial state of the intersection.
+	 * @default false
+	 */
+	initialIsIntersecting?: boolean
+}
+
+/**
+ * The return type of the useIntersectionObserver hook.
+ *
+ * Supports both tuple and object destructing.
+ * @param {(node: Element | null) => void} ref - The ref callback function.
+ * @param {boolean} isIntersecting - A boolean indicating if the element is intersecting.
+ * @param {IntersectionObserverEntry | undefined} entry - The intersection observer Entry.
+ */
+type IntersectionReturn = {
+	ref: (node?: Element | null) => void
+	isIntersecting: boolean
+	entry?: IntersectionObserverEntry
+}
+
+/**
+ * Custom hook that tracks the intersection of a DOM element with its containing element or the viewport using the [`Intersection Observer API`](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API).
+ * @param {UseIntersectionObserverOptions} options - The options for the Intersection Observer.
+ * @returns {IntersectionReturn} The ref callback, a boolean indicating if the element is intersecting, and the intersection observer entry.
+ * @example
+ * ```tsx
+ * const { ref, isIntersecting, entry } = useIntersectionObserver({ threshold: 0.5 });
+ * ```
+ */
+export function useIntersectionObserver({
+	threshold = 0,
+	root = null,
+	rootMargin = '0%',
+	freeze = true,
+	initialIsIntersecting = false,
+	onChange,
+}: UseIntersectionObserverOptions = {}): IntersectionReturn {
+	const [ref, setRef] = useState<Element | null>(null)
+
+	const [state, setState] = useState<State>(() => ({
+		isIntersecting: initialIsIntersecting,
+		entry: undefined,
+	}))
+
+	const callbackRef = useRef<UseIntersectionObserverOptions['onChange']>()
+
+	callbackRef.current = onChange
+
+	const frozen = state.entry?.isIntersecting && freeze
+
+	useEffect(() => {
+		// Ensure we have a ref to observe
+		if (!ref) return
+
+		// Ensure the browser supports the Intersection Observer API
+		if (!('IntersectionObserver' in window)) return
+
+		// Skip if frozen
+		if (frozen) return
+
+		let unobserve: (() => void) | undefined
+
+		const observer = new IntersectionObserver(
+			(entries: IntersectionObserverEntry[]): void => {
+				const thresholds = Array.isArray(observer.thresholds)
+					? observer.thresholds
+					: [observer.thresholds]
+
+				entries.forEach((entry) => {
+					const isIntersecting =
+						entry.isIntersecting &&
+						thresholds.some((threshold) => entry.intersectionRatio >= threshold)
+
+					setState({ isIntersecting, entry })
+
+					if (callbackRef.current) {
+						callbackRef.current(isIntersecting, entry)
+					}
+
+					if (isIntersecting && freeze && unobserve) {
+						unobserve()
+						unobserve = undefined
+					}
+				})
+			},
+			{ threshold, root, rootMargin }
+		)
+
+		observer.observe(ref)
+
+		return () => {
+			observer.disconnect()
+		}
+
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+	}, [
+		ref,
+		// eslint-disable-next-line react-hooks/exhaustive-deps
+		JSON.stringify(threshold),
+		root,
+		rootMargin,
+		frozen,
+		freeze,
+	])
+
+	// ensures that if the observed element changes, the intersection observer is reinitialized
+	const prevRef = useRef<Element | null>(null)
+
+	useEffect(() => {
+		if (
+			!ref &&
+			state.entry?.target &&
+			!freeze &&
+			!frozen &&
+			prevRef.current !== state.entry.target
+		) {
+			prevRef.current = state.entry.target
+			setState({ isIntersecting: initialIsIntersecting, entry: undefined })
+		}
+	}, [ref, state.entry, freeze, frozen, initialIsIntersecting])
+
+	return {
+		ref: setRef,
+		isIntersecting: !!state.isIntersecting,
+		entry: state.entry,
+	} as IntersectionReturn
+}
--- a/beszel/site/src/lib/utils.ts
+++ b/beszel/site/src/lib/utils.ts
@@ -7,11 +7,13 @@ import { RecordModel, RecordSubscription } from 'pocketbase'
 import { WritableAtom } from 'nanostores'
 import { timeDay, timeHour } from 'd3-time'
 import { useEffect, useState } from 'react'
-import useIsInViewport, { CallbackRef, HookOptions } from 'use-is-in-viewport'
+import { CpuIcon, HardDriveIcon, MemoryStickIcon } from 'lucide-react'
+import { EthernetIcon, ThermometerIcon } from '@/components/ui/icons'

 export function cn(...inputs: ClassValue[]) {
 	return twMerge(clsx(inputs))
 }
+// export const cn = clsx

 export async function copyToClipboard(content: string) {
 	const duration = 1500
@@ -40,23 +42,19 @@ const verifyAuth = () => {
 }

 export const updateSystemList = async () => {
-	// try {
-	const records = await pb.collection<SystemRecord>('systems').getFullList({ sort: '+name' })
+	const records = await pb
+		.collection<SystemRecord>('systems')
+		.getFullList({ sort: '+name', fields: 'id,name,host,info,status' })
 	if (records.length) {
 		$systems.set(records)
 	} else {
 		verifyAuth()
 	}
-	// }
-	// catch (e) {
-	// 	console.log('verifying auth error', e)
-	// 	verifyAuth()
-	// }
 }

 export const updateAlerts = () => {
 	pb.collection('alerts')
-		.getFullList<AlertRecord>({ fields: 'id,name,system,value' })
+		.getFullList<AlertRecord>({ fields: 'id,name,system,value,min,triggered', sort: 'updated' })
 		.then((records) => {
 			$alerts.set(records)
 		})
@@ -141,8 +139,8 @@ export function updateRecordList<T extends RecordModel>(
 	$store.set(newRecords)
 }

-export function getPbTimestamp(timeString: ChartTimes) {
-	const d = chartTimeData[timeString].getOffset(new Date())
+export function getPbTimestamp(timeString: ChartTimes, d?: Date) {
+	d ||= chartTimeData[timeString].getOffset(new Date())
 	const year = d.getUTCFullYear()
 	const month = String(d.getUTCMonth() + 1).padStart(2, '0')
 	const day = String(d.getUTCDate()).padStart(2, '0')
@@ -182,7 +180,7 @@ export const chartTimeData: ChartTimeData = {
 		expectedInterval: 60_000 * 120,
 		label: '1 week',
 		ticks: 7,
-		format: (timestamp: string) => formatShortDate(timestamp),
+		format: (timestamp: string) => formatDay(timestamp),
 		getOffset: (endTime: Date) => timeDay.offset(endTime, -7),
 	},
 	'30d': {
@@ -209,7 +207,10 @@ export function useYAxisWidth() {
 			clearTimeout(timeout)
 			timeout = setTimeout(() => {
 				document.body.appendChild(div)
-				setYAxisWidth(div.offsetWidth + 24)
+				const width = div.offsetWidth + 24
+				if (width > yAxisWidth) {
+					setYAxisWidth(div.offsetWidth + 24)
+				}
 				document.body.removeChild(div)
 			})
 		}
@@ -218,24 +219,6 @@ export function useYAxisWidth() {
 	return { yAxisWidth, updateYAxisWidth }
 }

-export function useClampedIsInViewport(options: HookOptions): [boolean | null, CallbackRef] {
-	const [isInViewport, wrappedTargetRef] = useIsInViewport(options)
-	const [wasInViewportAtleastOnce, setWasInViewportAtleastOnce] = useState(isInViewport)
-
-	useEffect(() => {
-		setWasInViewportAtleastOnce((prev) => {
-			// this will clamp it to the first true
-			// received from useIsInViewport
-			if (!prev) {
-				return isInViewport
-			}
-			return prev
-		})
-	}, [isInViewport])
-
-	return [wasInViewportAtleastOnce, wrappedTargetRef]
-}
-
 export function toFixedWithoutTrailingZeros(num: number, digits: number) {
 	return parseFloat(num.toFixed(digits)).toString()
 }
@@ -244,17 +227,18 @@ export function toFixedFloat(num: number, digits: number) {
 	return parseFloat(num.toFixed(digits))
 }

-let twoDecimalFormatter: Intl.NumberFormat
-/** Format number to two decimal places */
-export function twoDecimalString(num: number) {
-	if (!twoDecimalFormatter) {
-		twoDecimalFormatter = new Intl.NumberFormat(undefined, {
-			minimumFractionDigits: 2,
-			maximumFractionDigits: 2,
+let decimalFormatters: Map<number, Intl.NumberFormat> = new Map()
+/** Format number to x decimal places */
+export function decimalString(num: number, digits = 2) {
+	let formatter = decimalFormatters.get(digits)
+	if (!formatter) {
+		formatter = new Intl.NumberFormat(undefined, {
+			minimumFractionDigits: digits,
+			maximumFractionDigits: digits,
 		})
+		decimalFormatters.set(digits, formatter)
 	}
-	// Return a function that formats numbers using the saved formatter
-	return twoDecimalFormatter.format(num)
+	return formatter.format(num)
 }

 /** Get value from local storage */
@@ -294,3 +278,55 @@ export async function updateUserSettings() {
 		console.log('create settings', e)
 	}
 }
+
+/**
+ * Get the value and unit of size (TB, GB, or MB) for a given size
+ * @param n size in gigabytes or megabytes
+ * @param isGigabytes boolean indicating if n represents gigabytes (true) or megabytes (false)
+ * @returns an object containing the value and unit of size
+ */
+export const getSizeAndUnit = (n: number, isGigabytes = true) => {
+	const sizeInGB = isGigabytes ? n : n / 1_000
+
+	if (sizeInGB >= 1_000) {
+		return { v: sizeInGB / 1_000, u: ' TB' }
+	} else if (sizeInGB >= 1) {
+		return { v: sizeInGB, u: ' GB' }
+	}
+	return { v: n, u: ' MB' }
+}
+
+export const chartMargin = { top: 12 }
+
+export const alertInfo = {
+	CPU: {
+		name: 'CPU usage',
+		unit: '%',
+		icon: CpuIcon,
+		desc: 'Triggers when CPU usage exceeds a threshold.',
+	},
+	Memory: {
+		name: 'Memory usage',
+		unit: '%',
+		icon: MemoryStickIcon,
+		desc: 'Triggers when memory usage exceeds a threshold.',
+	},
+	Disk: {
+		name: 'Disk usage',
+		unit: '%',
+		icon: HardDriveIcon,
+		desc: 'Triggers when usage of any disk exceeds a threshold.',
+	},
+	Bandwidth: {
+		name: 'Bandwidth',
+		unit: ' MB/s',
+		icon: EthernetIcon,
+		desc: 'Triggers when combined up/down exceeds a threshold.',
+	},
+	Temperature: {
+		name: 'Temperature',
+		unit: '°C',
+		icon: ThermometerIcon,
+		desc: 'Triggers when any sensor exceeds a threshold.',
+	},
+}
--- a/beszel/site/src/main.tsx
+++ b/beszel/site/src/main.tsx
@@ -70,9 +70,9 @@ const App = () => {
 			$hubVersion.set(data.v)
 		})
 		// get servers / alerts / settings
-		updateSystemList()
-		updateAlerts()
 		updateUserSettings()
+		// get alerts after system list is loaded
+		updateSystemList().then(updateAlerts)
 	}, [])

 	// update favicon
--- a/beszel/site/src/types.d.ts
+++ b/beszel/site/src/types.d.ts
@@ -12,10 +12,12 @@ export interface SystemRecord extends RecordModel {
 export interface SystemInfo {
 	/** hostname */
 	h: string
+	/** kernel **/
+	k?: string
 	/** cpu percent */
 	cpu: number
 	/** cpu threads */
-	t: number
+	t?: number
 	/** cpu cores */
 	c: number
 	/** cpu model */
@@ -28,11 +30,17 @@ export interface SystemInfo {
 	mp: number
 	/** disk percent */
 	dp: number
+	/** bandwidth (mb) */
+	b: number
+	/** agent version */
+	v: string
 }

 export interface SystemStats {
 	/** cpu percent */
 	cpu: number
+	/** peak cpu */
+	cpum?: number
 	/** total memory (gb) */
 	m: number
 	/** memory used (gb) */
@@ -41,6 +49,8 @@ export interface SystemStats {
 	mp: number
 	/** memory buffer + cache (gb) */
 	mb: number
+	/** zfs arc memory (gb) */
+	mz?: number
 	/** swap space (gb) */
 	s: number
 	/** swap used (gb) */
@@ -55,10 +65,18 @@ export interface SystemStats {
 	dr: number
 	/** disk write (mb) */
 	dw: number
+	/** max disk read (mb) */
+	drm?: number
+	/** max disk write (mb) */
+	dwm?: number
 	/** network sent (mb) */
 	ns: number
 	/** network received (mb) */
 	nr: number
+	/** max network sent (mb) */
+	nsm?: number
+	/** max network received (mb) */
+	nrm?: number
 	/** temperatures */
 	t?: Record<string, number>
 	/** extra filesystems */
@@ -74,6 +92,10 @@ export interface ExtraFsStats {
 	r: number
 	/** total write (mb) */
 	w: number
+	/** max read (mb) */
+	rm: number
+	/** max write (mb) */
+	wm: number
 }

 export interface ContainerStatsRecord extends RecordModel {
@@ -105,6 +127,8 @@ export interface AlertRecord extends RecordModel {
 	id: string
 	system: string
 	name: string
+	triggered: boolean
+	sysname?: string
 	// user: string
 }

@@ -127,3 +151,17 @@ export type UserSettings = {
 	emails?: string[]
 	webhooks?: string[]
 }
+
+type ChartDataContainer = {
+	created: number | null
+} & {
+	[key: string]: key extends 'created' ? never : ContainerStats
+}
+
+export interface ChartData {
+	systemStats: SystemStatsRecord[]
+	containerData: ChartDataContainer[]
+	ticks: number[]
+	domain: number[]
+	chartTime: ChartTimes
+}
--- a/beszel/version.go
+++ b/beszel/version.go
@@ -1,6 +1,6 @@
 package beszel

 const (
-	Version = "0.4.0"
+	Version = "0.6.0"
 	AppName = "beszel"
 )
--- a/readme.md
+++ b/readme.md
@@ -12,7 +12,7 @@ A lightweight server resource monitoring hub with historical data, docker stats,
 - **Lightweight**: Smaller and less resource-intensive than leading solutions.
 - **Simple**: Easy setup, no need for public internet exposure.
 - **Docker stats**: Tracks CPU, memory, and network usage history for each container.
- **Alerts**: Configurable alerts for CPU, memory, disk usage, and system status.
+- **Alerts**: Configurable alerts for CPU, memory, disk, bandwidth, temperature, and system status.
 - **Multi-user**: Each user manages their own systems. Admins can share systems across users.
 - **OAuth / OIDC**: Supports multiple OAuth2 providers. Password authentication can be disabled.
 - **Automatic backups**: Save and restore data from disk or S3-compatible storage.
@@ -98,24 +98,28 @@ Use `./beszel update` and `./beszel-agent update` to update to the latest versio

 ### Hub

-| Name                    | Default | Description                      |
-| ----------------------- | ------- | -------------------------------- |
-| `DISABLE_PASSWORD_AUTH` | false   | Disables password authentication |
+| Name                    | Default | Description                                                                                                                                 |
+| ----------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CSP`                   | unset   | Adds a [Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy) header with this value. |
+| `DISABLE_PASSWORD_AUTH` | false   | Disables password authentication.                                                                                                           |

 ### Agent

-| Name                | Default | Description                                                                              |
-| ------------------- | ------- | ---------------------------------------------------------------------------------------- |
-| `DOCKER_HOST`       | unset   | Overrides the docker host (docker.sock) if using a proxy.[^socket]                       |
-| `EXTRA_FILESYSTEMS` | unset   | See [Monitoring additional disks / partitions](#monitoring-additional-disks--partitions) |
-| `FILESYSTEM`        | unset   | Device, partition, or mount point to use for root disk stats.                            |
-| `KEY`               | unset   | Public SSH key to use for authentication. Provided in hub.                               |
-| `NICS`              | unset   | Whitelist of network interfaces to monitor for bandwidth chart.                          |
-| `PORT`              | 45876   | Port or address:port to listen on.                                                       |
-
-<!-- | `SYS_SENSORS` | unset | Overrides the sys location for sensors. | -->
+| Name                | Default | Description                                                                                                               |
+| ------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `DOCKER_HOST`       | unset   | Overrides the docker host (docker.sock) if using a proxy.[^socket]                                                        |
+| `EXTRA_FILESYSTEMS` | unset   | See [Monitoring additional disks, partitions, or remote mounts](#monitoring-additional-disks-partitions-or-remote-mounts) |
+| `FILESYSTEM`        | unset   | Device, partition, or mount point to use for root disk stats.                                                             |
+| `KEY`               | unset   | Public SSH key to use for authentication. Provided in hub.                                                                |
+| `LOG_LEVEL`         | info    | Logging level. Valid values: "debug", "info", "warn", "error".                                                            |
+| `MEM_CALC`          | unset   | Overrides the default memory calculation.[^memcalc]                                                                       |
+| `NICS`              | unset   | Whitelist of network interfaces to monitor for bandwidth chart.                                                           |
+| `PORT`              | 45876   | Port or address:port to listen on.                                                                                        |
+| `SENSORS`           | unset   | Whitelist of temperature sensors to monitor.                                                                              |
+| `SYS_SENSORS`       | unset   | Overrides sys path for sensors. See [#160](https://github.com/henrygd/beszel/discussions/160).                            |

 [^socket]: Beszel only needs access to read container information. For [linuxserver/docker-socket-proxy](https://github.com/linuxserver/docker-socket-proxy) you would set `CONTAINERS=1`.
+[^memcalc]: The default value for used memory is based on gopsutil's [Used](https://pkg.go.dev/github.com/shirou/gopsutil/v4@v4.24.6/mem#VirtualMemoryStat) calculation, which should align fairly closely with `free`. Set `MEM_CALC` to `htop` to align with htop's calculation.

 ## OAuth / OIDC Setup

@@ -151,15 +155,17 @@ Visit the "Auth providers" page to enable your provider. The redirect / callback

 </details>

-## Monitoring additional disks / partitions
+## Monitoring additional disks, partitions, or remote mounts

-You can configure the agent to monitor the usage and I/O of more than one disk or partition. The approach differs depending on the deployment method.
+The method for adding additional disks differs depending on your deployment method.

 Use `lsblk` to find the names and mount points of your partitions. If you have trouble, check the agent logs.

+> Note: The charts will use the name of the device or partition if available, and fall back to the folder name. You will not get I/O stats for network mounted drives.
+
 ### Docker

-Mount a folder from the partition's filesystem in the container's `/extra-filesystems` directory, like the example below. The charts will use the name of the device or partition, not the name of the folder.
+Mount a folder from the target filesystem in the container's `/extra-filesystems` directory. For example:

 ```yaml
 volumes:
@@ -169,10 +175,10 @@ volumes:

 ### Binary

-Set the `EXTRA_FILESYSTEMS` environment variable to a comma-separated list of devices or partitions to monitor. For example:
+Set the `EXTRA_FILESYSTEMS` environment variable to a comma-separated list of devices, partitions, or mount points to monitor. For example:

 ```bash
-EXTRA_FILESYSTEMS="sdb,sdc1,mmcblk0"
+EXTRA_FILESYSTEMS="sdb,sdc1,mmcblk0,/mnt/network-share"
 ```

 ## REST API
@@ -212,7 +218,7 @@ Assuming the agent is running, the connection is probably being blocked by a fir
 1. Add an inbound rule to the agent system's firewall(s) to allow TCP connections to the port. Check any active firewalls, like iptables, and your cloud provider's firewall settings if applicable.
 2. Alternatively, use software like [Cloudflare Tunnel](https://www.cloudflare.com/products/tunnel/), [WireGuard](https://www.wireguard.com/), or [Tailscale](https://tailscale.com/) to securely bypass your firewall.

-You can test connectivity by running telnet `<agent-ip> <port>`.
+You can test connectivity by running `telnet <agent-ip> <port>`.

 ### Connecting the hub and agent on the same system using Docker
Author	SHA1	Message	Date
Henry Dollman	ee92e338cb	update debug log locations	2024-10-16 18:12:43 -04:00
Henry Dollman	1a3ad04e03	release 0.6.0	2024-10-16 18:02:53 -04:00
Henry Dollman	9c061774a3	update alert notification titles	2024-10-16 18:02:38 -04:00
Henry Dollman	3336b0a7d9	fix chart null values connecting after downtime	2024-10-16 17:46:42 -04:00
Henry Dollman	f034eed431	update js packages	2024-10-16 17:39:56 -04:00
Henry Dollman	6b6d3fabc0	change disk alert to monitor usage of any disk, not only root	2024-10-16 17:21:05 -04:00
Henry Dollman	59d541dd1d	fix edge case overwriting extra filesystem with root io fallback	2024-10-16 15:26:12 -04:00
Henry Dollman	abff85d61e	alerts web ui refactoring	2024-10-16 13:48:36 -04:00
Henry Dollman	02641ec007	time averaged thresholds for alerts	2024-10-15 21:59:53 -04:00
Henry Dollman	92179cbbb2	show active alerts in dashboard	2024-10-15 21:59:05 -04:00
Henry Dollman	299152413a	small longer record creation refactoring	2024-10-15 19:54:46 -04:00
Henry Dollman	703a3c41c9	empty info for systems that are paused	2024-10-15 18:31:03 -04:00
Henry Dollman	31d1153916	invert sorting in systems table	2024-10-15 18:20:38 -04:00
Henry Dollman	c1577d3ba5	fix bottom spacing	2024-10-14 19:03:02 -04:00
Henry Dollman	c4400eb0a3	refactor container-chart.tsx	2024-10-14 18:48:19 -04:00
Henry Dollman	a57498f8f7	update alerts dialog and icon imports	2024-10-14 17:53:49 -04:00
Henry Dollman	1b0dffc1ab	combine docker charts and chart data	2024-10-14 17:25:21 -04:00
Henry Dollman	bea37d62b4	simplify container chart data and reduce rerenders	2024-10-14 11:48:33 -04:00
Henry Dollman	d53b6be5b9	update collections	2024-10-12 18:28:32 -04:00
Henry Dollman	6c31263e60	add bandwidth alerts	2024-10-12 17:22:25 -04:00
Henry Dollman	b464fa5b3f	add net column to systems table	2024-10-12 16:37:09 -04:00
Henry Dollman	c0a3bbeefc	change twoDecimalString to use customizable digits	2024-10-12 16:03:51 -04:00
Henry Dollman	10d348c052	temperature alerts	2024-10-12 14:57:46 -04:00
Henry Dollman	6cf6661f2e	raise docker client timeout to 8 seconds if version <= 24	2024-10-12 12:24:53 -04:00
Henry Dollman	23ab1208cd	release 0.5.3	2024-10-10 18:36:28 -04:00
Henry Dollman	5b0fac429b	move update functions to agent / hub packages	2024-10-10 18:36:01 -04:00
Henry Dollman	efca56ceca	add temp debug logs to troubleshoot #196	2024-10-10 18:28:24 -04:00
Henry Dollman	64f0a23969	move fsStats creation to NewAgent function	2024-10-10 18:18:57 -04:00
Henry Dollman	4245da7792	Add caching to the web app to reduce requests for the same data	2024-10-10 18:11:36 -04:00
Henry Dollman	cedf80a869	add max 1m values for cpu, bandwidth, disk io * removes unused things from chart.tsx * updates y axis width only if it grows * add generic area chart component and remove individual cpu, bandwidth, disk io charts	2024-10-10 15:11:48 -04:00
Henry Dollman	76cea9d3c3	increase docker client timeout to 2100ms	2024-10-08 19:17:03 -04:00
Henry Dollman	10ef430826	small refactor in CreateLongerRecords	2024-10-08 12:42:02 -04:00
Henry Dollman	d672017af0	add peak values for cpu and net	2024-10-07 19:20:53 -04:00
Henry Dollman	7a82571921	add time back to memory chart tooltip	2024-10-07 18:19:28 -04:00
Henry Dollman	e81f8ac387	add zfs arc to longer records	2024-10-07 11:45:09 -04:00
Henry Dollman	05faa88e6a	release 0.5.2	2024-10-05 18:30:10 -04:00
Henry Dollman	73aae62c2e	add ZFS ARC memory accounting	2024-10-05 18:07:42 -04:00
Henry Dollman	af4877ca30	add MEM_CALC env var	2024-10-05 15:29:27 -04:00
Henry Dollman	c407fe9af0	exclude sensor if temp <=0 \|\| temp >= 200	2024-10-05 11:14:20 -04:00
hank	13c9497951	Merge pull request #199 from Bot-wxt1221/main fix(package-lock.json): fix for nixpkgs	2024-10-04 11:06:58 -04:00
wxt	4274096645	fix(package-lock.json): fix for nixpkgs	2024-10-03 16:18:31 +08:00
Henry Dollman	a213b70a1c	release 0.5.1	2024-10-02 19:58:44 -04:00
Henry Dollman	66cc0a4b24	log stats on startup if log level is debug	2024-10-02 19:58:02 -04:00
Henry Dollman	f051f6a5f8	add dockerManager / fix for Docker 24 and older * dockerManager now handles all docker api interaction and container metrics tracking * sets unlimited concurrency for docker 24 and older	2024-10-02 19:45:26 -04:00
Henry Dollman	b9f142c28c	update go deps (gopsutil v4.24.9)	2024-10-02 19:11:13 -04:00
Henry Dollman	45e1283b83	move system.Info to Agent struct * cleaner to store entire info struct rather than separate properties for unchanging values	2024-10-02 12:34:42 -04:00
Henry Dollman	94cb5f2798	fix uptime hours pluralization	2024-10-02 12:33:31 -04:00
Henry Dollman	2883467b2b	update docker image workflow - change tag to "*v" - remove cache	2024-10-02 12:32:19 -04:00
Lindemberg Barbosa	0c77190161	fix: readme link for Monitoring additional disks, partitions, or remote mounts (#195 )	2024-10-02 10:40:12 -04:00
Henry Dollman	8d4d072343	fix readme backticks for telnet command	2024-09-30 15:45:46 -04:00
Henry Dollman	d6e0daf52a	update js deps and add package-lock.json (#192 ) - replaces use-is-in-viewport package with lib/use-intersection-observer.ts due to npm dependency conflict	2024-09-30 14:37:59 -04:00
Henry Dollman	22e9ede766	release 0.5.0	2024-09-29 16:37:09 -04:00
Henry Dollman	9ab359d3cf	add SENSORS env var	2024-09-29 16:36:32 -04:00
Henry Dollman	5447ccad47	make sure temp chart starts at 0 degrees	2024-09-29 16:33:23 -04:00
Henry Dollman	3e51d79c37	update memory chart colors	2024-09-29 15:14:55 -04:00
Henry Dollman	0996d60224	update go deps	2024-09-29 14:22:21 -04:00
Henry Dollman	7a5ec067f5	refactor records package	2024-09-29 13:36:03 -04:00
Henry Dollman	98563d643d	refactor alerts and move managers to hub struct - resource alerts called from updateSystem to avoid needing to pull from db after update	2024-09-29 13:35:38 -04:00
Henry Dollman	268e364bd4	update MemoryStats type	2024-09-29 12:36:19 -04:00
Henry Dollman	dd84a9fd35	remove semaphore and limit docker host connections to 10	2024-09-29 12:30:30 -04:00
Henry Dollman	2f4e537f72	change containerStatsMutex to a RWMutex	2024-09-28 19:13:24 -04:00
Henry Dollman	9637363cf3	combine container.Stats and container.PrevContainerStats	2024-09-28 18:51:46 -04:00
Henry Dollman	73d0dd25ec	agent refactoring - create agent/docker.go, agent/system.go	2024-09-28 17:49:04 -04:00
Henry Dollman	2ecf5572ba	remove addr, pubKey fields from agent struct	2024-09-28 16:48:55 -04:00
Henry Dollman	5e97167ee0	Fetch kernel, hostname, cpu at start rather than every run	2024-09-28 16:38:52 -04:00
Henry Dollman	1a4862ecd9	remove containerStats mutex and add stats by index	2024-09-27 19:06:37 -04:00
Henry Dollman	6235d15fa2	tweak colors in memory chart	2024-09-27 19:03:46 -04:00
Henry Dollman	4694642674	add apiContainerList variable to reduce memory allocations	2024-09-27 16:10:31 -04:00
Henry Dollman	56c0b86025	rename variables for clarity	2024-09-27 14:56:53 -04:00
Henry Dollman	82e3f3c7c1	Fix temperature sensors not reporting if any sensor lacks valid data (#167 )	2024-09-27 13:10:13 -04:00
Henry Dollman	38a9c535b8	change x axis time format for 1 week chart and add key	2024-09-27 13:08:48 -04:00
Henry Dollman	34c83e7c17	hide temp sensors chart legend if more than 11 sensors	2024-09-27 13:08:11 -04:00
Henry Dollman	fe5732d75a	replace icon and remove unneeded usememo in system.tsx	2024-09-27 13:06:31 -04:00
Henry Dollman	cc32b50d82	add agent.debug and comments	2024-09-27 12:17:19 -04:00
Henry Dollman	764e043e83	add slog and LOG_LEVEL to agent	2024-09-26 20:07:35 -04:00
Henry Dollman	cec9339f6d	allow monitoring remote mounts (#178 ) and handle I/O edge case (#183 )	2024-09-26 18:01:52 -04:00
Henry Dollman	f96f04f876	change swap chart placement	2024-09-26 16:55:31 -04:00
Henry Dollman	06b1c2200b	reorganize agent package	2024-09-26 15:08:26 -04:00
Henry Dollman	e88e2bf3dc	agent binary - show correct cores in lxc	2024-09-26 15:00:48 -04:00
Henry Dollman	8621a45383	remove unnecessary buffer pool	2024-09-26 14:57:01 -04:00
Henry Dollman	f2ddee9216	Fix typo in extra disk I/O chart (closes #187 )	2024-09-26 10:50:23 -04:00
Henry Dollman	f350d61ee2	add CSP env var to set a custom Content-Security-Policy header value	2024-09-24 15:22:47 -04:00
Henry Dollman	2d670c585d	optimize deletion of old records	2024-09-23 17:17:30 -04:00
Henry Dollman	55d1c00903	use same disk I/O chart component for root and extra fs	2024-09-23 13:56:15 -04:00
Henry Dollman	78a9086b55	use same disk usage chart component for root and extra fs	2024-09-23 13:42:44 -04:00
Henry Dollman	4ee169fea5	display TB in disk usage charts if value >= 1 TB	2024-09-23 13:34:40 -04:00
Henry Dollman	a286bed54c	update SystemInfo ts type	2024-09-18 13:02:53 -04:00
Henry Dollman	314cee081a	system info refactoring	2024-09-18 12:47:06 -04:00
Henry Dollman	e287124632	show swap chart only if swap is in use	2024-09-18 12:46:15 -04:00
Stavros	9cccefd3fa	feat: add kernel version text (#170 )	2024-09-17 13:43:58 -04:00
Henry Dollman	ec95f63806	limit fields when fetching server list	2024-09-16 18:40:11 -04:00
Henry Dollman	812fe20df7	fix: update settings when visiting a settings page directly	2024-09-16 16:51:23 -04:00