feat: added log package with importantLogger support

Important logger panics if it fails to write the log more than specified in `maxErrors` param

Author: r3code

log/doc.go

@@ -0,0 +1,26 @@
+// Package log пакет предназначен для упрощения ведения логов в программах.
+// Представляет надстройку над go-kit/kit/log. 
+// Этот пакет создан для ведения важных логов, т.е. без нормально работающего логгера продолжение работы программы не имеет смысла, т.к. разрабочик не получит важную информацию в случае откраза.
+// Потому этот парет предоставялет возможность использовать важный логгер (см. `NewImportantLogger()`), который следит за количеством ошибок при выполнение записи в носитель лога (например, файл). И если число ошибок превышает заданное - вызывает панику.
+package log
+
+// Logger интерфейс логгера базовый для препятствования сильному связыванию
+// см. https://dave.cheney.net/2015/11/05/lets-talk-about-logging
+// https://docs.google.com/document/d/1oTjtY49y8iSxmM9YBaz2NrZIlaXtQsq3nQMd-E0HtwM/edit
+// https://groups.google.com/forum/#!topic/golang-dev/F3l9Iz1JX4g
+/*
+Это позволит выводить любой тип данных, например:
+
+// common formatted string output
+Log(fmt.Sprintf(“some custom print string: %s”, value))
+
+// no format string, just values
+Log(someText, struct1, struct2, err)
+
+// Custom key value style structs that can be interrogated with the logger that satisfied the interface to create structured logging
+Log(key, value, key, value)
+
+// log levels (with a colog style implementation)
+Log(“info: starting up system”)
+Log(fmt.Sprintf(“err: kaboom %s”, err))
+ */

log/example/main.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"os"
+
+	"github.com/r3code/go-useful-snippets/log"
+	kitlog "github.com/go-kit/kit/log"
+)
+
+func main() {
+	logger := kitlog.NewLogfmtLogger(os.Stdout)
+	for depth := 0; depth <= 5; depth++ {
+		l := log.With(logger, "caller", kitlog.Caller(depth))
+		l.Log("depth", depth) // line 13
+	}
+	l2 := log.NewDefaultStdOutLogger(false)
+	l2.Log("testNo", "1")
+	l3 := log.MustCreateComponentLog(l2, "cp2")
+	l3.Log("test", "2")
+}

log/important_logger.go

@@ -0,0 +1,62 @@
+package log
+
+import (
+	gklog "github.com/go-kit/kit/log"
+	"github.com/juju/errors"
+)
+
+/* See https://github.com/go-kit/kit/issues/164#issuecomment-274185353
+
+Пример использования:
+func main() {
+    // ...
+    var logger log.Logger
+    logger = importantLogger{
+        logger: gklog.NewLogfmtLogger(log.NewSyncWriter(os.Stdout)),
+        thresh: 10,
+        metricErrCounter: logErrorCounter,
+    }
+    logger = log.NewContext(logger).With("ts",log.DefaultTimestampUTC,
+		"caller", log.DefaultCaller)
+    // ...
+    app.AppLogic(logger, 5, "hello, world")
+}
+
+*/
+
+type importantLogger struct {
+	logger gklog.Logger
+	// metricErrCounter metrics.Counter
+	errorCount uint8
+	maxErrors  uint8
+}
+
+// importantLogger отслеживает число ошибок записи писателя лога, а когда число ошибок переваливает за указанное число `maxErrors`, то он вызывает панику.
+// Реализует интерфейс log.Logger. 
+// Всегда возвращает только nil или вызывает panic.
+func (il *importantLogger) Log(keyvals ...interface{}) error {
+	if err := il.logger.Log(keyvals...); err != nil {
+		il.errorCount++
+		// TODO(dsin): добавить счетичик для вывода метрики "логгер.число_ошибок_записи" - бекэнд или expvar или prometheus
+		// il.metricErrCounter.Add(1)
+		tooMuchLogFails := il.errorCount > il.maxErrors
+		if tooMuchLogFails {
+			panic(errors.Annotate(err, "Logger write failed"))
+		}
+	}
+	return nil
+}
+
+// NewImportantLogger созает экземпляр важного логгера из обычного, отказ которого вызывает панику и остановку программы.
+// Параметр `maxErrors` указывает предельное количество ошибок запси в лог после достижения которого будет вызвана паника и выполнение программы прервется.
+// Если `maxErrors` = 0, то используется значение `maxErrors` по умолчанию (=1). 
+func NewImportantLogger(logger gklog.Logger, maxErrors uint8) Logger {
+	if maxErrors == 0 {
+		maxErrors = 1
+	}
+	return &importantLogger{
+		logger:     logger,
+		maxErrors:  maxErrors,
+		errorCount: 0,
+	}
+}

log/important_logger_test.go

@@ -0,0 +1,64 @@
+package log_test
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/r3code/go-useful-snippets/log"
+)
+
+func fakeNow() time.Time {
+	timeNow, _ := time.Parse(time.RFC3339, "2014-11-12T11:45:26.371Z")
+	return timeNow
+}
+
+func Test_Logger_Log(t *testing.T) {
+	var buf bytes.Buffer
+	logger := log.NewLogger(&buf, 1, false)
+
+	if err := logger.Log("hello", "world"); err != nil {
+		t.Fatal(err)
+	}
+	want := "hello=world\n"
+	have := buf.String()
+	if !strings.Contains(have, want) {
+		t.Errorf("\nwant %#v\nhave %#v", want, have)
+	}
+	if !strings.Contains(have, "time=") {
+		t.Errorf("No time= field printed")
+	}
+	if !strings.Contains(have, "caller=") {
+		t.Errorf("No caller= field printed")
+	}
+}
+
+type failingWriter struct {
+	io.Writer
+}
+
+func (w *failingWriter) Write(p []byte) (n int, err error) {
+	return 0, errors.New("Write failed")
+}
+
+func Test_Logger_Log_WriteError(t *testing.T) {
+	var w failingWriter
+	logger := log.NewLogger(&w, 3, false)
+
+	var initPainc = func() {
+		for i := 0; i <= 4; i++ {
+			_ = logger.Log("hello", "world")
+		}
+	}
+	// отложим проверку на возникновение паники, затем вызовем функцию в которой должна быть паника. Если паника не произошла - тест провалится
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("Logger did not panic after 3 errors as it should")
+		}
+	}()
+
+	initPainc()
+}

log/logger.go

@@ -0,0 +1,61 @@
+package log
+
+import (
+	"io"
+	"os"
+	"strings"
+
+	kitlog "github.com/go-kit/kit/log"
+)
+
+// Logger переименовывает  (go-kit/log).Logger интерфейс для удобства
+type Logger kitlog.Logger
+
+var (
+	// DefaultCaller указывает на место вызова, добавляет свойство "caller" в лог
+	DefaultCaller = kitlog.Caller(5)
+	// DefaultTimestampUTC определяет временую метку, используется в свойстве "ts" в логе
+	DefaultTimestampUTC = kitlog.DefaultTimestampUTC
+)
+
+// NewDefaultStdOutLogger создает логгер с настройками по умолчанию для вывода в STDOUT
+func NewDefaultStdOutLogger(disableTimestamp bool) Logger {
+	var maxErrors uint8 = 10
+	return NewStdOutLogger(maxErrors, disableTimestamp)
+}
+
+// NewStdOutLogger создает логгер для вывода сообщений в STDOUT
+func NewStdOutLogger(maxErrors uint8, disableTimestamp bool) Logger {
+	lg := NewLogger(os.Stdout, maxErrors, disableTimestamp)
+
+	return NewImportantLogger(lg, maxErrors)
+}
+
+// NewLogger создает новый логер с указанным писателем.
+// Параметр `maxErrors` указывает предельное количество ошибок запси в лог после достижения которого будет вызвана паника и выполнение программы прервется
+func NewLogger(writer io.Writer, maxErrors uint8, disableTimestamp bool) Logger {
+	lg := kitlog.NewLogfmtLogger(kitlog.NewSyncWriter(writer))
+
+	il := NewImportantLogger(lg, maxErrors)
+
+	il = kitlog.WithPrefix(il, "caller", DefaultCaller)
+	if !disableTimestamp {
+		il = kitlog.WithPrefix(il, "time", DefaultTimestampUTC)
+	}
+
+	return il
+}
+
+// With добавляет новые постоянно добавляемые поля со значениями в сообщение
+func With(l Logger, keyvals ...interface{}) Logger {
+	return kitlog.With(l, keyvals...)
+}
+
+// MustCreateComponentLog создает новый логгер для компонента или паникует, если имя не указано
+func MustCreateComponentLog(l Logger, componentName string) Logger {
+	if strings.TrimSpace(componentName) == "" {
+		panic("Can not create named logger. Empty component name passed")
+	}
+
+	return With(l, "component", componentName)
+}