# How to Configure Logging Levels in Wand Enhancer: A Complete Guide

> Configure logging levels in Wand Enhancer by filtering the Action<string, ELogType> logger callback. Learn how to specify verbosity thresholds using ELogType for detailed insights.

- Repository: [k1tbyte/Wand-Enhancer](https://github.com/k1tbyte/Wand-Enhancer)
- Tags: how-to-guide
- Published: 2026-07-13

---

**You configure logging levels in Wand Enhancer by filtering the `Action<string, ELogType>` logger callback passed to the `Enhancer` class, using the `ELogType` enumeration defined in [`Logs.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/Logs.cs) to specify verbosity thresholds.**

Wand Enhancer implements a type‑safe logging system centered on a simple callback pattern and a severity enumeration. To configure which messages appear in the output, you must understand how the `ELogType` enum structures severity and how the core engine receives log output.

## Understanding the Logging Architecture

### The ELogType Enumeration in Logs.cs

According to the Wand Enhancer source code, the available logging levels are declared in [`WandEnhancer/View/MainWindow/Logs.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/View/MainWindow/Logs.cs) as the `ELogType` enumeration. This enum defines four distinct severity levels:

- `Info` – General informational messages
- `Success` – Operations that completed successfully
- `Warning` – Recoverable problems that deserve attention
- `Error` – Fatal errors or unexpected failures

The enum order follows increasing severity: `Info` < `Success` < `Warning` < `Error`.

### The Logger Callback Pattern

The `Enhancer` class in [`WandEnhancer/Core/Enhancer.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/Core/Enhancer.cs) does not write to the console directly. Instead, it receives an `Action<string, ELogType>` callback that forwards text and severity to the UI or any custom handler. For example, the core engine emits logs via calls such as:

```csharp
_logger($"{prefix} Patch applied", ELogType.Success);
_logger("[ENHANCER] Injected remote panel assets …", ELogType.Info);
_logger($"[ENHANCER] Failed to copy logs: {e.Message}", ELogType.Error);

```

## How to Configure Logging Levels Programmatically

By default, the `Enhancer` emits all log levels. To configure verbosity, wrap the original logger with a filter that checks the `ELogType` value against a minimum threshold before forwarding the message.

```csharp
// Define the minimum level you want to keep
const ELogType minLevel = ELogType.Warning;

// Wrap the original logger to filter levels
Action<string, ELogType> filteredLogger = (msg, level) =>
{
    if (level >= minLevel)   // Only allow Warning and Error
        originalLogger(msg, level);
};

// Pass the filtered logger to the Enhancer constructor
var enhancer = new Enhancer(config, filteredLogger, patchConfig);

```

This approach lets you silence `Info` and `Success` messages while preserving critical output without modifying the core library files.

## UI-Based Log Filtering

### The LogList Collection in MainWindowVm.cs

The `MainWindowVm` class in [`WandEnhancer/View/MainWindow/MainWindowVm.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/View/MainWindow/MainWindowVm.cs) maintains an observable collection named `LogList`. The `Log` method creates `LogEntry` objects containing the message, type, and timestamp:

```csharp
public void Log(string message, ELogType logType)
{
    var entry = new LogEntry
    {
        Timestamp = DateTime.Now,
        Message   = $"[{logType}] {message}",
        Type      = logType
    };
    LogList.Add(entry);
}

```

### Viewing Filtered Output

The UI binds to `LogList` and typically provides a ComboBox or similar control bound to the `ELogType` values. This allows users to filter the visible log entries at the presentation layer, independent of the core logging configuration.

## Practical Implementation Examples

**Example 1 – Emitting logs at each level:**

```csharp
_logger("Application started", ELogType.Info);
_logger("Patch file loaded", ELogType.Success);
_logger("Using deprecated API", ELogType.Warning);
_logger("Failed to read config", ELogType.Error);

```

**Example 2 – Creating a filtered logger (warnings and errors only):**

```csharp
Action<string, ELogType> filtered = (msg, lvl) =>
{
    if (lvl is ELogType.Warning or ELogType.Error)
        Console.WriteLine($"[{lvl}] {msg}");
};

var enhancer = new Enhancer(weModConfig, filtered, patchConfig);

```

**Example 3 – UI-bound log entry handling:**

```csharp
// Inside MainWindowVm.cs
public void Log(string message, ELogType logType)
{
    var entry = new LogEntry
    {
        Timestamp = DateTime.Now,
        Message   = $"[{logType}] {message}",
        Type      = logType
    };
    LogList.Add(entry);
}

```

## Summary

- The `ELogType` enum in [`WandEnhancer/View/MainWindow/Logs.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/View/MainWindow/Logs.cs) defines four levels: `Info`, `Success`, `Warning`, and `Error`.
- Configure logging levels by wrapping the `Action<string, ELogType>` callback passed to the `Enhancer` class with a filtering condition based on enum comparison.
- The UI layer in [`WandEnhancer/View/MainWindow/MainWindowVm.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/View/MainWindow/MainWindowVm.cs) aggregates logs in `LogList` and can filter the display independently of the core logger.
- Enum values follow natural order where `Info` < `Success` < `Warning` < `Error`, enabling simple threshold checks.

## Frequently Asked Questions

### Where is the logging level enum defined in Wand Enhancer?

The `ELogType` enumeration is defined in [`WandEnhancer/View/MainWindow/Logs.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/View/MainWindow/Logs.cs). It contains four values—`Info`, `Success`, `Warning`, and `Error`—that represent increasing severity levels used throughout the application.

### How do I suppress informational messages in Wand Enhancer?

Wrap the logger callback with a condition that checks if the level meets your minimum threshold. For example, check `if (level >= ELogType.Warning)` before calling the original logger to suppress `Info` and `Success` messages while retaining warnings and errors.

### Can I change logging levels without modifying the source code?

Yes. You can inject a filtered logger at the composition root where you instantiate the `Enhancer` class. By passing a wrapper around the original logger that filters by `ELogType`, you control verbosity programmatically without altering the internal `Enhancer` or `MainWindowVm` implementations.

### Does Wand Enhancer support dynamic log level changes at runtime?

While the core `Enhancer` receives a fixed callback at initialization, you can implement a mutable wrapper that checks a configurable threshold variable. The UI layer in `MainWindowVm` already supports dynamic filtering by binding `LogList` to view controls that filter by `ELogType` in real time.