Add ColorHeaderAndFields logger option

intlogger.go

@@ -70,6 +70,7 @@ type intLogger struct {
 	level  *int32
 
 	headerColor ColorOption
+	fieldColor  ColorOption
 
 	implied []interface{}
 
@@ -115,14 +116,19 @@ func newLogger(opts *LoggerOptions) *intLogger {
 		mutex = new(sync.Mutex)
 	}
 
-	var primaryColor, headerColor ColorOption
-
-	if opts.ColorHeaderOnly {
-		primaryColor = ColorOff
+	var (
+		primaryColor ColorOption = ColorOff
+		headerColor  ColorOption = ColorOff
+		fieldColor   ColorOption = ColorOff
+	)
+	switch {
+	case opts.ColorHeaderOnly:
 		headerColor = opts.Color
-	} else {
+	case opts.ColorHeaderAndFields:
+		fieldColor = opts.Color
+		headerColor = opts.Color
+	default:
 		primaryColor = opts.Color
-		headerColor = ColorOff
 	}
 
 	l := &intLogger{
@@ -137,6 +143,7 @@ func newLogger(opts *LoggerOptions) *intLogger {
 		exclude:           opts.Exclude,
 		independentLevels: opts.IndependentLevels,
 		headerColor:       headerColor,
+		fieldColor:        fieldColor,
 	}
 	if opts.IncludeLocation {
 		l.callerOffset = offsetIntLogger + opts.AdditionalLocationOffset
@@ -235,7 +242,18 @@ func needsQuoting(str string) bool {
 	return false
 }
 
-// Non-JSON logging format function
+// logPlain is the non-JSON logging format function which writes directly
+// to the underlying writer the logger was initialized with.
+//
+// If the logger was initialized with a color function, it also handles
+// applying the color to the log message.
+//
+// Color Options
+//  1. No color.
+//  2. Color the whole log line, based on the level.
+//  3. Color only the header (level) part of the log line.
+//  4. Color both the header and fields of the log line.
+//
 func (l *intLogger) logPlain(t time.Time, name string, level Level, msg string, args ...interface{}) {
 
 	if !l.disableTime {
@@ -245,10 +263,11 @@ func (l *intLogger) logPlain(t time.Time, name string, level Level, msg string,
 
 	s, ok := _levelToBracket[level]
 	if ok {
-		if l.headerColor != ColorOff {
+		switch {
+		case l.headerColor != ColorOff:
 			color := _levelToColor[level]
 			color.Fprint(l.writer, s)
-		} else {
+		default:
 			l.writer.WriteString(s)
 		}
 	} else {
@@ -281,7 +300,7 @@ func (l *intLogger) logPlain(t time.Time, name string, level Level, msg string,
 
 	var stacktrace CapturedStacktrace
 
-	if args != nil && len(args) > 0 {
+	if len(args) > 0 {
 		if len(args)%2 != 0 {
 			cs, ok := args[len(args)-1].(CapturedStacktrace)
 			if ok {
@@ -295,13 +314,16 @@ func (l *intLogger) logPlain(t time.Time, name string, level Level, msg string,
 
 		l.writer.WriteByte(':')
 
+		// Handle the field arguments, which come in pairs (key=val).
 	FOR:
 		for i := 0; i < len(args); i = i + 2 {
 			var (
+				key string
 				val string
 				raw bool
 			)
 
+			// Convert the field value to a string.
 			switch st := args[i+1].(type) {
 			case string:
 				val = st
@@ -353,32 +375,69 @@ func (l *intLogger) logPlain(t time.Time, name string, level Level, msg string,
 				}
 			}
 
-			var key string
-
+			// Convert the field key to a string.
 			switch st := args[i].(type) {
 			case string:
 				key = st
 			default:
 				key = fmt.Sprintf("%s", st)
 			}
 
-			if strings.Contains(val, "\n") {
-				l.writer.WriteString("\n  ")
-				l.writer.WriteString(key)
-				l.writer.WriteString("=\n")
-				writeIndent(l.writer, val, "  | ")
-				l.writer.WriteString("  ")
-			} else if !raw && needsQuoting(val) {
+			// Optionally apply the ANSI "dim" (faint) and "bold"
+			// SGR values to the key.
+			if l.fieldColor != ColorOff {
+				color := color.New(color.Faint, color.Bold)
+				key = color.Sprint(key)
+			}
+
+			// Values may contain multiple lines, and that format
+			// is preserved, with each line prefixed with a "  | "
+			// to show it's part of a collection of lines.
+			//
+			// Values may also neeq quoting, if not all the runes
+			// in the value string are "normal", like if they
+			// contain ANSI escape sequences.
+			switch {
+			case strings.Contains(val, "\n"):
+				key = "\n  " + key
+
+				valStrBuilder := &strings.Builder{}
+				valStrWriter := newWriter(valStrBuilder, ColorOff)
+
+				valStrBuilder.WriteString("\n")
+
+				if l.fieldColor != ColorOff {
+					color := color.New(color.Faint)
+					writeIndent(valStrWriter, val, color.Sprint("  | "))
+				} else {
+					writeIndent(valStrWriter, val, "  | ")
+				}
+				valStrWriter.Flush(level)
+
+				valStrBuilder.WriteString("  ")
+
+				val = valStrBuilder.String()
+			case !raw && needsQuoting(val):
+				val = strconv.Quote(val)
+			}
+
+			// If the key contains a newline, because the value itself
+			// contains newlines, then we pad with an extra space.
+			if !strings.Contains(key, "\n") {
 				l.writer.WriteByte(' ')
-				l.writer.WriteString(key)
-				l.writer.WriteByte('=')
-				l.writer.WriteString(strconv.Quote(val))
+			}
+			l.writer.WriteString(key)
+
+			if l.fieldColor != ColorOff {
+				faintColor := color.New(color.Faint)
+				faintColor.Fprint(l.writer, "=")
+				resetColor := color.New(color.Reset)
+				resetColor.Fprint(l.writer, "")
 			} else {
-				l.writer.WriteByte(' ')
-				l.writer.WriteString(key)
 				l.writer.WriteByte('=')
-				l.writer.WriteString(val)
 			}
+
+			l.writer.WriteString(val)
 		}
 	}
 

logger.go

@@ -274,6 +274,10 @@ type LoggerOptions struct {
 	// Only color the header, not the body. This can help with readability of long messages.
 	ColorHeaderOnly bool
 
+	// Color the header and message body fields. This can help with readability
+	// of long messages with multiple fields.
+	ColorHeaderAndFields bool
+
 	// A function which is called with the log information and if it returns true the value
 	// should not be logged.
 	// This is useful when interacting with a system that you wish to suppress the log