syslog.h

/*
 * uuid-syslog - Microcontroller syslog service
 * Copyright 2019,2021-2022  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_SYSLOG_H_
#define UUID_SYSLOG_H_
 
#include <Arduino.h>
#ifdef ARDUINO_ARCH_ESP8266
# include <ESP8266WiFi.h>
#else
# include <WiFi.h>
#endif
#include <WiFiUdp.h>
#include <time.h>
 
#include <list>
#include <memory>
#include <string>
 
#include <uuid/log.h>
 
#ifndef UUID_LOG_THREAD_SAFE
# define UUID_LOG_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_SYSLOG_THREAD_SAFE 1
#else
# define UUID_SYSLOG_THREAD_SAFE 0
#endif
 
#if UUID_LOG_THREAD_SAFE
# include <mutex>
#endif
 
namespace uuid {
 
namespace syslog {
 
#if UUID_COMMON_THREAD_SAFE && UUID_LOG_THREAD_SAFE && UUID_SYSLOG_THREAD_SAFE
static constexpr bool thread_safe = true;
#else
static constexpr bool thread_safe = false;
#endif
 
class SyslogService: public uuid::log::Handler {
public:
    static constexpr size_t MAX_LOG_MESSAGES = 50; 
    static constexpr uint16_t DEFAULT_PORT = 514; 
    SyslogService() = default;
    ~SyslogService() = default;
 
    void start();
 
    uuid::log::Level log_level() const;
    void log_level(uuid::log::Level level);
 
    size_t maximum_log_messages() const;
    void maximum_log_messages(size_t count);
 
    size_t current_log_messages() const;
 
    std::pair<IPAddress,uint16_t> destination() const;
    void destination(IPAddress host, uint16_t port = DEFAULT_PORT);
 
    std::string hostname() const;
    void hostname(std::string hostname);
 
    unsigned long mark_interval() const;
    void mark_interval(unsigned long interval);
 
    void loop();
 
    void operator<<(std::shared_ptr<uuid::log::Message> message) override;
 
private:
    class QueuedLogMessage {
    public:
        QueuedLogMessage(unsigned long id, std::shared_ptr<uuid::log::Message> &&content);
        ~QueuedLogMessage() = default;
 
        unsigned long id_; 
        struct timeval time_; 
        std::shared_ptr<const uuid::log::Message> content_; 
    private:
        static bool time_good_; 
    };
 
    void add_message(std::shared_ptr<uuid::log::Message> &message);
 
    void remove_queued_messages(uuid::log::Level level);
 
    bool can_transmit();
 
    bool transmit(const QueuedLogMessage &message);
 
    static uuid::log::Logger logger_; 
    bool started_ = false; 
    bool level_set_ = false; 
    WiFiUDP udp_; 
    IPAddress host_; 
    uint16_t port_ = DEFAULT_PORT; 
    uint64_t last_transmit_ = 0; 
    std::string hostname_{'-'}; 
#if UUID_SYSLOG_THREAD_SAFE
    mutable std::mutex mutex_; 
#endif
    size_t maximum_log_messages_ = MAX_LOG_MESSAGES; 
    unsigned long log_message_id_ = 0; 
    std::list<QueuedLogMessage> log_messages_; 
    uint64_t mark_interval_ = 0; 
    uint64_t last_message_ = 0; 
};
 
} // namespace syslog
 
} // namespace uuid
 
#endif