What causes "server: DoltServer.Stop: close log: %w" in gastownhall/beads?

Check disk space and filesystem health on the volume holding the log file.

server: DoltServer.Stop: close log: %w

Error message

server: DoltServer.Stop: close log: %w

What it means

During Stop(), closing the server's log file (opened by NewDoltServer) failed. The error is joined into Stop's aggregate return, so shutdown still completes; it usually indicates an fd or filesystem-level problem at close time.

Source

Thrown at internal/storage/dbproxy/server/doltserver.go:374

	}
	var waitErr error
	if s.eg != nil {
		waitErr = s.eg.Wait()
		var exitErr *exec.ExitError
		if errors.As(waitErr, &exitErr) || errors.Is(waitErr, context.Canceled) {
			waitErr = nil
		}
	}
	if waitErr != nil {
		waitErr = fmt.Errorf("server: DoltServer.Stop: %w", waitErr)
	}
	var closeErr error
	if s.logFile != nil {
		closeErr = s.logFile.Close()
		s.logFile = nil
	}
	if closeErr != nil {
		closeErr = fmt.Errorf("server: DoltServer.Stop: close log: %w", closeErr)
	}
	var rmErr error
	if s.pid != 0 {
		rmErr = pidfile.Remove(s.rootDir, PIDFileName)
		s.pid = 0
	}
	if rmErr != nil {
		rmErr = fmt.Errorf("server: DoltServer.Stop: remove pidfile: %w", rmErr)
	}
	return errors.Join(gcErr, waitErr, closeErr, rmErr)
}

func (s *DoltServer) runShutdownGC(ctx context.Context) (retErr error) {
	if s.database == "" || !s.Running(ctx) {
		return nil
	}
	db, err := sql.Open("mysql", s.DSN(ctx, s.database, "root", ""))
	if err != nil {

View on GitHub (pinned to 71377f2769)

Solutions

Check disk space and filesystem health on the volume holding the log file.
Ensure Stop is called only once; use sync.Once to guard shutdown paths.
Verify the log file path is on reliable local storage, not a flaky network mount.
Treat as non-fatal if the dolt child exited cleanly — data integrity is unaffected by log-close failure.

Example fix

// before
srv.Stop(ctx)
srv.Stop(ctx) // second call can hit closed log file / fd errors
// after
var stopOnce sync.Once
stopOnce.Do(func() { _ = srv.Stop(ctx) })

Defensive patterns

Strategy: try-catch

Validate before calling

// Ensure the log directory has space and is on a reliable filesystem.
var st syscall.Statfs_t
if err := syscall.Statfs(filepath.Dir(logPath), &st); err == nil && st.Bavail*uint64(st.Bsize) < 5<<20 {
    return fmt.Errorf("low disk on log volume; log close may fail")
}

Try / catch

if err := srv.Stop(ctx); err != nil {
    if strings.Contains(err.Error(), "close log") {
        log.Warnf("non-fatal: log file close failed: %v", err)
        return nil
    }
    return err
}

Prevention

Call Stop exactly once (sync.Once) to avoid double-close of the log fd.
Keep logs on local disk with adequate free space.
Monitor disk usage of server log files and rotate them.
Treat log-close errors as non-fatal; the server data state is unaffected.

When it happens

Trigger: s.logFile.Close() returns an error — typically deferred I/O flush failure on a full/unavailable filesystem, an already-closed fd (double Stop), or the log file was removed/changed underneath the process.

Common situations: Disk full so buffered writes fail on close; log file on a network mount that dropped; Stop called twice (second call has nil logFile so normally skipped, but concurrent calls can double-close).

Related errors

AI-assisted analysis of gastownhall/beads@71377f2769 (2026-08-30). Data as JSON: /api/errors/39fae7a6cafa1075. Report an issue: GitHub.