FIX8::Logger Class Reference

f8_thread delegated async logging class More...

#include <logger.hpp>

Inheritance diagram for FIX8::Logger:

Classes
struct	LogElement

Public Types
enum	Level {   Debug, Info, Warn, Error,   Fatal }
enum	Flags {   mstart, sstart, sequence, thread,   timestamp, minitimestamp, direction, level,   location, start_controls, append =start_controls, buffer,   compress, pipe, broadcast, nolf,   inbound, outbound, xml, num_flags }
using	LogFlags = ebitset< Flags >
using	Levels = ebitset< Level >
using	LogPositions = std::vector< int >

Public Member Functions
	Logger (const LogFlags flags, const Levels levels=Levels(All), const std::string delim=" ", const LogPositions positions=LogPositions())
virtual	~Logger ()
	Dtor. More...
bool	is_loggable (Level level) const
void	set_levels (Levels levels)
void	set_flags (LogFlags flags)
void	set_delimiter (const std::string &delim)
void	set_positions (const std::vector< int > &positions)
virtual std::ostream &	get_stream () const
bool	enqueue (const std::string &what, Level lev=Logger::Info, const char *fl=nullptr, const unsigned val=0)
bool	send (const std::string &what, Level lev=Logger::Info, const char *fl=nullptr, const unsigned val=0)
void	stop ()
	Stop the logging thread. More...
virtual bool	rotate (bool force=false)
F8API int	operator() ()
virtual F8API void	process_logline (LogElement *le)
bool	has_flag (const Flags flg) const
F8API char	get_thread_code (thread_id_t tid)
F8API void	purge_thread_codes ()
	Remove dead threads from the thread code cache. More...
virtual F8API void	flush ()
	Flush the buffer. More...
f8_thread_cancellation_token &	cancellation_token ()

Static Public Member Functions
static const Tickval &	get_time_started ()

Static Public Attributes
static const int	Errors = bitsum(Warn,Error,Fatal)
static const int	All = bitsum(Debug,Info,Warn,Error,Fatal)
static const int	None = 0
static const int	StdFlags = bitsum(sequence,thread,timestamp,level)
static const int	rotation_default = 5
static const int	max_rotation = 1024
static const std::vector< std::string >	_bit_names
	string representation of logflags More...
static const std::vector< std::string >	_level_names { "Debug", "Info ", "Warn ", "Error", "Fatal" }
	string representation of levels More...

Protected Types
using	ThreadCodes = std::map< thread_id_t, char >
using	RevThreadCodes = std::map< char, thread_id_t >

Protected Attributes
f8_mutex	_mutex
f8_spin_lock	_log_spl
LogFlags	_flags
Levels	_levels
std::string	_delim
std::ostream *	_ofs = nullptr
size_t	_lines = 0
f8_thread_cancellation_token	_stopping
f8_concurrent_queue< LogElement >	_msg_queue
unsigned	_sequence = 0
unsigned	_osequence = 0
ThreadCodes	_thread_codes
RevThreadCodes	_rev_thread_codes
LogPositions	_positions

Static Protected Attributes
static const Tickval	_started { true }
	The time the entire logging system was start. More...

Private Attributes
f8_thread< Logger >	_thread
std::list< std::string >	_buffer

Detailed Description

f8_thread delegated async logging class

Definition at line 153 of file logger.hpp.

Member Typedef Documentation

using FIX8::Logger::Levels = ebitset<Level>

Definition at line 175 of file logger.hpp.

using FIX8::Logger::LogFlags = ebitset<Flags>

Definition at line 174 of file logger.hpp.

using FIX8::Logger::LogPositions = std::vector<int>

Definition at line 176 of file logger.hpp.

using FIX8::Logger::RevThreadCodes = std::map<char, thread_id_t>

protected

Definition at line 225 of file logger.hpp.

using FIX8::Logger::ThreadCodes = std::map<thread_id_t, char>

protected

Definition at line 222 of file logger.hpp.

Member Enumeration Documentation

enum FIX8::Logger::Flags

Enumerator
mstart
sstart
sequence
thread
timestamp
minitimestamp
direction
level
location
start_controls
append
buffer
compress
pipe
broadcast
nolf
inbound
outbound
xml
num_flags

Definition at line 166 of file logger.hpp.

              { mstart, sstart, sequence, thread, timestamp, minitimestamp, direction, level, location,
                start_controls, append=start_controls, buffer, compress, pipe, broadcast, nolf, inbound, outbound, xml, num_flags };

enum FIX8::Logger::Level

Enumerator
Debug
Info
Warn
Error
Fatal

Definition at line 159 of file logger.hpp.

{ Debug, Info, Warn, Error, Fatal };

Constructor & Destructor Documentation

FIX8::Logger::Logger ( const LogFlags  flags, const Levels  levels = Levels(All), const std::string  delim = " ", const LogPositions  positions = LogPositions()  )

inline

Ctor.

Parameters

flags	ebitset flags
levels	ebitset levels
delim	field delimiter
positions	field positions

Definition at line 239 of file logger.hpp.

References mstart, num_flags, and FIX8::f8_thread< T >::start().

      : _thread(std::ref(*this)), _flags(flags), _levels(levels), _delim(delim), _positions(positions)
   {
      if (_positions.empty()) // setup default order
      {
         for (auto ii(mstart); ii != num_flags; ii = Flags(ii + 1))
            if (_flags & ii)
               _positions.push_back(ii);
      }

      _thread.start();
   }

virtual FIX8::Logger::~Logger ( )

inlinevirtual

Dtor.

Definition at line 253 of file logger.hpp.

References _ofs, and stop().

   {
      stop();
      delete _ofs;
   }

Member Function Documentation

f8_thread_cancellation_token& FIX8::Logger::cancellation_token ( )

inline

Get the thread cancellation token

Returns

reference to the cancellation token

Definition at line 352 of file logger.hpp.

References _stopping.

{ return _stopping; }

bool FIX8::Logger::enqueue ( const std::string &  what, Level  lev = Logger::Info, const char *  fl = nullptr, const unsigned  val = 0  )

inline

Log a string with log level. Ignore level and always enqueue.

Parameters

what	the string to log
lev	log level (enum)
fl	pointer to fileline
val	optional value for the logger to use

Returns

true on success

Definition at line 294 of file logger.hpp.

Referenced by FIX8::SingleLogger< fn >::enqueue(), FIX8::Session::enqueue(), send(), and stop().

   {
      const LogElement le(f8_thread<Logger>::getid(), what, lev, fl, val);
      return _msg_queue.try_push (le) == 0;
   }

void Logger::flush ( )

virtual

Flush the buffer.

Definition at line 196 of file logger.cpp.

Referenced by FIX8::SingleLogger< fn >::flush_log().

{
   f8_scoped_lock guard(_mutex);
   for (const auto& pp : _buffer)
      get_stream() << pp << endl;
   _buffer.clear();
   _lines = 0;
}

virtual std::ostream& FIX8::Logger::get_stream ( ) const

inlinevirtual

Get the underlying stream object.

Returns

the stream

Definition at line 286 of file logger.hpp.

Referenced by FIX8::XmlFileLogger::postamble(), FIX8::XmlFileLogger::preamble(), and FIX8::XmlFileLogger::process_logline().

{ return _ofs ? *_ofs : std::cout; }

char Logger::get_thread_code

(

thread_id_t

tid

)

Get the thread code for this thread or allocate a new code if not found.

Parameters

tid	the thread id of the thread to get a code for

Definition at line 232 of file logger.cpp.

Referenced by FIX8::XmlFileLogger::process_logline().

{
   f8_scoped_lock guard(_mutex);

   ThreadCodes::const_iterator itr(_thread_codes.find(tid));
   if (itr != _thread_codes.end())
      return itr->second;

   for (char acode('A'); acode < 127; ++acode)  // A-~ will allow for 86 threads
   {
      RevThreadCodes::const_iterator itr(_rev_thread_codes.find(acode));
      if (itr == _rev_thread_codes.end())
      {
         _thread_codes.insert({tid, acode});
         _rev_thread_codes.insert({acode, tid});
         return acode;
      }
   }

   return '?';
}

static const Tickval& FIX8::Logger::get_time_started ( )

inlinestatic

Get te time the logging syste started (actual system startup)

Returns

Tickval of start time

Definition at line 333 of file logger.hpp.

References _started.

{ return _started; }

bool FIX8::Logger::has_flag ( const Flags  flg ) const

inline

Check if the given log flag is set

Parameters

flg	flag bit to check

Returns

true if set

Definition at line 338 of file logger.hpp.

References FIX8::ebitset< T, B >::has().

Referenced by FIX8::Session::process(), and FIX8::Session::send_process().

{ return _flags.has(flg); }

bool FIX8::Logger::is_loggable ( Level  level ) const

inline

Check if the given log level is set for this logger

Parameters

level

level to test

Returns

true if available

Definition at line 262 of file logger.hpp.

References level.

Referenced by FIX8::SingleLogger< fn >::is_loggable(), FIX8::Session::is_loggable(), and send().

{ return _levels & level; }

int Logger::operator()

(

)

The logging thread entry point.

Returns

0 on success

Definition at line 60 of file logger.cpp.

References FIX8::Logger::LogElement::_str, and FIX8::hypersleep< h_microseconds >().

{
   unsigned received(0);

   while (!_stopping)
   {
      LogElement *msg_ptr(0);

#if (FIX8_MPMC_SYSTEM == FIX8_MPMC_FF)
      if (!_msg_queue.try_pop(msg_ptr))
      {
         hypersleep<h_microseconds>(200);
         continue;
      }
#else
      LogElement msg;
      if (_stopping) // make sure we dequeue any pending msgs before exiting
      {
         if (!_msg_queue.try_pop(msg))
            break;
      }
      else
         _msg_queue.pop (msg); // will block
      msg_ptr = &msg;
#endif

      ++received;

      if (msg_ptr)
      {
         if (msg_ptr->_str.empty())  // means exit
         {
#if (FIX8_MPMC_SYSTEM == FIX8_MPMC_FF)
            break;
#else
            continue;
#endif
         }

         process_logline(msg_ptr);
      }
#if (FIX8_MPMC_SYSTEM == FIX8_MPMC_FF)
      _msg_queue.release(msg_ptr);
#endif
   }

   return 0;
}

void Logger::process_logline ( LogElement *  le )

virtual

Process this logelement

Parameters

le	LogElement

Reimplemented in FIX8::XmlFileLogger.

Definition at line 110 of file logger.cpp.

References FIX8::Logger::LogElement::_fileline, FIX8::Logger::LogElement::_level, FIX8::Logger::LogElement::_str, FIX8::Logger::LogElement::_tid, FIX8::Logger::LogElement::_val, FIX8::Logger::LogElement::_when, FIX8::GetTimeAsStringMini(), FIX8::Tickval::msecs(), FIX8::f8_scoped_lock_impl< T >::release(), and FIX8::Tickval::secs().

{
   ostringstream ostr;
   f8_scoped_spin_lock posguard(_log_spl); // protect positions, allow app to change
   for (auto pp : _positions)
   {
      ostringstream fostr;
      if (pp < start_controls) switch (pp)
      {
      case mstart:
         {
            const Tickval tvs(msg_ptr->_when - _started);
            fostr << setw(11) << right << setfill('0') << (tvs.secs() * 1000 + tvs.msecs());
         }
         break;
      case sstart:
         fostr << setw(8) << right << setfill('0') << (msg_ptr->_when - _started).secs();
         break;
      case sequence:
         fostr << setw(7) << right << setfill('0');
         if (_flags & direction)
            fostr << (msg_ptr->_val ? ++_sequence  : ++_osequence);
         else
            fostr << ++_sequence;
         break;
      case thread:
         fostr << get_thread_code(msg_ptr->_tid);
         break;
      case location:
         if (msg_ptr->_fileline)
            fostr << msg_ptr->_fileline;
         break;
      case direction:
         fostr << (msg_ptr->_val ? " in" : "out");
         break;
      case timestamp:
         fostr << msg_ptr->_when;
         break;
      case minitimestamp:
         fostr << GetTimeAsStringMini(&msg_ptr->_when);
         break;
      case level:
         fostr << _level_names[msg_ptr->_level];
         break;
      default:
         break;
      }

      if (!fostr.str().empty())
      {
         if (_delim.size() > 1)
            ostr << _delim[0] << fostr.str() << _delim[1];
         else
            ostr << fostr.str() << _delim;
      }
   }
   posguard.release();

   if (_flags & buffer)
   {
      string result(ostr.str());
      if (_delim.size() > 1)
      {
         result += _delim[0];
         result += msg_ptr->_str;
         result += _delim[1];
      }
      else
         result += msg_ptr->_str;
      _buffer.push_back(result);
   }
   else
   {
      f8_scoped_lock guard(_mutex);
      if (_delim.size() > 1)
         get_stream() << ostr.str() << _delim[0] << msg_ptr->_str << _delim[1];
      else
         get_stream() << ostr.str() << msg_ptr->_str;
      if (_flags & nolf)
         get_stream().flush();
      else
         get_stream() << endl;
   }
}

void Logger::purge_thread_codes

(

)

Remove dead threads from the thread code cache.

Definition at line 206 of file logger.cpp.

Referenced by FIX8::Session::start().

{
#if (FIX8_THREAD_SYSTEM == FIX8_THREAD_PTHREAD)
   f8_scoped_lock guard(_mutex);

   for (ThreadCodes::iterator itr(_thread_codes.begin()); itr != _thread_codes.end();)
   {
#if defined _MSC_VER || defined __APPLE__
      // If ESRCH then thread is definitely dead.  Otherwise, we're unsure.
      if (pthread_kill(itr->first, 0) == ESRCH)
#else
      // a little trick to see if a thread is still alive
      clockid_t clock_id;
      if (pthread_getcpuclockid(itr->first, &clock_id) == ESRCH)
#endif
      {
         _rev_thread_codes.erase(itr->second);
         _thread_codes.erase(itr++); // post inc, takes copy before incr;
      }
      else
         ++itr;
   }
#endif
}

virtual bool FIX8::Logger::rotate ( bool  force = false )

inlinevirtual

Perform logfile rotation. Only relevant for file-type loggers.

Parameters

force

the rotation (even if the file is set to append)

Returns

true on success

Reimplemented in FIX8::FileLogger.

Definition at line 315 of file logger.hpp.

{ return true; }

bool FIX8::Logger::send ( const std::string &  what, Level  lev = Logger::Info, const char *  fl = nullptr, const unsigned  val = 0  )

inline

Log a string with log level.

Parameters

what	the string to log
lev	log level (enum)
fl	pointer to fileline
val	optional value for the logger to use

Returns

true on success

Definition at line 306 of file logger.hpp.

References enqueue(), and is_loggable().

Referenced by FIX8::SingleLogger< fn >::log(), FIX8::Session::log(), and FIX8::Session::plog().

      { return is_loggable(lev) ? enqueue(what, lev, fl, val) : true; }

void FIX8::Logger::set_delimiter ( const std::string &  delim )

inline

Set the field delimiter

Parameters

delim

delimiter value to set

Definition at line 274 of file logger.hpp.

Referenced by FIX8::SingleLogger< fn >::set_delimiter().

{ _delim = delim; }

void FIX8::Logger::set_flags ( LogFlags  flags )

inline

Set the LogFlags

Parameters

flags

flags to set

Definition at line 270 of file logger.hpp.

Referenced by FIX8::SingleLogger< fn >::set_flags().

{ _flags = flags; }

void FIX8::Logger::set_levels ( Levels  levels )

inline

Set the Log Levels

Parameters

levels

levels to set

Definition at line 266 of file logger.hpp.

Referenced by FIX8::SingleLogger< fn >::set_levels().

{ _levels = levels; }

void FIX8::Logger::set_positions ( const std::vector< int > &  positions )

inline

Set the log attribute positions

Parameters

positions

positions to set

Definition at line 278 of file logger.hpp.

Referenced by FIX8::SingleLogger< fn >::set_positions().

   {
      f8_scoped_spin_lock guard(_log_spl);
      _positions = positions;
   }

void FIX8::Logger::stop ( )

inline

Stop the logging thread.

Definition at line 310 of file logger.hpp.

References enqueue(), FIX8::_f8_threadcore::join(), and FIX8::f8_thread_cancellation_token::request_stop().

Referenced by FIX8::SingleLogger< fn >::stop(), ~Logger(), and FIX8::Session::~Session().

{ _stopping.request_stop(); enqueue(std::string()); _thread.join(); }

Member Data Documentation

const vector< string > FIX8::Logger::_bit_names

static

Initial value:

{
      "mstart", "sstart", "sequence", "thread", "timestamp", "minitimestamp", "direction", "level", "location",
      "append", "buffer", "compress", "pipe", "broadcast", "nolf", "inbound", "outbound", "xml"
   }

string representation of logflags

Definition at line 326 of file logger.hpp.

Referenced by FIX8::Configuration::create_logger().

std::list<std::string> FIX8::Logger::_buffer

private

Definition at line 156 of file logger.hpp.

std::string FIX8::Logger::_delim

protected

Definition at line 183 of file logger.hpp.

LogFlags FIX8::Logger::_flags

protected

Definition at line 181 of file logger.hpp.

Referenced by FIX8::BCLogger::BCLogger(), FIX8::PipeLogger::PipeLogger(), FIX8::XmlFileLogger::process_logline(), and FIX8::FileLogger::rotate().

const vector< string > FIX8::Logger::_level_names { "Debug", "Info ", "Warn ", "Error", "Fatal" }

static

string representation of levels

Definition at line 329 of file logger.hpp.

Referenced by FIX8::Configuration::create_logger(), and FIX8::XmlFileLogger::process_logline().

Levels FIX8::Logger::_levels

protected

Definition at line 182 of file logger.hpp.

size_t FIX8::Logger::_lines = 0

protected

Definition at line 185 of file logger.hpp.

f8_spin_lock FIX8::Logger::_log_spl

protected

Definition at line 180 of file logger.hpp.

f8_concurrent_queue<LogElement> FIX8::Logger::_msg_queue

protected

Definition at line 219 of file logger.hpp.

f8_mutex FIX8::Logger::_mutex

protected

Definition at line 179 of file logger.hpp.

Referenced by FIX8::XmlFileLogger::process_logline(), and FIX8::FileLogger::rotate().

std::ostream* FIX8::Logger::_ofs = nullptr

protected

Definition at line 184 of file logger.hpp.

Referenced by FIX8::BCLogger::BCLogger(), FIX8::PipeLogger::PipeLogger(), FIX8::FileLogger::rotate(), and ~Logger().

unsigned FIX8::Logger::_osequence = 0

protected

Definition at line 220 of file logger.hpp.

Referenced by FIX8::XmlFileLogger::process_logline().

LogPositions FIX8::Logger::_positions

protected

Definition at line 231 of file logger.hpp.

RevThreadCodes FIX8::Logger::_rev_thread_codes

protected

Definition at line 226 of file logger.hpp.

unsigned FIX8::Logger::_sequence = 0

protected

Definition at line 220 of file logger.hpp.

Referenced by FIX8::XmlFileLogger::process_logline().

const Tickval FIX8::Logger::_started { true }

staticprotected

The time the entire logging system was start.

Definition at line 229 of file logger.hpp.

Referenced by get_time_started(), and FIX8::XmlFileLogger::process_logline().

f8_thread_cancellation_token FIX8::Logger::_stopping

protected

Definition at line 186 of file logger.hpp.

Referenced by cancellation_token().

f8_thread<Logger> FIX8::Logger::_thread

private

Definition at line 155 of file logger.hpp.

ThreadCodes FIX8::Logger::_thread_codes

protected

Definition at line 223 of file logger.hpp.

const int FIX8::Logger::All = bitsum(Debug,Info,Warn,Error,Fatal)

static

Definition at line 161 of file logger.hpp.

Referenced by FIX8::Configuration::create_logger(), and FIX8::SingleLogger< fn >::instance().

const int FIX8::Logger::Errors = bitsum(Warn,Error,Fatal)

static

Definition at line 161 of file logger.hpp.

const int FIX8::Logger::max_rotation = 1024

static

Definition at line 173 of file logger.hpp.

Referenced by FIX8::FilePersister::initialise(), and FIX8::FileLogger::rotate().

const int FIX8::Logger::None = 0

static

Definition at line 165 of file logger.hpp.

Referenced by FIX8::Configuration::create_logger().

const int FIX8::Logger::rotation_default = 5

static

Definition at line 173 of file logger.hpp.

const int FIX8::Logger::StdFlags = bitsum(sequence,thread,timestamp,level)

static

Definition at line 169 of file logger.hpp.

Referenced by FIX8::Configuration::create_logger().

---

The documentation for this class was generated from the following files:

• logger.hpp
• logger.cpp