Struct Builder 

pub struct Builder { /* private fields */ }

日志构建器

Implementations

impl Builder

pub fn new() -> Self

Examples found in repository

examples/quickwit_example.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn validate(&self) -> LogResult<()>

验证配置的有效性

pub fn builder(self) -> LogResult<()>

Examples found in repository

examples/quickwit_example.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn level(self, level: LevelFilter) -> Self

Examples found in repository

examples/quickwit_example.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn log_file(self, log_file: String) -> Self

Examples found in repository

examples/quickwit_example.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn log_file_max(self, log_file_max: u32) -> Self

Examples found in repository

examples/quickwit_example.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn use_console(self, use_console: bool) -> Self

Examples found in repository

examples/quickwit_example.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn use_async(self, use_async: bool) -> Self

pub fn level_str(self, level: &str) -> LogResult<Self>

pub fn log_file_max_str(self, log_file_max: &str) -> LogResult<Self>

pub fn plugin<T: Write + Send + Sync + 'static>(self, plugin: T) -> Self

pub fn filter(self, filter: impl CustomFilter) -> Self

pub fn show_process_id(self, show: bool) -> Self

设置是否显示进程ID

pub fn show_thread_info(self, show: bool) -> Self

设置是否显示线程信息

pub fn show_module_path(self, show: bool) -> Self

设置是否显示模块路径

pub fn highlight_keywords(self, keywords: Vec<String>) -> Self

设置需要高亮显示的关键词

pub fn add_highlight_keyword(self, keyword: String) -> Self

添加单个关键词到高亮列表

pub fn quickwit(self, config: QuickwitConfig) -> Self

设置 Quickwit 配置

Examples found in repository

examples/quickwit_example.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 配置 Quickwit（带 token 认证）
    let quickwit_config =
        QuickwitConfig::new("http://localhost:7280".to_string(), "log_full".to_string())
            .with_timeout(30)
            .with_batch_size(50); // 可选的认证 token

    // 使用 Builder 配置日志器，包含 Quickwit 功能
    Builder::new()
        .level(log::LevelFilter::Info)
        .use_console(true)
        .log_file("logs/quickwit_example.log".to_string())
        .log_file_max(10 * 1024 * 1024) // 10MB
        .quickwit(quickwit_config)
        .builder()?;

    loop {
        // 记录一些测试日志
        info!("这是一条信息日志，将被发送到 Quickwit");
        warn!("这是一条警告日志，包含关键信息: user_id=12345");
        error!("这是一条错误日志，错误代码: E001");

        // 记录带有结构化数据的日志
        info!(
            "用户登录成功: user={}, ip={}, timestamp={}",
            "alice",
            "192.168.1.100",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_secs()
        );

        println!("日志已记录并发送到 Quickwit（如果配置正确）");
        println!("请检查 Quickwit 索引 'log_full' 中的日志条目");

        // 确保所有异步日志都被处理
        log::logger().flush();
        std::thread::sleep(std::time::Duration::from_millis(1000));

        println!("所有日志处理完成");
        thread::sleep(time::Duration::from_secs(3));
    }

    // Ok(())
}

pub fn quickwit_simple(self, url: String, index_id: String) -> Self

设置 Quickwit URL 和索引 ID

pub fn disable_quickwit(self) -> Self

禁用 Quickwit

Trait Implementations

impl Default for Builder

fn default() -> Self

Returns the “default value” for a type.