@logtape/logtape 2.1.0-dev.501 → 2.1.0-dev.517

package/dist/logger.cjs

@@ -57,6 +57,23 @@ function resolveProperties(properties) {
 	}
 	return resolved;
 }
+function isPromiseObject(value) {
+	if (value instanceof Promise) return true;
+	return Object.prototype.toString.call(value) === "[object Promise]" && typeof value.then === "function";
+}
+function logStringMessage(logger, level, message, props) {
+	if (typeof props !== "function") {
+		const properties = props ?? {};
+		logger.log(level, message, properties);
+		return;
+	}
+	if (!logger.isEnabledFor(level)) return Promise.resolve();
+	const result = props();
+	if (isPromiseObject(result)) return Promise.resolve(result).then((resolvedProps) => {
+		logger.log(level, message, resolvedProps);
+	});
+	logger.log(level, message, result);
+}
 /**
 * Get a logger with the given category.
 *
@@ -261,185 +278,73 @@ var LoggerImpl = class LoggerImpl {
 		});
 	}
 	trace(message, ...values) {
-		if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("trace")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("trace", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("trace")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("trace", message, resolvedProps);
-					});
-				}
-				this.log("trace", message, result);
-				return;
-			}
-			this.log("trace", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("trace", message);
+		if (typeof message === "string") return logStringMessage(this, "trace", message, values[0]);
+		else if (typeof message === "function") this.logLazily("trace", message);
 		else if (!Array.isArray(message)) this.log("trace", "{*}", message);
 		else this.logTemplate("trace", message, values);
 	}
 	debug(message, ...values) {
-		if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("debug")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("debug", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("debug")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("debug", message, resolvedProps);
-					});
-				}
-				this.log("debug", message, result);
-				return;
-			}
-			this.log("debug", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("debug", message);
+		if (typeof message === "string") return logStringMessage(this, "debug", message, values[0]);
+		else if (typeof message === "function") this.logLazily("debug", message);
 		else if (!Array.isArray(message)) this.log("debug", "{*}", message);
 		else this.logTemplate("debug", message, values);
 	}
 	info(message, ...values) {
-		if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("info")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("info", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("info")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("info", message, resolvedProps);
-					});
-				}
-				this.log("info", message, result);
-				return;
-			}
-			this.log("info", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("info", message);
+		if (typeof message === "string") return logStringMessage(this, "info", message, values[0]);
+		else if (typeof message === "function") this.logLazily("info", message);
 		else if (!Array.isArray(message)) this.log("info", "{*}", message);
 		else this.logTemplate("info", message, values);
 	}
+	logError(level, error, props) {
+		if (typeof props !== "function") {
+			this.log(level, "{error.message}", {
+				...props,
+				error
+			});
+			return;
+		}
+		if (!this.isEnabledFor(level)) return Promise.resolve();
+		const result = props();
+		if (result instanceof Promise) return result.then((resolved) => {
+			this.log(level, "{error.message}", {
+				...resolved,
+				error
+			});
+		});
+		this.log(level, "{error.message}", {
+			...result,
+			error
+		});
+	}
 	warn(message, ...values) {
-		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("warning", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				this.log("warning", message, result);
-				return;
-			}
-			this.log("warning", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") return logStringMessage(this, "warning", message, values[0]);
+		else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	warning(message, ...values) {
-		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("warning", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				this.log("warning", message, result);
-				return;
-			}
-			this.log("warning", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") return logStringMessage(this, "warning", message, values[0]);
+		else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	error(message, ...values) {
-		if (message instanceof Error) this.log("error", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("error", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("error", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("error")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("error", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("error")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("error", message, resolvedProps);
-					});
-				}
-				this.log("error", message, result);
-				return;
-			}
-			this.log("error", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("error", message);
+		else if (typeof message === "string") return logStringMessage(this, "error", message, values[0]);
+		else if (typeof message === "function") this.logLazily("error", message);
 		else if (!Array.isArray(message)) this.log("error", "{*}", message);
 		else this.logTemplate("error", message, values);
 	}
 	fatal(message, ...values) {
-		if (message instanceof Error) this.log("fatal", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("fatal", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("fatal", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("fatal")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("fatal", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("fatal")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("fatal", message, resolvedProps);
-					});
-				}
-				this.log("fatal", message, result);
-				return;
-			}
-			this.log("fatal", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("fatal", message);
+		else if (typeof message === "string") return logStringMessage(this, "fatal", message, values[0]);
+		else if (typeof message === "function") this.logLazily("fatal", message);
 		else if (!Array.isArray(message)) this.log("fatal", "{*}", message);
 		else this.logTemplate("fatal", message, values);
 	}
@@ -501,185 +406,73 @@ var LoggerCtx = class LoggerCtx {
 		return this.logger.isEnabledFor(level);
 	}
 	trace(message, ...values) {
-		if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("trace")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("trace", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("trace")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("trace", message, resolvedProps);
-					});
-				}
-				this.log("trace", message, result);
-				return;
-			}
-			this.log("trace", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("trace", message);
+		if (typeof message === "string") return logStringMessage(this, "trace", message, values[0]);
+		else if (typeof message === "function") this.logLazily("trace", message);
 		else if (!Array.isArray(message)) this.log("trace", "{*}", message);
 		else this.logTemplate("trace", message, values);
 	}
 	debug(message, ...values) {
-		if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("debug")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("debug", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("debug")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("debug", message, resolvedProps);
-					});
-				}
-				this.log("debug", message, result);
-				return;
-			}
-			this.log("debug", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("debug", message);
+		if (typeof message === "string") return logStringMessage(this, "debug", message, values[0]);
+		else if (typeof message === "function") this.logLazily("debug", message);
 		else if (!Array.isArray(message)) this.log("debug", "{*}", message);
 		else this.logTemplate("debug", message, values);
 	}
 	info(message, ...values) {
-		if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("info")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("info", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("info")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("info", message, resolvedProps);
-					});
-				}
-				this.log("info", message, result);
-				return;
-			}
-			this.log("info", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("info", message);
+		if (typeof message === "string") return logStringMessage(this, "info", message, values[0]);
+		else if (typeof message === "function") this.logLazily("info", message);
 		else if (!Array.isArray(message)) this.log("info", "{*}", message);
 		else this.logTemplate("info", message, values);
 	}
+	logError(level, error, props) {
+		if (typeof props !== "function") {
+			this.log(level, "{error.message}", {
+				...props,
+				error
+			});
+			return;
+		}
+		if (!this.isEnabledFor(level)) return Promise.resolve();
+		const result = props();
+		if (result instanceof Promise) return result.then((resolved) => {
+			this.log(level, "{error.message}", {
+				...resolved,
+				error
+			});
+		});
+		this.log(level, "{error.message}", {
+			...result,
+			error
+		});
+	}
 	warn(message, ...values) {
-		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("warning", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				this.log("warning", message, result);
-				return;
-			}
-			this.log("warning", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") return logStringMessage(this, "warning", message, values[0]);
+		else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	warning(message, ...values) {
-		if (message instanceof Error) this.log("warning", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("warning", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("warning", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("warning")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("warning", message, resolvedProps);
-					});
-				}
-				this.log("warning", message, result);
-				return;
-			}
-			this.log("warning", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("warning", message);
+		else if (typeof message === "string") return logStringMessage(this, "warning", message, values[0]);
+		else if (typeof message === "function") this.logLazily("warning", message);
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
 	error(message, ...values) {
-		if (message instanceof Error) this.log("error", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("error", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("error", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("error")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("error", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("error")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("error", message, resolvedProps);
-					});
-				}
-				this.log("error", message, result);
-				return;
-			}
-			this.log("error", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("error", message);
+		else if (typeof message === "string") return logStringMessage(this, "error", message, values[0]);
+		else if (typeof message === "function") this.logLazily("error", message);
 		else if (!Array.isArray(message)) this.log("error", "{*}", message);
 		else this.logTemplate("error", message, values);
 	}
 	fatal(message, ...values) {
-		if (message instanceof Error) this.log("fatal", "{error.message}", { error: message });
+		if (message instanceof Error) return this.logError("fatal", message, values[0]);
 		else if (typeof message === "string" && values[0] instanceof Error) this.log("fatal", message, { error: values[0] });
-		else if (typeof message === "string") {
-			const props = values[0];
-			if (typeof props === "function") {
-				if (props.constructor.name === "AsyncFunction") {
-					if (!this.isEnabledFor("fatal")) return Promise.resolve();
-					return props().then((resolvedProps) => {
-						this.log("fatal", message, resolvedProps);
-					});
-				}
-				const result = props();
-				if (result instanceof Promise) {
-					if (!this.isEnabledFor("fatal")) return Promise.resolve();
-					return result.then((resolvedProps) => {
-						this.log("fatal", message, resolvedProps);
-					});
-				}
-				this.log("fatal", message, result);
-				return;
-			}
-			this.log("fatal", message, props ?? {});
-		} else if (typeof message === "function") this.logLazily("fatal", message);
+		else if (typeof message === "string") return logStringMessage(this, "fatal", message, values[0]);
+		else if (typeof message === "function") this.logLazily("fatal", message);
 		else if (!Array.isArray(message)) this.log("fatal", "{*}", message);
 		else this.logTemplate("fatal", message, values);
 	}

package/dist/logger.d.cts

@@ -60,6 +60,13 @@ declare function lazy<T>(getter: () => T): Lazy<T>;
  * logger.error `An error message with ${value}.`;
  * logger.fatal `A fatal error message with ${value}.`;
  * ```
+ *
+ * Callback-based string-message overloads should be treated as
+ * fire-and-forget.  Async callbacks return `Promise<void>`, and when a
+ * callback is filtered out because the level is disabled an implementation may
+ * still return an already-resolved promise so the async path remains awaitable
+ * without invoking the callback.  Call sites should not branch on these
+ * return values.
  */
 interface Logger {
   /**
@@ -433,6 +440,30 @@ interface Logger {
    * @since 2.0.0
    */
   warn(error: Error): void;
+  /**
+   * Log a warning with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.warn(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  warn(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning with additional properties computed asynchronously.
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  warn(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a warning message with an {@link Error}.
    *
@@ -562,6 +593,30 @@ interface Logger {
    * @since 2.0.0
    */
   warning(error: Error): void;
+  /**
+   * Log a warning with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.warning(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  warning(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning with additional properties computed asynchronously.
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  warning(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a warning message with an {@link Error}.
    *
@@ -694,6 +749,49 @@ interface Logger {
    * @since 2.0.0
    */
   error(error: Error): void;
+  /**
+   * Log an error with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.error(new Error("Oops"), { requestId });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.error(
+   *   new Error("Oops"),
+   *   () => ({ requestId: expensiveLookup() })
+   * );
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  error(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log an error with additional properties computed asynchronously.
+   *
+   * Use this when the properties require async operations to compute:
+   *
+   * ```typescript
+   * await logger.error(
+   *   new Error("Oops"),
+   *   async () => ({ requestId: await fetchRequestId() })
+   * );
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  error(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log an error message with an {@link Error}.
    *
@@ -823,6 +921,30 @@ interface Logger {
    * @since 2.0.0
    */
   fatal(error: Error): void;
+  /**
+   * Log a fatal error with additional properties.
+   *
+   * This overload is a shorthand for logging an {@link Error} instance as a
+   * structured property while also adding extra properties.
+   *
+   * ```typescript
+   * logger.fatal(new Error("Oops"), { requestId });
+   * ```
+   *
+   * @param error The error to log.
+   * @param properties Additional properties to log alongside the error.
+   * @since 2.1.0
+   */
+  fatal(error: Error, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a fatal error with additional properties computed asynchronously.
+   *
+   * @param error The error to log.
+   * @param properties An async callback that returns the properties.
+   * @returns A promise that resolves when the log is written.
+   * @since 2.1.0
+   */
+  fatal(error: Error, properties: () => Promise<Record<string, unknown>>): Promise<void>;
   /**
    * Log a fatal error message with an {@link Error}.
    *

package/dist/logger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.cts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":"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"}