logging.cpp

#include "logging.h"

#include <QCoreApplication>
#include <QDateTime>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QMutex>
#include <QMutexLocker>
#include <QSettings>
#include <QStandardPaths>
#include <QSysInfo>
#include <QTextStream>

namespace {

// One rotation, so the log is bounded at ~1 MB total without needing a cleanup
// policy.  Big enough to cover a long session and still hold the startup lines
// that say which tracking backend was chosen; small enough to paste from.
constexpr qint64 k_maxBytes = 512 * 1024;
constexpr int    k_maxTailLines = 2000;   // ceiling on a tail() request

QMutex           g_mutex;
QFile*           g_file    = nullptr;     // owned; null when closed
QtMessageHandler g_previous = nullptr;
bool             g_enabled = true;
bool             g_installed = false;

QString settingsKey() { return QStringLiteral("diagnostics/logging"); }

QString dirPathLocked()
{
    QString base = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
    if (base.isEmpty())                    // no writable app-data location
        base = QDir::tempPath() + QStringLiteral("/TrackClick");
    return base + QStringLiteral("/logs");
}

QString filePathLocked()
{
    return dirPathLocked() + QStringLiteral("/trackclick.log");
}

// The single rotated predecessor.
QString rotatedPathLocked()
{
    return filePathLocked() + QStringLiteral(".1");
}

void closeFileLocked()
{
    delete g_file;
    g_file = nullptr;
}

// Open the log for appending, creating the directory if needed.  Returns false
// and leaves g_file null when the location is not writable — logging then
// degrades to "forwarded to the default handler only" rather than failing.
bool openFileLocked()
{
    if (g_file)
        return true;
    if (!QDir().mkpath(dirPathLocked()))
        return false;

    auto* f = new QFile(filePathLocked());
    if (!f->open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) {
        delete f;
        return false;
    }
    g_file = f;
    return true;
}

void rotateIfNeededLocked()
{
    if (!g_file || g_file->size() < k_maxBytes)
        return;
    closeFileLocked();
    QFile::remove(rotatedPathLocked());
    QFile::rename(filePathLocked(), rotatedPathLocked());
    openFileLocked();
}

char levelChar(QtMsgType type)
{
    switch (type) {
        case QtDebugMsg:    return 'D';
        case QtInfoMsg:     return 'I';
        case QtWarningMsg:  return 'W';
        case QtCriticalMsg: return 'C';
        case QtFatalMsg:    return 'F';
    }
    return '?';
}

void writeLineLocked(const QString& line)
{
    if (!openFileLocked())
        return;
    rotateIfNeededLocked();
    if (!g_file)
        return;
    QTextStream out(g_file);
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    out.setEncoding(QStringConverter::Utf8);
#else
    out.setCodec("UTF-8");
#endif
    out << line << '\n';
    // Two flushes, and both are needed.  QTextStream::flush() only pushes its own
    // buffer into the QFile; QFile::flush() is what pushes the file engine's
    // buffer out to the OS.  Without the second one the bytes are invisible to
    // anything that stats the path separately — which is exactly what
    // sizeBytes() does, so rotation would trigger late or never.
    out.flush();
    g_file->flush();
    // Flushed per line on purpose: the messages worth having are the ones written
    // just before something goes wrong, and a buffered tail is exactly what gets
    // lost if the app is killed or crashes.  Volume here is a handful of lines
    // per session, so the cost is irrelevant.
}

void messageHandler(QtMsgType type, const QMessageLogContext& ctx, const QString& msg)
{
    // Forward first and unconditionally: a developer running from a terminal, and
    // qFatal's abort behaviour, must both survive this handler existing.
    if (g_previous)
        g_previous(type, ctx, msg);

    // A failure inside our own write path (QFile reporting an error, say) would
    // re-enter the handler and recurse.  One flag per thread breaks that without
    // serialising the check.
    static thread_local bool reentering = false;
    if (reentering)
        return;
    reentering = true;

    {
        QMutexLocker lock(&g_mutex);
        if (g_enabled) {
            QString line = QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss.zzz");
            line += QStringLiteral(" [");
            line += QLatin1Char(levelChar(type));
            line += QStringLiteral("] ");
            // Category is "default" for plain qWarning() calls — only worth
            // printing once the codebase starts using QLoggingCategory.
            if (ctx.category && qstrcmp(ctx.category, "default") != 0)
                line += QLatin1Char('[') + QString::fromUtf8(ctx.category) + QStringLiteral("] ");
            line += msg;
            writeLineLocked(line);
        }
    }

    reentering = false;
}

} // namespace

namespace logging {

void install()
{
    QMutexLocker lock(&g_mutex);
    if (g_installed)
        return;

    {
        // Off unless the user asked for it.  The cost is that a first bug report
        // never carries a log — the user has to switch it on and reproduce — but
        // an accessibility tool that already trips AV heuristics (§1) should not
        // also start writing files nobody asked for.
        QSettings s;
        g_enabled = s.value(settingsKey(), false).toBool();
    }

    g_previous  = qInstallMessageHandler(messageHandler);
    g_installed = true;

    if (!g_enabled)
        return;

    // Header on every launch, so a pasted log says what produced it without the
    // user having to also report their version and platform.
    writeLineLocked(QString());
    writeLineLocked(QStringLiteral("=== TrackClick %1 starting — %2 / %3 ===")
                        .arg(QCoreApplication::applicationVersion(),
                             QSysInfo::prettyProductName(),
                             QSysInfo::currentCpuArchitecture()));
}

bool isEnabled()
{
    QMutexLocker lock(&g_mutex);
    return g_enabled;
}

void setEnabled(bool on)
{
    QMutexLocker lock(&g_mutex);
    if (on == g_enabled)
        return;
    g_enabled = on;
    {
        QSettings s;
        s.setValue(settingsKey(), on);
    }
    // writeLineLocked() does not consult g_enabled, so the "stopping" line still
    // reaches the file — a log that just ends is indistinguishable from one that
    // was truncated by a crash.
    if (on) {
        writeLineLocked(QStringLiteral("=== logging enabled ==="));
    } else {
        writeLineLocked(QStringLiteral("=== logging disabled by user ==="));
        closeFileLocked();
    }
}

QString filePath()
{
    QMutexLocker lock(&g_mutex);
    return filePathLocked();
}

QString dirPath()
{
    QMutexLocker lock(&g_mutex);
    return dirPathLocked();
}

qint64 sizeBytes()
{
    QMutexLocker lock(&g_mutex);
    return QFileInfo(filePathLocked()).size();   // 0 when absent
}

QString tail(int maxLines)
{
    if (maxLines <= 0)
        return QString();
    maxLines = qMin(maxLines, k_maxTailLines);

    QMutexLocker lock(&g_mutex);
    // Push anything still buffered out first, so the tail really is the tail —
    // this reads the path rather than the open handle.
    if (g_file)
        g_file->flush();

    QFile f(filePathLocked());
    if (!f.open(QIODevice::ReadOnly | QIODevice::Text))
        return QString();

    // Read the whole file: it is capped at k_maxBytes, so this is bounded and far
    // simpler than seeking backwards for line breaks.
    QTextStream in(&f);
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    in.setEncoding(QStringConverter::Utf8);
#else
    in.setCodec("UTF-8");
#endif
    QStringList lines;
    while (!in.atEnd()) {
        lines.append(in.readLine());
        if (lines.size() > maxLines)
            lines.removeFirst();
    }
    return lines.join(QLatin1Char('\n'));
}

void clear()
{
    QMutexLocker lock(&g_mutex);
    closeFileLocked();
    QFile::remove(rotatedPathLocked());
    QFile::remove(filePathLocked());
    if (g_enabled)
        writeLineLocked(QStringLiteral("=== log cleared ==="));
}

} // namespace logging