From c4721c0db70c8da8b764b148e035f9cbaa458709 Mon Sep 17 00:00:00 2001
From: soven <nicko54lay@mail.ru>
Date: Mon, 16 Nov 2020 22:02:21 +0300
Subject: [PATCH 1/4] fix log stdlibadapter when prefixed

---
 log/stdlib.go      | 36 ++++++++++++++++++++++++++++++---
 log/stdlib_test.go | 50 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 3 deletions(-)

diff --git a/log/stdlib.go b/log/stdlib.go
index ff96b5dee..6acd2e0f3 100644
--- a/log/stdlib.go
+++ b/log/stdlib.go
@@ -1,6 +1,7 @@
 package log
 
 import (
+	"bytes"
 	"io"
 	"log"
 	"regexp"
@@ -26,9 +27,11 @@ func (w StdlibWriter) Write(p []byte) (int, error) {
 // messages, and place them under relevant keys.
 type StdlibAdapter struct {
 	Logger
-	timestampKey string
-	fileKey      string
-	messageKey   string
+	timestampKey    string
+	fileKey         string
+	messageKey      string
+	prefix          string
+	joinPrefixToMsg bool
 }
 
 // StdlibAdapterOption sets a parameter for the StdlibAdapter.
@@ -49,6 +52,11 @@ func MessageKey(key string) StdlibAdapterOption {
 	return func(a *StdlibAdapter) { a.messageKey = key }
 }
 
+// Prefix sets value of the prefix for the actual log message. By default, there's no prefix.
+func Prefix(prefix string, joinPrefixToMsg bool) StdlibAdapterOption {
+	return func(a *StdlibAdapter) { a.prefix = prefix; a.joinPrefixToMsg = joinPrefixToMsg }
+}
+
 // NewStdlibAdapter returns a new StdlibAdapter wrapper around the passed
 // logger. It's designed to be passed to log.SetOutput.
 func NewStdlibAdapter(logger Logger, options ...StdlibAdapterOption) io.Writer {
@@ -65,6 +73,8 @@ func NewStdlibAdapter(logger Logger, options ...StdlibAdapterOption) io.Writer {
 }
 
 func (a StdlibAdapter) Write(p []byte) (int, error) {
+	p = a.handlePrefix(p)
+
 	result := subexps(p)
 	keyvals := []interface{}{}
 	var timestamp string
@@ -84,6 +94,7 @@ func (a StdlibAdapter) Write(p []byte) (int, error) {
 		keyvals = append(keyvals, a.fileKey, file)
 	}
 	if msg, ok := result["msg"]; ok {
+		msg = a.handleMessagePrefix(msg)
 		keyvals = append(keyvals, a.messageKey, msg)
 	}
 	if err := a.Logger.Log(keyvals...); err != nil {
@@ -92,6 +103,25 @@ func (a StdlibAdapter) Write(p []byte) (int, error) {
 	return len(p), nil
 }
 
+func (a StdlibAdapter) handlePrefix(p []byte) []byte {
+	if a.prefix != "" {
+		p = bytes.TrimPrefix(p, []byte(a.prefix))
+	}
+	return p
+}
+
+func (a StdlibAdapter) handleMessagePrefix(msg string) string {
+	if a.prefix == "" {
+		return msg
+	}
+
+	msg = strings.TrimPrefix(msg, a.prefix)
+	if a.joinPrefixToMsg {
+		msg = a.prefix + msg
+	}
+	return msg
+}
+
 const (
 	logRegexpDate = `(?P<date>[0-9]{4}/[0-9]{2}/[0-9]{2})?[ ]?`
 	logRegexpTime = `(?P<time>[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?)?[ ]?`
diff --git a/log/stdlib_test.go b/log/stdlib_test.go
index 90ebc5fa4..ae9d82ce4 100644
--- a/log/stdlib_test.go
+++ b/log/stdlib_test.go
@@ -72,6 +72,56 @@ func TestStdLibAdapterExtraction(t *testing.T) {
 	}
 }
 
+func TestStdLibAdapterPrefixedExtraction(t *testing.T) {
+	buf := &bytes.Buffer{}
+	logger := NewLogfmtLogger(buf)
+	writer := NewStdlibAdapter(logger, Prefix("some prefix ", false))
+	for input, want := range map[string]string{
+		"some prefix hello":                                            "msg=hello\n",
+		"some prefix 2009/01/23: hello":                                "ts=2009/01/23 msg=hello\n",
+		"some prefix 2009/01/23 01:23:23: hello":                       "ts=\"2009/01/23 01:23:23\" msg=hello\n",
+		"some prefix 01:23:23: hello":                                  "ts=01:23:23 msg=hello\n",
+		"some prefix 2009/01/23 01:23:23.123123: hello":                "ts=\"2009/01/23 01:23:23.123123\" msg=hello\n",
+		"some prefix 2009/01/23 01:23:23.123123 /a/b/c/d.go:23: hello": "ts=\"2009/01/23 01:23:23.123123\" caller=/a/b/c/d.go:23 msg=hello\n",
+		"some prefix 01:23:23.123123 /a/b/c/d.go:23: hello":            "ts=01:23:23.123123 caller=/a/b/c/d.go:23 msg=hello\n",
+		"some prefix 2009/01/23 01:23:23 /a/b/c/d.go:23: hello":        "ts=\"2009/01/23 01:23:23\" caller=/a/b/c/d.go:23 msg=hello\n",
+		"some prefix 2009/01/23 /a/b/c/d.go:23: hello":                 "ts=2009/01/23 caller=/a/b/c/d.go:23 msg=hello\n",
+		"some prefix /a/b/c/d.go:23: hello":                            "caller=/a/b/c/d.go:23 msg=hello\n",
+		"/a/b/c/d.go:23: some prefix hello":                            "caller=/a/b/c/d.go:23 msg=hello\n",
+	} {
+		buf.Reset()
+		fmt.Fprint(writer, input)
+		if have := buf.String(); want != have {
+			t.Errorf("%q: want %#v, have %#v", input, want, have)
+		}
+	}
+}
+
+func TestStdLibAdapterPrefixedExtractionWithJoinToMessage(t *testing.T) {
+	buf := &bytes.Buffer{}
+	logger := NewLogfmtLogger(buf)
+	writer := NewStdlibAdapter(logger, Prefix("some prefix ", true))
+	for input, want := range map[string]string{
+		"some prefix hello":                                            "msg=\"some prefix hello\"\n",
+		"some prefix 2009/01/23: hello":                                "ts=2009/01/23 msg=\"some prefix hello\"\n",
+		"some prefix 2009/01/23 01:23:23: hello":                       "ts=\"2009/01/23 01:23:23\" msg=\"some prefix hello\"\n",
+		"some prefix 01:23:23: hello":                                  "ts=01:23:23 msg=\"some prefix hello\"\n",
+		"some prefix 2009/01/23 01:23:23.123123: hello":                "ts=\"2009/01/23 01:23:23.123123\" msg=\"some prefix hello\"\n",
+		"some prefix 2009/01/23 01:23:23.123123 /a/b/c/d.go:23: hello": "ts=\"2009/01/23 01:23:23.123123\" caller=/a/b/c/d.go:23 msg=\"some prefix hello\"\n",
+		"some prefix 01:23:23.123123 /a/b/c/d.go:23: hello":            "ts=01:23:23.123123 caller=/a/b/c/d.go:23 msg=\"some prefix hello\"\n",
+		"some prefix 2009/01/23 01:23:23 /a/b/c/d.go:23: hello":        "ts=\"2009/01/23 01:23:23\" caller=/a/b/c/d.go:23 msg=\"some prefix hello\"\n",
+		"some prefix 2009/01/23 /a/b/c/d.go:23: hello":                 "ts=2009/01/23 caller=/a/b/c/d.go:23 msg=\"some prefix hello\"\n",
+		"some prefix /a/b/c/d.go:23: hello":                            "caller=/a/b/c/d.go:23 msg=\"some prefix hello\"\n",
+		"/a/b/c/d.go:23: some prefix hello":                            "caller=/a/b/c/d.go:23 msg=\"some prefix hello\"\n",
+	} {
+		buf.Reset()
+		fmt.Fprint(writer, input)
+		if have := buf.String(); want != have {
+			t.Errorf("%q: want %#v, have %#v", input, want, have)
+		}
+	}
+}
+
 func TestStdlibAdapterSubexps(t *testing.T) {
 	for input, wantMap := range map[string]map[string]string{
 		"hello world": {

From 1c6d4c156d54ce3c157b60c84499a66646562d3d Mon Sep 17 00:00:00 2001
From: Nick Gudinov <nicko54lay@mail.ru>
Date: Tue, 24 Nov 2020 10:21:28 +0300
Subject: [PATCH 2/4] add some more doc for Prefix stdlib adapter option

---
 log/stdlib.go | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/log/stdlib.go b/log/stdlib.go
index 6acd2e0f3..ea52494fa 100644
--- a/log/stdlib.go
+++ b/log/stdlib.go
@@ -52,7 +52,17 @@ func MessageKey(key string) StdlibAdapterOption {
 	return func(a *StdlibAdapter) { a.messageKey = key }
 }
 
-// Prefix sets value of the prefix for the actual log message. By default, there's no prefix.
+// Prefix sets value of the prefix for the actual log message. By default,
+// there's no prefix.
+//
+// When you create a stdlib Logger, you can define a log prefix like this:
+//
+//		logger := log.New(w, "some prefix", log.LstdFlags)
+//
+// To correctly extract stdlib logger fields, you should set the same prefix
+// by Prefix stdlib adapter option. Also you can set joinPrefixToMsg  if you need
+// to join the prefix to extracted message fields. For example, you can need it
+// when using log.Lmsgprefix flag.
 func Prefix(prefix string, joinPrefixToMsg bool) StdlibAdapterOption {
 	return func(a *StdlibAdapter) { a.prefix = prefix; a.joinPrefixToMsg = joinPrefixToMsg }
 }

From a331bbc825b70001354bbcb738e61227a2913bf3 Mon Sep 17 00:00:00 2001
From: Nick Gudinov <nicko54lay@mail.ru>
Date: Tue, 24 Nov 2020 10:23:18 +0300
Subject: [PATCH 3/4] fix typo

---
 log/stdlib.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/log/stdlib.go b/log/stdlib.go
index ea52494fa..7dfb98719 100644
--- a/log/stdlib.go
+++ b/log/stdlib.go
@@ -60,7 +60,7 @@ func MessageKey(key string) StdlibAdapterOption {
 //		logger := log.New(w, "some prefix", log.LstdFlags)
 //
 // To correctly extract stdlib logger fields, you should set the same prefix
-// by Prefix stdlib adapter option. Also you can set joinPrefixToMsg  if you need
+// by Prefix stdlib adapter option. Also you can set joinPrefixToMsg if you need
 // to join the prefix to extracted message fields. For example, you can need it
 // when using log.Lmsgprefix flag.
 func Prefix(prefix string, joinPrefixToMsg bool) StdlibAdapterOption {

From 90b8a6ba5cf891ef4c48685bbde70a817fb95af8 Mon Sep 17 00:00:00 2001
From: Peter Bourgon <peterbourgon@users.noreply.github.com>
Date: Wed, 25 Nov 2020 19:49:38 +0100
Subject: [PATCH 4/4] Update log/stdlib.go

---
 log/stdlib.go | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/log/stdlib.go b/log/stdlib.go
index 7dfb98719..2d030c456 100644
--- a/log/stdlib.go
+++ b/log/stdlib.go
@@ -52,17 +52,12 @@ func MessageKey(key string) StdlibAdapterOption {
 	return func(a *StdlibAdapter) { a.messageKey = key }
 }
 
-// Prefix sets value of the prefix for the actual log message. By default,
-// there's no prefix.
+// Prefix configures the adapter to parse a prefix from stdlib log events. If
+// you provide a non-empty prefix to the stdlib logger, then your should provide
+// that same prefix to the adapter via this option.
 //
-// When you create a stdlib Logger, you can define a log prefix like this:
-//
-//		logger := log.New(w, "some prefix", log.LstdFlags)
-//
-// To correctly extract stdlib logger fields, you should set the same prefix
-// by Prefix stdlib adapter option. Also you can set joinPrefixToMsg if you need
-// to join the prefix to extracted message fields. For example, you can need it
-// when using log.Lmsgprefix flag.
+// By default, the prefix isn't included in the msg key. Set joinPrefixToMsg to
+// true if you want to include the parsed prefix in the msg.
 func Prefix(prefix string, joinPrefixToMsg bool) StdlibAdapterOption {
 	return func(a *StdlibAdapter) { a.prefix = prefix; a.joinPrefixToMsg = joinPrefixToMsg }
 }