Перенаправление c++ std:: clog в системный журнал в Unix
Я работаю над Unix в программе на C++, которая отправляет сообщения в syslog.
текущий код использует системного журнала системный вызов, который работает как printf.
теперь я предпочел бы использовать поток для этой цели, как правило, встроенный std:: clog. Но clog просто перенаправляет вывод в stderr, а не в syslog, и это бесполезно для меня, поскольку я также использую stderr и stdout для других целей.
Я видел в другой ответ что его довольно легко перенаправить в файл с помощью rdbuf (), но я не вижу способа применить этот метод для вызова syslog, поскольку openlog не возвращает обработчик файла, который я мог бы использовать для привязки потока к нему.
есть ли другой способ сделать это ? (выглядит довольно просто для программирования unix)?
Edit: Я ищу решение, которое не использует внешние библиотеки. То, что @Chris предлагает, Может быть хорошим началом, но все еще немного расплывчато, чтобы стать ответ принят.
редактировать: использование Boost.IOStreams в порядке, так как мой проект уже использует Boost.
связывание с внешней библиотекой возможно, но также является проблемой, поскольку это код GPL. Зависимости также являются бременем, поскольку они могут конфликтовать с другими компонентами, недоступны в моем дистрибутиве Linux, вводить сторонние ошибки и т. д. Если это единственное решение, я могу полностью избежать потоков... (жалость.)
4 ответов
мне тоже нужно было что-то простое, поэтому я просто собрал это вместе:
log.h:
enum LogPriority {
kLogEmerg = LOG_EMERG, // system is unusable
kLogAlert = LOG_ALERT, // action must be taken immediately
kLogCrit = LOG_CRIT, // critical conditions
kLogErr = LOG_ERR, // error conditions
kLogWarning = LOG_WARNING, // warning conditions
kLogNotice = LOG_NOTICE, // normal, but significant, condition
kLogInfo = LOG_INFO, // informational message
kLogDebug = LOG_DEBUG // debug-level message
};
std::ostream& operator<< (std::ostream& os, const LogPriority& log_priority);
class Log : public std::basic_streambuf<char, std::char_traits<char> > {
public:
explicit Log(std::string ident, int facility);
protected:
int sync();
int overflow(int c);
private:
friend std::ostream& operator<< (std::ostream& os, const LogPriority& log_priority);
std::string buffer_;
int facility_;
int priority_;
char ident_[50];
};
log.cc:
Log::Log(std::string ident, int facility) {
facility_ = facility;
priority_ = LOG_DEBUG;
strncpy(ident_, ident.c_str(), sizeof(ident_));
ident_[sizeof(ident_)-1] = '';
openlog(ident_, LOG_PID, facility_);
}
int Log::sync() {
if (buffer_.length()) {
syslog(priority_, buffer_.c_str());
buffer_.erase();
priority_ = LOG_DEBUG; // default to debug for each message
}
return 0;
}
int Log::overflow(int c) {
if (c != EOF) {
buffer_ += static_cast<char>(c);
} else {
sync();
}
return c;
}
std::ostream& operator<< (std::ostream& os, const LogPriority& log_priority) {
static_cast<Log *>(os.rdbuf())->priority_ = (int)log_priority;
return os;
}
на main()
Я инициализирую clog:
std::clog.rdbuf(new Log("foo", LOG_LOCAL0));
тогда, когда я хочу войти в систему, это легко:
std::clog << kLogNotice << "test log message" << std::endl;
std::clog << "the default is debug level" << std::endl;
вы можете определить streambuf, который вызывает syslog. Например:
// Pseudo-code
class syslog_streambuf : public streambuf {
private:
void internal_log(string& log) {
syslog(..., log, ...);
}
public:
int sputc ( char c ) {
internal_log(...);
}
streamsize sputn ( const char * s, streamsize n ) {
internal_log(...);
}
}
тогда вы просто напишете следующее, чтобы перенаправить засор:
clog.rdbuf( new syslog_streambuf );
есть еще несколько функций, которые вы, вероятно, придется переопределить, вот хороший ссылка на API streambuf.
другая версия частично вдохновлена eater. Он не перенаправляет std:: clog как таковой, но использует знакомый синтаксис потока.
#ifndef SYSLOG_HPP
#define SYSLOG_HPP
#include <ostream>
#include <streambuf>
#include <string>
#include <syslog.h>
namespace log
{
enum level
{
emergency = LOG_EMERG,
alert = LOG_ALERT,
critical = LOG_CRIT,
error = LOG_ERR,
warning = LOG_WARNING,
notice = LOG_NOTICE,
info = LOG_INFO,
debug = LOG_DEBUG,
};
enum type
{
auth = LOG_AUTH,
cron = LOG_CRON,
daemon = LOG_DAEMON,
local0 = LOG_LOCAL0,
local1 = LOG_LOCAL1,
local2 = LOG_LOCAL2,
local3 = LOG_LOCAL3,
local4 = LOG_LOCAL4,
local5 = LOG_LOCAL5,
local6 = LOG_LOCAL6,
local7 = LOG_LOCAL7,
print = LOG_LPR,
mail = LOG_MAIL,
news = LOG_NEWS,
user = LOG_USER,
uucp = LOG_UUCP,
};
}
class syslog_stream;
class syslog_streambuf: public std::basic_streambuf<char>
{
public:
explicit syslog_streambuf(const std::string& name, log::type type):
std::basic_streambuf<char>()
{
openlog(name.size() ? name.data() : nullptr, LOG_PID, type);
}
~syslog_streambuf() override { closelog(); }
protected:
int_type overflow(int_type c = traits_type::eof()) override
{
if(traits_type::eq_int_type(c, traits_type::eof()))
sync();
else buffer += traits_type::to_char_type(c);
return c;
}
int sync() override
{
if(buffer.size())
{
syslog(level, "%s", buffer.data());
buffer.clear();
level = ini_level;
}
return 0;
}
friend class syslog_stream;
void set_level(log::level new_level) noexcept { level = new_level; }
private:
static constexpr log::level ini_level = log::info;
log::level level = ini_level;
std::string buffer;
};
class syslog_stream: public std::basic_ostream<char>
{
public:
explicit syslog_stream(const std::string& name = std::string(), log::type type = log::user):
std::basic_ostream<char>(&streambuf),
streambuf(name, type)
{ }
syslog_stream& operator<<(log::level level) noexcept
{
streambuf.set_level(level);
return (*this);
}
private:
syslog_streambuf streambuf;
};
#endif // SYSLOG_HPP
чтобы использовать его, вы можете сделать что-то вроде:
syslog_stream clog;
clog << "Hello, world!" << std::endl;
clog << log::emergency << "foo" << "bar" << "baz" << 42 << std::endl;
Я разработал класс OStreamedLog, очень похожий на то, что было показано выше, за исключением того, что мои объекты OStreamedLog настроены на использование произвольного объекта ostringstream, как предложил @Basilevs.
во-первых, существует определение класса Log, очень похожее на то, что @eater и @Chris Kaminski упоминали выше. Затем мое определение класса OStreamedLog, содержащее объект Log:
class OStreamedLog : public ostringstream
{
public:
OStreamedLog (const char* ident, int facility)
{
log = new Log (ident, facility);
(static_cast<ostream*>(this))->rdbuf (log);
}
private:
Log* log;
};
теперь, когда вам нужно войти, просто позвоните:
OStreamedLog someLog ("MyOwnProgramThatNeedsLogging", LOG_LOCAL1);
someLog << "Log testing" << endl;
someLog << LOG_ERR << "some other error log" << endl;
конечно, вы могли бы сверните все определение журнала в свой класс OStreamedLog, но вы можете сделать другие вещи в своем базовом объекте журнала и использовать оболочки, как указано выше, чтобы различать различные типы журналов. Например, у вас могут быть удобочитаемые диагностические журналы (отправленные как текст ASCII), двоичные журналы (для последующей обработки) или журнал потоковой передачи TLS (например, на сервер на севере).