✨ Add log methods with ln at the end

Author: jessedearing

log.go

@@ -20,6 +20,11 @@ type Logger interface {
 	Warn(msg ...interface{})
 	Error(msg ...interface{})
 
+	Debugln(msg ...interface{})
+	Infoln(msg ...interface{})
+	Warnln(msg ...interface{})
+	Errorln(msg ...interface{})
+
 	Debugf(format string, args ...interface{})
 	Infof(format string, args ...interface{})
 	Warnf(format string, args ...interface{})
@@ -86,6 +91,26 @@ func (b *simple) Error(msg ...interface{}) {
 	stdlog.Printf("[ERROR] %s %s", fmt.Sprint(msg...), pretty(b.fields))
 }
 
+// Debugln log line message
+func (b *simple) Debugln(msg ...interface{}) {
+	stdlog.Println("[DEBUG]", fmt.Sprintln(msg...), pretty(b.fields))
+}
+
+// Infoln log line message
+func (b *simple) Infoln(msg ...interface{}) {
+	stdlog.Println("[INFO]", fmt.Sprintln(msg...), pretty(b.fields))
+}
+
+// Warnln log line message
+func (b *simple) Warnln(msg ...interface{}) {
+	stdlog.Println("[WARN]", fmt.Sprintln(msg...), pretty(b.fields))
+}
+
+// Errorln log line message
+func (b *simple) Errorln(msg ...interface{}) {
+	stdlog.Println("[ERROR]", fmt.Sprintln(msg...), pretty(b.fields))
+}
+
 // Debugf log message with formatting
 func (b *simple) Debugf(format string, args ...interface{}) {
 	stdlog.Print(fmt.Sprintf("[DEBUG] "+format, args...), " ", pretty(b.fields))
@@ -144,6 +169,18 @@ func (n *noop) Warn(msg ...interface{}) {}
 // Error log message no-op
 func (n *noop) Error(msg ...interface{}) {}
 
+// Debugln line log message no-op
+func (n *noop) Debugln(msg ...interface{}) {}
+
+// Infoln line log message no-op
+func (n *noop) Infoln(msg ...interface{}) {}
+
+// Warnln line log message no-op
+func (n *noop) Warnln(msg ...interface{}) {}
+
+// Errorln line log message no-op
+func (n *noop) Errorln(msg ...interface{}) {}
+
 // Debugf log message with formatting no-op
 func (n *noop) Debugf(format string, args ...interface{}) {}
 

log_test.go

@@ -45,6 +45,26 @@ var _ = Describe("simple logger", func() {
 			}
 		})
 
+		It("prints all log line levels", func() {
+			logFuncs := map[string]func(...interface{}){
+				"DEBUG": l.Debugln,
+				"INFO":  l.Infoln,
+				"WARN":  l.Warnln,
+				"ERROR": l.Errorln,
+			}
+
+			for level, logFunc := range logFuncs {
+				logFunc("hi", "there")
+
+				b := newOut.Bytes()
+				newOut.Reset()
+				Expect(string(b)).To(SatisfyAll(
+					ContainSubstring("hi there"),
+					ContainSubstring(level),
+				))
+			}
+		})
+
 		It("prints all log levels on formatted", func() {
 			logFuncs := map[string]func(string, ...interface{}){
 				"DEBUG": l.Debugf,

shims/logrus/logrus_test.go

@@ -47,6 +47,26 @@ var _ = Describe("logrus logger", func() {
 			}
 		})
 
+		It("prints all log levels", func() {
+			logFuncs := map[string]func(...interface{}){
+				"debug": l.Debugln,
+				"info":  l.Infoln,
+				"warn":  l.Warnln,
+				"error": l.Errorln,
+			}
+
+			for level, logFunc := range logFuncs {
+				logFunc("hi", "there")
+
+				b := newOut.Bytes()
+				newOut.Reset()
+				Expect(string(b)).To(SatisfyAll(
+					ContainSubstring("hi there"),
+					ContainSubstring("level="+level),
+				))
+			}
+		})
+
 		It("prints all log levels on formatted", func() {
 			logFuncs := map[string]func(string, ...interface{}){
 				"debug": l.Debugf,

shims/testlog/testlog.go

@@ -49,6 +49,26 @@ func (t *TestLogger) write(level, msg string) {
 	t.count.inc()
 }
 
+//Debugln log line message
+func (t *TestLogger) Debugln(msg ...interface{}) {
+	t.write("DEBUG", fmt.Sprintln(msg...))
+}
+
+//Infoln log line message
+func (t *TestLogger) Infoln(msg ...interface{}) {
+	t.write("INFO", fmt.Sprintln(msg...))
+}
+
+//Warnln log line message
+func (t *TestLogger) Warnln(msg ...interface{}) {
+	t.write("WARN", fmt.Sprintln(msg...))
+}
+
+//Errorln log line message
+func (t *TestLogger) Errorln(msg ...interface{}) {
+	t.write("ERROR", fmt.Sprintln(msg...))
+}
+
 // Debug log message
 func (t *TestLogger) Debug(msg ...interface{}) {
 	t.write("DEBUG", fmt.Sprint(msg...))

shims/testlog/testlog_test.go

@@ -42,6 +42,26 @@ var _ = Describe("test logger", func() {
 			}
 		})
 
+		It("prints all log line levels", func() {
+			logFuncs := map[string]func(...interface{}){
+				"DEBUG": l.Debugln,
+				"INFO":  l.Infoln,
+				"WARN":  l.Warnln,
+				"ERROR": l.Errorln,
+			}
+
+			for level, logFunc := range logFuncs {
+				logFunc("hi", "there")
+
+				b := testOut.Bytes()
+				testOut.Reset()
+				Expect(string(b)).To(SatisfyAll(
+					ContainSubstring("hi there"),
+					ContainSubstring(level),
+				))
+			}
+		})
+
 		It("prints all log levels on formatted", func() {
 			logFuncs := map[string]func(string, ...interface{}){
 				"DEBUG": l.Debugf,