Move FieldsOrder work to separate method and only call if necessary

console.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/mattn/go-colorable"
 )
 
 const (
@@ -64,6 +66,8 @@ type ConsoleWriter struct {
 	// FieldsOrder defines the order of contextual fields in output.
 	FieldsOrder []string
 
+	fieldIsOrdered map[string]bool
+
 	// FieldsExclude defines contextual fields to not display in output.
 	FieldsExclude []string
 
@@ -167,15 +171,6 @@ func (w ConsoleWriter) Close() error {
 
 // writeFields appends formatted key-value pairs to buf.
 func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer) {
-	var isOrderedField = make(map[string]bool)
-	var orderedFields = make([]string, 0, len(w.FieldsOrder))
-	for _, fieldName := range w.FieldsOrder {
-		if evt[fieldName] != nil {
-			orderedFields = append(orderedFields, fieldName)
-			isOrderedField[fieldName] = true
-		}
-	}
-
 	var fields = make([]string, 0, len(evt))
 	for field := range evt {
 		var isExcluded bool
@@ -194,26 +189,24 @@ func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer
 			continue
 		}
 
-		if isOrderedField[field] {
-			continue
-		}
-
 		fields = append(fields, field)
 	}
 	sort.Strings(fields)
 
-	totalFields := len(orderedFields) + len(fields)
+	if len(w.FieldsOrder) > 0 {
+		fields = w.orderFields(fields)
+	}
 
 	// Write space only if something has already been written to the buffer, and if there are fields.
-	if buf.Len() > 0 && totalFields > 0 {
+	if buf.Len() > 0 && len(fields) > 0 {
 		buf.WriteByte(' ')
 	}
 
-	// Move the "error" field to the front of the orderedFields list
+	// Move the "error" field to the front
 	ei := sort.Search(len(fields), func(i int) bool { return fields[i] >= ErrorFieldName })
 	if ei < len(fields) && fields[ei] == ErrorFieldName {
 		fields[ei] = ""
-		orderedFields = append([]string{ErrorFieldName}, orderedFields...)
+		fields = append([]string{ErrorFieldName}, fields...)
 		var xfields = make([]string, 0, len(fields))
 		for _, field := range fields {
 			if field == "" { // Skip empty fields
@@ -224,7 +217,7 @@ func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer
 		fields = xfields
 	}
 
-	for i, field := range append(orderedFields, fields...) {
+	for i, field := range fields {
 		var fn Formatter
 		var fv Formatter
 
@@ -274,7 +267,7 @@ func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer
 			}
 		}
 
-		if i < totalFields-1 { // Skip space for last field
+		if i < len(fields)-1 { // Skip space for last field
 			buf.WriteByte(' ')
 		}
 	}
@@ -335,6 +328,34 @@ func (w ConsoleWriter) writePart(buf *bytes.Buffer, evt map[string]interface{},
 	}
 }
 
+// orderFields takes an array of field names and an array representing field order
+// and returns an array with any ordered fields at the beginning, in order,
+// and the remaining fields after in their original order.
+func (w ConsoleWriter) orderFields(fields []string) []string {
+	if w.fieldIsOrdered == nil {
+		w.fieldIsOrdered = make(map[string]bool)
+		for _, fieldName := range w.FieldsOrder {
+			w.fieldIsOrdered[fieldName] = true
+		}
+	}
+	hasOrderedField := make(map[string]bool)
+	otherFields := make([]string, 0, len(fields))
+	for _, fieldName := range fields {
+		if w.fieldIsOrdered[fieldName] {
+			hasOrderedField[fieldName] = true
+		} else {
+			otherFields = append(otherFields, fieldName)
+		}
+	}
+	result := make([]string, 0, len(fields))
+	for _, fieldName := range w.FieldsOrder {
+		if hasOrderedField[fieldName] {
+			result = append(result, fieldName)
+		}
+	}
+	return append(result, otherFields...)
+}
+
 // needsQuote returns true when the string s should be quoted in output.
 func needsQuote(s string) bool {
 	for i := range s {

console_test.go

@@ -382,13 +382,13 @@ func TestConsoleWriterConfiguration(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, FieldsOrder: []string{"zebra", "aardvark"}}
 
-		evt := `{"level": "info", "message": "Zoo", "aardvark": "Able", "zebra": "Zulu"}`
+		evt := `{"level": "info", "message": "Zoo", "aardvark": "Able", "mussel": "Mountain", "zebra": "Zulu"}`
 		_, err := w.Write([]byte(evt))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := "<nil> INF Zoo zebra=Zulu aardvark=Able\n"
+		expectedOutput := "<nil> INF Zoo zebra=Zulu aardvark=Able mussel=Mountain\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)