How to send all output to `logger` in POSIX shell?

Question

I'd like to log standard output and standard error separately in .xprofile using logger. In Bash I think that would look something like this:

exec 1> >(logger --priority user.notice --tag $(basename $0)) \
     2> >(logger --priority user.error --tag $(basename $0))

How would I do that in a POSIX /bin/sh compatible manner?

Answer 1

POSIX command/process substitution

---

_log()( x=0
    while  [ -e "${TMPDIR:=/tmp}/$$.$((x+=1))" ]
    do     continue; done        &&
    mkfifo -- "$TMPDIR/$$.$x"    &&
    printf %s\\n "$TMPDIR/$$.$x" || exit
    exec >&- >/dev/null
    {  rm -- "$TMPDIR/$$.$x"
       logger --priority user."$1" --tag "${0##*/}"
    }  <"$TMPDIR/$$.$x" &
)   <&- </dev/null

You should be able to use that like:

exec >"$(_log notice)" 2>"$(_log error)"

Here's a version which makes use of the mktemp command:

_log()( p=
    mkfifo "${p:=$(mktemp -u)}"    &&
    printf %s "$p"                 &&
    exec  <&- >&- <>/dev/null >&0  &&
    {   rm "$p"
        logger --priority user."$1" --tag "${0##*/}"
    }   <"$p" &
)

...which does much the same, except that it allows mktemp to select the filename for you. This works because process substitution is by no means magical and works in a very similar way to command substitution. Instead of replacing the expansion with the value of the command run within it as command substitution does, process substitution replaces it with the name of a filesystem link where the output can be found.

While the POSIX shell does not provide a direct corollary to such a thing, emulating it is very simply done. All you need to do is make a file, print its name to the standard out of a command substitution, and in the background of same run your command which will output to that file. Now you can just redirect into the value of that expansion - exactly as you do with process substitution. And so the POSIX shell provides all of the tools you need of course - all that is required is that you put them to use in a way which suits you.

Both of the above versions ensure that they destroy the filesystem link to the pipes they create/use before ever making use of them. This means there is no cleanup required after the fact, and, more importantly, their streams are only available to the processes which initially open them - and so their filesystem links cannot be used as a means to snoop/hijack your logging activity. To leave their fs-links in the filesystem is a potential security hole.

---

Another way is to wrap it. It can be done from within the script.

x=${x##*[!0-9]*}
_log(){ 
    logger --priority user."$1" --tag "${0##*/}"
}   2>/dev/null >&2

cd ../"$PPID.$x" 2>/dev/null &&
trap 'rm -rf -- "${TMPDIR:-/tmp}/$PPID.$x"' 0 || 
{   until cd -- "${TMPDIR:=/tmp}/$$.$x"
    do    mkdir -- "$TMPDIR/$$.$((x+=1))"
    done  && 
    x=$x "$0" "$@" | _log notice
    exit
}   2>&1 | _log error

That would basically allow your script to call itself if it hasn't yet and get you a work directory in temp to boot.

Answer 2

There's no POSIX equivalent. You can only perform a redirection with exec, not a fork. A pipe requires a fork, and the shell waits for the child to finish.

One solution is to put all your code in a function.

all_my_code () {
  …
}
{ all_my_code |
  logger --priority user.notice --tag "$(basename "$0")"; } 2>&1 | 
  logger --priority user.error --tag "$(basename "$0")"

(This also logs any error from the stdout instance of logger to the stderr instance. You can avoid this with more file descriptor shuffling.)

If you want the parent shell to exit even if the logger processes are still running, put & at the end of the logger invocations.

{ all_my_code |
  logger --priority user.notice --tag "$(basename "$0")" & } 2>&1 | 
  logger --priority user.error --tag "$(basename "$0")" &

Alternatively, you can use named pipes.

pipe_dir=$(mktemp -d)
mkfifo "$pipe_dir/out" "$pipe_dir/err"
<"$pipe_dir/out" logger --priority user.notice --tag "$(basename "$0")" &
<"$pipe_dir/err" logger --priority user.error --tag "$(basename "$0")" &
exec >"$pipe_dir/out" 2>"$pipe_dir/err" 
…
rm -r "$pipe_dir"