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. 250
      Log.cpp
  2. 267
      Log.h

250
Log.cpp
Unescape View File

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

267
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,150 +31,151 @@ 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 ();
if (fullFilePath.length () > 0)
log->SetLogFile (fullFilePath);
g_Log = log;
}
}
inline void StartLog (std::shared_ptr<std::ostream> s)
{
if (!g_Log)
{
auto log = new Log ();
if (s)
log->SetLogStream (s);
g_Log = log;
}
}
inline void StopLog ()
{
if (g_Log)
{ {
auto log = g_Log; private:
g_Log = nullptr;
log->Stop (); enum LogType m_Destination;
delete log; enum LogLevel m_MinLevel;
} std::shared_ptr<std::ostream> m_LogStream;
} std::string m_Logfile;
std::time_t m_LastTimestamp;
inline void SetLogLevel (const std::string& level) char m_LastDateTime[64];
{ i2p::util::Queue<std::shared_ptr<LogMsg> > m_Queue;
if (g_Log) volatile bool m_IsReady;
g_Log->SetLogLevel(level); mutable std::mutex m_OutputLock;
}
private:
inline void ReopenLogFile ()
{ /** prevent making copies */
if (g_Log) Log (const Log &);
g_Log->ReopenLogFile (); const Log& operator=(const Log&);
}
/**
inline bool IsLogToFile () * @brief process stored messages in queue
{ */
return g_Log ? !g_Log->GetFullFilePath ().empty () : false; void Process ();
}
/**
inline void StartSyslog() * @brief Makes formatted string from unix timestamp
{ * @param ts Second since epoch
StartLog(""); *
#ifndef _WIN32 * This function internally caches the result for last provided value
g_Log->StartSyslog("i2pd", LOG_USER); */
#endif const char * TimeAsString(std::time_t ts);
}
public:
inline void StopSyslog()
{ Log ();
if(g_Log) ~Log ();
g_Log->StopSyslog();
} LogType GetLogType () { return m_Destination; };
LogLevel GetLogLevel () { return m_MinLevel; };
/**
* @brief Sets minimal alloed level for log messages
* @param level String with wanted minimal msg level
*/
void SetLogLevel (const std::string& level);
/**
* @brief Sets log destination to logfile
* @param path Path to logfile
*/
void SendTo (const std::string &path);
/**
* @brief Sets log destination to given output stream
* @param os Output stream
*/
void SendTo (std::shared_ptr<std::ostream> s);
#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)
{ {
LogPrint (s, arg); LogPrint (s, arg);
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