How to Enable Debug Logging for Development in Meetily Using RUST_LOG

Set the RUST_LOG environment variable before launching Meetily to control Rust log levels dynamically without modifying source code.

Meetily is a Rust-based Tauri application that relies on the standard env_logger crate for diagnostic output. By default, the application enforces an info log level, but you can enable debug logging for development in Meetily using RUST_LOG environment variable overrides to troubleshoot specific components like audio processing or Whisper transcription.

How Meetily's Logging System Works

Default Log Level Fallback in main.rs

The entry point at frontend/src-tauri/src/main.rs explicitly sets a fallback log level to prevent verbose output in production builds. At line 10, the code calls std::env::set_var("RUST_LOG", "info"); to ensure RUST_LOG defaults to info if not already set in the environment.

Console Utilities Enforcement

Additional log level enforcement occurs in frontend/src-tauri/src/console_utils/console_utils.rs at line 34, which provides another layer of default configuration before the logger initializes.

Build Script Integration

The helper scripts frontend/clean_run.sh and frontend/clean_build.sh simplify log level management during development. At line 11 of clean_run.sh, the script exports RUST_LOG=$LOG_LEVEL, allowing you to use a LOG_LEVEL variable as a convenient shortcut that the script forwards to the underlying RUST_LOG variable.

Enable Debug Logging for Development in Meetily Using RUST_LOG

To override the default logging behavior, export a RUST_LOG value before executing the Tauri build scripts. The env_logger crate reads this variable at startup when env_logger::init() is called implicitly via Rust log macros throughout the application.

Quick Start Commands

# Enable debug for entire application

RUST_LOG=debug ./clean_run.sh

# Enable debug only for the audio subsystem (recommended for most dev work)

RUST_LOG=app_lib::audio=debug ./clean_run.sh

# Use LOG_LEVEL shortcut (script forwards to RUST_LOG)

LOG_LEVEL=trace ./clean_run.sh

Per-Module Filter Patterns

The env_logger crate supports fine-grained filtering using comma-separated module paths and log levels. This allows you to isolate specific subsystems without noise from dependencies.

• debug – Enables debug output for all crates
• app_lib::audio=debug – Targets only the audio subsystem (useful for troubleshooting audio mixing)
• module1=trace,module2=info – Applies different levels to specific modules
• trace – Enables maximum verbosity for all components

Targeting Specific Components

When debugging Meetily's real-time audio processing or Whisper transcription engines, use module-specific filters to reduce output volume:

# Trace audio library but keep wgpu graphics at error level only

RUST_LOG=app_lib::audio=trace,wgpu=error ./clean_run.sh

Persistent Configuration

For continuous development work, add the export to your shell profile to avoid typing the variable for every session:

# Bash / Zsh profile

export RUST_LOG=app_lib::audio=debug

After setting the variable permanently, launch the app with pnpm run tauri:dev or the helper scripts; logs will appear in the terminal where you launched the command.

Summary

• Meetily uses env_logger which reads the RUST_LOG environment variable at process startup
• The default info level is enforced in frontend/src-tauri/src/main.rs at line 10 but can be overridden by pre-setting the variable
• Helper scripts clean_run.sh and clean_build.sh support the LOG_LEVEL shortcut variable at line 11
• Use RUST_LOG=app_lib::audio=debug to target specific subsystems without noise from other modules
• Logs output to stdout/stderr of the terminal running the Tauri process, visible during pnpm run tauri:dev

Frequently Asked Questions

Why don't my debug logs appear when I run Meetily?

The application explicitly sets RUST_LOG=info in frontend/src-tauri/src/main.rs and frontend/src-tauri/src/console_utils/console_utils.rs if the variable is unset. You must export RUST_LOG before launching the process, or use the LOG_LEVEL variable which the clean_run.sh script forwards to RUST_LOG at line 11.

Can I enable trace logging for specific modules only?

Yes. Use comma-separated filter expressions like RUST_LOG=app_lib::audio=trace,winit=error to enable trace-level debugging for the audio library while suppressing verbose windowing system logs. The env_logger crate parses these module-specific directives at initialization.

Do I need to rebuild the application when changing log levels?

No. Because Meetily uses env_logger, log levels are determined at process startup based on the environment variable. You can change RUST_LOG and restart the application immediately without recompiling, making it ideal for rapid debugging cycles during development.

Where do the logs appear when running the Tauri desktop app?

Logs print to stdout/stderr of the terminal where you launched the Tauri process. When using pnpm run tauri:dev or the helper scripts, output appears in your development terminal, making it easy to monitor audio mixing, Whisper transcription, and other Rust components in real-time according to the Meetily source code.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}