@logtape/adaptor-log4js 2.0.0-dev.0

package/dist/src-tAG616xa.cjs

@@ -0,0 +1,232 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __logtape_logtape = __toESM(require("@logtape/logtape"));
+const node_util = __toESM(require("node:util"));
+
+//#region src/mod.ts
+const DEFAULT_LEVELS_MAP = {
+	"trace": "trace",
+	"debug": "debug",
+	"info": "info",
+	"warning": "warn",
+	"error": "error",
+	"fatal": "fatal"
+};
+const DEFAULT_CATEGORY_MAPPER = (category) => category.length === 0 ? "" : category.join(".");
+/**
+* Creates a LogTape sink that forwards log records to a log4js logger.
+*
+* This function creates a sink function that can be used with LogTape's
+* configuration system. The sink will format LogTape log records and
+* forward them to the provided log4js logger instance or create one
+* based on the LogTape category.
+*
+* @example Basic usage with default log4js logger
+* ```typescript
+* import log4js from "log4js";
+* import { configure } from "@logtape/logtape";
+* import { getLog4jsSink } from "@logtape/adaptor-log4js";
+*
+* log4js.configure({
+*   appenders: { out: { type: "stdout" } },
+*   categories: { default: { appenders: ["out"], level: "info" } }
+* });
+*
+* await configure({
+*   sinks: {
+*     log4js: getLog4jsSink()
+*   },
+*   loggers: [
+*     { category: ["myapp"], sinks: ["log4js"] }
+*   ]
+* });
+* ```
+*
+* @example With custom log4js logger
+* ```typescript
+* import log4js from "log4js";
+* import { getLog4jsSink } from "@logtape/adaptor-log4js";
+*
+* const logger = log4js.getLogger("custom");
+* const sink = getLog4jsSink(logger);
+* ```
+*
+* @example With custom options
+* ```typescript
+* const sink = getLog4jsSink(undefined, {
+*   categoryMapper: (cat) => cat.join("::"),
+*   contextStrategy: "args",
+*   levelsMap: {
+*     "trace": "debug",
+*     "debug": "debug",
+*     "info": "info",
+*     "warning": "warn",
+*     "error": "error",
+*     "fatal": "fatal"
+*   }
+* });
+* ```
+*
+* @param log4jsModule The log4js module instance. If not provided, log4js will be imported dynamically.
+* @param logger The log4js logger instance to forward logs to. If not provided,
+*               a logger will be created for each LogTape category using log4js.getLogger().
+* @param options Configuration options for the sink behavior.
+* @returns A sink function that can be used with LogTape's configure() function.
+* @since 2.0.0
+*/
+function getLog4jsSink(log4jsModule, logger, options = {}) {
+	const { levelsMap = DEFAULT_LEVELS_MAP, categoryMapper = DEFAULT_CATEGORY_MAPPER, valueFormatter = node_util.inspect } = options;
+	const contextStrategy = options.contextStrategy ?? "mdc";
+	const contextPreservation = contextStrategy === "mdc" && "contextPreservation" in options ? options.contextPreservation ?? "preserve" : "preserve";
+	const loggerCache = /* @__PURE__ */ new Map();
+	const getLoggerForCategory = (category) => {
+		if (logger) return logger;
+		const categoryStr = categoryMapper(category);
+		if (loggerCache.has(categoryStr)) return loggerCache.get(categoryStr);
+		if (!log4jsModule) throw new Error("log4js module must be provided when not using a fixed logger");
+		const newLogger = categoryStr ? log4jsModule.getLogger(categoryStr) : log4jsModule.getLogger();
+		loggerCache.set(categoryStr, newLogger);
+		return newLogger;
+	};
+	return (record) => {
+		const targetLogger = getLoggerForCategory(record.category);
+		const level = levelsMap[record.level];
+		let message = "";
+		for (let i = 0; i < record.message.length; i += 2) {
+			message += record.message[i];
+			if (i + 1 < record.message.length) message += valueFormatter(record.message[i + 1]);
+		}
+		if (contextStrategy === "mdc") {
+			const propertiesToAdd = Object.entries(record.properties);
+			if (contextPreservation === "preserve") {
+				propertiesToAdd.forEach(([key, value]) => {
+					targetLogger.addContext(key, value);
+				});
+				targetLogger[level](message);
+				propertiesToAdd.forEach(([key]) => {
+					targetLogger.removeContext(key);
+				});
+			} else if (contextPreservation === "merge") {
+				propertiesToAdd.forEach(([key, value]) => {
+					targetLogger.addContext(key, value);
+				});
+				targetLogger[level](message);
+			} else {
+				targetLogger.clearContext();
+				propertiesToAdd.forEach(([key, value]) => {
+					targetLogger.addContext(key, value);
+				});
+				targetLogger[level](message);
+			}
+		} else targetLogger[level](message, record.properties);
+	};
+}
+/**
+* Automatically configures LogTape to route all logs to log4js.
+*
+* This is a convenience function that automatically sets up LogTape to forward
+* all log records to log4js. By default, it creates loggers based on LogTape
+* categories using log4js.getLogger(), but you can provide a custom logger
+* as the second parameter.
+*
+* @param log4jsModule The log4js module instance. If not provided, log4js will be imported dynamically.
+* @param logger Optional log4js logger instance to use for all logs.
+* @param options Configuration options for the log4js sink behavior.
+*
+* @example Basic auto-configuration
+* ```typescript
+* import log4js from "log4js";
+* import { install } from "@logtape/adaptor-log4js";
+*
+* log4js.configure({
+*   appenders: { out: { type: "stdout" } },
+*   categories: { default: { appenders: ["out"], level: "info" } }
+* });
+*
+* // Automatically route all LogTape logs to log4js
+* install(log4js);
+*
+* // Now any LogTape-enabled library will log through log4js
+* import { getLogger } from "@logtape/logtape";
+* const logger = getLogger("my-app");
+* logger.info("This will be logged through log4js");
+* ```
+*
+* @example Auto-configuration with custom logger
+* ```typescript
+* import log4js from "log4js";
+* import { install } from "@logtape/adaptor-log4js";
+*
+* const customLogger = log4js.getLogger("myapp");
+*
+* // Install with custom logger
+* install(log4js, customLogger);
+* ```
+*
+* @example Auto-configuration with custom options
+* ```typescript
+* import log4js from "log4js";
+* import { install } from "@logtape/adaptor-log4js";
+*
+* install(log4js, undefined, {
+*   categoryMapper: (cat) => cat.join("::"),
+*   contextStrategy: "args"
+* });
+* ```
+*
+* @since 2.0.0
+*/
+function install(log4jsModule, logger, options) {
+	(0, __logtape_logtape.configureSync)({
+		sinks: { log4js: getLog4jsSink(log4jsModule, logger, options) },
+		loggers: [{
+			category: ["logtape", "meta"],
+			sinks: ["log4js"],
+			lowestLevel: "warning"
+		}, {
+			category: [],
+			sinks: ["log4js"]
+		}]
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'getLog4jsSink', {
+  enumerable: true,
+  get: function () {
+    return getLog4jsSink;
+  }
+});
+Object.defineProperty(exports, 'install', {
+  enumerable: true,
+  get: function () {
+    return install;
+  }
+});

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@logtape/adaptor-log4js",
+  "version": "2.0.0-dev.0",
+  "description": "log4js adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "log4js",
+    "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": "packages/adaptor-log4js/"
+  },
+  "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"
+    },
+    "./install": {
+      "types": {
+        "import": "./dist/install.d.ts",
+        "require": "./dist/install.d.cts"
+      },
+      "import": "./dist/install.js",
+      "require": "./dist/install.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
+  "peerDependencies": {
+    "log4js": "^6.0.0",
+    "@logtape/logtape": "^2.0.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
+    "log4js": "^6.9.1",
+    "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"
+  }
+}