Add tstest.PanicOnLog(), and fix various problems detected by this.

If a test calls log.Printf, 'go test' horrifyingly rearranges the
output to no longer be in chronological order, which makes debugging
virtually impossible. Let's stop that from happening by making
log.Printf panic if called from any module, no matter how deep, during
tests.

This required us to change the default error handler in at least one
http.Server, as well as plumbing a bunch of logf functions around,
especially in magicsock and wgengine, but also in logtail and backoff.

To add insult to injury, 'go test' also rearranges the output when a
parent test has multiple sub-tests (all the sub-test's t.Logf is always
printed after all the parent tests t.Logf), so we need to screw around
with a special Logf that can point at the "current" t (current_t.Logf)
in some places. Probably our entire way of using subtests is wrong,
since 'go test' would probably like to run them all in parallel if you
called t.Parallel(), but it definitely can't because the're all
manipulating the shared state created by the parent test. They should
probably all be separate toplevel tests instead, with common
setup/teardown logic. But that's a job for another time.

Signed-off-by: Avery Pennarun <apenwarr@tailscale.com>

logtail/backoff/backoff.go

@@ -6,9 +6,10 @@ package backoff
 
 import (
 	"context"
-	"log"
 	"math/rand"
 	"time"
+
+	"tailscale.com/types/logger"
 )
 
 const MAX_BACKOFF_MSEC = 30000
@@ -16,7 +17,9 @@ const MAX_BACKOFF_MSEC = 30000
 type Backoff struct {
 	n int
 	// Name is the name of this backoff timer, for logging purposes.
-	Name string
+	name string
+	// logf is the function used for log messages when backing off.
+	logf logger.Logf
 	// NewTimer is the function that acts like time.NewTimer().
 	// You can override this in unit tests.
 	NewTimer func(d time.Duration) *time.Timer
@@ -25,6 +28,14 @@ type Backoff struct {
 	LogLongerThan time.Duration
 }
 
+func NewBackoff(name string, logf logger.Logf) Backoff {
+	return Backoff{
+		name:     name,
+		logf:     logf,
+		NewTimer: time.NewTimer,
+	}
+}
+
 func (b *Backoff) BackOff(ctx context.Context, err error) {
 	if ctx.Err() == nil && err != nil {
 		b.n++
@@ -39,13 +50,9 @@ func (b *Backoff) BackOff(ctx context.Context, err error) {
 		msec = rand.Intn(msec) + msec/2
 		dur := time.Duration(msec) * time.Millisecond
 		if dur >= b.LogLongerThan {
-			log.Printf("%s: backoff: %d msec\n", b.Name, msec)
+			b.logf("%s: backoff: %d msec\n", b.name, msec)
 		}
-		newTimer := b.NewTimer
-		if newTimer == nil {
-			newTimer = time.NewTimer
-		}
-		t := newTimer(dur)
+		t := b.NewTimer(dur)
 		select {
 		case <-ctx.Done():
 			t.Stop()