Escribir resultados en el archivo de registro y la consola

En el shell de Unix, tengo un archivo env (el archivo env define los parámetros necesarios para ejecutar el script de usuario, como el nombre y la ruta del archivo de registro, redirigir las salidas y los errores al archivo de registro, los detalles de la conexión de la base de datos, etc. ) que redirige todas las salidas ( mensajes de eco ) y errores en el archivo de registro del script ejecutado utilizando el siguiente código:

exec 1>>${LOG_FILE}
exec 2>>${LOG_FILE}

El archivo env se ejecuta al principio de cada script. Debido al código anterior en el archivo env, todas las salidas de la consola que pueden ser salidas de usuario o errores se envían directamente al archivo de registro, que es lo que realmente necesitaba.

Pero hay algunas salidas de usuario selectivas que quiero que se muestren tanto en la consola como en el archivo de registro. Pero debido al código anterior no puedo hacerlo.

Sé que si elimino el código anterior puedo obtener el resultado deseado para este caso, pero tendré que escribir manualmente todas las demás salidas en el archivo de registro, lo cual no es una tarea fácil.

¿Hay alguna forma de obtener la salida tanto en la consola como en el archivo de registro sin eliminar los códigos anteriores?

exec 3>&1 1>>${LOG_FILE} 2>&1

enviaría la salida stdout y stderr al archivo de registro, pero también lo dejaría con fd 3 conectado a la consola, para que pueda hacerlo

echo "Some console message" 1>&3

para escribir un mensaje solo en la consola, o

echo "Some console and log file message" | tee /dev/fd/3

para escribir un mensaje tanto en la consola como en el archivo de registro: teeenvía su salida tanto a su propio fd 1 (que aquí es el LOG_FILE) como al archivo en el que le dijo que escribiera (que aquí es fd 3, es decir, la consola).

Ejemplo:

exec 3>&1 1>>${LOG_FILE} 2>&1

echo "This is stdout"
echo "This is stderr" 1>&2
echo "This is the console (fd 3)" 1>&3
echo "This is both the log and the console" | tee /dev/fd/3

imprimiría

This is the console (fd 3)
This is both the log and the console

en la consola y poner

This is stdout
This is stderr
This is both the log and the console

en el archivo de registro.

Sí, quieres usar tee:

tee: lee desde la entrada estándar y escribe en archivos y salidas estándar

Simplemente canalice su comando a tee y pase el archivo como un argumento, así:

exec 1 | tee ${LOG_FILE}
exec 2 | tee ${LOG_FILE}

Esto imprime la salida en STDOUT y escribe la misma salida en un archivo de registro. Consulte man teepara obtener más información.

Tenga en cuenta que esto no escribirá stderr en el archivo de registro, por lo que si desea combinar las dos secuencias, use:

exec 1 2>&1 | tee ${LOG_FILE}

Probé la respuesta de Joonty, pero también obtuve la

exec: 1: no encontrado

error. Esto es lo que funciona mejor para mí ( confirmado que también funciona en zsh):

#!/bin/bash
LOG_FILE=/tmp/both.log
exec > >(tee ${LOG_FILE}) 2>&1
echo "this is stdout"
chmmm 77 /makeError

El archivo /tmp/both.log luego contiene

this is stdout
chmmm command not found 

El /tmp/both.log se adjunta a menos que elimine la -a de tee.

Pista: >(...)es una sustitución de proceso. Permite que el execde la teeorden como si se tratara de un archivo.

Quería mostrar los registros en stdout y el archivo de registro junto con la marca de tiempo. Ninguna de las respuestas anteriores funcionó para mí. Hice uso de la sustitución de procesos y el comando exec y se me ocurrió el siguiente código. Registros de muestra:

2017-06-21 11:16:41+05:30 Fetching information about files in the directory...

Agregue las siguientes líneas en la parte superior de su secuencia de comandos:

LOG_FILE=script.log
exec > >(while read -r line; do printf '%s %s\n' "$(date --rfc-3339=seconds)" "$line" | tee -a $LOG_FILE; done)
exec 2> >(while read -r line; do printf '%s %s\n' "$(date --rfc-3339=seconds)" "$line" | tee -a $LOG_FILE; done >&2)

¡Espero que esto ayude a alguien!

para el archivo de registro puede fechar para ingresar datos de texto. el siguiente código puede ayudar

# declaring variables

Logfile="logfile.txt"   
MAIL_LOG="Message to print in log file"  
Location="were is u want to store log file"

cd $Location   
if [ -f $Logfile ]  
then   
echo "$MAIL_LOG " >> $Logfile

else        

touch $Logfile   
echo "$MAIL_LOG" >> $Logfile    

fi  

Salida: 2. El archivo de registro se creará en la primera ejecución y se actualizará en las próximas ejecuciones. En caso de que falte el archivo de registro en una ejecución futura, el script creará un nuevo archivo de registro.

Encontré una manera de obtener el resultado deseado. Aunque puede ser una forma poco ortodoxa. De todos modos aquí va. En el archivo redir.env tengo el siguiente código:

#####redir.env#####    
export LOG_FILE=log.txt

      exec 2>>${LOG_FILE}

    function log {
     echo "$1">>${LOG_FILE}
    }

    function message {
     echo "$1"
     echo "$1">>${LOG_FILE}
    }

Luego, en el script real, tengo los siguientes códigos:

#!/bin/sh 
. redir.env
echo "Echoed to console only"
log "Written to log file only"
message "To console and log"
echo "This is stderr. Written to log file only" 1>&2

Aquí eco salidas sólo para la consola, inicie sesión salidas a registrar sólo los archivos y mensajes salidas tanto al archivo de registro y la consola.

Después de ejecutar el archivo de script anterior, tengo los siguientes resultados:

En consola

En la consola
Echoed a la consola solamente
A la consola y al registro

Para el archivo de registro

En archivo de registro Escrito solo en archivo de registro
Esto es stderr. Escrito solo en el archivo de registro
Para la consola y el registro

Espero que esto ayude.

Prueba esto, hará el trabajo:

log_file=$curr_dir/log_file.txt
exec > >(tee -a ${log_file} )
exec 2> >(tee -a ${log_file} >&2)

    #
    #------------------------------------------------------------------------------
    # echo pass params and print them to a log file and terminal
    # with timestamp and $host_name and $0 PID
    # usage:
    # doLog "INFO some info message"
    # doLog "DEBUG some debug message"
    # doLog "WARN some warning message"
    # doLog "ERROR some really ERROR message"
    # doLog "FATAL some really fatal message"
    #------------------------------------------------------------------------------
    doLog(){
        type_of_msg=$(echo $*|cut -d" " -f1)
        msg=$(echo "$*"|cut -d" " -f2-)
        [[ $type_of_msg == DEBUG ]] && [[ $do_print_debug_msgs -ne 1 ]] && return
        [[ $type_of_msg == INFO ]] && type_of_msg="INFO " # one space for aligning
        [[ $type_of_msg == WARN ]] && type_of_msg="WARN " # as well

        # print to the terminal if we have one
        test -t 1 && echo " [$type_of_msg] `date "+%Y.%m.%d-%H:%M:%S %Z"` [$run_unit][@$host_name] [$$] ""$msg"

        # define default log file none specified in cnf file
        test -z $log_file && \
            mkdir -p $product_instance_dir/dat/log/bash && \
                log_file="$product_instance_dir/dat/log/bash/$run_unit.`date "+%Y%m"`.log"
        echo " [$type_of_msg] `date "+%Y.%m.%d-%H:%M:%S %Z"` [$run_unit][@$host_name] [$$] ""$msg" >> $log_file
    }
    #eof func doLog

Me parece muy útil agregar stdout y stderr a un archivo de registro. Me alegré de ver una solución de alfonx con exec > >(tee -a), porque me preguntaba cómo lograr esto usando exec. Encontré una solución creativa usando la sintaxis here-doc y .: /unix/80707/how-to-output-text-to-both-screen-and-file-inside-a-shell -guión

Descubrí que en zsh, la solución here-doc se puede modificar usando la construcción "multios" para copiar la salida tanto en stdout / stderr como en el archivo de registro:

#!/bin/zsh
LOG=$0.log
# 8 is an arbitrary number;
# multiple redirects for the same file descriptor 
# triggers "multios"
. 8<<\EOF /dev/fd/8 2>&2 >&1 2>>$LOG >>$LOG
# some commands
date >&2
set -x
echo hi
echo bye
EOF
echo not logged

No es tan legible como la execsolución, pero tiene la ventaja de permitirle registrar solo una parte del script. Por supuesto, si omite el EOF, todo el script se ejecuta con el registro. No estoy seguro de cómo zshimplementa multios, pero puede tener menos gastos generales que tee. Desafortunadamente, parece que no se pueden usar multios con exec.