---
url: /logly.zig/examples/filtering.md
description: >-
  Example of filtering logs with Logly.zig. Filter by level, module, message
  content with allow/deny rules and batch evaluation for precise log control.
---

# Filtering Example

Learn how to filter log messages based on level, module, or content.

## Basic Filtering

```zig
const std = @import("std");
const logly = @import("logly");

pub fn main() !void {
    var gpa = std.heap.DebugAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // Enable colors on Windows
     _ = logly.Terminal.enableAnsiColors();

    const logger = try logly.Logger.init(allocator);
    defer logger.deinit();

    // Create a filter
    var filter = logly.Filter.init(allocator);
    defer filter.deinit();

    // Add minimum level filter - only warning and above
    try filter.addMinLevel(.warning);

    // Apply filter to logger
    logger.setFilter(&filter);

    // Only warning and above will pass
    try logger.debug("This won't appear", @src());  // Filtered out
    try logger.info("This won't appear", @src());   // Filtered out
    try logger.warn("This will appear", @src());    // Passes filter (short alias)
    try logger.err("This will appear", @src());     // Passes filter
}
```

## Module-Based Filtering

```zig
// Filter by module prefix
var filter = logly.Filter.init(allocator);
defer filter.deinit();

try filter.addModulePrefix("database");  // Only from "database" module

logger.setFilter(&filter);

// Create scoped logger
const dbLogger = logger.scoped("database");
try dbLogger.info("This will appear", @src());     // Module matches

try logger.info("This won't appear", @src());       // No module, filtered
```

## Message Content Filtering

```zig
var filter = logly.Filter.init(allocator);
defer filter.deinit();

// Deny logs containing sensitive keywords
try filter.addMessageFilter("password", .deny);
try filter.addMessageFilter("secret", .deny);

logger.setFilter(&filter);

try logger.info("Normal message", @src());           // Passes
try logger.info("User password changed", @src());    // Filtered (contains "password")
```

## Filter Presets

```zig
const FilterPresets = logly.FilterPresets;

// Production: info and above (excludes trace/debug)
var prodFilter = try FilterPresets.production(allocator);
defer prodFilter.deinit();

// Errors only: err and above
var error_filter = try FilterPresets.errorsOnly(allocator);
defer error_filter.deinit();

// Module-specific filter
var db_filter = try FilterPresets.moduleOnly(allocator, "database");
defer db_filter.deinit();
```

## Filter Rule Types

| Rule Type | Method | Description |
|-----------|--------|-------------|
| Min Level | `addMinLevel(level)` | Allow logs at or above level |
| Max Level | `addMaxLevel(level)` | Allow logs at or below level |
| Module Prefix | `addModulePrefix(prefix)` | Allow logs from matching modules |
| Message Contains | `addMessageFilter(str, action)` | Allow/deny based on content |

## Filter Actions

* **`.allow`** - Allow logs matching this rule
* **`.deny`** - Block logs matching this rule

## Combined Filtering

```zig
var filter = logly.Filter.init(allocator);
defer filter.deinit();

// Multiple rules: info level minimum, exclude password-related
try filter.addMinLevel(.info);
try filter.addMessageFilter("password", .deny);

logger.setFilter(&filter);
```

## Use Cases

* **Development**: No filter (show all logs)
* **Production**: Filter to warnings and above
* **Debugging**: Enable debug for specific modules only
* **Security**: Filter out PII-containing messages

## New Features (v0.1.8)

### Improved Regex Engine

The filter now supports a production-ready regex-like engine for `allowRegex` and `denyRegex` (see [Filtering Guide](/guide/filtering) for details).

### Batch Evaluation

```zig
var filter = logly.Filter.init(allocator);
defer filter.deinit();

// Add rules
try filter.addMinLevel(.warning);
try filter.addModulePrefix("database.", .allow);
try filter.addMessageFilter("password", .deny);

// Batch evaluation (more efficient for multiple records)
var results: [100]bool = undefined;
filter.shouldLogBatch(&records, &results);

// Fast path check
if (filter.allowsAll()) {
   // No rules, skip evaluation
}

// Statistics
const allowed = filter.allowedCount();
const denied = filter.deniedCount();
const total = filter.totalProcessed();
filter.resetStats();

// State
const count = filter.count();  // Number of rules
const has = filter.hasRules();
const empty = filter.isEmpty();

// Disable filter
filter.disable();
```

## Aliases

| Alias | Method |
|-------|--------|
| `check` | `shouldLog` |
| `evaluate` | `shouldLog` |
| `minLevel` | `addMinLevel` |
| `min` | `addMinLevel` |
| `maxLevel` | `addMaxLevel` |
| `max` | `addMaxLevel` |
| `moduleFilter` | `addModulePrefix` |
| `addPrefix` | `addModulePrefix` |
| `messageFilter` | `addMessageFilter` |
| `reset` | `clear` |
| `removeAll` | `clear` |
| `ruleCount` | `count` |
| `length` | `count` |

## See Also

* [Filtering Guide](/guide/filtering) - Detailed filtering documentation
* [Filter API](/api/filter) - Full API reference