log_sink.hpp

Go to the documentation of this file.

#pragma once
 
// Log sinks for <pulp/runtime/log.hpp>.
//
//   FileLogSink     - size-rotated log file in a private directory.
//   CaptureLogSink  - bounded in-memory record list for tests and tooling.
//   ScopedLogSink   - installs a sink for a scope and restores the previous one.
//
// Logging is not realtime-safe, and neither are these sinks: they allocate,
// take a mutex and (for files) perform I/O. Never log from the audio thread.
//
// Every sink here is a cheap shared handle. Copies refer to the same file or
// record list, so a copy can be installed with `set_log_sink` while the original
// stays available for inspection.
 
#include <pulp/runtime/log.hpp>
 
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::runtime {
 
struct FileLogSinkOptions {
    std::filesystem::path directory;

    std::string app_name = "pulp";

    std::string file_name = "pulp.log";

    std::uint64_t max_file_bytes = 1024 * 1024;

    int max_files = 5;

    LogLevel min_level = LogLevel::Info;
};

class FileLogSink {
  public:
    static std::optional<FileLogSink> open(FileLogSinkOptions options,
                                           std::string* error = nullptr);
 
    void write(LogLevel level, std::string_view category, std::string_view message) const;

    LogSink sink() const;
    operator LogSink() const {
        return sink();
    } // NOLINT: intentional conversion

    const std::filesystem::path& directory() const;
    std::filesystem::path path() const;

    std::filesystem::path rotated_path(int index) const;

    std::uint64_t dropped_count() const;
 
    class Impl;
 
  private:
    explicit FileLogSink(std::shared_ptr<Impl> impl) : impl_(std::move(impl)) {}
    std::shared_ptr<Impl> impl_;
};
 
struct LogRecord {
    LogLevel level = LogLevel::Info;
    std::string category;
    std::string message;
};

class CaptureLogSink {
  public:
    explicit CaptureLogSink(std::size_t max_records = 4096);
 
    void write(LogLevel level, std::string_view category, std::string_view message) const;
 
    LogSink sink() const;
    operator LogSink() const {
        return sink();
    } // NOLINT: intentional conversion

    std::vector<LogRecord> records() const;
    std::vector<LogRecord> records_at_least(LogLevel min_level) const;
    std::vector<LogRecord> take();
    void clear();
 
    std::size_t size() const;
    std::uint64_t dropped_count() const;
    bool contains(std::string_view needle) const;
 
    class Impl;
 
  private:
    std::shared_ptr<Impl> impl_;
};

class ScopedLogSink {
  public:
    explicit ScopedLogSink(LogSink sink) : previous_(set_log_sink(std::move(sink))) {}
    ~ScopedLogSink() {
        set_log_sink(std::move(previous_));
    }
 
    ScopedLogSink(const ScopedLogSink&) = delete;
    ScopedLogSink& operator=(const ScopedLogSink&) = delete;
 
  private:
    LogSink previous_;
};
 
} // namespace pulp::runtime