Process Management: From Linux Commands to a Go Supervisor

mkdir process-mgmt && cd process-mgmt
go mod init process-mgmt

ps aux

ps aux --sort=-%mem | head -20

ps -eo pid,ppid,cmd --forest

pgrep -af nginx

package main

import (
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
)

type ProcessInfo struct {
	PID     int
	Name    string
	State   string
	RSS     int // in KB
	Threads int
}

func listProcesses() ([]ProcessInfo, error) {
	entries, err := os.ReadDir("/proc")
	if err != nil {
		return nil, err
	}

	var procs []ProcessInfo
	for _, entry := range entries {
		if !entry.IsDir() {
			continue
		}
		pid, err := strconv.Atoi(entry.Name())
		if err != nil {
			continue // not a PID directory
		}

		info, err := readProcessInfo(pid)
		if err != nil {
			continue // process may have exited
		}
		procs = append(procs, info)
	}

	return procs, nil
}

func readProcessInfo(pid int) (ProcessInfo, error) {
	data, err := os.ReadFile(filepath.Join("/proc", strconv.Itoa(pid), "stat"))
	if err != nil {
		return ProcessInfo{}, err
	}

	line := string(data)
	fields := strings.Fields(line)

	// BUG: parse name from fields[1], RSS from fields[23]
	name := strings.Trim(fields[1], "()")

	rssPages, _ := strconv.Atoi(fields[23])
	pageSize := os.Getpagesize()
	rssKB := (rssPages * pageSize) / 1024

	return ProcessInfo{
		PID:  pid,
		Name: name,
		RSS:  rssKB,
	}, nil
}

func main() {
	procs, err := listProcesses()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	// Sort by RSS descending
	sort.Slice(procs, func(i, j int) bool {
		return procs[i].RSS > procs[j].RSS
	})

	fmt.Printf("%-8s %-20s %10s\n", "PID", "NAME", "RSS (KB)")
	fmt.Println(strings.Repeat("-", 42))

	limit := 20
	if len(procs) < limit {
		limit = len(procs)
	}
	for _, p := range procs[:limit] {
		fmt.Printf("%-8d %-20s %10d\n", p.PID, p.Name, p.RSS)
	}
}

go run step1/main.go

func readProcessInfo(pid int) (ProcessInfo, error) {
	data, err := os.ReadFile(filepath.Join("/proc", strconv.Itoa(pid), "stat"))
	if err != nil {
		return ProcessInfo{}, err
	}

	line := string(data)

	// Find the last ')' — everything after it has fixed positions
	closeIdx := strings.LastIndex(line, ")")
	if closeIdx == -1 {
		return ProcessInfo{}, fmt.Errorf("bad stat format for pid %d", pid)
	}

	// Name is between first '(' and last ')'
	openIdx := strings.Index(line, "(")
	name := line[openIdx+1 : closeIdx]

	// Fields after ')' — skip the space after ')'
	rest := strings.Fields(line[closeIdx+2:])
	// rest[0] = state, rest[1] = ppid, ..., rest[21] = RSS (field 23 in original, index 21 here)
	if len(rest) < 22 {
		return ProcessInfo{}, fmt.Errorf("not enough fields for pid %d", pid)
	}

	state := rest[0]
	rssPages, _ := strconv.Atoi(rest[21])
	pageSize := os.Getpagesize()
	rssKB := (rssPages * pageSize) / 1024

	threads, _ := strconv.Atoi(rest[17])

	return ProcessInfo{
		PID:     pid,
		Name:    name,
		State:   state,
		RSS:     rssKB,
		Threads: threads,
	}, nil
}

kill -l

kill PID

kill -9 PID

kill -HUP PID

pkill -f "python server.py"

package main

import (
	"fmt"
	"os"
	"os/exec"
	"time"
)

func main() {
	// Start a child process that sleeps for 60 seconds
	cmd := exec.Command("sleep", "60")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if err := cmd.Start(); err != nil {
		fmt.Println("Failed to start:", err)
		os.Exit(1)
	}
	fmt.Printf("Started child process (pid=%d)\n", cmd.Process.Pid)

	// Wait 2 seconds then try to stop it
	time.Sleep(2 * time.Second)
	fmt.Println("Stopping child process...")

	// BUG: just kill it immediately
	err := cmd.Process.Kill()
	if err != nil {
		fmt.Println("Kill error:", err)
	}

	err = cmd.Wait()
	fmt.Println("Process exited:", err)
}

go run step2/main.go

package main

import (
	"fmt"
	"os"
	"os/exec"
	"syscall"
	"time"
)

func gracefulStop(cmd *exec.Cmd, timeout time.Duration) error {
	// Step 1: send SIGTERM
	fmt.Println("Sending SIGTERM...")
	if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
		return fmt.Errorf("failed to send SIGTERM: %w", err)
	}

	// Step 2: wait with a timeout
	done := make(chan error, 1)
	go func() {
		done <- cmd.Wait()
	}()

	select {
	case err := <-done:
		fmt.Println("Process exited gracefully")
		return err
	case <-time.After(timeout):
		// Step 3: SIGTERM was ignored, send SIGKILL
		fmt.Println("Timeout — sending SIGKILL...")
		if err := cmd.Process.Kill(); err != nil {
			return fmt.Errorf("failed to kill: %w", err)
		}
		return <-done
	}
}

func main() {
	cmd := exec.Command("sleep", "60")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if err := cmd.Start(); err != nil {
		fmt.Println("Failed to start:", err)
		os.Exit(1)
	}
	fmt.Printf("Started child process (pid=%d)\n", cmd.Process.Pid)

	time.Sleep(2 * time.Second)
	fmt.Println("Stopping child process...")

	err := gracefulStop(cmd, 5*time.Second)
	if err != nil {
		fmt.Println("Process exited:", err)
	}
}

# Terminal 1: Run your Go program
go run main.go

# Terminal 2: Find the process and send signals
kill -TERM $(pgrep -f "go run main.go")
kill -HUP $(pgrep -f "go run main.go")

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"
)

var config = map[string]string{
	"log_level": "info",
	"port":      "8080",
}

func reloadConfig() {
	fmt.Println("[config] reloading configuration...")
	// In a real app, re-read the config file here
	config["log_level"] = "debug"
	fmt.Printf("[config] log_level is now: %s\n", config["log_level"])
}

func gracefulShutdown() {
	fmt.Println("[shutdown] closing database connections...")
	time.Sleep(500 * time.Millisecond)
	fmt.Println("[shutdown] flushing logs...")
	time.Sleep(300 * time.Millisecond)
	fmt.Println("[shutdown] done. goodbye.")
}

func main() {
	fmt.Println("[app] starting up...")
	fmt.Printf("[app] config: %v\n", config)

	// BUG: unbuffered channel
	sigChan := make(chan os.Signal)
	signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT, syscall.SIGHUP)

	fmt.Println("[app] running. send me signals:")
	fmt.Println("  kill -TERM <pid>  — graceful shutdown")
	fmt.Println("  kill -HUP <pid>   — reload config")
	fmt.Println("  Ctrl+C            — graceful shutdown")
	fmt.Printf("[app] my PID is %d\n", os.Getpid())

	for {
		sig := <-sigChan
		switch sig {
		case syscall.SIGHUP:
			reloadConfig()
		case syscall.SIGTERM, syscall.SIGINT:
			fmt.Printf("\n[app] received %s\n", sig)
			gracefulShutdown()
			os.Exit(0)
		}
	}
}

go run step3/main.go

kill -HUP 54321

kill -TERM 54321

sigChan := make(chan os.Signal)

sigChan := make(chan os.Signal, 1)

sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT, syscall.SIGHUP)

ulimit -a

ulimit -n 65536

ulimit -v 1048576

nice -n 19 ./heavy-task

renice -n 10 -p PID

package main

import (
	"fmt"
	"os"
	"os/exec"
	"syscall"
)

func main() {
	// Start a child process with resource limits
	cmd := exec.Command("sh", "-c", `
		echo "Child started (pid=$$)"
		echo "Allocating memory..."
		# Allocate ~50MB by reading from /dev/urandom
		head -c 52428800 /dev/urandom > /dev/null
		echo "Done"
	`)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	// Set memory limit to 10MB (too low)
	memLimit := uint64(10 * 1024 * 1024) // 10MB in bytes
	cmd.SysProcAttr = &syscall.SysProcAttr{}

	// Set RLIMIT_AS (address space limit) before starting
	// We need to use a wrapper approach since SysProcAttr doesn't
	// directly support rlimits on the child. Instead, set them in
	// the child using a prlimit approach.

	// For simplicity, we'll set limits using prlimit command
	cmd = exec.Command("sh", "-c", fmt.Sprintf(`
		ulimit -v %d
		echo "Child started (pid=$$)"
		echo "Memory limit set to %d KB"
		echo "Allocating memory..."
		# Try to allocate a large block
		python3 -c "x = bytearray(%d); print('Allocated', len(x), 'bytes')"
		echo "Exit code: $?"
	`, memLimit/1024, memLimit/1024, 50*1024*1024))

	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	fmt.Println("Starting child with memory limit...")
	err := cmd.Run()
	if err != nil {
		// BUG: just print the error with no context
		fmt.Println("Error:", err)
	}
}

go run step4/main.go

package main

import (
	"errors"
	"fmt"
	"os"
	"os/exec"
	"syscall"
)

func runWithLimits(command string, memLimitKB uint64) error {
	cmd := exec.Command("sh", "-c", fmt.Sprintf(`
		ulimit -v %d 2>/dev/null
		exec %s
	`, memLimitKB, command))

	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	fmt.Printf("Starting child with memory limit %d KB...\n", memLimitKB)
	err := cmd.Run()
	if err == nil {
		fmt.Println("Child exited normally")
		return nil
	}

	// Check if it was killed by a signal
	var exitErr *exec.ExitError
	if errors.As(err, &exitErr) {
		status, ok := exitErr.Sys().(syscall.WaitStatus)
		if ok {
			if status.Signaled() {
				sig := status.Signal()
				fmt.Printf("Child killed by signal: %s (%d)\n", sig, sig)

				if sig == syscall.SIGKILL {
					fmt.Println("SIGKILL + resource limit = likely hit memory limit")
					fmt.Println("Try increasing the memory limit or reducing usage")
				}
				if sig == syscall.SIGXFSZ {
					fmt.Println("Hit file size limit (RLIMIT_FSIZE)")
				}
				return err
			}

			fmt.Printf("Child exited with code: %d\n", status.ExitStatus())
			return err
		}
	}

	fmt.Println("Error:", err)
	return err
}

func main() {
	fmt.Println("=== Test 1: Low memory limit (will likely fail) ===")
	runWithLimits(
		`python3 -c "x = bytearray(50*1024*1024); print('Allocated', len(x), 'bytes')"`,
		10*1024, // 10MB
	)

	fmt.Println()

	fmt.Println("=== Test 2: Generous memory limit (should succeed) ===")
	runWithLimits(
		`python3 -c "x = bytearray(10*1024*1024); print('Allocated', len(x), 'bytes')"`,
		512*1024, // 512MB
	)
}

nohup ./server &

disown

[Unit]
Description=My Go Service
After=network.target

[Service]
ExecStart=/usr/local/bin/myservice
Restart=always
RestartSec=5
LimitNOFILE=65536
User=deploy

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl start myservice
sudo systemctl status myservice
sudo journalctl -u myservice -f

package main

import (
	"fmt"
	"os"
	"os/exec"
	"time"
)

func main() {
	command := "sh"
	args := []string{"-c", `echo "Worker started (pid=$$)"; sleep 3; echo "Worker done"; exit 1`}

	restarts := 0

	for {
		fmt.Printf("[supervisor] starting: %s %v\n", command, args)

		cmd := exec.Command(command, args...)
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr

		startTime := time.Now()
		err := cmd.Run()
		elapsed := time.Since(startTime)

		restarts++
		fmt.Printf("[supervisor] process exited after %v (err=%v)\n", elapsed.Round(time.Millisecond), err)

		// BUG: restart immediately every time
		fmt.Printf("[supervisor] restarting (attempt %d)...\n\n", restarts)
	}
}

go run step5/main.go

package main

import (
	"fmt"
	"os"
	"os/exec"
	"time"
)

type BackoffPolicy struct {
	Delay      time.Duration
	MinDelay   time.Duration
	MaxDelay   time.Duration
	QuickCrash time.Duration // if child runs less than this, it's a "fast crash"
	StableTime time.Duration // if child runs more than this, reset delay
}

func defaultBackoff() BackoffPolicy {
	return BackoffPolicy{
		Delay:      1 * time.Second,
		MinDelay:   1 * time.Second,
		MaxDelay:   60 * time.Second,
		QuickCrash: 5 * time.Second,
		StableTime: 30 * time.Second,
	}
}

func main() {
	command := "sh"
	args := []string{"-c", `echo "Worker started (pid=$$)"; sleep 1; echo "Worker crashed"; exit 1`}

	restarts := 0
	backoff := defaultBackoff()

	for {
		fmt.Printf("[supervisor] starting: %s\n", command)

		cmd := exec.Command(command, args...)
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr

		startTime := time.Now()
		err := cmd.Run()
		elapsed := time.Since(startTime)

		restarts++
		fmt.Printf("[supervisor] process exited after %v (err=%v)\n",
			elapsed.Round(time.Millisecond), err)

		if elapsed < backoff.QuickCrash {
			// Fast crash — increase backoff
			backoff.Delay *= 2
			if backoff.Delay > backoff.MaxDelay {
				backoff.Delay = backoff.MaxDelay
			}
			fmt.Printf("[supervisor] fast crash detected — backoff: %v\n", backoff.Delay)
		} else if elapsed > backoff.StableTime {
			// Ran for a while — reset backoff
			backoff.Delay = backoff.MinDelay
			fmt.Println("[supervisor] process was stable — resetting backoff")
		}

		fmt.Printf("[supervisor] restarting in %v (attempt %d)...\n\n", backoff.Delay, restarts)
		time.Sleep(backoff.Delay)
	}
}

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	fmt.Printf("Worker started (pid=%d)\n", os.Getpid())

	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		fmt.Fprintln(w, "ok")
	})

	server := &http.Server{Addr: ":8080"}

	// Graceful shutdown on SIGTERM
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)

	go func() {
		sig := <-sigChan
		fmt.Printf("\nWorker received %s, shutting down...\n", sig)
		server.Close()
	}()

	fmt.Println("Worker listening on :8080")
	if err := server.ListenAndServe(); err != http.ErrServerClosed {
		log.Fatal(err)
	}
	fmt.Println("Worker stopped cleanly")

	// Simulate cleanup
	time.Sleep(500 * time.Millisecond)
	fmt.Println("Worker cleanup done")
}

cd step6/worker && go build -o worker . && cd ../..

package main

import (
	"errors"
	"flag"
	"fmt"
	"net/http"
	"os"
	"os/exec"
	"os/signal"
	"strings"
	"syscall"
	"time"
)

// ANSI colors
const (
	colorReset  = "\033[0m"
	colorRed    = "\033[31m"
	colorGreen  = "\033[32m"
	colorYellow = "\033[33m"
	colorCyan   = "\033[36m"
)

type SupervisorConfig struct {
	Command        string
	HealthURL      string
	CheckInterval  time.Duration
	MaxFailures    int
	GraceTimeout   time.Duration
	MinBackoff     time.Duration
	MaxBackoff     time.Duration
	QuickCrashTime time.Duration
	StableTime     time.Duration
}

type Supervisor struct {
	config       SupervisorConfig
	cmd          *exec.Cmd
	restarts     int
	startTime    time.Time
	backoff      time.Duration
	lastHealth   string
	running      bool
	shutdownChan chan struct{}
}

func NewSupervisor(cfg SupervisorConfig) *Supervisor {
	return &Supervisor{
		config:       cfg,
		backoff:      cfg.MinBackoff,
		shutdownChan: make(chan struct{}),
	}
}

func (s *Supervisor) log(color, format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	timestamp := time.Now().Format("15:04:05")
	fmt.Printf("%s[supervisor %s]%s %s\n", color, timestamp, colorReset, msg)
}

func (s *Supervisor) startProcess() error {
	parts := strings.Fields(s.config.Command)
	s.cmd = exec.Command(parts[0], parts[1:]...)
	s.cmd.Stdout = os.Stdout
	s.cmd.Stderr = os.Stderr

	// Set process group so we can kill the whole tree
	s.cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

	if err := s.cmd.Start(); err != nil {
		return fmt.Errorf("failed to start: %w", err)
	}

	s.startTime = time.Now()
	s.running = true
	s.log(colorGreen, "process started (pid=%d)", s.cmd.Process.Pid)
	return nil
}

func (s *Supervisor) stopProcess() error {
	if s.cmd == nil || s.cmd.Process == nil {
		return nil
	}

	s.log(colorYellow, "sending SIGTERM to pid=%d", s.cmd.Process.Pid)
	if err := s.cmd.Process.Signal(syscall.SIGTERM); err != nil {
		return err
	}

	done := make(chan error, 1)
	go func() {
		done <- s.cmd.Wait()
	}()

	select {
	case err := <-done:
		s.running = false
		s.log(colorGreen, "process exited gracefully")
		return err
	case <-time.After(s.config.GraceTimeout):
		s.log(colorRed, "grace timeout — sending SIGKILL")
		s.cmd.Process.Kill()
		err := <-done
		s.running = false
		return err
	}
}

func (s *Supervisor) checkHealth() (int, error) {
	client := &http.Client{Timeout: 5 * time.Second}
	resp, err := client.Get(s.config.HealthURL)
	if err != nil {
		return 0, err
	}
	defer resp.Body.Close()
	return resp.StatusCode, nil
}

func (s *Supervisor) waitForProcess() error {
	return s.cmd.Wait()
}

func (s *Supervisor) updateBackoff(elapsed time.Duration) {
	if elapsed < s.config.QuickCrashTime {
		s.backoff *= 2
		if s.backoff > s.config.MaxBackoff {
			s.backoff = s.config.MaxBackoff
		}
		s.log(colorYellow, "fast crash (%v) — backoff: %v", elapsed.Round(time.Millisecond), s.backoff)
	} else if elapsed > s.config.StableTime {
		s.backoff = s.config.MinBackoff
		s.log(colorCyan, "process was stable — resetting backoff")
	}
}

func (s *Supervisor) Run() {
	// Handle signals for graceful shutdown of supervisor itself
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)

	go func() {
		sig := <-sigChan
		s.log(colorYellow, "received %s — shutting down", sig)
		close(s.shutdownChan)
		if s.running {
			s.stopProcess()
		}
		os.Exit(0)
	}()

	for {
		s.log(colorCyan, "starting: %s", s.config.Command)

		if err := s.startProcess(); err != nil {
			s.log(colorRed, "start failed: %v", err)
			s.log(colorYellow, "retrying in %v...", s.backoff)
			time.Sleep(s.backoff)
			s.backoff *= 2
			if s.backoff > s.config.MaxBackoff {
				s.backoff = s.config.MaxBackoff
			}
			continue
		}

		// Wait for the process to exit in the background
		exitChan := make(chan error, 1)
		go func() {
			exitChan <- s.waitForProcess()
		}()

		// Run health check loop
		failures := 0
		ticker := time.NewTicker(s.config.CheckInterval)

	healthLoop:
		for {
			select {
			case err := <-exitChan:
				// Process exited on its own
				ticker.Stop()
				s.running = false
				elapsed := time.Since(s.startTime)

				if err != nil {
					s.log(colorRed, "process exited with error after %v: %v",
						elapsed.Round(time.Millisecond), err)

					// Check if killed by signal
					var exitErr *exec.ExitError
					if errors.As(err, &exitErr) {
						if status, ok := exitErr.Sys().(syscall.WaitStatus); ok && status.Signaled() {
							s.log(colorRed, "killed by signal: %s", status.Signal())
						}
					}
				} else {
					s.log(colorYellow, "process exited cleanly after %v",
						elapsed.Round(time.Millisecond))
				}

				s.updateBackoff(elapsed)
				break healthLoop

			case <-ticker.C:
				// Health check
				statusCode, err := s.checkHealth()
				uptime := time.Since(s.startTime).Round(time.Second)

				if err != nil {
					failures++
					s.lastHealth = fmt.Sprintf("FAILED (%v)", err)
					s.log(colorRed, "health check FAILED (%v) [%d/%d]",
						err, failures, s.config.MaxFailures)
				} else if statusCode >= 200 && statusCode < 300 {
					failures = 0
					s.lastHealth = fmt.Sprintf("OK (%d)", statusCode)
					s.log(colorGreen, "health check OK (%d) — uptime: %v, restarts: %d",
						statusCode, uptime, s.restarts)
				} else {
					failures++
					s.lastHealth = fmt.Sprintf("UNHEALTHY (%d)", statusCode)
					s.log(colorRed, "health check UNHEALTHY (%d) [%d/%d]",
						statusCode, failures, s.config.MaxFailures)
				}

				if failures >= s.config.MaxFailures {
					s.log(colorRed, "health check failed %d times — restarting process",
						s.config.MaxFailures)
					ticker.Stop()
					s.stopProcess()
					s.restarts++
					break healthLoop
				}

			case <-s.shutdownChan:
				ticker.Stop()
				return
			}
		}

		s.restarts++
		s.log(colorYellow, "restarting in %v (restart #%d)...", s.backoff, s.restarts)
		time.Sleep(s.backoff)
	}
}

func main() {
	cmdFlag := flag.String("cmd", "", "Command to run and supervise")
	healthFlag := flag.String("health", "", "Health check URL (e.g. http://localhost:8080/health)")
	intervalFlag := flag.Duration("interval", 10*time.Second, "Health check interval")
	maxFailFlag := flag.Int("max-failures", 3, "Consecutive failures before restart")
	graceFlag := flag.Duration("grace", 10*time.Second, "Grace period for SIGTERM before SIGKILL")
	flag.Parse()

	if *cmdFlag == "" {
		fmt.Println("Usage: supervisor --cmd './myserver' --health 'http://localhost:8080/health'")
		fmt.Println()
		fmt.Println("Flags:")
		flag.PrintDefaults()
		os.Exit(1)
	}

	config := SupervisorConfig{
		Command:        *cmdFlag,
		HealthURL:      *healthFlag,
		CheckInterval:  *intervalFlag,
		MaxFailures:    *maxFailFlag,
		GraceTimeout:   *graceFlag,
		MinBackoff:     1 * time.Second,
		MaxBackoff:     60 * time.Second,
		QuickCrashTime: 5 * time.Second,
		StableTime:     30 * time.Second,
	}

	s := NewSupervisor(config)

	fmt.Println("=== Process Supervisor ===")
	fmt.Printf("Command:        %s\n", config.Command)
	fmt.Printf("Health URL:     %s\n", config.HealthURL)
	fmt.Printf("Check interval: %v\n", config.CheckInterval)
	fmt.Printf("Max failures:   %d\n", config.MaxFailures)
	fmt.Printf("Grace timeout:  %v\n", config.GraceTimeout)
	fmt.Println()

	s.Run()
}

go build -o supervisor step6/main.go
./supervisor --cmd "./step6/worker/worker" --health "http://localhost:8080/health" --interval 10s

kill -9 $(pgrep -f worker)

./supervisor --cmd "sleep 300" --health "http://localhost:8080/health" --interval 5s

kill -TERM $(pgrep -f supervisor)

ps aux --sort=-%mem | head -20         # top processes by memory
ps -eo pid,ppid,cmd --forest           # process tree
pgrep -af nginx                        # find by name
kill -TERM PID                         # graceful stop
kill -9 PID                            # forced stop
kill -HUP PID                          # reload config
nice -n 19 ./task                      # low priority
ulimit -n 65536                        # max open files
systemctl status myservice             # service status
journalctl -u myservice -f             # follow logs