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. 224
      Log.cpp
  2. 239
      Log.h

224
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 {
Log logger;
/**
* @enum Maps our loglevel to their symbolic name
*/
static const char * g_LogLevelStr[eNumLogLevels] =
{
"error", // eLogError "error", // eLogError
"warn", // eLogWarning "warn", // eLogWarn
"info", // eLogInfo "info", // eLogInfo
"debug" // eLogDebug "debug" // eLogDebug
}; };
#ifndef _WIN32
/** convert LogLevel enum to syslog priority level */
static int ToSyslogLevel(LogLevel lvl)
{
switch (lvl) {
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 () Log::~Log ()
{
if (m_LogStream)
m_LogStream->flush();
}
void Log::SetLogFile (const std::string& fullFilePath, bool truncate)
{
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 ()
{
if (m_FullFilePath.length () > 0)
{
SetLogFile (m_FullFilePath, false); // don't truncate
LogPrint(eLogInfo, "Log: file ", m_FullFilePath, " reopen");
} }
}
void Log::SetLogLevel (const std::string& level) void Log::SetLogLevel (const std::string& level) {
{
if (level == "error") { m_MinLevel = eLogError; } if (level == "error") { m_MinLevel = eLogError; }
else if (level == "warn") { m_MinLevel = eLogWarning; } else if (level == "warn") { m_MinLevel = eLogWarning; }
else if (level == "info") { m_MinLevel = eLogInfo; } else if (level == "info") { m_MinLevel = eLogInfo; }
else if (level == "debug") { m_MinLevel = eLogDebug; } else if (level == "debug") { m_MinLevel = eLogDebug; }
else { else {
LogPrint(eLogError, "Log: Unknown loglevel: ", level); LogPrint(eLogError, "Log: unknown loglevel: ", level);
return; return;
} }
LogPrint(eLogInfo, "Log: min msg level set to ", level); LogPrint(eLogInfo, "Log: min messages level set to ", level);
} }
void Log::SetLogStream (std::shared_ptr<std::ostream> logStream) const char * Log::TimeAsString(std::time_t t) {
{ if (t != m_LastTimestamp) {
m_LogStream = logStream; strftime(m_LastDateTime, sizeof(m_LastDateTime), "%H:%M:%S", localtime(&t));
} m_LastTimestamp = t;
}
return m_LastDateTime;
}
void Log::StartSyslog(const std::string & ident, const int facility) 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 #ifndef _WIN32
m_Ident = ident; case eLogSyslog:
openlog(m_Ident.c_str(), LOG_PID, facility); syslog(GetSyslogPrio(msg->level), "%s", msg->text.c_str());
break;
#endif #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::SendTo (const std::string& path) {
auto flags = std::ofstream::out | std::ofstream::app;
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::SendTo (std::shared_ptr<std::ostream> os) {
m_Destination = eLogStream;
m_IsReady = true;
m_LogStream = os;
}
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

239
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,
#endif
LogMsg (Log * l = nullptr, LogLevel lv = eLogInfo): log (l), level (lv) {};
void Process();
}; };
class Log: public i2p::util::MsgQueue<LogMsg> namespace i2p {
{ namespace log {
public: struct LogMsg; /* forward declaration */
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 ();
class Log
{
private: private:
std::string m_FullFilePath; // empty if stream enum LogType m_Destination;
std::shared_ptr<std::ostream> m_LogStream;
enum LogLevel m_MinLevel; enum LogLevel m_MinLevel;
std::string m_Timestamp; std::shared_ptr<std::ostream> m_LogStream;
#if (__GNUC__ == 4) && (__GNUC_MINOR__ <= 6) && !defined(__clang__) // gcc 4.6 std::string m_Logfile;
std::chrono::monotonic_clock::time_point m_LastTimestampUpdate; std::time_t m_LastTimestamp;
#else char m_LastDateTime[64];
std::chrono::steady_clock::time_point m_LastTimestampUpdate; i2p::util::Queue<std::shared_ptr<LogMsg> > m_Queue;
#endif volatile bool m_IsReady;
std::string m_Ident; mutable std::mutex m_OutputLock;
};
extern Log * g_Log;
inline void StartLog (const std::string& fullFilePath) private:
{
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) /** prevent making copies */
{ Log (const Log &);
if (!g_Log) const Log& operator=(const Log&);
{
auto log = new Log ();
if (s)
log->SetLogStream (s);
g_Log = log;
}
}
inline void StopLog () /**
{ * @brief process stored messages in queue
if (g_Log) */
{ void Process ();
auto log = g_Log;
g_Log = nullptr;
log->Stop ();
delete log;
}
}
inline void SetLogLevel (const std::string& level) /**
{ * @brief Makes formatted string from unix timestamp
if (g_Log) * @param ts Second since epoch
g_Log->SetLogLevel(level); *
} * This function internally caches the result for last provided value
*/
const char * TimeAsString(std::time_t ts);
inline void ReopenLogFile () public:
{
if (g_Log)
g_Log->ReopenLogFile ();
}
inline bool IsLogToFile () Log ();
{ ~Log ();
return g_Log ? !g_Log->GetFullFilePath ().empty () : false;
}
inline void StartSyslog() LogType GetLogType () { return m_Destination; };
{ LogLevel GetLogLevel () { return m_MinLevel; };
StartLog("");
#ifndef _WIN32
g_Log->StartSyslog("i2pd", LOG_USER);
#endif
}
inline void StopSyslog() /**
{ * @brief Sets minimal alloed level for log messages
if(g_Log) * @param level String with wanted minimal msg level
g_Log->StopSyslog(); */
} 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)
{ {
@ -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