In bash/ksh can we add timestamp to STDERR redirection?
E.g. myscript.sh 2> error.log
I want to get a timestamp written on the log too.
If you're talking about an up-to-date timestamp on each line, that's something you'd probably want to do in your actual script (but see below for a nifty solution if you have no power to change it). If you just want a marker date on its own line before your script starts writing, I'd use:
( date 1>&2 ; myscript.sh ) 2>error.log
What you need is a trick to pipe stderr through another program that can add timestamps to each line. You could do this with a C program but there's a far more devious way using just bash.
First, create a script which will add the timestamp to each line (called predate.sh):
#!/bin/bash
while read line ; do
echo "$(date): ${line}"
done
For example:
( echo a ; sleep 5 ; echo b ; sleep 2 ; echo c ) | ./predate.sh
produces:
Fri Oct 2 12:31:39 WAST 2009: a
Fri Oct 2 12:31:44 WAST 2009: b
Fri Oct 2 12:31:46 WAST 2009: c
Then you need another trick that can swap stdout and stderr, this little monstrosity here:
( myscript.sh 3>&1 1>&2- 2>&3- )
Then it's simple to combine the two tricks by timestamping stdout and redirecting it to your file:
( myscript.sh 3>&1 1>&2- 2>&3- ) | ./predate.sh >error.log
The following transcript shows this in action:
pax> cat predate.sh
#!/bin/bash
while read line ; do
echo "$(date): ${line}"
done
pax> cat tstdate.sh
#!/bin/bash
echo a to stderr then wait five seconds 1>&2
sleep 5
echo b to stderr then wait two seconds 1>&2
sleep 2
echo c to stderr 1>&2
echo d to stdout
pax> ( ( ./tstdate.sh ) 3>&1 1>&2- 2>&3- ) | ./predate.sh >error.log
d to stdout
pax> cat error.log
Fri Oct 2 12:49:40 WAST 2009: a to stderr then wait five seconds
Fri Oct 2 12:49:45 WAST 2009: b to stderr then wait two seconds
Fri Oct 2 12:49:47 WAST 2009: c to stderr
As already mentioned, predate.sh will prefix each line with a timestamp and the tstdate.sh is simply a test program to write to stdout and stderr with specific time gaps.
When you run the command, you actually get "d to stdout" written to stderr (but that's your TTY device or whatever else stdout may have been when you started). The timestamped stderr lines are written to your desired file.
The devscripts package in Debian/Ubuntu contains a script called annotate-output which does that (for both stdout and stderr).
$ annotate-output make
21:41:21 I: Started make
21:41:21 O: gcc -Wall program.c
21:43:18 E: program.c: Couldn't compile, and took me ages to find out
21:43:19 E: collect2: ld returned 1 exit status
21:43:19 E: make: *** [all] Error 1
21:43:19 I: Finished with exitcode 2
Here's a version that uses a while read loop like pax's, but doesn't require extra file descriptors or a separate script (although you could use one). It uses process substitution:
myscript.sh 2> >( while read line; do echo "$(date): ${line}"; done > error.log )
Using pax's predate.sh:
myscript.sh 2> >( predate.sh > error.log )
The program ts from the moreutils package pipes standard input to standard output, and prefixes each line with a timestamp.
To prefix stdout lines: command | ts
To prefix both stdout and stderr: command 2>&1 | ts
I like those portable shell scripts but a little disturbed that they fork/exec date(1) for every line. Here is a quick perl one-liner to do the same more efficiently:
perl -p -MPOSIX -e 'BEGIN {$!=1} $_ = strftime("%T ", localtime) . $_'
To use it, just feed this command input through its stdin:
(echo hi; sleep 1; echo lo) | perl -p -MPOSIX -e 'BEGIN {$|=1} $_ = strftime("%T ", localtime) . $_'
Rather than writing a script to pipe to, I prefer to write the logger as a function inside the script, and then send the entirety of the process into it with brackets, like so:
# Vars
logfile=/path/to/scriptoutput.log
# Defined functions
teelogger(){
log=$1
while read line ; do
print "$(date +"%x %T") :: $line" | tee -a $log
done
}
# Start process
{
echo 'well'
sleep 3
echo 'hi'
sleep 3
echo 'there'
sleep 3
echo 'sailor'
} | teelogger $logfile
If you want to redirect back to stdout I found you have to do this:
myscript.sh >> >( while read line; do echo "$(date): ${line}"; done )
Not sure why I need the > in front of the (, so <(, but thats what works.
I was too lazy for all current solutions... So I figured out new one (works for stdout could be adjusted for stderr as well):
echo "output" | xargs -L1 -I{} bash -c "echo \$(date +'%x %T') '{}'" | tee error.log
would save to file and print something like that:
11/3/16 16:07:52 output
Details:
-L1 means "for each new line"
-I{} means "replace {} by input"
bash -c is used to update $(date) each time for new call
%x %T formats timestamp to minimal form.
It should work like a charm if stdout and stderr doesn't have quotes (" or `). If it has (or could have) it's better to use:
echo "output" | awk '{cmd="(date +'%H:%M:%S')"; cmd | getline d; print d,$0; close(cmd)} | tee error.log'
(Took from my answer in another topic: https://stackoverflow.com/a/41138870/868947)
How about timestamping the remaining output, redirecting all to stdout?
This answer combines some techniques from above, as well as from unix stackexchange here and here. bash >= 4.2 is assumed, but other advanced shells may work. For < 4.2, replace printf with a (slower) call to date.
: ${TIMESTAMP_FORMAT:="%F %T"} # override via environment
_loglines() {
while IFS= read -r _line ; do
printf "%(${TIMESTAMP_FORMAT})T#%s\n" '-1' "$_line";
done;
}
exec 7<&2 6<&1
exec &> >( _loglines )
# Logit
To restore stdout/stderr:
exec 1>&6 2>&7
You can then use tee to send the timestamps to stdout and a logfile.
_tmpfile=$(mktemp)
exec &> >( _loglines | tee $_tmpfile )
Not a bad idea to have cleanup code if the process exited without error:
trap "_cleanup \$?" 0 SIGHUP SIGINT SIGABRT SIGBUS SIGQUIT SIGTRAP SIGUSR1 SIGUSR2 SIGTERM
_cleanup() {
exec >&6 2>&7
[[ "$1" != 0 ]] && cat "$_logtemp"
rm -f "$_logtemp"
exit "${1:-0}"
}
#!/bin/bash
DEBUG=1
LOG=$HOME/script_${0##*/}_$(date +%Y.%m.%d-%H.%M.%S-%N).log
ERROR=$HOME/error.log
exec 2> $ERROR
exec 1> >(tee -ai $LOG)
if [ $DEBUG = 0 ] ; then
exec 4> >(xargs -i echo -e "[ debug ] {}")
else
exec 4> /dev/null
fi
# test
echo " debug sth " >&4
echo " log sth normal "
type -f this_is_error
echo " errot sth ..." >&2
echo " finish ..." >&2>&4
# close descriptor 4
exec 4>&-
This thing: nohup myscript.sh 2> >( while read line; do echo "$(date): ${line}"; done > mystd.err ) < /dev/null &
Works as such but when I log out and log back in to the server, it does not work. that is mystd.err stop getting populated with stderr stream even though my process (myscript.sh here) still runs.
Does someone know how to get back the lost stderr in the mystd.err file back?
Thought I would add my 2 cents worth..
#!/bin/sh
timestamp(){
name=$(printf "$1%*s" `expr 15 - ${#1}`)
awk "{ print strftime(\"%b %d %H:%M:%S\"), \"- $name -\", $$, \"- INFO -\", \$0; fflush() }";
}
echo "hi" | timestamp "process name" >> /tmp/proccess.log
printf "$1%*s" `expr 15 - ${#1}`
Spaces the name out so it looks nice, where 15 is the max space issued, increase if desired
outputs >> Date - Process name - Process ID - INFO - Message
Jun 27 13:57:20 - process name - 18866 - INFO - hi
Redirections are taken in order. Try this:
Given a script -
$: cat tst
echo a
sleep 2
echo 1 >&2
echo b
sleep 2
echo 2 >&2
echo c
sleep 2
echo 3 >&2
echo d
I get the following
$: ./tst 2>&1 1>stdout | sed 's/^/echo $(date +%Y%m%dT%H%M%S) /; e'
20180925T084008 1
20180925T084010 2
20180925T084012 3
And as much as I dislike awk, it does avoid the redundant subcalls to date.
$: ./tst 2>&1 1>stdout | awk "{ print strftime(\"%Y%m%dT%H%M%S \") \$0; fflush() }"; >stderr
$: cat stderr
20180925T084414 1
20180925T084416 2
20180925T084418 3
$: cat stdout
a
b
c
d
Related
I am assigning the output of a command to variable A:
A=$(some_command)
How can I "capture" stderr into a variable B ?
I have tried some variations with 2>&1 and read but that does not work:
A=$(some_command) 2>&1 | read B
echo $B
Here's a code snippet that might help you
# capture stderr into a variable and print it
echo "capture stderr into a variable and print it"
var=$(lt -l /tmp 2>&1)
echo $var
capture stderr into a variable and print it
zsh: command not found: lt
# capture stdout into a variable and print it
echo "capture stdout into a variable and print it"
var=$(ls -l /tmp)
echo $var
# capture both stderr and stdout into a variable and print it
echo "capture both stderr and stdout into a variable and print it"
var=$(ls -l /tmp 2>&1)
echo $var
# more classic way of executing a command which I always follow is as follows. This way I am always in control of what is going on and can act accordingly
if somecommand ; then
echo "command succeeded"
else
echo "command failed"
fi
If you have to capture the output and stderr in different variables, then the following might help as well
## create a file using file descriptor for stdout
exec 3> stdout.txt
# create a file using file descriptor for stderr
exec 4> stderr.txt
A=$($1 /tmp 2>&4 >&3);
## close file descriptor
exec 3>&-
exec 4>&-
## open file descriptor for reading
exec 3< stdout.txt
exec 4< stderr.txt
## read from file using file descriptor
read line <&3
read line2 <&4
## close file descriptor
exec 3<&-
exec 4<&-
## print line read from file
echo "stdout: $line"
echo "stderr: $line2"
## delete file
rm stdout.txt
rm stderr.txt
You can try running it with the following
╰─ bash test.sh pwd
stdout: /tmp/somedir
stderr:
╰─ bash test.sh pwdd
stdout:
stderr: test.sh: line 8: pwdd: command not found
As noted in a comment your use case may be better served in other scripting languages. An example: in Perl you can achieve what you want quite simple:
#!/usr/bin/env perl
use v5.26; # or earlier versions
use Capture::Tiny 'capture'; # library is not in core
my $cmd = 'date';
my #arg = ('-R', '-u');
my ($stdout, $stderr, $exit) = capture {
system( $cmd, #arg );
};
say "STDOUT: $stdout";
say "STDERR: $stderr";
say "EXIT: $exit";
I'm sure similar solutions are available in python, ruby, and all the rest.
I gave it another try using process substitution and came up with this:
# command with no error
date +%b > >(read A; if [ "$A" = 'Sep' ]; then echo 'September'; fi ) 2> >(read B; if [ ! -z "$B" ]; then echo "$B"; fi >&2)
September
# command with error
date b > >(read A; if [ "$A" = 'Sep' ]; then echo 'September'; fi ) 2> >(read B; if [ ! -z "$B" ]; then echo "$B"; fi >&2)
date: invalid date “b“
# command with both at the same time should work too
I had no success "exporting" the variables from the subprocesses back to the original script. It might be possible though. I just couldn't figure it out.
But this gives you at least access to stdout and stderr as a variable. This means you can do whatever processing you want on them as variables. It depends on your use case if this is of any help to you. Good luck :-)
bash 4.2 centos7
test.sh
LOG_FILE=./logs/result.log
exec > >(tee -a ${LOG_FILE} )
exec 2> >(tee -a ${LOG_FILE} >&2)
echo
for x in {1..3}
do
echo $x
done
# I want the second part to be displayed but not logged.
for x in {4..6}
do
echo $x
done
# Recommence logging
for x in {7..9}
do
echo $x
done
desired output
console
1
2
3
4
5
6
7
8
9
result.log
1
2
3
7
8
9
question
Can I stop or revert the redirection of exec > >(tee -a ${LOG_FILE} ) inside the same shell?
Or should I use different method than tee?
EDIT2
I'm struggling to get this function out of the log.
spinner()
{
trap "kill 0" SIGINT
spin='-\|/'
i=0
while kill -0 $1 2>/dev/null
do
i=$(( (i+1) %4 ))
printf "\e[1;33m" >&3
printf "\r${spin:$i:1}" >&3
printf "\e[m" >&3
sleep .1
done
}
I put >&3 in three printf lines but it results in Bad file descriptor. The function gets a pid parameter and spins the wheel until the delivered pid is done.
You need to save a copy of the original standard output so that you can send the middle section to it once more, like this:
#!/bin/bash
LOG_DIR="./logs"
LOG_FILE="$LOG_DIR/result.log"
mkdir -p "$LOG_DIR"
exec 3>&1 # Save a copy of standard output as file descriptor 3
exec > >(tee -a ${LOG_FILE} )
exec 2> >(tee -a ${LOG_FILE} >&2)
echo
for x in {1..3}
do
echo $x
done
# I want the second part to be displayed but not logged.
{
for x in {4..6}
do
echo $x
done
} 1>&3
# Recommence logging
for x in {7..9}
do
echo $x
done
There are multiple ways of restoring the middle section to write just to the original standard output, but I think the { … } 1>&3 notation is probably the simplest.
Beware: you have two copies of tee both writing to the same file. If you're lucky (careful), the one processing standard error won't have anything to write to the log file. You might be better off using 2>&1 like this exec > >(tee …) 2>&1 and omitting the exec 2> >(tee …) line. Also, note that the prompt may appear before the last of the logging output.
$ bash script.sh
4
5
6
$
1
2
3
7
8
9
echo Hi
Hi
$
I typed the echo Hi to the prompt $ on the line after the 6.
The file logs/result.log contained one copy of the sequence "blank line, numbers 1-3, numbers 7-9" for each time I tested the script.
See also the Bash manual on:
I/O Redirection
Duplicating file descriptors
Command grouping for an explanation of { … }.
I am currently using following to log stdout and stderr. I want to log echo statements along with timestamp.
exec 3>&1 1>>${LOG_FILE} 2>&1
How can I achieve it using shell
Depending on the exact intended behavior you may want the ts
utility.
% echo message | ts
Apr 16 10:56:39 message
You could also alias echo.
% sh
$ alias echo='echo $(date)'
$ echo message
Mon Apr 16 10:57:55 UTC 2018 message
Or make it a shell function.
#!/bin/sh
echo() {
command echo $(date) "$#"
}
echo message
Here I'm using a function to simplify the line, but the main thing to look for is process substitution, that's the >(log_it) syntax. REPLY is the default variable used by read.
logit() {
while read
do
echo "$(date) $REPLY" >> ${LOG_FILE}
done
}
LOG_FILE="./logfile"
exec 3>&1 1>> >(logit) 2>&1
echo "Hello world"
ls -l does_not_exist
The example puts into logfile:
Mon 16 Apr 2018 09:18:33 BST Hello world
Mon 16 Apr 2018 09:18:33 BST ls: does_not_exist: No such file or directory
You might wish to change the bare $(date) to use a better format. If you are running bash 4.2 or later you can use printf instead, which will be more efficient, for example, instead of the echo:
# -1 means "current time"
printf "%(%Y-%m-%d %T)T %s\n" -1 "$REPLY" >> ${LOG_FILE}
Gives:
2018-04-16 09:26:50 Hello world
2018-04-16 09:26:50 ls: does_not_exist: No such file or directory
Brilliant, thanks #cdarke! I'm now using something like the following so that I have more fine-grained control in the main part of my scripts - it logs everything I want and I still see stdout:
logouts() {
while read
do
printf "%(%T)T %s\n" -1 "stdout: $REPLY" | tee -a ${LOG_FILE}
done
}
logerrs() {
while read
do
printf "%(%T)T %s\n" -1 "stderr: $REPLY" >> ${LOG_FILE}
done
}
LOG_FILE="./logfile"
main()
{
echo "Hello world" 1>> >(logouts) 2>> >(logerrs)
ls -l does_not_exist 1>> >(logouts) 2>> >(logerrs)
}
main "$#"
(Apologies to #cdarke: I couldn't format this into a comment - please upvote #cdarke answer if you find this useful.)
Is it possible to store or capture stdout and stderr in different variables, without using a temp file? Right now I do this to get stdout in out and stderr in err when running some_command, but I'd
like to avoid the temp file.
error_file=$(mktemp)
out=$(some_command 2>$error_file)
err=$(< $error_file)
rm $error_file
Ok, it got a bit ugly, but here is a solution:
unset t_std t_err
eval "$( (echo std; echo err >&2) \
2> >(readarray -t t_err; typeset -p t_err) \
> >(readarray -t t_std; typeset -p t_std) )"
where (echo std; echo err >&2) needs to be replaced by the actual command. Output of stdout is saved into the array $t_std line by line omitting the newlines (the -t) and stderr into $t_err.
If you don't like arrays you can do
unset t_std t_err
eval "$( (echo std; echo err >&2 ) \
2> >(t_err=$(cat); typeset -p t_err) \
> >(t_std=$(cat); typeset -p t_std) )"
which pretty much mimics the behavior of var=$(cmd) except for the value of $? which takes us to the last modification:
unset t_std t_err t_ret
eval "$( (echo std; echo err >&2; exit 2 ) \
2> >(t_err=$(cat); typeset -p t_err) \
> >(t_std=$(cat); typeset -p t_std); t_ret=$?; typeset -p t_ret )"
Here $? is preserved into $t_ret
Tested on Debian wheezy using GNU bash, Version 4.2.37(1)-release (i486-pc-linux-gnu).
I think before saying “you can't” do something, people should at least give it a try with their own hands…
Simple and clean solution, without using eval or anything exotic
1. A minimal version
{
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
} < <((printf '\0%s\0' "$(some_command)" 1>&2) 2>&1)
Requires: printf, read
2. A simple test
A dummy script for producing stdout and stderr: useless.sh
#!/bin/bash
#
# useless.sh
#
echo "This is stderr" 1>&2
echo "This is stdout"
The actual script that will capture stdout and stderr: capture.sh
#!/bin/bash
#
# capture.sh
#
{
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
} < <((printf '\0%s\0' "$(./useless.sh)" 1>&2) 2>&1)
echo 'Here is the captured stdout:'
echo "${CAPTURED_STDOUT}"
echo
echo 'And here is the captured stderr:'
echo "${CAPTURED_STDERR}"
echo
Output of capture.sh
Here is the captured stdout:
This is stdout
And here is the captured stderr:
This is stderr
3. How it works
The command
(printf '\0%s\0' "$(some_command)" 1>&2) 2>&1
sends the standard output of some_command to printf '\0%s\0', thus creating the string \0${stdout}\n\0 (where \0 is a NUL byte and \n is a new line character); the string \0${stdout}\n\0 is then redirected to the standard error, where the standard error of some_command was already present, thus composing the string ${stderr}\n\0${stdout}\n\0, which is then redirected back to the standard output.
Afterwards, the command
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
starts reading the string ${stderr}\n\0${stdout}\n\0 up until the first NUL byte and saves the content into ${CAPTURED_STDERR}. Then the command
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
keeps reading the same string up to the next NUL byte and saves the content into ${CAPTURED_STDOUT}.
4. Making it unbreakable
The solution above relies on a NUL byte for the delimiter between stderr and stdout, therefore it will not work if for any reason stderr contains other NUL bytes.
Although that will rarely happen, it is possible to make the script completely unbreakable by stripping all possible NUL bytes from stdout and stderr before passing both outputs to read (sanitization) – NUL bytes would anyway get lost, as it is not possible to store them into shell variables:
{
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
} < <((printf '\0%s\0' "$((some_command | tr -d '\0') 3>&1- 1>&2- 2>&3- | tr -d '\0')" 1>&2) 2>&1)
Requires: printf, read, tr
5. Preserving the exit status – the blueprint (without sanitization)
After thinking a bit about the ultimate approach, I have come out with a solution that uses printf to cache both stdout and the exit code as two different arguments, so that they never interfere.
The first thing I did was outlining a way to communicate the exit status to the third argument of printf, and this was something very easy to do in its simplest form (i.e. without sanitization).
{
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
(IFS=$'\n' read -r -d '' _ERRNO_; exit ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(some_command)" "${?}" 1>&2) 2>&1)
Requires: exit, printf, read
6. Preserving the exit status with sanitization – unbreakable (rewritten)
Things get very messy though when we try to introduce sanitization. Launching tr for sanitizing the streams does in fact overwrite our previous exit status, so apparently the only solution is to redirect the latter to a separate descriptor before it gets lost, keep it there until tr does its job twice, and then redirect it back to its place.
After some quite acrobatic redirections between file descriptors, this is what I came out with.
The code below is a rewriting of the example that I have removed. It also sanitizes possible NUL bytes in the streams, so that read can always work properly.
{
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
(IFS=$'\n' read -r -d '' _ERRNO_; exit ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(((({ some_command; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
Requires: exit, printf, read, tr
This solution is really robust. The exit code is always kept separated in a different descriptor until it reaches printf directly as a separate argument.
7. The ultimate solution – a general purpose function with exit status
We can also transform the code above to a general purpose function.
# SYNTAX:
# catch STDOUT_VARIABLE STDERR_VARIABLE COMMAND [ARG1[ ARG2[ ...[ ARGN]]]]
catch() {
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
(IFS=$'\n' read -r -d '' _ERRNO_; return ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(((({ shift 2; "${#}"; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
}
Requires: cat, exit, printf, read, shift, tr
ChangeLog: 2022-06-17 // Replaced ${3} with shift 2; ${#} after Pavel Tankov's comment (Bash-only). 2023-01-18 // Replaced ${#} with "${#}" after cbugk's comment.
With the catch function we can launch the following snippet,
catch MY_STDOUT MY_STDERR './useless.sh'
echo "The \`./useless.sh\` program exited with code ${?}"
echo
echo 'Here is the captured stdout:'
echo "${MY_STDOUT}"
echo
echo 'And here is the captured stderr:'
echo "${MY_STDERR}"
echo
and get the following result:
The `./useless.sh` program exited with code 0
Here is the captured stdout:
This is stderr 1
This is stderr 2
And here is the captured stderr:
This is stdout 1
This is stdout 2
8. What happens in the last examples
Here follows a fast schematization:
some_command is launched: we then have some_command's stdout on the descriptor 1, some_command's stderr on the descriptor 2 and some_command's exit code redirected to the descriptor 3
stdout is piped to tr (sanitization)
stderr is swapped with stdout (using temporarily the descriptor 4) and piped to tr (sanitization)
the exit code (descriptor 3) is swapped with stderr (now descriptor 1) and piped to exit $(cat)
stderr (now descriptor 3) is redirected to the descriptor 1, end expanded as the second argument of printf
the exit code of exit $(cat) is captured by the third argument of printf
the output of printf is redirected to the descriptor 2, where stdout was already present
the concatenation of stdout and the output of printf is piped to read
9. The POSIX-compliant version #1 (breakable)
Process substitutions (the < <() syntax) are not POSIX-standard (although they de facto are). In a shell that does not support the < <() syntax the only way to reach the same result is via the <<EOF … EOF syntax. Unfortunately this does not allow us to use NUL bytes as delimiters, because these get automatically stripped out before reaching read. We must use a different delimiter. The natural choice falls onto the CTRL+Z character (ASCII character no. 26). Here is a breakable version (outputs must never contain the CTRL+Z character, or otherwise they will get mixed).
_CTRL_Z_=$'\cZ'
{
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" CAPTURED_STDERR;
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" CAPTURED_STDOUT;
(IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" _ERRNO_; exit ${_ERRNO_});
} <<EOF
$((printf "${_CTRL_Z_}%s${_CTRL_Z_}%d${_CTRL_Z_}" "$(some_command)" "${?}" 1>&2) 2>&1)
EOF
Requires: exit, printf, read
Note: As shift is Bash-only, in this POSIX-compliant version command + arguments must appear under the same quotes.
10. The POSIX-compliant version #2 (unbreakable, but not as good as the non-POSIX one)
And here is its unbreakable version, directly in function form (if either stdout or stderr contain CTRL+Z characters, the stream will be truncated, but will never be exchanged with another descriptor).
_CTRL_Z_=$'\cZ'
# SYNTAX:
# catch_posix STDOUT_VARIABLE STDERR_VARIABLE COMMAND
catch_posix() {
{
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" "${1}";
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" "${2}";
(IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" _ERRNO_; return ${_ERRNO_});
} <<EOF
$((printf "${_CTRL_Z_}%s${_CTRL_Z_}%d${_CTRL_Z_}" "$(((({ ${3}; echo "${?}" 1>&3-; } | cut -z -d"${_CTRL_Z_}" -f1 | tr -d '\0' 1>&4-) 4>&2- 2>&1- | cut -z -d"${_CTRL_Z_}" -f1 | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
EOF
}
Requires: cat, cut, exit, printf, read, tr
Answer's history
Here is a previous version of catch() before Pavel Tankov's comment (this version requires the additional arguments to be quoted together with the command):
# SYNTAX:
# catch STDOUT_VARIABLE STDERR_VARIABLE COMMAND [ARG1[ ARG2[ ...[ ARGN]]]]
catch() {
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
(IFS=$'\n' read -r -d '' _ERRNO_; return ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(((({ shift 2; ${#}; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
}
Requires: cat, exit, printf, read, tr
Furthermore, I replaced an old example for propagating the exit status to the current shell, because, as Andy had pointed out in the comments, it was not as “unbreakable” as it was supposed to be (since it did not use printf to buffer one of the streams). For the record I paste the problematic code here:
Preserving the exit status (still unbreakable)
The following variant propagates also the exit status of some_command to the current shell:
{
IFS= read -r -d '' CAPTURED_STDOUT;
IFS= read -r -d '' CAPTURED_STDERR;
(IFS= read -r -d '' CAPTURED_EXIT; exit "${CAPTURED_EXIT}");
} < <((({ { some_command ; echo "${?}" 1>&3; } | tr -d '\0'; printf '\0'; } 2>&1- 1>&4- | tr -d '\0' 1>&4-) 3>&1- | xargs printf '\0%s\0' 1>&4-) 4>&1-)
Requires: printf, read, tr, xargs
Later, Andy submitted the following “suggested edit” for capturing the exit code:
Simple and clean solution saving the exit value
We can add to the end of stderr, a third piece of information, another NUL plus the exit status of the command. It will be outputted after stderr but before stdout
{
IFS= read -r -d '' CAPTURED_STDERR;
IFS= read -r -d '' CAPTURED_EXIT;
IFS= read -r -d '' CAPTURED_STDOUT;
} < <((printf '\0%s\n\0' "$(some_command; printf '\0%d' "${?}" 1>&2)" 1>&2) 2>&1)
His solution seemed to work, but had the minor problem that the exit status needed to be placed as the last fragment of the string, so that we are able to launch exit "${CAPTURED_EXIT}" within round brackets and not pollute the global scope, as I had tried to do in the removed example. The other problem was that, as the output of his innermost printf got immediately appended to the stderr of some_command, we could no more sanitize possible NUL bytes in stderr, because among these now there was also our NUL delimiter.
Trying to find the right solution to this problem was what led me to write § 5. Preserving the exit status – the blueprint (without sanitization), and the following sections.
This is for catching stdout and stderr in different variables. If you only want to catch stderr, leaving stdout as-is, there is a better and shorter solution.
To sum everything up for the benefit of the reader, here is an
Easy Reusable bash Solution
This version does use subshells and runs without tempfiles. (For a tempfile version which runs without subshells, see my other answer.)
: catch STDOUT STDERR cmd args..
catch()
{
eval "$({
__2="$(
{ __1="$("${#:3}")"; } 2>&1;
ret=$?;
printf '%q=%q\n' "$1" "$__1" >&2;
exit $ret
)";
ret="$?";
printf '%s=%q\n' "$2" "$__2" >&2;
printf '( exit %q )' "$ret" >&2;
} 2>&1 )";
}
Example use:
dummy()
{
echo "$3" >&2
echo "$2" >&1
return "$1"
}
catch stdout stderr dummy 3 $'\ndiffcult\n data \n\n\n' $'\nother\n difficult \n data \n\n'
printf 'ret=%q\n' "$?"
printf 'stdout=%q\n' "$stdout"
printf 'stderr=%q\n' "$stderr"
this prints
ret=3
stdout=$'\ndiffcult\n data '
stderr=$'\nother\n difficult \n data '
So it can be used without deeper thinking about it. Just put catch VAR1 VAR2 in front of any command args.. and you are done.
Some if cmd args..; then will become if catch VAR1 VAR2 cmd args..; then. Really nothing complex.
Addendum: Use in "strict mode"
catch works for me identically in strict mode. The only caveat is, that the example above returns error code 3, which, in strict mode, calls the ERR trap. Hence if you run some command under set -e which is expected to return arbitrary error codes (not only 0), you need to catch the return code into some variable like && ret=$? || ret=$? as shown below:
dummy()
{
echo "$3" >&2
echo "$2" >&1
return "$1"
}
catch stdout stderr dummy 3 $'\ndifficult\n data \n\n\n' $'\nother\n difficult \n data \n\n' && ret=$? || ret=$?
printf 'ret=%q\n' "$ret"
printf 'stdout=%q\n' "$stdout"
printf 'stderr=%q\n' "$stderr"
Discussion
Q: How does it work?
It just wraps ideas from the other answers here into a function, such that it can easily be resused.
catch() basically uses eval to set the two variables. This is similar to https://stackoverflow.com/a/18086548
Consider a call of catch out err dummy 1 2a 3b:
let's skip the eval "$({ and the __2="$( for now. I will come to this later.
__1="$("$("${#:3}")"; } 2>&1; executes dummy 1 2a 3b and stores its stdout into __1 for later use. So __1 becomes 2a. It also redirects stderr of dummy to stdout, such that the outer catch can gather stdout
ret=$?; catches the exit code, which is 1
printf '%q=%q\n' "$1" "$__1" >&2; then outputs out=2a to stderr. stderr is used here, as the current stdout already has taken over the role of stderr of the dummy command.
exit $ret then forwards the exit code (1) to the next stage.
Now to the outer __2="$( ... )":
This catches stdout of the above, which is the stderr of the dummy call, into variable __2. (We could re-use __1 here, but I used __2 to make it less confusing.). So __2 becomes 3b
ret="$?"; catches the (returned) return code 1 (from dummy) again
printf '%s=%q\n' "$2" "$__2" >&2; then outputs err=3a to stderr. stderr is used again, as it already was used to output the other variable out=2a.
printf '( exit %q )' "$ret" >&2; then outputs the code to set the proper return value. I did not find a better way, as assigning it to a variable needs a variable name, which then cannot be used as first or second argument to catch.
Please note that, as an optimization, we could have written those 2 printf as a single one like printf '%s=%q\n( exit %q ) "$__2" "$ret"` as well.
So what do we have so far?
We have following written to stderr:
out=2a
err=3b
( exit 1 )
where out is from $1, 2a is from stdout of dummy, err is from $2, 3b is from stderr of dummy, and the 1 is from the return code from dummy.
Please note that %q in the format of printf takes care for quoting, such that the shell sees proper (single) arguments when it comes to eval. 2a and 3b are so simple, that they are copied literally.
Now to the outer eval "$({ ... } 2>&1 )";:
This executes all of above which output the 2 variables and the exit, catches it (therefor the 2>&1) and parses it into the current shell using eval.
This way the 2 variables get set and the return code as well.
Q: It uses eval which is evil. So is it safe?
As long as printf %q has no bugs, it should be safe. But you always have to be very careful, just think about ShellShock.
Q: Bugs?
No obvious bugs are known, except following:
Catching big output needs big memory and CPU, as everything goes into variables and needs to be back-parsed by the shell. So use it wisely.
As usual $(echo $'\n\n\n\n') swallows all linefeeds, not only the last one. This is a POSIX requirement. If you need to get the LFs unharmed, just add some trailing character to the output and remove it afterwards like in following recipe (look at the trailing x which allows to read a softlink pointing to a file which ends on a $'\n'):
target="$(readlink -e "$file")x"
target="${target%x}"
Shell-variables cannot carry the byte NUL ($'\0'). They are simply ignores if they happen to occur in stdout or stderr.
The given command runs in a sub-subshell. So it has no access to $PPID, nor can it alter shell variables. You can catch a shell function, even builtins, but those will not be able to alter shell variables (as everything running within $( .. ) cannot do this). So if you need to run a function in current shell and catch it's stderr/stdout, you need to do this the usual way with tempfiles. (There are ways to do this such, that interrupting the shell normally does not leave debris behind, but this is complex and deserves it's own answer.)
Q: Bash version?
I think you need Bash 4 and above (due to printf %q)
Q: This still looks so awkward.
Right. Another answer here shows how it can be done in ksh much more cleanly. However I am not used to ksh, so I leave it to others to create a similar easy to reuse recipe for ksh.
Q: Why not use ksh then?
Because this is a bash solution
Q: The script can be improved
Of course you can squeeze out some bytes and create smaller or more incomprehensible solution. Just go for it ;)
Q: There is a typo. : catch STDOUT STDERR cmd args.. shall read # catch STDOUT STDERR cmd args..
Actually this is intended. : shows up in bash -x while comments are silently swallowed. So you can see where the parser is if you happen to have a typo in the function definition. It's an old debugging trick. But beware a bit, you can easily create some neat sideffects within the arguments of :.
Edit: Added a couple more ; to make it more easy to create a single-liner out of catch(). And added section how it works.
Technically, named pipes aren't temporary files and nobody here mentions them. They store nothing in the filesystem and you can delete them as soon as you connect them (so you won't ever see them):
#!/bin/bash -e
foo () {
echo stdout1
echo stderr1 >&2
sleep 1
echo stdout2
echo stderr2 >&2
}
rm -f stdout stderr
mkfifo stdout stderr
foo >stdout 2>stderr & # blocks until reader is connected
exec {fdout}<stdout {fderr}<stderr # unblocks `foo &`
rm stdout stderr # filesystem objects are no longer needed
stdout=$(cat <&$fdout)
stderr=$(cat <&$fderr)
echo $stdout
echo $stderr
exec {fdout}<&- {fderr}<&- # free file descriptors, optional
You can have multiple background processes this way and asynchronously collect their stdouts and stderrs at a convenient time, etc.
If you need this for one process only, you may just as well use hardcoded fd numbers like 3 and 4, instead of the {fdout}/{fderr} syntax (which finds a free fd for you).
This command sets both stdout (stdval) and stderr (errval) values in the present running shell:
eval "$( execcommand 2> >(setval errval) > >(setval stdval); )"
provided this function has been defined:
function setval { printf -v "$1" "%s" "$(cat)"; declare -p "$1"; }
Change execcommand to the captured command, be it "ls", "cp", "df", etc.
All this is based on the idea that we could convert all captured values to a text line with the help of the function setval, then setval is used to capture each value in this structure:
execcommand 2> CaptureErr > CaptureOut
Convert each capture value to a setval call:
execcommand 2> >(setval errval) > >(setval stdval)
Wrap everything inside an execute call and echo it:
echo "$( execcommand 2> >(setval errval) > >(setval stdval) )"
You will get the declare calls that each setval creates:
declare -- stdval="I'm std"
declare -- errval="I'm err"
To execute that code (and get the vars set) use eval:
eval "$( execcommand 2> >(setval errval) > >(setval stdval) )"
and finally echo the set vars:
echo "std out is : |$stdval| std err is : |$errval|
It is also possible to include the return (exit) value.
A complete bash script example looks like this:
#!/bin/bash --
# The only function to declare:
function setval { printf -v "$1" "%s" "$(cat)"; declare -p "$1"; }
# a dummy function with some example values:
function dummy { echo "I'm std"; echo "I'm err" >&2; return 34; }
# Running a command to capture all values
# change execcommand to dummy or any other command to test.
eval "$( dummy 2> >(setval errval) > >(setval stdval); <<<"$?" setval retval; )"
echo "std out is : |$stdval| std err is : |$errval| return val is : |$retval|"
Jonathan has the answer. For reference, this is the ksh93 trick. (requires a non-ancient version).
function out {
echo stdout
echo stderr >&2
}
x=${ { y=$(out); } 2>&1; }
typeset -p x y # Show the values
produces
x=stderr
y=stdout
The ${ cmds;} syntax is just a command substitution that doesn't create a subshell. The commands are executed in the current shell environment. The space at the beginning is important ({ is a reserved word).
Stderr of the inner command group is redirected to stdout (so that it applies to the inner substitution). Next, the stdout of out is assigned to y, and the redirected stderr is captured by x, without the usual loss of y to a command substitution's subshell.
It isn't possible in other shells, because all constructs which capture output require putting the producer into a subshell, which in this case, would include the assignment.
update: Now also supported by mksh.
This is a diagram showing how #madmurphy's very neat solution works.
And an indented version of the one-liner:
catch() {
{
IFS=$'\n' read -r -d '' "$out_var";
IFS=$'\n' read -r -d '' "$err_var";
(IFS=$'\n' read -r -d '' _ERRNO_; return ${_ERRNO_});
}\
< <(
(printf '\0%s\0%d\0' \
"$(
(
(
(
{ ${3}; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-
) 4>&2- 2>&1- | tr -d '\0' 1>&4-
) 3>&1- | exit "$(cat)"
) 4>&1-
)" "${?}" 1>&2
) 2>&1
)
}
Did not like the eval, so here is a solution that uses some redirection tricks to capture program output to a variable and then parses that variable to extract the different components. The -w flag sets the chunk size and influences the ordering of std-out/err messages in the intermediate format. 1 gives potentially high resolution at the cost of overhead.
#######
# runs "$#" and outputs both stdout and stderr on stdin, both in a prefixed format allowing both std in and out to be separately stored in variables later.
# limitations: Bash does not allow null to be returned from subshells, limiting the usefullness of applying this function to commands with null in the output.
# example:
# var=$(keepBoth ls . notHere)
# echo ls had the exit code "$(extractOne r "$var")"
# echo ls had the stdErr of "$(extractOne e "$var")"
# echo ls had the stdOut of "$(extractOne o "$var")"
keepBoth() {
(
prefix(){
( set -o pipefail
base64 -w 1 - | (
while read c
do echo -E "$1" "$c"
done
)
)
}
( (
"$#" | prefix o >&3
echo ${PIPESTATUS[0]} | prefix r >&3
) 2>&1 | prefix e >&1
) 3>&1
)
}
extractOne() { # extract
echo "$2" | grep "^$1" | cut --delimiter=' ' --fields=2 | base64 --decode -
}
For the benefit of the reader here is a solution using tempfiles.
The question was not to use tempfiles. However this might be due to the unwanted pollution of /tmp/ with tempfile in case the shell dies. In case of kill -9 some trap 'rm "$tmpfile1" "$tmpfile2"' 0 does not fire.
If you are in a situation where you can use tempfile, but want to never leave debris behind, here is a recipe.
Again it is called catch() (as my other answer) and has the same calling syntax:
catch stdout stderr command args..
# Wrappers to avoid polluting the current shell's environment with variables
: catch_read returncode FD variable
catch_read()
{
eval "$3=\"\`cat <&$2\`\"";
# You can use read instead to skip some fork()s.
# However read stops at the first NUL byte,
# also does no \n removal and needs bash 3 or above:
#IFS='' read -ru$2 -d '' "$3";
return $1;
}
: catch_1 tempfile variable comand args..
catch_1()
{
{
rm -f "$1";
"${#:3}" 66<&-;
catch_read $? 66 "$2";
} 2>&1 >"$1" 66<"$1";
}
: catch stdout stderr command args..
catch()
{
catch_1 "`tempfile`" "${2:-stderr}" catch_1 "`tempfile`" "${1:-stdout}" "${#:3}";
}
What it does:
It creates two tempfiles for stdout and stderr. However it nearly immediately removes these, such that they are only around for a very short time.
catch_1() catches stdout (FD 1) into a variable and moves stderr to stdout, such that the next ("left") catch_1 can catch that.
Processing in catch is done from right to left, so the left catch_1 is executed last and catches stderr.
The worst which can happen is, that some temporary files show up on /tmp/, but they are always empty in that case. (They are removed before they get filled.). Usually this should not be a problem, as under Linux tmpfs supports roughly 128K files per GB of main memory.
The given command can access and alter all local shell variables as well. So you can call a shell function which has sideffects!
This only forks twice for the tempfile call.
Bugs:
Missing good error handling in case tempfile fails.
This does the usual \n removal of the shell. See comment in catch_read().
You cannot use file descriptor 66 to pipe data to your command. If you need that, use another descriptor for the redirection, like 42 (note that very old shells only offer FDs up to 9).
This cannot handle NUL bytes ($'\0') in stdout and stderr. (NUL is just ignored. For the read variant everything behind a NUL is ignored.)
FYI:
Unix allows us to access deleted files, as long as you keep some reference to them around (such as an open filehandle). This way we can open and then remove them.
In the bash realm, #madmurphy's "7. The ultimate solution – a general purpose function with exit status" is the way to go that I've been massively using everywhere. Based on my experience I'm contributing minor updates making it really "ultimate" also in the following two scenarios:
complex command lines to have args correctly quoted and without the need of quoting the original commands which are now naturally typed as plain tokens. ( the replacement is this..."$(((({ "${#:3}" ; echo...)
our trusted friend "debug" options. xtrace and verbose work by injecting text into stderr... You can immagine for how long I was baffled by the erratic behaviour of scripts that seemed to work perfectly well just before the catch... And the problem actually was quite subtler and required to take care of xtrace and verbose options as mentioned here https://unix.stackexchange.com/a/21944
One of my use case scenarios, where you'll get why the entire quoting mechanism was a problem is the following. Also, to detect the length of a video and do something else in case of error, I needed some debug before figuring out how this fast ffprobe command fails on the given video:
catch end err ffprobe -i "${filename}" -show_entries format=duration -v warning -of csv='p=0'
This, in my experience so far, is the ultimate ultimate ;-) one, and hope may serve you as well. Credits to #madmurphy and all other contributors.
catch() {
if [ "$#" -lt 3 ]; then
echo USAGE: catch STDOUT_VAR STDERR_VAR COMMAND [CMD_ARGS...]
echo 'stdout-> ${STDOUT_VAR}' 'stderr-> ${STDERR_VAR}' 'exit-> ${?}'
echo -e "\n** NOTICE: FD redirects are used to make the magic happen."
echo " Shell's xtrace (set -x) and verbose (set -v) work by redirecting to stderr, which screws the magic up."
echo " xtrace (set -x) and verbose (set -v) modes are suspended during the execution of this function."
return 1
fi
# check "verbose" option, turn if off if enabled, and save restore status USE_V
[[ ${-/v} != $- ]] && set +v && USE_V="-v" || USE_V="+v"
# check "xtrace" option, turn if off if enabled, and save restore status USE_X
[[ ${-/x} != $- ]] && set +x && USE_X="-x" || USE_X="+x"
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
# restore the "xtrace" and "verbose" options before returning
(IFS=$'\n' read -r -d '' _ERRNO_; set $USE_X; set $USE_V; return "${_ERRNO_}");
} < <((printf '\0%s\0%d\0' "$(((({ "${#:3}" ; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
}
Succinctly, I believe the answer is 'No'. The capturing $( ... ) only captures standard output to the variable; there isn't a way to get the standard error captured into a separate variable. So, what you have is about as neat as it gets.
What about... =D
GET_STDERR=""
GET_STDOUT=""
get_stderr_stdout() {
GET_STDERR=""
GET_STDOUT=""
unset t_std t_err
eval "$( (eval $1) 2> >(t_err=$(cat); typeset -p t_err) > >(t_std=$(cat); typeset -p t_std) )"
GET_STDERR=$t_err
GET_STDOUT=$t_std
}
get_stderr_stdout "command"
echo "$GET_STDERR"
echo "$GET_STDOUT"
One workaround, which is hacky but perhaps more intuitive than some of the suggestions on this page, is to tag the output streams, merge them, and split afterwards based on the tags. For example, we might tag stdout with a "STDOUT" prefix:
function someCmd {
echo "I am stdout"
echo "I am stderr" 1>&2
}
ALL=$({ someCmd | sed -e 's/^/STDOUT/g'; } 2>&1)
OUT=$(echo "$ALL" | grep "^STDOUT" | sed -e 's/^STDOUT//g')
ERR=$(echo "$ALL" | grep -v "^STDOUT")
```
If you know that stdout and/or stderr are of a restricted form, you can come up with a tag which does not conflict with their allowed content.
WARNING: NOT (yet?) WORKING!
The following seems a possible lead to get it working without creating any temp files and also on POSIX sh only; it requires base64 however and due to the encoding/decoding may not be that efficient and use also "larger" memory.
Even in the simple case, it would already fail, when the last stderr line has no newline. This can be fixed at least in some cases with replacing exe with "{ exe ; echo >&2 ; }", i.e. adding a newline.
The main problem is however that everything seems racy. Try using an exe like:
exe()
{
cat /usr/share/hunspell/de_DE.dic
cat /usr/share/hunspell/en_GB.dic >&2
}
and you'll see that e.g. parts of the base64 encoded line is on the top of the file, parts at the end, and the non-decoded stderr stuff in the middle.
Well, even if the idea below cannot be made working (which I assume), it may serve as an anti-example for people who may falsely believe it could be made working like this.
Idea (or anti-example):
#!/bin/sh
exe()
{
echo out1
echo err1 >&2
echo out2
echo out3
echo err2 >&2
echo out4
echo err3 >&2
echo -n err4 >&2
}
r="$( { exe | base64 -w 0 ; } 2>&1 )"
echo RAW
printf '%s' "$r"
echo RAW
o="$( printf '%s' "$r" | tail -n 1 | base64 -d )"
e="$( printf '%s' "$r" | head -n -1 )"
unset r
echo
echo OUT
printf '%s' "$o"
echo OUT
echo
echo ERR
printf '%s' "$e"
echo ERR
gives (with the stderr-newline fix):
$ ./ggg
RAW
err1
err2
err3
err4
b3V0MQpvdXQyCm91dDMKb3V0NAo=RAW
OUT
out1
out2
out3
out4OUT
ERR
err1
err2
err3
err4ERR
(At least on Debian's dash and bash)
Here is an variant of #madmurphy solution that should work for arbitrarily large stdout/stderr streams, maintain the exit return value, and handle nulls in the stream (by converting them to newlines)
function buffer_plus_null()
{
local buf
IFS= read -r -d '' buf || :
echo -n "${buf}"
printf '\0'
}
{
IFS= time read -r -d '' CAPTURED_STDOUT;
IFS= time read -r -d '' CAPTURED_STDERR;
(IFS= read -r -d '' CAPTURED_EXIT; exit "${CAPTURED_EXIT}");
} < <((({ { some_command ; echo "${?}" 1>&3; } | tr '\0' '\n' | buffer_plus_null; } 2>&1 1>&4 | tr '\0' '\n' | buffer_plus_null 1>&4 ) 3>&1 | xargs printf '%s\0' 1>&4) 4>&1 )
Cons:
The read commands are the most expensive part of the operation. For example: find /proc on a computer running 500 processes, takes 20 seconds (while the command was only 0.5 seconds). It takes 10 seconds to read in the first time, and 10 seconds more to read the second time, doubling the total time.
Explanation of buffer
The original solution was to an argument to printf to buffer the stream, however with the need to have the exit code come last, one solution is to buffer both stdout and stderr. I tried xargs -0 printf but then you quickly started hitting "max argument length limits". So I decided a solution was to write a quick buffer function:
Use read to store the stream in a variable
This read will terminate when the stream ends, or a null is received. Since we already removed the nulls, it ends when the stream is closed, and returns non-zero. Since this is expected behavior we add || : meaning "or true" so that the line always evaluates to true (0)
Now that I know the stream has ended, it's safe to start echoing it back out.
echo -n "${buf}" is a builtin command and thus not limited to the argument length limit
Lastly, add a null separator to the end.
This prefixes error messages (similar to the answer of #Warbo) and by that we are able to distinguish between stdout and stderr:
out=$(some_command 2> >(sed -e 's/^/stderr/g'))
err=$(echo "$out" | grep -oP "(?<=^stderr).*")
out=$(echo "$out" | grep -v '^stderr')
The (?<=string) part is called a positive lookbehind which excludes the string from the result.
How I use it
# cat ./script.sh
#!/bin/bash
# check script arguments
args=$(getopt -u -l "foo,bar" "fb" "$#" 2> >(sed -e 's/^/stderr/g') )
[[ $? -ne 0 ]] && echo -n "Error: " && echo "$args" | grep -oP "(?<=^stderr).*" && exit 1
mapfile -t args < <(xargs -n1 <<< "$args")
#
# ./script.sh --foo --bar --baz
# Error: getopt: unrecognized option '--baz'
Notes:
As you can see I don't need to filter for stdout as the condition already catched the error and stopped the script. So if the script does not stop, $args does not contain any prefixed content.
An alternative to sed -e 's/^/stderr/g' is xargs -d '\n' -I {} echo "stderr{}".
Variant to prefix stdout AND stderr
# smbclient localhost 1> >(sed -e 's/^/std/g') 2> >(sed -e 's/^/err/g')
std
stdlocalhost: Not enough '\' characters in service
stderrUsage: smbclient [-?EgBVNkPeC] [-?|--help] [--usage]
stderr [-R|--name-resolve=NAME-RESOLVE-ORDER] [-M|--message=HOST]
stderr [-I|--ip-address=IP] [-E|--stderr] [-L|--list=HOST]
stderr [-m|--max-protocol=LEVEL] [-T|--tar=<c|x>IXFqgbNan]
stderr [-D|--directory=DIR] [-c|--command=STRING] [-b|--send-buffer=BYTES]
stderr [-t|--timeout=SECONDS] [-p|--port=PORT] [-g|--grepable]
stderr [-B|--browse] [-d|--debuglevel=DEBUGLEVEL]
stderr [-s|--configfile=CONFIGFILE] [-l|--log-basename=LOGFILEBASE]
stderr [-V|--version] [--option=name=value]
stderr [-O|--socket-options=SOCKETOPTIONS] [-n|--netbiosname=NETBIOSNAME]
stderr [-W|--workgroup=WORKGROUP] [-i|--scope=SCOPE] [-U|--user=USERNAME]
stderr [-N|--no-pass] [-k|--kerberos] [-A|--authentication-file=FILE]
stderr [-S|--signing=on|off|required] [-P|--machine-pass] [-e|--encrypt]
stderr [-C|--use-ccache] [--pw-nt-hash] service <password>
This is an addendum to Jacques Gaudin's addendum to madmurphy's answer.
Unlike the source, this uses eval to execute multi-line command (multi-argument is ok as well thanks to "${#}").
Another caveat is this function will return 0 in any case, and output exit code to a third variable instead. IMO this is more apt for catch.
#!/bin/bash
# Overwrites existing values of provided variables in any case.
# SYNTAX:
# catch STDOUT_VAR_NAME STDERR_VAR_NAME EXIT_CODE_VAR_NAME COMMAND1 [COMMAND2 [...]]
function catch() {
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
IFS=$'\n' read -r -d '' "${3}";
return 0;
}\
< <(
(printf '\0%s\0%d\0' \
"$(
(
(
(
{
shift 3;
eval "${#}";
echo "${?}" 1>&3-;
} | tr -d '\0' 1>&4-
) 4>&2- 2>&1- | tr -d '\0' 1>&4-
) 3>&1- | exit "$(cat)"
) 4>&1-
)" "${?}" 1>&2
) 2>&1
)
}
# Simulation of here-doc
MULTILINE_SCRIPT_1='cat << EOF
foo
bar
with newlines
EOF
'
# Simulation of multiple streams
# Notice the lack of semi-colons, otherwise below code
# could become a one-liner and still work
MULTILINE_SCRIPT_2='echo stdout stream
echo error stream 1>&2
'
catch out err code "${MULTILINE_SCRIPT_1}" \
'printf "wait there is more\n" 1>&2'
printf "1)\n\tSTDOUT: ${out}\n\tSTDERR: ${err}\n\tCODE: ${code}\n"
echo ''
catch out err code "${MULTILINE_SCRIPT_2}" echo this multi-argument \
form works too '1>&2' \; \(exit 5\)
printf "2)\n\tSTDOUT: ${out}\n\tSTDERR: ${err}\n\tCODE: ${code}\n"
Output:
1)
STDOUT: foo
bar
with newlines
STDERR: wait there is more
CODE: 0
2)
STDOUT: stdout stream
STDERR: error stream
this multi-argument form works too
CODE: 5
If the command 1) no stateful side effects and 2) is computationally cheap, the easiest solution is to just run it twice. I've mainly used this for code that runs during the boot sequence when you don't yet know if the disk is going to be working. In my case it was a tiny some_command so there was no performance hit for running twice, and the command had no side effects.
The main benefit is that this is clean and easy to read. The solutions here are quite clever, but I would hate to be the one that has to maintain a script containing the more complicated solutions. I'd recommend the simple run-it-twice approach if your scenario works with that, as it's much cleaner and easier to maintain.
Example:
output=$(getopt -o '' -l test: -- "$#")
errout=$(getopt -o '' -l test: -- "$#" 2>&1 >/dev/null)
if [[ -n "$errout" ]]; then
echo "Option Error: $errout"
fi
Again, this is only ok to do because getopt has no side effects. I know it's performance-safe because my parent code calls this less than 100 times during the entire program, and the user will never notice 100 getopt calls vs 200 getopt calls.
Here's a simpler variation that isn't quite what the OP wanted, but is unlike any of the other options. You can get whatever you want by rearranging the file descriptors.
Test command:
%> cat xx.sh
#!/bin/bash
echo stdout
>&2 echo stderr
which by itself does:
%> ./xx.sh
stdout
stderr
Now, print stdout, capture stderr to a variable, & log stdout to a file
%> export err=$(./xx.sh 3>&1 1>&2 2>&3 >"out")
stdout
%> cat out
stdout
%> echo
$err
stderr
Or log stdout & capture stderr to a variable:
export err=$(./xx.sh 3>&1 1>out 2>&3 )
%> cat out
stdout
%> echo $err
stderr
You get the idea.
Realtime output and write to file:
#!/usr/bin/env bash
# File where store the output
log_file=/tmp/out.log
# Empty file
echo > ${log_file}
outToLog() {
# File where write (first parameter)
local f="$1"
# Start file output watcher in background
tail -f "${f}" &
# Capture background process PID
local pid=$!
# Write "stdin" to file
cat /dev/stdin >> "${f}"
# Kill background task
kill -9 ${pid}
}
(
# Long execution script example
echo a
sleep 1
echo b >&2
sleep 1
echo c >&2
sleep 1
echo d
) 2>&1 | outToLog "${log_file}"
# File result
echo '==========='
cat "${log_file}"
I've posted my solution to this problem here. It does use process substitution and requires Bash > v4 but also captures stdout, stderr and return code into variables you name in the current scope:
https://gist.github.com/pmarreck/5eacc6482bc19b55b7c2f48b4f1db4e8
The whole point of this exercise was so that I could assert on these things in a test suite. The fact that I just spent all afternoon figuring out this simple-sounding thing... I hope one of these solutions helps others!
Is it possible to store or capture stdout and stderr in different variables, without using a temp file? Right now I do this to get stdout in out and stderr in err when running some_command, but I'd
like to avoid the temp file.
error_file=$(mktemp)
out=$(some_command 2>$error_file)
err=$(< $error_file)
rm $error_file
Ok, it got a bit ugly, but here is a solution:
unset t_std t_err
eval "$( (echo std; echo err >&2) \
2> >(readarray -t t_err; typeset -p t_err) \
> >(readarray -t t_std; typeset -p t_std) )"
where (echo std; echo err >&2) needs to be replaced by the actual command. Output of stdout is saved into the array $t_std line by line omitting the newlines (the -t) and stderr into $t_err.
If you don't like arrays you can do
unset t_std t_err
eval "$( (echo std; echo err >&2 ) \
2> >(t_err=$(cat); typeset -p t_err) \
> >(t_std=$(cat); typeset -p t_std) )"
which pretty much mimics the behavior of var=$(cmd) except for the value of $? which takes us to the last modification:
unset t_std t_err t_ret
eval "$( (echo std; echo err >&2; exit 2 ) \
2> >(t_err=$(cat); typeset -p t_err) \
> >(t_std=$(cat); typeset -p t_std); t_ret=$?; typeset -p t_ret )"
Here $? is preserved into $t_ret
Tested on Debian wheezy using GNU bash, Version 4.2.37(1)-release (i486-pc-linux-gnu).
I think before saying “you can't” do something, people should at least give it a try with their own hands…
Simple and clean solution, without using eval or anything exotic
1. A minimal version
{
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
} < <((printf '\0%s\0' "$(some_command)" 1>&2) 2>&1)
Requires: printf, read
2. A simple test
A dummy script for producing stdout and stderr: useless.sh
#!/bin/bash
#
# useless.sh
#
echo "This is stderr" 1>&2
echo "This is stdout"
The actual script that will capture stdout and stderr: capture.sh
#!/bin/bash
#
# capture.sh
#
{
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
} < <((printf '\0%s\0' "$(./useless.sh)" 1>&2) 2>&1)
echo 'Here is the captured stdout:'
echo "${CAPTURED_STDOUT}"
echo
echo 'And here is the captured stderr:'
echo "${CAPTURED_STDERR}"
echo
Output of capture.sh
Here is the captured stdout:
This is stdout
And here is the captured stderr:
This is stderr
3. How it works
The command
(printf '\0%s\0' "$(some_command)" 1>&2) 2>&1
sends the standard output of some_command to printf '\0%s\0', thus creating the string \0${stdout}\n\0 (where \0 is a NUL byte and \n is a new line character); the string \0${stdout}\n\0 is then redirected to the standard error, where the standard error of some_command was already present, thus composing the string ${stderr}\n\0${stdout}\n\0, which is then redirected back to the standard output.
Afterwards, the command
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
starts reading the string ${stderr}\n\0${stdout}\n\0 up until the first NUL byte and saves the content into ${CAPTURED_STDERR}. Then the command
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
keeps reading the same string up to the next NUL byte and saves the content into ${CAPTURED_STDOUT}.
4. Making it unbreakable
The solution above relies on a NUL byte for the delimiter between stderr and stdout, therefore it will not work if for any reason stderr contains other NUL bytes.
Although that will rarely happen, it is possible to make the script completely unbreakable by stripping all possible NUL bytes from stdout and stderr before passing both outputs to read (sanitization) – NUL bytes would anyway get lost, as it is not possible to store them into shell variables:
{
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
} < <((printf '\0%s\0' "$((some_command | tr -d '\0') 3>&1- 1>&2- 2>&3- | tr -d '\0')" 1>&2) 2>&1)
Requires: printf, read, tr
5. Preserving the exit status – the blueprint (without sanitization)
After thinking a bit about the ultimate approach, I have come out with a solution that uses printf to cache both stdout and the exit code as two different arguments, so that they never interfere.
The first thing I did was outlining a way to communicate the exit status to the third argument of printf, and this was something very easy to do in its simplest form (i.e. without sanitization).
{
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
(IFS=$'\n' read -r -d '' _ERRNO_; exit ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(some_command)" "${?}" 1>&2) 2>&1)
Requires: exit, printf, read
6. Preserving the exit status with sanitization – unbreakable (rewritten)
Things get very messy though when we try to introduce sanitization. Launching tr for sanitizing the streams does in fact overwrite our previous exit status, so apparently the only solution is to redirect the latter to a separate descriptor before it gets lost, keep it there until tr does its job twice, and then redirect it back to its place.
After some quite acrobatic redirections between file descriptors, this is what I came out with.
The code below is a rewriting of the example that I have removed. It also sanitizes possible NUL bytes in the streams, so that read can always work properly.
{
IFS=$'\n' read -r -d '' CAPTURED_STDOUT;
IFS=$'\n' read -r -d '' CAPTURED_STDERR;
(IFS=$'\n' read -r -d '' _ERRNO_; exit ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(((({ some_command; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
Requires: exit, printf, read, tr
This solution is really robust. The exit code is always kept separated in a different descriptor until it reaches printf directly as a separate argument.
7. The ultimate solution – a general purpose function with exit status
We can also transform the code above to a general purpose function.
# SYNTAX:
# catch STDOUT_VARIABLE STDERR_VARIABLE COMMAND [ARG1[ ARG2[ ...[ ARGN]]]]
catch() {
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
(IFS=$'\n' read -r -d '' _ERRNO_; return ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(((({ shift 2; "${#}"; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
}
Requires: cat, exit, printf, read, shift, tr
ChangeLog: 2022-06-17 // Replaced ${3} with shift 2; ${#} after Pavel Tankov's comment (Bash-only). 2023-01-18 // Replaced ${#} with "${#}" after cbugk's comment.
With the catch function we can launch the following snippet,
catch MY_STDOUT MY_STDERR './useless.sh'
echo "The \`./useless.sh\` program exited with code ${?}"
echo
echo 'Here is the captured stdout:'
echo "${MY_STDOUT}"
echo
echo 'And here is the captured stderr:'
echo "${MY_STDERR}"
echo
and get the following result:
The `./useless.sh` program exited with code 0
Here is the captured stdout:
This is stderr 1
This is stderr 2
And here is the captured stderr:
This is stdout 1
This is stdout 2
8. What happens in the last examples
Here follows a fast schematization:
some_command is launched: we then have some_command's stdout on the descriptor 1, some_command's stderr on the descriptor 2 and some_command's exit code redirected to the descriptor 3
stdout is piped to tr (sanitization)
stderr is swapped with stdout (using temporarily the descriptor 4) and piped to tr (sanitization)
the exit code (descriptor 3) is swapped with stderr (now descriptor 1) and piped to exit $(cat)
stderr (now descriptor 3) is redirected to the descriptor 1, end expanded as the second argument of printf
the exit code of exit $(cat) is captured by the third argument of printf
the output of printf is redirected to the descriptor 2, where stdout was already present
the concatenation of stdout and the output of printf is piped to read
9. The POSIX-compliant version #1 (breakable)
Process substitutions (the < <() syntax) are not POSIX-standard (although they de facto are). In a shell that does not support the < <() syntax the only way to reach the same result is via the <<EOF … EOF syntax. Unfortunately this does not allow us to use NUL bytes as delimiters, because these get automatically stripped out before reaching read. We must use a different delimiter. The natural choice falls onto the CTRL+Z character (ASCII character no. 26). Here is a breakable version (outputs must never contain the CTRL+Z character, or otherwise they will get mixed).
_CTRL_Z_=$'\cZ'
{
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" CAPTURED_STDERR;
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" CAPTURED_STDOUT;
(IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" _ERRNO_; exit ${_ERRNO_});
} <<EOF
$((printf "${_CTRL_Z_}%s${_CTRL_Z_}%d${_CTRL_Z_}" "$(some_command)" "${?}" 1>&2) 2>&1)
EOF
Requires: exit, printf, read
Note: As shift is Bash-only, in this POSIX-compliant version command + arguments must appear under the same quotes.
10. The POSIX-compliant version #2 (unbreakable, but not as good as the non-POSIX one)
And here is its unbreakable version, directly in function form (if either stdout or stderr contain CTRL+Z characters, the stream will be truncated, but will never be exchanged with another descriptor).
_CTRL_Z_=$'\cZ'
# SYNTAX:
# catch_posix STDOUT_VARIABLE STDERR_VARIABLE COMMAND
catch_posix() {
{
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" "${1}";
IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" "${2}";
(IFS=$'\n'"${_CTRL_Z_}" read -r -d "${_CTRL_Z_}" _ERRNO_; return ${_ERRNO_});
} <<EOF
$((printf "${_CTRL_Z_}%s${_CTRL_Z_}%d${_CTRL_Z_}" "$(((({ ${3}; echo "${?}" 1>&3-; } | cut -z -d"${_CTRL_Z_}" -f1 | tr -d '\0' 1>&4-) 4>&2- 2>&1- | cut -z -d"${_CTRL_Z_}" -f1 | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
EOF
}
Requires: cat, cut, exit, printf, read, tr
Answer's history
Here is a previous version of catch() before Pavel Tankov's comment (this version requires the additional arguments to be quoted together with the command):
# SYNTAX:
# catch STDOUT_VARIABLE STDERR_VARIABLE COMMAND [ARG1[ ARG2[ ...[ ARGN]]]]
catch() {
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
(IFS=$'\n' read -r -d '' _ERRNO_; return ${_ERRNO_});
} < <((printf '\0%s\0%d\0' "$(((({ shift 2; ${#}; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
}
Requires: cat, exit, printf, read, tr
Furthermore, I replaced an old example for propagating the exit status to the current shell, because, as Andy had pointed out in the comments, it was not as “unbreakable” as it was supposed to be (since it did not use printf to buffer one of the streams). For the record I paste the problematic code here:
Preserving the exit status (still unbreakable)
The following variant propagates also the exit status of some_command to the current shell:
{
IFS= read -r -d '' CAPTURED_STDOUT;
IFS= read -r -d '' CAPTURED_STDERR;
(IFS= read -r -d '' CAPTURED_EXIT; exit "${CAPTURED_EXIT}");
} < <((({ { some_command ; echo "${?}" 1>&3; } | tr -d '\0'; printf '\0'; } 2>&1- 1>&4- | tr -d '\0' 1>&4-) 3>&1- | xargs printf '\0%s\0' 1>&4-) 4>&1-)
Requires: printf, read, tr, xargs
Later, Andy submitted the following “suggested edit” for capturing the exit code:
Simple and clean solution saving the exit value
We can add to the end of stderr, a third piece of information, another NUL plus the exit status of the command. It will be outputted after stderr but before stdout
{
IFS= read -r -d '' CAPTURED_STDERR;
IFS= read -r -d '' CAPTURED_EXIT;
IFS= read -r -d '' CAPTURED_STDOUT;
} < <((printf '\0%s\n\0' "$(some_command; printf '\0%d' "${?}" 1>&2)" 1>&2) 2>&1)
His solution seemed to work, but had the minor problem that the exit status needed to be placed as the last fragment of the string, so that we are able to launch exit "${CAPTURED_EXIT}" within round brackets and not pollute the global scope, as I had tried to do in the removed example. The other problem was that, as the output of his innermost printf got immediately appended to the stderr of some_command, we could no more sanitize possible NUL bytes in stderr, because among these now there was also our NUL delimiter.
Trying to find the right solution to this problem was what led me to write § 5. Preserving the exit status – the blueprint (without sanitization), and the following sections.
This is for catching stdout and stderr in different variables. If you only want to catch stderr, leaving stdout as-is, there is a better and shorter solution.
To sum everything up for the benefit of the reader, here is an
Easy Reusable bash Solution
This version does use subshells and runs without tempfiles. (For a tempfile version which runs without subshells, see my other answer.)
: catch STDOUT STDERR cmd args..
catch()
{
eval "$({
__2="$(
{ __1="$("${#:3}")"; } 2>&1;
ret=$?;
printf '%q=%q\n' "$1" "$__1" >&2;
exit $ret
)";
ret="$?";
printf '%s=%q\n' "$2" "$__2" >&2;
printf '( exit %q )' "$ret" >&2;
} 2>&1 )";
}
Example use:
dummy()
{
echo "$3" >&2
echo "$2" >&1
return "$1"
}
catch stdout stderr dummy 3 $'\ndiffcult\n data \n\n\n' $'\nother\n difficult \n data \n\n'
printf 'ret=%q\n' "$?"
printf 'stdout=%q\n' "$stdout"
printf 'stderr=%q\n' "$stderr"
this prints
ret=3
stdout=$'\ndiffcult\n data '
stderr=$'\nother\n difficult \n data '
So it can be used without deeper thinking about it. Just put catch VAR1 VAR2 in front of any command args.. and you are done.
Some if cmd args..; then will become if catch VAR1 VAR2 cmd args..; then. Really nothing complex.
Addendum: Use in "strict mode"
catch works for me identically in strict mode. The only caveat is, that the example above returns error code 3, which, in strict mode, calls the ERR trap. Hence if you run some command under set -e which is expected to return arbitrary error codes (not only 0), you need to catch the return code into some variable like && ret=$? || ret=$? as shown below:
dummy()
{
echo "$3" >&2
echo "$2" >&1
return "$1"
}
catch stdout stderr dummy 3 $'\ndifficult\n data \n\n\n' $'\nother\n difficult \n data \n\n' && ret=$? || ret=$?
printf 'ret=%q\n' "$ret"
printf 'stdout=%q\n' "$stdout"
printf 'stderr=%q\n' "$stderr"
Discussion
Q: How does it work?
It just wraps ideas from the other answers here into a function, such that it can easily be resused.
catch() basically uses eval to set the two variables. This is similar to https://stackoverflow.com/a/18086548
Consider a call of catch out err dummy 1 2a 3b:
let's skip the eval "$({ and the __2="$( for now. I will come to this later.
__1="$("$("${#:3}")"; } 2>&1; executes dummy 1 2a 3b and stores its stdout into __1 for later use. So __1 becomes 2a. It also redirects stderr of dummy to stdout, such that the outer catch can gather stdout
ret=$?; catches the exit code, which is 1
printf '%q=%q\n' "$1" "$__1" >&2; then outputs out=2a to stderr. stderr is used here, as the current stdout already has taken over the role of stderr of the dummy command.
exit $ret then forwards the exit code (1) to the next stage.
Now to the outer __2="$( ... )":
This catches stdout of the above, which is the stderr of the dummy call, into variable __2. (We could re-use __1 here, but I used __2 to make it less confusing.). So __2 becomes 3b
ret="$?"; catches the (returned) return code 1 (from dummy) again
printf '%s=%q\n' "$2" "$__2" >&2; then outputs err=3a to stderr. stderr is used again, as it already was used to output the other variable out=2a.
printf '( exit %q )' "$ret" >&2; then outputs the code to set the proper return value. I did not find a better way, as assigning it to a variable needs a variable name, which then cannot be used as first or second argument to catch.
Please note that, as an optimization, we could have written those 2 printf as a single one like printf '%s=%q\n( exit %q ) "$__2" "$ret"` as well.
So what do we have so far?
We have following written to stderr:
out=2a
err=3b
( exit 1 )
where out is from $1, 2a is from stdout of dummy, err is from $2, 3b is from stderr of dummy, and the 1 is from the return code from dummy.
Please note that %q in the format of printf takes care for quoting, such that the shell sees proper (single) arguments when it comes to eval. 2a and 3b are so simple, that they are copied literally.
Now to the outer eval "$({ ... } 2>&1 )";:
This executes all of above which output the 2 variables and the exit, catches it (therefor the 2>&1) and parses it into the current shell using eval.
This way the 2 variables get set and the return code as well.
Q: It uses eval which is evil. So is it safe?
As long as printf %q has no bugs, it should be safe. But you always have to be very careful, just think about ShellShock.
Q: Bugs?
No obvious bugs are known, except following:
Catching big output needs big memory and CPU, as everything goes into variables and needs to be back-parsed by the shell. So use it wisely.
As usual $(echo $'\n\n\n\n') swallows all linefeeds, not only the last one. This is a POSIX requirement. If you need to get the LFs unharmed, just add some trailing character to the output and remove it afterwards like in following recipe (look at the trailing x which allows to read a softlink pointing to a file which ends on a $'\n'):
target="$(readlink -e "$file")x"
target="${target%x}"
Shell-variables cannot carry the byte NUL ($'\0'). They are simply ignores if they happen to occur in stdout or stderr.
The given command runs in a sub-subshell. So it has no access to $PPID, nor can it alter shell variables. You can catch a shell function, even builtins, but those will not be able to alter shell variables (as everything running within $( .. ) cannot do this). So if you need to run a function in current shell and catch it's stderr/stdout, you need to do this the usual way with tempfiles. (There are ways to do this such, that interrupting the shell normally does not leave debris behind, but this is complex and deserves it's own answer.)
Q: Bash version?
I think you need Bash 4 and above (due to printf %q)
Q: This still looks so awkward.
Right. Another answer here shows how it can be done in ksh much more cleanly. However I am not used to ksh, so I leave it to others to create a similar easy to reuse recipe for ksh.
Q: Why not use ksh then?
Because this is a bash solution
Q: The script can be improved
Of course you can squeeze out some bytes and create smaller or more incomprehensible solution. Just go for it ;)
Q: There is a typo. : catch STDOUT STDERR cmd args.. shall read # catch STDOUT STDERR cmd args..
Actually this is intended. : shows up in bash -x while comments are silently swallowed. So you can see where the parser is if you happen to have a typo in the function definition. It's an old debugging trick. But beware a bit, you can easily create some neat sideffects within the arguments of :.
Edit: Added a couple more ; to make it more easy to create a single-liner out of catch(). And added section how it works.
Technically, named pipes aren't temporary files and nobody here mentions them. They store nothing in the filesystem and you can delete them as soon as you connect them (so you won't ever see them):
#!/bin/bash -e
foo () {
echo stdout1
echo stderr1 >&2
sleep 1
echo stdout2
echo stderr2 >&2
}
rm -f stdout stderr
mkfifo stdout stderr
foo >stdout 2>stderr & # blocks until reader is connected
exec {fdout}<stdout {fderr}<stderr # unblocks `foo &`
rm stdout stderr # filesystem objects are no longer needed
stdout=$(cat <&$fdout)
stderr=$(cat <&$fderr)
echo $stdout
echo $stderr
exec {fdout}<&- {fderr}<&- # free file descriptors, optional
You can have multiple background processes this way and asynchronously collect their stdouts and stderrs at a convenient time, etc.
If you need this for one process only, you may just as well use hardcoded fd numbers like 3 and 4, instead of the {fdout}/{fderr} syntax (which finds a free fd for you).
This command sets both stdout (stdval) and stderr (errval) values in the present running shell:
eval "$( execcommand 2> >(setval errval) > >(setval stdval); )"
provided this function has been defined:
function setval { printf -v "$1" "%s" "$(cat)"; declare -p "$1"; }
Change execcommand to the captured command, be it "ls", "cp", "df", etc.
All this is based on the idea that we could convert all captured values to a text line with the help of the function setval, then setval is used to capture each value in this structure:
execcommand 2> CaptureErr > CaptureOut
Convert each capture value to a setval call:
execcommand 2> >(setval errval) > >(setval stdval)
Wrap everything inside an execute call and echo it:
echo "$( execcommand 2> >(setval errval) > >(setval stdval) )"
You will get the declare calls that each setval creates:
declare -- stdval="I'm std"
declare -- errval="I'm err"
To execute that code (and get the vars set) use eval:
eval "$( execcommand 2> >(setval errval) > >(setval stdval) )"
and finally echo the set vars:
echo "std out is : |$stdval| std err is : |$errval|
It is also possible to include the return (exit) value.
A complete bash script example looks like this:
#!/bin/bash --
# The only function to declare:
function setval { printf -v "$1" "%s" "$(cat)"; declare -p "$1"; }
# a dummy function with some example values:
function dummy { echo "I'm std"; echo "I'm err" >&2; return 34; }
# Running a command to capture all values
# change execcommand to dummy or any other command to test.
eval "$( dummy 2> >(setval errval) > >(setval stdval); <<<"$?" setval retval; )"
echo "std out is : |$stdval| std err is : |$errval| return val is : |$retval|"
Jonathan has the answer. For reference, this is the ksh93 trick. (requires a non-ancient version).
function out {
echo stdout
echo stderr >&2
}
x=${ { y=$(out); } 2>&1; }
typeset -p x y # Show the values
produces
x=stderr
y=stdout
The ${ cmds;} syntax is just a command substitution that doesn't create a subshell. The commands are executed in the current shell environment. The space at the beginning is important ({ is a reserved word).
Stderr of the inner command group is redirected to stdout (so that it applies to the inner substitution). Next, the stdout of out is assigned to y, and the redirected stderr is captured by x, without the usual loss of y to a command substitution's subshell.
It isn't possible in other shells, because all constructs which capture output require putting the producer into a subshell, which in this case, would include the assignment.
update: Now also supported by mksh.
This is a diagram showing how #madmurphy's very neat solution works.
And an indented version of the one-liner:
catch() {
{
IFS=$'\n' read -r -d '' "$out_var";
IFS=$'\n' read -r -d '' "$err_var";
(IFS=$'\n' read -r -d '' _ERRNO_; return ${_ERRNO_});
}\
< <(
(printf '\0%s\0%d\0' \
"$(
(
(
(
{ ${3}; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-
) 4>&2- 2>&1- | tr -d '\0' 1>&4-
) 3>&1- | exit "$(cat)"
) 4>&1-
)" "${?}" 1>&2
) 2>&1
)
}
Did not like the eval, so here is a solution that uses some redirection tricks to capture program output to a variable and then parses that variable to extract the different components. The -w flag sets the chunk size and influences the ordering of std-out/err messages in the intermediate format. 1 gives potentially high resolution at the cost of overhead.
#######
# runs "$#" and outputs both stdout and stderr on stdin, both in a prefixed format allowing both std in and out to be separately stored in variables later.
# limitations: Bash does not allow null to be returned from subshells, limiting the usefullness of applying this function to commands with null in the output.
# example:
# var=$(keepBoth ls . notHere)
# echo ls had the exit code "$(extractOne r "$var")"
# echo ls had the stdErr of "$(extractOne e "$var")"
# echo ls had the stdOut of "$(extractOne o "$var")"
keepBoth() {
(
prefix(){
( set -o pipefail
base64 -w 1 - | (
while read c
do echo -E "$1" "$c"
done
)
)
}
( (
"$#" | prefix o >&3
echo ${PIPESTATUS[0]} | prefix r >&3
) 2>&1 | prefix e >&1
) 3>&1
)
}
extractOne() { # extract
echo "$2" | grep "^$1" | cut --delimiter=' ' --fields=2 | base64 --decode -
}
For the benefit of the reader here is a solution using tempfiles.
The question was not to use tempfiles. However this might be due to the unwanted pollution of /tmp/ with tempfile in case the shell dies. In case of kill -9 some trap 'rm "$tmpfile1" "$tmpfile2"' 0 does not fire.
If you are in a situation where you can use tempfile, but want to never leave debris behind, here is a recipe.
Again it is called catch() (as my other answer) and has the same calling syntax:
catch stdout stderr command args..
# Wrappers to avoid polluting the current shell's environment with variables
: catch_read returncode FD variable
catch_read()
{
eval "$3=\"\`cat <&$2\`\"";
# You can use read instead to skip some fork()s.
# However read stops at the first NUL byte,
# also does no \n removal and needs bash 3 or above:
#IFS='' read -ru$2 -d '' "$3";
return $1;
}
: catch_1 tempfile variable comand args..
catch_1()
{
{
rm -f "$1";
"${#:3}" 66<&-;
catch_read $? 66 "$2";
} 2>&1 >"$1" 66<"$1";
}
: catch stdout stderr command args..
catch()
{
catch_1 "`tempfile`" "${2:-stderr}" catch_1 "`tempfile`" "${1:-stdout}" "${#:3}";
}
What it does:
It creates two tempfiles for stdout and stderr. However it nearly immediately removes these, such that they are only around for a very short time.
catch_1() catches stdout (FD 1) into a variable and moves stderr to stdout, such that the next ("left") catch_1 can catch that.
Processing in catch is done from right to left, so the left catch_1 is executed last and catches stderr.
The worst which can happen is, that some temporary files show up on /tmp/, but they are always empty in that case. (They are removed before they get filled.). Usually this should not be a problem, as under Linux tmpfs supports roughly 128K files per GB of main memory.
The given command can access and alter all local shell variables as well. So you can call a shell function which has sideffects!
This only forks twice for the tempfile call.
Bugs:
Missing good error handling in case tempfile fails.
This does the usual \n removal of the shell. See comment in catch_read().
You cannot use file descriptor 66 to pipe data to your command. If you need that, use another descriptor for the redirection, like 42 (note that very old shells only offer FDs up to 9).
This cannot handle NUL bytes ($'\0') in stdout and stderr. (NUL is just ignored. For the read variant everything behind a NUL is ignored.)
FYI:
Unix allows us to access deleted files, as long as you keep some reference to them around (such as an open filehandle). This way we can open and then remove them.
In the bash realm, #madmurphy's "7. The ultimate solution – a general purpose function with exit status" is the way to go that I've been massively using everywhere. Based on my experience I'm contributing minor updates making it really "ultimate" also in the following two scenarios:
complex command lines to have args correctly quoted and without the need of quoting the original commands which are now naturally typed as plain tokens. ( the replacement is this..."$(((({ "${#:3}" ; echo...)
our trusted friend "debug" options. xtrace and verbose work by injecting text into stderr... You can immagine for how long I was baffled by the erratic behaviour of scripts that seemed to work perfectly well just before the catch... And the problem actually was quite subtler and required to take care of xtrace and verbose options as mentioned here https://unix.stackexchange.com/a/21944
One of my use case scenarios, where you'll get why the entire quoting mechanism was a problem is the following. Also, to detect the length of a video and do something else in case of error, I needed some debug before figuring out how this fast ffprobe command fails on the given video:
catch end err ffprobe -i "${filename}" -show_entries format=duration -v warning -of csv='p=0'
This, in my experience so far, is the ultimate ultimate ;-) one, and hope may serve you as well. Credits to #madmurphy and all other contributors.
catch() {
if [ "$#" -lt 3 ]; then
echo USAGE: catch STDOUT_VAR STDERR_VAR COMMAND [CMD_ARGS...]
echo 'stdout-> ${STDOUT_VAR}' 'stderr-> ${STDERR_VAR}' 'exit-> ${?}'
echo -e "\n** NOTICE: FD redirects are used to make the magic happen."
echo " Shell's xtrace (set -x) and verbose (set -v) work by redirecting to stderr, which screws the magic up."
echo " xtrace (set -x) and verbose (set -v) modes are suspended during the execution of this function."
return 1
fi
# check "verbose" option, turn if off if enabled, and save restore status USE_V
[[ ${-/v} != $- ]] && set +v && USE_V="-v" || USE_V="+v"
# check "xtrace" option, turn if off if enabled, and save restore status USE_X
[[ ${-/x} != $- ]] && set +x && USE_X="-x" || USE_X="+x"
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
# restore the "xtrace" and "verbose" options before returning
(IFS=$'\n' read -r -d '' _ERRNO_; set $USE_X; set $USE_V; return "${_ERRNO_}");
} < <((printf '\0%s\0%d\0' "$(((({ "${#:3}" ; echo "${?}" 1>&3-; } | tr -d '\0' 1>&4-) 4>&2- 2>&1- | tr -d '\0' 1>&4-) 3>&1- | exit "$(cat)") 4>&1-)" "${?}" 1>&2) 2>&1)
}
Succinctly, I believe the answer is 'No'. The capturing $( ... ) only captures standard output to the variable; there isn't a way to get the standard error captured into a separate variable. So, what you have is about as neat as it gets.
What about... =D
GET_STDERR=""
GET_STDOUT=""
get_stderr_stdout() {
GET_STDERR=""
GET_STDOUT=""
unset t_std t_err
eval "$( (eval $1) 2> >(t_err=$(cat); typeset -p t_err) > >(t_std=$(cat); typeset -p t_std) )"
GET_STDERR=$t_err
GET_STDOUT=$t_std
}
get_stderr_stdout "command"
echo "$GET_STDERR"
echo "$GET_STDOUT"
One workaround, which is hacky but perhaps more intuitive than some of the suggestions on this page, is to tag the output streams, merge them, and split afterwards based on the tags. For example, we might tag stdout with a "STDOUT" prefix:
function someCmd {
echo "I am stdout"
echo "I am stderr" 1>&2
}
ALL=$({ someCmd | sed -e 's/^/STDOUT/g'; } 2>&1)
OUT=$(echo "$ALL" | grep "^STDOUT" | sed -e 's/^STDOUT//g')
ERR=$(echo "$ALL" | grep -v "^STDOUT")
```
If you know that stdout and/or stderr are of a restricted form, you can come up with a tag which does not conflict with their allowed content.
WARNING: NOT (yet?) WORKING!
The following seems a possible lead to get it working without creating any temp files and also on POSIX sh only; it requires base64 however and due to the encoding/decoding may not be that efficient and use also "larger" memory.
Even in the simple case, it would already fail, when the last stderr line has no newline. This can be fixed at least in some cases with replacing exe with "{ exe ; echo >&2 ; }", i.e. adding a newline.
The main problem is however that everything seems racy. Try using an exe like:
exe()
{
cat /usr/share/hunspell/de_DE.dic
cat /usr/share/hunspell/en_GB.dic >&2
}
and you'll see that e.g. parts of the base64 encoded line is on the top of the file, parts at the end, and the non-decoded stderr stuff in the middle.
Well, even if the idea below cannot be made working (which I assume), it may serve as an anti-example for people who may falsely believe it could be made working like this.
Idea (or anti-example):
#!/bin/sh
exe()
{
echo out1
echo err1 >&2
echo out2
echo out3
echo err2 >&2
echo out4
echo err3 >&2
echo -n err4 >&2
}
r="$( { exe | base64 -w 0 ; } 2>&1 )"
echo RAW
printf '%s' "$r"
echo RAW
o="$( printf '%s' "$r" | tail -n 1 | base64 -d )"
e="$( printf '%s' "$r" | head -n -1 )"
unset r
echo
echo OUT
printf '%s' "$o"
echo OUT
echo
echo ERR
printf '%s' "$e"
echo ERR
gives (with the stderr-newline fix):
$ ./ggg
RAW
err1
err2
err3
err4
b3V0MQpvdXQyCm91dDMKb3V0NAo=RAW
OUT
out1
out2
out3
out4OUT
ERR
err1
err2
err3
err4ERR
(At least on Debian's dash and bash)
Here is an variant of #madmurphy solution that should work for arbitrarily large stdout/stderr streams, maintain the exit return value, and handle nulls in the stream (by converting them to newlines)
function buffer_plus_null()
{
local buf
IFS= read -r -d '' buf || :
echo -n "${buf}"
printf '\0'
}
{
IFS= time read -r -d '' CAPTURED_STDOUT;
IFS= time read -r -d '' CAPTURED_STDERR;
(IFS= read -r -d '' CAPTURED_EXIT; exit "${CAPTURED_EXIT}");
} < <((({ { some_command ; echo "${?}" 1>&3; } | tr '\0' '\n' | buffer_plus_null; } 2>&1 1>&4 | tr '\0' '\n' | buffer_plus_null 1>&4 ) 3>&1 | xargs printf '%s\0' 1>&4) 4>&1 )
Cons:
The read commands are the most expensive part of the operation. For example: find /proc on a computer running 500 processes, takes 20 seconds (while the command was only 0.5 seconds). It takes 10 seconds to read in the first time, and 10 seconds more to read the second time, doubling the total time.
Explanation of buffer
The original solution was to an argument to printf to buffer the stream, however with the need to have the exit code come last, one solution is to buffer both stdout and stderr. I tried xargs -0 printf but then you quickly started hitting "max argument length limits". So I decided a solution was to write a quick buffer function:
Use read to store the stream in a variable
This read will terminate when the stream ends, or a null is received. Since we already removed the nulls, it ends when the stream is closed, and returns non-zero. Since this is expected behavior we add || : meaning "or true" so that the line always evaluates to true (0)
Now that I know the stream has ended, it's safe to start echoing it back out.
echo -n "${buf}" is a builtin command and thus not limited to the argument length limit
Lastly, add a null separator to the end.
This prefixes error messages (similar to the answer of #Warbo) and by that we are able to distinguish between stdout and stderr:
out=$(some_command 2> >(sed -e 's/^/stderr/g'))
err=$(echo "$out" | grep -oP "(?<=^stderr).*")
out=$(echo "$out" | grep -v '^stderr')
The (?<=string) part is called a positive lookbehind which excludes the string from the result.
How I use it
# cat ./script.sh
#!/bin/bash
# check script arguments
args=$(getopt -u -l "foo,bar" "fb" "$#" 2> >(sed -e 's/^/stderr/g') )
[[ $? -ne 0 ]] && echo -n "Error: " && echo "$args" | grep -oP "(?<=^stderr).*" && exit 1
mapfile -t args < <(xargs -n1 <<< "$args")
#
# ./script.sh --foo --bar --baz
# Error: getopt: unrecognized option '--baz'
Notes:
As you can see I don't need to filter for stdout as the condition already catched the error and stopped the script. So if the script does not stop, $args does not contain any prefixed content.
An alternative to sed -e 's/^/stderr/g' is xargs -d '\n' -I {} echo "stderr{}".
Variant to prefix stdout AND stderr
# smbclient localhost 1> >(sed -e 's/^/std/g') 2> >(sed -e 's/^/err/g')
std
stdlocalhost: Not enough '\' characters in service
stderrUsage: smbclient [-?EgBVNkPeC] [-?|--help] [--usage]
stderr [-R|--name-resolve=NAME-RESOLVE-ORDER] [-M|--message=HOST]
stderr [-I|--ip-address=IP] [-E|--stderr] [-L|--list=HOST]
stderr [-m|--max-protocol=LEVEL] [-T|--tar=<c|x>IXFqgbNan]
stderr [-D|--directory=DIR] [-c|--command=STRING] [-b|--send-buffer=BYTES]
stderr [-t|--timeout=SECONDS] [-p|--port=PORT] [-g|--grepable]
stderr [-B|--browse] [-d|--debuglevel=DEBUGLEVEL]
stderr [-s|--configfile=CONFIGFILE] [-l|--log-basename=LOGFILEBASE]
stderr [-V|--version] [--option=name=value]
stderr [-O|--socket-options=SOCKETOPTIONS] [-n|--netbiosname=NETBIOSNAME]
stderr [-W|--workgroup=WORKGROUP] [-i|--scope=SCOPE] [-U|--user=USERNAME]
stderr [-N|--no-pass] [-k|--kerberos] [-A|--authentication-file=FILE]
stderr [-S|--signing=on|off|required] [-P|--machine-pass] [-e|--encrypt]
stderr [-C|--use-ccache] [--pw-nt-hash] service <password>
This is an addendum to Jacques Gaudin's addendum to madmurphy's answer.
Unlike the source, this uses eval to execute multi-line command (multi-argument is ok as well thanks to "${#}").
Another caveat is this function will return 0 in any case, and output exit code to a third variable instead. IMO this is more apt for catch.
#!/bin/bash
# Overwrites existing values of provided variables in any case.
# SYNTAX:
# catch STDOUT_VAR_NAME STDERR_VAR_NAME EXIT_CODE_VAR_NAME COMMAND1 [COMMAND2 [...]]
function catch() {
{
IFS=$'\n' read -r -d '' "${1}";
IFS=$'\n' read -r -d '' "${2}";
IFS=$'\n' read -r -d '' "${3}";
return 0;
}\
< <(
(printf '\0%s\0%d\0' \
"$(
(
(
(
{
shift 3;
eval "${#}";
echo "${?}" 1>&3-;
} | tr -d '\0' 1>&4-
) 4>&2- 2>&1- | tr -d '\0' 1>&4-
) 3>&1- | exit "$(cat)"
) 4>&1-
)" "${?}" 1>&2
) 2>&1
)
}
# Simulation of here-doc
MULTILINE_SCRIPT_1='cat << EOF
foo
bar
with newlines
EOF
'
# Simulation of multiple streams
# Notice the lack of semi-colons, otherwise below code
# could become a one-liner and still work
MULTILINE_SCRIPT_2='echo stdout stream
echo error stream 1>&2
'
catch out err code "${MULTILINE_SCRIPT_1}" \
'printf "wait there is more\n" 1>&2'
printf "1)\n\tSTDOUT: ${out}\n\tSTDERR: ${err}\n\tCODE: ${code}\n"
echo ''
catch out err code "${MULTILINE_SCRIPT_2}" echo this multi-argument \
form works too '1>&2' \; \(exit 5\)
printf "2)\n\tSTDOUT: ${out}\n\tSTDERR: ${err}\n\tCODE: ${code}\n"
Output:
1)
STDOUT: foo
bar
with newlines
STDERR: wait there is more
CODE: 0
2)
STDOUT: stdout stream
STDERR: error stream
this multi-argument form works too
CODE: 5
If the command 1) no stateful side effects and 2) is computationally cheap, the easiest solution is to just run it twice. I've mainly used this for code that runs during the boot sequence when you don't yet know if the disk is going to be working. In my case it was a tiny some_command so there was no performance hit for running twice, and the command had no side effects.
The main benefit is that this is clean and easy to read. The solutions here are quite clever, but I would hate to be the one that has to maintain a script containing the more complicated solutions. I'd recommend the simple run-it-twice approach if your scenario works with that, as it's much cleaner and easier to maintain.
Example:
output=$(getopt -o '' -l test: -- "$#")
errout=$(getopt -o '' -l test: -- "$#" 2>&1 >/dev/null)
if [[ -n "$errout" ]]; then
echo "Option Error: $errout"
fi
Again, this is only ok to do because getopt has no side effects. I know it's performance-safe because my parent code calls this less than 100 times during the entire program, and the user will never notice 100 getopt calls vs 200 getopt calls.
Here's a simpler variation that isn't quite what the OP wanted, but is unlike any of the other options. You can get whatever you want by rearranging the file descriptors.
Test command:
%> cat xx.sh
#!/bin/bash
echo stdout
>&2 echo stderr
which by itself does:
%> ./xx.sh
stdout
stderr
Now, print stdout, capture stderr to a variable, & log stdout to a file
%> export err=$(./xx.sh 3>&1 1>&2 2>&3 >"out")
stdout
%> cat out
stdout
%> echo
$err
stderr
Or log stdout & capture stderr to a variable:
export err=$(./xx.sh 3>&1 1>out 2>&3 )
%> cat out
stdout
%> echo $err
stderr
You get the idea.
Realtime output and write to file:
#!/usr/bin/env bash
# File where store the output
log_file=/tmp/out.log
# Empty file
echo > ${log_file}
outToLog() {
# File where write (first parameter)
local f="$1"
# Start file output watcher in background
tail -f "${f}" &
# Capture background process PID
local pid=$!
# Write "stdin" to file
cat /dev/stdin >> "${f}"
# Kill background task
kill -9 ${pid}
}
(
# Long execution script example
echo a
sleep 1
echo b >&2
sleep 1
echo c >&2
sleep 1
echo d
) 2>&1 | outToLog "${log_file}"
# File result
echo '==========='
cat "${log_file}"
I've posted my solution to this problem here. It does use process substitution and requires Bash > v4 but also captures stdout, stderr and return code into variables you name in the current scope:
https://gist.github.com/pmarreck/5eacc6482bc19b55b7c2f48b4f1db4e8
The whole point of this exercise was so that I could assert on these things in a test suite. The fact that I just spent all afternoon figuring out this simple-sounding thing... I hope one of these solutions helps others!