luhlog 0.0.4

A horrible Rust logging library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

# LuhLog

[<img alt="github" src="https://img.shields.io/badge/github-calizoots/luhlog-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/calizoots/luhlog)
[<img alt="crates.io" src="https://img.shields.io/crates/v/luhlog.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/luhlog)
[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-luhlog-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs" height="20">](https://docs.rs/luhlog)

A horrible way to log your messages. You would have to be sick to use this.
<br>
Please take care of your mental health >.<

> Made with love though s.c <3 2025. LKK FREE BINE

As a library, we expose:

- `luhtwin::Logger` and trait `luhtwin::Log` for creating custom loggers.
- `luhtwin::LogFormatter` for formatting logs.
- `luhtwin::Level` with 5 levels (Trace, Debug, Info, Warn, Error), similar to the `log` crate.
- Corresponding macros (`trace!`, `debug!`, `info!`, `warn!`, `error!`) for the global logger instance through `get_logger()`.

> This is still in development stages. Thank you for your patience.

We also provide `luhtwin::GlobalLogger` for creating your own global logger instance.

---

## Examples

### 1. Basic usage

```rust
use luhlog::{set_logger, Level, CompactFormatter, info, warn, trace};

fn main() {
    // Level sets the requirement: logs below this won't be logged
    // Formatter must implement LogFormatter
    set_logger!(level: Level::Info, formatter: CompactFormatter);

    info!("hello world");
    warn!(target: "main", "targeting main <3");

    // Won't be printed because it's below the Level::Info threshold
    trace!("bine");
}
```

### 2. Using a logger directly

```rust
use luhlog::{set_logger, get_logger, Level, LogBuilder, Logger, CompactFormatter};

fn main() {
    set_logger!(level: Level::Trace);

    let logger = get_logger();

    let other_logger = Logger::with_formatter(
        Level::Info,
        std::sync::Arc::new(CompactFormatter)
    ).no_stdout().file("test.log").expect("failed to open test.log");

    // log directly with a custom LogBuilder
    logger.log(
        LogBuilder::new("hello guys <3")
            .level(Level::Trace)
            .build()
    );

    other_logger.log(
        LogBuilder::new("in the file >.<")
            .target("main")
            .level(Level::Warn)
            .location(file!(), line!())
            .build()
    );
}

```

### 3. Using GlobalLogger

```rust
use luhlog::{GlobalLogger, Log, Level, LogBuilder};

static LOG: GlobalLogger = GlobalLogger::new();

fn main() {
    LOG.get().log(
        LogBuilder::new("test for GlobalLogger :3")
            .target("LOG")
            .level(Level::Info)
            .location(file!(), line!())
            .build()
    );
}
```

### 4. Custom formatters

```rust
use luhlog::{set_logger, Level, Logger, LogBuilder};
use std::sync::Arc;

#[derive(Debug)]
struct MyFormatter;

impl luhtwin::LogFormatter for MyFormatter {
    fn format(&self, record: &luhtwin::LogRecord) -> String {
        format!(">>> {} <<<", record.msg)
    }
}

fn main() {
    let logger = Logger::with_formatter(Level::Info, Arc::new(MyFormatter));
    set_logger!(logger);

    luhtwin::info!("custom format");
}
```

### 5. No stdout

```rust
use luhlog::{set_logger, Level, Logger, info};

fn main() {
    let logger = Logger::new(Level::Info).no_stdout();
    set_logger!(logger);

    info!("this won't print to stdout");
}
```