@harperfast/rocksdb-js 2.7.0 → 2.7.1

package/README.md

@@ -57,6 +57,18 @@ Creates a new database instance.
   - `enableStats: boolean` When `true` and the database is open, RocksDB will captures stats that
     are retrieved by calling `db.getStats()`. Enabling statistics imposes 5-10% in overhead.
     Defaults to `false`.
+  - `infoLogLevel: number` The verbosity of RocksDB's informational logging (`LOG` /
+    `LOG.old.*`): `0` (debug), `1` (info), `2` (warn), `3` (error), `4` (fatal), or `5`
+    (header-only). Omit to leave RocksDB's own default (`INFO_LEVEL` in a release build of the
+    linked RocksDB library). See [`db.logOptions`](#dblogoptions-maxlogfilesize-number-infologlevel-number).
+  - `maxLogFileSize: number` The per-file size cap, in bytes, for informational log files (`LOG` /
+    `LOG.old.*`). RocksDB retains up to 5 of these files, so the total informational-log footprint
+    is bounded at roughly `5 * maxLogFileSize`. Defaults to 16 MB (an 80 MB bound), which stops
+    purely informational logging from growing without bound. A value of `0` is RocksDB's special
+    "single unbounded log file" mode — it **disables size-based rotation entirely**, so the log
+    can grow without limit; only set `0` if you deliberately want that (it forgoes the bounded
+    footprint this option otherwise provides). See
+    [`db.logOptions`](#dblogoptions-maxlogfilesize-number-infologlevel-number).
   - `maxOpenFiles: number` The maximum number of table files RocksDB keeps open. `0` (the default)
     derives a budget from the effective per-process open-file limit (an eighth of the limit —
     several databases can share one process — clamped to `[1024, 262144]`); `-1` holds every table
@@ -134,6 +146,18 @@ const db = RocksDatabase.open('path/to/db', {
 console.log(db.compression); // { algorithm: 'zstd', level: 3 }
 ```
 
+### `db.logOptions: { maxLogFileSize: number, infoLogLevel: number }`
+
+Returns the informational-log settings currently in effect for this database, read live from
+RocksDB. These are database-wide settings (not per-column-family). `maxLogFileSize` is the
+per-file size cap for informational log files (`LOG` / `LOG.old.*`); `infoLogLevel` is the logging
+verbosity. The database must be open.
+
+```typescript
+const db = RocksDatabase.open('path/to/db', { maxLogFileSize: 4 * 1024 * 1024 });
+console.log(db.logOptions); // { maxLogFileSize: 4194304, infoLogLevel: 1 }
+```
+
 ### `db.config(options)`
 
 Sets global database settings.

package/dist/index.cjs

@@ -1336,6 +1336,11 @@ var Store = class {
 	*/
 	freezeData;
 	/**
+	* Verbosity of RocksDB's informational logging (`info_log_level`). Omit to
+	* leave RocksDB's own default.
+	*/
+	infoLogLevel;
+	/**
 	* Reusable buffer for encoding keys.
 	*/
 	keyBuffer;
@@ -1348,6 +1353,16 @@ var Store = class {
 	*/
 	maxKeySize;
 	/**
+	* Per-file size cap (bytes) for informational log files (`LOG` /
+	* `LOG.old.*`). Bounds total informational-log footprint to roughly `5 *
+	* maxLogFileSize` (RocksDB retains up to 5 of these files). A value of `0`
+	* is RocksDB's "single unbounded log file" mode: it disables size-based
+	* rotation, so the log can grow without limit — set it only if you want that.
+	*
+	* @default 16777216 (16MB)
+	*/
+	maxLogFileSize;
+	/**
 	* The maximum number of table files RocksDB keeps open. `0` (the default)
 	* derives a budget from the effective per-process open-file limit (an
 	* eighth of the limit — several databases can share one process — clamped
@@ -1366,13 +1381,26 @@ var Store = class {
 	/**
 	* The bytes of recent memtable history to retain in memory for transaction
 	* conflict checking. `-1` derives the value from
-	* `maxWriteBufferNumber * writeBufferSize`.
+	* `maxWriteBufferNumber * writeBufferSize`, except under a stalling
+	* `writeBufferManager`, where it derives `0`: retained history is charged to
+	* that manager and is only trimmable down to this target, so a target the
+	* budget cannot hold stalls writes permanently. Set a number to size it
+	* yourself against the budget and the column-family count.
 	*/
 	maxWriteBufferSizeToMaintain;
 	/**
 	* The total memtable budget in bytes across all column families. When the
-	* sum of memtables reaches this size, RocksDB flushes the largest one. `0`
-	* disables the global trigger so per-CF `writeBufferSize` drives flushing.
+	* sum of memtables reaches this size, RocksDB flushes the largest one.
+	* Defaults to `0`, which disables the global trigger so per-CF
+	* `writeBufferSize` drives flushing.
+	*
+	* Set this only if you know your column-family count: it is one budget split
+	* across all of them, so a value that suits a few families starves many. To
+	* bound total memtable memory instead, configure a WriteBufferManager.
+	*
+	* Database-wide, so it binds when the path is first opened in this process:
+	* a later open of the same path — including from another worker thread —
+	* keeps the first opener's value rather than overriding or rejecting it.
 	*/
 	dbWriteBufferSize;
 	/**
@@ -1477,9 +1505,11 @@ var Store = class {
 		this.encoder = options?.encoder ?? null;
 		this.encoding = options?.encoding ?? null;
 		this.freezeData = options?.freezeData ?? false;
+		this.infoLogLevel = options?.infoLogLevel;
 		this.keyBuffer = KEY_BUFFER;
 		this.keyEncoding = keyEncoding;
 		this.maxKeySize = options?.maxKeySize ?? MAX_KEY_SIZE;
+		this.maxLogFileSize = options?.maxLogFileSize;
 		this.maxOpenFiles = options?.maxOpenFiles;
 		this.maxWriteBufferNumber = options?.maxWriteBufferNumber;
 		this.maxWriteBufferSizeToMaintain = options?.maxWriteBufferSizeToMaintain;
@@ -1787,6 +1817,8 @@ var Store = class {
 			dbWriteBufferSize: this.dbWriteBufferSize,
 			disableWAL: this.disableWAL,
 			enableStats: this.enableStats,
+			infoLogLevel: this.infoLogLevel,
+			maxLogFileSize: this.maxLogFileSize,
 			maxOpenFiles: this.maxOpenFiles,
 			maxWriteBufferNumber: this.maxWriteBufferNumber,
 			maxWriteBufferSizeToMaintain: this.maxWriteBufferSizeToMaintain,
@@ -2231,6 +2263,24 @@ var RocksDatabase = class RocksDatabase extends DBI {
 		return this.store.db.getCompression();
 	}
 	/**
+	* The informational-log settings currently in effect for this database,
+	* read live from RocksDB, as `{ maxLogFileSize, infoLogLevel }`. These are
+	* database-wide settings (not per-column-family): `maxLogFileSize` bounds
+	* each retained `LOG` / `LOG.old.*` file's size (defaults to 16MB, so with
+	* RocksDB's `keep_log_file_num = 5` the total footprint is bounded at
+	* roughly 80MB); `infoLogLevel` is the logging verbosity. The database must
+	* be open.
+	*
+	* @example
+	* ```typescript
+	* const db = RocksDatabase.open('/path/to/db', { maxLogFileSize: 4 * 1024 * 1024 });
+	* db.logOptions; // { maxLogFileSize: 4194304, infoLogLevel: 1 }
+	* ```
+	*/
+	get logOptions() {
+		return this.store.db.getLogOptions();
+	}
+	/**
 	* Set global database settings.
 	*
 	* @param options - The options for the database.
@@ -3060,7 +3110,7 @@ function loadLastPosition(transactionLog, readUncommitted) {
 //#region src/index.ts
 const versions = {
 	rocksdb: version,
-	"rocksdb-js": "2.7.0"
+	"rocksdb-js": "2.7.1"
 };
 
 //#endregion