Скопируйте stdout и stderr в файл журнала, покажите на консоли только вывод stderr и запишите сообщения stderr в другой файл

Я не мог придумать решение на основе -оболочки, поэтому предложил это. Другие предоставили гораздо лучшие решения на основе оболочки -. Я оставлю это здесь на всякий случай, если кому-то это покажется интересным, но другие ответы лучше.

Вот программа на C, которая сделает то, что вам нужно:

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

// Some wrappers around system calls to hide error handling
static void Pipe(int pipe_fds[]);
static pid_t Fork();
static void Dup2(int old_fd, int new_fd);
static void Execvp(const char *file, char *const argv[]);

int main(int argc, char* argv[])
{
    if (argc < 2) {
        fprintf(stderr, "usage: %s <script> [<arg>,...]\n", argv[0]);
        return EXIT_FAILURE;
    }

    // Create a pipe to handle stdout
    int out_pipe[2];
    Pipe(out_pipe);

    // Create a second pipe to handle stderr
    int err_pipe[2];
    Pipe(err_pipe);

    if (Fork() == 0) { // Child
        // Wire the child's stdout stream to the write end of out_pipe
        close(out_pipe[0]);
        Dup2(out_pipe[1], STDOUT_FILENO);
        close(out_pipe[1]);

        // Wire the child's stderr stream to the write end of err
        close(err_pipe[0]);
        Dup2(err_pipe[1], STDERR_FILENO);
        close(err_pipe[1]);

        // Invoke the target program with the remaining args
        Execvp(argv[1], argv + 1);
    }

    // Parent only from here on out

    // Close the write ends of the pipes
    close(out_pipe[1]);
    close(err_pipe[1]);

    // Set up the file descriptors and events we're interested in monitoring
    struct pollfd poll_fds[] = {
        {.fd = out_pipe[0],.events = POLLIN },
        {.fd = err_pipe[0],.events = POLLIN },
    };

    int incomplete_fds = 0;

    while (incomplete_fds != 2 && poll(poll_fds, 2, -1) > 0) {
        for (int i = 0; i < 2; ++i) {
            // Is this file descriptor readable?
            if (poll_fds[i].revents & POLLIN) {
                char buffer[4096];
                const ssize_t num_bytes = read(poll_fds[i].fd, buffer, sizeof(buffer));

                // (3) write both stdout and stderr our stderr
                write(STDERR_FILENO, buffer, num_bytes);

                if (i == 1) { // if this was a write to stderr
                    // (1) write standard error to out stdout
                    write(STDOUT_FILENO, buffer, num_bytes);
                }

            }

            if (poll_fds[i].revents & (POLLHUP | POLLNVAL)) {
                // Don't expect anything more from this
                poll_fds[i].events = 0;
                poll_fds[i].fd = -1;
                ++incomplete_fds;
            }
        }
    }

    return EXIT_SUCCESS;
}

static void Pipe(int pipe_fds[])
{
    if (pipe(pipe_fds) < 0) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
}

static pid_t Fork()
{
    const pid_t pid = fork();

    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    return pid;
}

static void Dup2(const int old_fd, const int new_fd)
{
    if (dup2(old_fd, new_fd) < 0) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
}

static void Execvp(const char *file, char *const argv[])
{
    execvp(file, argv);
    perror("execvp");

    exit(EXIT_FAILURE);
}

Программа принимает приложение, которое вы хотите запустить, в качестве аргумента вместе с любыми аргументами, которые вы хотите передать этому приложению. Он создает два канала: один для захвата содержимого, которое приложение записывает в stdout, а другой — для stderr. Затем он fork()s, соединяет каналы с выходными потоками дочернего элемента, затем вызывает приложение с любыми аргументами.

Затем родительский процесс может читать из этих каналов; он использует poll()для ожидания активности любого из этих файловых дескрипторов. Все, что программа читает из потоков stdoutили stderrприложения, она записывает в stderr.Все, что программа читает из потока stderrприложения, она записывает в stdout(. Это кажется обратным, но упрощает перенаправление ).

Я могу скомпилировать программу на C с помощью

$ gcc prog.c -o pipe_wrapper

Теперь предположим, что у меня есть что-то, что генерирует вывод как для stdout, так и для stderr:

#!/bin/bash
# ex.sh

echo stdout
echo stderr 1>&2

Тогда я смогу бежать:

# Note that the content written to stderr appears on the console
$./pipe_wrapper./ex.sh 2> allout.log | tee errout.log
stderr
$

# That content written to stderr is captured in errout.log
$ cat errout.log
stderr
$

# And that everything written to either stdout of stderr is captured
# in allout.log
$ cat allout.log
stdout
stderr
$

Я не могу гарантировать, что это сохранит порядок; если приложение записывает в stderrи stdoutв быстрой последовательности, эта программа может обрабатывать содержимое, записанное в stdout, до того, как содержимое будет записано в stderr.

В zsh это может быть foo 2>&2 2> err.log > all.log 2>&1.

В bash это может работать:

foo 2>&1 >> all.log | tee -a all.log err.log >&2

или

{ foo >> all.log; } 2>&1 | tee -a all.log err.log >&2