feat: add SD-backed stats archive and dedicated /stats web console
This commit is contained in:
Jared Dohrman
@@ -0,0 +1,889 @@
|
||||
#include "StatsHistory.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#if defined(ESP32)
|
||||
#include <esp_heap_caps.h>
|
||||
#endif
|
||||
|
||||
#ifndef ARCHIVE_DEBUG
|
||||
#if defined(MQTT_DEBUG) && MQTT_DEBUG
|
||||
#define ARCHIVE_DEBUG 1
|
||||
#else
|
||||
#define ARCHIVE_DEBUG 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if ARCHIVE_DEBUG
|
||||
#define ARCHIVE_LOG(fmt, ...) Serial.printf("[ARCHIVE] " fmt "\n", ##__VA_ARGS__)
|
||||
#else
|
||||
#define ARCHIVE_LOG(...) do { } while (0)
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr uint32_t kSummaryFlushIntervalMs = 5UL * 60UL * 1000UL;
|
||||
constexpr uint32_t kEventFlushIntervalMs = 60UL * 1000UL;
|
||||
constexpr size_t kMaxSeriesPoints = 64;
|
||||
constexpr size_t kSummaryRestoreWindowBytes = 16384;
|
||||
constexpr size_t kEventsRestoreWindowBytes = 4096;
|
||||
|
||||
struct HistoryCapacityBucket {
|
||||
size_t sample_capacity;
|
||||
size_t event_capacity;
|
||||
};
|
||||
|
||||
HistoryCapacityBucket getHistoryCapacityBucket(bool want_psram) {
|
||||
#if defined(ESP32)
|
||||
if (!want_psram) {
|
||||
return {96, 32};
|
||||
}
|
||||
|
||||
const uint32_t psram_size = ESP.getPsramSize();
|
||||
if (psram_size >= (8UL * 1024UL * 1024UL)) {
|
||||
return {720, 288};
|
||||
}
|
||||
if (psram_size >= (4UL * 1024UL * 1024UL)) {
|
||||
return {480, 192};
|
||||
}
|
||||
return {240, 96};
|
||||
#else
|
||||
(void)want_psram;
|
||||
return {96, 32};
|
||||
#endif
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
T* allocHistoryBuffer(size_t count) {
|
||||
#if defined(ESP32)
|
||||
if (psramFound()) {
|
||||
void* ptr = heap_caps_calloc(count, sizeof(T), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
|
||||
if (ptr != nullptr) {
|
||||
return static_cast<T*>(ptr);
|
||||
}
|
||||
}
|
||||
return static_cast<T*>(calloc(count, sizeof(T)));
|
||||
#else
|
||||
return static_cast<T*>(calloc(count, sizeof(T)));
|
||||
#endif
|
||||
}
|
||||
|
||||
void freeHistoryBuffer(void* ptr) {
|
||||
#if defined(ESP32)
|
||||
if (ptr != nullptr) {
|
||||
free(ptr);
|
||||
}
|
||||
#else
|
||||
free(ptr);
|
||||
#endif
|
||||
}
|
||||
|
||||
File openArchiveRead(FILESYSTEM* fs, const char* filename) {
|
||||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) || defined(RP2040_PLATFORM)
|
||||
return fs->open(filename, "r");
|
||||
#else
|
||||
return fs->open(filename, FILE_READ);
|
||||
#endif
|
||||
}
|
||||
|
||||
File openArchiveAppend(FILESYSTEM* fs, const char* filename) {
|
||||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) || defined(RP2040_PLATFORM)
|
||||
return fs->open(filename, "a");
|
||||
#else
|
||||
return fs->open(filename, FILE_APPEND, true);
|
||||
#endif
|
||||
}
|
||||
|
||||
File openArchiveWrite(FILESYSTEM* fs, const char* filename) {
|
||||
#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
|
||||
if (fs->exists(filename)) {
|
||||
fs->remove(filename);
|
||||
}
|
||||
return fs->open(filename, FILE_O_WRITE);
|
||||
#elif defined(RP2040_PLATFORM)
|
||||
return fs->open(filename, "w");
|
||||
#else
|
||||
if (fs->exists(filename)) {
|
||||
fs->remove(filename);
|
||||
}
|
||||
return fs->open(filename, FILE_WRITE);
|
||||
#endif
|
||||
}
|
||||
|
||||
File openArchiveReadWithRecovery(ArchiveStorage* archive, const char* filename) {
|
||||
if (archive == nullptr) {
|
||||
return File();
|
||||
}
|
||||
FILESYSTEM* fs = archive->getFS();
|
||||
if (fs == nullptr) {
|
||||
return File();
|
||||
}
|
||||
File file = openArchiveRead(fs, filename);
|
||||
if (file) {
|
||||
return file;
|
||||
}
|
||||
if (!archive->recover()) {
|
||||
return File();
|
||||
}
|
||||
fs = archive->getFS();
|
||||
return fs != nullptr ? openArchiveRead(fs, filename) : File();
|
||||
}
|
||||
|
||||
File openArchiveAppendWithRecovery(ArchiveStorage* archive, const char* filename) {
|
||||
if (archive == nullptr) {
|
||||
return File();
|
||||
}
|
||||
FILESYSTEM* fs = archive->getFS();
|
||||
if (fs == nullptr) {
|
||||
return File();
|
||||
}
|
||||
File file = openArchiveAppend(fs, filename);
|
||||
if (file) {
|
||||
return file;
|
||||
}
|
||||
if (!archive->recover()) {
|
||||
return File();
|
||||
}
|
||||
fs = archive->getFS();
|
||||
return fs != nullptr ? openArchiveAppend(fs, filename) : File();
|
||||
}
|
||||
|
||||
File openArchiveWriteWithRecovery(ArchiveStorage* archive, const char* filename) {
|
||||
if (archive == nullptr) {
|
||||
return File();
|
||||
}
|
||||
FILESYSTEM* fs = archive->getFS();
|
||||
if (fs == nullptr) {
|
||||
return File();
|
||||
}
|
||||
File file = openArchiveWrite(fs, filename);
|
||||
if (file) {
|
||||
return file;
|
||||
}
|
||||
if (!archive->recover()) {
|
||||
return File();
|
||||
}
|
||||
fs = archive->getFS();
|
||||
return fs != nullptr ? openArchiveWrite(fs, filename) : File();
|
||||
}
|
||||
|
||||
int buildPointValue(const HistorySample& sample, const HistorySample* previous, const char* series) {
|
||||
if (strcmp(series, "battery") == 0) {
|
||||
return static_cast<int>(sample.battery_mv);
|
||||
}
|
||||
if (strcmp(series, "memory") == 0) {
|
||||
return static_cast<int>(sample.heap_free);
|
||||
}
|
||||
if (strcmp(series, "signal") == 0) {
|
||||
return static_cast<int>(sample.last_rssi_x4);
|
||||
}
|
||||
if (strcmp(series, "packets") == 0) {
|
||||
if (previous == nullptr) {
|
||||
return 0;
|
||||
}
|
||||
const uint32_t curr_total = sample.packets_sent + sample.packets_recv;
|
||||
const uint32_t prev_total = previous->packets_sent + previous->packets_recv;
|
||||
return static_cast<int>(curr_total >= prev_total ? (curr_total - prev_total) : 0);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char* seriesTitle(const char* series) {
|
||||
if (strcmp(series, "battery") == 0) {
|
||||
return "Battery";
|
||||
}
|
||||
if (strcmp(series, "memory") == 0) {
|
||||
return "Heap Free";
|
||||
}
|
||||
if (strcmp(series, "packets") == 0) {
|
||||
return "Packet Activity";
|
||||
}
|
||||
if (strcmp(series, "signal") == 0) {
|
||||
return "Signal";
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
const char* seriesUnit(const char* series) {
|
||||
if (strcmp(series, "battery") == 0) {
|
||||
return "mV";
|
||||
}
|
||||
if (strcmp(series, "memory") == 0) {
|
||||
return "bytes";
|
||||
}
|
||||
if (strcmp(series, "packets") == 0) {
|
||||
return "pkts";
|
||||
}
|
||||
if (strcmp(series, "signal") == 0) {
|
||||
return "rssi_x4";
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
uint32_t sampleAgeSecs(const HistorySample& sample, uint32_t now_epoch_secs, uint32_t now_uptime_secs) {
|
||||
if (sample.epoch_secs > 0 && now_epoch_secs >= sample.epoch_secs) {
|
||||
return now_epoch_secs - sample.epoch_secs;
|
||||
}
|
||||
if (now_uptime_secs >= sample.uptime_secs) {
|
||||
return now_uptime_secs - sample.uptime_secs;
|
||||
}
|
||||
return sample.uptime_secs;
|
||||
}
|
||||
|
||||
uint8_t eventTypeFromName(const char* name) {
|
||||
if (name == nullptr || name[0] == 0) {
|
||||
return 0;
|
||||
}
|
||||
if (strcmp(name, "boot") == 0) return HISTORY_EVENT_BOOT;
|
||||
if (strcmp(name, "web_started") == 0) return HISTORY_EVENT_WEB_STARTED;
|
||||
if (strcmp(name, "web_stopped") == 0) return HISTORY_EVENT_WEB_STOPPED;
|
||||
if (strcmp(name, "mqtt_connected") == 0) return HISTORY_EVENT_MQTT_CONNECTED;
|
||||
if (strcmp(name, "mqtt_disconnected") == 0) return HISTORY_EVENT_MQTT_DISCONNECTED;
|
||||
if (strcmp(name, "archive_mounted") == 0) return HISTORY_EVENT_ARCHIVE_MOUNTED;
|
||||
if (strcmp(name, "archive_unavailable") == 0) return HISTORY_EVENT_ARCHIVE_UNAVAILABLE;
|
||||
if (strcmp(name, "low_memory") == 0) return HISTORY_EVENT_LOW_MEMORY;
|
||||
if (strcmp(name, "stats_enabled") == 0) return HISTORY_EVENT_STATS_ENABLED;
|
||||
if (strcmp(name, "stats_disabled") == 0) return HISTORY_EVENT_STATS_DISABLED;
|
||||
return 0;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
StatsHistory::StatsHistory()
|
||||
: _enabled(false), _psram_backed(false), _degraded(false), _summary_dirty(false), _next_summary_flush_ms(0),
|
||||
_next_event_flush_ms(0), _sample_capacity(0), _sample_head(0), _sample_count(0), _event_capacity(0),
|
||||
_event_head(0), _event_count(0), _samples(nullptr), _events(nullptr), _archive(nullptr), _restored_sample_count(0),
|
||||
_pending_event_count(0) {
|
||||
}
|
||||
|
||||
StatsHistory::~StatsHistory() {
|
||||
freeHistoryBuffer(_samples);
|
||||
freeHistoryBuffer(_events);
|
||||
}
|
||||
|
||||
void StatsHistory::begin(bool enabled, ArchiveStorage* archive) {
|
||||
_archive = archive;
|
||||
_enabled = enabled;
|
||||
ensureBuffers();
|
||||
if (_enabled && _sample_count == 0 && isArchiveAvailable()) {
|
||||
restoreSummaryLog();
|
||||
}
|
||||
_next_summary_flush_ms = millis() + kSummaryFlushIntervalMs;
|
||||
_next_event_flush_ms = millis() + kEventFlushIntervalMs;
|
||||
}
|
||||
|
||||
void StatsHistory::setArchive(ArchiveStorage* archive) {
|
||||
_archive = archive;
|
||||
}
|
||||
|
||||
void StatsHistory::setEnabled(bool enabled) {
|
||||
if (enabled && !ensureBuffers()) {
|
||||
_enabled = false;
|
||||
return;
|
||||
}
|
||||
_enabled = enabled;
|
||||
if (_enabled && _sample_count == 0 && isArchiveAvailable()) {
|
||||
restoreSummaryLog();
|
||||
}
|
||||
}
|
||||
|
||||
bool StatsHistory::isArchiveAvailable() const {
|
||||
return _archive != nullptr && _archive->isMounted();
|
||||
}
|
||||
|
||||
bool StatsHistory::ensureBuffers() {
|
||||
if (_samples != nullptr && _events != nullptr) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#if defined(ESP32)
|
||||
const bool want_psram = psramFound();
|
||||
#else
|
||||
const bool want_psram = false;
|
||||
#endif
|
||||
|
||||
const HistoryCapacityBucket bucket = getHistoryCapacityBucket(want_psram);
|
||||
_sample_capacity = bucket.sample_capacity;
|
||||
_event_capacity = bucket.event_capacity;
|
||||
_samples = allocHistoryBuffer<HistorySample>(_sample_capacity);
|
||||
_events = allocHistoryBuffer<HistoryEvent>(_event_capacity);
|
||||
_psram_backed = want_psram;
|
||||
_degraded = !want_psram;
|
||||
|
||||
if (_samples == nullptr || _events == nullptr) {
|
||||
freeHistoryBuffer(_samples);
|
||||
freeHistoryBuffer(_events);
|
||||
_samples = allocHistoryBuffer<HistorySample>(64);
|
||||
_events = allocHistoryBuffer<HistoryEvent>(24);
|
||||
_sample_capacity = (_samples != nullptr) ? 64 : 0;
|
||||
_event_capacity = (_events != nullptr) ? 24 : 0;
|
||||
_psram_backed = false;
|
||||
_degraded = true;
|
||||
}
|
||||
|
||||
return _samples != nullptr && _events != nullptr;
|
||||
}
|
||||
|
||||
void StatsHistory::storeSample(const HistorySample& sample, bool mark_dirty) {
|
||||
if (!ensureBuffers()) {
|
||||
return;
|
||||
}
|
||||
|
||||
_samples[_sample_head] = sample;
|
||||
_sample_head = (_sample_head + 1) % _sample_capacity;
|
||||
if (_sample_count < _sample_capacity) {
|
||||
_sample_count++;
|
||||
}
|
||||
if (mark_dirty) {
|
||||
_summary_dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool StatsHistory::parseSummaryLine(const char* line, HistorySample& sample) const {
|
||||
if (line == nullptr || line[0] == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned long epoch_secs = 0;
|
||||
unsigned long uptime_secs = 0;
|
||||
unsigned battery_mv = 0;
|
||||
unsigned queue_len = 0;
|
||||
int last_rssi_x4 = 0;
|
||||
int last_snr_x4 = 0;
|
||||
unsigned long packets_sent = 0;
|
||||
unsigned long packets_recv = 0;
|
||||
unsigned long heap_free = 0;
|
||||
unsigned long psram_free = 0;
|
||||
unsigned error_flags = 0;
|
||||
unsigned recv_errors = 0;
|
||||
unsigned neighbour_count = 0;
|
||||
unsigned direct_dups = 0;
|
||||
unsigned flood_dups = 0;
|
||||
unsigned flags = 0;
|
||||
|
||||
const int parsed = sscanf(line,
|
||||
"%lu,%lu,%u,%u,%d,%d,%lu,%lu,%lu,%lu,%u,%u,%u,%u,%u,%u",
|
||||
&epoch_secs,
|
||||
&uptime_secs,
|
||||
&battery_mv,
|
||||
&queue_len,
|
||||
&last_rssi_x4,
|
||||
&last_snr_x4,
|
||||
&packets_sent,
|
||||
&packets_recv,
|
||||
&heap_free,
|
||||
&psram_free,
|
||||
&error_flags,
|
||||
&recv_errors,
|
||||
&neighbour_count,
|
||||
&direct_dups,
|
||||
&flood_dups,
|
||||
&flags);
|
||||
if (parsed != 16) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memset(&sample, 0, sizeof(sample));
|
||||
sample.epoch_secs = static_cast<uint32_t>(epoch_secs);
|
||||
sample.uptime_secs = static_cast<uint32_t>(uptime_secs);
|
||||
sample.packets_sent = static_cast<uint32_t>(packets_sent);
|
||||
sample.packets_recv = static_cast<uint32_t>(packets_recv);
|
||||
sample.heap_free = static_cast<uint32_t>(heap_free);
|
||||
sample.heap_min = static_cast<uint32_t>(heap_free);
|
||||
sample.psram_free = static_cast<uint32_t>(psram_free);
|
||||
sample.psram_min = static_cast<uint32_t>(psram_free);
|
||||
sample.battery_mv = static_cast<uint16_t>(battery_mv);
|
||||
sample.queue_len = static_cast<uint16_t>(queue_len);
|
||||
sample.error_flags = static_cast<uint16_t>(error_flags);
|
||||
sample.recv_errors = static_cast<uint16_t>(recv_errors);
|
||||
sample.neighbour_count = static_cast<uint16_t>(neighbour_count);
|
||||
sample.direct_dups = static_cast<uint16_t>(direct_dups);
|
||||
sample.flood_dups = static_cast<uint16_t>(flood_dups);
|
||||
sample.last_rssi_x4 = static_cast<int16_t>(last_rssi_x4);
|
||||
sample.last_snr_x4 = static_cast<int16_t>(last_snr_x4);
|
||||
sample.flags = static_cast<uint8_t>(flags);
|
||||
sample.battery_pct = -1;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StatsHistory::restoreSummaryLog() {
|
||||
if (!isArchiveAvailable() || _sample_capacity == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
FILESYSTEM* fs = _archive->getFS();
|
||||
if (fs == nullptr || !fs->exists("/stats/summary.log")) {
|
||||
return false;
|
||||
}
|
||||
|
||||
File file = openArchiveReadWithRecovery(_archive, "/stats/summary.log");
|
||||
if (!file) {
|
||||
ARCHIVE_LOG("summary restore open failed path=%s", "/stats/summary.log");
|
||||
return false;
|
||||
}
|
||||
|
||||
_restored_sample_count = 0;
|
||||
const size_t size = static_cast<size_t>(file.size());
|
||||
const size_t start = (size > kSummaryRestoreWindowBytes) ? (size - kSummaryRestoreWindowBytes) : 0;
|
||||
if (start > 0 && !file.seek(start)) {
|
||||
file.close();
|
||||
return false;
|
||||
}
|
||||
|
||||
char line[192];
|
||||
size_t line_len = 0;
|
||||
bool skip_partial = (start > 0);
|
||||
while (file.available()) {
|
||||
const int raw = file.read();
|
||||
if (raw < 0) {
|
||||
break;
|
||||
}
|
||||
const char ch = static_cast<char>(raw);
|
||||
if (skip_partial) {
|
||||
if (ch == '\n') {
|
||||
skip_partial = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (ch == '\r') {
|
||||
continue;
|
||||
}
|
||||
if (ch == '\n') {
|
||||
line[line_len] = 0;
|
||||
HistorySample sample{};
|
||||
if (parseSummaryLine(line, sample)) {
|
||||
storeSample(sample, false);
|
||||
_restored_sample_count++;
|
||||
}
|
||||
line_len = 0;
|
||||
continue;
|
||||
}
|
||||
if (line_len + 1 < sizeof(line)) {
|
||||
line[line_len++] = ch;
|
||||
}
|
||||
}
|
||||
|
||||
if (!skip_partial && line_len > 0) {
|
||||
line[line_len] = 0;
|
||||
HistorySample sample{};
|
||||
if (parseSummaryLine(line, sample)) {
|
||||
storeSample(sample, false);
|
||||
_restored_sample_count++;
|
||||
}
|
||||
}
|
||||
|
||||
file.close();
|
||||
return _restored_sample_count > 0;
|
||||
}
|
||||
|
||||
bool StatsHistory::parseEventLine(const char* line, HistoryEvent& event) const {
|
||||
if (line == nullptr || line[0] == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
unsigned long epoch_secs = 0;
|
||||
unsigned long uptime_secs = 0;
|
||||
char type_name[32];
|
||||
int value = 0;
|
||||
memset(type_name, 0, sizeof(type_name));
|
||||
|
||||
const int parsed = sscanf(line, "%lu,%lu,%31[^,],%d", &epoch_secs, &uptime_secs, type_name, &value);
|
||||
if (parsed != 4) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const uint8_t type = eventTypeFromName(type_name);
|
||||
if (type == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
memset(&event, 0, sizeof(event));
|
||||
event.type = type;
|
||||
event.epoch_secs = static_cast<uint32_t>(epoch_secs);
|
||||
event.uptime_secs = static_cast<uint32_t>(uptime_secs);
|
||||
event.value = static_cast<int16_t>(value);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StatsHistory::restoreEventsLog() {
|
||||
if (!isArchiveAvailable() || _event_capacity == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
FILESYSTEM* fs = _archive->getFS();
|
||||
if (fs == nullptr || !fs->exists("/stats/events.log")) {
|
||||
return false;
|
||||
}
|
||||
|
||||
File file = openArchiveRead(fs, "/stats/events.log");
|
||||
if (!file) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const size_t size = static_cast<size_t>(file.size());
|
||||
const size_t start = (size > kEventsRestoreWindowBytes) ? (size - kEventsRestoreWindowBytes) : 0;
|
||||
if (start > 0 && !file.seek(start)) {
|
||||
file.close();
|
||||
return false;
|
||||
}
|
||||
|
||||
char line[160];
|
||||
size_t line_len = 0;
|
||||
bool skip_partial = (start > 0);
|
||||
while (file.available()) {
|
||||
const int raw = file.read();
|
||||
if (raw < 0) {
|
||||
break;
|
||||
}
|
||||
const char ch = static_cast<char>(raw);
|
||||
if (skip_partial) {
|
||||
if (ch == '\n') {
|
||||
skip_partial = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (ch == '\r') {
|
||||
continue;
|
||||
}
|
||||
if (ch == '\n') {
|
||||
line[line_len] = 0;
|
||||
HistoryEvent event{};
|
||||
if (parseEventLine(line, event)) {
|
||||
storeEvent(event, false);
|
||||
}
|
||||
line_len = 0;
|
||||
continue;
|
||||
}
|
||||
if (line_len + 1 < sizeof(line)) {
|
||||
line[line_len++] = ch;
|
||||
}
|
||||
}
|
||||
|
||||
if (!skip_partial && line_len > 0) {
|
||||
line[line_len] = 0;
|
||||
HistoryEvent event{};
|
||||
if (parseEventLine(line, event)) {
|
||||
storeEvent(event, false);
|
||||
}
|
||||
}
|
||||
|
||||
file.close();
|
||||
return _event_count > 0;
|
||||
}
|
||||
|
||||
void StatsHistory::pushSample(const HistorySample& sample) {
|
||||
if (!_enabled || !ensureBuffers()) {
|
||||
return;
|
||||
}
|
||||
storeSample(sample, true);
|
||||
}
|
||||
|
||||
void StatsHistory::appendPendingEvent(const HistoryEvent& event) {
|
||||
if (_pending_event_count < (sizeof(_pending_events) / sizeof(_pending_events[0]))) {
|
||||
_pending_events[_pending_event_count++] = event;
|
||||
return;
|
||||
}
|
||||
|
||||
memmove(&_pending_events[0], &_pending_events[1], sizeof(_pending_events) - sizeof(_pending_events[0]));
|
||||
_pending_events[(sizeof(_pending_events) / sizeof(_pending_events[0])) - 1] = event;
|
||||
}
|
||||
|
||||
void StatsHistory::storeEvent(const HistoryEvent& event, bool queue_pending) {
|
||||
if (!ensureBuffers()) {
|
||||
return;
|
||||
}
|
||||
|
||||
_events[_event_head] = event;
|
||||
_event_head = (_event_head + 1) % _event_capacity;
|
||||
if (_event_count < _event_capacity) {
|
||||
_event_count++;
|
||||
}
|
||||
|
||||
if (queue_pending) {
|
||||
appendPendingEvent(event);
|
||||
}
|
||||
}
|
||||
|
||||
void StatsHistory::recordEvent(uint8_t type, uint32_t epoch_secs, uint32_t uptime_secs, int16_t value) {
|
||||
if (!ensureBuffers()) {
|
||||
return;
|
||||
}
|
||||
|
||||
HistoryEvent event{};
|
||||
event.type = type;
|
||||
event.epoch_secs = epoch_secs;
|
||||
event.uptime_secs = uptime_secs;
|
||||
event.value = value;
|
||||
storeEvent(event, true);
|
||||
}
|
||||
|
||||
void StatsHistory::maybeFlush(uint32_t now_ms) {
|
||||
if (!_enabled || !isArchiveAvailable()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (_summary_dirty && (now_ms >= _next_summary_flush_ms || _pending_event_count >= 8)) {
|
||||
flushSummaryLog();
|
||||
_summary_dirty = false;
|
||||
_next_summary_flush_ms = now_ms + kSummaryFlushIntervalMs;
|
||||
}
|
||||
|
||||
if (_pending_event_count > 0 && now_ms >= _next_event_flush_ms) {
|
||||
flushEventsLog();
|
||||
_next_event_flush_ms = now_ms + kEventFlushIntervalMs;
|
||||
}
|
||||
}
|
||||
|
||||
void StatsHistory::flushSummaryLog() {
|
||||
if (_archive == nullptr || _sample_count == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
FILESYSTEM* fs = _archive->getFS();
|
||||
if (fs == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
HistorySample latest{};
|
||||
if (!getSampleFromOldest(_sample_count - 1, latest)) {
|
||||
return;
|
||||
}
|
||||
|
||||
File file = openArchiveAppendWithRecovery(_archive, "/stats/summary.log");
|
||||
if (!file) {
|
||||
ARCHIVE_LOG("summary open failed path=%s", "/stats/summary.log");
|
||||
return;
|
||||
}
|
||||
|
||||
char line[256];
|
||||
snprintf(line, sizeof(line),
|
||||
"%lu,%lu,%u,%u,%d,%d,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u\n",
|
||||
static_cast<unsigned long>(latest.epoch_secs),
|
||||
static_cast<unsigned long>(latest.uptime_secs),
|
||||
static_cast<unsigned>(latest.battery_mv),
|
||||
static_cast<unsigned>(latest.queue_len),
|
||||
static_cast<int>(latest.last_rssi_x4),
|
||||
static_cast<int>(latest.last_snr_x4),
|
||||
static_cast<unsigned>(latest.packets_sent),
|
||||
static_cast<unsigned>(latest.packets_recv),
|
||||
static_cast<unsigned>(latest.heap_free),
|
||||
static_cast<unsigned>(latest.psram_free),
|
||||
static_cast<unsigned>(latest.error_flags),
|
||||
static_cast<unsigned>(latest.recv_errors),
|
||||
static_cast<unsigned>(latest.neighbour_count),
|
||||
static_cast<unsigned>(latest.direct_dups),
|
||||
static_cast<unsigned>(latest.flood_dups),
|
||||
static_cast<unsigned>(latest.flags));
|
||||
const size_t written = file.print(line);
|
||||
file.flush();
|
||||
file.close();
|
||||
ARCHIVE_LOG("summary flushed path=%s bytes=%u sample_count=%u",
|
||||
"/stats/summary.log",
|
||||
static_cast<unsigned>(written),
|
||||
static_cast<unsigned>(_sample_count));
|
||||
writeMetaFile();
|
||||
}
|
||||
|
||||
void StatsHistory::flushEventsLog() {
|
||||
if (_archive == nullptr || _pending_event_count == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
FILESYSTEM* fs = _archive->getFS();
|
||||
if (fs == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
File file = openArchiveAppendWithRecovery(_archive, "/stats/events.log");
|
||||
if (!file) {
|
||||
ARCHIVE_LOG("events open failed path=%s", "/stats/events.log");
|
||||
return;
|
||||
}
|
||||
|
||||
size_t total_written = 0;
|
||||
for (size_t i = 0; i < _pending_event_count; ++i) {
|
||||
const HistoryEvent& event = _pending_events[i];
|
||||
char line[160];
|
||||
snprintf(line, sizeof(line),
|
||||
"%lu,%lu,%s,%d\n",
|
||||
static_cast<unsigned long>(event.epoch_secs),
|
||||
static_cast<unsigned long>(event.uptime_secs),
|
||||
getEventTypeName(event.type),
|
||||
static_cast<int>(event.value));
|
||||
total_written += file.print(line);
|
||||
}
|
||||
file.flush();
|
||||
file.close();
|
||||
ARCHIVE_LOG("events flushed path=%s bytes=%u count=%u",
|
||||
"/stats/events.log",
|
||||
static_cast<unsigned>(total_written),
|
||||
static_cast<unsigned>(_pending_event_count));
|
||||
_pending_event_count = 0;
|
||||
writeMetaFile();
|
||||
}
|
||||
|
||||
void StatsHistory::writeMetaFile() const {
|
||||
if (_archive == nullptr) {
|
||||
return;
|
||||
}
|
||||
FILESYSTEM* fs = _archive->getFS();
|
||||
if (fs == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
File file = openArchiveWriteWithRecovery(_archive, "/stats/meta.json");
|
||||
if (!file) {
|
||||
ARCHIVE_LOG("meta open failed path=%s", "/stats/meta.json");
|
||||
return;
|
||||
}
|
||||
|
||||
char json[256];
|
||||
snprintf(json, sizeof(json),
|
||||
"{\"logical\":\"%s\",\"path\":\"%s\",\"samples\":{\"count\":%u,\"capacity\":%u},"
|
||||
"\"events\":{\"count\":%u,\"capacity\":%u},\"psram\":%s,\"degraded\":%s}\n",
|
||||
_archive->getLogicalName(),
|
||||
_archive->getLogicalStatsPath(),
|
||||
static_cast<unsigned>(_sample_count),
|
||||
static_cast<unsigned>(_sample_capacity),
|
||||
static_cast<unsigned>(_event_count),
|
||||
static_cast<unsigned>(_event_capacity),
|
||||
_psram_backed ? "true" : "false",
|
||||
_degraded ? "true" : "false");
|
||||
const size_t written = file.print(json);
|
||||
file.flush();
|
||||
file.close();
|
||||
ARCHIVE_LOG("meta flushed path=%s bytes=%u",
|
||||
"/stats/meta.json",
|
||||
static_cast<unsigned>(written));
|
||||
}
|
||||
|
||||
bool StatsHistory::getSampleFromOldest(size_t index, HistorySample& sample) const {
|
||||
if (_samples == nullptr || index >= _sample_count) {
|
||||
return false;
|
||||
}
|
||||
const size_t oldest = (_sample_head + _sample_capacity - _sample_count) % _sample_capacity;
|
||||
const size_t slot = (oldest + index) % _sample_capacity;
|
||||
sample = _samples[slot];
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StatsHistory::buildSeriesJson(const char* series, char* buffer, size_t buffer_size, uint32_t now_epoch_secs, uint32_t now_uptime_secs) const {
|
||||
if (buffer == nullptr || buffer_size == 0 || series == nullptr) {
|
||||
return false;
|
||||
}
|
||||
buffer[0] = 0;
|
||||
if (seriesTitle(series)[0] == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (_sample_count == 0) {
|
||||
snprintf(buffer, buffer_size,
|
||||
"{\"series\":\"%s\",\"title\":\"%s\",\"unit\":\"%s\",\"interval_secs\":%lu,\"current\":0,\"oldest_age_secs\":0,\"latest_age_secs\":0,\"points\":[]}",
|
||||
series,
|
||||
seriesTitle(series),
|
||||
seriesUnit(series),
|
||||
static_cast<unsigned long>(kSampleIntervalSecs));
|
||||
return true;
|
||||
}
|
||||
|
||||
const size_t points = min(_sample_count, kMaxSeriesPoints);
|
||||
const size_t step = (_sample_count > kMaxSeriesPoints) ? ((_sample_count + kMaxSeriesPoints - 1) / kMaxSeriesPoints) : 1;
|
||||
|
||||
size_t offset = 0;
|
||||
HistorySample sample{};
|
||||
HistorySample previous{};
|
||||
bool have_previous = false;
|
||||
int current_value = 0;
|
||||
|
||||
offset += snprintf(&buffer[offset], buffer_size - offset,
|
||||
"{\"series\":\"%s\",\"title\":\"%s\",\"unit\":\"%s\",\"interval_secs\":%lu,\"current\":",
|
||||
series,
|
||||
seriesTitle(series),
|
||||
seriesUnit(series),
|
||||
static_cast<unsigned long>(kSampleIntervalSecs));
|
||||
|
||||
getSampleFromOldest(_sample_count - 1, sample);
|
||||
if (strcmp(series, "packets") == 0 && _sample_count >= 2) {
|
||||
getSampleFromOldest(_sample_count - 2, previous);
|
||||
current_value = buildPointValue(sample, &previous, series);
|
||||
} else {
|
||||
current_value = buildPointValue(sample, nullptr, series);
|
||||
}
|
||||
|
||||
size_t last_index = 0;
|
||||
for (size_t i = 0, emitted = 0; i < _sample_count && emitted < points; i += step, ++emitted) {
|
||||
last_index = i;
|
||||
}
|
||||
HistorySample oldest_sample{};
|
||||
HistorySample latest_emitted_sample{};
|
||||
const bool have_oldest_sample = getSampleFromOldest(0, oldest_sample);
|
||||
const bool have_latest_emitted_sample = getSampleFromOldest(last_index, latest_emitted_sample);
|
||||
const uint32_t oldest_age_secs = have_oldest_sample ? sampleAgeSecs(oldest_sample, now_epoch_secs, now_uptime_secs) : 0;
|
||||
const uint32_t latest_age_secs = have_latest_emitted_sample ? sampleAgeSecs(latest_emitted_sample, now_epoch_secs, now_uptime_secs) : 0;
|
||||
|
||||
offset += snprintf(&buffer[offset], buffer_size - offset,
|
||||
"%d,\"oldest_age_secs\":%lu,\"latest_age_secs\":%lu,\"points\":[",
|
||||
current_value,
|
||||
static_cast<unsigned long>(oldest_age_secs),
|
||||
static_cast<unsigned long>(latest_age_secs));
|
||||
|
||||
size_t emitted = 0;
|
||||
for (size_t i = 0; i < _sample_count && emitted < points; i += step, ++emitted) {
|
||||
if (!getSampleFromOldest(i, sample)) {
|
||||
break;
|
||||
}
|
||||
int value = buildPointValue(sample, have_previous ? &previous : nullptr, series);
|
||||
offset += snprintf(&buffer[offset], buffer_size - offset,
|
||||
"%s[%lu,%d]",
|
||||
emitted == 0 ? "" : ",",
|
||||
static_cast<unsigned long>(sample.uptime_secs),
|
||||
value);
|
||||
previous = sample;
|
||||
have_previous = true;
|
||||
if (offset + 24 >= buffer_size) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(&buffer[offset], buffer_size - offset, "]}");
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StatsHistory::getRecentEvent(size_t reverse_index, HistoryEvent& event) const {
|
||||
if (_events == nullptr || reverse_index >= _event_count) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const size_t newest = (_event_head + _event_capacity - 1) % _event_capacity;
|
||||
const size_t slot = (newest + _event_capacity - reverse_index) % _event_capacity;
|
||||
event = _events[slot];
|
||||
return true;
|
||||
}
|
||||
|
||||
const char* StatsHistory::getEventTypeName(uint8_t type) {
|
||||
switch (type) {
|
||||
case HISTORY_EVENT_BOOT:
|
||||
return "boot";
|
||||
case HISTORY_EVENT_WEB_STARTED:
|
||||
return "web_started";
|
||||
case HISTORY_EVENT_WEB_STOPPED:
|
||||
return "web_stopped";
|
||||
case HISTORY_EVENT_MQTT_CONNECTED:
|
||||
return "mqtt_connected";
|
||||
case HISTORY_EVENT_MQTT_DISCONNECTED:
|
||||
return "mqtt_disconnected";
|
||||
case HISTORY_EVENT_ARCHIVE_MOUNTED:
|
||||
return "archive_mounted";
|
||||
case HISTORY_EVENT_ARCHIVE_UNAVAILABLE:
|
||||
return "archive_unavailable";
|
||||
case HISTORY_EVENT_LOW_MEMORY:
|
||||
return "low_memory";
|
||||
case HISTORY_EVENT_STATS_ENABLED:
|
||||
return "stats_enabled";
|
||||
case HISTORY_EVENT_STATS_DISABLED:
|
||||
return "stats_disabled";
|
||||
default:
|
||||
return "unknown";
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user