From aa82dc64b397b6ca0d336d91638d4f4b849e3667 Mon Sep 17 00:00:00 2001
From: Mike Buland <eichlan@xagasoft.com>
Date: Tue, 26 Jun 2007 05:10:58 +0000
Subject: Fixed a minor bug in FString, and added the Logger and a test...it's
 cool, and a decent replacement for multilog now that we use runit.

---
 src/fstring.h        |   1 +
 src/logger.cpp       | 123 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/logger.h         | 112 ++++++++++++++++++++++++++++++++++++++++++++++
 src/tests/logger.cpp |  28 ++++++++++++
 4 files changed, 264 insertions(+)
 create mode 100644 src/logger.cpp
 create mode 100644 src/logger.h
 create mode 100644 src/tests/logger.cpp

(limited to 'src')

diff --git a/src/fstring.h b/src/fstring.h
index 9d88bd4..fe34804 100644
--- a/src/fstring.h
+++ b/src/fstring.h
@@ -128,6 +128,7 @@ namespace Bu
 		 */
 		void append( const chr *pData )
 		{
+			if( !pData ) return;
 			long nLen;
 			for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
 			if( nLen == 0 )
diff --git a/src/logger.cpp b/src/logger.cpp
new file mode 100644
index 0000000..848dfb1
--- /dev/null
+++ b/src/logger.cpp
@@ -0,0 +1,123 @@
+#include "bu/logger.h"
+#include <stdarg.h>
+#include <time.h>
+#include <stdio.h>
+
+Bu::Logger::Logger()
+{
+}
+
+Bu::Logger::~Logger()
+{
+}
+
+void Bu::Logger::log( int nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...)
+{
+	if( (nLevel&nLevelMask) == 0 )
+		return;
+
+	va_list ap;
+	va_start( ap, sFormat );
+	char *text;
+	vasprintf( &text, sFormat, ap );
+	va_end(ap);
+	
+	time_t t = time(NULL);
+	
+	char *line = NULL;
+	struct tm *pTime;
+	pTime = localtime( &t );
+	asprintf(
+		&line,
+		sLogFormat.getStr(),
+		pTime->tm_year+1900,
+		pTime->tm_mon+1,
+		pTime->tm_mday,
+		pTime->tm_hour,
+		pTime->tm_min,
+		pTime->tm_sec,
+		nLevel,
+		sFile,
+		nLine,
+		text,
+		sFunction
+		);
+	write( fileno(stdout), line, strlen(line) );
+	free( text );
+	free( line );
+}
+
+void Bu::Logger::setFormat( const Bu::FString &str )
+{
+	sLogFormat = "";
+
+	static char fmts[][4]={
+		{'y', 'd', '0', '1'},
+		{'m', 'd', '0', '2'},
+		{'d', 'd', '0', '3'},
+		{'h', 'd', '0', '4'},
+		{'M', 'd', '0', '5'},
+		{'s', 'd', '0', '6'},
+		{'L', 'd', '0', '7'},
+		{'f', 's', '0', '8'},
+		{'l', 'd', '0', '9'},
+		{'t', 's', '1', '0'},
+		{'F', 's', '1', '1'},
+		{'\0', '\0', '\0', '\0'},
+	};
+	
+	for( const char *s = str.getStr(); *s; s++ )
+	{
+		if( *s == '%' )
+		{
+			sLogFormat += '%';
+			s++;
+			for( int l = 0;; l++ )
+			{
+				if( fmts[l][0] == '\0' )
+				{
+					sLogFormat += *s;
+					break;
+				}
+				else if( *s == fmts[l][0] )
+				{
+					sLogFormat += fmts[l][2];
+					sLogFormat += fmts[l][3];
+					sLogFormat += '$';
+					sLogFormat += fmts[l][1];
+					break;
+				}
+			}
+		}
+		else
+		{
+			sLogFormat += *s;
+		}
+	}
+	sLogFormat += '\n';
+
+	write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
+}
+
+void Bu::Logger::setMask( int n )
+{
+	nLevelMask = n;
+}
+
+void Bu::Logger::setLevel( int n )
+{
+	int j;
+	for( j = 31; j > 0; j-- )
+	{
+		if( (n&(1<<j)) )
+		{
+			for(; j >= 0; j-- )
+			{
+				n |= (1<<j);
+			}
+			nLevelMask = n;
+			return;
+		}
+	}
+}
+
diff --git a/src/logger.h b/src/logger.h
new file mode 100644
index 0000000..f8e1692
--- /dev/null
+++ b/src/logger.h
@@ -0,0 +1,112 @@
+#ifndef BU_LOGGER_H
+#define BU_LOGGER_H
+
+#include "bu/singleton.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+	/**
+	 * Simple logging facility.  All output goes straight to stdout, unlike the
+	 * old multi-log system.  Generally we expect any program complex enough to
+	 * want to use this will have other facilities for processing the logging
+	 * output, but if we need it we can add other output methods.
+	 *
+	 * Currently implemented as a singleton to avoid clutter with globals, you
+	 * generally never want to use the logging system directly, it's annoying.
+	 * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
+	 * setLogLevel.  They do all the real work for you.
+	 *
+	 * In the log format, you can specify extra information that will be written
+	 * to the log with every message, and extras in printf style.  Use %X flags
+	 * where X is one of the following:
+	 * - L - Logging level of the log message (not the current mask)
+	 * - y - Full year
+	 * - m - Month
+	 * - d - Day of month
+	 * - h - Hour (24-hour format)
+	 * - M - Minutes
+	 * - s - Seconds 
+	 * - f - Source file
+	 * - l - Line number
+	 * - F - function name
+	 * - t - Text of message (usually important)
+	 *
+	 * You can include anything extra that you would like, a newline will always
+	 * be added automatically, so no need to worry about that.  You can also
+	 * include any extra printf style formatting that you would like, for
+	 * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
+	 *
+	 * It's generally handy to create an enum of values you use as levels during
+	 * program execution (such as error, warning, info, debug, etc).  These
+	 * levels should be treated as bitflags, and the most desirable messages,
+	 * i.e. serious errors and the like should be low order (0x01), and the much
+	 * less desirable messages, like debugging info, should be higher order
+	 * (0xF0).  During operation you can then set either an explicit mask,
+	 * selecting just the levels that you would like to see printed, or set the
+	 * mask using the setLevel helper function, which simulates verbosity
+	 * levels, enabling every flag lower order than the highest order set bit
+	 * passed.  I.E. if you had the following enumerated levels:
+	 * 
+	 *@code
+	 enum {
+	 	logError	= 0x01,
+		logWarning	= 0x02,
+		logInfo		= 0x04,
+		logDebug	= 0x08
+	 };
+	 @endcode
+	 * And you set the mask with setMask( logInfo ) the only messages you would
+	 * see are the ones catagorized logInfo.  However, if you used 
+	 * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
+	 * type messages, since they are lower order.
+	 */
+	class Logger : public Bu::Singleton<Bu::Logger>
+	{
+		friend class Bu::Singleton<Bu::Logger>;
+	private:
+		Logger();
+		virtual ~Logger();
+
+	public:
+		void log( int nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
+
+		void setFormat( const Bu::FString &str );
+		void setMask( int n );
+		void setLevel( int n );
+
+	private:
+		Bu::FString sLogFormat;
+		int nLevelMask;
+	};
+}
+
+/**
+ * Use Bu::Logger to log a message at the given level and with the given message
+ * using printf style formatting, and include extra data such as the current
+ * file, line number, and function.
+ */
+#define lineLog( nLevel, sFrmt, ...) \
+	Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
+
+/**
+ * Set the Bu::Logger logging mask directly.  See Bu::Logger::setMask for
+ * details.
+ */
+#define setLogMask( nLevel ) \
+	Bu::Logger::getInstance().setMask( nLevel ) 
+
+/**
+ * Set the Bu::Logger format. See Bu::Logger::setFormat for details.
+ */
+#define setLogFormat( sFrmt ) \
+	Bu::Logger::getInstance().setFormat( sFrmt ) 
+
+/**
+ * Set the Bu::Logger logging mask simulating levels.  See Bu::Logger::setLevel
+ * for details.
+ */
+#define setLogLevel( nLevel ) \
+	Bu::Logger::getInstance().setLevel( nLevel ) 
+
+#endif
diff --git a/src/tests/logger.cpp b/src/tests/logger.cpp
new file mode 100644
index 0000000..a271443
--- /dev/null
+++ b/src/tests/logger.cpp
@@ -0,0 +1,28 @@
+#include "bu/logger.h"
+#include <errno.h>
+#include <stdlib.h>
+
+class Thing
+{
+	public:
+		Thing()
+		{
+			lineLog( 2, "Want a thing?");
+		}
+
+		void go( int i )
+		{
+			lineLog( 1, "GO!!!!");
+		}
+};
+
+int main()
+{
+	setLogLevel( 4 );
+	setLogFormat("%L: %y-%m-%d %h:%M:%s %f:%l:%F: %t");
+	lineLog( 5, "Hey, error: %s", strerror( errno ) );
+
+	Thing gh;
+	gh.go( 6);
+}
+
-- 
cgit v1.2.3