andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-12 18:59:51 +03:00
Code Issues Packages Projects Releases Wiki Activity

weblog queue complete in psram, save weblog settings in one call

Browse Source
This commit is contained in:
MichaelDvP
2025-12-06 14:06:15 +01:00
parent 1d03056784
commit 67280546af
2 changed files with 86 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
src/web/WebLogService.cpp
View File

@@ -40,7 +40,8 @@ WebLogService::WebLogService(AsyncWebServer * server, SecurityManager * security
// start the log service with INFO level // start the log service with INFO level
void WebLogService::begin() { void WebLogService::begin() {
uuid::log::Logger::register_handler(this, uuid::log::Level::INFO); level_ = uuid::log::Level::INFO;
uuid::log::Logger::register_handler(this, level_);
} }
// apply the user settings // apply the user settings
@@ -49,24 +50,10 @@ void WebLogService::start() {
maximum_log_messages_ = settings.weblog_buffer; maximum_log_messages_ = settings.weblog_buffer;
limit_log_messages_ = maximum_log_messages_; limit_log_messages_ = maximum_log_messages_;
compact_ = settings.weblog_compact; compact_ = settings.weblog_compact;
uuid::log::Logger::register_handler(this, (uuid::log::Level)settings.weblog_level); level_ = (uuid::log::Level)settings.weblog_level;
if ((uuid::log::Level)settings.weblog_level == uuid::log::Level::OFF) {
log_messages_.clear();
}
}); });
} uuid::log::Logger::register_handler(this, level_);
if (level_ == uuid::log::Level::OFF) {
uuid::log::Level WebLogService::log_level() const {
return uuid::log::Logger::get_log_level(this);
}
void WebLogService::log_level(uuid::log::Level level) {
EMSESP::webSettingsService.update([&](WebSettings & settings) {
settings.weblog_level = level;
return StateUpdateResult::CHANGED;
});
uuid::log::Logger::register_handler(this, level);
if (level == uuid::log::Level::OFF) {
log_messages_.clear(); log_messages_.clear();
} }
} }
@@ -75,58 +62,33 @@ size_t WebLogService::num_log_messages() const {
return log_messages_.size(); return log_messages_.size();
} }
size_t WebLogService::maximum_log_messages() const { WebLogService::QueuedLogMessage::QueuedLogMessage(unsigned long id, uint64_t uptime, uuid::log::Level level, const char * name, std::string text)
return maximum_log_messages_;
}
void WebLogService::maximum_log_messages(size_t count) {
maximum_log_messages_ = std::max((size_t)1, count);
if (limit_log_messages_ > maximum_log_messages_) {
limit_log_messages_ = maximum_log_messages_;
}
while (log_messages_.size() > maximum_log_messages_) {
log_messages_.pop_front();
}
EMSESP::webSettingsService.update([&](WebSettings & settings) {
settings.weblog_buffer = count;
return StateUpdateResult::CHANGED;
});
}
bool WebLogService::compact() const {
return compact_;
}
void WebLogService::compact(bool compact) {
compact_ = compact;
EMSESP::webSettingsService.update([&](WebSettings & settings) {
settings.weblog_compact = compact;
return StateUpdateResult::CHANGED;
});
}
WebLogService::QueuedLogMessage::QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content)
: id_(id) : id_(id)
, content_(std::move(content)) { , uptime_(uptime)
, level_(level)
, name_(name)
, text_(text) {
} }
void WebLogService::operator<<(std::shared_ptr<uuid::log::Message> message) { void WebLogService::operator<<(std::shared_ptr<uuid::log::Message> message) {
#ifndef EMSESP_STANDALONE #ifndef EMSESP_STANDALONE
size_t maxAlloc = ESP.getMaxAllocHeap(); if (emsesp::EMSESP::system_.PSram()) {
if (limit_log_messages_ > 5 && maxAlloc < 46080) { limit_log_messages_ = maximum_log_messages_;
} else {
uint32_t maxAlloc = ESP.getMaxAllocHeap();
if (limit_log_messages_ > 5 && maxAlloc < (50 * 1024)) { // 50k
--limit_log_messages_; --limit_log_messages_;
} else if (limit_log_messages_ < maximum_log_messages_ && maxAlloc > 51200) { } else if (limit_log_messages_ < maximum_log_messages_ && maxAlloc > (60 * 1024)) { // 60k
++limit_log_messages_; ++limit_log_messages_;
} }
}
#endif #endif
while (log_messages_.size() >= limit_log_messages_) { while (log_messages_.size() >= limit_log_messages_) {
log_messages_.pop_front(); log_messages_.pop_front();
} }
log_messages_.emplace_back(++log_message_id_, std::move(message)); log_messages_.emplace_back(++log_message_id_, message->uptime_ms, message->level, message->name, message->text.c_str());
} }
// dumps out the contents of log buffer to shell console // dumps out the contents of log buffer to shell console
@@ -136,30 +98,28 @@ void WebLogService::show(Shell & shell) {
} }
shell.println(); shell.println();
shell.printfln("Recent Log (level %s, max %d messages):", format_level_uppercase(log_level()), maximum_log_messages()); shell.printfln("Recent Log (level %s, max %d messages):", uuid::log::format_level_uppercase(level_), maximum_log_messages_);
shell.println(); shell.println();
for (const auto & message : log_messages_) { for (const auto & message : log_messages_) {
log_message_id_tail_ = message.id_;
char time_string[26]; char time_string[26];
shell.print(messagetime(time_string, message.content_->uptime_ms, sizeof(time_string))); shell.print(messagetime(time_string, message.uptime_, sizeof(time_string)));
shell.printf(" %c %lu: [%s] ", uuid::log::format_level_char(message.content_->level), message.id_, message.content_->name); shell.printf(" %c %lu: [%s] ", uuid::log::format_level_char(message.level_), message.id_, message.name_);
if ((message.content_->level == uuid::log::Level::ERR) || (message.content_->level == uuid::log::Level::WARNING)) { if ((message.level_ == uuid::log::Level::ERR) || (message.level_ == uuid::log::Level::WARNING)) {
shell.print(COLOR_RED); shell.print(COLOR_RED);
shell.println(message.content_->text); shell.println(message.text_.c_str());
shell.print(COLOR_RESET); shell.print(COLOR_RESET);
} else if (message.content_->level == uuid::log::Level::INFO) { } else if (message.level_ == uuid::log::Level::INFO) {
shell.print(COLOR_YELLOW); shell.print(COLOR_YELLOW);
shell.println(message.content_->text); shell.println(message.text_.c_str());
shell.print(COLOR_RESET); shell.print(COLOR_RESET);
} else if (message.content_->level == uuid::log::Level::DEBUG) { } else if (message.level_ == uuid::log::Level::DEBUG) {
shell.print(COLOR_CYAN); shell.print(COLOR_CYAN);
shell.println(message.content_->text); shell.println(message.text_.c_str());
shell.print(COLOR_RESET); shell.print(COLOR_RESET);
} else { } else {
shell.println(message.content_->text); shell.println(message.text_.c_str());
} }
} }
@@ -187,7 +147,6 @@ void WebLogService::loop() {
// flush // flush
for (const auto & message : log_messages_) { for (const auto & message : log_messages_) {
if (message.id_ > log_message_id_tail_) { if (message.id_ > log_message_id_tail_) {
log_message_id_tail_ = message.id_;
transmit(message); transmit(message);
return; return;
} }
@@ -215,17 +174,18 @@ void WebLogService::transmit(const QueuedLogMessage & message) {
JsonObject logEvent = jsonDocument.to<JsonObject>(); JsonObject logEvent = jsonDocument.to<JsonObject>();
char time_string[25]; char time_string[25];
logEvent["t"] = messagetime(time_string, message.content_->uptime_ms, sizeof(time_string)); logEvent["t"] = messagetime(time_string, message.uptime_, sizeof(time_string));
logEvent["l"] = message.content_->level; logEvent["l"] = message.level_; // .content_->level;
logEvent["i"] = message.id_; logEvent["i"] = message.id_;
logEvent["n"] = message.content_->name; logEvent["n"] = message.name_; // content_->name;
logEvent["m"] = message.content_->text; logEvent["m"] = message.text_; // content_->text;
size_t len = measureJson(jsonDocument); size_t len = measureJson(jsonDocument) + 1;
char * buffer = new char[len + 1]; char * buffer = new char[len];
if (buffer) { if (buffer) {
serializeJson(jsonDocument, buffer, len + 1); serializeJson(jsonDocument, buffer, len);
events_.send(buffer, "message", message.id_); events_.send(buffer, "message", message.id_);
log_message_id_tail_ = message.id_;
} }
delete[] buffer; delete[] buffer;
} }
@@ -236,9 +196,9 @@ void WebLogService::getSetValues(AsyncWebServerRequest * request, JsonVariant js
// GET - return the values // GET - return the values
auto * response = new AsyncJsonResponse(false); auto * response = new AsyncJsonResponse(false);
JsonObject root = response->getRoot(); JsonObject root = response->getRoot();
root["level"] = log_level(); root["level"] = level_;
root["max_messages"] = maximum_log_messages(); root["max_messages"] = maximum_log_messages_;
root["compact"] = compact(); root["compact"] = compact_;
root["psram"] = (EMSESP::system_.PSram() > 0); root["psram"] = (EMSESP::system_.PSram() > 0);
root["developer_mode"] = EMSESP::system_.developer_mode(); root["developer_mode"] = EMSESP::system_.developer_mode();
@@ -250,19 +210,29 @@ void WebLogService::getSetValues(AsyncWebServerRequest * request, JsonVariant js
return; return;
} }
// POST - write the settings
level_ = json["level"];
maximum_log_messages_ = json["max_messages"];
compact_ = json["compact"];
// POST - set the values uuid::log::Logger::register_handler(this, level_);
auto && body = json.as<JsonObject>(); if (level_ == uuid::log::Level::OFF) {
log_messages_.clear();
}
uuid::log::Level level = body["level"]; if (limit_log_messages_ > maximum_log_messages_) {
log_level(level); limit_log_messages_ = maximum_log_messages_;
while (log_messages_.size() > limit_log_messages_) {
uint8_t max_messages = body["max_messages"]; log_messages_.pop_front();
maximum_log_messages(max_messages); }
}
bool comp = body["compact"];
compact(comp);
EMSESP::webSettingsService.update([&](WebSettings & settings) {
settings.weblog_compact = compact_;
settings.weblog_level = level_;
settings.weblog_buffer = maximum_log_messages_;
return StateUpdateResult::CHANGED;
});
request->send(200); // OK request->send(200); // OK
} }

20
src/web/WebLogService.h
View File

@@ -23,6 +23,7 @@
#define EMSESP_LOG_SETTINGS_PATH "/rest/logSettings" #define EMSESP_LOG_SETTINGS_PATH "/rest/logSettings"
#ifndef EMSESP_STANDALONE #ifndef EMSESP_STANDALONE
#include <esp32-psram.h> #include <esp32-psram.h>
using stringPSRAM = std::basic_string<char, std::char_traits<char>, AllocatorPSRAM<char>>;
#endif #endif
using ::uuid::console::Shell; using ::uuid::console::Shell;
@@ -38,13 +39,7 @@ class WebLogService : public uuid::log::Handler {
void begin(); void begin();
void start(); void start();
uuid::log::Level log_level() const;
void log_level(uuid::log::Level level);
size_t maximum_log_messages() const;
size_t num_log_messages() const; size_t num_log_messages() const;
void maximum_log_messages(size_t count);
bool compact() const;
void compact(bool compact);
void loop(); void loop();
void show(Shell & shell); void show(Shell & shell);
@@ -55,12 +50,20 @@ class WebLogService : public uuid::log::Handler {
class QueuedLogMessage { class QueuedLogMessage {
public: public:
QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> && content); QueuedLogMessage(unsigned long id, uint64_t uptime, uuid::log::Level level, const char * name, std::string text);
~QueuedLogMessage() = default; ~QueuedLogMessage() = default;
unsigned long id_; // Sequential identifier for this log message unsigned long id_; // Sequential identifier for this log message
struct timeval time_; // Time message was received struct timeval time_; // Time message was received
const std::shared_ptr<const uuid::log::Message> content_; // Log message content uint64_t uptime_;
uuid::log::Level level_;
const char * name_;
#ifndef EMSESP_STANDALONE
stringPSRAM text_;
#else
std::string text_;
#endif
}; };
void transmit(const QueuedLogMessage & message); void transmit(const QueuedLogMessage & message);
@@ -78,6 +81,7 @@ class WebLogService : public uuid::log::Handler {
unsigned long log_message_id_ = 0; // The next identifier to use for queued log messages unsigned long log_message_id_ = 0; // The next identifier to use for queued log messages
unsigned long log_message_id_tail_ = 0; // last event shown on the screen after fetch unsigned long log_message_id_tail_ = 0; // last event shown on the screen after fetch
bool compact_ = true; bool compact_ = true;
uuid::log::Level level_ = uuid::log::Level::INFO;
}; };
} // namespace emsesp } // namespace emsesp