From 0e60860cf0bf0349344d077e2ad6bb7e188b7d43 Mon Sep 17 00:00:00 2001
From: Jens Ahrensfeld <jens@jayfield.org>
Date: Wed, 1 Jul 2026 09:44:11 +0200
Subject: [PATCH] feat: periodically checkpoint server/sud logs to disk

Both loggers previously only wrote their JSON log on their end trigger
(shutdown / Stop-or-DONE), losing the whole session/run's data on a
hard crash or power loss. Add a log_interval (config.json, default
300s) that rewrites the same file whole every N seconds in between.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TvgC7oy9MxaA4ZQxXqkNdS
---
 README.md            | 18 ++++++++++--------
 config-real.json.tpl |  1 +
 config-sim.json.tpl  |  1 +
 server/brewpi.py     | 17 +++++++++++++----
 tasks/server_log.py  | 11 ++++++++++-
 tasks/sud_log.py     |  5 +++--
 6 files changed, 38 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 06a043b..0f2aa7b 100644
--- a/README.md
+++ b/README.md
@@ -689,20 +689,22 @@ Both loggers record the same six signals the GUI's Automatic tab plots live
 (`temp_ist`/`temp_soll`, `rate_ist`/`rate_soll`, `power_set`/`power_eff`),
 each sample with both simulated-elapsed-seconds and a real wall-clock
 timestamp, plus any plant-param changes along the way (see
-`apply_plant_params()`) - written as JSON via `write()`, whole and only
-once, never partially mid-run.
+`apply_plant_params()`) - written as JSON via `write()`, always the whole
+accumulated sample list rewritten to the same file, never appended.
 
 `tasks/server_log.py`'s `ServerLogTask` records continuously for the whole
 server session, regardless of Sud state - useful for verifying controller
 and heater behaviour outside of a scheduled brew. It starts on construction
-and is written to `logs/log_<date>T<time>.json` on shutdown.
+and is written to `logs/log_<date>T<time>.json` on shutdown, and again
+every `log_interval` seconds (`config.json`, default 300) in between so a
+hard crash or power loss only loses up to that much data.
 
 `tasks/sud_log.py`'s `SudLogTask` subclasses `ServerLogTask` to reuse the
-same sample format, but only records while a Sud run is actually active. A
-fresh run starts recording on a genuine `Start` from `IDLE`/`DONE` (a
-`Pause`→resume `Start` is a no-op - it's still the same run) and is written
-out on `Stop` or natural completion (`DONE`), to
-`logs/log_<date>T<time>_<sud-name>.log`.
+same sample format and `log_interval` checkpointing, but only records while
+a Sud run is actually active. A fresh run starts recording on a genuine
+`Start` from `IDLE`/`DONE` (a `Pause`→resume `Start` is a no-op - it's still
+the same run) and is written out on `Stop` or natural completion (`DONE`),
+to `logs/log_<date>T<time>_<sud-name>.log`.
 
 `server/brewpi.py` also mirrors everything it prints (every component's
 `print()`-based status/debug output) to a plain text log,
diff --git a/config-real.json.tpl b/config-real.json.tpl
index 07c48ec..5db5933 100644
--- a/config-real.json.tpl
+++ b/config-real.json.tpl
@@ -1,5 +1,6 @@
 {
 	"ambient_temperature": 20,
+	"log_interval": 300,
  	"TempCtrl": {
 		"pid_type": "Smith",
 		"beta": 0.05,
diff --git a/config-sim.json.tpl b/config-sim.json.tpl
index f86299a..7c30879 100644
--- a/config-sim.json.tpl
+++ b/config-sim.json.tpl
@@ -1,5 +1,6 @@
 {
 	"ambient_temperature": 20,
+	"log_interval": 300,
  	"TempCtrl": {
 		"pid_type": "Smith",
 		"beta": 0.05,
diff --git a/server/brewpi.py b/server/brewpi.py
index cf46c5b..9b3fce6 100755
--- a/server/brewpi.py
+++ b/server/brewpi.py
@@ -131,16 +131,25 @@ if __name__ == '__main__':
 	sud_task = SudTask(sud, tc, stirrer, pot, DT, DT_TASK, dispatcher.msgio_get("Sud"), forecast_estimator)
 	taskmgr.add(sud_task)
 
+	# How often the server/sud logs checkpoint themselves to disk (in
+	# addition to always writing on their own end trigger) - so a hard
+	# crash/power loss only loses up to this much data. Config-only (no CLI
+	# flag): it's a plant/deployment concern like the rest of config.json,
+	# not a per-invocation run-mode knob.
+	log_interval = config.get('log_interval', 300)
+
 	# Continuous server-session log - records from startup to shutdown
-	# regardless of Sud state; written to logs/log_{date_time}.json on exit.
-	server_log_task = ServerLogTask(tc, heater, heater_task, DT_TASK, args.logdir, config=config, dt=DT)
+	# regardless of Sud state; written to logs/log_{date_time}.json on exit
+	# and every log_interval seconds in between.
+	server_log_task = ServerLogTask(tc, heater, heater_task, DT_TASK, args.logdir, config=config, dt=DT, log_interval=log_interval)
 	if startup_params is not None:
 		server_log_task.log_plant_params(0, startup_params)
 	taskmgr.add(server_log_task)
 
 	# Per-run log - only records while a Sud is actually playing; written to
-	# logs/log_{date_time}_{sud_name}.log on Stop (or natural completion).
-	sud_log_task = SudLogTask(tc, heater, heater_task, sud, DT_TASK, args.logdir, config=config, dt=DT)
+	# logs/log_{date_time}_{sud_name}.log on Stop (or natural completion) and
+	# every log_interval seconds in between.
+	sud_log_task = SudLogTask(tc, heater, heater_task, sud, DT_TASK, args.logdir, config=config, dt=DT, log_interval=log_interval)
 	taskmgr.add(sud_log_task)
 
 	sud_task.set_on_plant_params(lambda elapsed, params: (
diff --git a/tasks/server_log.py b/tasks/server_log.py
index e13ee90..e915562 100644
--- a/tasks/server_log.py
+++ b/tasks/server_log.py
@@ -16,7 +16,7 @@ class ServerLogTask(ATask):
 	Sud state — useful for verifying controller and heater behaviour
 	outside of a scheduled brew."""
 
-	def __init__(self, tc: APid, heater: AHeater, heater_task, interval, path='./logs', config=None, dt=None):
+	def __init__(self, tc: APid, heater: AHeater, heater_task, interval, path='./logs', config=None, dt=None, log_interval=None):
 		ATask.__init__(self, interval)
 		self.tc = tc
 		self.heater = heater
@@ -24,10 +24,12 @@ class ServerLogTask(ATask):
 		self.path = path
 		self.config = config
 		self.dt = dt
+		self.log_interval = log_interval
 		self._samples = []
 		self._param_events = []
 		self._t0 = time.monotonic()
 		self._run_id = time.strftime("%Y%m%dT%H%M%S", time.localtime())
+		self._last_write = self._t0
 
 	def log_plant_params(self, elapsed, params):
 		self._param_events.append({'t': time.monotonic() - self._t0, 'params': params})
@@ -36,6 +38,13 @@ class ServerLogTask(ATask):
 		while True:
 			if self._should_sample():
 				self._samples.append(self._take_sample())
+			# Periodically checkpoints to disk (same file, overwritten whole
+			# each time - see write()) so a hard crash/power loss only loses
+			# up to log_interval seconds, not the whole session/run.
+			now = time.monotonic()
+			if self.log_interval and now - self._last_write >= self.log_interval:
+				self.write()
+				self._last_write = now
 			await asyncio.sleep(self.interval)
 
 	def _should_sample(self):
diff --git a/tasks/sud_log.py b/tasks/sud_log.py
index bf65740..524b9ad 100644
--- a/tasks/sud_log.py
+++ b/tasks/sud_log.py
@@ -14,8 +14,8 @@ class SudLogTask(ServerLogTask):
 	logs/log_{date_time}_{sud_name}.log. A Pause/resume doesn't start a new
 	file - only a fresh Play (from IDLE/DONE) does."""
 
-	def __init__(self, tc: APid, heater: AHeater, heater_task, sud, interval, path='./logs', config=None, dt=None):
-		ServerLogTask.__init__(self, tc, heater, heater_task, interval, path, config, dt)
+	def __init__(self, tc: APid, heater: AHeater, heater_task, sud, interval, path='./logs', config=None, dt=None, log_interval=None):
+		ServerLogTask.__init__(self, tc, heater, heater_task, interval, path, config, dt, log_interval)
 		self.sud = sud
 		self._active = False
 
@@ -31,6 +31,7 @@ class SudLogTask(ServerLogTask):
 			return
 		self._samples = []
 		self._t0 = time.monotonic()
+		self._last_write = self._t0
 		self._run_id = time.strftime("%Y%m%dT%H%M%S", time.localtime())
 		self._active = True