logBuffer.cpp

#include "logBuffer.h"
#include "logShipper.h" // optional remote log push (no-op unless configured)

LogBuffer Log;

static const size_t LOG_RING_SIZE = 6144;
static char ring[LOG_RING_SIZE];
static size_t head = 0; // next write position
static bool wrapped = false;
static bool atLineStart = true;
static volatile uint32_t lineVersion = 0;
static volatile uint32_t bytesWritten = 0;

// Spinlock, not a FreeRTOS mutex: writes come from both cores and must also
// work before the logger has been "begun" (there is no begin - static init
// covers everything).
static portMUX_TYPE logMux = portMUX_INITIALIZER_UNLOCKED;

static inline void ringPut(char c)
{
    ring[head] = c;
    head = (head + 1) % LOG_RING_SIZE;
    if (head == 0) wrapped = true;
}

// UTC epoch minus uptime seconds, set after the first NTP sync. Lines are
// stamped with real time-of-day (suffix Z) once known; plain uptime before.
// Word-sized so the lock-free read in ringWrite below is atomic.
static volatile uint32_t wallClockOffset = 0;

void logSetWallClock(uint32_t utcEpochNow)
{
    wallClockOffset = utcEpochNow - millis() / 1000UL;
}

// Callers hold logMux. CRs are dropped and each line gets a timestamp so
// entries can be correlated without a serial monitor attached. No ezTime
// calls here - this runs from both cores inside a spinlock, so the wall
// clock is plain arithmetic on the cached offset.
static void ringWrite(const uint8_t *buffer, size_t size)
{
    for (size_t i = 0; i < size; i++)
    {
        char c = (char)buffer[i];
        if (c == '\r') continue;
        if (atLineStart && c != '\n')
        {
            char stamp[14];
            unsigned long s = millis() / 1000UL;
            uint32_t off = wallClockOffset;
            if (off != 0)
            {
                uint32_t t = off + s;
                snprintf(stamp, sizeof(stamp), "[%02lu:%02lu:%02luZ] ",
                         (unsigned long)((t / 3600UL) % 24UL),
                         (unsigned long)((t / 60UL) % 60UL),
                         (unsigned long)(t % 60UL));
            }
            else
            {
                snprintf(stamp, sizeof(stamp), "[%02lu:%02lu:%02lu] ",
                         (s / 3600UL) % 100UL, (s / 60UL) % 60UL, s % 60UL);
            }
            for (const char *p = stamp; *p; p++) ringPut(*p);
            atLineStart = false;
        }
        if (c == '\n')
        {
            atLineStart = true;
            lineVersion = lineVersion + 1;
        }
        ringPut(c);
    }
}

size_t LogBuffer::write(uint8_t c)
{
    return write(&c, 1);
}

size_t LogBuffer::write(const uint8_t *buffer, size_t size)
{
    // Serial first (it may block on a full TX buffer - do that outside the
    // spinlock), then the ring.
    size_t n = Serial.write(buffer, size);
    portENTER_CRITICAL(&logMux);
    ringWrite(buffer, size);
    bytesWritten = bytesWritten + size;
    portEXIT_CRITICAL(&logMux);
    // Tee into the remote-shipping queue (its own lock; never nested with
    // logMux, and a no-op when LOG_PUSH_URL isn't configured).
    logShipperFeed(buffer, size);
    return n;
}

uint32_t logVersion()
{
    return lineVersion; // 32-bit reads are atomic on the ESP32
}

uint32_t logBytesWritten()
{
    return bytesWritten;
}

String logTail(size_t maxBytes)
{
    if (maxBytes > LOG_RING_SIZE) maxBytes = LOG_RING_SIZE;

    // Allocate outside the critical section (heap ops must not run with
    // interrupts disabled), memcpy inside it.
    char *tmp = (char *)malloc(maxBytes + 1);
    if (!tmp) return String();

    portENTER_CRITICAL(&logMux);
    size_t avail = wrapped ? LOG_RING_SIZE : head;
    size_t want = (maxBytes < avail) ? maxBytes : avail;
    size_t start = (head + LOG_RING_SIZE - want) % LOG_RING_SIZE;
    for (size_t i = 0; i < want; i++)
    {
        tmp[i] = ring[(start + i) % LOG_RING_SIZE];
    }
    bool clipped = (want < avail) || wrapped;
    portEXIT_CRITICAL(&logMux);
    tmp[want] = '\0';

    // If the snapshot starts mid-line, drop the partial first line.
    char *text = tmp;
    if (clipped)
    {
        char *nl = strchr(tmp, '\n');
        if (nl && *(nl + 1) != '\0') text = nl + 1;
    }

    String out(text);
    free(tmp);
    return out;
}