@pippocao/bqlog 2.2.1

package/README.md

@@ -0,0 +1,185 @@
+# @pippocao/bqlog
+
+> **The fastest industrial-grade logging engine** for Node.js — powered by a native C++ lock-free ring-buffer core, battle-tested at Tencent across large-scale game engines and backend services.
+
+[![npm version](https://img.shields.io/npm/v/@pippocao/bqlog)](https://www.npmjs.com/package/@pippocao/bqlog)
+[![license](https://img.shields.io/npm/l/@pippocao/bqlog)](https://www.apache.org/licenses/LICENSE-2.0)
+
+Part of the [BqLog](https://github.com/Tencent/BqLog) project.
+
+---
+
+## 🚀 Why BqLog?
+
+- ⚡ **Fastest in class** — lock-free MISO ring-buffer delivers ~80% higher throughput than comparable loggers for UTF-8, and >500% for UTF-16 environments
+- 🏭 **Industrial grade** — production-proven at Tencent, designed for game engines (Unity, Unreal), mobile apps, and high-concurrency server workloads
+- 🔐 **Compressed & Encrypted appender** — `compressed_file` produces the smallest log files with near-zero overhead, and supports **hybrid asymmetric encryption** (RSA + AES) for secure log storage at virtually no performance cost
+- 🔄 **Sync & Async modes** — choose per-log thread model to balance latency vs throughput
+- 🏷️ **Category logging** — attach categories to log entries, filter with category masks
+- 🛡️ **Crash-safe recovery** — memory-mapped buffers survive process crashes; unflushed logs are recovered on restart
+- 🌍 **Cross-platform native binaries** — prebuilt for Windows, macOS, Linux, FreeBSD, OpenBSD, NetBSD, DragonflyBSD, Solaris/OmniOS (x64 & ARM64)
+- 📦 **ESM + CommonJS** — dual module support, works everywhere
+
+---
+
+## 📥 Installation
+
+```bash
+npm install @pippocao/bqlog
+```
+
+---
+
+## ⚡ Quick Start
+
+### ESM
+
+```typescript
+import { bq } from "@pippocao/bqlog";
+
+const config = `
+    appenders_config.console.type=console
+    appenders_config.console.levels=[all]
+`;
+const log = bq.log.create_log("my_log", config);
+
+log.info("Hello BqLog! int:{}, float:{}", 123, 3.14);
+bq.log.force_flush_all_logs();
+```
+
+### CommonJS
+
+```javascript
+const { bq } = require("@pippocao/bqlog");
+
+const log = bq.log.create_log("my_log", `
+    appenders_config.console.type=console
+    appenders_config.console.levels=[all]
+`);
+log.info("Hello from CJS!");
+```
+
+---
+
+## 📋 Appender Types
+
+| Type | Description |
+|------|-------------|
+| `console` | 🖥️ Output to stdout/stderr |
+| `text_file` | 📄 Plain text log files, human-readable |
+| `compressed_file` | 🔒 **Binary compressed — smallest size, fastest writes, optional RSA+AES encryption.** Decode with the BqLog decoder tool. |
+
+---
+
+## 🔐 Compressed & Encrypted Appender
+
+The `compressed_file` appender is the **recommended choice for production**:
+
+- 📉 **Smallest output** — proprietary binary format produces files significantly smaller than plain text or gzip
+- ⚡ **Fastest writes** — compression is integrated into the write path with near-zero overhead
+- 🔑 **Hybrid encryption** — optional RSA + AES encryption protects log content at rest; encryption adds virtually no performance penalty
+
+```typescript
+const config = `
+    appenders_config.SecureFile.type=compressed_file
+    appenders_config.SecureFile.time_zone=localtime
+    appenders_config.SecureFile.levels=[all]
+    appenders_config.SecureFile.file_name=logs/secure
+    appenders_config.SecureFile.max_file_size=100000000
+    appenders_config.SecureFile.expire_time_days=30
+
+    # Optional: enable encryption (provide RSA public key)
+    # appenders_config.SecureFile.pub_key=your_rsa_public_key_here
+
+    log.thread_mode=async
+`;
+const log = bq.log.create_log("secure_log", config);
+log.info("This log is compressed and optionally encrypted");
+```
+
+---
+
+## ⚙️ Configuration Example
+
+```typescript
+const config = `
+    appenders_config.ConsoleAppender.type=console
+    appenders_config.ConsoleAppender.time_zone=localtime
+    appenders_config.ConsoleAppender.levels=[all]
+
+    appenders_config.FileAppender.type=compressed_file
+    appenders_config.FileAppender.time_zone=localtime
+    appenders_config.FileAppender.levels=[info,warning,error,fatal]
+    appenders_config.FileAppender.file_name=logs/app
+    appenders_config.FileAppender.max_file_size=100000000
+    appenders_config.FileAppender.expire_time_days=7
+
+    log.thread_mode=async
+`;
+const log = bq.log.create_log("app", config);
+```
+
+---
+
+## 🏷️ Category Logging
+
+Use the [BqLog Category Generator](https://github.com/Tencent/BqLog/tree/main/tools/category_log_generator) tool to generate type-safe category wrappers:
+
+```typescript
+import { my_category_log } from "./my_category_log";
+
+const log = my_category_log.create_log("cat_log", config);
+log.info(log.cat.ModuleA.SystemA, "categorized message: {}", value);
+```
+
+---
+
+## 📊 Log Levels
+
+| Level | Usage |
+|-------|-------|
+| `verbose` | Fine-grained tracing |
+| `debug` | Debugging information |
+| `info` | General operational messages |
+| `warning` | Potential issues |
+| `error` | Error conditions |
+| `fatal` | Critical failures |
+
+---
+
+## 🌍 Supported Platforms
+
+Prebuilt native binaries are included — **no compiler needed** at install time.
+
+| OS | Architectures |
+|----|--------------|
+| 🪟 Windows | x64, ARM64 |
+| 🍎 macOS | x64, ARM64 (Universal Binary) |
+| 🐧 Linux | x64, ARM64, x86 (ia32) |
+| 😈 FreeBSD | x64, ARM64 |
+| 🐡 OpenBSD | x64, ARM64 |
+| 🏁 NetBSD | x64, ARM64 |
+| 🐉 DragonflyBSD | x64 |
+| ☀️ Solaris / OmniOS (SunOS) | x64 |
+
+---
+
+## 📈 Benchmark
+
+BqLog consistently outperforms popular logging libraries. See [full benchmark results](https://github.com/Tencent/BqLog#benchmark) in the main repository.
+
+---
+
+## 📚 Documentation
+
+Full documentation and examples for all supported languages:
+
+**C++ · Java · C# · Python · TypeScript · Unreal Engine · Unity · HarmonyOS**
+
+👉 **[github.com/Tencent/BqLog](https://github.com/Tencent/BqLog)**
+
+---
+
+## 📄 License
+
+[Apache-2.0](https://www.apache.org/licenses/LICENSE-2.0) — free for commercial use.

package/dist/cjs/bq/category_log.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.category_log = void 0;
+/*
+ * Copyright (C) 2025 Tencent.
+ * BQLOG is licensed under the Apache License, Version 2.0.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
+const log_1 = require("./log");
+const log_invoker_1 = require("./impl/log_invoker");
+class category_log extends log_1.log {
+    constructor(arg) {
+        super(arg);
+    }
+    /**
+     * Get log categories count
+     * @return
+     */
+    get_categories_count() {
+        return this.categories_name_array_.length;
+    }
+    /**
+     * Get names of all categories
+     * @return
+     */
+    get_categories_name_array() {
+        return this.categories_name_array_;
+    }
+    /**
+     * Create a category log
+     * @param name
+     *          If the log name is an empty string, bqLog will automatically assign you a unique log name.
+     * 			If the log name already exists, it will return the previously existing log object and overwrite the previous configuration with the new config.
+     * @param config
+     * 			Log config string
+     * @param categories_count
+     * @param categories
+     * @returns
+     * 			A log id, if create failed, 0 will be returned
+     */
+    static call_api_create_category_log(name, config, categories_count, categories) {
+        if (!config || config.length == 0) {
+            return 0n;
+        }
+        let log_handle = log_invoker_1.log_invoker.__api_create_log(name, config, categories_count, categories);
+        return log_handle;
+    }
+}
+exports.category_log = category_log;

package/dist/cjs/bq/def/log_category_base.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Copyright (C) 2025 Tencent.
+ * BQLOG is licensed under the Apache License, Version 2.0.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log_category_base = void 0;
+const log_invoker_1 = require("../impl/log_invoker");
+class log_category_base {
+    constructor(index) {
+        this.index = 0;
+        this.index = index;
+        log_invoker_1.log_invoker.__api_attach_category_base_inst(this);
+    }
+}
+exports.log_category_base = log_category_base;

package/dist/cjs/bq/def/log_level.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Copyright (C) 2025 Tencent.
+ * BQLOG is licensed under the Apache License, Version 2.0.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log_level = void 0;
+var log_level;
+(function (log_level) {
+    log_level[log_level["verbose"] = 0] = "verbose";
+    log_level[log_level["debug"] = 1] = "debug";
+    log_level[log_level["info"] = 2] = "info";
+    log_level[log_level["warning"] = 3] = "warning";
+    log_level[log_level["error"] = 4] = "error";
+    log_level[log_level["fatal"] = 5] = "fatal";
+})(log_level || (exports.log_level = log_level = {}));

package/dist/cjs/bq/def/string_holder.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (C) 2025 Tencent.
+ * BQLOG is licensed under the Apache License, Version 2.0.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string_holder = void 0;
+class string_holder {
+}
+exports.string_holder = string_holder;

package/dist/cjs/bq/impl/log_invoker.js

@@ -0,0 +1,107 @@
+"use strict";
+/*
+ * Copyright (C) 2025 Tencent.
+ * BQLOG is licensed under the Apache License, Version 2.0.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log_invoker = void 0;
+// IMPORTANT: this is a build-alias file generated per build.
+// For ESM build it is a copy of lib_loader.esm.txt,
+// for CJS and OHOS build it is lib_loader.ts.
+const lib_loader_1 = require("../utils/lib_loader");
+function as_bigint(v, def = 0n) {
+    return typeof v === "bigint" ? v : def;
+}
+class log_invoker {
+    static __api_get_log_version() {
+        return (0, lib_loader_1.native_export)("get_log_version")();
+    }
+    static __api_enable_auto_crash_handler() {
+        (0, lib_loader_1.native_export)("enable_auto_crash_handler")();
+    }
+    static __api_create_log(log_name, config_content, category_count, category_names_array) {
+        const id = (0, lib_loader_1.native_export)("create_log")(log_name, config_content, category_count, category_names_array);
+        return as_bigint(id);
+    }
+    static __api_log_reset_config(log_name, config_content) {
+        (0, lib_loader_1.native_export)("log_reset_config")(log_name, config_content);
+    }
+    static __api_attach_log_inst(log_inst) {
+        return (0, lib_loader_1.native_export)("attach_log_inst")(log_inst, log_inst['log_id_']);
+    }
+    static __api_attach_category_base_inst(category_inst) {
+        return (0, lib_loader_1.native_export)("attach_category_base_inst")(category_inst, category_inst['index']);
+    }
+    static __api_set_appender_enable(log_id, appender_name, enable) {
+        (0, lib_loader_1.native_export)("set_appender_enable")(log_id, appender_name, !!enable);
+    }
+    static __api_get_logs_count() {
+        return (0, lib_loader_1.native_export)("get_logs_count")();
+    }
+    static __api_get_log_id_by_index(index) {
+        return as_bigint((0, lib_loader_1.native_export)("get_log_id_by_index")(index));
+    }
+    static __api_get_log_name_by_id(log_id) {
+        return (0, lib_loader_1.native_export)("get_log_name_by_id")(log_id);
+    }
+    static __api_get_log_categories_count(log_id) {
+        return (0, lib_loader_1.native_export)("get_log_categories_count")(log_id);
+    }
+    static __api_get_log_category_name_by_index(log_id, category_index) {
+        return (0, lib_loader_1.native_export)("get_log_category_name_by_index")(log_id, category_index);
+    }
+    static __api_log_device_console(level, content) {
+        (0, lib_loader_1.native_export)("log_device_console")(level, content);
+    }
+    static __api_force_flush(log_id) {
+        (0, lib_loader_1.native_export)("force_flush")(log_id);
+    }
+    static __api_get_file_base_dir(base_dir_type) {
+        return (0, lib_loader_1.native_export)("get_file_base_dir")(base_dir_type);
+    }
+    static __api_log_decoder_create(log_file_path, priv_key) {
+        return (0, lib_loader_1.native_export)("log_decoder_create")(log_file_path, priv_key ? priv_key : "");
+    }
+    static __api_log_decoder_decode(handle, out) {
+        const obj = (0, lib_loader_1.native_export)("log_decoder_decode")(handle);
+        if (out && typeof out === "object") {
+            out.value = obj?.text ?? "";
+        }
+        return obj?.code ?? 0;
+    }
+    static __api_attach_decoder_inst(decoder_inst) {
+        (0, lib_loader_1.native_export)("attach_decoder_inst")(decoder_inst, decoder_inst['handle_']);
+    }
+    static __api_log_decode(in_file_path, out_file_path, priv_key) {
+        return !!(0, lib_loader_1.native_export)("log_decode")(in_file_path, out_file_path, priv_key ? priv_key : "");
+    }
+    static __api_take_snapshot_string(log_id, time_zone_config) {
+        return (0, lib_loader_1.native_export)("take_snapshot_string")(log_id, time_zone_config ? time_zone_config : "");
+    }
+    static __api_set_console_callback(callback) {
+        if (typeof callback !== "function" && callback !== null) {
+            throw new Error("__api_set_console_callback requires a function callback, or pass null ");
+        }
+        (0, lib_loader_1.native_export)("set_console_callback")(callback);
+    }
+    static __api_set_console_buffer_enable(enable) {
+        (0, lib_loader_1.native_export)("set_console_buffer_enable")(!!enable);
+    }
+    static __api_reset_base_dir(base_dir_type, dir) {
+        (0, lib_loader_1.native_export)("reset_base_dir")(base_dir_type, dir);
+    }
+    static __api_fetch_and_remove_console_buffer(callback) {
+        if (typeof callback !== "function") {
+            throw new Error("__api_fetch_and_remove_console_buffer requires a function callback");
+        }
+        return !!(0, lib_loader_1.native_export)("fetch_and_remove_console_buffer")(callback);
+    }
+}
+exports.log_invoker = log_invoker;

package/dist/cjs/bq/lib_def.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Copyright (C) 2025 Tencent.
+ * BQLOG is licensed under the Apache License, Version 2.0.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lib_def = void 0;
+exports.lib_def = {
+    // native module name; keep as runtime string, not an identifier
+    lib_name: "BqLog",
+};

package/dist/cjs/bq/log.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const log_invoker_1 = require("./impl/log_invoker");
+// IMPORTANT: this is a build-alias file generated per build.
+// For ESM build it is a copy of lib_loader.esm.txt,
+// for CJS and OHOS build it is lib_loader.ts.
+const lib_loader_1 = require("./utils/lib_loader");
+class log {
+    static inner_callback(log_id, category_idx, level, text) {
+        if (log.callback_) {
+            log.callback_(log_id, category_idx, level, text);
+        }
+    }
+    /**
+     * Get bqLog lib version
+     * @return
+     */
+    static get_version() {
+        return log_invoker_1.log_invoker.__api_get_log_version();
+    }
+    /**
+     * Reset the base dir
+     * @param base_dir_type
+     * @param dir
+     */
+    static reset_base_dir(base_dir_type, dir) {
+        log_invoker_1.log_invoker.__api_reset_base_dir(base_dir_type, dir);
+    }
+    /**
+     * If bqLog is asynchronous, a crash in the program may cause the logs in the buffer not to be persisted to disk.
+     * If this feature is enabled, bqLog will attempt to perform a forced flush of the logs in the buffer in the event of a crash. However,
+     * this functionality does not guarantee success.
+     */
+    static enable_auto_crash_handle() {
+        log_invoker_1.log_invoker.__api_enable_auto_crash_handler();
+    }
+    /**
+     * If bqLog is stored in a relative path, the base dir is determined by the value of base_dir_type.
+     * This will return the absolute paths corresponding to both scenarios.
+     * @param base_dir_type
+     * @return
+     */
+    static get_file_base_dir(base_dir_type) {
+        return log_invoker_1.log_invoker.__api_get_file_base_dir(base_dir_type);
+    }
+    /**
+     * Create a log object
+     * @param name
+     * 		  	If the log name is an empty string, bqLog will automatically assign you a unique log name.
+     * 			If the log name already exists, it will return the previously existing log object and overwrite the previous configuration with the new config.
+     * @param config
+     * 			Log config string
+     * @return
+     * 			A log object, if create failed, the is_valid() method of it will return false
+     */
+    static create_log(name, config) {
+        if (!config || config.length == 0) {
+            return new log(0n);
+        }
+        let log_id = log_invoker_1.log_invoker.__api_create_log(name, config, 0, null);
+        return new log(log_id);
+    }
+    /**
+     * Get a log object by it's name
+     * @param log_name
+     * 			Name of the log you want to find
+     * @return
+     * 			A log object, if the log object with specific name was not found, the is_valid() method of it will return false
+     */
+    static get_log_by_name(log_name) {
+        if (!log_name || log_name.length == 0) {
+            return new log(0n);
+        }
+        let log_count = log_invoker_1.log_invoker.__api_get_logs_count();
+        for (let i = 0; i < log_count; ++i) {
+            let id = log_invoker_1.log_invoker.__api_get_log_id_by_index(i);
+            let name = log_invoker_1.log_invoker.__api_get_log_name_by_id(id);
+            if (log_name == name) {
+                return new log(id);
+            }
+        }
+        return new log(0n);
+    }
+    /**
+     * Synchronously flush the buffer of all log objects
+     * to ensure that all data in the buffer is processed after the call.
+     */
+    static force_flush_all_logs() {
+        log_invoker_1.log_invoker.__api_force_flush(0n);
+    }
+    /**
+     * Register a callback that will be invoked whenever a console log message is output.
+     * This can be used for an external system to monitor console log output.
+     * @param callback
+     */
+    static register_console_callback(callback) {
+        log.callback_ = callback;
+        if (null != log.callback_) {
+            log_invoker_1.log_invoker.__api_set_console_callback(log.inner_callback);
+        }
+        else {
+            log_invoker_1.log_invoker.__api_set_console_callback(null);
+        }
+    }
+    /**
+     * Unregister a previously registered console callback.
+     * @param callback
+     */
+    static unregister_console_callback(callback) {
+        if (log.callback_ == callback) {
+            log_invoker_1.log_invoker.__api_set_console_callback(null);
+            log.callback_ = null;
+        }
+    }
+    /**
+     * Enable or disable the console appender buffer.
+     * Since our wrapper may run in both C# and Java virtual machines, and we do not want to directly invoke callbacks from a native thread,
+     * we can enable this option. This way, all console outputs will be saved in the buffer until we fetch them.
+     * @param enable
+     */
+    static set_console_buffer_enable(enable) {
+        log_invoker_1.log_invoker.__api_set_console_buffer_enable(enable);
+    }
+    /**
+     * Fetch and remove a log entry from the console appender buffer in a thread-safe manner.
+     * If the console appender buffer is not empty, the on_console_callback function will be invoked for this log entry.
+     * Please ensure not to output synchronized BQ logs within the callback function.
+     * @param on_console_callback
+     *        A callback function to be invoked for the fetched log entry if the console appender buffer is not empty
+     * @return
+     *        True if the console appender buffer is not empty and a log entry is fetched; otherwise False is returned.
+     */
+    static fetch_and_remove_console_buffer(on_console_callback) {
+        return log_invoker_1.log_invoker.__api_fetch_and_remove_console_buffer(on_console_callback);
+    }
+    /**
+    * Output to console with log_level.
+    * Important: This is not log entry, and can not be caught by console callback which was registered by register_console_callback or fetch_and_remove_console_buffer
+    * @param level
+    * @param str
+    */
+    static console(level, str) {
+        log_invoker_1.log_invoker.__api_log_device_console(level, str);
+    }
+    constructor(arg) {
+        this.log_id_ = 0n;
+        this.name_ = "";
+        this.categories_name_array_ = [];
+        if (arg instanceof log) {
+            this.name_ = arg.name_;
+            this.log_id_ = arg.log_id_;
+            let category_count = log_invoker_1.log_invoker.__api_get_log_categories_count(this.log_id_);
+            this.categories_name_array_ = [];
+            for (let i = 0; i < category_count; ++i) {
+                let category_item_name = log_invoker_1.log_invoker.__api_get_log_category_name_by_index(this.log_id_, i);
+                if (category_item_name) {
+                    this.categories_name_array_.push(category_item_name);
+                }
+            }
+        }
+        else if (typeof (arg) === 'bigint') {
+            this.log_id_ = arg;
+            let name = log_invoker_1.log_invoker.__api_get_log_name_by_id(this.log_id_);
+            if (!name) {
+                this.log_id_ = 0n;
+                return;
+            }
+            this.name_ = name;
+            let category_count = log_invoker_1.log_invoker.__api_get_log_categories_count(this.log_id_);
+            this.categories_name_array_ = [];
+            for (let i = 0; i < category_count; ++i) {
+                let category_item_name = log_invoker_1.log_invoker.__api_get_log_category_name_by_index(this.log_id_, i);
+                this.categories_name_array_.push(category_item_name);
+            }
+        }
+        log_invoker_1.log_invoker.__api_attach_log_inst(this);
+    }
+    /**
+     * Modify the log configuration, but some fields, such as buffer_size, cannot be modified.
+     * @param config
+     */
+    reset_config(config) {
+        if (!config || config.length == 0) {
+            return;
+        }
+        log_invoker_1.log_invoker.__api_log_reset_config(this.name_, config);
+    }
+    /**
+     * Temporarily disable or enable a specific Appender.
+     * @param appender_name
+     * @param enable
+     */
+    set_appender_enable(appender_name, enable) {
+        log_invoker_1.log_invoker.__api_set_appender_enable(this.log_id_, appender_name, enable);
+    }
+    /**
+     * Synchronously flush the buffer of this log object
+     * to ensure that all data in the buffer is processed after the call.
+     */
+    force_flush() {
+        log_invoker_1.log_invoker.__api_force_flush(this.log_id_);
+    }
+    /**
+     * Get id of this log object
+     * @return
+     */
+    get_id() {
+        return this.log_id_;
+    }
+    /**
+     * Whether a log object is valid
+     * @return
+     */
+    is_valid() {
+        return this.get_id() != 0n;
+    }
+    /**
+     * Get the name of a log
+     * @return
+     */
+    get_name() {
+        return this.name_;
+    }
+    /**
+     * Works only when snapshot is configured.
+     * It will decode the snapshot buffer to text.
+     * @param time_zone_config
+     * 			Use this to specify the time display of log text. such as : "localtime", "gmt", "Z", "UTC", "UTC+8", "UTC-11", "utc+11:30"
+     * @return
+     * 			The decoded snapshot buffer
+     */
+    take_snapshot(time_zone_config) {
+        return log_invoker_1.log_invoker.__api_take_snapshot_string(this.log_id_, time_zone_config);
+    }
+}
+exports.log = log;
+log.callback_ = null;
+function defineNativeMethod(proto, name) {
+    const fn = (0, lib_loader_1.native_export)(name);
+    if (typeof fn !== 'function') {
+        throw new Error(`Native method "__bq_napi_${name}" not found or not a function`);
+    }
+    Object.defineProperty(proto, name, {
+        value: fn,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+    });
+}
+['verbose', 'debug', 'info', 'warning', 'error', 'fatal'].forEach(n => defineNativeMethod(log.prototype, n));