Add backlog to buffered logger

Author: GuLinux

src/asyncbufferedtcplogger.cpp

@@ -1,19 +1,29 @@
 #include "asyncbufferedtcplogger.h"
+#include "configuration.h"
 
 APB::AsyncBufferedTCPLogger::AsyncBufferedTCPLogger(AsyncServer & loggerServer) {
     loggerServer.onClient([this](void *,AsyncClient *c){
       this->client = c;
+      if(!this->backlog.empty()) {
+        c->write("==== Flushing backlog ====\n");
+        while(!this->backlog.empty()) {
+          c->write(this->backlog.front().c_str(), this->backlog.front().length());
+          this->backlog.pop();
+        }
+        c->write("==== Backlog finished ====\n");
+      }
     }, nullptr);
 }
 
+#include "utils.h"
 size_t APB::AsyncBufferedTCPLogger::write(uint8_t c) {
-    if(!client) {
-      return 0;
-    }
     buffer[currentPosition++] = c;
     if(c == '\n') {
+      ScopeGuard resetBuffer(std::bind(&AsyncBufferedTCPLogger::reset, this));
+      if(!client) {
+        return fillBacklog();
+      }
       client->write(buffer.data(), currentPosition);
-      reset();
     }
     return 1;
 }
@@ -22,3 +32,13 @@ void APB::AsyncBufferedTCPLogger::reset() {
     std::fill(std::begin(buffer), std::end(buffer), 0);
     currentPosition = 0;
 }
+
+size_t APB::AsyncBufferedTCPLogger::fillBacklog() {
+  #if APB_NETWORK_LOGGER_BACKLOG > 0
+    backlog.push(String{buffer.data()});
+    while(backlog.size() > APB_NETWORK_LOGGER_BACKLOG) {
+      backlog.pop();
+    }
+  #endif
+    return 0;
+}

src/asyncbufferedtcplogger.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <Print.h>
 #include <AsyncTCP.h>
+#include <queue>
 
 namespace APB {
 class AsyncBufferedTCPLogger: public Print {
@@ -11,7 +12,9 @@ class AsyncBufferedTCPLogger: public Print {
 private:
   AsyncClient *client = nullptr;
   void reset();
+  size_t fillBacklog();
   std::array<char, 1024> buffer = {0};
+  std::queue<String> backlog;
   uint16_t currentPosition = 0;
 };
 

src/main.cpp

@@ -19,8 +19,6 @@
 #include <AsyncTCP.h>
 #include "asyncbufferedtcplogger.h"
 
-#include "time.h"
-#include "esp_sntp.h"
 Scheduler scheduler;
 AsyncServer loggerServer{9911};
 
@@ -52,16 +50,15 @@ void setup() {
 
   Log.begin(LOG_LEVEL_VERBOSE, &Serial, true);
   Log.infoln(LOG_SCOPE "setup, core: %d", xPortGetCoreID());
+  
+  Log.addHandler(&bufferedLogger);
 
   LittleFS.begin();
   APB::Settings::Instance.setup();
   APB::StatusLed::Instance.setup();
 
   APB::WiFiManager::Instance.setup(scheduler);
   loggerServer.begin();
-
-  Log.addHandler(&bufferedLogger);
-
   Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
   Wire.setClock(100000);
   APB::Ambient::Instance.setup(scheduler);
@@ -103,28 +100,31 @@ void setupArduinoOTA() {
       }
 
       // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
-      Serial.println("Start updating " + type);
+      Log.infoln("Start updating %s", type.c_str());
       LittleFS.end();
     })
     .onEnd([]() {
-      Serial.println("\nEnd");
+      Log.infoln("\nEnd");
     })
     .onProgress([](unsigned int progress, unsigned int total) {
-      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+      Log.infoln("Progress: %u%%\r", (progress / (total / 100)));
     })
     .onError([](ota_error_t error) {
-      Serial.printf("Error[%u]: ", error);
+      String errorMessage;
       if (error == OTA_AUTH_ERROR) {
-        Serial.println("Auth Failed");
+        errorMessage = "Auth Failed";
       } else if (error == OTA_BEGIN_ERROR) {
-        Serial.println("Begin Failed");
+        errorMessage = "Begin Failed";
       } else if (error == OTA_CONNECT_ERROR) {
-        Serial.println("Connect Failed");
+        errorMessage = "Connect Failed";
       } else if (error == OTA_RECEIVE_ERROR) {
-        Serial.println("Receive Failed");
+        errorMessage = "Receive Failed";
       } else if (error == OTA_END_ERROR) {
-        Serial.println("End Failed");
+        errorMessage = "End Failed";
+      } else {
+        errorMessage = "Unknown error";
       }
+      Log.errorln("Error[%u]: %s", error, errorMessage.c_str());
     });
 
   ArduinoOTA.begin();