# How to Enable Debug Logging for Development in Meetily Using RUST_LOG

> Learn how to enable debug logging for development in Meetily by setting the RUST_LOG environment variable. Control Rust log levels easily without code changes.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-07-09

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_run.sh) and [`frontend/clean_build.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_build.sh) simplify log level management during development. At line 11 of [`clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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

```bash

# 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:

```bash

# 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

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/main.rs) at line 10 but can be overridden by pre-setting the variable
- Helper scripts [`clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/clean_run.sh) and [`clean_build.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/main.rs) and [`frontend/src-tauri/src/console_utils/console_utils.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.