mirror of
https://github.com/emsesp/EMS-ESP32.git
synced 2025-12-06 15:59:52 +03:00
274 lines
8.9 KiB
C++
274 lines
8.9 KiB
C++
/*
|
|
* EMS-ESP - https://github.com/emsesp/EMS-ESP
|
|
* Copyright 2020-2024 emsesp.org - proddy, MichaelDvP
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "emsesp.h"
|
|
|
|
using ::uuid::console::Shell;
|
|
|
|
namespace emsesp {
|
|
|
|
WebLogService::WebLogService(AsyncWebServer * server, SecurityManager * securityManager)
|
|
: events_(EMSESP_EVENT_SOURCE_LOG_PATH) {
|
|
// get & set settings
|
|
server->on(EMSESP_LOG_SETTINGS_PATH, [this](AsyncWebServerRequest * request, JsonVariant json) { getSetValues(request, json); });
|
|
|
|
// for bring back the whole log - is a command, hence a POST
|
|
server->on(EMSESP_FETCH_LOG_PATH, HTTP_POST, [this](AsyncWebServerRequest * request) { fetchLog(request); });
|
|
|
|
// events_.setFilter(securityManager->filterRequest(AuthenticationPredicates::IS_ADMIN));
|
|
server->addHandler(&events_);
|
|
}
|
|
|
|
// start the log service with INFO level
|
|
void WebLogService::begin() {
|
|
uuid::log::Logger::register_handler(this, uuid::log::Level::INFO);
|
|
}
|
|
|
|
// apply the user settings
|
|
void WebLogService::start() {
|
|
EMSESP::webSettingsService.read([&](WebSettings & settings) {
|
|
maximum_log_messages_ = settings.weblog_buffer;
|
|
limit_log_messages_ = maximum_log_messages_;
|
|
compact_ = settings.weblog_compact;
|
|
uuid::log::Logger::register_handler(this, (uuid::log::Level)settings.weblog_level);
|
|
if ((uuid::log::Level)settings.weblog_level == uuid::log::Level::OFF) {
|
|
log_messages_.clear();
|
|
}
|
|
});
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
size_t WebLogService::num_log_messages() const {
|
|
return log_messages_.size();
|
|
}
|
|
|
|
size_t WebLogService::maximum_log_messages() const {
|
|
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)
|
|
, content_(std::move(content)) {
|
|
}
|
|
|
|
void WebLogService::operator<<(std::shared_ptr<uuid::log::Message> message) {
|
|
#ifndef EMSESP_STANDALONE
|
|
size_t maxAlloc = ESP.getMaxAllocHeap();
|
|
if (limit_log_messages_ > 5 && maxAlloc < 46080) {
|
|
--limit_log_messages_;
|
|
} else if (limit_log_messages_ < maximum_log_messages_ && maxAlloc > 51200) {
|
|
++limit_log_messages_;
|
|
}
|
|
#endif
|
|
while (log_messages_.size() >= limit_log_messages_) {
|
|
log_messages_.pop_front();
|
|
}
|
|
|
|
log_messages_.emplace_back(++log_message_id_, std::move(message));
|
|
|
|
EMSESP::esp8266React.getNTPSettingsService()->read([&](NTPSettings & settings) {
|
|
if (!settings.enabled || (time(nullptr) < 1500000000L)) {
|
|
time_offset_ = 0;
|
|
} else {
|
|
uint32_t offset = time(nullptr) - uuid::get_uptime_sec();
|
|
// if NTP is more that 1 sec apart, correct setting
|
|
if (time_offset_ < offset - 1 || time_offset_ > offset + 1) {
|
|
time_offset_ = offset;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// dumps out the contents of log buffer to shell console
|
|
void WebLogService::show(Shell & shell) {
|
|
if (log_messages_.empty()) {
|
|
return;
|
|
}
|
|
|
|
shell.println();
|
|
shell.printfln("Last Log (filtered by WebLog's level %s & buffer %d):", format_level_uppercase(log_level()), maximum_log_messages());
|
|
shell.println();
|
|
|
|
for (const auto & message : log_messages_) {
|
|
log_message_id_tail_ = message.id_;
|
|
|
|
shell.print(uuid::log::format_timestamp_ms(message.content_->uptime_ms, 3));
|
|
shell.printf(" %c %lu: [%s] ", uuid::log::format_level_char(message.content_->level), message.id_, message.content_->name);
|
|
|
|
if ((message.content_->level == uuid::log::Level::ERR) || (message.content_->level == uuid::log::Level::WARNING)) {
|
|
shell.print(COLOR_RED);
|
|
shell.println(message.content_->text);
|
|
shell.print(COLOR_RESET);
|
|
} else if (message.content_->level == uuid::log::Level::INFO) {
|
|
shell.print(COLOR_YELLOW);
|
|
shell.println(message.content_->text);
|
|
shell.print(COLOR_RESET);
|
|
} else if (message.content_->level == uuid::log::Level::DEBUG) {
|
|
shell.print(COLOR_CYAN);
|
|
shell.println(message.content_->text);
|
|
shell.print(COLOR_RESET);
|
|
} else {
|
|
shell.println(message.content_->text);
|
|
}
|
|
}
|
|
|
|
shell.println();
|
|
}
|
|
|
|
void WebLogService::loop() {
|
|
if (!events_.count() || log_messages_.empty()) {
|
|
return;
|
|
}
|
|
|
|
// see if we've advanced
|
|
if (log_messages_.back().id_ <= log_message_id_tail_) {
|
|
return;
|
|
}
|
|
|
|
// put a small delay in
|
|
if (uuid::get_uptime_ms() - last_transmit_ < REFRESH_SYNC) {
|
|
return;
|
|
}
|
|
last_transmit_ = uuid::get_uptime_ms();
|
|
|
|
// flush
|
|
for (const auto & message : log_messages_) {
|
|
if (message.id_ > log_message_id_tail_) {
|
|
log_message_id_tail_ = message.id_;
|
|
transmit(message);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// convert time to real offset
|
|
char * WebLogService::messagetime(char * out, const uint64_t t, const size_t bufsize) {
|
|
if (!time_offset_) {
|
|
strlcpy(out, uuid::log::format_timestamp_ms(t, 3).c_str(), bufsize);
|
|
} else {
|
|
time_t t1 = time_offset_ + t / 1000ULL;
|
|
char timestr[bufsize];
|
|
strftime(timestr, bufsize, "%F %T", localtime(&t1));
|
|
snprintf(out, bufsize, "%s.%03d", timestr, (uint16_t)(t % 1000));
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// send to web eventsource
|
|
void WebLogService::transmit(const QueuedLogMessage & message) {
|
|
JsonDocument jsonDocument;
|
|
|
|
JsonObject logEvent = jsonDocument.to<JsonObject>();
|
|
char time_string[25];
|
|
|
|
logEvent["t"] = messagetime(time_string, message.content_->uptime_ms, sizeof(time_string));
|
|
logEvent["l"] = message.content_->level;
|
|
logEvent["i"] = message.id_;
|
|
logEvent["n"] = message.content_->name;
|
|
logEvent["m"] = message.content_->text;
|
|
|
|
size_t len = measureJson(jsonDocument);
|
|
char * buffer = new char[len + 1];
|
|
if (buffer) {
|
|
serializeJson(jsonDocument, buffer, len + 1);
|
|
events_.send(buffer, "message", message.id_);
|
|
}
|
|
delete[] buffer;
|
|
}
|
|
|
|
// send the complete log buffer to the API, not filtering on log level
|
|
// done by resetting the pointer
|
|
void WebLogService::fetchLog(AsyncWebServerRequest * request) {
|
|
log_message_id_tail_ = 0;
|
|
request->send(200);
|
|
}
|
|
|
|
// sets the values after a POST
|
|
void WebLogService::getSetValues(AsyncWebServerRequest * request, JsonVariant json) {
|
|
if ((request->method() == HTTP_GET) || (!json.is<JsonObject>())) {
|
|
// GET - return the values
|
|
auto * response = new AsyncJsonResponse(false);
|
|
JsonObject root = response->getRoot();
|
|
root["level"] = log_level();
|
|
root["max_messages"] = maximum_log_messages();
|
|
root["compact"] = compact();
|
|
root["psram"] = (EMSESP::system_.PSram() > 0);
|
|
|
|
response->setLength();
|
|
request->send(response);
|
|
return;
|
|
}
|
|
|
|
auto && body = json.as<JsonObject>();
|
|
|
|
uuid::log::Level level = body["level"];
|
|
log_level(level);
|
|
|
|
uint8_t max_messages = body["max_messages"];
|
|
maximum_log_messages(max_messages);
|
|
|
|
bool comp = body["compact"];
|
|
compact(comp);
|
|
|
|
request->send(200); // OK
|
|
}
|
|
|
|
} // namespace emsesp
|