residue.h

//
//  residue.h
//
//  Official C++ client library for Residue logging server
//
//  Copyright (C) 2017-present Muflihun Labs
//  Copyright (C) 2017-present @abumusamq
//
//  https://muflihun.com/
//  https://muflihun.github.io/residue/
//  https://github.com/muflihun/residue-cpp/
//
//  See https://github.com/muflihun/residue-cpp/blob/master/LICENSE
//  for licensing information
//

#ifndef Residue_h
#define Residue_h

#include <cstdint>
#include <ctime>
#include <atomic>
#include <deque>
#include <exception>
#include <mutex>
#include <thread>
#include <tuple>
#include <unordered_map>
#include "easylogging++.h"

class ResidueDispatcher;

class ResidueException : public std::runtime_error
{
public:
    explicit ResidueException(const std::string& msg) : runtime_error(msg) {}
    virtual ~ResidueException() = default;
};

void residueCrashHandler(int) noexcept;

class Residue {
public:
    enum Flag : unsigned int {
        NONE = 0,
        ALLOW_UNKNOWN_LOGGERS = 1,
        ALLOW_BULK_LOG_REQUEST = 16,
        COMPRESSION = 256,
    };

    enum class InternalLoggingLevel : std::int8_t {
        crazy = 0,
        debug = 1,
        info = 2,
        warning = 3,
        error = 4,
        none = 5
    };

#ifdef RESIDUE_PROFILING
    unsigned long queue_ms;
    unsigned long dispatch_ms;
    int c_total;
    int c_dispatched;
#endif

    static const std::size_t DEFAULT_KEY_SIZE;

    static const int DEFAULT_PORT;

    static const std::string LOCALHOST;

    static const unsigned int TOUCH_THRESHOLD;

    static volatile int s_internalLoggingLevel;

    static inline Residue& instance() noexcept
    {
        static Residue s_instance;
        return s_instance;
    }

    virtual ~Residue() noexcept;

    Residue(Residue&&) = delete;
    Residue(const Residue&) = delete;
    Residue& operator=(const Residue&) = delete;

    static std::string version() noexcept;

    static std::string info() noexcept;

    static inline void connect(const std::string& host, int port)
    {
        Residue::instance().connect_(host, port);
    }

    static inline void connect(int port)
    {
        Residue::instance().connect_(Residue::LOCALHOST, port);
    }

    static inline void connect(const std::string& host)
    {
        Residue::instance().connect_(host, Residue::DEFAULT_PORT);
    }

    static inline void connect()
    {
        Residue::instance().connect_(Residue::LOCALHOST, Residue::DEFAULT_PORT);
    }

    static inline void reconnect(const std::string& host = "", int port = -1)
    {
        Residue::disconnect();
        Residue::connect(host.empty() ? Residue::instance().m_host : host,
                         port == -1 ? Residue::instance().m_port : port);
    }

    static inline bool connected() noexcept
    {
        return Residue::instance().m_connected;
    }

    static inline const std::string& clientId() noexcept
    {
        return Residue::instance().m_clientId;
    }

    static inline bool connecting() noexcept
    {
        return Residue::instance().m_connecting;
    }

    static inline unsigned int maxBulkSize() noexcept
    {
        return Residue::instance().m_maxBulkSize;
    }

    static inline unsigned int serverFlags() noexcept
    {
        return Residue::instance().m_serverFlags;
    }

    static void disconnect() noexcept;

    static inline void wait() noexcept
    {
        if (Residue::instance().m_dispatcher->joinable()) {
            Residue::instance().m_dispatcher->join();
        }
    }

    static inline void setApplicationId(const std::string& id) noexcept
    {
        Residue::instance().m_applicationId = id;
    }

    static inline void setResidueHomePath(const std::string& path) noexcept
    {
        Residue::instance().m_homepath = path;
    }

    static inline void enableBulkDispatch()
    {
        if (connected() && !hasFlag(Flag::ALLOW_BULK_LOG_REQUEST)) {
            throw std::invalid_argument("Bulk log requests not allowed by this server");
        }
        Residue::instance().m_bulkDispatch = true;
    }

    static inline void disableBulkDispatch() noexcept
    {
        Residue::instance().m_bulkDispatch = false;
    }

    static inline void enableUtc() noexcept
    {
        Residue::instance().m_utc = true;
    }

    static inline void disableUtc() noexcept
    {
        Residue::instance().m_utc = false;
    }

    static inline void setTimeOffset(int offset) noexcept
    {
        Residue::instance().m_timeOffset = offset;
    }

    static inline void setDispatchDelay(unsigned int delay) noexcept
    {
        Residue::instance().m_dispatchDelay = delay;
    }

    static inline void setBulkSize(unsigned int bulkSize)
    {
        if (connected() && bulkSize > maxBulkSize()) {
            throw ResidueException("Invalid bulk dispatch size. Maximum allowed: " + std::to_string(maxBulkSize()));
        }
        Residue::instance().m_bulkSize = bulkSize;
    }

    static inline void enableAutoBulkParams() noexcept
    {
        Residue::instance().m_autoBulkParams = true;
    }

    static inline void disableAutoBulkParams() noexcept
    {
        Residue::instance().m_autoBulkParams = false;
    }

    static inline void setKeySize(std::size_t keySize)
    {
        if (keySize != 2048 && keySize != 2048 * 2 && keySize != 2048 * 4) {
            throw ResidueException("Invalid key size. Please select 2048, 4096 or 8192");
        }
        Residue::instance().m_keySize = keySize;
    }

    static inline void setApplicationArgs(int argc, char** argv)
    {
        START_EASYLOGGINGPP(argc, argv);
    }

    static inline void setApplicationArgs(int argc, const char** argv)
    {
        START_EASYLOGGINGPP(argc, argv);
    }

    static inline void setKnownClient(const std::string& clientId, const std::string& privateKeyPem)
    {
        Residue::instance().m_clientId = clientId;
        Residue::instance().m_rsaPrivateKey = privateKeyPem;
        if (!clientId.empty() && privateKeyPem.empty()) {
            throw ResidueException("Please provide private key for known client.");
        }
        Residue::instance().m_knownClient = !clientId.empty() && !privateKeyPem.empty();
    }

    static inline void setServerPublicKey(const std::string& publicKeyPem)
    {
        Residue::instance().m_serverPublicKey = publicKeyPem;
    }

    static inline void setInternalLoggingLevel(int level)
    {
        Residue::s_internalLoggingLevel = level;
    }

    static inline void setInternalLoggingLevel(InternalLoggingLevel level)
    {
        setInternalLoggingLevel(static_cast<int>(level));
    }

    static inline bool hasFlag(Flag flag) noexcept
    {
        return serverFlags() != 0 && (serverFlags() & flag) != 0;
    }

    static inline void setThreadName(const std::string& threadName) noexcept
    {
        el::Helpers::setThreadName(threadName);
    }

    static inline void enableCrashHandler(const std::string& loggerId = el::base::consts::kDefaultLoggerId)
    {
#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
        Residue::instance().m_crashHandlerLoggerId = loggerId;
        el::Helpers::setCrashHandler(residueCrashHandler);
#endif
    }

    static inline const std::vector<std::string>& errors() noexcept
    {
        return Residue::instance().m_errors;
    }

    static void loadConfiguration(const std::string& jsonFilename);

    static inline void loadConfigurationFromJson(const std::string& json)
    {
        Residue::instance().loadConfigurationFromJson_(json);
    }

    static inline void saveConnection(const std::string& outputFile)
    {
        Residue::instance().saveConnection_(outputFile);
    }

    static inline std::string connection()
    {
        return Residue::instance().m_connection;
    }

    static inline void loadConnection(const std::string& connectionFile)
    {
        Residue::instance().loadConnection_(connectionFile);
    }

    static void loadConnectionFromJson(const std::string& connectionJson);

    inline std::string crashHandlerLoggerId() const noexcept
    {
        return m_crashHandlerLoggerId;
    }

    unsigned long getTimestamp() const noexcept
    {
        std::time_t seconds;
        std::time(&seconds);
        return seconds;
    }

    inline std::string serverVersion() const noexcept
    {
        return m_serverVersion;
    }

private:

    // defs and structs
    struct RawRequest {
        unsigned long date;
        std::string threadId;
        std::string loggerId;
        el::base::type::string_t msg;
        std::string file;
        el::base::type::LineNumber line;
        std::string func;
        unsigned int level;
        el::base::type::VerboseLevel vlevel;
    };

    // private members

    std::string m_host;
    int m_port;

    std::string m_connection;

    std::atomic<bool> m_connected;
    std::atomic<bool> m_connecting;
    std::atomic<bool> m_disconnected; // user called disconnect()

    std::atomic<bool> m_bulkDispatch;
    unsigned int m_bulkSize;
    unsigned int m_maxBulkSize;

    std::string m_rsaPrivateKey;
    std::string m_rsaPrivateKeySecret;
    std::string m_rsaPublicKey;
    std::size_t m_keySize;
    std::string m_clientId;
    std::string m_key;
    std::string m_serverVersion;
    std::string m_serverPublicKey;
    unsigned int m_age;
    unsigned long m_dateCreated;
    int m_loggingPort;
    unsigned int m_serverFlags;
    std::atomic<bool> m_utc;
    std::atomic<int> m_timeOffset;
    std::atomic<unsigned int> m_dispatchDelay;

    std::deque<RawRequest> m_requests;

    std::recursive_mutex m_mutex;
    std::thread* m_dispatcher;
    std::atomic<bool> m_running;
    std::atomic<bool> m_autoBulkParams;

    std::string m_applicationId;
    bool m_knownClient;

    std::string m_homepath;

    std::string m_crashHandlerLoggerId;

    std::vector<std::string> m_errors;
    std::mutex m_errorsMutex;

    friend class ResidueDispatcher;

    Residue() noexcept;

    // client
    bool isClientValid() const noexcept;
    bool shouldTouch() const noexcept;
    void touch() noexcept;
    void healthCheck() noexcept;

    // connect
    void connect_(const std::string& host, int port, bool estabilishFullConnection = true);
    void disconnect_() noexcept;
    void reset();
    void onConnect() noexcept;
    void loadConnectionFromJson_(const std::string& connectionJson);
    void saveConnection_(const std::string& outputFile);
    void loadConnection_(const std::string& connectionFile);

    void loadConfigurationFromJson_(const std::string& json);

    // request
    void addToQueue(RawRequest&&) noexcept;
    void dispatch();
    std::string requestToJson(RawRequest&& request);

    void addError(const std::string& errorText) noexcept;

    std::string& resolveResidueHomeEnvVar(std::string& str);
};

#endif /* Residue_h */