From ebf209427a694c2fc6af63d3b64ae9c25f1d1334 Mon Sep 17 00:00:00 2001
From: Christian Schwarz <me@cschwarz.com>
Date: Sat, 23 Dec 2017 01:22:38 +0100
Subject: [PATCH] logging: support ignoring fields in HumanFormatter

should be refactored to logger one day so the implementation of ignoring
is not duplicated to each outlet.

refs #10
---
 cmd/logging_formatters.go | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/cmd/logging_formatters.go b/cmd/logging_formatters.go
index dc668ca..754d26a 100644
--- a/cmd/logging_formatters.go
+++ b/cmd/logging_formatters.go
@@ -41,12 +41,29 @@ func (f NoFormatter) Format(e *logger.Entry) ([]byte, error) {
 
 type HumanFormatter struct {
 	metadataFlags MetadataFlags
+	ignoreFields  map[string]bool
 }
 
 func (f *HumanFormatter) SetMetadataFlags(flags MetadataFlags) {
 	f.metadataFlags = flags
 }
 
+func (f *HumanFormatter) SetIgnoreFields(ignore []string) {
+	if ignore == nil {
+		f.ignoreFields = nil
+		return
+	}
+	f.ignoreFields = make(map[string]bool, len(ignore))
+
+	for _, field := range ignore {
+		f.ignoreFields[field] = true
+	}
+}
+
+func (f *HumanFormatter) ignored(field string) bool {
+	return f.ignoreFields != nil && f.ignoreFields[field]
+}
+
 func (f *HumanFormatter) Format(e *logger.Entry) (out []byte, err error) {
 
 	var line bytes.Buffer
@@ -63,8 +80,10 @@ func (f *HumanFormatter) Format(e *logger.Entry) (out []byte, err error) {
 	for _, field := range prefixFields {
 		val, ok := e.Fields[field].(string)
 		if ok {
-			fmt.Fprintf(&line, "[%s]", val)
-			prefixed[field] = true
+			if !f.ignored(field) {
+				fmt.Fprintf(&line, "[%s]", val)
+				prefixed[field] = true
+			}
 		} else {
 			break
 		}
@@ -72,13 +91,13 @@ func (f *HumanFormatter) Format(e *logger.Entry) (out []byte, err error) {
 	// even more prefix fields
 	mapFrom, mapFromOk := e.Fields[logMapFromField].(string)
 	mapTo, mapToOk := e.Fields[logMapToField].(string)
-	if mapFromOk && mapToOk {
+	if mapFromOk && mapToOk && !f.ignored(logMapFromField) && !f.ignored(logMapToField) {
 		fmt.Fprintf(&line, "[%s => %s]", mapFrom, mapTo)
 		prefixed[logMapFromField], prefixed[logMapToField] = true, true
 	}
 	incFrom, incFromOk := e.Fields[logIncFromField].(string)
 	incTo, incToOk := e.Fields[logIncToField].(string)
-	if incFromOk && incToOk {
+	if incFromOk && incToOk && !f.ignored(logIncFromField) && !f.ignored(logMapToField) {
 		fmt.Fprintf(&line, "[%s => %s]", incFrom, incTo)
 		prefixed[logIncFromField], prefixed[logIncToField] = true, true
 	}
@@ -92,7 +111,7 @@ func (f *HumanFormatter) Format(e *logger.Entry) (out []byte, err error) {
 		fmt.Fprint(&line, " ")
 		enc := logfmt.NewEncoder(&line)
 		for field, value := range e.Fields {
-			if prefixed[field] {
+			if prefixed[field] || f.ignored(field) {
 				continue
 			}
 			if err := logfmtTryEncodeKeyval(enc, field, value); err != nil {