Forwards logs to the server if server supports it

src/logging/LogQueue.cpp

@@ -0,0 +1,8 @@
+#include "LogQueue.h"
+
+namespace SlimeVR::Logging
+{
+
+LogQueue LogQueue::s_Instance{};
+
+} // namespace SlimeVR::Logging

src/logging/LogQueue.h

@@ -0,0 +1,111 @@
+#ifndef LOGGING_LOGQUEUE_H
+#define LOGGING_LOGQUEUE_H
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <numeric>
+
+namespace SlimeVR::Logging {
+
+template <typename T, T Modulus>
+class Modulo {
+public:
+    Modulo(T value) : m_Value(value) {}
+
+    Modulo<T, Modulus>& operator++()
+    {
+        m_Value = (m_Value + 1) % Modulus;
+        return *this;
+    }
+
+    Modulo<T, Modulus> operator+(T other) const
+    {
+		// WARNING: Does not consider overflow or negative values
+		T newValue = (m_Value + other) % Modulus;
+        return Modulo<T, Modulus>{newValue};
+    }
+
+    T get() const
+    {
+        return m_Value;
+    }
+
+private:
+    T m_Value;
+};
+
+class LogQueue {
+public:
+    // Whether there are any messages in the queue.
+    bool empty() const
+    {
+        return m_Count == 0;
+    }
+
+    // First message in the queue.
+    const char* front() const
+    {
+        if (empty())
+        {
+            return nullptr;
+        }
+
+        return m_MessageQueue[m_StartIndex.get()].data();
+    }
+
+    // Adds a message to the end of the queue. Messages that are too long will be truncated.
+    void push(const char* message)
+    {
+        if (m_Count < m_MessageQueue.max_size())
+        {
+            setMessageAt(m_Count, message);
+            ++m_Count;
+        }
+        else
+        {
+            // Overwrite the last message
+            setMessageAt(m_Count - 1, OverflowMessage);
+        }
+    }
+
+    // Removes a message from the front of the queue.
+    void pop()
+    {
+        if (m_Count > 0)
+        {
+            ++m_StartIndex;
+            --m_Count;
+        }
+    }
+
+    // Global instance of the log queue
+    static LogQueue& instance()
+    {
+        return s_Instance;
+    }
+
+private:
+    static constexpr int MaxMessages = 100;
+    static constexpr int MaxMessageLength = std::numeric_limits<uint8_t>::max();
+    static constexpr char OverflowMessage[] = "[OVERFLOW]";
+
+    void setMessageAt(int offset, const char* message)
+    {
+		Modulo<size_t, MaxMessages> index = m_StartIndex + offset;
+        std::array<char, MaxMessageLength>& entry = m_MessageQueue[index.get()];
+
+        std::strncpy(entry.data(), message, entry.max_size());
+        entry[entry.max_size() - 1] = '\0';	// NULL terminate string in case message overflows because strncpy does not do that
+    }
+
+    Modulo<size_t, MaxMessages> m_StartIndex{0};
+    size_t m_Count = 0;
+    std::array<std::array<char, MaxMessageLength>, MaxMessages> m_MessageQueue;
+
+    static LogQueue s_Instance;
+};
+
+} // namespace SlimeVR::Logging
+
+#endif /* LOGGING_LOGQUEUE_H */

src/logging/Logger.cpp

@@ -1,4 +1,5 @@
 #include "Logger.h"
+#include "LogQueue.h"
 
 namespace SlimeVR {
 namespace Logging {
@@ -65,6 +66,9 @@ void Logger::log(Level level, const char* format, va_list args) {
 	}
 
 	Serial.printf("[%-5s] [%s] %s\n", levelToString(level), buf, buffer);
+
+	// REVIEW: Do we want to print the log level and tags too?
+	LogQueue::instance().push(buffer);
 }
 }  // namespace Logging
 }  // namespace SlimeVR

src/network/connection.cpp

@@ -25,6 +25,7 @@
 
 #include "GlobalVars.h"
 #include "logging/Logger.h"
+#include "logging/LogQueue.h"
 #include "packets.h"
 
 #define TIMEOUT 3000UL
@@ -189,7 +190,12 @@ bool Connection::sendPacketNumber() {
 }
 
 bool Connection::sendShortString(const char* str) {
-	uint8_t size = strlen(str);
+	size_t size = strlen(str);
+
+	constexpr size_t maxLength = std::numeric_limits<uint8_t>::max();
+	if (size > maxLength) {
+		size = maxLength;
+	}
 
 	MUST_TRANSFER_BOOL(sendByte(size));
 	MUST_TRANSFER_BOOL(sendBytes((const uint8_t*)str, size));
@@ -395,6 +401,31 @@ void Connection::sendAcknowledgeConfigChange(uint8_t sensorId, uint16_t configTy
 	MUST(endPacket());
 }
 
+// PACKET_LOG 26
+void Connection::sendLogMessage(const char* message) {
+	MUST(m_Connected);
+
+	MUST(beginPacket());
+
+	MUST(sendPacketType(PACKET_LOG));
+	MUST(sendPacketNumber());
+	MUST(sendShortString(message));
+
+	MUST(endPacket());
+}
+
+void Connection::sendPendingLogMessage() {
+	MUST(m_Connected);
+	MUST(m_ServerFeatures.has(ServerFeatures::PROTOCOL_LOG_SUPPORT));
+
+	Logging::LogQueue& logQueue = Logging::LogQueue::instance();
+	if (!logQueue.empty()) {
+		const char* message = logQueue.front();
+		sendLogMessage(message);
+		logQueue.pop();
+	}
+}
+
 void Connection::sendTrackerDiscovery() {
 	MUST(!m_Connected);
 
@@ -634,6 +665,7 @@ void Connection::update() {
 	auto& sensors = sensorManager.getSensors();
 
 	updateSensorState(sensors);
+	sendPendingLogMessage();
 	maybeRequestFeatureFlags();
 
 	if (!m_Connected) {
@@ -731,6 +763,9 @@ void Connection::update() {
 					m_Logger.debug("Server supports packet bundling");
 				}
 #endif
+				if (m_ServerFeatures.has(ServerFeatures::PROTOCOL_LOG_SUPPORT)) {
+					m_Logger.debug("Server supports network logging");
+				}
 			}
 
 			break;

src/network/connection.h

@@ -158,6 +158,10 @@ class Connection {
 
 	void sendAcknowledgeConfigChange(uint8_t sensorId, uint16_t configType);
 
+	// PACKET_LOG 26
+	void sendLogMessage(const char* message);
+	void sendPendingLogMessage();
+
 	bool m_Connected = false;
 	SlimeVR::Logging::Logger m_Logger = SlimeVR::Logging::Logger("UDPConnection");
 

src/network/featureflags.h

@@ -38,6 +38,14 @@ struct ServerFeatures {
 		// Server can parse bundle packets: `PACKET_BUNDLE` = 100 (0x64).
 		PROTOCOL_BUNDLE_SUPPORT,
 
+		// Server can parse bundle packets with compact headers and packed IMU rotation/acceleration frames:
+		// - `PACKET_BUNDLE_COMPACT` = 101 (0x65),
+		// - `PACKET_ROTATION_AND_ACCELERATION` = 23 (0x17).
+		PROTOCOL_BUNDLE_COMPACT_SUPPORT,
+
+		// Server can receive log messages: `PACKET_LOG` = 102 (0x66).
+		PROTOCOL_LOG_SUPPORT,
+
 		// Add new flags here
 
 		BITS_TOTAL,

src/network/packets.h

@@ -51,6 +51,7 @@
 // packet
 #define PACKET_ACKNOWLEDGE_CONFIG_CHANGE 24
 #define PACKET_SET_CONFIG_FLAG 25
+#define PACKET_LOG 26
 
 #define PACKET_BUNDLE 100