Production Bash Error Handling: Choose Strict Mode with Trapped Cleanup

The problem: silent failures and leaked temp files in production scripts

Production bash scripts need two guarantees: fail fast on real errors, and always clean up temporary resources. The common failure mode is a script that continues after a failed command in a pipeline, uses an unset variable, and leaves a temp directory behind. The useful takeaway is to standardize on strict mode with explicit traps, and only relax it where control flow requires it.

Decision and constraints

Adopt set -euo pipefail with trap 'cleanup' EXIT and an ERR notification trap for scripts that run on Linux and macOS with bash 4+.

Constraints that drive the decision:

• Fail-fast on non-zero exit, undefined variables, and silent pipe failures.
• Portable to common Linux/macOS bash, not POSIX sh.
• Maintainable for teams: minimal boilerplate, predictable cleanup.
• Temporary files and locks must be removed on success and error.

Options compared

Trade-offs

Strict mode catches more bug classes early and removes repetitive checks. The cost is changed control flow. set -e does not exit when a failing command is part of an if test, &&/|| list, or command substitution. Developers unfamiliar with this can be surprised.

set -u errors on referencing unset variables, including positional parameters in loops. Use defaults like ${var:-} where absence is intentional.

pipefail and set -o options are bash-specific and not available in POSIX sh. Scripts must require bash explicitly via shebang.

ERR trap is not inherited by subshells in older bash releases. Keep cleanup logic in functions called in the main shell, not in background subshells.

Manual checks are maximally portable and explicit, but increase code size and risk of missed checks. set -e only is common but hides failures in pipelines.

Concrete implementation

Use this skeleton for production scripts. Run it with bash 4+ on the target host. Requires write permission for temp directory creation.

#!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'

tmpdir=$(mktemp -d)
cleanup() {
  rm -rf "$tmpdir"
}
trap cleanup EXIT
trap 'echo "error on line $LINENO" >&2' ERR

# main logic, always quote variables
output="$tmpdir/out.txt"
cat > "$output" <<'EOF'
data
EOF

# intentional error handling example
if ! grep -q data "$output"; then
  echo "missing data" >&2
  exit 1
fi

The EXIT trap runs on normal exit and on error, guaranteeing removal of $tmpdir. The ERR trap logs the line number without changing exit status.

Limitations and verification

Limitations:

• Do not rely on set -e inside complex conditionals without explicit tests.
• Avoid unquoted expansions with set -u.
• Do not assume pipefail in POSIX sh environments.

Practical checks before shipping:

1. Confirm bash version: run bash --version on target systems and require 4+.
2. Test undefined variable detection: create a script with set -euo pipefail and reference an unset variable, run it, and confirm non-zero exit with no partial execution.
3. Test pipefail: run a script containing false | true under set -o pipefail and verify the script exits non-zero.
4. Test cleanup: run a script that creates a temp directory, triggers an error, then inspect the filesystem to confirm the EXIT trap removed the directory.

When the operation changes state, keep rollback simple: the EXIT trap itself is the rollback for temp resources. For scripts that modify system state, add an explicit undo function and trap it on ERR.