Logging

Referencia de API

Logging configurable para tu aplicación Tauri.

Plataformas Soportadas

Este plugin requiere una versión de Rust de al menos 1.77.2

Plataforma	Nivel	Notas
windows
linux
macos
android
ios

Configuración

Instala el plugin log para comenzar.

Automático
Manual

Usa el gestor de paquetes de tu proyecto para agregar la dependencia:

npm run tauri add log

yarn run tauri add log

pnpm tauri add log

deno task tauri add log

bun tauri add log

cargo tauri add log

Ejecuta el siguiente comando en la carpeta src-tauri para agregar el plugin a las dependencias del proyecto en Cargo.toml:
```
cargo add tauri-plugin-log
```

Modifica lib.rs para inicializar el plugin:

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_log::Builder::new().build())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Instala los bindings de JavaScript utilizando tu gestor de paquetes de JavaScript preferido:

npm install @tauri-apps/plugin-log

yarn add @tauri-apps/plugin-log

pnpm add @tauri-apps/plugin-log

deno add npm:@tauri-apps/plugin-log

bun add @tauri-apps/plugin-log

Uso

Primero, necesitas registrar el plugin con Tauri.

use tauri_plugin_log::{Target, TargetKind};

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_log::Builder::new().build())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Después, todas las API del plugin estarán disponibles a través de los bindings guest de JavaScript:

import {
  warn,
  debug,
  trace,
  info,
  error,
  attachConsole,
  attachLogger,
} from '@tauri-apps/plugin-log';
// when using `"withGlobalTauri": true`, you may use
// const { warn, debug, trace, info, error, attachConsole, attachLogger } = window.__TAURI__.log;

Utiliza una de las API del plugin (warn, debug, trace, info o error) para generar un registro desde el código de JavaScript:

import { warn, debug, trace, info, error } from '@tauri-apps/plugin-log';

trace('Trace');
info('Info');
error('Error');

Para reenviar automáticamente todos los mensajes de la console al plugin log, puedes reescribirlos:

import { warn, debug, trace, info, error } from '@tauri-apps/plugin-log';

function forwardConsole(
  fnName: 'log' | 'debug' | 'info' | 'warn' | 'error',
  logger: (message: string) => Promise<void>
) {
  const original = console[fnName];
  console[fnName] = (message) => {
    original(message);
    logger(message);
  };
}

forwardConsole('log', trace);
forwardConsole('debug', debug);
forwardConsole('info', info);
forwardConsole('warn', warn);
forwardConsole('error', error);

Para crear tus propios registros en el lado de Rust puedes utilizar el crate log:

log::error!("something bad happened!");
log::info!("Tauri is awesome!");

Ten en cuenta que el crate log debe añadirse a tu archivo Cargo.toml:

[dependencies]
log = "0.4"

Destinos de registro

El builder del plugin log tiene una función targets que te permite configurar el destino común de todos los logs de tu aplicación.

Por defecto el plugin registra en stdout y en un archivo dentro del directorio de logs de la aplicación. Para utilizar únicamente tus propios destinos de registro, llama a clear_targets:

tauri_plugin_log::Builder::new()
.clear_targets()
.build()

Imprimir logs en la terminal

Para reenviar todos tus logs a la terminal, habilita los destinos Stdout o Stderr:

tauri_plugin_log::Builder::new()
  .target(tauri_plugin_log::Target::new(
    tauri_plugin_log::TargetKind::Stdout,
  ))
  .build()

Este destino está habilitado por defecto.

Registrar en la consola del webview

Para ver todos tus logs de Rust en la consola del webview, habilita el destino Webview y ejecuta attachConsole en tu frontend:

tauri_plugin_log::Builder::new()
  .target(tauri_plugin_log::Target::new(
    tauri_plugin_log::TargetKind::Webview,
  ))
  .build()

import { attachConsole } from '@tauri-apps/plugin-log';
const detach = await attachConsole();
// call detach() if you do not want to print logs to the console anymore

Persistir logs

Para escribir todos los logs en un archivo, puedes utilizar los destinos LogDir o Folder.

LogDir:

tauri_plugin_log::Builder::new()
  .target(tauri_plugin_log::Target::new(
    tauri_plugin_log::TargetKind::LogDir {
      file_name: Some("logs".to_string()),
    },
  ))
  .build()

Al utilizar el destino LogDir, todos los logs se almacenan en el directorio de registros recomendado. La siguiente tabla describe la ubicación de los logs por plataforma:

Plataforma	Valor	Ejemplo
Linux	`$XDG_DATA_HOME/{bundleIdentifier}/logs` o `$HOME/.local/share/{bundleIdentifier}/logs`	`/home/alice/.local/share/com.tauri.dev/logs`
macOS	`{homeDir}/Library/Logs/{bundleIdentifier}`	`/Users/Alice/Library/Logs/com.tauri.dev`
Ventanas	`{FOLDERID_LocalAppData}/{bundleIdentifier}/logs`	`C:\Users\Alice\AppData\Local\com.tauri.dev\logs`

Folder:

El destino Folder te permite escribir logs en una ubicación personalizada del sistema de archivos.

tauri_plugin_log::Builder::new()
  .target(tauri_plugin_log::Target::new(
    tauri_plugin_log::TargetKind::Folder {
      path: std::path::PathBuf::from("/path/to/logs"),
      file_name: None,
    },
  ))
  .build()

El file_name por defecto es el nombre de la aplicación.

Configurar el comportamiento del archivo de registros

Por defecto el archivo de registros se descarta cuando alcanza el tamaño máximo. El tamaño máximo del archivo se puede configurar mediante la función max_file_size del builder:

tauri_plugin_log::Builder::new()
  .max_file_size(50_000 /* bytes */)
  .build()

Tauri puede rotar automáticamente tu archivo de logs cuando alcanza el límite de tamaño en lugar de descartar el archivo anterior. Este comportamiento se puede configurar usando rotation_strategy:

tauri_plugin_log::Builder::new()
  .rotation_strategy(tauri_plugin_log::RotationStrategy::KeepAll)
  .build()

Filtrado

Por defecto se procesan todos los logs. Existen varios mecanismos para reducir la cantidad de registros y filtrar solo la información relevante.

Nivel máximo de registro

Para establecer un nivel máximo de registro, utiliza la función level:

tauri_plugin_log::Builder::new()
  .level(log::LevelFilter::Info)
  .build()

En este ejemplo, los logs de debug y trace se descartan ya que tienen un nivel inferior a info.

También es posible definir niveles máximos separados para módulos individuales:

tauri_plugin_log::Builder::new()
  .level(log::LevelFilter::Info)
  // verbose logs only for the commands module
  .level_for("my_crate_name::commands", log::LevelFilter::Trace)
  .build()

Ten en cuenta que estas API utilizan el crate log, que debe añadirse a tu archivo Cargo.toml:

[dependencies]
log = "0.4"

Filtro de objetivo

Se puede definir una función filter para descartar los registros no deseados comprobando sus metadatos:

tauri_plugin_log::Builder::new()
  // exclude logs with target `"hyper"`
  .filter(|metadata| metadata.target() != "hyper")
  .build()

Formateo

El plugin log da formato a cada registro como FECHA[OBJETIVO][NIVEL] MENSAJE. Se puede proporcionar una función de formato personalizada mediante format:

tauri_plugin_log::Builder::new()
  .format(|out, message, record| {
    out.finish(format_args!(
      "[{} {}] {}",
      record.level(),
      record.target(),
      message
    ))
  })
  .build()

Aplicar un formato diferente a los destinos

Puedes especificar tu propio formato de registros para destinos específicos utilizando el método format en tauri_plugin_log::Target. Es posible que también desees llamar a clear_format en el builder para eliminar el formateador por defecto, el cual se aplica a todos los destinos:

tauri_plugin_log::Builder::new()
    .clear_format()
    .targets([
        tauri_plugin_log::Target::new(
            tauri_plugin_log::TargetKind::Stdout
        )
        .format(move |out, message, record| {
            // custom formatter for stdout
        }),
        tauri_plugin_log::Target::new(
            tauri_plugin_log::TargetKind::LogDir { file_name: None }
        )
        .format(move |out, message, record| {
            // custom formatter for log files
        }),
    ])
    .build(),

Fechas de registros

Por defecto el plugin log utiliza la zona horaria UTC para formatear las fechas, pero puedes mejoararlo para usar la zona horaria local con timezone_strategy:

tauri_plugin_log::Builder::new()
  .timezone_strategy(tauri_plugin_log::TimezoneStrategy::UseLocal)
  .build()

Permisos

Por defecto, todos los comandos del plugin están bloqueados y no se puede acceder a ellos. Debes definir una lista de permisos en tu configuración de capabilities.

Consulta la Visión General de Capacidades para obtener más información y la guía paso a paso para usar permisos de plugins.

{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "main-capability",
  "description": "Capability for the main window",
  "windows": ["main"],
  "permissions": ["log:default"]
}

Permiso Predeterminado

Permite el comando log

Este conjunto de permisos predeterminado incluye lo siguiente:

allow-log

Tabla de Permisos

Identificador	Descripción
`log:allow-log`	Habilita el comando log sin ningún alcance preconfigurado.
`log:deny-log`	Deniega el comando log sin ningún alcance preconfigurado.

Apoya en Open Collective Patrocina en GitHub