Adding `cleverlib` library as a dependency

Run this command in a terminal, in your project's directory:

cargo add cleverlib

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

cleverlib = "0.2.0"

The cleverlib library will be automatically available globally. Read the cleverlib library documentation.

Back to the crate overview.

Readme

CleverLib

A flexible Rust library for processing and analyzing log events with parallel and serial processing strategies.

Features

Multiple event processing strategies
- Serial processing
- Parallel processing
Efficient log event parsing
Automatic log level detection
Simple and intuitive API

Basic Usage

use cleverlib::event_collection::EventCollection;
use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() {
    // Read log file lines
    let file: File = File::open("events.log").expect("Failed to open log file");
    let lines: Vec<String> = BufReader::new(file)
        .lines()
        .collect::<Result<Vec<String>, std::io::Error>>()
        .expect("Failed to read lines");

    // Create event collection
    let event_collection: EventCollection = EventCollection::create(&lines).unwrap();

    // Print detected log levels
    println!("Log Levels: {:?}", event_collection.log_levels);

    // Filter events by log level
    let error_events: Vec<&Event> = event_collection.filter_log_level("error");
    println!("Error Events: {}", error_events.len());
}

Parallel Processing

use cleverlib::event_collection::EventCollection;
use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() {
    let file: File = File::open("large_events.log").expect("Failed to open log file");
    let lines: Vec<String> = BufReader::new(file)
        .lines()
        .collect::<Result<Vec<String>, std::io::Error>>()
        .expect("Failed to read lines");

    // Use parallel processing for large log files
    let event_collection: EventCollection = EventCollection::create_par(&lines).unwrap();

    println!("Total Events: {}", event_collection.events.len());
    println!("Unique Log Levels: {:?}", event_collection.log_levels);
}

Performance Strategies

Serial Processing: create() - Best for smaller log files
Parallel Processing: create_par() - Recommended for large log files

Key Methods

create(&lines): Process events serially
create_par(&lines): Process events in parallel
filter_log_level(level): Filter events by log level
filter_log_level_par(level): Parallel log level filtering

Log Level Detection

The library automatically detects unique log levels during event processing. Detected levels are stored in event_collection.log_levels.

Dependencies

Requires Rayon for parallel processing
Uses Regex for log parsing

Contributing

Contributions welcome! Please submit pull requests or open issues on the project repository.

Adding cleverlib library as a dependency

Adding `cleverlib` library as a dependency