PurpleI2P
/
i2pd
mirror of https://github.com/PurpleI2P/i2pd.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

* new logs: code

pull/448/head
hagen 9 years ago
parent
598d0e216a
commit
17fb419fb1
2 changed files with 274 additions and 243 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 244
      Log.cpp
  2. 259
      Log.h

244
Log.cpp
Unescape View File

@ -1,133 +1,155 @@
#include <boost/date_time/posix_time/posix_time.hpp> /*
* Copyright (c) 2013-2016, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/
#include "Log.h" #include "Log.h"
Log * g_Log = nullptr; namespace i2p {
namespace log {
Log logger;
/**
* @enum Maps our loglevel to their symbolic name
*/
static const char * g_LogLevelStr[eNumLogLevels] =
{
"error", // eLogError
"warn", // eLogWarn
"info", // eLogInfo
"debug" // eLogDebug
};
static const char * g_LogLevelStr[eNumLogLevels] =
{
"error", // eLogError
"warn", // eLogWarning
"info", // eLogInfo
"debug" // eLogDebug
};
#ifndef _WIN32 #ifndef _WIN32
/** convert LogLevel enum to syslog priority level */ /**
static int ToSyslogLevel(LogLevel lvl) * @brief Maps our log levels to syslog one
{ * @return syslog priority LOG_*, as defined in syslog.h
switch (lvl) { */
case eLogError: static inline int GetSyslogPrio (enum LogLevel l) {
return LOG_ERR; int priority = LOG_DEBUG;
case eLogWarning: switch (l) {
return LOG_WARNING; case eLogError : priority = LOG_ERR; break;
case eLogInfo: case eLogWarning : priority = LOG_WARNING; break;
return LOG_INFO; case eLogInfo : priority = LOG_INFO; break;
case eLogDebug: case eLogDebug : priority = LOG_DEBUG; break;
return LOG_DEBUG; default : priority = LOG_DEBUG; break;
default: }
// WTF? invalid log level? return priority;
return LOG_CRIT; }
}
}
#endif #endif
void LogMsg::Process() Log::Log():
{ m_Destination(eLogStdout), m_MinLevel(eLogInfo),
#ifndef _WIN32 m_LogStream (nullptr), m_Logfile(""), m_IsReady(false)
if (log && log->SyslogEnabled()) { {
// only log to syslog }
syslog(ToSyslogLevel(level), "%s", s.str().c_str());
return;
}
#endif
auto stream = log ? log->GetLogStream () : nullptr;
auto& output = stream ? *stream : std::cout;
if (log)
output << log->GetTimestamp ();
else
output << boost::posix_time::second_clock::local_time().time_of_day ();
output << "/" << g_LogLevelStr[level] << " - ";
output << s.str();
}
const std::string& Log::GetTimestamp () Log::~Log ()
{
#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__)
auto ts = std::chrono::monotonic_clock::now ();
#else
auto ts = std::chrono::steady_clock::now ();
#endif
if (ts > m_LastTimestampUpdate + std::chrono::milliseconds (500)) // 0.5 second
{ {
m_LastTimestampUpdate = ts; switch (m_Destination) {
m_Timestamp = boost::posix_time::to_simple_string (boost::posix_time::second_clock::local_time().time_of_day ()); #ifndef _WIN32
case eLogSyslog :
closelog();
break;
#endif
case eLogFile:
case eLogStream:
m_LogStream->flush();
break;
default:
/* do nothing */
break;
}
Process();
} }
return m_Timestamp;
}
void Log::Flush () void Log::SetLogLevel (const std::string& level) {
{ if (level == "error") { m_MinLevel = eLogError; }
if (m_LogStream) else if (level == "warn") { m_MinLevel = eLogWarning; }
m_LogStream->flush(); else if (level == "info") { m_MinLevel = eLogInfo; }
} else if (level == "debug") { m_MinLevel = eLogDebug; }
else {
LogPrint(eLogError, "Log: unknown loglevel: ", level);
return;
}
LogPrint(eLogInfo, "Log: min messages level set to ", level);
}
void Log::SetLogFile (const std::string& fullFilePath, bool truncate) const char * Log::TimeAsString(std::time_t t) {
{ if (t != m_LastTimestamp) {
m_FullFilePath = fullFilePath; strftime(m_LastDateTime, sizeof(m_LastDateTime), "%H:%M:%S", localtime(&t));
auto mode = std::ofstream::out | std::ofstream::binary; m_LastTimestamp = t;
mode |= truncate ? std::ofstream::trunc : std::ofstream::app; }
auto logFile = std::make_shared<std::ofstream> (fullFilePath, mode); return m_LastDateTime;
if (logFile->is_open ())
{
SetLogStream (logFile);
LogPrint(eLogInfo, "Log: will send messages to ", fullFilePath);
} }
}
void Log::ReopenLogFile () void Log::Process() {
{ std::unique_lock<std::mutex> l(m_OutputLock);
if (m_FullFilePath.length () > 0) while (1) {
{ auto msg = m_Queue.GetNextWithTimeout (1);
SetLogFile (m_FullFilePath, false); // don't truncate if (!msg)
LogPrint(eLogInfo, "Log: file ", m_FullFilePath, " reopen"); break;
switch (m_Destination) {
#ifndef _WIN32
case eLogSyslog:
syslog(GetSyslogPrio(msg->level), "%s", msg->text.c_str());
break;
#endif
case eLogFile:
case eLogStream:
*m_LogStream << TimeAsString(msg->timestamp) << "/" << g_LogLevelStr[msg->level] << " - " << msg->text << std::endl;
break;
default:
std::cout << TimeAsString(msg->timestamp) << "/" << g_LogLevelStr[msg->level] << " - " << msg->text << std::endl;
break;
} // switch
} // while
} }
}
void Log::Append(std::shared_ptr<i2p::log::LogMsg> & msg) {
m_Queue.Put(msg);
if (!m_IsReady)
return;
Process();
}
void Log::SetLogLevel (const std::string& level) void Log::SendTo (const std::string& path) {
{ auto flags = std::ofstream::out | std::ofstream::app;
if (level == "error") { m_MinLevel = eLogError; } auto os = std::make_shared<std::ofstream> (path, flags);
else if (level == "warn") { m_MinLevel = eLogWarning; } if (os->is_open ()) {
else if (level == "info") { m_MinLevel = eLogInfo; } m_Logfile = path;
else if (level == "debug") { m_MinLevel = eLogDebug; } m_Destination = eLogFile;
else { m_LogStream = os;
LogPrint(eLogError, "Log: Unknown loglevel: ", level); m_IsReady = true;
return; return;
} }
LogPrint(eLogInfo, "Log: min msg level set to ", level); LogPrint(eLogError, "Log: can't open file ", path);
} }
void Log::SetLogStream (std::shared_ptr<std::ostream> logStream) void Log::SendTo (std::shared_ptr<std::ostream> os) {
{ m_Destination = eLogStream;
m_LogStream = logStream; m_IsReady = true;
} m_LogStream = os;
}
void Log::StartSyslog(const std::string & ident, const int facility)
{
#ifndef _WIN32 #ifndef _WIN32
m_Ident = ident; void Log::SendTo(const char *name, int facility) {
openlog(m_Ident.c_str(), LOG_PID, facility); m_Destination = eLogSyslog;
m_LogStream = nullptr;
m_IsReady = true;
openlog(name, LOG_CONS | LOG_PID, facility);
}
#endif #endif
}
void Log::StopSyslog() void Log::Reopen() {
{ if (m_Destination == eLogFile)
#ifndef _WIN32 SendTo(m_Logfile);
closelog(); }
m_Ident.clear();
#endif
}
bool Log::SyslogEnabled() Log & Logger() {
{ return logger;
return m_Ident.size() > 0; }
} } // log
} // i2p

259
Log.h
Unescape View File

@ -1,11 +1,19 @@
/*
* Copyright (c) 2013-2016, The PurpleI2P Project
*
* This file is part of Purple i2pd project and licensed under BSD3
*
* See full license text in LICENSE file at top of project tree
*/
#ifndef LOG_H__ #ifndef LOG_H__
#define LOG_H__ #define LOG_H__
#include <ctime>
#include <string> #include <string>
#include <iostream> #include <iostream>
#include <sstream>
#include <fstream> #include <fstream>
#include <functional> #include <sstream>
#include <chrono> #include <chrono>
#include <memory> #include <memory>
#include "Queue.h" #include "Queue.h"
@ -23,129 +31,126 @@ enum LogLevel
eNumLogLevels eNumLogLevels
}; };
class Log; enum LogType {
struct LogMsg eLogStdout = 0,
{ eLogStream,
std::stringstream s; eLogFile,
Log * log; #ifndef _WIN32
LogLevel level; eLogSyslog,
LogMsg (Log * l = nullptr, LogLevel lv = eLogInfo): log (l), level (lv) {};
void Process();
};
class Log: public i2p::util::MsgQueue<LogMsg>
{
public:
Log () { SetOnEmpty (std::bind (&Log::Flush, this)); };
~Log () {};
void SetLogFile (const std::string& fullFilePath, bool truncate = true);
void ReopenLogFile ();
void SetLogLevel (const std::string& level);
void SetLogStream (std::shared_ptr<std::ostream> logStream);
std::shared_ptr<std::ostream> GetLogStream () const { return m_LogStream; };
const std::string& GetTimestamp ();
LogLevel GetLogLevel () { return m_MinLevel; };
const std::string& GetFullFilePath () const { return m_FullFilePath; };
/** start logging to syslog */
void StartSyslog(const std::string & ident, const int facility);
/** stop logging to syslog */
void StopSyslog();
/** are we logging to syslog right now? */
bool SyslogEnabled();
private:
void Flush ();
private:
std::string m_FullFilePath; // empty if stream
std::shared_ptr<std::ostream> m_LogStream;
enum LogLevel m_MinLevel;
std::string m_Timestamp;
#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__) // gcc 4.6
std::chrono::monotonic_clock::time_point m_LastTimestampUpdate;
#else
std::chrono::steady_clock::time_point m_LastTimestampUpdate;
#endif #endif
std::string m_Ident;
}; };
extern Log * g_Log; namespace i2p {
namespace log {
struct LogMsg; /* forward declaration */
inline void StartLog (const std::string& fullFilePath) class Log
{
if (!g_Log)
{ {
auto log = new Log (); private:
if (fullFilePath.length () > 0)
log->SetLogFile (fullFilePath); enum LogType m_Destination;
g_Log = log; enum LogLevel m_MinLevel;
} std::shared_ptr<std::ostream> m_LogStream;
} std::string m_Logfile;
std::time_t m_LastTimestamp;
inline void StartLog (std::shared_ptr<std::ostream> s) char m_LastDateTime[64];
{ i2p::util::Queue<std::shared_ptr<LogMsg> > m_Queue;
if (!g_Log) volatile bool m_IsReady;
{ mutable std::mutex m_OutputLock;
auto log = new Log ();
if (s) private:
log->SetLogStream (s);
g_Log = log; /** prevent making copies */
} Log (const Log &);
} const Log& operator=(const Log&);
inline void StopLog () /**
{ * @brief process stored messages in queue
if (g_Log) */
{ void Process ();
auto log = g_Log;
g_Log = nullptr; /**
log->Stop (); * @brief Makes formatted string from unix timestamp
delete log; * @param ts Second since epoch
} *
} * This function internally caches the result for last provided value
*/
inline void SetLogLevel (const std::string& level) const char * TimeAsString(std::time_t ts);
{
if (g_Log) public:
g_Log->SetLogLevel(level);
} Log ();
~Log ();
inline void ReopenLogFile ()
{ LogType GetLogType () { return m_Destination; };
if (g_Log) LogLevel GetLogLevel () { return m_MinLevel; };
g_Log->ReopenLogFile ();
} /**
* @brief Sets minimal alloed level for log messages
inline bool IsLogToFile () * @param level String with wanted minimal msg level
{ */
return g_Log ? !g_Log->GetFullFilePath ().empty () : false; void SetLogLevel (const std::string& level);
}
/**
inline void StartSyslog() * @brief Sets log destination to logfile
{ * @param path Path to logfile
StartLog(""); */
#ifndef _WIN32 void SendTo (const std::string &path);
g_Log->StartSyslog("i2pd", LOG_USER);
#endif /**
} * @brief Sets log destination to given output stream
* @param os Output stream
inline void StopSyslog() */
{ void SendTo (std::shared_ptr<std::ostream> s);
if(g_Log)
g_Log->StopSyslog(); #ifndef _WIN32
} /**
* @brief Sets log destination to syslog
* @param name Wanted program name
* @param facility Wanted log category
*/
void SendTo (const char *name, int facility);
#endif
/**
* @brief Format log message and write to output stream/syslog
* @param msg Pointer to processed message
*/
void Append(std::shared_ptr<i2p::log::LogMsg> &);
/** @brief Flushes the output log stream */
void Flush();
/** @brief Reopen log file */
void Reopen();
};
/**
* @struct Log message container
*
* We creating it somewhere with LogPrint(),
* then put in MsgQueue for later processing.
*/
struct LogMsg {
std::time_t timestamp;
std::string text; /**< message text as single string */
LogLevel level; /**< message level */
LogMsg (LogLevel lvl, std::time_t ts, const std::string & txt): timestamp(ts), text(txt), level(lvl) {};
};
Log & Logger();
} // log
} // i2p
/** internal usage only -- folding args array to single string */
template<typename TValue> template<typename TValue>
void LogPrint (std::stringstream& s, TValue arg) void LogPrint (std::stringstream& s, TValue arg)
{ {
s << arg; s << arg;
} }
/** internal usage only -- folding args array to single string */
template<typename TValue, typename... TArgs> template<typename TValue, typename... TArgs>
void LogPrint (std::stringstream& s, TValue arg, TArgs... args) void LogPrint (std::stringstream& s, TValue arg, TArgs... args)
{ {
@ -153,20 +158,24 @@ void LogPrint (std::stringstream& s, TValue arg, TArgs... args)
LogPrint (s, args...); LogPrint (s, args...);
} }
/**
* @brief Create log message and send it to queue
* @param level Message level (eLogError, eLogInfo, ...)
* @param args Array of message parts
*/
template<typename... TArgs> template<typename... TArgs>
void LogPrint (LogLevel level, TArgs... args) void LogPrint (LogLevel level, TArgs... args)
{ {
if (g_Log && level > g_Log->GetLogLevel ()) i2p::log::Log &log = i2p::log::Logger();
if (level > log.GetLogLevel ())
return; return;
LogMsg * msg = new LogMsg (g_Log, level);
LogPrint (msg->s, args...); // fold message to single string
msg->s << std::endl; std::stringstream ss("");
if (g_Log) { LogPrint (ss, args ...);
g_Log->Put (msg);
} else { auto msg = std::make_shared<i2p::log::LogMsg>(level, std::time(nullptr), ss.str());
msg->Process (); log.Append(msg);
delete msg;
}
} }
#endif #endif // LOG_H__

Write Preview
Loading…
Cancel
Save