mflogger Library

MFlogger

current time, formatting and logging

mflogger Library - Version: 3.1.6

Please read 'COPYING' for license terms

To use in your code include the MFlogger header

#include <mflogger.h>

There are four classes: logger, jsonlog, syslog & timestring

logger - current time/data saved to file
jsonlog - current time/data saved to file in json format
syslog - use systems syslog interface as defined by <syslog.h>
timestring - return formatted current time

e.g. log data to a file

mflogger::logger loggingfile("/path/to/log/file.log");
loggingfile.log("there is something fishy going on");
loggingfile.log("Barracuda");

This will result in something like this in the log file

2025-11-01T07:24:35 there is something fishy going on
2025-11-01T07:24:36 Barracuda

e.g. log json data to a file

mflogger::jsonlog loggingfile("/path/to/log/file.log");
loggingfile.log("what's up", "there is something fishy going on", "info");
loggingfile.log("fish", "Barracuda", "oh no");

This will result in something like this in the log file

{"level":"info","timestamp":"2025-11-30T19:16:15","what's up":"there is something fishy going on"}
{"level":"oh no","timestamp":"2025-11-30T19:16:15","fish":"Barracuda"}

e.g. You can use the std::vector version of the jsonlog class to add as many values as you wish in a log message

mflogger::jsonlog loggingfile("/path/to/log/file.log");
std::vector<std::pair<std::string, std::string> > values;
values.push_back(std::make_pair("hello", "world"));
values.push_back(std::make_pair("pointless", "query"));
values.push_back(std::make_pair("pi", "3.14159265358979323846"));
jlog.log(values, "trace");

This will result in something like this in the log file

{"level":"trace","timestamp":"2024-11-30T19:16:15EDT","hello":"world","pointless":"query","pi":"3.14159265358979323846"}

By default logging happens using local time in iso 8601 format.
This can be changed using the timeformat function. This function uses std::put_time formatting syntax or can be used with mflogger::timestring::format as an argument
e.g.

loggingfile.timeformat(mflogger::timestring::format::HMS24);  // see timestring.h for enum mflogger::timestring::format values
  // or
loggingfile.timeformat("Making up a logging line prefix %H:%M");

e.g. using mfsyslog

mflogger::mfsyslog log;
log.log(LOG_INFO, "finished execution");

this should log using the syslog daemon

Please look at logexample.cpp for examples
mflogger::logger Interface

// constructor
logger(const std::string& logfilename, const bool& append = true, timestring::format prefix = timestring::format::iso8601);
logger(); // use without logging to a file, i.e. to get time stamped strings

// close current logging file and open a new file
bool open(const std::string& logfilename, const bool& append = true);

// is open ready for log input [encapsulates std::ios::base library routines]
bool good() const;
bool is_open() const;

// log message with timestamp/prefix. return the whole log line
std::string log(const std::string& message);

// log message using time since epoch as the format
// see mflogger::timestring::precision enum for valid values for second argument, defaults to seconds
std::string log_epoch(const std::string& message, timestring::precision p = timestring::precision::sec);

// stream various types to file
logger& operator<<(const std::string& in);
logger& operator<<(bool in);
logger& operator<<(char in);
//   ... rest left our for brevity -- see log.h

// set the delimiter between time prefix and message, a space is the default - " "
void setdelimiter(const std::string& d);

mflogger::jsonlog Interface derived from mflogger::log

// constructor
jsonlog(const std::string& logfilename, const bool& append = true, timestring::format prefix = timestring::format::iso8601);
jsonlog(); // use without logging to a file, i.e. to get time stamped json strings

// log message with timestamp/prefix. return the whole log line
// e.g.  general       : TRACE, DEBUG, INFO, WARN, ERROR, FATAL.
//       RSYSLOG style : emerg alert crit error warn notice info debug
// don't add Level if no level is appended
std::string log(const std::string& logitem, const std::string& value, const std::string& level = "");

// Level can obviously be anything that parses to valid json name
// e.g.  general       : TRACE, DEBUG, INFO, WARN, ERROR, FATAL.
//       RSYSLOG style : emerg alert crit error warn notice info debug
// don't add Level if no level is appended
std::string log(const std::vector<std::pair<std::string, std::string> >& logdata, const std::string& level = "");

mflogger::mfsyslog Interface

// mapping openlog - 'man syslog'
//
// Prepend - added to the beginning of a logged message
//
//option values bit mask constructed by ORing   e.g.  LOG_CONS | LOG_NOWAIT
// LOG_CONS	      Write directly to the system console if there is an error while sending to the system logger.
// LOG_NDELAY     Open the connection immediately (normally, the connection is opened when the first message is logged).  This may be useful, for example, if a
//	               subsequent chroot(2) would make the pathname used internally by the logging facility unreachable.
// LOG_NOWAIT     Don't wait for child processes that may have been created while logging the message.  (The GNU C library does not create a child process,	 so
//                 this option has no effect on Linux.)
// LOG_ODELAY     The converse of LOG_NDELAY; opening of the connection is delayed until syslog() is called.  (This is the default, and need not be specified.)
// LOG_PID	      Include the caller's PID with each message.
//
// facility values
// LOG_AUTH	      security/authorization messages
// LOG_AUTHPRIV   security/authorization messages (private)
// LOG_CRON	      clock daemon (cron and at)
// LOG_DAEMON     system daemons without separate facility value
// LOG_FTP	      ftp daemon
// LOG_KERN	      kernel messages (these can't be generated from user processes)
// LOG_LOCAL0 through LOG_LOCAL7
// LOG_MAIL	      mail subsystem
// LOG_NEWS	      USENET news subsystem
// LOG_SYSLOG     messages generated internally by syslogd(8)
// LOG_USER (default)
// LOG_UUCP	      UUCP subsystem
mfsyslog(const std::string& Prepend = "", int option = 0, int facility = 0);

// the data to be sent to the log daemon
//
// mapping syslog - 'man syslog'
//
// priority  argument	is formed by ORing together a facility value and a level value - facility above
// Values for level
//     This determines the importance of the message.  The levels are, in order of decreasing importance:
//
// LOG_EMERG      system is unusable
// LOG_ALERT      action must be taken immediately
// LOG_CRIT	      critical conditions
// LOG_ERR	      error conditions
// LOG_WARNING    warning conditions
// LOG_NOTICE     normal, but significant, condition
// LOG_INFO	      informational message
// LOG_DEBUG      debug-level message
void log(int priority, const std::string& data);

timestring

Log's Base class timestring can be used just to get local time in a string
Can also be used to format the current time.
e.g.

mflogger::timestring st;
st.time_asstring(); // will return (iso 8601 default) formatted current local time when called
st.epoch_asstring;  // will return seconds since epoch (in various formats)

// get current UTC time [zulu time]
st.ISO8601TimeUTC(); // in iso 8601 format

mflogger::timestring Interface

// constructor
timestring(timestring::format f = timestring::format::iso8601);

// return current time [format dependant on timeformat function call - referenced above in log class documentation]
std::string time_asstring();

// display time since epoch [various formats see enum mflogger::timestring::precision]
// second argument: if seconds and partial second delimit using this character or set of characters
std::string epoch_asstring(precision Precision = sec, std::string delimeter = ".")

// format the time output via time_asstring using std::put_time syntax
void timeformat(const std::string& FORMAT); { // see std::put_time to reference substitutions possible

// pre setup formatting - convenience
// one of:- iso8601, iso8601Z, iso8601z, HMS24, HMS12 -- see timestring::format
void timeformat(format FORMAT);