@logtape/logtape 1.0.0-dev.208 → 1.0.0-dev.209

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "1.0.0-dev.208+b3f9fea2",
+  "version": "1.0.0-dev.209+dd32a335",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/mod.cjs

@@ -15,6 +15,7 @@ exports.defaultConsoleFormatter = require_formatter.defaultConsoleFormatter;
 exports.defaultTextFormatter = require_formatter.defaultTextFormatter;
 exports.dispose = require_config.dispose;
 exports.disposeSync = require_config.disposeSync;
+exports.fromAsyncSink = require_sink.fromAsyncSink;
 exports.getAnsiColorFormatter = require_formatter.getAnsiColorFormatter;
 exports.getConfig = require_config.getConfig;
 exports.getConsoleSink = require_sink.getConsoleSink;

package/dist/mod.d.cts

@@ -3,7 +3,7 @@ import { LogLevel, compareLogLevel, getLogLevels, isLogLevel, parseLogLevel } fr
 import { LogRecord } from "./record.cjs";
 import { Filter, FilterLike, getLevelFilter, toFilter } from "./filter.cjs";
 import { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, ConsoleFormatter, FormattedValues, JsonLinesFormatterOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, defaultConsoleFormatter, defaultTextFormatter, getAnsiColorFormatter, getJsonLinesFormatter, getTextFormatter, jsonLinesFormatter } from "./formatter.cjs";
-import { BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, getConsoleSink, getStreamSink, withBuffer, withFilter } from "./sink.cjs";
+import { AsyncSink, BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, fromAsyncSink, getConsoleSink, getStreamSink, withBuffer, withFilter } from "./sink.cjs";
 import { Config, ConfigError, LoggerConfig, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync } from "./config.cjs";
 import { LogMethod, Logger, getLogger } from "./logger.cjs";
-export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, BufferSinkOptions, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FormattedValues, JsonLinesFormatterOptions, LogLevel, LogMethod, LogRecord, Logger, LoggerConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogger, getStreamSink, getTextFormatter, isLogLevel, jsonLinesFormatter, parseLogLevel, reset, resetSync, toFilter, withBuffer, withContext, withFilter };
+export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, AsyncSink, BufferSinkOptions, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FormattedValues, JsonLinesFormatterOptions, LogLevel, LogMethod, LogRecord, Logger, LoggerConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogger, getStreamSink, getTextFormatter, isLogLevel, jsonLinesFormatter, parseLogLevel, reset, resetSync, toFilter, withBuffer, withContext, withFilter };

package/dist/mod.d.ts

@@ -3,7 +3,7 @@ import { LogLevel, compareLogLevel, getLogLevels, isLogLevel, parseLogLevel } fr
 import { LogRecord } from "./record.js";
 import { Filter, FilterLike, getLevelFilter, toFilter } from "./filter.js";
 import { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, ConsoleFormatter, FormattedValues, JsonLinesFormatterOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, defaultConsoleFormatter, defaultTextFormatter, getAnsiColorFormatter, getJsonLinesFormatter, getTextFormatter, jsonLinesFormatter } from "./formatter.js";
-import { BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, getConsoleSink, getStreamSink, withBuffer, withFilter } from "./sink.js";
+import { AsyncSink, BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, fromAsyncSink, getConsoleSink, getStreamSink, withBuffer, withFilter } from "./sink.js";
 import { Config, ConfigError, LoggerConfig, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync } from "./config.js";
 import { LogMethod, Logger, getLogger } from "./logger.js";
-export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, BufferSinkOptions, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FormattedValues, JsonLinesFormatterOptions, LogLevel, LogMethod, LogRecord, Logger, LoggerConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogger, getStreamSink, getTextFormatter, isLogLevel, jsonLinesFormatter, parseLogLevel, reset, resetSync, toFilter, withBuffer, withContext, withFilter };
+export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, AsyncSink, BufferSinkOptions, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FormattedValues, JsonLinesFormatterOptions, LogLevel, LogMethod, LogRecord, Logger, LoggerConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogger, getStreamSink, getTextFormatter, isLogLevel, jsonLinesFormatter, parseLogLevel, reset, resetSync, toFilter, withBuffer, withContext, withFilter };

package/dist/mod.js

@@ -2,8 +2,8 @@ import { getLevelFilter, toFilter } from "./filter.js";
 import { compareLogLevel, getLogLevels, isLogLevel, parseLogLevel } from "./level.js";
 import { getLogger } from "./logger.js";
 import { ansiColorFormatter, defaultConsoleFormatter, defaultTextFormatter, getAnsiColorFormatter, getJsonLinesFormatter, getTextFormatter, jsonLinesFormatter } from "./formatter.js";
-import { getConsoleSink, getStreamSink, withBuffer, withFilter } from "./sink.js";
+import { fromAsyncSink, getConsoleSink, getStreamSink, withBuffer, withFilter } from "./sink.js";
 import { ConfigError, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync } from "./config.js";
 import { withContext } from "./context.js";
 
-export { ConfigError, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogger, getStreamSink, getTextFormatter, isLogLevel, jsonLinesFormatter, parseLogLevel, reset, resetSync, toFilter, withBuffer, withContext, withFilter };
+export { ConfigError, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogger, getStreamSink, getTextFormatter, isLogLevel, jsonLinesFormatter, parseLogLevel, reset, resetSync, toFilter, withBuffer, withContext, withFilter };

package/dist/sink.cjs

@@ -151,8 +151,39 @@ function getConsoleSink(options = {}) {
 		} else console[method](...args);
 	};
 }
+/**
+* Converts an async sink into a regular sink with proper async handling.
+* The returned sink chains async operations to ensure proper ordering and
+* implements AsyncDisposable to wait for all pending operations on disposal.
+*
+* @example Create a sink that asynchronously posts to a webhook
+* ```typescript
+* const asyncSink: AsyncSink = async (record) => {
+*   await fetch("https://example.com/logs", {
+*     method: "POST",
+*     body: JSON.stringify(record),
+*   });
+* };
+* const sink = fromAsyncSink(asyncSink);
+* ```
+*
+* @param asyncSink The async sink function to convert.
+* @returns A sink that properly handles async operations and disposal.
+* @since 1.0.0
+*/
+function fromAsyncSink(asyncSink) {
+	let lastPromise = Promise.resolve();
+	const sink = (record) => {
+		lastPromise = lastPromise.then(() => asyncSink(record)).catch(() => {});
+	};
+	sink[Symbol.asyncDispose] = async () => {
+		await lastPromise;
+	};
+	return sink;
+}
 
 //#endregion
+exports.fromAsyncSink = fromAsyncSink;
 exports.getConsoleSink = getConsoleSink;
 exports.getStreamSink = getStreamSink;
 exports.withBuffer = withBuffer;

package/dist/sink.d.cts

@@ -15,6 +15,16 @@ import { ConsoleFormatter, TextFormatter } from "./formatter.cjs";
  * @param record The log record to sink.
  */
 type Sink = (record: LogRecord) => void;
+/**
+ * An async sink is a function that accepts a log record and asynchronously
+ * processes it. This type is used with {@link fromAsyncSink} to create
+ * a regular sink that properly handles asynchronous operations.
+ *
+ * @param record The log record to process asynchronously.
+ * @returns A promise that resolves when the record has been processed.
+ * @since 1.0.0
+ */
+type AsyncSink = (record: LogRecord) => Promise<void>;
 /**
  * Turns a sink into a filtered sink.  The returned sink only logs records that
  * pass the filter.
@@ -146,6 +156,27 @@ interface ConsoleSinkOptions {
  * @returns A sink that logs to the console.
  */
 declare function getConsoleSink(options?: ConsoleSinkOptions): Sink;
+/**
+ * Converts an async sink into a regular sink with proper async handling.
+ * The returned sink chains async operations to ensure proper ordering and
+ * implements AsyncDisposable to wait for all pending operations on disposal.
+ *
+ * @example Create a sink that asynchronously posts to a webhook
+ * ```typescript
+ * const asyncSink: AsyncSink = async (record) => {
+ *   await fetch("https://example.com/logs", {
+ *     method: "POST",
+ *     body: JSON.stringify(record),
+ *   });
+ * };
+ * const sink = fromAsyncSink(asyncSink);
+ * ```
+ *
+ * @param asyncSink The async sink function to convert.
+ * @returns A sink that properly handles async operations and disposal.
+ * @since 1.0.0
+ */
+declare function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable;
 //#endregion
-export { BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, getConsoleSink, getStreamSink, withBuffer, withFilter };
+export { AsyncSink, BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, fromAsyncSink, getConsoleSink, getStreamSink, withBuffer, withFilter };
 //# sourceMappingURL=sink.d.cts.map

package/dist/sink.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.cts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAgBA;;;;;AAAgE;AAW/C,KA3BL,IAAA,GA2BK,CAAA,MAAiB,EA3BN,SA2BM,EAAA,GAAA,IAAA;AAmClC;;;;;;AAGyB;AAsEzB;;;;AAS8C;AA2B9C;;AACU,iBA5JM,UAAA,CA4JN,IAAA,EA5JuB,IA4JvB,EAAA,MAAA,EA5JqC,UA4JrC,CAAA,EA5JkD,IA4JlD;;;;AAEe;AAkBpB,UArKY,iBAAA,CAqKC;EAKD;;;;;EAsBW,UAAE,CAAA,EAAA,MAAA;EAAa;;AAKxB;AASnB;;;EAA+D,aAAG,CAAA,EAAA,MAAA;AAAI;;;;;;;;;;;;;;;;;;;iBA3KtD,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkBL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;iBASI,cAAA,WAAwB,qBAA0B"}
+{"version":3,"file":"sink.d.cts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAWhE;AAmCA;;;;AAGG,KAjES,SAAA,GAiET,CAAA,MAAA,EAjE8B,SAiE9B,EAAA,GAjE4C,OAiE5C,CAAA,IAAA,CAAA;;AAAsB;AAsEzB;;;;AAS8C;AA2B9C;;;;;;AAGyB;AAkBpB,iBAhLW,UAAA,CAgLE,IAAA,EAhLe,IAgLf,EAAA,MAAA,EAhL6B,UAgL7B,CAAA,EAhL0C,IAgL1C;AAKlB;;;;AAsBoB,UAhMH,iBAAA,CAgMG;EAAQ;;;AAKT;AASnB;EAA8B,UAAA,CAAA,EAAA,MAAA;EAAA;;AAAwC;AA+CtE;;;EAAkD,aAAG,CAAA,EAAA,MAAA;;AAAsB;;;;;;;;;;;;;;;;;;iBA1N3D,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkBL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;iBASI,cAAA,WAAwB,qBAA0B;;;;;;;;;;;;;;;;;;;;;iBA+ClD,aAAA,YAAyB,YAAY,OAAO"}

package/dist/sink.d.ts

@@ -15,6 +15,16 @@ import { ConsoleFormatter, TextFormatter } from "./formatter.js";
  * @param record The log record to sink.
  */
 type Sink = (record: LogRecord) => void;
+/**
+ * An async sink is a function that accepts a log record and asynchronously
+ * processes it. This type is used with {@link fromAsyncSink} to create
+ * a regular sink that properly handles asynchronous operations.
+ *
+ * @param record The log record to process asynchronously.
+ * @returns A promise that resolves when the record has been processed.
+ * @since 1.0.0
+ */
+type AsyncSink = (record: LogRecord) => Promise<void>;
 /**
  * Turns a sink into a filtered sink.  The returned sink only logs records that
  * pass the filter.
@@ -146,6 +156,27 @@ interface ConsoleSinkOptions {
  * @returns A sink that logs to the console.
  */
 declare function getConsoleSink(options?: ConsoleSinkOptions): Sink;
+/**
+ * Converts an async sink into a regular sink with proper async handling.
+ * The returned sink chains async operations to ensure proper ordering and
+ * implements AsyncDisposable to wait for all pending operations on disposal.
+ *
+ * @example Create a sink that asynchronously posts to a webhook
+ * ```typescript
+ * const asyncSink: AsyncSink = async (record) => {
+ *   await fetch("https://example.com/logs", {
+ *     method: "POST",
+ *     body: JSON.stringify(record),
+ *   });
+ * };
+ * const sink = fromAsyncSink(asyncSink);
+ * ```
+ *
+ * @param asyncSink The async sink function to convert.
+ * @returns A sink that properly handles async operations and disposal.
+ * @since 1.0.0
+ */
+declare function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable;
 //#endregion
-export { BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, getConsoleSink, getStreamSink, withBuffer, withFilter };
+export { AsyncSink, BufferSinkOptions, ConsoleSinkOptions, Sink, StreamSinkOptions, fromAsyncSink, getConsoleSink, getStreamSink, withBuffer, withFilter };
 //# sourceMappingURL=sink.d.ts.map

package/dist/sink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.ts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAgBA;;;;;AAAgE;AAW/C,KA3BL,IAAA,GA2BK,CAAA,MAAiB,EA3BN,SA2BM,EAAA,GAAA,IAAA;AAmClC;;;;;;AAGyB;AAsEzB;;;;AAS8C;AA2B9C;;AACU,iBA5JM,UAAA,CA4JN,IAAA,EA5JuB,IA4JvB,EAAA,MAAA,EA5JqC,UA4JrC,CAAA,EA5JkD,IA4JlD;;;;AAEe;AAkBpB,UArKY,iBAAA,CAqKC;EAKD;;;;;EAsBW,UAAE,CAAA,EAAA,MAAA;EAAa;;AAKxB;AASnB;;;EAA+D,aAAG,CAAA,EAAA,MAAA;AAAI;;;;;;;;;;;;;;;;;;;iBA3KtD,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkBL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;iBASI,cAAA,WAAwB,qBAA0B"}
+{"version":3,"file":"sink.d.ts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAWhE;AAmCA;;;;AAGG,KAjES,SAAA,GAiET,CAAA,MAAA,EAjE8B,SAiE9B,EAAA,GAjE4C,OAiE5C,CAAA,IAAA,CAAA;;AAAsB;AAsEzB;;;;AAS8C;AA2B9C;;;;;;AAGyB;AAkBpB,iBAhLW,UAAA,CAgLE,IAAA,EAhLe,IAgLf,EAAA,MAAA,EAhL6B,UAgL7B,CAAA,EAhL0C,IAgL1C;AAKlB;;;;AAsBoB,UAhMH,iBAAA,CAgMG;EAAQ;;;AAKT;AASnB;EAA8B,UAAA,CAAA,EAAA,MAAA;EAAA;;AAAwC;AA+CtE;;;EAAkD,aAAG,CAAA,EAAA,MAAA;;AAAsB;;;;;;;;;;;;;;;;;;iBA1N3D,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkBL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;iBASI,cAAA,WAAwB,qBAA0B;;;;;;;;;;;;;;;;;;;;;iBA+ClD,aAAA,YAAyB,YAAY,OAAO"}

package/dist/sink.js

@@ -151,7 +151,37 @@ function getConsoleSink(options = {}) {
 		} else console[method](...args);
 	};
 }
+/**
+* Converts an async sink into a regular sink with proper async handling.
+* The returned sink chains async operations to ensure proper ordering and
+* implements AsyncDisposable to wait for all pending operations on disposal.
+*
+* @example Create a sink that asynchronously posts to a webhook
+* ```typescript
+* const asyncSink: AsyncSink = async (record) => {
+*   await fetch("https://example.com/logs", {
+*     method: "POST",
+*     body: JSON.stringify(record),
+*   });
+* };
+* const sink = fromAsyncSink(asyncSink);
+* ```
+*
+* @param asyncSink The async sink function to convert.
+* @returns A sink that properly handles async operations and disposal.
+* @since 1.0.0
+*/
+function fromAsyncSink(asyncSink) {
+	let lastPromise = Promise.resolve();
+	const sink = (record) => {
+		lastPromise = lastPromise.then(() => asyncSink(record)).catch(() => {});
+	};
+	sink[Symbol.asyncDispose] = async () => {
+		await lastPromise;
+	};
+	return sink;
+}
 
 //#endregion
-export { getConsoleSink, getStreamSink, withBuffer, withFilter };
+export { fromAsyncSink, getConsoleSink, getStreamSink, withBuffer, withFilter };
 //# sourceMappingURL=sink.js.map

package/dist/sink.js.map

@@ -1 +1 @@
-{"version":3,"file":"sink.js","names":["sink: Sink","filter: FilterLike","record: LogRecord","options: BufferSinkOptions","buffer: LogRecord[]","flushTimer: ReturnType<typeof setTimeout> | null","bufferedSink: Sink & AsyncDisposable","stream: WritableStream","options: StreamSinkOptions","sink: Sink & AsyncDisposable","options: ConsoleSinkOptions","levelMap: Record<LogLevel, ConsoleMethod>"],"sources":["../sink.ts"],"sourcesContent":["import { type FilterLike, toFilter } from \"./filter.ts\";\nimport {\n  type ConsoleFormatter,\n  defaultConsoleFormatter,\n  defaultTextFormatter,\n  type TextFormatter,\n} from \"./formatter.ts\";\nimport type { LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\n\n/**\n * A sink is a function that accepts a log record and prints it somewhere.\n * Thrown exceptions will be suppressed and then logged to the meta logger,\n * a {@link Logger} with the category `[\"logtape\", \"meta\"]`.  (In that case,\n * the meta log record will not be passed to the sink to avoid infinite\n * recursion.)\n *\n * @param record The log record to sink.\n */\nexport type Sink = (record: LogRecord) => void;\n\n/**\n * Turns a sink into a filtered sink.  The returned sink only logs records that\n * pass the filter.\n *\n * @example Filter a console sink to only log records with the info level\n * ```typescript\n * const sink = withFilter(getConsoleSink(), \"info\");\n * ```\n *\n * @param sink A sink to be filtered.\n * @param filter A filter to apply to the sink.  It can be either a filter\n *               function or a {@link LogLevel} string.\n * @returns A sink that only logs records that pass the filter.\n */\nexport function withFilter(sink: Sink, filter: FilterLike): Sink {\n  const filterFunc = toFilter(filter);\n  return (record: LogRecord) => {\n    if (filterFunc(record)) sink(record);\n  };\n}\n\n/**\n * Options for the {@link withBuffer} function.\n * @since 1.0.0\n */\nexport interface BufferSinkOptions {\n  /**\n   * The maximum number of log records to buffer before flushing to the\n   * underlying sink.\n   * @default `10`\n   */\n  bufferSize?: number;\n\n  /**\n   * The maximum time in milliseconds to wait before flushing buffered records\n   * to the underlying sink.  Defaults to 5000 (5 seconds).  Set to 0 or\n   * negative to disable time-based flushing.\n   * @default `5000`\n   */\n  flushInterval?: number;\n}\n\n/**\n * Turns a sink into a buffered sink.  The returned sink buffers log records\n * in memory and flushes them to the underlying sink when the buffer is full\n * or after a specified time interval.\n *\n * @example Buffer a console sink with custom options\n * ```typescript\n * const sink = withBuffer(getConsoleSink(), {\n *   bufferSize: 5,\n *   flushInterval: 1000\n * });\n * ```\n *\n * @param sink A sink to be buffered.\n * @param options Options for the buffered sink.\n * @returns A buffered sink that flushes records periodically.\n * @since 1.0.0\n */\nexport function withBuffer(\n  sink: Sink,\n  options: BufferSinkOptions = {},\n): Sink & AsyncDisposable {\n  const bufferSize = options.bufferSize ?? 10;\n  const flushInterval = options.flushInterval ?? 5000;\n\n  const buffer: LogRecord[] = [];\n  let flushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n\n  function flush(): void {\n    if (buffer.length === 0) return;\n\n    const records = buffer.splice(0);\n    for (const record of records) {\n      try {\n        sink(record);\n      } catch (error) {\n        // Errors are handled by the sink infrastructure\n        throw error;\n      }\n    }\n\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (flushInterval <= 0 || flushTimer !== null || disposed) return;\n\n    flushTimer = setTimeout(() => {\n      flushTimer = null;\n      flush();\n    }, flushInterval);\n  }\n\n  const bufferedSink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    buffer.push(record);\n\n    if (buffer.length >= bufferSize) {\n      flush();\n    } else {\n      scheduleFlush();\n    }\n  };\n\n  bufferedSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n    flush();\n\n    // Dispose the underlying sink if it's disposable\n    if (Symbol.asyncDispose in sink) {\n      await (sink as AsyncDisposable)[Symbol.asyncDispose]();\n    } else if (Symbol.dispose in sink) {\n      (sink as Disposable)[Symbol.dispose]();\n    }\n  };\n\n  return bufferedSink;\n}\n\n/**\n * Options for the {@link getStreamSink} function.\n */\nexport interface StreamSinkOptions {\n  /**\n   * The text formatter to use.  Defaults to {@link defaultTextFormatter}.\n   */\n  formatter?: TextFormatter;\n\n  /**\n   * The text encoder to use.  Defaults to an instance of {@link TextEncoder}.\n   */\n  encoder?: { encode(text: string): Uint8Array };\n}\n\n/**\n * A factory that returns a sink that writes to a {@link WritableStream}.\n *\n * Note that the `stream` is of Web Streams API, which is different from\n * Node.js streams.  You can convert a Node.js stream to a Web Streams API\n * stream using [`stream.Writable.toWeb()`] method.\n *\n * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable\n *\n * @example Sink to the standard error in Deno\n * ```typescript\n * const stderrSink = getStreamSink(Deno.stderr.writable);\n * ```\n *\n * @example Sink to the standard error in Node.js\n * ```typescript\n * import stream from \"node:stream\";\n * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));\n * ```\n *\n * @param stream The stream to write to.\n * @param options The options for the sink.\n * @returns A sink that writes to the stream.\n */\nexport function getStreamSink(\n  stream: WritableStream,\n  options: StreamSinkOptions = {},\n): Sink & AsyncDisposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const writer = stream.getWriter();\n  let lastPromise = Promise.resolve();\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    const bytes = encoder.encode(formatter(record));\n    lastPromise = lastPromise\n      .then(() => writer.ready)\n      .then(() => writer.write(bytes));\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    await lastPromise;\n    await writer.close();\n  };\n  return sink;\n}\n\ntype ConsoleMethod = \"debug\" | \"info\" | \"log\" | \"warn\" | \"error\";\n\n/**\n * Options for the {@link getConsoleSink} function.\n */\nexport interface ConsoleSinkOptions {\n  /**\n   * The console formatter or text formatter to use.\n   * Defaults to {@link defaultConsoleFormatter}.\n   */\n  formatter?: ConsoleFormatter | TextFormatter;\n\n  /**\n   * The mapping from log levels to console methods.  Defaults to:\n   *\n   * ```typescript\n   * {\n   *   trace: \"trace\",\n   *   debug: \"debug\",\n   *   info: \"info\",\n   *   warning: \"warn\",\n   *   error: \"error\",\n   *   fatal: \"error\",\n   * }\n   * ```\n   * @since 0.9.0\n   */\n  levelMap?: Record<LogLevel, ConsoleMethod>;\n\n  /**\n   * The console to log to.  Defaults to {@link console}.\n   */\n  console?: Console;\n}\n\n/**\n * A console sink factory that returns a sink that logs to the console.\n *\n * @param options The options for the sink.\n * @returns A sink that logs to the console.\n */\nexport function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {\n  const formatter = options.formatter ?? defaultConsoleFormatter;\n  const levelMap: Record<LogLevel, ConsoleMethod> = {\n    trace: \"debug\",\n    debug: \"debug\",\n    info: \"info\",\n    warning: \"warn\",\n    error: \"error\",\n    fatal: \"error\",\n    ...(options.levelMap ?? {}),\n  };\n  const console = options.console ?? globalThis.console;\n  return (record: LogRecord) => {\n    const args = formatter(record);\n    const method = levelMap[record.level];\n    if (method === undefined) {\n      throw new TypeError(`Invalid log level: ${record.level}.`);\n    }\n    if (typeof args === \"string\") {\n      const msg = args.replace(/\\r?\\n$/, \"\");\n      console[method](msg);\n    } else {\n      console[method](...args);\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,SAAgB,WAAWA,MAAYC,QAA0B;CAC/D,MAAM,aAAa,SAAS,OAAO;AACnC,QAAO,CAACC,WAAsB;AAC5B,MAAI,WAAW,OAAO,CAAE,MAAK,OAAO;CACrC;AACF;;;;;;;;;;;;;;;;;;;AAyCD,SAAgB,WACdF,MACAG,UAA6B,CAAE,GACP;CACxB,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,gBAAgB,QAAQ,iBAAiB;CAE/C,MAAMC,SAAsB,CAAE;CAC9B,IAAIC,aAAmD;CACvD,IAAI,WAAW;CAEf,SAAS,QAAc;AACrB,MAAI,OAAO,WAAW,EAAG;EAEzB,MAAM,UAAU,OAAO,OAAO,EAAE;AAChC,OAAK,MAAM,UAAU,QACnB,KAAI;AACF,QAAK,OAAO;EACb,SAAQ,OAAO;AAEd,SAAM;EACP;AAGH,MAAI,eAAe,MAAM;AACvB,gBAAa,WAAW;AACxB,gBAAa;EACd;CACF;CAED,SAAS,gBAAsB;AAC7B,MAAI,iBAAiB,KAAK,eAAe,QAAQ,SAAU;AAE3D,eAAa,WAAW,MAAM;AAC5B,gBAAa;AACb,UAAO;EACR,GAAE,cAAc;CAClB;CAED,MAAMC,eAAuC,CAACJ,WAAsB;AAClE,MAAI,SAAU;AAEd,SAAO,KAAK,OAAO;AAEnB,MAAI,OAAO,UAAU,WACnB,QAAO;MAEP,gBAAe;CAElB;AAED,cAAa,OAAO,gBAAgB,YAAY;AAC9C,aAAW;AACX,MAAI,eAAe,MAAM;AACvB,gBAAa,WAAW;AACxB,gBAAa;EACd;AACD,SAAO;AAGP,MAAI,OAAO,gBAAgB,KACzB,OAAM,AAAC,KAAyB,OAAO,eAAe;WAC7C,OAAO,WAAW,KAC3B,CAAC,KAAoB,OAAO,UAAU;CAEzC;AAED,QAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;AAyCD,SAAgB,cACdK,QACAC,UAA6B,CAAE,GACP;CACxB,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,UAAU,QAAQ,WAAW,IAAI;CACvC,MAAM,SAAS,OAAO,WAAW;CACjC,IAAI,cAAc,QAAQ,SAAS;CACnC,MAAMC,OAA+B,CAACP,WAAsB;EAC1D,MAAM,QAAQ,QAAQ,OAAO,UAAU,OAAO,CAAC;AAC/C,gBAAc,YACX,KAAK,MAAM,OAAO,MAAM,CACxB,KAAK,MAAM,OAAO,MAAM,MAAM,CAAC;CACnC;AACD,MAAK,OAAO,gBAAgB,YAAY;AACtC,QAAM;AACN,QAAM,OAAO,OAAO;CACrB;AACD,QAAO;AACR;;;;;;;AA2CD,SAAgB,eAAeQ,UAA8B,CAAE,GAAQ;CACrE,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAMC,WAA4C;EAChD,OAAO;EACP,OAAO;EACP,MAAM;EACN,SAAS;EACT,OAAO;EACP,OAAO;EACP,GAAI,QAAQ,YAAY,CAAE;CAC3B;CACD,MAAM,UAAU,QAAQ,WAAW,WAAW;AAC9C,QAAO,CAACT,WAAsB;EAC5B,MAAM,OAAO,UAAU,OAAO;EAC9B,MAAM,SAAS,SAAS,OAAO;AAC/B,MAAI,kBACF,OAAM,IAAI,WAAW,qBAAqB,OAAO,MAAM;AAEzD,aAAW,SAAS,UAAU;GAC5B,MAAM,MAAM,KAAK,QAAQ,UAAU,GAAG;AACtC,WAAQ,QAAQ,IAAI;EACrB,MACC,SAAQ,QAAQ,GAAG,KAAK;CAE3B;AACF"}
+{"version":3,"file":"sink.js","names":["sink: Sink","filter: FilterLike","record: LogRecord","options: BufferSinkOptions","buffer: LogRecord[]","flushTimer: ReturnType<typeof setTimeout> | null","bufferedSink: Sink & AsyncDisposable","stream: WritableStream","options: StreamSinkOptions","sink: Sink & AsyncDisposable","options: ConsoleSinkOptions","levelMap: Record<LogLevel, ConsoleMethod>","asyncSink: AsyncSink"],"sources":["../sink.ts"],"sourcesContent":["import { type FilterLike, toFilter } from \"./filter.ts\";\nimport {\n  type ConsoleFormatter,\n  defaultConsoleFormatter,\n  defaultTextFormatter,\n  type TextFormatter,\n} from \"./formatter.ts\";\nimport type { LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\n\n/**\n * A sink is a function that accepts a log record and prints it somewhere.\n * Thrown exceptions will be suppressed and then logged to the meta logger,\n * a {@link Logger} with the category `[\"logtape\", \"meta\"]`.  (In that case,\n * the meta log record will not be passed to the sink to avoid infinite\n * recursion.)\n *\n * @param record The log record to sink.\n */\nexport type Sink = (record: LogRecord) => void;\n\n/**\n * An async sink is a function that accepts a log record and asynchronously\n * processes it. This type is used with {@link fromAsyncSink} to create\n * a regular sink that properly handles asynchronous operations.\n *\n * @param record The log record to process asynchronously.\n * @returns A promise that resolves when the record has been processed.\n * @since 1.0.0\n */\nexport type AsyncSink = (record: LogRecord) => Promise<void>;\n\n/**\n * Turns a sink into a filtered sink.  The returned sink only logs records that\n * pass the filter.\n *\n * @example Filter a console sink to only log records with the info level\n * ```typescript\n * const sink = withFilter(getConsoleSink(), \"info\");\n * ```\n *\n * @param sink A sink to be filtered.\n * @param filter A filter to apply to the sink.  It can be either a filter\n *               function or a {@link LogLevel} string.\n * @returns A sink that only logs records that pass the filter.\n */\nexport function withFilter(sink: Sink, filter: FilterLike): Sink {\n  const filterFunc = toFilter(filter);\n  return (record: LogRecord) => {\n    if (filterFunc(record)) sink(record);\n  };\n}\n\n/**\n * Options for the {@link withBuffer} function.\n * @since 1.0.0\n */\nexport interface BufferSinkOptions {\n  /**\n   * The maximum number of log records to buffer before flushing to the\n   * underlying sink.\n   * @default `10`\n   */\n  bufferSize?: number;\n\n  /**\n   * The maximum time in milliseconds to wait before flushing buffered records\n   * to the underlying sink.  Defaults to 5000 (5 seconds).  Set to 0 or\n   * negative to disable time-based flushing.\n   * @default `5000`\n   */\n  flushInterval?: number;\n}\n\n/**\n * Turns a sink into a buffered sink.  The returned sink buffers log records\n * in memory and flushes them to the underlying sink when the buffer is full\n * or after a specified time interval.\n *\n * @example Buffer a console sink with custom options\n * ```typescript\n * const sink = withBuffer(getConsoleSink(), {\n *   bufferSize: 5,\n *   flushInterval: 1000\n * });\n * ```\n *\n * @param sink A sink to be buffered.\n * @param options Options for the buffered sink.\n * @returns A buffered sink that flushes records periodically.\n * @since 1.0.0\n */\nexport function withBuffer(\n  sink: Sink,\n  options: BufferSinkOptions = {},\n): Sink & AsyncDisposable {\n  const bufferSize = options.bufferSize ?? 10;\n  const flushInterval = options.flushInterval ?? 5000;\n\n  const buffer: LogRecord[] = [];\n  let flushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n\n  function flush(): void {\n    if (buffer.length === 0) return;\n\n    const records = buffer.splice(0);\n    for (const record of records) {\n      try {\n        sink(record);\n      } catch (error) {\n        // Errors are handled by the sink infrastructure\n        throw error;\n      }\n    }\n\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (flushInterval <= 0 || flushTimer !== null || disposed) return;\n\n    flushTimer = setTimeout(() => {\n      flushTimer = null;\n      flush();\n    }, flushInterval);\n  }\n\n  const bufferedSink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    buffer.push(record);\n\n    if (buffer.length >= bufferSize) {\n      flush();\n    } else {\n      scheduleFlush();\n    }\n  };\n\n  bufferedSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n    flush();\n\n    // Dispose the underlying sink if it's disposable\n    if (Symbol.asyncDispose in sink) {\n      await (sink as AsyncDisposable)[Symbol.asyncDispose]();\n    } else if (Symbol.dispose in sink) {\n      (sink as Disposable)[Symbol.dispose]();\n    }\n  };\n\n  return bufferedSink;\n}\n\n/**\n * Options for the {@link getStreamSink} function.\n */\nexport interface StreamSinkOptions {\n  /**\n   * The text formatter to use.  Defaults to {@link defaultTextFormatter}.\n   */\n  formatter?: TextFormatter;\n\n  /**\n   * The text encoder to use.  Defaults to an instance of {@link TextEncoder}.\n   */\n  encoder?: { encode(text: string): Uint8Array };\n}\n\n/**\n * A factory that returns a sink that writes to a {@link WritableStream}.\n *\n * Note that the `stream` is of Web Streams API, which is different from\n * Node.js streams.  You can convert a Node.js stream to a Web Streams API\n * stream using [`stream.Writable.toWeb()`] method.\n *\n * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable\n *\n * @example Sink to the standard error in Deno\n * ```typescript\n * const stderrSink = getStreamSink(Deno.stderr.writable);\n * ```\n *\n * @example Sink to the standard error in Node.js\n * ```typescript\n * import stream from \"node:stream\";\n * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));\n * ```\n *\n * @param stream The stream to write to.\n * @param options The options for the sink.\n * @returns A sink that writes to the stream.\n */\nexport function getStreamSink(\n  stream: WritableStream,\n  options: StreamSinkOptions = {},\n): Sink & AsyncDisposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const writer = stream.getWriter();\n  let lastPromise = Promise.resolve();\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    const bytes = encoder.encode(formatter(record));\n    lastPromise = lastPromise\n      .then(() => writer.ready)\n      .then(() => writer.write(bytes));\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    await lastPromise;\n    await writer.close();\n  };\n  return sink;\n}\n\ntype ConsoleMethod = \"debug\" | \"info\" | \"log\" | \"warn\" | \"error\";\n\n/**\n * Options for the {@link getConsoleSink} function.\n */\nexport interface ConsoleSinkOptions {\n  /**\n   * The console formatter or text formatter to use.\n   * Defaults to {@link defaultConsoleFormatter}.\n   */\n  formatter?: ConsoleFormatter | TextFormatter;\n\n  /**\n   * The mapping from log levels to console methods.  Defaults to:\n   *\n   * ```typescript\n   * {\n   *   trace: \"trace\",\n   *   debug: \"debug\",\n   *   info: \"info\",\n   *   warning: \"warn\",\n   *   error: \"error\",\n   *   fatal: \"error\",\n   * }\n   * ```\n   * @since 0.9.0\n   */\n  levelMap?: Record<LogLevel, ConsoleMethod>;\n\n  /**\n   * The console to log to.  Defaults to {@link console}.\n   */\n  console?: Console;\n}\n\n/**\n * A console sink factory that returns a sink that logs to the console.\n *\n * @param options The options for the sink.\n * @returns A sink that logs to the console.\n */\nexport function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {\n  const formatter = options.formatter ?? defaultConsoleFormatter;\n  const levelMap: Record<LogLevel, ConsoleMethod> = {\n    trace: \"debug\",\n    debug: \"debug\",\n    info: \"info\",\n    warning: \"warn\",\n    error: \"error\",\n    fatal: \"error\",\n    ...(options.levelMap ?? {}),\n  };\n  const console = options.console ?? globalThis.console;\n  return (record: LogRecord) => {\n    const args = formatter(record);\n    const method = levelMap[record.level];\n    if (method === undefined) {\n      throw new TypeError(`Invalid log level: ${record.level}.`);\n    }\n    if (typeof args === \"string\") {\n      const msg = args.replace(/\\r?\\n$/, \"\");\n      console[method](msg);\n    } else {\n      console[method](...args);\n    }\n  };\n}\n\n/**\n * Converts an async sink into a regular sink with proper async handling.\n * The returned sink chains async operations to ensure proper ordering and\n * implements AsyncDisposable to wait for all pending operations on disposal.\n *\n * @example Create a sink that asynchronously posts to a webhook\n * ```typescript\n * const asyncSink: AsyncSink = async (record) => {\n *   await fetch(\"https://example.com/logs\", {\n *     method: \"POST\",\n *     body: JSON.stringify(record),\n *   });\n * };\n * const sink = fromAsyncSink(asyncSink);\n * ```\n *\n * @param asyncSink The async sink function to convert.\n * @returns A sink that properly handles async operations and disposal.\n * @since 1.0.0\n */\nexport function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable {\n  let lastPromise = Promise.resolve();\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    lastPromise = lastPromise\n      .then(() => asyncSink(record))\n      .catch(() => {\n        // Errors are handled by the sink infrastructure\n      });\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    await lastPromise;\n  };\n  return sink;\n}\n"],"mappings":"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"}

package/mod.ts

@@ -44,8 +44,10 @@ export {
 export { getLogger, type Logger, type LogMethod } from "./logger.ts";
 export type { LogRecord } from "./record.ts";
 export {
+  type AsyncSink,
   type BufferSinkOptions,
   type ConsoleSinkOptions,
+  fromAsyncSink,
   getConsoleSink,
   getStreamSink,
   type Sink,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "1.0.0-dev.208+b3f9fea2",
+  "version": "1.0.0-dev.209+dd32a335",
   "description": "Simple logging library with zero dependencies for Deno/Node.js/Bun/browsers",
   "keywords": [
     "logging",

package/sink.test.ts

@@ -9,6 +9,8 @@ import { defaultTextFormatter } from "./formatter.ts";
 import type { LogLevel } from "./level.ts";
 import type { LogRecord } from "./record.ts";
 import {
+  type AsyncSink,
+  fromAsyncSink,
   getConsoleSink,
   getStreamSink,
   type Sink,
@@ -635,3 +637,202 @@ test("withBuffer() - edge case: concurrent dispose and log calls", async () => {
   assertEquals(buffer.length, 1);
   assertEquals(buffer, [trace]);
 });
+
+test("fromAsyncSink() - basic functionality", async () => {
+  const buffer: LogRecord[] = [];
+  const asyncSink: AsyncSink = async (record) => {
+    await delay(10);
+    buffer.push(record);
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  sink(trace);
+  sink(debug);
+  sink(info);
+
+  // Records should not be in buffer immediately
+  assertEquals(buffer.length, 0);
+
+  // Wait for async operations to complete
+  await sink[Symbol.asyncDispose]();
+
+  // All records should be in buffer in order
+  assertEquals(buffer.length, 3);
+  assertEquals(buffer, [trace, debug, info]);
+});
+
+test("fromAsyncSink() - promise chaining preserves order", async () => {
+  const buffer: LogRecord[] = [];
+  const delays = [50, 10, 30]; // Different delays for each call
+  let callIndex = 0;
+
+  const asyncSink: AsyncSink = async (record) => {
+    const delayTime = delays[callIndex % delays.length];
+    callIndex++;
+    await delay(delayTime);
+    buffer.push(record);
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  sink(trace);
+  sink(debug);
+  sink(info);
+
+  await sink[Symbol.asyncDispose]();
+
+  // Despite different delays, order should be preserved
+  assertEquals(buffer.length, 3);
+  assertEquals(buffer, [trace, debug, info]);
+});
+
+test("fromAsyncSink() - error handling", async () => {
+  const buffer: LogRecord[] = [];
+  let errorCount = 0;
+
+  const asyncSink: AsyncSink = async (record) => {
+    if (record.level === "error") {
+      errorCount++;
+      throw new Error("Async sink error");
+    }
+    await Promise.resolve(); // Ensure it's async
+    buffer.push(record);
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  sink(trace);
+  sink(error); // This will throw in async sink
+  sink(info);
+
+  await sink[Symbol.asyncDispose]();
+
+  // Error should be caught and not break the chain
+  assertEquals(errorCount, 1);
+  assertEquals(buffer.length, 2);
+  assertEquals(buffer, [trace, info]);
+});
+
+test("fromAsyncSink() - multiple dispose calls", async () => {
+  const buffer: LogRecord[] = [];
+  const asyncSink: AsyncSink = async (record) => {
+    await delay(10);
+    buffer.push(record);
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  sink(trace);
+  sink(debug);
+
+  // First dispose
+  await sink[Symbol.asyncDispose]();
+  assertEquals(buffer.length, 2);
+
+  // Second dispose should be safe
+  await sink[Symbol.asyncDispose]();
+  assertEquals(buffer.length, 2);
+
+  // Third dispose should be safe
+  await sink[Symbol.asyncDispose]();
+  assertEquals(buffer.length, 2);
+});
+
+test("fromAsyncSink() - concurrent calls", async () => {
+  const buffer: LogRecord[] = [];
+  let concurrentCalls = 0;
+  let maxConcurrentCalls = 0;
+
+  const asyncSink: AsyncSink = async (record) => {
+    concurrentCalls++;
+    maxConcurrentCalls = Math.max(maxConcurrentCalls, concurrentCalls);
+    await delay(20);
+    buffer.push(record);
+    concurrentCalls--;
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  // Fire multiple calls rapidly
+  for (let i = 0; i < 5; i++) {
+    sink(trace);
+  }
+
+  await sink[Symbol.asyncDispose]();
+
+  // Due to promise chaining, max concurrent calls should be 1
+  assertEquals(maxConcurrentCalls, 1);
+  assertEquals(buffer.length, 5);
+});
+
+test("fromAsyncSink() - works with synchronous exceptions", async () => {
+  const buffer: LogRecord[] = [];
+  let errorCount = 0;
+
+  const asyncSink: AsyncSink = async (record) => {
+    if (record.level === "fatal") {
+      errorCount++;
+      // Synchronous throw before any await
+      throw new Error("Sync error in async sink");
+    }
+    await delay(10);
+    buffer.push(record);
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  sink(trace);
+  sink(fatal); // This will throw synchronously in async sink
+  sink(info);
+
+  await sink[Symbol.asyncDispose]();
+
+  // Error should still be caught
+  assertEquals(errorCount, 1);
+  assertEquals(buffer.length, 2);
+  assertEquals(buffer, [trace, info]);
+});
+
+test("fromAsyncSink() - very long async operations", async () => {
+  const buffer: LogRecord[] = [];
+  const asyncSink: AsyncSink = async (record) => {
+    await delay(100); // Longer delay
+    buffer.push(record);
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  sink(trace);
+  sink(debug);
+
+  // Don't wait, just dispose immediately
+  const disposePromise = sink[Symbol.asyncDispose]();
+
+  // Buffer should still be empty
+  assertEquals(buffer.length, 0);
+
+  // Wait for dispose to complete
+  await disposePromise;
+
+  // Now all records should be processed
+  assertEquals(buffer.length, 2);
+  assertEquals(buffer, [trace, debug]);
+});
+
+test("fromAsyncSink() - empty async sink", async () => {
+  const asyncSink: AsyncSink = async () => {
+    // Do nothing
+  };
+
+  const sink = fromAsyncSink(asyncSink);
+
+  // Should not throw
+  sink(trace);
+  sink(debug);
+
+  await sink[Symbol.asyncDispose]();
+
+  // Test passes if no errors thrown
+  assertEquals(true, true);
+});

package/sink.ts

@@ -19,6 +19,17 @@ import type { LogRecord } from "./record.ts";
  */
 export type Sink = (record: LogRecord) => void;
 
+/**
+ * An async sink is a function that accepts a log record and asynchronously
+ * processes it. This type is used with {@link fromAsyncSink} to create
+ * a regular sink that properly handles asynchronous operations.
+ *
+ * @param record The log record to process asynchronously.
+ * @returns A promise that resolves when the record has been processed.
+ * @since 1.0.0
+ */
+export type AsyncSink = (record: LogRecord) => Promise<void>;
+
 /**
  * Turns a sink into a filtered sink.  The returned sink only logs records that
  * pass the filter.
@@ -276,3 +287,38 @@ export function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {
     }
   };
 }
+
+/**
+ * Converts an async sink into a regular sink with proper async handling.
+ * The returned sink chains async operations to ensure proper ordering and
+ * implements AsyncDisposable to wait for all pending operations on disposal.
+ *
+ * @example Create a sink that asynchronously posts to a webhook
+ * ```typescript
+ * const asyncSink: AsyncSink = async (record) => {
+ *   await fetch("https://example.com/logs", {
+ *     method: "POST",
+ *     body: JSON.stringify(record),
+ *   });
+ * };
+ * const sink = fromAsyncSink(asyncSink);
+ * ```
+ *
+ * @param asyncSink The async sink function to convert.
+ * @returns A sink that properly handles async operations and disposal.
+ * @since 1.0.0
+ */
+export function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable {
+  let lastPromise = Promise.resolve();
+  const sink: Sink & AsyncDisposable = (record: LogRecord) => {
+    lastPromise = lastPromise
+      .then(() => asyncSink(record))
+      .catch(() => {
+        // Errors are handled by the sink infrastructure
+      });
+  };
+  sink[Symbol.asyncDispose] = async () => {
+    await lastPromise;
+  };
+  return sink;
+}