Techniques for Redirecting Standard Output to Log Files Within Bash Scripts

Technical Background and Problem Definition

In Bash script development, logging is a common requirement. Developers often need script output to be both displayed on the terminal for real-time monitoring and saved to log files for subsequent analysis. While piping with the tee command from outside the script can easily achieve this functionality, certain scenarios require declaring this dual-output behavior within the script itself, providing self-contained logging capabilities.

Core Solution: Process Substitution and tee Command

Bash provides process substitution functionality, allowing command output to be used as file descriptors. Combined with the tee command's特性, this enables duplication and分流of standard output. The basic implementation code is as follows:

#!/usr/bin/env bash

# Redirect standard output to a named pipe running tee
exec > >(tee -i logfile.txt)

# Redirect standard error to standard output to ensure error messages are logged
exec 2>&1

echo "Normal output message"
echo "Error message example" >&2

In-depth Technical Analysis

The core of the above code lies in the >(tee -i logfile.txt) construct. In Bash, >() creates a named pipe (FIFO) running the tee -i logfile.txt command. The tee command's特殊性lies in its ability to write input data simultaneously to standard output and specified files.

When executing exec > >(tee -i logfile.txt), the script's standard output file descriptor (FD 1) is redirected to this named pipe. Subsequently, all standard output content passes through the pipe to the tee process, which负责sends data both to the terminal (through its own standard output) and to the log file.

The -i option in tee -i ignores interrupt signals, preventing output interruption when receiving signals like SIGINT, which is particularly important in scripts that need to handle signal traps.

Standard Error Stream Handling Strategies

The initial approach with exec 2>&1 merges standard error into standard output, ensuring error messages are also logged. However, this method alters the independent nature of standard error and may produce unexpected behavior in certain usage scenarios.

An alternative approach creates independent tee processes for standard error:

#!/bin/bash

# Set up separate tee processes for stdout and stderr
exec >  >(tee -ia foo.log)
exec 2> >(tee -ia foo.log >&2)

echo "Standard output content"
echo "Standard error content" >&2

This method maintains standard output and standard error as independent streams, but需要注意concurrent writing by two tee processes may cause interleaved line ordering in the log file. According to POSIX specifications, tee uses unbuffered I/O, which more closely resembles the真实timing characteristics of terminal output.

Practical Application Considerations

The process substitution and tee approach primarily applies to Bash environments, as execution in standard sh will produce syntax errors. If scripts require cross-shell compatibility, alternative implementations should be considered.

Certain command-line tools (like ls) adjust their output format based on destination type. When detecting output redirected to a pipe, these tools may disable color output or column formatting. Formatting can be maintained through强制options (like ls -C --color=always), but note this will write control characters to the log file as well.

Log file initialization also warrants attention. The above code defaults to appending to log files. If旧logs need truncation with each script execution, add >foo.log at the script beginning to truncate the file.

Performance and Reliability Considerations

The dual independent tee process approach maintains stream separation but increases process management overhead. In scenarios with massive output volumes, this overhead's impact on performance should be evaluated.

For applications requiring strict output ordering preservation, consider using a single log file with timestamp prefixes, or separate log files for standard output and standard error with post-execution chronological merging for analysis.

Summary and Best Practices

For implementing simultaneous display and logging of output within Bash scripts, the combination of process substitution and tee commands provides a flexible and powerful solution. When selecting specific implementation approaches, comprehensively consider the following factors:

1. Whether standard error independence needs preservation
2. Script execution environment (Bash-specific or requiring shell compatibility)
3. Stringency of output ordering requirements
4. Sensitivity to performance overhead
5. Log file initialization needs

For most application scenarios, the single tee process approach merging standard output and standard error provides good balance, achieving complete logging while maintaining code simplicity. In scenarios requiring精细control over output streams, the dual tee process approach offers more professional solutions.