log.h

/*
 * uuid-log - Microcontroller logging framework
 * Copyright 2019,2021-2024  Simon Arlott
 *
 * 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/>.
 */
 
#ifndef UUID_LOG_H_
#define UUID_LOG_H_
 
#include <Arduino.h>
 
#include <algorithm>
#include <atomic>
#include <cstdarg>
#include <cstdint>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include <uuid/common.h>
 
#ifndef UUID_COMMON_THREAD_SAFE
# define UUID_COMMON_THREAD_SAFE 0
#endif
 
#ifndef UUID_COMMON_STD_MUTEX_AVAILABLE
# define UUID_COMMON_STD_MUTEX_AVAILABLE 0
#endif
 
#if defined(DOXYGEN) || UUID_COMMON_STD_MUTEX_AVAILABLE
# define UUID_LOG_THREAD_SAFE 1
#else
# define UUID_LOG_THREAD_SAFE 0
#endif
 
#if UUID_LOG_THREAD_SAFE
# include <mutex>
#endif
 
namespace uuid {
 
namespace log {
 
#if UUID_COMMON_THREAD_SAFE && UUID_LOG_THREAD_SAFE
static constexpr bool thread_safe = true;
#else
static constexpr bool thread_safe = false;
#endif
 
enum Level : int8_t {
    OFF = -1, 
    EMERG = 0, 
    ALERT, 
    CRIT, 
    ERR, 
    WARNING, 
    NOTICE, 
    INFO, 
    DEBUG, 
    TRACE, 
    ALL, 
};
 
enum Facility : uint8_t {
    KERN = 0, 
    USER, 
    MAIL, 
    DAEMON, 
    AUTH, 
    SYSLOG, 
    LPR, 
    NEWS, 
    UUCP, 
    CRON, 
    AUTHPRIV, 
    FTP, 
    NTP, 
    SECURITY, 
    CONSOLE, 
    CRON2, 
    LOCAL0, 
    LOCAL1, 
    LOCAL2, 
    LOCAL3, 
    LOCAL4, 
    LOCAL5, 
    LOCAL6, 
    LOCAL7, 
};
 
std::string format_timestamp_ms(uint64_t timestamp_ms, unsigned int days_width = 1);
 
std::vector<Level> levels();
 
char format_level_char(Level level);
 
const __FlashStringHelper *format_level_uppercase(Level level);
 
std::vector<std::string> levels_uppercase();
 
bool parse_level_uppercase(const std::string &name, Level &level);
 
const __FlashStringHelper *format_level_lowercase(Level level);
 
std::vector<std::string> levels_lowercase();
 
bool parse_level_lowercase(const std::string &name, Level &level);
 
struct Message {
    Message(uint64_t uptime_ms, Level level, Facility facility, const __FlashStringHelper *name, const std::string &&text);
    ~Message() = default;
 
    const uint64_t uptime_ms;
 
    const Level level;
 
    const Facility facility;
 
    const __FlashStringHelper *name;
 
    const std::string text;
};
 
class Logger;
 
class Handler {
    friend Logger;
public:
    virtual ~Handler();
 
    virtual void operator<<(std::shared_ptr<Message> message) = 0;
 
protected:
    Handler() = default;
 
private:
    std::weak_ptr<std::map<Handler*,Level>> handlers_;
};
 
class Logger {
public:
    static constexpr size_t MAX_LOG_LENGTH = 255;
 
    explicit Logger(const __FlashStringHelper *name, Facility facility = Facility::LOCAL0);
    ~Logger() = default;
 
    static void register_handler(Handler *handler, Level level);
 
    static void unregister_handler(Handler *handler);
 
    static Level get_log_level(const Handler *handler);
 
    static Level global_level() { return global_level_; };
 
    inline bool enabled(Level level) const { return level <= global_level_ && level <= local_level_; }
 
    inline Facility facility() const { return facility_; }
 
    inline Level level() const { return local_level_; }
 
    inline void level(Level level) { local_level_ = level; }
 
    Level effective_level() const { return std::min(global_level(), local_level_); };
 
    void emerg(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void emerg(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void alert(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void alert(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void crit(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void crit(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void err(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void err(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void warning(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void warning(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void notice(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void notice(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void info(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void info(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void debug(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void debug(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void trace(const char *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
    void trace(const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 2, 3))) */;
 
    void log(Level level, const char *format, ...) const /* __attribute__((format (printf, 3, 4))) */;
    void log(Level level, const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 3, 4))) */;
 
    void log(Level level, Facility facility, const char *format, ...) const /* __attribute__((format (printf, 4, 5))) */;
    void log(Level level, Facility facility, const __FlashStringHelper *format, ...) const /* __attribute__((format (printf, 4, 5))) */;
 
    void vlog(Level level, const char *format, va_list ap) const;
    void vlog(Level level, const __FlashStringHelper *format, va_list ap) const;
 
    void vlog(Level level, Facility facility, const char *format, va_list ap) const;
    void vlog(Level level, Facility facility, const __FlashStringHelper *format, va_list ap) const;
 
    void logp(Level level, const char *text) const;
    void logp(Level level, Facility facility, const char *text) const;
 
private:
    void vlog_internal(Level level, Facility facility, const char *format, va_list ap) const;
    void vlog_internal(Level level, Facility facility, const __FlashStringHelper *format, va_list ap) const;
 
    static void refresh_log_level();
    static std::shared_ptr<std::map<Handler*,Level>>& registered_handlers();
 
    void dispatch(Level level, Facility facility, std::vector<char> &text) const;
 
    void dispatch(const std::shared_ptr<Message> &message) const;
 
    static std::atomic<Level> global_level_; 
#if UUID_LOG_THREAD_SAFE
    static std::mutex mutex_; 
#endif
 
    const __FlashStringHelper *name_; 
    const Facility facility_; 
    Level local_level_{Level::ALL}; 
};
 
class PrintHandler: public uuid::log::Handler {
public:
    static constexpr size_t MAX_LOG_MESSAGES = 50; 
    explicit PrintHandler(Print &print);
    ~PrintHandler() = default;
 
    size_t maximum_log_messages() const;
    void maximum_log_messages(size_t count);
 
    void loop(size_t count = SIZE_MAX);
 
    void operator<<(std::shared_ptr<Message> message) override;
 
private:
    Print &print_; 
#if UUID_LOG_THREAD_SAFE
    mutable std::mutex mutex_; 
#endif
    size_t maximum_log_messages_ = MAX_LOG_MESSAGES; 
    std::list<std::shared_ptr<Message>> log_messages_; 
};
 
} // namespace log
 
} // namespace uuid
 
#endif