Doc updates

Author: Lars Ekman

docs/logging.md

@@ -67,25 +67,25 @@ use the logger from the context;
 // In main();
 ctx = logr.NewContext(ctx, logger)
 // In a function;
-logger = log.FromContextOrDefault(ctx)
+logger = log.FromContextOrGlobal(ctx)
 ```
 
 Functions really should always have a context as first parameter but
-during transition they might not. A global logger is provided;
+they might not. A global logger is provided;
 
 ```
 log.Logger.Info("Configuration read", "config", config)
 ```
 
 The global logger it the one returnad by the *first* call to `log.New`
-or a logger named "Meridio" and always on INFO level if `log.New` is
-not called.
+or a logger named "Meridio" and always on INFO level before `log.New` is
+called.
 
 
 
 ## Log levels
 
-Only severity `info`, `error` and `critical` are used (not `warning`) but
+Severity `debug`, `info`, `error` and `critical` are used (not `warning`).
 `info` can have different "verbosity" set with the `V(n)` method;
 
 ```go
@@ -94,9 +94,9 @@ logger.V(1).Info("This is a debug message")
 logger.V(2).Info("This is a trace message")
 ```
 
-There is no "trace" level so both trace and debug messages will be
-shown as "debug". The level setting is still valid though, trace
-messages are suspressed unless TRACE level is set.
+There is no defined "trace" level so both trace and debug messages
+will be shown as "debug". The level filtering is still valid though,
+trace messages are suspressed unless TRACE level is set.
 
 The `Fatal()` function logs on `critical` level.
 
@@ -154,8 +154,8 @@ Example output;
 ## Design patterns
 
 Patterns must evolve slowly to get really good so these are mere
-ideas. It is very easy to get carried away and impose some over
-structured logging that floods the logs with useless data.
+ideas. It is very easy to get carried away and impose some
+over-structured logging that floods the logs with useless data.
 
 
 ### Class logger
@@ -167,7 +167,7 @@ A logger used in a type (Class) can be decorated with `class` and
 type someHandler struct {
 	ctx    context.Context
 	logger logr.Logger
-	Adr    *net.TCPAddr // Capitalized to make it visible!
+	Adr    *net.TCPAddr // (optional; capitalized to make it visible)
 }
 
 func newHandler(ctx context.Context, addr string) *someHandler {
@@ -181,7 +181,7 @@ func newHandler(ctx context.Context, addr string) *someHandler {
 		logger: logger.WithValues("instance", adr),
 		Adr:    adr,
 	}
-	h.logger.Info("Created")
+	h.logger.Info("Created", "object", h)
 	return h
 }
 
@@ -193,8 +193,8 @@ func (h *someHandler) connect() error {
 ```
 
 The `class` is the name of the type and `instance` can be anything
-that identifies an instance. Remember that the instance field must be
-visible (Capitalized).
+that identifies an instance. The instance field must be
+capitalized if you want it visible.
 
 The example shows a `func` entry to identify a function. This should
 *not* be used as a common pattern but may be handy in some cases.