Log rotation

Author: sjmiller609

cmd/api/config/config.go

@@ -18,6 +18,8 @@ type Config struct {
 	DNSServer           string
 	MaxConcurrentBuilds int
 	MaxOverlaySize      string
+	LogMaxSize          string
+	LogMaxFiles         int
 }
 
 // Load loads configuration from environment variables
@@ -37,6 +39,8 @@ func Load() *Config {
 		DNSServer:           getEnv("DNS_SERVER", "1.1.1.1"),
 		MaxConcurrentBuilds: getEnvInt("MAX_CONCURRENT_BUILDS", 1),
 		MaxOverlaySize:      getEnv("MAX_OVERLAY_SIZE", "100GB"),
+		LogMaxSize:          getEnv("LOG_MAX_SIZE", "50MB"),
+		LogMaxFiles:         getEnvInt("LOG_MAX_FILES", 1),
 	}
 
 	return cfg

cmd/api/main.go

@@ -12,6 +12,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/c2h5oh/datasize"
 	"github.com/getkin/kin-openapi/openapi3filter"
 	"github.com/ghodss/yaml"
 	"github.com/go-chi/chi/v5"
@@ -177,6 +178,29 @@ func run() error {
 		return nil
 	})
 
+	// Log rotation scheduler
+	grp.Go(func() error {
+		var logMaxSize datasize.ByteSize
+		if err := logMaxSize.UnmarshalText([]byte(app.Config.LogMaxSize)); err != nil {
+			logger.Error("invalid LOG_MAX_SIZE config", "value", app.Config.LogMaxSize, "error", err)
+			return nil // Don't crash server, just skip rotation
+		}
+
+		ticker := time.NewTicker(5 * time.Minute)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-gctx.Done():
+				return nil
+			case <-ticker.C:
+				if err := app.InstanceManager.RotateLogs(gctx, int64(logMaxSize), app.Config.LogMaxFiles); err != nil {
+					logger.Error("log rotation failed", "error", err)
+				}
+			}
+		}
+	})
+
 	return grp.Wait()
 }
 

lib/instances/logs.go

@@ -4,6 +4,8 @@ import (
 	"bufio"
 	"context"
 	"fmt"
+	"io"
+	"os"
 	"os/exec"
 	"strconv"
 
@@ -74,3 +76,59 @@ func (m *manager) streamInstanceLogs(ctx context.Context, id string, tail int, f
 
 	return out, nil
 }
+
+// rotateLogIfNeeded performs copytruncate rotation if file exceeds maxBytes
+// Keeps up to maxFiles old backups (.1, .2, etc.)
+func rotateLogIfNeeded(path string, maxBytes int64, maxFiles int) error {
+	info, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // Nothing to rotate
+		}
+		return fmt.Errorf("stat log file: %w", err)
+	}
+
+	if info.Size() < maxBytes {
+		return nil // Under limit, nothing to do
+	}
+
+	// Shift old backups (.1 -> .2, .2 -> .3, etc.)
+	for i := maxFiles; i >= 1; i-- {
+		oldPath := fmt.Sprintf("%s.%d", path, i)
+		newPath := fmt.Sprintf("%s.%d", path, i+1)
+
+		if i == maxFiles {
+			// Delete the oldest backup
+			os.Remove(oldPath)
+		} else {
+			// Shift to next number
+			os.Rename(oldPath, newPath)
+		}
+	}
+
+	// Copy current log to .1
+	src, err := os.Open(path)
+	if err != nil {
+		return fmt.Errorf("open log for rotation: %w", err)
+	}
+
+	dst, err := os.Create(path + ".1")
+	if err != nil {
+		src.Close()
+		return fmt.Errorf("create backup: %w", err)
+	}
+
+	_, err = io.Copy(dst, src)
+	src.Close()
+	dst.Close()
+	if err != nil {
+		return fmt.Errorf("copy to backup: %w", err)
+	}
+
+	// Truncate original (keeps file descriptor valid for writers)
+	if err := os.Truncate(path, 0); err != nil {
+		return fmt.Errorf("truncate log: %w", err)
+	}
+
+	return nil
+}

lib/instances/manager.go

@@ -19,6 +19,7 @@ type Manager interface {
 	StandbyInstance(ctx context.Context, id string) (*Instance, error)
 	RestoreInstance(ctx context.Context, id string) (*Instance, error)
 	StreamInstanceLogs(ctx context.Context, id string, tail int, follow bool) (<-chan string, error)
+	RotateLogs(ctx context.Context, maxBytes int64, maxFiles int) error
 	AttachVolume(ctx context.Context, id string, volumeId string, req AttachVolumeRequest) (*Instance, error)
 	DetachVolume(ctx context.Context, id string, volumeId string) (*Instance, error)
 }
@@ -115,6 +116,23 @@ func (m *manager) StreamInstanceLogs(ctx context.Context, id string, tail int, f
 	return m.streamInstanceLogs(ctx, id, tail, follow)
 }
 
+// RotateLogs rotates console logs for all instances that exceed maxBytes
+func (m *manager) RotateLogs(ctx context.Context, maxBytes int64, maxFiles int) error {
+	instances, err := m.listInstances(ctx)
+	if err != nil {
+		return fmt.Errorf("list instances for rotation: %w", err)
+	}
+
+	var lastErr error
+	for _, inst := range instances {
+		logPath := m.paths.InstanceConsoleLog(inst.Id)
+		if err := rotateLogIfNeeded(logPath, maxBytes, maxFiles); err != nil {
+			lastErr = err // Continue with other instances, but track error
+		}
+	}
+	return lastErr
+}
+
 // AttachVolume attaches a volume to an instance (not yet implemented)
 func (m *manager) AttachVolume(ctx context.Context, id string, volumeId string, req AttachVolumeRequest) (*Instance, error) {
 	return nil, fmt.Errorf("attach volume not yet implemented")