testserver: improve the error trace

ZhouXing19 · ZhouXing19 · commit 7b228df37162 · 2021-09-10T12:23:19.000-05:00
Wrapped errors from `NewTestServer`and `NewTenantServer`.
Also improved logging for better error trace by adding
"cockroach-go testserver:" or `cockroach-go tenantserver:`
at the beginning of log messages.
diff --git a/testserver/binaries.go b/testserver/binaries.go
@@ -42,7 +42,7 @@ const (
 func downloadFile(response *http.Response, filePath string, tc *TestConfig) error {
 	output, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, writingFileMode)
 	if err != nil {
-		return fmt.Errorf("error creating %s: %s", filePath, err)
+		return fmt.Errorf("error creating %s: %w", filePath, err)
 	}
 	defer func() { _ = output.Close() }()
 
@@ -66,7 +66,7 @@ func downloadFile(response *http.Response, filePath string, tc *TestConfig) erro
 	}
 
 	if _, err := io.Copy(output, response.Body); err != nil {
-		return fmt.Errorf("problem saving %s to %s: %s", response.Request.URL, filePath, err)
+		return fmt.Errorf("problem saving %s to %s: %w", response.Request.URL, filePath, err)
 	}
 
 	// Download was successful, add the rw bits.
@@ -97,7 +97,7 @@ func GetDownloadResponse() (*http.Response, error) {
 			cmd := exec.Command("ldd", "--version")
 			out, err := cmd.Output()
 			if err != nil {
-				log.Printf("%s: out=%q err=%s", cmd.Args, out, err)
+				log.Printf("%s: %s: out=%q err=%v", testserverMessagePrefix, cmd.Args, out, err)
 			} else if muslRE.Match(out) {
 				return "-musl"
 			}
@@ -192,7 +192,7 @@ func downloadLatestBinary(tc *TestConfig) (string, error) {
 	if err != nil {
 		if !errors.Is(err, errStoppedInMiddle) {
 			if err := os.Remove(localFile); err != nil {
-				log.Printf("failed to remove %s: %s", localFile, err)
+				log.Printf("failed to remove %s: %v", localFile, err)
 			}
 		}
 		return "", err
diff --git a/testserver/tenant.go b/testserver/tenant.go
@@ -50,7 +50,7 @@ func (ts *testServerImpl) isTenant() bool {
 // NewTestServer to this interface. Refer to the tests for an example.
 func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 	if proxy && !ts.serverArgs.secure {
-		return nil, errors.New("proxy can not be used with insecure mode")
+		return nil, fmt.Errorf("%s: proxy cannot be used with insecure mode", tenantserverMessagePrefix)
 	}
 	cockroachBinary := ts.cmdArgs[0]
 	tenantID, err := func() (int, error) {
@@ -67,7 +67,7 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 		return tenantID, nil
 	}()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 
 	secureFlag := "--insecure"
@@ -83,25 +83,25 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 			{"mt", "cert", "create-tenant-client", fmt.Sprint(tenantID)},
 		} {
 			if err := exec.Command(cockroachBinary, append(args, certArgs...)...).Run(); err != nil {
-				return nil, err
+				return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 			}
 		}
 	}
 	// Create a new tenant.
 	if err := ts.WaitForInit(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 	pgURL := ts.PGURL()
 	if pgURL == nil {
-		return nil, errors.New("url not found")
+		return nil, fmt.Errorf("%s: url not found", tenantserverMessagePrefix)
 	}
 	db, err := sql.Open("postgres", pgURL.String())
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 	defer db.Close()
 	if _, err := db.Exec(fmt.Sprintf("SELECT crdb_internal.create_tenant(%d)", tenantID)); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 
 	// TODO(asubiotto): We should pass ":0" as the sql addr to push port
@@ -112,13 +112,13 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 	addr := func() (string, error) {
 		l, err := net.Listen("tcp", ":0")
 		if err != nil {
-			return "", err
+			return "", fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 		}
 		// Use localhost because of certificate validation issues otherwise
 		// (something about IP SANs).
 		addr := "localhost:" + strconv.Itoa(l.Addr().(*net.TCPAddr).Port)
 		if err := l.Close(); err != nil {
-			return "", err
+			return "", fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 		}
 		return addr, nil
 	}
@@ -157,17 +157,18 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 		}
 		cmd := exec.Command(cockroachBinary, args...)
 		if err := cmd.Start(); err != nil {
-			return "", err
+			return "", fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 		}
 		if cmd.Process != nil {
-			log.Printf("process %d started: %s", cmd.Process.Pid, strings.Join(args, " "))
+			log.Printf("%s: process %d started: %s", tenantserverMessagePrefix, cmd.Process.Pid,
+				strings.Join(args, " "))
 		}
 		ts.proxyProcess = cmd.Process
 
 		return ts.proxyAddr, nil
 	}()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 
 	args := []string{
@@ -203,15 +204,15 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 
 	tenant.setPGURL(&tenantURL)
 	if err := tenant.Start(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 	if err := tenant.WaitForInit(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 
 	tenantDB, err := sql.Open("postgres", tenantURL.String())
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 	}
 	defer tenantDB.Close()
 
@@ -227,7 +228,7 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {
 	if rootPassword != "" {
 		// Allow root to login via password.
 		if _, err := tenantDB.Exec(`ALTER USER $1 WITH PASSWORD $2`, "root", rootPassword); err != nil {
-			return nil, err
+			return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)
 		}
 
 		// NB: need the lock since *tenantURL is owned by `tenant`.
diff --git a/testserver/testserver.go b/testserver/testserver.go
@@ -79,6 +79,9 @@ const (
 // By default, we allocate 20% of available memory to the test server.
 const defaultStoreMemSize = 0.2
 
+const testserverMessagePrefix = "cockroach-go testserver"
+const tenantserverMessagePrefix = "cockroach-go tenantserver"
+
 // TestServer is a helper to run a real cockroach node.
 type TestServer interface {
 	// Start starts the server.
@@ -164,7 +167,7 @@ func NewDBForTestWithDatabase(
 
 	db, err := sql.Open("postgres", url.String())
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%s: %v", testserverMessagePrefix, err)
 	}
 
 	return db, func() {
@@ -276,7 +279,7 @@ func NewTestServer(opts ...TestServerOpt) (TestServer, error) {
 				// return error.
 				return nil, err
 			}
-			log.Printf("Failed to fetch latest binary: %s, attempting to use cockroach binary from your PATH", err)
+			log.Printf("%s: Failed to fetch latest binary: %v attempting to use cockroach binary from your PATH", testserverMessagePrefix, err)
 			cockroachBinary = "cockroach"
 		} else {
 			log.Printf("Using automatically-downloaded binary: %s", cockroachBinary)
@@ -287,13 +290,15 @@ func NewTestServer(opts ...TestServerOpt) (TestServer, error) {
 	// which get us over the socket filename length limit.
 	baseDir, err := ioutil.TempDir("/tmp", "cockroach-testserver")
 	if err != nil {
-		return nil, fmt.Errorf("could not create temp directory: %s", err)
+		return nil, fmt.Errorf("%s: could not create temp directory: %w",
+			testserverMessagePrefix, err)
 	}
 
 	mkDir := func(name string) (string, error) {
 		path := filepath.Join(baseDir, name)
 		if err := os.MkdirAll(path, 0755); err != nil {
-			return "", fmt.Errorf("could not create %s directory: %s: %s", name, path, err)
+			return "", fmt.Errorf("%s: could not create %s directory: %s: %w",
+				testserverMessagePrefix, name, path, err)
 		}
 		return path, nil
 	}
@@ -302,11 +307,11 @@ func NewTestServer(opts ...TestServerOpt) (TestServer, error) {
 	// https://github.com/cockroachdb/cockroach-go/issues/109
 	logDir, err := mkDir(logsDirName)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 	certsDir, err := mkDir(certsDirName)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 
 	listeningURLFile := filepath.Join(baseDir, "listen-url")
@@ -327,7 +332,7 @@ func NewTestServer(opts ...TestServerOpt) (TestServer, error) {
 			{"cert", "create-client", "root"},
 		} {
 			if err := exec.Command(cockroachBinary, append(args, certArgs...)...).Run(); err != nil {
-				return nil, err
+				return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 			}
 		}
 		secureOpt = "--certs-dir=" + certsDir
@@ -339,17 +344,17 @@ func NewTestServer(opts ...TestServerOpt) (TestServer, error) {
 	versionCmd := exec.Command(cockroachBinary, "version")
 	versionOutput, err := versionCmd.CombinedOutput()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 	reader := bufio.NewReader(bytes.NewReader(versionOutput))
 	versionLine, err := reader.ReadString('\n')
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 	versionLineTokens := strings.Fields(versionLine)
 	v, err := version.Parse(versionLineTokens[2])
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 	startCmd := "start-single-node"
 	if !v.AtLeast(version.MustParse("v19.2.0-alpha")) {
@@ -388,15 +393,15 @@ func NewTestServer(opts ...TestServerOpt) (TestServer, error) {
 	ts.pgURL.set = make(chan struct{})
 
 	if err := ts.Start(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 
 	if ts.PGURL() == nil {
-		return nil, errors.New("testserver: url not found")
+		return nil, fmt.Errorf("%s: url not found", testserverMessagePrefix)
 	}
 
 	if err := ts.WaitForInit(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s: %w", testserverMessagePrefix, err)
 	}
 
 	return ts, nil
@@ -439,7 +444,7 @@ func (ts *testServerImpl) WaitForInit() error {
 		if _, err = db.Query("SHOW DATABASES"); err == nil {
 			return err
 		}
-		log.Printf("WaitForInit: Trying again after error: %v", err)
+		log.Printf("%s: WaitForInit: Trying again after error: %v", testserverMessagePrefix, err)
 		time.Sleep(time.Millisecond * 100)
 	}
 	return err
@@ -460,14 +465,14 @@ func (ts *testServerImpl) pollListeningURLFile() error {
 		if err == nil {
 			break
 		} else if !os.IsNotExist(err) {
-			return fmt.Errorf("unexpected error while reading listening URL file: %v", err)
+			return fmt.Errorf("unexpected error while reading listening URL file: %w", err)
 		}
 		time.Sleep(100 * time.Millisecond)
 	}
 
 	u, err := url.Parse(string(bytes.TrimSpace(data)))
 	if err != nil {
-		return fmt.Errorf("failed to parse SQL URL: %v", err)
+		return fmt.Errorf("failed to parse SQL URL: %w", err)
 	}
 	ts.pgURL.orig = *u
 	if pw := ts.serverArgs.rootPW; pw != "" {
@@ -507,7 +512,7 @@ func (ts *testServerImpl) Start() error {
 		case stateStopped, stateFailed:
 			// Start() can only be called once.
 			return errors.New(
-				"Start() cannot be used to restart a stopped or failed server. " +
+				"`Start()` cannot be used to restart a stopped or failed server. " +
 					"Please use NewTestServer()")
 		}
 	}
@@ -523,7 +528,7 @@ func (ts *testServerImpl) Start() error {
 	if len(ts.stdout) > 0 {
 		wr, err := newFileLogWriter(ts.stdout)
 		if err != nil {
-			return fmt.Errorf("unable to open file %s: %s", ts.stdout, err)
+			return fmt.Errorf("unable to open file %s: %w", ts.stdout, err)
 		}
 		ts.stdoutBuf = wr
 	}
@@ -532,7 +537,7 @@ func (ts *testServerImpl) Start() error {
 	if len(ts.stderr) > 0 {
 		wr, err := newFileLogWriter(ts.stderr)
 		if err != nil {
-			return fmt.Errorf("unable to open file %s: %s", ts.stderr, err)
+			return fmt.Errorf("unable to open file %s: %w", ts.stderr, err)
 		}
 		ts.stderrBuf = wr
 	}
@@ -549,33 +554,37 @@ func (ts *testServerImpl) Start() error {
 	if err != nil {
 		log.Print(err.Error())
 		if err := ts.stdoutBuf.Close(); err != nil {
-			log.Printf("failed to close stdout: %s", err)
+			log.Printf("%s: failed to close stdout: %v", testserverMessagePrefix, err)
 		}
 		if err := ts.stderrBuf.Close(); err != nil {
-			log.Printf("failed to close stderr: %s", err)
+			log.Printf("%s: failed to close stderr: %v", testserverMessagePrefix, err)
 		}
 
 		ts.mu.Lock()
 		ts.state = stateFailed
 		ts.mu.Unlock()
 
-		return fmt.Errorf("failure starting process: %s", err)
+		return fmt.Errorf("failure starting process: %w", err)
 	}
 
 	go func() {
 		err := ts.cmd.Wait()
 
 		if err := ts.stdoutBuf.Close(); err != nil {
-			log.Printf("failed to close stdout: %s", err)
+			log.Printf("%s: failed to close stdout: %v", testserverMessagePrefix, err)
 		}
 		if err := ts.stderrBuf.Close(); err != nil {
-			log.Printf("failed to close stderr: %s", err)
+			log.Printf("%s: failed to close stderr: %v", testserverMessagePrefix, err)
 		}
 
 		ps := ts.cmd.ProcessState
 		sy := ps.Sys().(syscall.WaitStatus)
 
-		log.Printf("Process %d exited with status %d: %v", ps.Pid(), sy.ExitStatus(), err)
+		log.Printf("%s: Process %d exited with status %d: %v",
+			testserverMessagePrefix,
+			ps.Pid(),
+			sy.ExitStatus(),
+			err)
 		log.Print(ps.String())
 
 		ts.mu.Lock()
@@ -590,7 +599,7 @@ func (ts *testServerImpl) Start() error {
 	if ts.pgURL.u == nil {
 		go func() {
 			if err := ts.pollListeningURLFile(); err != nil {
-				log.Printf("%v", err)
+				log.Printf("%s: %v", testserverMessagePrefix, err)
 				close(ts.pgURL.set)
 				ts.Stop()
 			}
@@ -608,11 +617,13 @@ func (ts *testServerImpl) Stop() {
 	defer ts.mu.RUnlock()
 
 	if ts.state == stateNew {
-		log.Fatal("Stop() called, but Start() was never called")
+		log.Fatalf("%s: Stop() called, but Start() was never called", testserverMessagePrefix)
 	}
 	if ts.state == stateFailed {
-		log.Fatalf("Stop() called, but process exited unexpectedly. Stdout:\n%s\nStderr:\n%s\n",
-			ts.Stdout(), ts.Stderr())
+		log.Fatalf("%s: Stop() called, but process exited unexpectedly. Stdout:\n%s\nStderr:\n%s\n",
+			testserverMessagePrefix,
+			ts.Stdout(),
+			ts.Stderr())
 		return
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ const (`
`42`	`42`	`func downloadFile(response http.Response, filePath string, tc TestConfig) error {`
`43`	`43`	`output, err := os.OpenFile(filePath, os.O_WRONLY\|os.O_CREATE\|os.O_EXCL, writingFileMode)`
`44`	`44`	`if err != nil {`
`45`		`- return fmt.Errorf("error creating %s: %s", filePath, err)`
	`45`	`+ return fmt.Errorf("error creating %s: %w", filePath, err)`
`46`	`46`	`}`
`47`	`47`	`defer func() { _ = output.Close() }()`
`48`	`48`
`@@ -66,7 +66,7 @@ func downloadFile(response http.Response, filePath string, tc TestConfig) erro`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`if _, err := io.Copy(output, response.Body); err != nil {`
`69`		`- return fmt.Errorf("problem saving %s to %s: %s", response.Request.URL, filePath, err)`
	`69`	`+ return fmt.Errorf("problem saving %s to %s: %w", response.Request.URL, filePath, err)`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`// Download was successful, add the rw bits.`
`@@ -97,7 +97,7 @@ func GetDownloadResponse() (*http.Response, error) {`
`97`	`97`	`cmd := exec.Command("ldd", "--version")`
`98`	`98`	`out, err := cmd.Output()`
`99`	`99`	`if err != nil {`
`100`		`- log.Printf("%s: out=%q err=%s", cmd.Args, out, err)`
	`100`	`+ log.Printf("%s: %s: out=%q err=%v", testserverMessagePrefix, cmd.Args, out, err)`
`101`	`101`	`} else if muslRE.Match(out) {`
`102`	`102`	`return "-musl"`
`103`	`103`	`}`
`@@ -192,7 +192,7 @@ func downloadLatestBinary(tc *TestConfig) (string, error) {`
`192`	`192`	`if err != nil {`
`193`	`193`	`if !errors.Is(err, errStoppedInMiddle) {`
`194`	`194`	`if err := os.Remove(localFile); err != nil {`
`195`		`- log.Printf("failed to remove %s: %s", localFile, err)`
	`195`	`+ log.Printf("failed to remove %s: %v", localFile, err)`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`	`return "", err`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ func (ts *testServerImpl) isTenant() bool {`
`50`	`50`	`// NewTestServer to this interface. Refer to the tests for an example.`
`51`	`51`	`func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`52`	`52`	`if proxy && !ts.serverArgs.secure {`
`53`		`- return nil, errors.New("proxy can not be used with insecure mode")`
	`53`	`+ return nil, fmt.Errorf("%s: proxy cannot be used with insecure mode", tenantserverMessagePrefix)`
`54`	`54`	`}`
`55`	`55`	`cockroachBinary := ts.cmdArgs[0]`
`56`	`56`	`tenantID, err := func() (int, error) {`
`@@ -67,7 +67,7 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`67`	`67`	`return tenantID, nil`
`68`	`68`	`}()`
`69`	`69`	`if err != nil {`
`70`		`- return nil, err`
	`70`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`secureFlag := "--insecure"`
`@@ -83,25 +83,25 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`83`	`83`	`{"mt", "cert", "create-tenant-client", fmt.Sprint(tenantID)},`
`84`	`84`	`} {`
`85`	`85`	`if err := exec.Command(cockroachBinary, append(args, certArgs...)...).Run(); err != nil {`
`86`		`- return nil, err`
	`86`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`// Create a new tenant.`
`91`	`91`	`if err := ts.WaitForInit(); err != nil {`
`92`		`- return nil, err`
	`92`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`93`	`93`	`}`
`94`	`94`	`pgURL := ts.PGURL()`
`95`	`95`	`if pgURL == nil {`
`96`		`- return nil, errors.New("url not found")`
	`96`	`+ return nil, fmt.Errorf("%s: url not found", tenantserverMessagePrefix)`
`97`	`97`	`}`
`98`	`98`	`db, err := sql.Open("postgres", pgURL.String())`
`99`	`99`	`if err != nil {`
`100`		`- return nil, err`
	`100`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`101`	`101`	`}`
`102`	`102`	`defer db.Close()`
`103`	`103`	`if _, err := db.Exec(fmt.Sprintf("SELECT crdb_internal.create_tenant(%d)", tenantID)); err != nil {`
`104`		`- return nil, err`
	`104`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`// TODO(asubiotto): We should pass ":0" as the sql addr to push port`
`@@ -112,13 +112,13 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`112`	`112`	`addr := func() (string, error) {`
`113`	`113`	`l, err := net.Listen("tcp", ":0")`
`114`	`114`	`if err != nil {`
`115`		`- return "", err`
	`115`	`+ return "", fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`116`	`116`	`}`
`117`	`117`	`// Use localhost because of certificate validation issues otherwise`
`118`	`118`	`// (something about IP SANs).`
`119`	`119`	`addr := "localhost:" + strconv.Itoa(l.Addr().(*net.TCPAddr).Port)`
`120`	`120`	`if err := l.Close(); err != nil {`
`121`		`- return "", err`
	`121`	`+ return "", fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`122`	`122`	`}`
`123`	`123`	`return addr, nil`
`124`	`124`	`}`
`@@ -157,17 +157,18 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`157`	`157`	`}`
`158`	`158`	`cmd := exec.Command(cockroachBinary, args...)`
`159`	`159`	`if err := cmd.Start(); err != nil {`
`160`		`- return "", err`
	`160`	`+ return "", fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`161`	`161`	`}`
`162`	`162`	`if cmd.Process != nil {`
`163`		`- log.Printf("process %d started: %s", cmd.Process.Pid, strings.Join(args, " "))`
	`163`	`+ log.Printf("%s: process %d started: %s", tenantserverMessagePrefix, cmd.Process.Pid,`
	`164`	`+ strings.Join(args, " "))`
`164`	`165`	`}`
`165`	`166`	`ts.proxyProcess = cmd.Process`
`166`	`167`
`167`	`168`	`return ts.proxyAddr, nil`
`168`	`169`	`}()`
`169`	`170`	`if err != nil {`
`170`		`- return nil, err`
	`171`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`171`	`172`	`}`
`172`	`173`
`173`	`174`	`args := []string{`
`@@ -203,15 +204,15 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`203`	`204`
`204`	`205`	`tenant.setPGURL(&tenantURL)`
`205`	`206`	`if err := tenant.Start(); err != nil {`
`206`		`- return nil, err`
	`207`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`207`	`208`	`}`
`208`	`209`	`if err := tenant.WaitForInit(); err != nil {`
`209`		`- return nil, err`
	`210`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`210`	`211`	`}`
`211`	`212`
`212`	`213`	`tenantDB, err := sql.Open("postgres", tenantURL.String())`
`213`	`214`	`if err != nil {`
`214`		`- return nil, err`
	`215`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`215`	`216`	`}`
`216`	`217`	`defer tenantDB.Close()`
`217`	`218`
`@@ -227,7 +228,7 @@ func (ts *testServerImpl) NewTenantServer(proxy bool) (TestServer, error) {`
`227`	`228`	`if rootPassword != "" {`
`228`	`229`	`// Allow root to login via password.`
`229`	`230`	if _, err := tenantDB.Exec(`ALTER USER $1 WITH PASSWORD $2`, "root", rootPassword); err != nil {
`230`		`- return nil, err`
	`231`	`+ return nil, fmt.Errorf("%s: %w", tenantserverMessagePrefix, err)`
`231`	`232`	`}`
`232`	`233`
`233`	`234`	// NB: need the lock since *tenantURL is owned by `tenant`.