docs: shared example logger (debug) and pl logging guide

Extract examples.NewLogger: zap NewProductionConfig at Debug level, so MTProto
RPC traces and the business peer diagnostics are visible. Add examples/README.md
documenting how to pretty-print the JSONL with github.com/go-faster/pl. Use the
shared logger in the business example and drop the peer diagnostic to Debug.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ernado

business_updates.go

@@ -98,7 +98,7 @@ func (b *Bot) logBusinessPeerDiag(ctx context.Context, peer tg.PeerClass, e tg.E
 		}
 	}
 
-	b.logger().Info(ctx, "Business peer diagnostic", fields...)
+	b.logger().Debug(ctx, "Business peer diagnostic", fields...)
 }
 
 // peerKindString describes a peer for diagnostics.

examples/README.md

@@ -0,0 +1,53 @@
+# Examples
+
+Runnable bots showing the library in practice. Each is its own `main` package:
+
+```bash
+APP_ID=12345 APP_HASH=abcdef BOT_TOKEN=123:abc go run ./examples/echo
+```
+
+Bots need an MTProto app identity (`APP_ID`/`APP_HASH`, from
+<https://my.telegram.org>) plus a BotFather token (`BOT_TOKEN`).
+
+## Logging
+
+The bots log structured **JSONL** via zap. The shared
+[`examples.NewLogger`](./logger.go) uses `zap.NewProductionConfig` but lowers the
+level to **Debug**, so MTProto RPC traces and the business peer diagnostics show
+up — handy when verifying behavior against the live API.
+
+Raw JSON is hard to read in a terminal. Pipe it through
+[`github.com/go-faster/pl`](https://github.com/go-faster/pl), which tails and
+pretty-prints exactly this `zap.NewProductionConfig` JSONL.
+
+### Install pl
+
+```bash
+go install github.com/go-faster/pl/cmd/pl@latest
+```
+
+### Use it
+
+zap writes to **stderr**, so redirect it into `pl` with `2>&1`:
+
+```bash
+APP_ID=12345 APP_HASH=abcdef BOT_TOKEN=123:abc go run ./examples/business 2>&1 | pl
+```
+
+Useful flags:
+
+- `--level info` — hide debug lines (keep info and above)
+- `--no-time` — drop timestamps
+- `--no-color` — disable colors (or set `NO_COLOR`)
+- `-f service.log` — follow a file like `tail -f`
+
+Non-JSON lines pass through untouched, so mixed output (e.g. a panic stack
+trace) stays readable.
+
+To capture a session and read it back later:
+
+```bash
+go run ./examples/business 2>session.log
+pl session.log          # read once
+pl -f session.log       # follow while the bot runs
+```

examples/business/main.go

@@ -49,11 +49,16 @@ import (
 	"go.uber.org/zap"
 
 	"github.com/gotd/botapi"
+	"github.com/gotd/botapi/examples"
 	"github.com/gotd/botapi/storage"
 )
 
 func main() {
-	log, _ := zap.NewProduction()
+	log, err := examples.NewLogger()
+	if err != nil {
+		panic(err)
+	}
+
 	defer func() { _ = log.Sync() }()
 
 	appID, err := atoi(os.Getenv("APP_ID"))

examples/logger.go

@@ -0,0 +1,22 @@
+// Package examples holds helpers shared by the runnable example bots.
+package examples
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// NewLogger builds the logger shared by the example bots: the standard zap
+// production configuration (structured JSONL on stderr) with the level lowered
+// to Debug, so the library's debug output — MTProto RPC traces and the business
+// peer diagnostics — is visible while debugging.
+//
+// The output is JSONL in the shape github.com/go-faster/pl expects; pipe it
+// through pl for readable, colorized logs (see the examples README).
+func NewLogger() (*zap.Logger, error) {
+	cfg := zap.NewProductionConfig()
+
+	cfg.Level = zap.NewAtomicLevelAt(zapcore.DebugLevel)
+
+	return cfg.Build()
+}