log.go

@@ -10,30 +10,46 @@ import (
 
 // All log functions
 var (
-	Debug    = logFunc(LevelDebug)
-	Info     = logFunc(LevelInfo)
-	Warning  = logFunc(LevelWarning)
-	Error    = logFunc(LevelError)
-	Critical = logFunc(LevelCritical)
+	Debug     = logFunc(LevelDebug)
+	Debugf    = logfFunc(LevelDebug)
+	Info      = logFunc(LevelInfo)
+	Infof     = logfFunc(LevelInfo)
+	Warning   = logFunc(LevelWarning)
+	Warningf  = logfFunc(LevelWarning)
+	Error     = logFunc(LevelError)
+	Errorf    = logfFunc(LevelError)
+	Critical  = logFunc(LevelCritical)
+	Criticalf = logfFunc(LevelCritical)
 )
 
 func logFunc(level LevelType) func(...interface{}) {
 	return func(message ...interface{}) {
-		writeMessage(level, message)
+		writeMessage(level, ``, message)
+	}
+}
+
+func logfFunc(level LevelType) func(string, ...interface{}) {
+	return func(format string, a ...interface{}) {
+		writeMessage(level, format, a)
 	}
 }
 
 var mu sync.Mutex
 
-func writeMessage(level LevelType, message []interface{}) {
+func writeMessage(level LevelType, format string, message []interface{}) {
 	if MinLevel > level {
 		return
 	}
 
 	entry := LogEntry{
-		Level:   level,
-		Time:    time.Now(),
-		Message: fmt.Sprint(message...),
+		Level: level,
+		Time:  time.Now(),
+	}
+
+	if format == `` {
+		entry.Message = fmt.Sprint(message...)
+	} else {
+		entry.Message = fmt.Sprintf(format, message...)
 	}
 
 	if MinStackLevel <= level {

log_test.go

@@ -55,6 +55,16 @@ func TestLogLevel(t *testing.T) {
 	MinLevel, Output = LevelInfo, nil
 }
 
+func TestLogf(t *testing.T) {
+	b := bytes.Buffer{}
+	Output = &b
+
+	Infof(`Test%s-%d`, `tt`, 1)
+	assert.True(t, strings.Contains(b.String(), `Testtt-1`))
+
+	Output = nil
+}
+
 func TestStackTrace(t *testing.T) {
 	b := bytes.Buffer{}
 	Output = &b