fake-log 0.1.0

A fake logging implementation with the same interface as log crate but with no-op implementation for embedded scenarios
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

# fake-log

A fake logging library that provides the same interface as Rust's `log` crate but with no-op implementations. Designed specifically for embedded scenarios where reducing memory footprint is critical.

### Features

- 🚀 **Zero Overhead**: All logging macros are optimized away at compile time
- 📦 **Full Compatibility**: Provides exactly the same API as the `log` crate
- 🔧 **No Dependencies**: Supports `no_std` environments with minimal dependencies
- âš¡ **Compile-time Optimization**: Supports compile-time log level filtering
- 🎯 **Embedded Friendly**: Designed specifically for embedded and resource-constrained environments

### Use Cases

- Embedded systems where memory usage needs to be minimized
- Production environments where logging should be completely disabled
- Testing environments where log output would be distracting
- Library development with optional logging support

### Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
fake-log = "0.1"
```

### Basic Usage

#### Drop-in Replacement for log crate

If your project already uses the `log` crate, you can quickly replace it:

```toml
[dependencies]
# log = "0.4"  # Comment out the original log dependency
fake-log = { version = "0.1", package = "log" }  # Use fake-log as replacement
```

Your existing code requires no changes.

#### Direct Usage

```rust
extern crate fake_log as log;

fn main() {
    // These calls produce no output and allocate no memory
    log::info!("Application started");
    log::debug!("Debug info: {}", 42);
    log::error!("Error message");
    log::warn!("Warning message");
    log::trace!("Trace message");
    
    // Support for target parameter
    log::info!(target: "my_module", "Module-specific log");
}
```


### Comparison with log crate

| Feature | log crate | fake-log |
|---------|-----------|----------|
| Runtime overhead | Small overhead | Zero overhead |
| Memory allocation | May allocate | Zero allocation |
| Binary size | Slightly larger | Minimal |
| Configuration complexity | Requires Logger setup | No configuration needed |
| Embedded support | Good | Excellent |

### Examples

See complete examples in the `examples/` directory:

```bash
cargo run --example basic
cargo run --example no_std
cargo run --example custom_logger
```

### no_std Support

fake-log fully supports `no_std` environments:

```rust
#![no_std]

use fake_log::{info, error};

fn embedded_function() {
    info!("Running in no_std environment");
    error!("Error handling");
}
```

fake-log should perform best in all scenarios since it does nothing.

### License

This project is licensed under MIT OR Apache-2.0, consistent with the Rust ecosystem.

### Contributing

Issues and pull requests are welcome!

### FAQ

**Q: Why do I need fake-log?**
A: In embedded systems, even the lightest logging libraries can consume precious stack memory resources. fake-log provides a completely zero-overhead solution.

**Q: Can I switch to real logging at runtime?**
A: No. fake-log is designed for compile-time optimization, and all log calls are removed at compile time.

**Q: How can I use real logging during development and fake-log in production?**
A: You can use Cargo features and conditional compilation to achieve this switching.

### Related Projects

- [log](https://crates.io/crates/log) - Rust's standard logging facade
- [env_logger](https://crates.io/crates/env_logger) - Environment variable configured logger
- [slog](https://crates.io/crates/slog) - Structured logging library