@logtape/adaptor-pino 1.0.0-dev.253

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+<!-- deno-fmt-ignore-file -->
+
+@logtape/adaptor-pino
+=====================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+*@logtape/adaptor-pino* is a [LogTape] adapter that forwards log records to
+[Pino] loggers, enabling seamless integration between LogTape-enabled libraries
+and applications using Pino for logging infrastructure.
+
+[JSR]: https://jsr.io/@logtape/adaptor-pino
+[JSR badge]: https://jsr.io/badges/@logtape/adaptor-pino
+[npm]: https://www.npmjs.com/package/@logtape/adaptor-pino
+[npm badge]: https://img.shields.io/npm/v/@logtape/adaptor-pino?logo=npm
+[LogTape]: https://logtape.org/
+[Pino]: https://getpino.io/
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@logtape/adaptor-pino  # for Deno
+npm  add     @logtape/adaptor-pino  # for npm
+pnpm add     @logtape/adaptor-pino  # for pnpm
+yarn add     @logtape/adaptor-pino  # for Yarn
+bun  add     @logtape/adaptor-pino  # for Bun
+~~~~
+
+
+Usage
+-----
+
+Configure LogTape to use the Pino adapter in your application:
+
+~~~~ typescript
+import { configure } from "@logtape/logtape";
+import { getPinoSink } from "@logtape/adaptor-pino";
+import pino from "pino";
+
+const pinoLogger = pino();
+
+await configure({
+  sinks: {
+    pino: getPinoSink(pinoLogger, {
+      category: {
+        position: "start",
+        decorator: "[]",
+        separator: "."
+      }
+    })
+  },
+  loggers: [
+    { category: "my-library", sinks: ["pino"] }
+  ]
+});
+~~~~
+
+
+Category formatting
+-------------------
+
+The adapter supports flexible category formatting options:
+
+~~~~typescript
+import { getPinoSink } from "@logtape/adaptor-pino";
+
+// Hide categories completely
+const sink1 = getPinoSink(logger, { category: false });
+
+// Use default formatting (category with ":" separator)
+const sink2 = getPinoSink(logger, { category: true });
+
+// Custom formatting
+const sink3 = getPinoSink(logger, {
+  category: {
+    position: "end",      // "start" or "end"
+    decorator: "[]",      // "[]", "()", "<>", "{}", ":", "-", "|", "/", ""
+    separator: "::"       // custom separator for multi-part categories
+  }
+});
+~~~~
+
+
+Docs
+----
+
+See the [API reference] on JSR for further details.
+
+[API reference]: https://jsr.io/@logtape/adaptor-pino/doc

package/deno.json

@@ -0,0 +1,37 @@
+{
+  "name": "@logtape/adaptor-pino",
+  "version": "1.0.0-dev.253+3fd9a841",
+  "license": "MIT",
+  "exports": "./mod.ts",
+  "imports": {
+    "pino-abstract-transport": "npm:pino-abstract-transport@^2.0.0"
+  },
+  "exclude": [
+    "coverage/",
+    "npm/",
+    ".dnt-import-map.json"
+  ],
+  "tasks": {
+    "build": "pnpm build",
+    "test": "deno test --allow-env --allow-sys",
+    "test:node": {
+      "dependencies": [
+        "build"
+      ],
+      "command": "node --experimental-transform-types --test"
+    },
+    "test:bun": {
+      "dependencies": [
+        "build"
+      ],
+      "command": "bun test"
+    },
+    "test-all": {
+      "dependencies": [
+        "test",
+        "test:node",
+        "test:bun"
+      ]
+    }
+  }
+}

package/dist/mod.cjs

@@ -0,0 +1,78 @@
+
+//#region mod.ts
+/**
+* Creates a LogTape sink that forwards log records to a Pino logger.
+*
+* This adapter allows LogTape-enabled libraries to integrate seamlessly with
+* applications that use Pino for logging.
+*
+* @example
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getPinoSink } from "@logtape/adaptor-pino";
+* import pino from "pino";
+*
+* const pinoLogger = pino();
+*
+* await configure({
+*   sinks: {
+*     pino: getPinoSink(pinoLogger, {
+*       category: {
+*         position: "start",
+*         decorator: "[]",
+*         separator: "."
+*       }
+*     })
+*   },
+*   loggers: [
+*     { category: "my-library", sinks: ["pino"] }
+*   ]
+* });
+* ```
+*
+* @typeParam CustomLevels The custom log levels supported by the Pino logger.
+* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
+*                                in the Pino logger.
+* @param logger The Pino logger instance to forward logs to.
+* @param options Configuration options for the sink adapter.
+* @returns A LogTape sink function that can be used in LogTape configuration.
+* @since 1.0.0
+*/
+function getPinoSink(logger, options) {
+	const categoryOptions = !options?.category ? void 0 : typeof options.category === "object" ? options.category : {};
+	const category = categoryOptions == null ? void 0 : {
+		separator: categoryOptions.separator ?? "·",
+		position: categoryOptions.position ?? "start",
+		decorator: categoryOptions.decorator ?? ":"
+	};
+	return (record) => {
+		let message = "";
+		const interpolationValues = [];
+		if (category?.position === "start" && record.category.length > 0) {
+			message += category.decorator === "[]" ? "[%s] " : category.decorator === "()" ? "(%s) " : category.decorator === "<>" ? "<%s> " : category.decorator === "{}" ? "{%s} " : category.decorator === ":" ? "%s: " : category.decorator === "-" ? "%s - " : category.decorator === "|" ? "%s | " : category.decorator === "/" ? "%s / " : "%s ";
+			interpolationValues.push(record.category.join(category.separator));
+		}
+		for (let i = 0; i < record.message.length; i += 2) {
+			message += record.message[i];
+			if (i + 1 < record.message.length) {
+				message += "%o";
+				interpolationValues.push(record.message[i + 1]);
+			}
+		}
+		if (category?.position === "end" && record.category.length > 0) {
+			message += category.decorator === "[]" ? " [%s]" : category.decorator === "()" ? " (%s)" : category.decorator === "<>" ? " <%s>" : category.decorator === "{}" ? " {%s}" : category.decorator === ":" ? ": %s" : category.decorator === "-" ? " - %s" : category.decorator === "|" ? " | %s" : category.decorator === "/" ? " / %s" : " %s";
+			interpolationValues.push(record.category.join(category.separator));
+		}
+		switch (record.level) {
+			case "trace": return logger.trace(record.properties, message, interpolationValues);
+			case "debug": return logger.debug(record.properties, message, interpolationValues);
+			case "info": return logger.info(record.properties, message, interpolationValues);
+			case "warning": return logger.warn(record.properties, message, interpolationValues);
+			case "error": return logger.error(record.properties, message, interpolationValues);
+			case "fatal": return logger.fatal(record.properties, message, interpolationValues);
+		}
+	};
+}
+
+//#endregion
+exports.getPinoSink = getPinoSink;

package/dist/mod.d.cts

@@ -0,0 +1,93 @@
+import { Logger } from "pino";
+import { Sink } from "@logtape/logtape";
+
+//#region mod.d.ts
+
+/**
+ * Options for configuring the Pino sink adapter.
+ * @since 1.0.0
+ */
+interface PinoSinkOptions {
+  /**
+   * Configuration for how LogTape categories are handled in Pino logs.
+   * - `false` or `undefined`: Categories are not included in the log message
+   * - `true`: Categories are included with default formatting
+   * - `CategoryOptions`: Custom category formatting configuration
+   */
+  readonly category?: boolean | CategoryOptions;
+}
+/**
+ * Configuration options for formatting LogTape categories in Pino log messages.
+ * @since 1.0.0
+ */
+interface CategoryOptions {
+  /**
+   * The separator used to join category parts when multiple categories exist.
+   * @default "·"
+   */
+  readonly separator?: string;
+  /**
+   * Where to position the category in the log message.
+   * - `"start"`: Category appears at the beginning of the message
+   * - `"end"`: Category appears at the end of the message
+   * @default "start"
+   */
+  readonly position?: "start" | "end";
+  /**
+   * The decorator used to format the category in the log message.
+   * - `"[]"`: [category] format
+   * - `"()"`: (category) format
+   * - `"<>"`: <category> format
+   * - `"{}"`: {category} format
+   * - `":"`: category: format
+   * - `"-"`: category - format
+   * - `"|"`: category | format
+   * - `"/"`: category / format
+   * - `""`: category format (no decoration)
+   * @default ":"
+   */
+  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
+}
+/**
+ * Creates a LogTape sink that forwards log records to a Pino logger.
+ *
+ * This adapter allows LogTape-enabled libraries to integrate seamlessly with
+ * applications that use Pino for logging.
+ *
+ * @example
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getPinoSink } from "@logtape/adaptor-pino";
+ * import pino from "pino";
+ *
+ * const pinoLogger = pino();
+ *
+ * await configure({
+ *   sinks: {
+ *     pino: getPinoSink(pinoLogger, {
+ *       category: {
+ *         position: "start",
+ *         decorator: "[]",
+ *         separator: "."
+ *       }
+ *     })
+ *   },
+ *   loggers: [
+ *     { category: "my-library", sinks: ["pino"] }
+ *   ]
+ * });
+ * ```
+ *
+ * @typeParam CustomLevels The custom log levels supported by the Pino logger.
+ * @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
+ *                                in the Pino logger.
+ * @param logger The Pino logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @returns A LogTape sink function that can be used in LogTape configuration.
+ * @since 1.0.0
+ */
+declare function getPinoSink<CustomLevels extends string, UseOnlyCustomLevels extends boolean>(logger: Logger<CustomLevels, UseOnlyCustomLevels>, options?: PinoSinkOptions): Sink;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { CategoryOptions, PinoSinkOptions, getPinoSink };
+//# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;AAcA;AAqEgB,UAnFC,eAAA,CAmFU;EAAA;;;;;;EAMpB,SAAA,QAAA,CAAA,EAAA,OAAA,GAlFyB,eAkFzB;;;;;;UA3EU,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqED,sFAIN,OAAO,cAAc,gCACnB,kBACT"}

package/dist/mod.d.ts

@@ -0,0 +1,93 @@
+import { Logger } from "pino";
+import { Sink } from "@logtape/logtape";
+
+//#region mod.d.ts
+
+/**
+ * Options for configuring the Pino sink adapter.
+ * @since 1.0.0
+ */
+interface PinoSinkOptions {
+  /**
+   * Configuration for how LogTape categories are handled in Pino logs.
+   * - `false` or `undefined`: Categories are not included in the log message
+   * - `true`: Categories are included with default formatting
+   * - `CategoryOptions`: Custom category formatting configuration
+   */
+  readonly category?: boolean | CategoryOptions;
+}
+/**
+ * Configuration options for formatting LogTape categories in Pino log messages.
+ * @since 1.0.0
+ */
+interface CategoryOptions {
+  /**
+   * The separator used to join category parts when multiple categories exist.
+   * @default "·"
+   */
+  readonly separator?: string;
+  /**
+   * Where to position the category in the log message.
+   * - `"start"`: Category appears at the beginning of the message
+   * - `"end"`: Category appears at the end of the message
+   * @default "start"
+   */
+  readonly position?: "start" | "end";
+  /**
+   * The decorator used to format the category in the log message.
+   * - `"[]"`: [category] format
+   * - `"()"`: (category) format
+   * - `"<>"`: <category> format
+   * - `"{}"`: {category} format
+   * - `":"`: category: format
+   * - `"-"`: category - format
+   * - `"|"`: category | format
+   * - `"/"`: category / format
+   * - `""`: category format (no decoration)
+   * @default ":"
+   */
+  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
+}
+/**
+ * Creates a LogTape sink that forwards log records to a Pino logger.
+ *
+ * This adapter allows LogTape-enabled libraries to integrate seamlessly with
+ * applications that use Pino for logging.
+ *
+ * @example
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getPinoSink } from "@logtape/adaptor-pino";
+ * import pino from "pino";
+ *
+ * const pinoLogger = pino();
+ *
+ * await configure({
+ *   sinks: {
+ *     pino: getPinoSink(pinoLogger, {
+ *       category: {
+ *         position: "start",
+ *         decorator: "[]",
+ *         separator: "."
+ *       }
+ *     })
+ *   },
+ *   loggers: [
+ *     { category: "my-library", sinks: ["pino"] }
+ *   ]
+ * });
+ * ```
+ *
+ * @typeParam CustomLevels The custom log levels supported by the Pino logger.
+ * @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
+ *                                in the Pino logger.
+ * @param logger The Pino logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @returns A LogTape sink function that can be used in LogTape configuration.
+ * @since 1.0.0
+ */
+declare function getPinoSink<CustomLevels extends string, UseOnlyCustomLevels extends boolean>(logger: Logger<CustomLevels, UseOnlyCustomLevels>, options?: PinoSinkOptions): Sink;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { CategoryOptions, PinoSinkOptions, getPinoSink };
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;AAcA;AAqEgB,UAnFC,eAAA,CAmFU;EAAA;;;;;;EAMpB,SAAA,QAAA,CAAA,EAAA,OAAA,GAlFyB,eAkFzB;;;;;;UA3EU,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqED,sFAIN,OAAO,cAAc,gCACnB,kBACT"}

package/dist/mod.js

@@ -0,0 +1,78 @@
+//#region mod.ts
+/**
+* Creates a LogTape sink that forwards log records to a Pino logger.
+*
+* This adapter allows LogTape-enabled libraries to integrate seamlessly with
+* applications that use Pino for logging.
+*
+* @example
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getPinoSink } from "@logtape/adaptor-pino";
+* import pino from "pino";
+*
+* const pinoLogger = pino();
+*
+* await configure({
+*   sinks: {
+*     pino: getPinoSink(pinoLogger, {
+*       category: {
+*         position: "start",
+*         decorator: "[]",
+*         separator: "."
+*       }
+*     })
+*   },
+*   loggers: [
+*     { category: "my-library", sinks: ["pino"] }
+*   ]
+* });
+* ```
+*
+* @typeParam CustomLevels The custom log levels supported by the Pino logger.
+* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
+*                                in the Pino logger.
+* @param logger The Pino logger instance to forward logs to.
+* @param options Configuration options for the sink adapter.
+* @returns A LogTape sink function that can be used in LogTape configuration.
+* @since 1.0.0
+*/
+function getPinoSink(logger, options) {
+	const categoryOptions = !options?.category ? void 0 : typeof options.category === "object" ? options.category : {};
+	const category = categoryOptions == null ? void 0 : {
+		separator: categoryOptions.separator ?? "·",
+		position: categoryOptions.position ?? "start",
+		decorator: categoryOptions.decorator ?? ":"
+	};
+	return (record) => {
+		let message = "";
+		const interpolationValues = [];
+		if (category?.position === "start" && record.category.length > 0) {
+			message += category.decorator === "[]" ? "[%s] " : category.decorator === "()" ? "(%s) " : category.decorator === "<>" ? "<%s> " : category.decorator === "{}" ? "{%s} " : category.decorator === ":" ? "%s: " : category.decorator === "-" ? "%s - " : category.decorator === "|" ? "%s | " : category.decorator === "/" ? "%s / " : "%s ";
+			interpolationValues.push(record.category.join(category.separator));
+		}
+		for (let i = 0; i < record.message.length; i += 2) {
+			message += record.message[i];
+			if (i + 1 < record.message.length) {
+				message += "%o";
+				interpolationValues.push(record.message[i + 1]);
+			}
+		}
+		if (category?.position === "end" && record.category.length > 0) {
+			message += category.decorator === "[]" ? " [%s]" : category.decorator === "()" ? " (%s)" : category.decorator === "<>" ? " <%s>" : category.decorator === "{}" ? " {%s}" : category.decorator === ":" ? ": %s" : category.decorator === "-" ? " - %s" : category.decorator === "|" ? " | %s" : category.decorator === "/" ? " / %s" : " %s";
+			interpolationValues.push(record.category.join(category.separator));
+		}
+		switch (record.level) {
+			case "trace": return logger.trace(record.properties, message, interpolationValues);
+			case "debug": return logger.debug(record.properties, message, interpolationValues);
+			case "info": return logger.info(record.properties, message, interpolationValues);
+			case "warning": return logger.warn(record.properties, message, interpolationValues);
+			case "error": return logger.error(record.properties, message, interpolationValues);
+			case "fatal": return logger.fatal(record.properties, message, interpolationValues);
+		}
+	};
+}
+
+//#endregion
+export { getPinoSink };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["logger: Logger<CustomLevels, UseOnlyCustomLevels>","options?: PinoSinkOptions","category: Required<CategoryOptions> | undefined","record: LogRecord","interpolationValues: unknown[]"],"sources":["../mod.ts"],"sourcesContent":["import type { Logger } from \"pino\";\nimport type { LogRecord, Sink } from \"@logtape/logtape\";\n\n/**\n * Options for configuring the Pino sink adapter.\n * @since 1.0.0\n */\nexport interface PinoSinkOptions {\n  /**\n   * Configuration for how LogTape categories are handled in Pino logs.\n   * - `false` or `undefined`: Categories are not included in the log message\n   * - `true`: Categories are included with default formatting\n   * - `CategoryOptions`: Custom category formatting configuration\n   */\n  readonly category?: boolean | CategoryOptions;\n}\n\n/**\n * Configuration options for formatting LogTape categories in Pino log messages.\n * @since 1.0.0\n */\nexport interface CategoryOptions {\n  /**\n   * The separator used to join category parts when multiple categories exist.\n   * @default \"·\"\n   */\n  readonly separator?: string;\n\n  /**\n   * Where to position the category in the log message.\n   * - `\"start\"`: Category appears at the beginning of the message\n   * - `\"end\"`: Category appears at the end of the message\n   * @default \"start\"\n   */\n  readonly position?: \"start\" | \"end\";\n\n  /**\n   * The decorator used to format the category in the log message.\n   * - `\"[]\"`: [category] format\n   * - `\"()\"`: (category) format\n   * - `\"<>\"`: <category> format\n   * - `\"{}\"`: {category} format\n   * - `\":\"`: category: format\n   * - `\"-\"`: category - format\n   * - `\"|\"`: category | format\n   * - `\"/\"`: category / format\n   * - `\"\"`: category format (no decoration)\n   * @default \":\"\n   */\n  readonly decorator?: \"[]\" | \"()\" | \"<>\" | \"{}\" | \":\" | \"-\" | \"|\" | \"/\" | \"\";\n}\n\n/**\n * Creates a LogTape sink that forwards log records to a Pino logger.\n *\n * This adapter allows LogTape-enabled libraries to integrate seamlessly with\n * applications that use Pino for logging.\n *\n * @example\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getPinoSink } from \"@logtape/adaptor-pino\";\n * import pino from \"pino\";\n *\n * const pinoLogger = pino();\n *\n * await configure({\n *   sinks: {\n *     pino: getPinoSink(pinoLogger, {\n *       category: {\n *         position: \"start\",\n *         decorator: \"[]\",\n *         separator: \".\"\n *       }\n *     })\n *   },\n *   loggers: [\n *     { category: \"my-library\", sinks: [\"pino\"] }\n *   ]\n * });\n * ```\n *\n * @typeParam CustomLevels The custom log levels supported by the Pino logger.\n * @typeParam UseOnlyCustomLevels Whether to use only custom levels defined\n *                                in the Pino logger.\n * @param logger The Pino logger instance to forward logs to.\n * @param options Configuration options for the sink adapter.\n * @returns A LogTape sink function that can be used in LogTape configuration.\n * @since 1.0.0\n */\nexport function getPinoSink<\n  CustomLevels extends string,\n  UseOnlyCustomLevels extends boolean,\n>(\n  logger: Logger<CustomLevels, UseOnlyCustomLevels>,\n  options?: PinoSinkOptions,\n): Sink {\n  const categoryOptions = !options?.category\n    ? undefined\n    : typeof options.category === \"object\"\n    ? options.category\n    : {};\n  const category: Required<CategoryOptions> | undefined =\n    categoryOptions == null ? undefined : {\n      separator: categoryOptions.separator ?? \"·\",\n      position: categoryOptions.position ?? \"start\",\n      decorator: categoryOptions.decorator ?? \":\",\n    };\n  return (record: LogRecord) => {\n    let message = \"\";\n    const interpolationValues: unknown[] = [];\n    if (category?.position === \"start\" && record.category.length > 0) {\n      message += category.decorator === \"[]\"\n        ? \"[%s] \"\n        : category.decorator === \"()\"\n        ? \"(%s) \"\n        : category.decorator === \"<>\"\n        ? \"<%s> \"\n        : category.decorator === \"{}\"\n        ? \"{%s} \"\n        : category.decorator === \":\"\n        ? \"%s: \"\n        : category.decorator === \"-\"\n        ? \"%s - \"\n        : category.decorator === \"|\"\n        ? \"%s | \"\n        : category.decorator === \"/\"\n        ? \"%s / \"\n        : \"%s \";\n      interpolationValues.push(\n        record.category.join(category.separator),\n      );\n    }\n    for (let i = 0; i < record.message.length; i += 2) {\n      message += record.message[i];\n      if (i + 1 < record.message.length) {\n        message += \"%o\";\n        interpolationValues.push(record.message[i + 1]);\n      }\n    }\n    if (category?.position === \"end\" && record.category.length > 0) {\n      message += category.decorator === \"[]\"\n        ? \" [%s]\"\n        : category.decorator === \"()\"\n        ? \" (%s)\"\n        : category.decorator === \"<>\"\n        ? \" <%s>\"\n        : category.decorator === \"{}\"\n        ? \" {%s}\"\n        : category.decorator === \":\"\n        ? \": %s\"\n        : category.decorator === \"-\"\n        ? \" - %s\"\n        : category.decorator === \"|\"\n        ? \" | %s\"\n        : category.decorator === \"/\"\n        ? \" / %s\"\n        : \" %s\";\n      interpolationValues.push(\n        record.category.join(category.separator),\n      );\n    }\n    switch (record.level) {\n      case \"trace\":\n        return logger.trace(record.properties, message, interpolationValues);\n      case \"debug\":\n        return logger.debug(record.properties, message, interpolationValues);\n      case \"info\":\n        return logger.info(record.properties, message, interpolationValues);\n      case \"warning\":\n        return logger.warn(record.properties, message, interpolationValues);\n      case \"error\":\n        return logger.error(record.properties, message, interpolationValues);\n      case \"fatal\":\n        return logger.fatal(record.properties, message, interpolationValues);\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,YAIdA,QACAC,SACM;CACN,MAAM,mBAAmB,SAAS,2BAEvB,QAAQ,aAAa,WAC5B,QAAQ,WACR,CAAE;CACN,MAAMC,WACJ,mBAAmB,gBAAmB;EACpC,WAAW,gBAAgB,aAAa;EACxC,UAAU,gBAAgB,YAAY;EACtC,WAAW,gBAAgB,aAAa;CACzC;AACH,QAAO,CAACC,WAAsB;EAC5B,IAAI,UAAU;EACd,MAAMC,sBAAiC,CAAE;AACzC,MAAI,UAAU,aAAa,WAAW,OAAO,SAAS,SAAS,GAAG;AAChE,cAAW,SAAS,cAAc,OAC9B,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,MACvB,SACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA;AACJ,uBAAoB,KAClB,OAAO,SAAS,KAAK,SAAS,UAAU,CACzC;EACF;AACD,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,QAAQ,KAAK,GAAG;AACjD,cAAW,OAAO,QAAQ;AAC1B,OAAI,IAAI,IAAI,OAAO,QAAQ,QAAQ;AACjC,eAAW;AACX,wBAAoB,KAAK,OAAO,QAAQ,IAAI,GAAG;GAChD;EACF;AACD,MAAI,UAAU,aAAa,SAAS,OAAO,SAAS,SAAS,GAAG;AAC9D,cAAW,SAAS,cAAc,OAC9B,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,MACvB,SACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA;AACJ,uBAAoB,KAClB,OAAO,SAAS,KAAK,SAAS,UAAU,CACzC;EACF;AACD,UAAQ,OAAO,OAAf;GACE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;GACtE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;GACtE,KAAK,OACH,QAAO,OAAO,KAAK,OAAO,YAAY,SAAS,oBAAoB;GACrE,KAAK,UACH,QAAO,OAAO,KAAK,OAAO,YAAY,SAAS,oBAAoB;GACrE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;GACtE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;EACvE;CACF;AACF"}

package/mod.test.ts

@@ -0,0 +1,405 @@
+import { suite } from "@alinea/suite";
+import { assertEquals } from "@std/assert/equals";
+import { assertGreaterOrEqual } from "@std/assert/greater-or-equal";
+import { assertLessOrEqual } from "@std/assert/less-or-equal";
+import { delay } from "@std/async/delay";
+import os from "node:os";
+import process from "node:process";
+import { pino } from "pino";
+import build from "pino-abstract-transport";
+import { getPinoSink } from "./mod.ts";
+
+const test = suite(import.meta);
+
+interface PinoLog {
+  level: number;
+  time: number;
+  pid: number;
+  hostname: string;
+  value: Record<string, unknown>;
+  msg: string;
+  [key: string]: unknown; // Allow additional properties from LogTape properties
+}
+
+test("getPinoSink(): basic scenario", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+  const sink = getPinoSink(logger);
+  const before = Date.now();
+  sink({
+    category: ["test", "category"],
+    level: "info",
+    message: ["Test log: ", { foo: 123 }, ""],
+    properties: { value: { foo: 123 } },
+    rawMessage: "Test log: {value}",
+    timestamp: Date.now(),
+  });
+  const after = Date.now();
+  logger.flush();
+  await delay(500);
+  assertEquals(buffer, [
+    {
+      level: 30,
+      time: buffer[0]?.time,
+      pid: process.pid,
+      hostname: os.hostname(),
+      value: { foo: 123 },
+      msg: 'Test log: [{"foo":123}]',
+    },
+  ]);
+  assertGreaterOrEqual(buffer[0].time, before);
+  assertLessOrEqual(buffer[0].time, after);
+});
+
+test("getPinoSink(): log level mappings", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+  const sink = getPinoSink(logger);
+
+  const logLevels = [
+    { logTapeLevel: "info", expectedPinoLevel: 30 },
+    { logTapeLevel: "warning", expectedPinoLevel: 40 },
+    { logTapeLevel: "error", expectedPinoLevel: 50 },
+    { logTapeLevel: "fatal", expectedPinoLevel: 60 },
+  ] as const;
+
+  for (const { logTapeLevel } of logLevels) {
+    sink({
+      category: ["test"],
+      level: logTapeLevel,
+      message: [`${logTapeLevel} message`],
+      properties: {},
+      rawMessage: `${logTapeLevel} message`,
+      timestamp: Date.now(),
+    });
+  }
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, 4);
+  for (let i = 0; i < logLevels.length; i++) {
+    assertEquals(
+      buffer[i].level,
+      logLevels[i].expectedPinoLevel,
+      `Level mapping failed for ${logLevels[i].logTapeLevel}`,
+    );
+  }
+});
+
+test("getPinoSink(): category option - false/undefined", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  // Test with category: false
+  const sinkFalse = getPinoSink(logger, { category: false });
+  sinkFalse({
+    category: ["test", "category"],
+    level: "info",
+    message: ["Test message"],
+    properties: {},
+    rawMessage: "Test message",
+    timestamp: Date.now(),
+  });
+
+  // Test with no options (undefined)
+  const sinkUndefined = getPinoSink(logger);
+  sinkUndefined({
+    category: ["test", "category"],
+    level: "info",
+    message: ["Test message 2"],
+    properties: {},
+    rawMessage: "Test message 2",
+    timestamp: Date.now(),
+  });
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, 2);
+  assertEquals(buffer[0].msg, "Test message");
+  assertEquals(buffer[1].msg, "Test message 2");
+  // Both should NOT include category in the message
+});
+
+test("getPinoSink(): category option - true (default formatting)", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  const sink = getPinoSink(logger, { category: true });
+  sink({
+    category: ["test", "category"],
+    level: "info",
+    message: ["Test message"],
+    properties: {},
+    rawMessage: "Test message",
+    timestamp: Date.now(),
+  });
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, 1);
+  assertEquals(buffer[0].msg, "test·category: Test message");
+});
+
+test("getPinoSink(): category decorators", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  const decorators = [
+    { decorator: "[]", expected: "[test] Message" },
+    { decorator: "()", expected: "(test) Message" },
+    { decorator: "<>", expected: "<test> Message" },
+    { decorator: "{}", expected: "{test} Message" },
+    { decorator: ":", expected: "test: Message" },
+    { decorator: "-", expected: "test - Message" },
+    { decorator: "|", expected: "test | Message" },
+    { decorator: "/", expected: "test / Message" },
+    { decorator: "", expected: "test Message" },
+  ] as const;
+
+  for (const { decorator } of decorators) {
+    const sink = getPinoSink(logger, {
+      category: { decorator, position: "start" },
+    });
+    sink({
+      category: ["test"],
+      level: "info",
+      message: ["Message"],
+      properties: {},
+      rawMessage: "Message",
+      timestamp: Date.now(),
+    });
+  }
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, decorators.length);
+  for (let i = 0; i < decorators.length; i++) {
+    assertEquals(
+      buffer[i].msg,
+      decorators[i].expected,
+      `Decorator '${decorators[i].decorator}' failed`,
+    );
+  }
+});
+
+test("getPinoSink(): category position (start vs end)", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  // Test position: "start"
+  const sinkStart = getPinoSink(logger, {
+    category: { position: "start", decorator: "[]" },
+  });
+  sinkStart({
+    category: ["test"],
+    level: "info",
+    message: ["Message"],
+    properties: {},
+    rawMessage: "Message",
+    timestamp: Date.now(),
+  });
+
+  // Test position: "end"
+  const sinkEnd = getPinoSink(logger, {
+    category: { position: "end", decorator: "[]" },
+  });
+  sinkEnd({
+    category: ["test"],
+    level: "info",
+    message: ["Message"],
+    properties: {},
+    rawMessage: "Message",
+    timestamp: Date.now(),
+  });
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, 2);
+  assertEquals(buffer[0].msg, "[test] Message");
+  assertEquals(buffer[1].msg, "Message [test]");
+});
+
+test("getPinoSink(): category separator", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  const separators = [
+    { separator: ".", expected: "[app.service.logger] Message" },
+    { separator: "/", expected: "[app/service/logger] Message" },
+    { separator: "::", expected: "[app::service::logger] Message" },
+    { separator: " > ", expected: "[app > service > logger] Message" },
+  ];
+
+  for (const { separator } of separators) {
+    const sink = getPinoSink(logger, {
+      category: { separator, decorator: "[]", position: "start" },
+    });
+    sink({
+      category: ["app", "service", "logger"],
+      level: "info",
+      message: ["Message"],
+      properties: {},
+      rawMessage: "Message",
+      timestamp: Date.now(),
+    });
+  }
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, separators.length);
+  for (let i = 0; i < separators.length; i++) {
+    assertEquals(
+      buffer[i].msg,
+      separators[i].expected,
+      `Separator '${separators[i].separator}' failed`,
+    );
+  }
+});
+
+test("getPinoSink(): empty category handling", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  const sink = getPinoSink(logger, {
+    category: { decorator: "[]", position: "start" },
+  });
+
+  // Test with empty category array
+  sink({
+    category: [],
+    level: "info",
+    message: ["Message with empty category"],
+    properties: {},
+    rawMessage: "Message with empty category",
+    timestamp: Date.now(),
+  });
+
+  // Test with single empty string category
+  sink({
+    category: [""],
+    level: "info",
+    message: ["Message with empty string category"],
+    properties: {},
+    rawMessage: "Message with empty string category",
+    timestamp: Date.now(),
+  });
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, 2);
+  // Empty category array should not include category in message
+  assertEquals(buffer[0].msg, "Message with empty category");
+  // Single empty string should still show the decorator
+  assertEquals(buffer[1].msg, "[] Message with empty string category");
+});
+
+test("getPinoSink(): message interpolation", async () => {
+  const buffer: PinoLog[] = [];
+  const dest = build(async (source) => {
+    for await (const obj of source) {
+      buffer.push(obj);
+    }
+  }, {});
+  const logger = pino({
+    useOnlyCustomLevels: false,
+  }, dest);
+
+  const sink = getPinoSink(logger, {
+    category: { decorator: ":", position: "start" },
+  });
+
+  // Test message with interpolated values
+  sink({
+    category: ["app", "auth"],
+    level: "info",
+    message: [
+      "User ",
+      { userId: 123, username: "johndoe" },
+      " logged in",
+    ],
+    properties: { sessionId: "sess_abc123", source: "web" },
+    rawMessage: "User {user} logged in",
+    timestamp: Date.now(),
+  });
+
+  logger.flush();
+  await delay(100);
+
+  assertEquals(buffer.length, 1);
+
+  // Check that the message contains expected parts
+  const actualMsg = buffer[0].msg;
+  assertEquals(actualMsg.includes("app·auth"), true, "Should contain category");
+  assertEquals(actualMsg.includes("User"), true, "Should contain 'User'");
+  assertEquals(
+    actualMsg.includes("logged in"),
+    true,
+    "Should contain 'logged in'",
+  );
+
+  assertEquals(buffer[0].sessionId, "sess_abc123");
+  assertEquals(buffer[0].source, "web");
+});

package/mod.ts

@@ -0,0 +1,178 @@
+import type { Logger } from "pino";
+import type { LogRecord, Sink } from "@logtape/logtape";
+
+/**
+ * Options for configuring the Pino sink adapter.
+ * @since 1.0.0
+ */
+export interface PinoSinkOptions {
+  /**
+   * Configuration for how LogTape categories are handled in Pino logs.
+   * - `false` or `undefined`: Categories are not included in the log message
+   * - `true`: Categories are included with default formatting
+   * - `CategoryOptions`: Custom category formatting configuration
+   */
+  readonly category?: boolean | CategoryOptions;
+}
+
+/**
+ * Configuration options for formatting LogTape categories in Pino log messages.
+ * @since 1.0.0
+ */
+export interface CategoryOptions {
+  /**
+   * The separator used to join category parts when multiple categories exist.
+   * @default "·"
+   */
+  readonly separator?: string;
+
+  /**
+   * Where to position the category in the log message.
+   * - `"start"`: Category appears at the beginning of the message
+   * - `"end"`: Category appears at the end of the message
+   * @default "start"
+   */
+  readonly position?: "start" | "end";
+
+  /**
+   * The decorator used to format the category in the log message.
+   * - `"[]"`: [category] format
+   * - `"()"`: (category) format
+   * - `"<>"`: <category> format
+   * - `"{}"`: {category} format
+   * - `":"`: category: format
+   * - `"-"`: category - format
+   * - `"|"`: category | format
+   * - `"/"`: category / format
+   * - `""`: category format (no decoration)
+   * @default ":"
+   */
+  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
+}
+
+/**
+ * Creates a LogTape sink that forwards log records to a Pino logger.
+ *
+ * This adapter allows LogTape-enabled libraries to integrate seamlessly with
+ * applications that use Pino for logging.
+ *
+ * @example
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getPinoSink } from "@logtape/adaptor-pino";
+ * import pino from "pino";
+ *
+ * const pinoLogger = pino();
+ *
+ * await configure({
+ *   sinks: {
+ *     pino: getPinoSink(pinoLogger, {
+ *       category: {
+ *         position: "start",
+ *         decorator: "[]",
+ *         separator: "."
+ *       }
+ *     })
+ *   },
+ *   loggers: [
+ *     { category: "my-library", sinks: ["pino"] }
+ *   ]
+ * });
+ * ```
+ *
+ * @typeParam CustomLevels The custom log levels supported by the Pino logger.
+ * @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
+ *                                in the Pino logger.
+ * @param logger The Pino logger instance to forward logs to.
+ * @param options Configuration options for the sink adapter.
+ * @returns A LogTape sink function that can be used in LogTape configuration.
+ * @since 1.0.0
+ */
+export function getPinoSink<
+  CustomLevels extends string,
+  UseOnlyCustomLevels extends boolean,
+>(
+  logger: Logger<CustomLevels, UseOnlyCustomLevels>,
+  options?: PinoSinkOptions,
+): Sink {
+  const categoryOptions = !options?.category
+    ? undefined
+    : typeof options.category === "object"
+    ? options.category
+    : {};
+  const category: Required<CategoryOptions> | undefined =
+    categoryOptions == null ? undefined : {
+      separator: categoryOptions.separator ?? "·",
+      position: categoryOptions.position ?? "start",
+      decorator: categoryOptions.decorator ?? ":",
+    };
+  return (record: LogRecord) => {
+    let message = "";
+    const interpolationValues: unknown[] = [];
+    if (category?.position === "start" && record.category.length > 0) {
+      message += category.decorator === "[]"
+        ? "[%s] "
+        : category.decorator === "()"
+        ? "(%s) "
+        : category.decorator === "<>"
+        ? "<%s> "
+        : category.decorator === "{}"
+        ? "{%s} "
+        : category.decorator === ":"
+        ? "%s: "
+        : category.decorator === "-"
+        ? "%s - "
+        : category.decorator === "|"
+        ? "%s | "
+        : category.decorator === "/"
+        ? "%s / "
+        : "%s ";
+      interpolationValues.push(
+        record.category.join(category.separator),
+      );
+    }
+    for (let i = 0; i < record.message.length; i += 2) {
+      message += record.message[i];
+      if (i + 1 < record.message.length) {
+        message += "%o";
+        interpolationValues.push(record.message[i + 1]);
+      }
+    }
+    if (category?.position === "end" && record.category.length > 0) {
+      message += category.decorator === "[]"
+        ? " [%s]"
+        : category.decorator === "()"
+        ? " (%s)"
+        : category.decorator === "<>"
+        ? " <%s>"
+        : category.decorator === "{}"
+        ? " {%s}"
+        : category.decorator === ":"
+        ? ": %s"
+        : category.decorator === "-"
+        ? " - %s"
+        : category.decorator === "|"
+        ? " | %s"
+        : category.decorator === "/"
+        ? " / %s"
+        : " %s";
+      interpolationValues.push(
+        record.category.join(category.separator),
+      );
+    }
+    switch (record.level) {
+      case "trace":
+        return logger.trace(record.properties, message, interpolationValues);
+      case "debug":
+        return logger.debug(record.properties, message, interpolationValues);
+      case "info":
+        return logger.info(record.properties, message, interpolationValues);
+      case "warning":
+        return logger.warn(record.properties, message, interpolationValues);
+      case "error":
+        return logger.error(record.properties, message, interpolationValues);
+      case "fatal":
+        return logger.fatal(record.properties, message, interpolationValues);
+    }
+  };
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@logtape/adaptor-pino",
+  "version": "1.0.0-dev.253+3fd9a841",
+  "description": "Pino adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "pino",
+    "adapter",
+    "logtape",
+    "sink"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://logtape.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/logtape.git",
+    "directory": "adaptor-pino/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/logtape/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "pino": "^9.7.0",
+    "@logtape/logtape": "1.0.0-dev.253+3fd9a841"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
+    "pino": "^9.7.0",
+    "pino-abstract-transport": "^2.0.0",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test --allow-env --allow-sys",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: "mod.ts",
+  dts: {
+    sourcemap: true,
+  },
+  format: ["esm", "cjs"],
+  platform: "node",
+  unbundle: true,
+});