BqLog (BianQue Log) V 2.3.0

English | 简体中文

[]() []()

BqLog is a lightweight, high-performance, industrial-grade logging system that has been widely used in online projects such as "Honor of Kings". BqLog 2.x is officially released! With native HarmonyOS NEXT, Python and Node.js support, and asymmetric hybrid encryption.

🚀 In Benchmarks, BqLog's compressed log mode is 2–3x faster than fmtlog, 3–6x faster than quill, 3–16x faster than spdlog, 10–12x faster than Log4j2, and 25–60x faster than glog; plain text mode also outperforms all of them.

📋 What's New in v2.3.0

• OpenHarmony compatibility — Replaced 0n BigInt literals with BigInt(0) in the TypeScript wrapper. The same bqlog package on ohpm now works on OpenHarmony 4.1+ (API 11+) as well as HarmonyOS NEXT.
• Recovery hardening — Strengthened data validation during recovery to detect malformed entries earlier and avoid potential crashes when consuming a corrupted ring buffer.

Full changelog → CHANGELOG.md

💡 If you have the following pain points, try BqLog

• If your client product (especially games) wants to satisfy this "impossible triangle" at the same time:
  • Easy troubleshooting (log as much as possible)
  • Good performance (log as little as possible)
  • Save storage space (better not log at all)
• If you are a backend service developer and your current logging library cannot handle high-concurrency scenarios, causing log loss or application stalls.
• If your programming language is one of C++, Java, C#, Kotlin, TypeScript, JavaScript, Python, or you use multiple languages at the same time and want a unified cross-language logging solution.

✨ Highlights

• Significant performance advantage over common open-source logging libraries (see Benchmark); suitable for server, client, and mobile.
• Low memory usage: in the Benchmark case (10 threads, 20,000,000 log entries), BqLog itself uses about 2-3 MB of memory. And in mobile platform scenarios, it's generally around 1 MB.
• Provides a high-performance, high-compression real-time compressed log format.
• Supports strong hybrid encryption (asymmetric + symmetric) for log content protection with nearly zero performance overhead (optional).
• Works well inside game engines (Unity, Unreal, etc.), with UE Blueprint and builtin data type support.
• Supports utf8, utf16, utf32 characters and strings, as well as bool, float, double, and integer types of various sizes.
• Supports C++20 std::format style format strings (without positional index and time formatting).
• Asynchronous logging supports crash recovery and tries to avoid data loss.
• On Java, C#, TypeScript wrappers, it can achieve "zero extra heap alloc" (or very close), avoiding continuous object allocations.
• Depends only on the standard C library and platform APIs; can be compiled with Android ANDROID_STL = none.
• Supports C++11 and later standards and works under very strict compiler options.
• Build system is based on CMake and provides multi-platform scripts, easy to integrate.
• Supports custom parameter types.
• Very friendly for code completion and IDE hints.

🖥️ Supported platforms & languages

Hardware architectures: x86, x86_64, ARM32, ARM64 Integration methods: Dynamic library, Static library, Source code

🏗️ Architecture

Your program accesses the core engine through BqLog Wrapper (C++, Java, C#, TypeScript, Python, etc.). Each Log object can mount one or more Appenders (Console / Text File / Compressed File). Within the same process, Wrappers of different languages can access the same Log object.

🚀 Quick Start

Before calling any API, you need to integrate BqLog into your project first:

• Standard environments (C++, Java, C#, Python, Node.js, etc.) → Integration Guide
• Game engines (Unity, Tuanjie Engine, Unreal Engine) → Game Engine Integration Guide

C++

#include <string>
#include <bq_log/bq_log.h>

int main() {
    std::string config = R"(
        appenders_config.appender_console.type=console
        appenders_config.appender_console.levels=[all]
    )";
    auto log = bq::log::create_log("main_log", config);
    log.info("Hello BqLog 2.0! int:{}, float:{}", 123, 3.14f);
    log.force_flush();
    return 0;
}

Java

String config = """
    appenders_config.console.type=console
    appenders_config.console.levels=[all]
""";
bq.log.Log log = bq.log.Log.createLog("java_log", config);
log.info("Hello Java! value: {}", 3.14);

C

string config = @"
    appenders_config.console.type=console
    appenders_config.console.levels=[all]
";
var log = bq.log.create_log("cs_log", config);
log.info("Hello C#! value:{}", 42);

TypeScript (Node.js)

import { bq } from "@pippocao/bqlog";
const config = `
    appenders_config.console.type=console
    appenders_config.console.levels=[all]
`;
const log = bq.log.create_log("node_log", config);
log.info("Hello from Node.js! params: {}, {}", "text", 123);
bq.log.force_flush_all_logs();

Python

from bq.log import log
config = """
    appenders_config.console.type=console
    appenders_config.console.levels=[all]
"""
my_log = log.create_log("python_log", config)
my_log.info("Hello from Python! params: {}, {}", "text", 123)
log.force_flush_all_logs()

TypeScript (HarmonyOS / OpenHarmony ArkTS)

The same bqlog package on ohpm works for both HarmonyOS (NEXT) and OpenHarmony (4.1+ / API 11+). Same install, same import, same code.

import { bq } from "bqlog";
const config = `
    appenders_config.console.type=console
    appenders_config.console.levels=[all]
`;
const log = bq.log.create_log("ohos_log", config);
log.info("Hello from HarmonyOS / OpenHarmony! params: {}, {}", "text", 123);
bq.log.force_flush_all_logs();

For full integration steps for all platforms, see Integration Guide and Game Engine Integration Guide.

📊 Benchmark results

Test: 1–10 threads, each writing 2,000,000 log entries. Environment: MacBook Pro, Apple M4 Pro (14-core: 10P + 4E), 48 GB, macOS.

Comparison: BqLog (Text / Compress / Compress+Encrypt) vs spdlog 1.17.0, glog 0.7.1, fmtlog, quill 11.1.0, Log4j2 2.23.1.

Throughput — Total Time Cost with 4 parameters (ms)

Peak Memory Usage (MB)

Output File Size (1 thread, 4M log entries)

• BqLog Compress: 2–3x faster than fmtlog, 3–16x than spdlog, 25–60x than glog
• Encryption adds near-zero overhead
• Compressed format is 6.7x smaller than text
• BqLog uses only 2.7–4.4 MB memory across all modes and thread counts

For full benchmark code, methodology, and feature comparison, see Benchmark.

🔄 Changes from 1.x to 2.x

1. Added HarmonyOS support, including ArkTS and C++.
2. Added Node.js support (CJS and ESM).
3. Improved cross-platform compatibility, stability and generality; supports more Unix systems.
4. Average performance improved by ~80% for UTF-8, and by >500% for UTF-16 environments (C#, Unreal, Unity).
5. Android no longer must be used together with Java.
6. Removed the is_in_sandbox config and replaced it with base_dir_type; added filters for snapshots and support for opening a new log file on each startup. See Configuration.
7. Added high-performance hybrid asymmetric encryption, almost zero overhead; see Advanced Usage — Encryption.
8. Provides Unity, Tuanjie Engine, and Unreal Engine plugins, making it easy to use in game engines; the Unreal plugin is also published on Fab (UE4 & UE5), with ConsoleAppender redirection to game-engine editors and Blueprint support for Unreal. See Game Engine Integration Guide.
9. The repository no longer ships binaries. From 2.x on, please download platform- and language-specific packages from the Releases page.
10. The size of a single log entry is not limited by log.buffer_size anymore;
11. The timezone can be specified manually.
12. The raw_file appender is deprecated and no longer maintained in 2.x; please use the compressed_file appender instead.
13. The Recovery feature's reliability has been improved and it has been promoted from experimental (beta) to stable (release). see Advanced Usage — Data Protection.

📑 Documentation

🤝 How to contribute

If you want to contribute code, please make sure your changes can pass the following workflows under GitHub Actions in the repository:

• AutoTest
• Build

It is recommended to run corresponding scripts locally before submitting to ensure both testing and building pass normally.