/*
* This file is a part of the LinkAhead Project.
*
* Copyright (C) 2021-2022 Timm Fitschen <t.fitschen@indiscale.com>
* Copyright (C) 2021-2022 IndiScale GmbH <info@indiscale.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
#ifndef LINKAHEAD_LOGGING_H
#define LINKAHEAD_LOGGING_H
#include "linkahead/log_level.h" // for LINKAHEAD_LOG_...
#include <cstdint> // for uint64_t
#include <iosfwd> // for streamsize
#include <memory> // for shared_ptr
#include <string> // for string
#include <vector> // for vector
#include <filesystem> // for path
namespace linkahead::logging {
const std::string logger_name = "linkahead::logging";
class LoggerOutputStream {
public:
LoggerOutputStream(std::string channel, int level);
auto operator<<(std::ostream &(*f)(std::ostream &)) -> LoggerOutputStream &;
auto operator<<(bool msg) -> LoggerOutputStream &;
auto operator<<(int msg) -> LoggerOutputStream &;
auto operator<<(uint64_t msg) -> LoggerOutputStream &;
auto operator<<(int64_t msg) -> LoggerOutputStream &;
auto operator<<(std::streambuf *msg) -> LoggerOutputStream &;
auto operator<<(const char *msg) -> LoggerOutputStream &;
auto operator<<(const std::string &msg) -> LoggerOutputStream &;
auto operator<<(void *msg) -> LoggerOutputStream &;
auto operator<<(std::filesystem::path *path) -> LoggerOutputStream &;
auto operator<<(const std::filesystem::path &path) -> LoggerOutputStream &;
static auto get(const std::string &channel, int level) -> LoggerOutputStream {
return LoggerOutputStream(channel, level);
}
private:
std::string channel;
int level;
};
/**
* Helper class for logging the entering and leaving of a function or method.
*
* Please Use the macro
*
* LINKAHEAD_LOG_TRACE_ENTER_AND_LEAVE(logger_name, function_name);
*/
class TraceEnterLeaveLogger {
public:
inline TraceEnterLeaveLogger(const std::string &channel, const std::string &function_name)
: channel(channel), function_name(function_name) {
linkahead::logging::LoggerOutputStream::get(this->channel, LINKAHEAD_LOG_LEVEL_TRACE)
<< "Enter " << this->function_name;
}
inline ~TraceEnterLeaveLogger() {
linkahead::logging::LoggerOutputStream::get(this->channel, LINKAHEAD_LOG_LEVEL_TRACE)
<< "Leave " << this->function_name;
}
private:
const std::string &channel;
const std::string function_name;
};
/**
* This class stores the integer log level.
*/
class LevelConfiguration {
public:
LevelConfiguration(int level) : level(level){};
[[nodiscard]] inline auto GetLevel() const -> int { return this->level; }
private:
int level;
};
class SinkConfiguration;
/**
* This class stores the logging level and log sinks.
*
* Sinks are represented by SinkConfiguration objects.
*/
class LoggingConfiguration : public LevelConfiguration {
public:
virtual ~LoggingConfiguration() = default;
LoggingConfiguration(int level);
auto AddSink(const std::shared_ptr<SinkConfiguration> &sink) -> void;
auto GetSinks() const -> const std::vector<std::shared_ptr<SinkConfiguration>> &;
private:
std::vector<std::shared_ptr<SinkConfiguration>> sinks;
};
auto initialize_logging_defaults() -> int;
auto initialize_logging(const LoggingConfiguration &configuration) -> void;
/**
* A logging sink is characterized by a name and destination.
*
* Typical inheriting configurations exist for console, files and syslog.
*
* When a SinkConfiguration is created from a configuration, the sink
* configuration must contain a \p destination key which matches one of the
* keywords for implemented sinks. At the moment of writing this documentation,
* valid destinations are:
*
* \li \p file
* \li \p console
* \li \p syslog
*
* A \p level keyword sets the logging level, if it exists at the sink or
* logging level of the configuration.
*/
class SinkConfiguration : public LevelConfiguration {
public:
virtual ~SinkConfiguration() = default;
SinkConfiguration(std::string name, int level);
[[nodiscard]] auto GetName() const -> const std::string &;
[[nodiscard]] virtual auto GetDestination() const -> const std::string & = 0;
friend auto initialize_logging_defaults() -> int;
friend auto initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
protected:
virtual auto Configure(void *settings) const -> void;
private:
std::string name;
};
class ConsoleSinkConfiguration : public SinkConfiguration {
public:
virtual ~ConsoleSinkConfiguration() = default;
ConsoleSinkConfiguration(const std::string &name, int level);
[[nodiscard]] auto GetDestination() const -> const std::string & override;
friend auto initialize_logging_defaults() -> int;
friend auto initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
protected:
typedef SinkConfiguration sink_configuration;
virtual auto Configure(void *settings) const -> void override;
private:
const std::string destination = "Console";
};
/**
* The file name is the destination, the directory can be set separately.
*
* If there is a `directory` key in the configuration, that will be used as a
* default, otherwise it is the current directory.
*/
class FileSinkConfiguration : public SinkConfiguration {
public:
virtual ~FileSinkConfiguration() = default;
FileSinkConfiguration(const std::string &name, int level);
[[nodiscard]] virtual auto GetDestination() const -> const std::string & override;
auto SetDirectory(const std::string &directory) -> void;
friend auto initialize_logging_defaults() -> int;
friend auto initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
protected:
typedef SinkConfiguration sink_configuration;
virtual auto Configure(void *settings) const -> void override;
private:
const std::string destination = "TextFile";
std::string directory = "./";
};
class SyslogSinkConfiguration : public SinkConfiguration {
public:
virtual ~SyslogSinkConfiguration() = default;
SyslogSinkConfiguration(const std::string &name, int level);
[[nodiscard]] virtual auto GetDestination() const -> const std::string & override;
private:
const std::string destination = "Syslog";
};
/**
* Convenience function for the C interface.
*/
void linkahead_log_fatal(const char *channel, const char *msg);
/**
* Convenience function for the C interface.
*/
void linkahead_log_error(const char *channel, const char *msg);
/**
* Convenience function for the C interface.
*/
void linkahead_log_warn(const char *channel, const char *msg);
/**
* Convenience function for the C interface.
*/
void linkahead_log_info(const char *channel, const char *msg);
/**
* Convenience function for the C interface.
*/
void linkahead_log_debug(const char *channel, const char *msg);
/**
* Convenience function for the C interface.
*/
void linkahead_log_trace(const char *channel, const char *msg);
} // namespace linkahead::logging
#define LINKAHEAD_LOG_FATAL(Channel) \
linkahead::logging::LoggerOutputStream::get(Channel, LINKAHEAD_LOG_LEVEL_FATAL)
#define LINKAHEAD_LOG_ERROR(Channel) \
linkahead::logging::LoggerOutputStream::get(Channel, LINKAHEAD_LOG_LEVEL_ERROR)
#define LINKAHEAD_LOG_WARN(Channel) \
linkahead::logging::LoggerOutputStream::get(Channel, LINKAHEAD_LOG_LEVEL_WARN)
#define LINKAHEAD_LOG_INFO(Channel) \
linkahead::logging::LoggerOutputStream::get(Channel, LINKAHEAD_LOG_LEVEL_INFO)
#define LINKAHEAD_LOG_DEBUG(Channel) \
linkahead::logging::LoggerOutputStream::get(Channel, LINKAHEAD_LOG_LEVEL_DEBUG)
#define LINKAHEAD_LOG_TRACE(Channel) \
linkahead::logging::LoggerOutputStream::get(Channel, LINKAHEAD_LOG_LEVEL_TRACE)
#define LINKAHEAD_LOG_TRACE_ENTER_AND_LEAVE(Channel, FunctionName) \
const linkahead::logging::TraceEnterLeaveLogger trace_enter_leave_logger(Channel, FunctionName);
#define LINKAHEAD_LOG_ERROR_AND_RETURN_STATUS(Channel, StatusCode, Message) \
LINKAHEAD_LOG_ERROR(Channel) << "StatusCode (" << StatusCode << ") " \
<< linkahead::get_status_description(StatusCode) << ": " \
<< Message; \
return StatusCode;
#endif