logged stream

transmisión registrada

Tabla de contenido

• Descripción
  • Estructura
  • Casos de uso
• Uso
• Ejemplo
• Licencia
• Contribución

Descripción

Estructura

logged-stream es una biblioteca de óxido que proporciona una estructura LoggedStream que puede usarse como un envoltorio para el objeto IO subyacente que implementa std::io::Write and std::io::Read rasgos o sus análogos asincrónicos de la biblioteca tokio para permitir el registro de todas las operaciones de lectura y escritura, errores y caídas.

LoggedStream Structure Construye a partir de cuatro partes:

• Objeto IO subyacente, que debe implementar std::io::Write y std::io::Read rasgos o sus análogos asíncronos de la biblioteca tokio : tokio::io::AsyncRead y tokio::io::AsyncWrite .
• Part de formato de búfer, que debe implementar el rasgo BufferFormatter proporcionado por esta biblioteca. Esta parte de LoggedStream es responsable del formulario que verá los bytes de entrada y salida. Actualmente UppercaseHexadecimalFormatter esta biblioteca proporciona OctalFormatter siguientes implementaciones del rasgo de BufferFormatter DecimalFormatter LowercaseHexadecimalFormatter BinaryFormatter . También BufferFormatter es el rasgo público, por lo que es libre de construir su propia implementación.
• Part de filtrado, que debe implementar el rasgo RecordFilter proporcionado por esta biblioteca. Esta parte de LoggedStream es responsable del filtrado de registros de registros. Actualmente, esta biblioteca proporciona la siguiente implementación del rasgo RecordFilter : DefaultFilter que acepta todos los registros de registro y RecordKindFilter que acepta registros con tipos especificados durante la construcción. También RecordFilter es un rasgo público y usted es libre de construir su propia implementación.
• Parte de registro, que debe implementar el rasgo Logger proporcionado por esta biblioteca. Esta parte de LoggedStream es responsable del trabajo adicional con el registro de registro construido, formatero y filtrado. Por ejemplo, se puede emitir a la consola, escrito en el archivo, escrito en la base de datos, escrita en la memoria para su uso posterior o enviado por el canal. Actualmente, esta biblioteca proporciona las siguientes implementaciones del rasgo Logger : ConsoleLogger , MemoryStorageLogger , ChannelLogger y FileLogger . También Logger es un rasgo público y usted es libre de construir su propia implementación.

Casos de uso

• Monitoreo del tráfico de red:
  • Monitoree y registre todo el tráfico de red entrante y saliente en un servidor o aplicación cliente.
  • Útil para depurar protocolos de red, seguimiento del intercambio de datos y garantizar el cumplimiento de la seguridad.
• Operaciones de E/S de depuración:
  • Registre todas las operaciones de lectura y escritura para diagnosticar problemas con el archivo o la E/S de la red.
  • Ayuda a identificar cuellos de botella, corrupción de datos y comportamiento inesperado en las operaciones de E/S.
• Análisis de rendimiento:
  • Analice el rendimiento de las operaciones de E/S registrando el tiempo tomado para cada operación de lectura/escritura.
  • Ayuda a identificar problemas de rendimiento y optimizar aplicaciones intensivas de E/S.
• Registro de actividad de la base de datos:
  • Registre todas las interacciones con una base de datos, incluidas consultas, actualizaciones y detalles de la transacción.
  • Ayuda en el ajuste de rendimiento de la base de datos, los problemas de consulta de depuración y el mantenimiento de registros de auditoría.
• Servidores proxy:
  • Implemente el inicio de sesión en servidores proxy para monitorear y registrar todo el tráfico reenviado.
  • Útil para depurar el comportamiento proxy y garantizar el enrutamiento de datos adecuado.

Uso

Para usar logged-stream , agregue la siguiente línea a su Cargo.toml :

[ dependencies ]
logged-stream = " 0.4 "

o ejecute el siguiente comando de carga en el directorio de su proyecto:

 $ cargo add [email protected]

Ejemplo

Este es un ejemplo de uso simple de la estructura LoggedStream con std::net::TcpStream como objeto IO sublacable que se conecta a un formateador hexadecimal en minúsculas, filtro predeterminado y registrador de consola.

 fn main ( ) {
    env :: set_var ( "RUST_LOG" , "debug" ) ;
    env_logger :: init ( ) ;

    let mut client = LoggedStream :: new (
        net :: TcpStream :: connect ( "127.0.0.1:8080" ) . unwrap ( ) ,
        LowercaseHexadecimalFormatter :: new ( None ) ,
        DefaultFilter :: default ( ) ,
        ConsoleLogger :: new_unchecked ( "debug" ) ,
    ) ;

    let send = [ 0x01 , 0x02 , 0x03 , 0x04 ] ;
    client . write_all ( & send ) . unwrap ( ) ;
    let mut response = [ 0u8 ; 4 ] ;
    client . read_exact ( & mut response ) . unwrap ( ) ;

    let send = [ 0x05 , 0x06 , 0x07 , 0x08 ] ;
    client . write_all ( & send ) . unwrap ( ) ;
    let mut response = [ 0u8 ; 4 ] ;
    client . read_exact ( & mut response ) . unwrap ( ) ;

    let send = [ 0x09 , 0x0a , 0x0b , 0x0c ] ;
    client . write_all ( & send ) . unwrap ( ) ;
    let mut response = [ 0u8 ; 4 ] ;
    client . read_exact ( & mut response ) . unwrap ( ) ;

    let send = [ 0x01 , 0x02 , 0x03 , 0x04 ] ;
    client . write_all ( & send ) . unwrap ( ) ;
    let mut response = [ 0u8 ; 4 ] ;
    client . read_exact ( & mut response ) . unwrap ( ) ;
}

Salida a la consola:

 [2023-04-18T08:18:45.895Z DEBUG logged_stream::logger] > 01:02:03:04
[2023-04-18T08:18:45.895Z DEBUG logged_stream::logger] < 01:02:03:04
[2023-04-18T08:18:45.895Z DEBUG logged_stream::logger] > 05:06:07:08
[2023-04-18T08:18:45.895Z DEBUG logged_stream::logger] < 05:06:07:08
[2023-04-18T08:18:45.895Z DEBUG logged_stream::logger] > 09:0a:0b:0c
[2023-04-18T08:18:45.896Z DEBUG logged_stream::logger] < 09:0a:0b:0c
[2023-04-18T08:18:45.896Z DEBUG logged_stream::logger] > 01:02:03:04
[2023-04-18T08:18:45.896Z DEBUG logged_stream::logger] < 01:02:03:04
[2023-04-18T08:18:45.896Z DEBUG logged_stream::logger] x Deallocated.

La versión completa de este ejemplo se puede encontrar allí.

El mismo ejemplo, pero reescrito usando la API asincrónica, se puede encontrar allí.

Licencia

Con licencia bajo cualquiera de

• Licencia Apache, versión 2.0, (licencia-apache o https://www.apache.org/licenses/license-2.0)
• Licencia MIT (licencia-mit o https://opensource.org/licenses/Mit)

a tu opción.

Contribución

A menos que declare explícitamente lo contrario, cualquier contribución presentada intencionalmente para su inclusión en el trabajo por usted, como se define en la licencia Apache-2.0, se debe tener doble licencia como se indicó anteriormente, sin ningún término o condiciones adicionales.