Cleared up code to go dir.

config/config.go

@@ -17,92 +17,109 @@ type LogFlag int
 type LogDir string
 
 var (
-	Trace   *log.Logger
-	Info    *log.Logger
-	Warning *log.Logger
-	Error   *log.Logger
-	Panic   *log.Logger
-)
-
-var (
-	DISCARD_HANDLE LogHandle = ioutil.Discard
-	HANDLE_TRACE   LogHandle = os.Stdout
-	HANDLE_INFO    LogHandle = os.Stdout
-	HANDLE_WARNING LogHandle = os.Stdout
-	HANDLE_ERROR   LogHandle = os.Stderr
-	HANDLE_PANIC   LogHandle = os.Stderr
-	LOG_DIR        LogDir    = LogDir(os.TempDir() + string(os.PathSeparator) + "go-log")
-	FILE_EXTRA     string    = ""
-	LOG_FORMAT               = log.Ldate | log.Lmicroseconds
+	// DiscardHandle: used when log level isnt reached (discard log)
+	DiscardHandle LogHandle = ioutil.Discard
+	// HandleTrace: output dest for trace log
+	HandleTrace LogHandle = os.Stdout
+	// HandleInfo: output dest for info log
+	HandleInfo LogHandle = os.Stdout
+	// HandleWarning: output dest for warning log
+	HandleWarning LogHandle = os.Stdout
+	// HandleError: output dest for error log
+	HandleError LogHandle = os.Stdout
+	// HandlePanic: output dest for panic log
+	HandlePanic LogHandle = os.Stderr
+	// Ldir: Log directory, where file (not "output") logs are stored.
+	Ldir LogDir = LogDir(os.TempDir() + string(os.PathSeparator) + "go-log")
 )
 
 const (
-	FILE_MASK = os.O_CREATE | os.O_WRONLY | os.O_APPEND
-	FILE_PERM = 0666
+	// LogFormat: format in front of log text
+	LogFormat = log.Ldate | log.Lmicroseconds
+	// FileMask: filedescriptor mask
+	FileMask = os.O_CREATE | os.O_WRONLY | os.O_APPEND
+	// FilePerm: File permission, 0600
+	FilePerm = 0x029A
 )
 
 const (
-	PREFIX_TRACE   LogPrefix = "TRACE"
-	PREFIX_INFO    LogPrefix = "INFO"
-	PREFIX_WARNING LogPrefix = "WARNING"
-	PREFIX_ERROR   LogPrefix = "ERROR"
-	PREFIX_PANIC   LogPrefix = "PANIC"
+	// PrefixTrace: Log prefix for trace
+	PrefixTrace LogPrefix = "TRACE"
+	// PrefixInfo: Log prefix for info
+	PrefixInfo LogPrefix = "INFO"
+	// PrefixWarning: Log prefix for warning
+	PrefixWarning LogPrefix = "WARNING"
+	// PrefixError: Log prefix for error
+	PrefixError LogPrefix = "ERROR"
+	// PrefixPanic: Log prefix for panic
+	PrefixPanic LogPrefix = "PANIC"
 )
 
 const (
-	TRACE   LogLevel = 1<<iota | 0
-	INFO    LogLevel = 1<<iota | TRACE
-	WARNING LogLevel = 1<<iota | INFO
-	ERROR   LogLevel = 1<<iota | WARNING
-	PANIC   LogLevel = 1<<iota | ERROR
+	// Trace level
+	Trace LogLevel = 1<<iota | 0
+	// Info level
+	Info LogLevel = 1<<iota | Trace
+	// Warning level
+	Warning LogLevel = 1<<iota | Info
+	// Error level
+	Error LogLevel = 1<<iota | Warning
+	// Panic level
+	Panic LogLevel = 1<<iota | Error
 )
 
 var (
-	LOG_LEVEL_OUTPUT LogLevel = INFO
-	LOG_LEVEL_FILE   LogLevel = WARNING
+	// Llo (log level output)
+	Llo LogLevel = Info
+	// Llf (log level file)
+	Llf LogLevel = Warning
 )
 
+// Set log level
 func (c *LogLevel) Set(l string) error {
 
 	l = strings.ToUpper(l)
 
 	if l == "TRACE" {
-		*c = TRACE
+		*c = Trace
 	} else if l == "INFO" {
-		*c = INFO
+		*c = Info
 	} else if l == "WARNING" {
-		*c = WARNING
+		*c = Warning
 	} else if l == "ERROR" {
-		*c = ERROR
+		*c = Error
 	} else if l == "PANIC" {
-		*c = PANIC
+		*c = Panic
 	} else {
-		return errors.UNKNOWN_LEVEL
+		return errors.UnknownLevel
 	}
 
 	return nil
 }
 
+// String function to print log level
 func (c *LogLevel) String() string {
 	switch *c {
-	case TRACE:
+	case Trace:
 		return "TRACE"
-	case INFO:
+	case Info:
 		return "INFO"
-	case WARNING:
+	case Warning:
 		return "WARNING"
-	case ERROR:
+	case Error:
 		return "ERROR"
 	default:
 		return "PANIC"
 	}
 }
 
+// Set logging directory
 func (d *LogDir) Set(nd string) error {
-	LOG_DIR = LogDir(nd)
+	Ldir = LogDir(nd)
 	return nil
 }
 
+// String function to print log level
 func (d *LogDir) String() string {
 	return string(*d)
 }

errors/errors.go

@@ -5,8 +5,8 @@ import (
 )
 
 var (
-	UNKNOWN_LOGGER = e.New("Unknown logger")
-	UNKNOWN_LEVEL  = e.New("Unknown log level: TRACE|INFO|WARNING|ERROR|PANIC")
+	UnknownLogger = e.New("Unknown logger")
+	UnknownLevel  = e.New("Unknown log level: TRACE|INFO|WARNING|ERROR|PANIC")
 
-	INVALID_PATH = e.New("Invalid path")
+	InvalidPath = e.New("Invalid path")
 )

log/log.go

@@ -12,12 +12,29 @@ import (
 	"git.giaever.org/joachimmg/go-log.git/errors"
 )
 
+// Init flags
+func init() {
+	flag.Var(&config.Llo, "llo", "Minimum log level that will be written to stdout.")
+	flag.Var(&config.Llf, "llf", "Minimum log level that will be written to file")
+	flag.Var(&config.Ldir, "ldir", "Directory to log to")
+}
+
+// Loggers
+var (
+	logTrace   *_log.Logger
+	logInfo    *_log.Logger
+	logWarning *_log.Logger
+	logError   *_log.Logger
+	logPanic   *_log.Logger
+)
+
+// Create log-file in director: Also creates the directory tree.
 func log_file(p config.LogPrefix) *os.File {
-	os.MkdirAll(config.LOG_DIR.String(), 0777)
+	os.MkdirAll(config.Ldir.String(), 0777)
 	f, err := os.OpenFile(
-		fmt.Sprintf("%s%c%s%s.log", config.LOG_DIR, os.PathSeparator, strings.ToLower(string(p)), config.FILE_EXTRA),
-		config.FILE_MASK,
-		config.FILE_PERM,
+		fmt.Sprintf("%s%c%s.log", config.Ldir, os.PathSeparator, strings.ToLower(string(p))),
+		config.FileMask,
+		config.FilePerm,
 	)
 
 	if err != nil {
@@ -28,144 +45,163 @@ func log_file(p config.LogPrefix) *os.File {
 	return f
 }
 
+// Create new logger
 func log_new(l config.LogLevel, h config.LogHandle, p config.LogPrefix) *_log.Logger {
 
-	if (config.LOG_LEVEL_FILE&l) == config.LOG_LEVEL_FILE && (config.LOG_LEVEL_OUTPUT&l) == config.LOG_LEVEL_OUTPUT {
+	if (config.Llf&l) == config.Llf && (config.Llo&l) == config.Llo {
 		f := log_file(p)
 		return _log.New(
 			io.MultiWriter(f, h),
 			fmt.Sprintf("%s ", p),
-			config.LOG_FORMAT,
+			config.LogFormat,
 		)
 	}
 
-	if (config.LOG_LEVEL_FILE & l) == config.LOG_LEVEL_FILE {
+	if (config.Llf & l) == config.Llf {
 		f := log_file(p)
 		return _log.New(
 			f, fmt.Sprintf("%s ", p),
-			config.LOG_FORMAT,
+			config.LogFormat,
 		)
 	}
 
-	if (config.LOG_LEVEL_OUTPUT & l) == config.LOG_LEVEL_OUTPUT {
+	if (config.Llo & l) == config.Llo {
 		return _log.New(
 			h, fmt.Sprintf("%s ", p),
-			config.LOG_FORMAT,
+			config.LogFormat,
 		)
 	}
 
 	return _log.New(
-		config.DISCARD_HANDLE, fmt.Sprintf("%s ", p),
-		config.LOG_FORMAT,
+		config.DiscardHandle, fmt.Sprintf("%s ", p),
+		config.LogFormat,
 	)
 }
 
-func init() {
-	flag.Var(&config.LOG_LEVEL_OUTPUT, "llo", "Minimum log level that will be written to stdout.")
-	flag.Var(&config.LOG_LEVEL_FILE, "llf", "Minimum log level that will be written to file")
-	flag.Var(&config.LOG_DIR, "ldir", "Directory to log to")
-}
-
+// Internal log function based on log level
 func log(t config.LogLevel) *_log.Logger {
 	var l *_log.Logger
 	switch t {
-	case config.TRACE:
-		if config.Trace == nil {
-			config.Trace = log_new(t, config.HANDLE_TRACE, config.PREFIX_TRACE)
+	case config.Trace:
+		if logTrace == nil {
+			logTrace = log_new(t, config.HandleTrace, config.PrefixTrace)
 		}
-		l = config.Trace
-	case config.INFO:
-		if config.Info == nil {
-			config.Info = log_new(t, config.HANDLE_INFO, config.PREFIX_INFO)
+		l = logTrace
+	case config.Info:
+		if logInfo == nil {
+			logInfo = log_new(t, config.HandleInfo, config.PrefixInfo)
 		}
-		l = config.Info
-	case config.WARNING:
-		if config.Warning == nil {
-			config.Warning = log_new(t, config.HANDLE_WARNING, config.PREFIX_WARNING)
+		l = logInfo
+	case config.Warning:
+		if logWarning == nil {
+			logWarning = log_new(t, config.HandleWarning, config.PrefixWarning)
 		}
-		l = config.Warning
-	case config.ERROR:
-		if config.Error == nil {
-			config.Error = log_new(t, config.HANDLE_ERROR, config.PREFIX_ERROR)
+		l = logWarning
+	case config.Error:
+		if logError == nil {
+			logError = log_new(t, config.HandleError, config.PrefixError)
 		}
-		l = config.Error
-	case config.PANIC:
-		if config.Panic == nil {
-			config.Panic = log_new(t, config.HANDLE_ERROR, config.PREFIX_PANIC)
+		l = logError
+	case config.Panic:
+		if logPanic == nil {
+			logPanic = log_new(t, config.HandlePanic, config.PrefixPanic)
 		}
-		l = config.Panic
+		l = logPanic
 	}
 
 	if l == nil {
-		_log.Panic(errors.UNKNOWN_LOGGER.Error())
+		_log.Panic(errors.UnknownLogger.Error())
 	}
 
 	return l
 }
 
-func LLO() *config.LogLevel {
-	return &config.LOG_LEVEL_OUTPUT
+// Llo returns output log level config
+func Llo() *config.LogLevel {
+	return &config.Llo
+}
+
+// Llf return file log level config
+func Llf() *config.LogLevel {
+	return &config.Llf
 }
 
-func LLF() *config.LogLevel {
-	return &config.LOG_LEVEL_FILE
+// Ldir return log directory config
+func Ldir() *config.LogDir {
+	return &config.Ldir
 }
 
+// Trace
 func Trace(m string) {
-	log(config.TRACE).Print(m)
+	log(config.Trace).Print(m)
 }
 
+// Tracef: format
 func Tracef(f string, v ...interface{}) {
-	log(config.TRACE).Printf(f, v...)
+	log(config.Trace).Printf(f, v...)
 }
 
+// Traceln: format standard
 func Traceln(v ...interface{}) {
-	log(config.TRACE).Println(v...)
+	log(config.Trace).Println(v...)
 }
 
+// Info
 func Info(m string) {
-	log(config.INFO).Print(m)
+	log(config.Info).Print(m)
 }
 
+// Infof: format
 func Infof(f string, v ...interface{}) {
-	log(config.INFO).Printf(f, v...)
+	log(config.Info).Printf(f, v...)
 }
 
+// Info: format standard
 func Infoln(v ...interface{}) {
-	log(config.INFO).Println(v...)
+	log(config.Info).Println(v...)
 }
 
+// Warning
 func Warning(m string) {
-	log(config.WARNING).Print(m)
+	log(config.Warning).Print(m)
 }
 
+// Warningf: format
 func Warningf(f string, v ...interface{}) {
-	log(config.WARNING).Printf(f, v...)
+	log(config.Warning).Printf(f, v...)
 }
 
+// Warningln: format standard
 func Warningln(v ...interface{}) {
-	log(config.WARNING).Println(v...)
+	log(config.Warning).Println(v...)
 }
+
+// Error
 func Error(m string) {
-	log(config.ERROR).Fatal(m)
+	log(config.Error).Fatal(m)
 }
 
+// Errorf: format
 func Errorf(f string, v ...interface{}) {
-	log(config.ERROR).Fatalf(f, v...)
+	log(config.Error).Fatalf(f, v...)
 }
 
+// Errorln: format standard
 func Errorln(v ...interface{}) {
-	log(config.ERROR).Fatalln(v...)
+	log(config.Error).Fatalln(v...)
 }
 
+// Panic
 func Panic(m string) {
-	log(config.PANIC).Panic(m)
+	log(config.Panic).Panic(m)
 }
 
+// Panicf: format
 func Panicf(f string, v ...interface{}) {
-	log(config.PANIC).Panicf(f, v...)
+	log(config.Panic).Panicf(f, v...)
 }
 
+// Panicln: format standard
 func Panicln(v ...interface{}) {
-	log(config.PANIC).Panicln(v...)
+	log(config.Panic).Panicln(v...)
 }