@logtape/file 0.12.0-dev.191 → 0.12.0-dev.194

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "0.12.0-dev.191+20e736ff",
+  "version": "0.12.0-dev.194+4b7c1127",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/filesink.base.cjs

@@ -14,14 +14,24 @@ const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/log
 function getBaseFileSink(path, options) {
 	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
+	const bufferSize = options.bufferSize ?? 1024 * 8;
 	let fd = options.lazy ? null : options.openSync(path);
+	let buffer = "";
 	const sink = (record) => {
-		if (fd === null) fd = options.openSync(path);
-		options.writeSync(fd, encoder.encode(formatter(record)));
-		options.flushSync(fd);
+		if (fd == null) fd = options.openSync(path);
+		buffer += formatter(record);
+		if (buffer.length >= bufferSize) {
+			options.writeSync(fd, encoder.encode(buffer));
+			buffer = "";
+			options.flushSync(fd);
+		}
 	};
 	sink[Symbol.dispose] = () => {
-		if (fd !== null) options.closeSync(fd);
+		if (fd !== null) {
+			options.writeSync(fd, encoder.encode(buffer));
+			options.flushSync(fd);
+			options.closeSync(fd);
+		}
 	};
 	return sink;
 }
@@ -43,6 +53,7 @@ function getBaseRotatingFileSink(path, options) {
 	const encoder = options.encoder ?? new TextEncoder();
 	const maxSize = options.maxSize ?? 1024 * 1024;
 	const maxFiles = options.maxFiles ?? 5;
+	const bufferSize = options.bufferSize ?? 1024 * 8;
 	let offset = 0;
 	try {
 		const stat = options.statSync(path);
@@ -65,14 +76,23 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
+	let buffer = "";
 	const sink = (record) => {
-		const bytes = encoder.encode(formatter(record));
-		if (shouldRollover(bytes)) performRollover();
-		options.writeSync(fd, bytes);
+		buffer += formatter(record);
+		if (buffer.length >= bufferSize) {
+			const bytes = encoder.encode(buffer);
+			buffer = "";
+			if (shouldRollover(bytes)) performRollover();
+			options.writeSync(fd, bytes);
+			options.flushSync(fd);
+			offset += bytes.length;
+		}
+	};
+	sink[Symbol.dispose] = () => {
+		options.writeSync(fd, encoder.encode(buffer));
 		options.flushSync(fd);
-		offset += bytes.length;
+		options.closeSync(fd);
 	};
-	sink[Symbol.dispose] = () => options.closeSync(fd);
 	return sink;
 }
 

package/dist/filesink.base.d.cts

@@ -10,6 +10,14 @@ type FileSinkOptions = StreamSinkOptions & {
    * If `true`, the file is not opened until the first write.  Defaults to `false`.
    */
   lazy?: boolean;
+  /**
+   * The size of the buffer to use when writing to the file.  If not specified,
+   * a default buffer size will be used.  If it is less or equal to 0,
+   * the file will be written directly without buffering.
+   * @default 8192
+   * @since 0.12.0
+   */
+  bufferSize?: number;
 };
 /**
  * A platform-specific file sink driver.

package/dist/filesink.base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAWiB,KAXL,eAAA,GAAkB,iBAWC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;CAAU;;AAYnB;AAqCrB;;AAAsD,UA7DrC,cA6DqC,CAAA,KAAA,CAAA,CAAA;EAAe;AAAhB;AAerD;;EAAuC,QAA+B,CAAA,IAAA,EAAA,MAAA,CAAA,EAvE5C,KAuE4C;EAAK;AAAN;;;;gBAhErD,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UAqCC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}
+{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAoBiB,KApBL,eAAA,GAAkB,iBAoBC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AA2CrB;;;;EAAqD,UAAA,CAAA,EAAA,MAAA;AAerD,CAAA;;;;AAAqE;UAlFpD;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UA2CC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}

package/dist/filesink.base.d.ts

@@ -10,6 +10,14 @@ type FileSinkOptions = StreamSinkOptions & {
    * If `true`, the file is not opened until the first write.  Defaults to `false`.
    */
   lazy?: boolean;
+  /**
+   * The size of the buffer to use when writing to the file.  If not specified,
+   * a default buffer size will be used.  If it is less or equal to 0,
+   * the file will be written directly without buffering.
+   * @default 8192
+   * @since 0.12.0
+   */
+  bufferSize?: number;
 };
 /**
  * A platform-specific file sink driver.

package/dist/filesink.base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAWiB,KAXL,eAAA,GAAkB,iBAWC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;CAAU;;AAYnB;AAqCrB;;AAAsD,UA7DrC,cA6DqC,CAAA,KAAA,CAAA,CAAA;EAAe;AAAhB;AAerD;;EAAuC,QAA+B,CAAA,IAAA,EAAA,MAAA,CAAA,EAvE5C,KAuE4C;EAAK;AAAN;;;;gBAhErD,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UAqCC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}
+{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAoBiB,KApBL,eAAA,GAAkB,iBAoBC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AA2CrB;;;;EAAqD,UAAA,CAAA,EAAA,MAAA;AAerD,CAAA;;;;AAAqE;UAlFpD;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UA2CC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}

package/dist/filesink.base.js

@@ -13,14 +13,24 @@ import { defaultTextFormatter } from "@logtape/logtape";
 function getBaseFileSink(path, options) {
 	const formatter = options.formatter ?? defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
+	const bufferSize = options.bufferSize ?? 1024 * 8;
 	let fd = options.lazy ? null : options.openSync(path);
+	let buffer = "";
 	const sink = (record) => {
-		if (fd === null) fd = options.openSync(path);
-		options.writeSync(fd, encoder.encode(formatter(record)));
-		options.flushSync(fd);
+		if (fd == null) fd = options.openSync(path);
+		buffer += formatter(record);
+		if (buffer.length >= bufferSize) {
+			options.writeSync(fd, encoder.encode(buffer));
+			buffer = "";
+			options.flushSync(fd);
+		}
 	};
 	sink[Symbol.dispose] = () => {
-		if (fd !== null) options.closeSync(fd);
+		if (fd !== null) {
+			options.writeSync(fd, encoder.encode(buffer));
+			options.flushSync(fd);
+			options.closeSync(fd);
+		}
 	};
 	return sink;
 }
@@ -42,6 +52,7 @@ function getBaseRotatingFileSink(path, options) {
 	const encoder = options.encoder ?? new TextEncoder();
 	const maxSize = options.maxSize ?? 1024 * 1024;
 	const maxFiles = options.maxFiles ?? 5;
+	const bufferSize = options.bufferSize ?? 1024 * 8;
 	let offset = 0;
 	try {
 		const stat = options.statSync(path);
@@ -64,14 +75,23 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
+	let buffer = "";
 	const sink = (record) => {
-		const bytes = encoder.encode(formatter(record));
-		if (shouldRollover(bytes)) performRollover();
-		options.writeSync(fd, bytes);
+		buffer += formatter(record);
+		if (buffer.length >= bufferSize) {
+			const bytes = encoder.encode(buffer);
+			buffer = "";
+			if (shouldRollover(bytes)) performRollover();
+			options.writeSync(fd, bytes);
+			options.flushSync(fd);
+			offset += bytes.length;
+		}
+	};
+	sink[Symbol.dispose] = () => {
+		options.writeSync(fd, encoder.encode(buffer));
 		options.flushSync(fd);
-		offset += bytes.length;
+		options.closeSync(fd);
 	};
-	sink[Symbol.dispose] = () => options.closeSync(fd);
 	return sink;
 }
 

package/dist/filesink.base.js.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.js","names":["path: string","options: FileSinkOptions & FileSinkDriver<TFile>","sink: Sink & Disposable","record: LogRecord","options: RotatingFileSinkOptions & RotatingFileSinkDriver<TFile>","offset: number","bytes: Uint8Array"],"sources":["../filesink.base.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type StreamSinkOptions,\n} from \"@logtape/logtape\";\n\n/**\n * Options for the {@link getBaseFileSink} function.\n */\nexport type FileSinkOptions = StreamSinkOptions & {\n  /**\n   * If `true`, the file is not opened until the first write.  Defaults to `false`.\n   */\n  lazy?: boolean;\n};\n\n/**\n * A platform-specific file sink driver.\n * @typeParam TFile The type of the file descriptor.\n */\nexport interface FileSinkDriver<TFile> {\n  /**\n   * Open a file for appending and return a file descriptor.\n   * @param path A path to the file to open.\n   */\n  openSync(path: string): TFile;\n\n  /**\n   * Write a chunk of data to the file.\n   * @param fd The file descriptor.\n   * @param chunk The data to write.\n   */\n  writeSync(fd: TFile, chunk: Uint8Array): void;\n\n  /**\n   * Flush the file to ensure that all data is written to the disk.\n   * @param fd The file descriptor.\n   */\n  flushSync(fd: TFile): void;\n\n  /**\n   * Close the file.\n   * @param fd The file descriptor.\n   */\n  closeSync(fd: TFile): void;\n}\n\n/**\n * Get a platform-independent file sink.\n *\n * @typeParam TFile The type of the file descriptor.\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed.\n */\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options: FileSinkOptions & FileSinkDriver<TFile>,\n): Sink & Disposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  let fd = options.lazy ? null : options.openSync(path);\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    if (fd === null) {\n      fd = options.openSync(path);\n    }\n    options.writeSync(fd, encoder.encode(formatter(record)));\n    options.flushSync(fd);\n  };\n  sink[Symbol.dispose] = () => {\n    if (fd !== null) {\n      options.closeSync(fd);\n    }\n  };\n  return sink;\n}\n\n/**\n * Options for the {@link getBaseRotatingFileSink} function.\n */\nexport interface RotatingFileSinkOptions extends Omit<FileSinkOptions, \"lazy\"> {\n  /**\n   * The maximum bytes of the file before it is rotated.  1 MiB by default.\n   */\n  maxSize?: number;\n\n  /**\n   * The maximum number of files to keep.  5 by default.\n   */\n  maxFiles?: number;\n}\n\n/**\n * A platform-specific rotating file sink driver.\n */\nexport interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {\n  /**\n   * Get the size of the file.\n   * @param path A path to the file.\n   * @returns The `size` of the file in bytes, in an object.\n   */\n  statSync(path: string): { size: number };\n\n  /**\n   * Rename a file.\n   * @param oldPath A path to the file to rename.\n   * @param newPath A path to be renamed to.\n   */\n  renameSync(oldPath: string, newPath: string): void;\n}\n\n/**\n * Get a platform-independent rotating file sink.\n *\n * This sink writes log records to a file, and rotates the file when it reaches\n * the `maxSize`.  The rotated files are named with the original file name\n * followed by a dot and a number, starting from 1.  The number is incremented\n * for each rotation, and the maximum number of files to keep is `maxFiles`.\n *\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed.\n */\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options: RotatingFileSinkOptions & RotatingFileSinkDriver<TFile>,\n): Sink & Disposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const maxSize = options.maxSize ?? 1024 * 1024;\n  const maxFiles = options.maxFiles ?? 5;\n  let offset: number = 0;\n  try {\n    const stat = options.statSync(path);\n    offset = stat.size;\n  } catch {\n    // Continue as the offset is already 0.\n  }\n  let fd = options.openSync(path);\n  function shouldRollover(bytes: Uint8Array): boolean {\n    return offset + bytes.length > maxSize;\n  }\n  function performRollover(): void {\n    options.closeSync(fd);\n    for (let i = maxFiles - 1; i > 0; i--) {\n      const oldPath = `${path}.${i}`;\n      const newPath = `${path}.${i + 1}`;\n      try {\n        options.renameSync(oldPath, newPath);\n      } catch (_) {\n        // Continue if the file does not exist.\n      }\n    }\n    options.renameSync(path, `${path}.1`);\n    offset = 0;\n    fd = options.openSync(path);\n  }\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    const bytes = encoder.encode(formatter(record));\n    if (shouldRollover(bytes)) performRollover();\n    options.writeSync(fd, bytes);\n    options.flushSync(fd);\n    offset += bytes.length;\n  };\n  sink[Symbol.dispose] = () => options.closeSync(fd);\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;AAyDA,SAAgB,gBACdA,MACAC,SACmB;CACnB,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,UAAU,QAAQ,WAAW,IAAI;CACvC,IAAI,KAAK,QAAQ,OAAO,OAAO,QAAQ,SAAS,KAAK;CACrD,MAAMC,OAA0B,CAACC,WAAsB;AACrD,MAAI,OAAO,KACT,MAAK,QAAQ,SAAS,KAAK;AAE7B,UAAQ,UAAU,IAAI,QAAQ,OAAO,UAAU,OAAO,CAAC,CAAC;AACxD,UAAQ,UAAU,GAAG;CACtB;AACD,MAAK,OAAO,WAAW,MAAM;AAC3B,MAAI,OAAO,KACT,SAAQ,UAAU,GAAG;CAExB;AACD,QAAO;AACR;;;;;;;;;;;;;;AAiDD,SAAgB,wBACdH,MACAI,SACmB;CACnB,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,UAAU,QAAQ,WAAW,IAAI;CACvC,MAAM,UAAU,QAAQ,WAAW,OAAO;CAC1C,MAAM,WAAW,QAAQ,YAAY;CACrC,IAAIC,SAAiB;AACrB,KAAI;EACF,MAAM,OAAO,QAAQ,SAAS,KAAK;AACnC,WAAS,KAAK;CACf,QAAO,CAEP;CACD,IAAI,KAAK,QAAQ,SAAS,KAAK;CAC/B,SAAS,eAAeC,OAA4B;AAClD,SAAO,SAAS,MAAM,SAAS;CAChC;CACD,SAAS,kBAAwB;AAC/B,UAAQ,UAAU,GAAG;AACrB,OAAK,IAAI,IAAI,WAAW,GAAG,IAAI,GAAG,KAAK;GACrC,MAAM,WAAW,EAAE,KAAK,GAAG,EAAE;GAC7B,MAAM,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE;AACjC,OAAI;AACF,YAAQ,WAAW,SAAS,QAAQ;GACrC,SAAQ,GAAG,CAEX;EACF;AACD,UAAQ,WAAW,OAAO,EAAE,KAAK,IAAI;AACrC,WAAS;AACT,OAAK,QAAQ,SAAS,KAAK;CAC5B;CACD,MAAMJ,OAA0B,CAACC,WAAsB;EACrD,MAAM,QAAQ,QAAQ,OAAO,UAAU,OAAO,CAAC;AAC/C,MAAI,eAAe,MAAM,CAAE,kBAAiB;AAC5C,UAAQ,UAAU,IAAI,MAAM;AAC5B,UAAQ,UAAU,GAAG;AACrB,YAAU,MAAM;CACjB;AACD,MAAK,OAAO,WAAW,MAAM,QAAQ,UAAU,GAAG;AAClD,QAAO;AACR"}
+{"version":3,"file":"filesink.base.js","names":["path: string","options: FileSinkOptions & FileSinkDriver<TFile>","buffer: string","sink: Sink & Disposable","record: LogRecord","options: RotatingFileSinkOptions & RotatingFileSinkDriver<TFile>","offset: number","bytes: Uint8Array"],"sources":["../filesink.base.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type StreamSinkOptions,\n} from \"@logtape/logtape\";\n\n/**\n * Options for the {@link getBaseFileSink} function.\n */\nexport type FileSinkOptions = StreamSinkOptions & {\n  /**\n   * If `true`, the file is not opened until the first write.  Defaults to `false`.\n   */\n  lazy?: boolean;\n\n  /**\n   * The size of the buffer to use when writing to the file.  If not specified,\n   * a default buffer size will be used.  If it is less or equal to 0,\n   * the file will be written directly without buffering.\n   * @default 8192\n   * @since 0.12.0\n   */\n  bufferSize?: number;\n};\n\n/**\n * A platform-specific file sink driver.\n * @typeParam TFile The type of the file descriptor.\n */\nexport interface FileSinkDriver<TFile> {\n  /**\n   * Open a file for appending and return a file descriptor.\n   * @param path A path to the file to open.\n   */\n  openSync(path: string): TFile;\n\n  /**\n   * Write a chunk of data to the file.\n   * @param fd The file descriptor.\n   * @param chunk The data to write.\n   */\n  writeSync(fd: TFile, chunk: Uint8Array): void;\n\n  /**\n   * Flush the file to ensure that all data is written to the disk.\n   * @param fd The file descriptor.\n   */\n  flushSync(fd: TFile): void;\n\n  /**\n   * Close the file.\n   * @param fd The file descriptor.\n   */\n  closeSync(fd: TFile): void;\n}\n\n/**\n * Get a platform-independent file sink.\n *\n * @typeParam TFile The type of the file descriptor.\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed.\n */\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options: FileSinkOptions & FileSinkDriver<TFile>,\n): Sink & Disposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 chars\n  let fd = options.lazy ? null : options.openSync(path);\n  let buffer: string = \"\";\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    if (fd == null) fd = options.openSync(path);\n    buffer += formatter(record);\n    if (buffer.length >= bufferSize) {\n      options.writeSync(fd, encoder.encode(buffer));\n      buffer = \"\";\n      options.flushSync(fd);\n    }\n  };\n  sink[Symbol.dispose] = () => {\n    if (fd !== null) {\n      options.writeSync(fd, encoder.encode(buffer));\n      options.flushSync(fd);\n      options.closeSync(fd);\n    }\n  };\n  return sink;\n}\n\n/**\n * Options for the {@link getBaseRotatingFileSink} function.\n */\nexport interface RotatingFileSinkOptions extends Omit<FileSinkOptions, \"lazy\"> {\n  /**\n   * The maximum bytes of the file before it is rotated.  1 MiB by default.\n   */\n  maxSize?: number;\n\n  /**\n   * The maximum number of files to keep.  5 by default.\n   */\n  maxFiles?: number;\n}\n\n/**\n * A platform-specific rotating file sink driver.\n */\nexport interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {\n  /**\n   * Get the size of the file.\n   * @param path A path to the file.\n   * @returns The `size` of the file in bytes, in an object.\n   */\n  statSync(path: string): { size: number };\n\n  /**\n   * Rename a file.\n   * @param oldPath A path to the file to rename.\n   * @param newPath A path to be renamed to.\n   */\n  renameSync(oldPath: string, newPath: string): void;\n}\n\n/**\n * Get a platform-independent rotating file sink.\n *\n * This sink writes log records to a file, and rotates the file when it reaches\n * the `maxSize`.  The rotated files are named with the original file name\n * followed by a dot and a number, starting from 1.  The number is incremented\n * for each rotation, and the maximum number of files to keep is `maxFiles`.\n *\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed.\n */\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options: RotatingFileSinkOptions & RotatingFileSinkDriver<TFile>,\n): Sink & Disposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const maxSize = options.maxSize ?? 1024 * 1024;\n  const maxFiles = options.maxFiles ?? 5;\n  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 chars\n  let offset: number = 0;\n  try {\n    const stat = options.statSync(path);\n    offset = stat.size;\n  } catch {\n    // Continue as the offset is already 0.\n  }\n  let fd = options.openSync(path);\n  function shouldRollover(bytes: Uint8Array): boolean {\n    return offset + bytes.length > maxSize;\n  }\n  function performRollover(): void {\n    options.closeSync(fd);\n    for (let i = maxFiles - 1; i > 0; i--) {\n      const oldPath = `${path}.${i}`;\n      const newPath = `${path}.${i + 1}`;\n      try {\n        options.renameSync(oldPath, newPath);\n      } catch (_) {\n        // Continue if the file does not exist.\n      }\n    }\n    options.renameSync(path, `${path}.1`);\n    offset = 0;\n    fd = options.openSync(path);\n  }\n  let buffer: string = \"\";\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    buffer += formatter(record);\n    if (buffer.length >= bufferSize) {\n      const bytes = encoder.encode(buffer);\n      buffer = \"\";\n      if (shouldRollover(bytes)) performRollover();\n      options.writeSync(fd, bytes);\n      options.flushSync(fd);\n      offset += bytes.length;\n    }\n  };\n  sink[Symbol.dispose] = () => {\n    options.writeSync(fd, encoder.encode(buffer));\n    options.flushSync(fd);\n    options.closeSync(fd);\n  };\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;AAkEA,SAAgB,gBACdA,MACAC,SACmB;CACnB,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,UAAU,QAAQ,WAAW,IAAI;CACvC,MAAM,aAAa,QAAQ,cAAc,OAAO;CAChD,IAAI,KAAK,QAAQ,OAAO,OAAO,QAAQ,SAAS,KAAK;CACrD,IAAIC,SAAiB;CACrB,MAAMC,OAA0B,CAACC,WAAsB;AACrD,MAAI,MAAM,KAAM,MAAK,QAAQ,SAAS,KAAK;AAC3C,YAAU,UAAU,OAAO;AAC3B,MAAI,OAAO,UAAU,YAAY;AAC/B,WAAQ,UAAU,IAAI,QAAQ,OAAO,OAAO,CAAC;AAC7C,YAAS;AACT,WAAQ,UAAU,GAAG;EACtB;CACF;AACD,MAAK,OAAO,WAAW,MAAM;AAC3B,MAAI,OAAO,MAAM;AACf,WAAQ,UAAU,IAAI,QAAQ,OAAO,OAAO,CAAC;AAC7C,WAAQ,UAAU,GAAG;AACrB,WAAQ,UAAU,GAAG;EACtB;CACF;AACD,QAAO;AACR;;;;;;;;;;;;;;AAiDD,SAAgB,wBACdJ,MACAK,SACmB;CACnB,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,UAAU,QAAQ,WAAW,IAAI;CACvC,MAAM,UAAU,QAAQ,WAAW,OAAO;CAC1C,MAAM,WAAW,QAAQ,YAAY;CACrC,MAAM,aAAa,QAAQ,cAAc,OAAO;CAChD,IAAIC,SAAiB;AACrB,KAAI;EACF,MAAM,OAAO,QAAQ,SAAS,KAAK;AACnC,WAAS,KAAK;CACf,QAAO,CAEP;CACD,IAAI,KAAK,QAAQ,SAAS,KAAK;CAC/B,SAAS,eAAeC,OAA4B;AAClD,SAAO,SAAS,MAAM,SAAS;CAChC;CACD,SAAS,kBAAwB;AAC/B,UAAQ,UAAU,GAAG;AACrB,OAAK,IAAI,IAAI,WAAW,GAAG,IAAI,GAAG,KAAK;GACrC,MAAM,WAAW,EAAE,KAAK,GAAG,EAAE;GAC7B,MAAM,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE;AACjC,OAAI;AACF,YAAQ,WAAW,SAAS,QAAQ;GACrC,SAAQ,GAAG,CAEX;EACF;AACD,UAAQ,WAAW,OAAO,EAAE,KAAK,IAAI;AACrC,WAAS;AACT,OAAK,QAAQ,SAAS,KAAK;CAC5B;CACD,IAAIL,SAAiB;CACrB,MAAMC,OAA0B,CAACC,WAAsB;AACrD,YAAU,UAAU,OAAO;AAC3B,MAAI,OAAO,UAAU,YAAY;GAC/B,MAAM,QAAQ,QAAQ,OAAO,OAAO;AACpC,YAAS;AACT,OAAI,eAAe,MAAM,CAAE,kBAAiB;AAC5C,WAAQ,UAAU,IAAI,MAAM;AAC5B,WAAQ,UAAU,GAAG;AACrB,aAAU,MAAM;EACjB;CACF;AACD,MAAK,OAAO,WAAW,MAAM;AAC3B,UAAQ,UAAU,IAAI,QAAQ,OAAO,OAAO,CAAC;AAC7C,UAAQ,UAAU,GAAG;AACrB,UAAQ,UAAU,GAAG;CACtB;AACD,QAAO;AACR"}

package/filesink.base.ts

@@ -13,6 +13,15 @@ export type FileSinkOptions = StreamSinkOptions & {
    * If `true`, the file is not opened until the first write.  Defaults to `false`.
    */
   lazy?: boolean;
+
+  /**
+   * The size of the buffer to use when writing to the file.  If not specified,
+   * a default buffer size will be used.  If it is less or equal to 0,
+   * the file will be written directly without buffering.
+   * @default 8192
+   * @since 0.12.0
+   */
+  bufferSize?: number;
 };
 
 /**
@@ -61,16 +70,22 @@ export function getBaseFileSink<TFile>(
 ): Sink & Disposable {
   const formatter = options.formatter ?? defaultTextFormatter;
   const encoder = options.encoder ?? new TextEncoder();
+  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 chars
   let fd = options.lazy ? null : options.openSync(path);
+  let buffer: string = "";
   const sink: Sink & Disposable = (record: LogRecord) => {
-    if (fd === null) {
-      fd = options.openSync(path);
+    if (fd == null) fd = options.openSync(path);
+    buffer += formatter(record);
+    if (buffer.length >= bufferSize) {
+      options.writeSync(fd, encoder.encode(buffer));
+      buffer = "";
+      options.flushSync(fd);
     }
-    options.writeSync(fd, encoder.encode(formatter(record)));
-    options.flushSync(fd);
   };
   sink[Symbol.dispose] = () => {
     if (fd !== null) {
+      options.writeSync(fd, encoder.encode(buffer));
+      options.flushSync(fd);
       options.closeSync(fd);
     }
   };
@@ -132,6 +147,7 @@ export function getBaseRotatingFileSink<TFile>(
   const encoder = options.encoder ?? new TextEncoder();
   const maxSize = options.maxSize ?? 1024 * 1024;
   const maxFiles = options.maxFiles ?? 5;
+  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 chars
   let offset: number = 0;
   try {
     const stat = options.statSync(path);
@@ -158,13 +174,22 @@ export function getBaseRotatingFileSink<TFile>(
     offset = 0;
     fd = options.openSync(path);
   }
+  let buffer: string = "";
   const sink: Sink & Disposable = (record: LogRecord) => {
-    const bytes = encoder.encode(formatter(record));
-    if (shouldRollover(bytes)) performRollover();
-    options.writeSync(fd, bytes);
+    buffer += formatter(record);
+    if (buffer.length >= bufferSize) {
+      const bytes = encoder.encode(buffer);
+      buffer = "";
+      if (shouldRollover(bytes)) performRollover();
+      options.writeSync(fd, bytes);
+      options.flushSync(fd);
+      offset += bytes.length;
+    }
+  };
+  sink[Symbol.dispose] = () => {
+    options.writeSync(fd, encoder.encode(buffer));
     options.flushSync(fd);
-    offset += bytes.length;
+    options.closeSync(fd);
   };
-  sink[Symbol.dispose] = () => options.closeSync(fd);
   return sink;
 }

package/filesink.test.ts

@@ -142,10 +142,209 @@ test("getFileSink()", () => {
   );
 });
 
+test("getFileSink() with bufferSize: 0 (no buffering)", () => {
+  const path = makeTempFileSync();
+  const sink: Sink & Disposable = getFileSink(path, { bufferSize: 0 });
+
+  // Write first log entry
+  sink(debug);
+  // With no buffering, content should be immediately written to file
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!\n",
+  );
+
+  // Write second log entry
+  sink(info);
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Write remaining entries
+  sink(warning);
+  sink(error);
+  sink(fatal);
+  sink[Symbol.dispose]();
+
+  // Final verification
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [ERR] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [FTL] my-app·junk: Hello, 123 & 456!
+`,
+  );
+});
+
+test("getFileSink() with small buffer size", () => {
+  const path = makeTempFileSync();
+  // Use a small buffer size (100 characters) to test buffering behavior
+  const sink: Sink & Disposable = getFileSink(path, { bufferSize: 100 });
+
+  // Write first log entry (about 65 characters)
+  sink(debug);
+  // Should be buffered, not yet written to file
+  assertEquals(fs.readFileSync(path, { encoding: "utf-8" }), "");
+
+  // Write second log entry - this should exceed buffer size and trigger flush
+  sink(info);
+  // Both entries should now be written to file
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Write third log entry - should be buffered again
+  sink(warning);
+  // Should still only have the first two entries
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Dispose should flush remaining buffer content
+  sink[Symbol.dispose]();
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!
+`,
+  );
+});
+
+test("getRotatingFileSink() with bufferSize: 0 (no buffering)", () => {
+  const path = makeTempFileSync();
+  const sink: Sink & Disposable = getRotatingFileSink(path, {
+    maxSize: 150,
+    bufferSize: 0, // No buffering - immediate writes
+  });
+
+  // Write first log entry - should be immediately written
+  sink(debug);
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!\n",
+  );
+
+  // Write second log entry - should be immediately written
+  sink(info);
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Write third log entry - should trigger rotation
+  sink(warning);
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    "2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!\n",
+  );
+  // Check that rotation occurred
+  assertEquals(
+    fs.readFileSync(`${path}.1`, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  sink[Symbol.dispose]();
+});
+
+test("getRotatingFileSink() with small buffer size", () => {
+  const path = makeTempFileSync();
+  const sink: Sink & Disposable = getRotatingFileSink(path, {
+    maxSize: 200, // Larger maxSize to allow for buffering tests
+    bufferSize: 100, // Small buffer to test interaction with rotation
+  });
+
+  // Write first log entry - should be buffered
+  sink(debug);
+  assertEquals(fs.readFileSync(path, { encoding: "utf-8" }), "");
+
+  // Write second log entry - should trigger buffer flush
+  sink(info);
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Write third log entry - should be buffered again
+  sink(warning);
+  assertEquals(
+    fs.readFileSync(path, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Write fourth log entry - should flush buffer and likely trigger rotation
+  sink(error);
+
+  // Dispose should flush any remaining buffer content
+  sink[Symbol.dispose]();
+
+  // Verify final state - all entries should be written somewhere
+  const mainContent = fs.readFileSync(path, { encoding: "utf-8" });
+  let rotatedContent = "";
+  try {
+    rotatedContent = fs.readFileSync(`${path}.1`, { encoding: "utf-8" });
+  } catch {
+    // No rotation occurred
+  }
+
+  const allContent = mainContent + rotatedContent;
+  // All four log entries should be present exactly once in either main or rotated file
+  const expectedEntries = [
+    "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!\n",
+    "2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!\n",
+    "2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!\n",
+    "2023-11-14 22:13:20.000 +00:00 [ERR] my-app·junk: Hello, 123 & 456!\n",
+  ];
+
+  for (const entry of expectedEntries) {
+    assertEquals(
+      allContent.includes(entry),
+      true,
+      `Missing log entry: ${entry.trim()}`,
+    );
+  }
+
+  // Verify each entry appears exactly once
+  for (const entry of expectedEntries) {
+    const firstIndex = allContent.indexOf(entry);
+    const lastIndex = allContent.lastIndexOf(entry);
+    assertEquals(firstIndex, lastIndex, `Duplicate log entry: ${entry.trim()}`);
+  }
+});
+
 test("getRotatingFileSink()", () => {
   const path = makeTempFileSync();
   const sink: Sink & Disposable = getRotatingFileSink(path, {
     maxSize: 150,
+    bufferSize: 0, // Disable buffering for this test to maintain existing behavior
   });
   sink(debug);
   assertEquals(
@@ -212,6 +411,7 @@ test("getRotatingFileSink()", () => {
   const path2 = join(dirPath, "log");
   const sink2: Sink & Disposable = getRotatingFileSink(path2, {
     maxSize: 150,
+    bufferSize: 0, // Disable buffering for this test to maintain existing behavior
   });
   sink2(debug);
   assertEquals(
@@ -221,4 +421,133 @@ test("getRotatingFileSink()", () => {
   sink2[Symbol.dispose]();
 });
 
+test("getBaseFileSink() with buffer edge cases", () => {
+  // Test negative bufferSize (should behave like bufferSize: 0)
+  const path1 = makeTempFileSync();
+  let sink1: Sink & Disposable;
+  if (isDeno) {
+    const driver: FileSinkDriver<Deno.FsFile> = {
+      openSync(path: string) {
+        return Deno.openSync(path, { create: true, append: true });
+      },
+      writeSync(fd, chunk) {
+        fd.writeSync(chunk);
+      },
+      flushSync(fd) {
+        fd.syncSync();
+      },
+      closeSync(fd) {
+        fd.close();
+      },
+    };
+    sink1 = getBaseFileSink(path1, { ...driver, bufferSize: -10 });
+  } else {
+    const driver: FileSinkDriver<number> = {
+      openSync(path: string) {
+        return fs.openSync(path, "a");
+      },
+      writeSync: fs.writeSync,
+      flushSync: fs.fsyncSync,
+      closeSync: fs.closeSync,
+    };
+    sink1 = getBaseFileSink(path1, { ...driver, bufferSize: -10 });
+  }
+
+  sink1(debug);
+  // With negative bufferSize, should write immediately
+  assertEquals(
+    fs.readFileSync(path1, { encoding: "utf-8" }),
+    "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!\n",
+  );
+  sink1[Symbol.dispose]();
+
+  // Test bufferSize of 1 (very small)
+  const path2 = makeTempFileSync();
+  let sink2: Sink & Disposable;
+  if (isDeno) {
+    const driver: FileSinkDriver<Deno.FsFile> = {
+      openSync(path: string) {
+        return Deno.openSync(path, { create: true, append: true });
+      },
+      writeSync(fd, chunk) {
+        fd.writeSync(chunk);
+      },
+      flushSync(fd) {
+        fd.syncSync();
+      },
+      closeSync(fd) {
+        fd.close();
+      },
+    };
+    sink2 = getBaseFileSink(path2, { ...driver, bufferSize: 1 });
+  } else {
+    const driver: FileSinkDriver<number> = {
+      openSync(path: string) {
+        return fs.openSync(path, "a");
+      },
+      writeSync: fs.writeSync,
+      flushSync: fs.fsyncSync,
+      closeSync: fs.closeSync,
+    };
+    sink2 = getBaseFileSink(path2, { ...driver, bufferSize: 1 });
+  }
+
+  sink2(debug);
+  // With bufferSize of 1, should write immediately since log entry > 1 char
+  assertEquals(
+    fs.readFileSync(path2, { encoding: "utf-8" }),
+    "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!\n",
+  );
+  sink2[Symbol.dispose]();
+
+  // Test very large bufferSize
+  const path3 = makeTempFileSync();
+  let sink3: Sink & Disposable;
+  if (isDeno) {
+    const driver: FileSinkDriver<Deno.FsFile> = {
+      openSync(path: string) {
+        return Deno.openSync(path, { create: true, append: true });
+      },
+      writeSync(fd, chunk) {
+        fd.writeSync(chunk);
+      },
+      flushSync(fd) {
+        fd.syncSync();
+      },
+      closeSync(fd) {
+        fd.close();
+      },
+    };
+    sink3 = getBaseFileSink(path3, { ...driver, bufferSize: 10000 });
+  } else {
+    const driver: FileSinkDriver<number> = {
+      openSync(path: string) {
+        return fs.openSync(path, "a");
+      },
+      writeSync: fs.writeSync,
+      flushSync: fs.fsyncSync,
+      closeSync: fs.closeSync,
+    };
+    sink3 = getBaseFileSink(path3, { ...driver, bufferSize: 10000 });
+  }
+
+  // Write multiple entries that shouldn't exceed the large buffer
+  sink3(debug);
+  sink3(info);
+  sink3(warning);
+  // Should still be buffered (file empty)
+  assertEquals(fs.readFileSync(path3, { encoding: "utf-8" }), "");
+
+  // Dispose should flush all buffered content
+  sink3[Symbol.dispose]();
+  assertEquals(
+    fs.readFileSync(path3, { encoding: "utf-8" }),
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!
+`,
+  );
+});
+
 // cSpell: ignore filesink

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "0.12.0-dev.191+20e736ff",
+  "version": "0.12.0-dev.194+4b7c1127",
   "description": "File sink and rotating file sink for LogTape",
   "keywords": [
     "logging",
@@ -50,7 +50,7 @@
     }
   },
   "peerDependencies": {
-    "@logtape/logtape": "0.12.0-dev.191+20e736ff"
+    "@logtape/logtape": "0.12.0-dev.194+4b7c1127"
   },
   "devDependencies": {
     "@david/which-runtime": "npm:@jsr/david__which-runtime@^0.2.1",