Sinobu

Sinobu provides a minimalist, high-performance logging library designed with an emphasis on garbage-less operation and zero-boilerplate code. It is especially well-suited for high-throughput applications where every microsecond and memory allocation matters.

🚀 No Boilerplate

Logging is as simple as calling a static method like I#info(Object). Therefore, there’s no need to create logger instances per class. This approach dramatically reduces code clutter and eliminates repetitive logger setup.

void log() {
    I.info("Hello Logging");
}

♻️ Garbage Less

Many logging libraries create temporary objects (log events, strings, byte arrays, etc.) each time they output logs, causing GC latency; Sinobu tackles this problem head on and does not create new objects unless you explicitly request stack trace.

⚡ High Performance

Sinobu is engineered for speed. Its optimized encoding, buffer reuse, and minimal synchronization mean it can outperform many mainstream logging libraries. Even under heavy logging loads, it maintains consistent performance with minimal CPU and memory impact. Check benchmark.

Logging is performed via static methods such as I#info(Object) or I#info(String, Object). These methods support various input types:

• Object - Use Object#toString() representation as message.
• Supplier - Delaying the construction of message avoids extra processing when the log level prevents writing.
• Throwable - A message and a stack trace back to the cause are written.

void basic() {
    I.trace("Write your message");
}

void lazyEvaluation() {
    I.debug(() -> "Delaying the construction of message.");
}

void throwable() {
    try {
        mayBeThrowError();
    } catch (Exception e) {
        I.error("Write message and stack trace");
        I.error(e);
    }
}

Most methods come in two forms:

• Without category - logs to the default system category.
• With category - the first argument specifies the log category, allowing fine-grained control.

void categorized() {
    I.debug("Write message in system category");
    I.warn("database", "Write message in database category");
}

Logging behavior can be configured via environment variables (I#env(String) Configuration keys follow a specific pattern to allow both fine-grained and global control.

Resolution Order

When any environment variable is required, configuration values are resolved in the following order:

1. Look for category.property (e.g. system.file)
2. If not found, look for *.property (e.g. *.file)
3. If still not found, use the built-in default (e.g. Level#WARNING)