Rewrite the log module.

It is now cleaner and acts as a wrapper around the standard go log module.

src/log/interface.go

@@ -0,0 +1,29 @@
+
+package log
+
+import (
+	"io"
+	stdlog "log"
+)
+
+// Create and export our different log functions.
+// ---------------------------------------------------------
+var (
+	Info logWrapper 	= stdWrapper
+	Notice logWrapper 	= createWrapper(noticeLogger)
+	Warning logWrapper  = createWrapper(warningLogger)
+	Error logWrapper 	= createWrapper(errorLogger)
+)
+
+// SetWriter
+// 	Configure the logger to use this writer.
+// ---------------------------------------------------------
+func SetWriter(handle io.Writer) {
+
+	// Info is standard logger.
+	stdlog.SetOutput(handle)
+
+	noticeLogger.SetOutput(handle)
+	warningLogger.SetOutput(handle)
+	errorLogger.SetOutput(handle)
+}

src/log/log.go

@@ -1,49 +0,0 @@
-
-package log
-
-import "fmt"
-
-// Colors
-// ---------------------------------------------------------
-const (
-	InfoColor    = "\033[1;34m%s\033[0m"
-	NoticeColor  = "\033[1;36m%s\033[0m"
-	WarningColor = "\033[1;33m%s\033[0m"
-	ErrorColor   = "\033[1;31m%s\033[0m"
-)
-
-// Define LogFunc prototype
-//  Function that takes a format string and variadic number
-//  of arguments (like printf)
-// ---------------------------------------------------------
-type LogFunc func(format string, args ...interface{})
-
-// Create a log function.
-//  This is the base logging function. by providing a prefix
-//  a new log function of LogFunc type will be created
-//  appending "[ <prefix> ]" before the message.
-// ---------------------------------------------------------
-func logfn(prefix string) LogFunc {
-	return func(format string, args ...interface{}) {
-		format = "[" + prefix + "] " + format + "\n"
-		fmt.Printf(format, args...)
-	}
-}
-
-// Declare our different log functions.
-// ---------------------------------------------------------
-var Info LogFunc
-var Notice LogFunc
-var Warning LogFunc
-var Error LogFunc
-
-// Initilize log module
-// ---------------------------------------------------------
-func init() {
-
-	// Initilize functions.
-	Info 	= logfn(fmt.Sprintf(InfoColor, "INFO"))
-	Notice 	= logfn(fmt.Sprintf(NoticeColor, "NOTICE"))
-	Warning = logfn(fmt.Sprintf(WarningColor, "WARN"))
-	Error 	= logfn(fmt.Sprintf(ErrorColor, "ERROR"))
-}

src/log/wrapper.go

@@ -0,0 +1,83 @@
+
+package log
+
+import (
+	"os"
+	stdlog "log"
+)
+
+
+// ---------------------------------------------------------
+//  Constants
+// ---------------------------------------------------------
+
+
+// Default flags to use.
+const defaultFlags = stdlog.Lmsgprefix | stdlog.Ldate | stdlog.Ltime | stdlog.Lmicroseconds
+
+// Prefixes
+const (
+	InfoPrefix    = "\033[1;34mINFO\033[0m   : "
+	NoticePrefix  = "\033[1;36mNOTICE\033[0m : "
+	WarningPrefix = "\033[1;33mWARN\033[0m   : "
+	ErrorPrefix   = "\033[1;31mERROR\033[0m  : "
+)
+
+
+// ---------------------------------------------------------
+//  Function wrappers
+// ---------------------------------------------------------
+
+
+// Define logWrapper prototype
+//  Function that takes a format string and variadic number
+//  of arguments (like printf)
+// ---------------------------------------------------------
+type logWrapper func(format string, args ...interface{})
+
+// Create a wrapper function.
+//  This creates a function wrapper around
+//  stdlog.Logger.Printf()
+// ---------------------------------------------------------
+func createWrapper(logger *stdlog.Logger) logWrapper {
+	return func(format string, args ...interface{}) {
+		logger.Printf(format, args...)
+	}
+}
+
+// Standard log wrapper
+//  Wrapper around stdlog.Printf()
+// ---------------------------------------------------------
+func stdWrapper(format string, args ...interface{}) {
+	stdlog.Printf(format, args...)
+}
+
+
+// ---------------------------------------------------------
+//  Logger objects.
+// ---------------------------------------------------------
+
+
+var (
+	// Info is standard logger. omitted here as we don't have direct access to the object.
+	warningLogger 	*stdlog.Logger = stdlog.New(os.Stdout, WarningPrefix, defaultFlags)
+	noticeLogger 	*stdlog.Logger = stdlog.New(os.Stdout, NoticePrefix, defaultFlags)
+	errorLogger 	*stdlog.Logger = stdlog.New(os.Stdout, ErrorPrefix, defaultFlags)
+)
+
+
+// ---------------------------------------------------------
+//  Initilize the module
+// ---------------------------------------------------------
+
+
+func init() {
+
+	// Info is standard logger.
+	// We are not allowed to access the standard
+	// Logger object, so we have to use the standalone functions.
+
+	stdlog.SetOutput(os.Stdout)
+	stdlog.SetPrefix(InfoPrefix)
+	stdlog.SetFlags(defaultFlags)
+}