Filtering Example

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

Basic Filtering

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

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    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

// 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 db_logger = logger.scoped("database");
try db_logger.info("This will appear", @src());     // Module matches

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

Message Content Filtering

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

const FilterPresets = logly.FilterPresets;

// Production: info and above (excludes trace/debug)
var prod_filter = try FilterPresets.production(allocator);
defer prod_filter.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

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