Scheduler Example

This example demonstrates automatic log maintenance using Logly's scheduler.

Centralized Configuration

const logly = @import("logly");

var config = logly.Config.default();
config.scheduler = logly.SchedulerConfig{
    .maxTasks = 512,
    .timer_resolution_ms = 10,
    .thread_pool_size = 4,
    .enable_persistence = true,
    .persistence_path = "scheduler.state",
};

// Or use helper method
var config2 = logly.Config.default().withScheduler(.{
    .maxTasks = 256,
    .timer_resolution_ms = 50,
});

Source Code

//! Scheduler Example
//!
//! Demonstrates scheduled log maintenance tasks.

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

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

    // 1. Basic Scheduler Setup
    const scheduler = try logly.Scheduler.init(allocator);
    defer scheduler.deinit();

    // 2. Add interval-based cleanup task
    const cleanupIdx = try scheduler.addTask(
        "log_cleanup",
        .cleanup,
        .{ .interval = 3600000 },
        .{
            .path = "logs",
            .maxAgeSeconds = 7 * 24 * 60 * 60,
            .filePattern = "*.log",
        },
    );

    // 3. Add compression task with cron-like preset
    const compIdx = try scheduler.addTask(
        "log_compression",
        .compression,
        logly.SchedulerPresets.dailyAt(3, 0),
        .{
            .path = "logs",
            .filePattern = "*.log",
        },
    );
    _ = compIdx;

    // 4. Add one-shot custom task
    const OneShotTask = struct {
        fn execute(_: *logly.Scheduler.ScheduledTask) anyerror!void {
            std.debug.print("Maintenance task executed!\n", .{});
        }
    };
    _ = try scheduler.addCustomTask("oneshot_task", .{ .interval = 1 }, OneShotTask.execute);

    // 5. Task management and control
    scheduler.setTaskEnabled(cleanupIdx, false); // Cancel / disable
    scheduler.setTaskEnabled(cleanupIdx, true);  // Re-enable

    // 6. Inspect registered tasks
    const tasks = scheduler.getTasks();
    for (tasks, 0..) |task, i| {
        std.debug.print("Task {d}: '{s}' type={s} enabled={s}\n", .{
            i,
            task.name,
            @tagName(task.taskType),
            if (task.enabled) "yes" else "no",
        });
    }

    // 7. Check statistics
    const stats = scheduler.getStats();
    std.debug.print("Tasks executed: {d}, Files cleaned: {d}\n", .{
        stats.getExecuted(),
        stats.getFilesCleaned(),
    });
}

Running the Example

zig build run-scheduler-demo

Expected Output

Task 0: log_cleanup (cleanup)
Task 1: log_compression (compression)

Key Concepts

Schedule Types

// Fixed interval
.schedule = logly.Schedule.interval(60), // Every 60 seconds

// Daily at specific time
.schedule = logly.Schedule.daily(2, 30), // 2:30 AM

// Weekly
.schedule = logly.Schedule.weekly(0, 3, 0), // Sunday 3 AM

// Convenience methods
.schedule = logly.Schedule.everyMinutes(5),
.schedule = logly.Schedule.everyHours(1),

Task Types

.taskType = .cleanup,      // Remove old logs
.taskType = .compression,  // Compress logs
.taskType = .rotation,     // Force rotation
.taskType = .custom,       // Custom function
.taskType = .flush,        // Flush buffers
.taskType = .healthCheck, // Health check

Cleanup Configuration

.config = .{ .cleanup = .{
    .path = "logs",
    .maxAgeDays = 30,
    .pattern = "*.log",
    .include_compressed = true,
    .min_files_to_keep = 5,
}},

Compression Configuration

.config = .{ .compression = .{
    .path = "logs",
    .pattern = "*.log",
    .minAgeDays = 1,
    .delete_originals = true,
}},

Compression Modes

// Mode 1: Compress then delete original
.config = .{
    .path = "logs",
    .filePattern = "*.log",
    .compressBeforeDelete = true,
    .skipAlreadyCompressed = true,
},

// Mode 2: Compress and keep both versions
.config = .{
    .path = "logs",
    .filePattern = "*.log",
    .compressAndKeep = true,
    .skipAlreadyCompressed = true,
},

// Mode 3: Only compress, never delete
.config = .{
    .path = "logs",
    .filePattern = "*.log",
    .compressOnly = true,
    .skipAlreadyCompressed = true,
},

Using Presets

// Daily cleanup at 2 AM
 _ = try scheduler.addTask(
    logly.SchedulerPresets.dailyCleanup("logs"),
);

// Hourly compression
 _ = try scheduler.addTask(
    logly.SchedulerPresets.hourlyCompression("logs"),
);

// Weekly deep clean
 _ = try scheduler.addTask(
    logly.SchedulerPresets.weeklyDeepClean("logs"),
);

Compression Presets

const Presets = logly.SchedulerPresets;

// Compress files older than 7 days, then delete originals
const archive = Presets.compressThenDelete("logs", 7);

// Compress files older than 3 days, keep both versions
const backup = Presets.compressAndKeep("logs", 3);

// Only compress, never delete anything
const pure_archive = Presets.compressOnly("logs", 1);

// Archive: compress after 7 days, delete after 30 days
const tiered = Presets.archiveOldLogs("logs", 7, 30);

// Aggressive: compress & delete, max 100 files
const aggressive = Presets.aggressiveCleanup("logs", 30, 100);

Task Management

// Disable a task
scheduler.disableTask(0);

// Enable a task
scheduler.enableTask(0);

// Run immediately
try scheduler.runTaskNow(0);

// Remove a task
try scheduler.removeTask(0);

Statistics

const stats = scheduler.getStats();
std.debug.print("Tasks executed: {d}\n", .{
    stats.getExecuted(),
});
std.debug.print("Files cleaned: {d}\n", .{
    stats.getFilesCleaned(),
});
std.debug.print("Bytes freed: {d}\n", .{
    stats.getBytesFreed(),
});

See Also

• Scheduler API
• Scheduler Guide
• Compression Example

New Presets (v0.0.9)

const SchedulerPresets = logly.SchedulerPresets;

// Every N minutes presets
var every_5 = SchedulerPresets.every5Minutes();
var every_15 = SchedulerPresets.every15Minutes();
var every_30 = SchedulerPresets.every30Minutes();

// Hourly presets
var every_hour = SchedulerPresets.everyHour();
var every_6 = SchedulerPresets.every6Hours();
var every_12 = SchedulerPresets.every12Hours();

// Daily presets
var midnight = SchedulerPresets.dailyMidnight();
var maintenance = SchedulerPresets.dailyMaintenance();  // 2 AM
var at_time = SchedulerPresets.dailyAt(9, 30);  // 9:30 AM

// Task configs
var cleanup = SchedulerPresets.dailyCleanup("logs", 30);
var compress = SchedulerPresets.hourlyCompression("logs");
var weekly = SchedulerPresets.weeklyCleanupConfig("logs", 90);

Aliases

Alias	Method
begin	start
end	stop
halt	stop
statistics	getStats