gofmt -w

doc.go

@@ -7,24 +7,24 @@
 // it is important that the log messages are structured and actionable.
 // Package log is designed to encourage both of these best practices.
 //
-// Basic Usage
+// # Basic Usage
 //
 // The fundamental interface is Logger. Loggers create log events from
 // key/value data. The Logger interface has a single method, Log, which
 // accepts a sequence of alternating key/value pairs, which this package names
 // keyvals.
 //
-//    type Logger interface {
-//        Log(keyvals ...interface{}) error
-//    }
+//	type Logger interface {
+//	    Log(keyvals ...interface{}) error
+//	}
 //
 // Here is an example of a function using a Logger to create log events.
 //
-//    func RunTask(task Task, logger log.Logger) string {
-//        logger.Log("taskID", task.ID, "event", "starting task")
-//        ...
-//        logger.Log("taskID", task.ID, "event", "task complete")
-//    }
+//	func RunTask(task Task, logger log.Logger) string {
+//	    logger.Log("taskID", task.ID, "event", "starting task")
+//	    ...
+//	    logger.Log("taskID", task.ID, "event", "task complete")
+//	}
 //
 // The keys in the above example are "taskID" and "event". The values are
 // task.ID, "starting task", and "task complete". Every key is followed
@@ -35,21 +35,21 @@
 // idea to log simple values without formatting them. This practice allows
 // the chosen logger to encode values in the most appropriate way.
 //
-// Contextual Loggers
+// # Contextual Loggers
 //
 // A contextual logger stores keyvals that it includes in all log events.
 // Building appropriate contextual loggers reduces repetition and aids
 // consistency in the resulting log output. With, WithPrefix, and WithSuffix
 // add context to a logger. We can use With to improve the RunTask example.
 //
-//    func RunTask(task Task, logger log.Logger) string {
-//        logger = log.With(logger, "taskID", task.ID)
-//        logger.Log("event", "starting task")
-//        ...
-//        taskHelper(task.Cmd, logger)
-//        ...
-//        logger.Log("event", "task complete")
-//    }
+//	func RunTask(task Task, logger log.Logger) string {
+//	    logger = log.With(logger, "taskID", task.ID)
+//	    logger.Log("event", "starting task")
+//	    ...
+//	    taskHelper(task.Cmd, logger)
+//	    ...
+//	    logger.Log("event", "task complete")
+//	}
 //
 // The improved version emits the same log events as the original for the
 // first and last calls to Log. Passing the contextual logger to taskHelper
@@ -59,7 +59,7 @@
 // life cycle of individual tasks. (See the Contextual example for the full
 // code of the above snippet.)
 //
-// Dynamic Contextual Values
+// # Dynamic Contextual Values
 //
 // A Valuer function stored in a contextual logger generates a new value each
 // time an event is logged. The Valuer example demonstrates how this feature
@@ -71,10 +71,10 @@
 // DefaultCaller. A common logger initialization sequence that ensures all log
 // entries contain a timestamp and source location looks like this:
 //
-//    logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
-//    logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller)
+//	logger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
+//	logger = log.With(logger, "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller)
 //
-// Concurrent Safety
+// # Concurrent Safety
 //
 // Applications with multiple goroutines want each log event written to the
 // same logger to remain separate from other log events. Package log provides
@@ -91,7 +91,7 @@
 // both the formatting and output logic. Use a SyncLogger if the formatting
 // logger may perform multiple writes per log event.
 //
-// Error Handling
+// # Error Handling
 //
 // This package relies on the practice of wrapping or decorating loggers with
 // other loggers to provide composable pieces of functionality. It also means
@@ -106,11 +106,11 @@
 // An application required to panic whenever its Logger encounters
 // an error could initialize its logger as follows.
 //
-//    fmtlogger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
-//    logger := log.LoggerFunc(func(keyvals ...interface{}) error {
-//        if err := fmtlogger.Log(keyvals...); err != nil {
-//            panic(err)
-//        }
-//        return nil
-//    })
+//	fmtlogger := log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
+//	logger := log.LoggerFunc(func(keyvals ...interface{}) error {
+//	    if err := fmtlogger.Log(keyvals...); err != nil {
+//	        panic(err)
+//	    }
+//	    return nil
+//	})
 package log

level/doc.go

@@ -2,30 +2,30 @@
 // use the level package, create a logger as per normal in your func main, and
 // wrap it with level.NewFilter.
 //
-//    var logger log.Logger
-//    logger = log.NewLogfmtLogger(os.Stderr)
-//    logger = level.NewFilter(logger, level.AllowInfo()) // <--
-//    logger = log.With(logger, "ts", log.DefaultTimestampUTC)
+//	var logger log.Logger
+//	logger = log.NewLogfmtLogger(os.Stderr)
+//	logger = level.NewFilter(logger, level.AllowInfo()) // <--
+//	logger = log.With(logger, "ts", log.DefaultTimestampUTC)
 //
 // It's also possible to configure log level from a string. For instance from
 // a flag, environment variable or configuration file.
 //
-//    fs := flag.NewFlagSet("myprogram")
-//    lvl := fs.String("log", "info", "debug, info, warn, error")
+//	fs := flag.NewFlagSet("myprogram")
+//	lvl := fs.String("log", "info", "debug, info, warn, error")
 //
-//    var logger log.Logger
-//    logger = log.NewLogfmtLogger(os.Stderr)
-//    logger = level.NewFilter(logger, level.Allow(level.ParseDefault(*lvl, level.InfoValue()))) // <--
-//    logger = log.With(logger, "ts", log.DefaultTimestampUTC)
+//	var logger log.Logger
+//	logger = log.NewLogfmtLogger(os.Stderr)
+//	logger = level.NewFilter(logger, level.Allow(level.ParseDefault(*lvl, level.InfoValue()))) // <--
+//	logger = log.With(logger, "ts", log.DefaultTimestampUTC)
 //
 // Then, at the callsites, use one of the level.Debug, Info, Warn, or Error
 // helper methods to emit leveled log events.
 //
-//    logger.Log("foo", "bar") // as normal, no level
-//    level.Debug(logger).Log("request_id", reqID, "trace_data", trace.Get())
-//    if value > 100 {
-//        level.Error(logger).Log("value", value)
-//    }
+//	logger.Log("foo", "bar") // as normal, no level
+//	level.Debug(logger).Log("request_id", reqID, "trace_data", trace.Get())
+//	if value > 100 {
+//	    level.Error(logger).Log("value", value)
+//	}
 //
 // NewFilter allows precise control over what happens when a log event is
 // emitted without a level key, or if a squelched level is used. Check the

log.go

@@ -125,11 +125,11 @@ func WithSuffix(logger Logger, keyvals ...interface{}) Logger {
 //
 // Two implementation details provide the needed stack depth consistency.
 //
-//    1. newContext avoids introducing an additional layer when asked to
-//       wrap another context.
-//    2. With, WithPrefix, and WithSuffix avoid introducing an additional
-//       layer by returning a newly constructed context with a merged keyvals
-//       rather than simply wrapping the existing context.
+//  1. newContext avoids introducing an additional layer when asked to
+//     wrap another context.
+//  2. With, WithPrefix, and WithSuffix avoid introducing an additional
+//     layer by returning a newly constructed context with a merged keyvals
+//     rather than simply wrapping the existing context.
 type context struct {
 	logger     Logger
 	keyvals    []interface{}

sync.go

@@ -43,9 +43,9 @@ func (l *SwapLogger) Swap(logger Logger) {
 //
 // If w implements the following interface, so does the returned writer.
 //
-//    interface {
-//        Fd() uintptr
-//    }
+//	interface {
+//	    Fd() uintptr
+//	}
 func NewSyncWriter(w io.Writer) io.Writer {
 	switch w := w.(type) {
 	case fdWriter: