Address review: bound actions, lock-safe crash-time reads

- RegisterAction: pop on size() > Maximum so it truly retains 50 (was
  >=, capping at 49); matches AddServerWarning and the PR description.
- ComputeServerWarnings: try_to_lock messageMutex instead of a blocking
  lock_guard. The crashing thread may already hold it (crashed inside
  AddServerWarning/RegisterAction); a blocking acquire would hang crash
  reporting. Return empty if it can't be acquired.
- Replace OBS_API::getOBSLogGeneral() (returned a mutable deque ref that
  RequestOBSLog drained with no synchronization, racing node_obs_log())
  with snapshotOBSLogGeneral(): copies and clears logReport.general
  under logMutex via try_to_lock. RequestOBSLog now consumes the
  snapshot, reverse-iterating to keep the newest-first ordering.
- Include <algorithm> explicitly (std::transform was relying on a
  transitive include).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: summeroff

obs-studio-server/source/nodeobs_api.cpp

@@ -2048,9 +2048,15 @@ double OBS_API::getMemoryUsage()
 	return (double)os_get_proc_resident_size() / (1024.0 * 1024.0);
 }
 
-std::deque<std::string> &OBS_API::getOBSLogGeneral()
+std::deque<std::string> OBS_API::snapshotOBSLogGeneral()
 {
-	return logReport.general;
+	std::unique_lock<std::mutex> lock(logMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return {};
+
+	std::deque<std::string> snapshot = std::move(logReport.general);
+	logReport.general.clear();
+	return snapshot;
 }
 
 std::string OBS_API::getCurrentVersion()

obs-studio-server/source/nodeobs_api.h

@@ -120,7 +120,10 @@ class OBS_API {
 	static double getMemoryUsage();
 	static void getCurrentOutputStats(obs_output_t *output, OBS_API::OutputStats &outputStats);
 
-	static std::deque<std::string> &getOBSLogGeneral();
+	// Snapshot (and clear) the general log tail under logMutex. Uses try_lock — the crash
+	// handler calls this and must never block on the logging thread. Returns oldest-first,
+	// empty if the lock can't be acquired.
+	static std::deque<std::string> snapshotOBSLogGeneral();
 
 	static std::string getCurrentVersion();
 	static std::string getUsername();

obs-studio-server/source/util-crashmanager.cpp

@@ -19,6 +19,7 @@
 #include "util-crashmanager.h"
 #include "util-metricsprovider.h"
 
+#include <algorithm>
 #include <chrono>
 #include <codecvt>
 #include <filesystem>
@@ -1029,13 +1030,10 @@ nlohmann::json util::CrashManager::RequestOBSLog()
 {
 	nlohmann::json result;
 
-	auto &general = OBS_API::getOBSLogGeneral();
-	while (!general.empty()) {
-		result.push_back(general.front());
-		general.pop_front();
-	}
-
-	std::reverse(result.begin(), result.end());
+	// snapshotOBSLogGeneral returns oldest-first under logMutex; emit newest-first.
+	std::deque<std::string> general = OBS_API::snapshotOBSLogGeneral();
+	for (auto it = general.rbegin(); it != general.rend(); ++it)
+		result.push_back(*it);
 
 	return result;
 }
@@ -1064,7 +1062,12 @@ nlohmann::json util::CrashManager::ComputeServerWarnings()
 {
 	nlohmann::json result;
 
-	std::lock_guard<std::mutex> lock(messageMutex);
+	// try_lock — the crashing thread may already hold messageMutex (e.g. it crashed inside
+	// AddServerWarning/RegisterAction); a blocking lock would hang crash reporting.
+	std::unique_lock<std::mutex> lock(messageMutex, std::try_to_lock);
+	if (!lock.owns_lock())
+		return result;
+
 	for (auto &msg : serverWarnings)
 		result.push_back(msg);
 
@@ -1243,7 +1246,7 @@ void RegisterAction(const std::string &message)
 		lastActions.back().first++;
 	} else {
 		lastActions.push({0, message});
-		if (lastActions.size() >= MaximumActionsRegistered) {
+		if (lastActions.size() > MaximumActionsRegistered) {
 			lastActions.pop();
 		}
 	}