file_collector/

file_collector.rs

//! Example usage of the data_hook crate with a file-based collector
//!
//! This example demonstrates how to implement a custom collector that writes
//! data to files and how to use the data_hook! macro.

use data_hook::{data_hook, set_collector, Collect, Record};
use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{BufWriter, Write};
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use std::thread;
use std::time::Duration;

/// A file-based collector that writes data to files in a directory
pub struct FileCollector {
    output_dir: PathBuf,
    writers: Mutex<HashMap<String, BufWriter<File>>>,
}

impl FileCollector {
    /// Create a new file collector that writes to the specified directory
    pub fn new<P: AsRef<Path>>(output_dir: P) -> std::io::Result<Self> {
        let output_dir = output_dir.as_ref().to_path_buf();
        
        // Create the output directory if it doesn't exist
        if !output_dir.exists() {
            std::fs::create_dir_all(&output_dir)?;
        }
        
        Ok(Self {
            output_dir,
            writers: Mutex::new(HashMap::new()),
        })
    }
    
    /// Get or create a writer for a specific category
    fn get_or_create_writer(&self, category: &str) -> std::io::Result<()> {
        let mut writers = self.writers.lock().unwrap();
        
        if !writers.contains_key(category) {
            let file_path = self.output_dir.join(format!("{}.jsonl", category));
            let file = OpenOptions::new()
                .create(true)
                .append(true)
                .open(file_path)?;
            let writer = BufWriter::new(file);
            writers.insert(category.to_string(), writer);
        }
        
        Ok(())
    }
}

impl Collect for FileCollector {
    fn collect(&self, record: &Record) {
        if let Err(e) = self.get_or_create_writer(&record.category) {
            eprintln!("Failed to create writer for category {}: {}", record.category, e);
            return;
        }

        let mut writers = self.writers.lock().unwrap();
        if let Some(writer) = writers.get_mut(&record.category) {
            // Write as JSON Lines format
            let json_line = format!(
                r#"{{"category":"{}","data":"{}"}}"#,
                record.category,
                record.data.replace('"', r#"\""#).replace('\n', r#"\n"#)
            );

            if let Err(e) = writeln!(writer, "{}", json_line) {
                eprintln!("Failed to write data record: {}", e);
            }
        }
    }
    
    fn flush(&self) {
        let mut writers = self.writers.lock().unwrap();
        for writer in writers.values_mut() {
            let _ = writer.flush();
        }
    }
}

impl Drop for FileCollector {
    fn drop(&mut self) {
        self.flush();
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Data Hook Example with File Collector");
    println!("=====================================");
    
    // Create and set up the file collector
    let collector = FileCollector::new("data_output")?;
    let collector: &'static FileCollector = Box::leak(Box::new(collector));
    set_collector(collector);
    
    println!("Initialized file collector. Data will be saved to 'data_output' directory.");
    
    // Simulate some application events
    simulate_user_actions();
    simulate_performance_metrics();
    simulate_error_events();
    
    // Flush any remaining data
    collector.flush();
    
    println!("\nExample completed! Check the 'data_output' directory for collected data files:");
    println!("- user_action.jsonl - User interaction events");
    println!("- performance.jsonl - Performance metrics");
    println!("- error.jsonl - Error events");
    
    Ok(())
}

fn simulate_user_actions() {
    println!("\n--- Simulating User Actions ---");
    
    // Simple data collection
    data_hook!("user_action", "User opened application");
    
    // Data collection with formatting
    let user_id = 12345;
    data_hook!("user_action", "User {} logged in", user_id);
    
    // Simulate button clicks
    for i in 1..=3 {
        data_hook!("user_action", "User clicked button: submit_{}", i);
        thread::sleep(Duration::from_millis(100));
    }
    
    // Navigation events
    data_hook!("user_action", "User navigated to page: {}", "/dashboard");
    data_hook!("user_action", "User navigated to page: {}", "/profile");
    
    println!("Collected {} user action events", 6);
}

fn simulate_performance_metrics() {
    println!("\n--- Simulating Performance Metrics ---");
    
    // API response times
    let response_times = [45, 123, 67, 234, 89];
    for (i, time) in response_times.iter().enumerate() {
        data_hook!("performance", "API request {} took {} ms", i + 1, time);
        thread::sleep(Duration::from_millis(50));
    }
    
    // Memory usage
    data_hook!("performance", "Memory usage: {} MB", 256);
    data_hook!("performance", "CPU usage: {}%", 15.7);
    
    // Database query performance
    data_hook!("performance", "Database query executed in {} ms: {}", 89, "SELECT * FROM users");
    
    println!("Collected {} performance metrics", 8);
}

fn simulate_error_events() {
    println!("\n--- Simulating Error Events ---");
    
    // Network errors
    data_hook!("error", "Network timeout: Failed to connect to {}", "api.example.com");
    
    // Validation errors
    data_hook!("error", "Validation failed: {} field is required", "email");
    
    // System errors
    data_hook!("error", "File not found: {}", "/path/to/config.json");
    
    // Custom error with context
    let error_code = 500;
    let error_msg = "Internal server error";
    data_hook!("error", "HTTP {} - {}: Request failed for endpoint /api/users", error_code, error_msg);
    
    println!("Collected {} error events", 4);
}

// Example of using data_hook in different modules
mod user_service {
    use data_hook::data_hook;
    
    pub fn create_user(username: &str) {
        // Simulate user creation logic
        data_hook!("user_action", "Creating user: {}", username);
        
        // Simulate some processing time
        std::thread::sleep(std::time::Duration::from_millis(10));
        
        data_hook!("user_action", "User created successfully: {}", username);
    }
    
    pub fn delete_user(user_id: u32) {
        data_hook!("user_action", "Deleting user with ID: {}", user_id);
        
        // Simulate deletion
        std::thread::sleep(std::time::Duration::from_millis(5));
        
        data_hook!("user_action", "User {} deleted", user_id);
    }
}