@logtape/logtape 0.12.0-dev.184 → 0.12.0-dev.186

package/dist/logger.d.cts

@@ -6,6 +6,7 @@
  *
  * ```typescript
  * const logger = getLogger("category");
+ * logger.trace `A trace message with ${value}`
  * logger.debug `A debug message with ${value}.`;
  * logger.info `An info message with ${value}.`;
  * logger.warn `A warning message with ${value}.`;
@@ -69,6 +70,87 @@ interface Logger {
    * @since 0.5.0
    */
   with(properties: Record<string, unknown>): Logger;
+  /**
+   * Log a trace message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.trace `A trace message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a trace message with properties.
+   *
+   * ```typescript
+   * logger.trace('A trace message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.trace(
+   *   'A trace message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  trace(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a trace values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.trace({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.trace('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.trace('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  trace(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a trace message.  Use this when the message values are expensive
+   * to compute and should only be computed if the message is actually logged.
+   *
+   * ```typescript
+   * logger.trace(l => l`A trace message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  trace(callback: LogCallback): void;
   /**
    * Log a debug message.  Use this as a template string prefix.
    *
@@ -305,6 +387,88 @@ interface Logger {
    * @throws {TypeError} If no log record was made inside the callback.
    */
   warn(callback: LogCallback): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  warning(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  warning(callback: LogCallback): void;
   /**
    * Log an error message.  Use this as a template string prefix.
    *

package/dist/logger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.cts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAkSiB,UA/QA,MAAA,CA+QA;EAAM;;;EA8CK,SAYX,QAAA,EAAA,SAAA,MAAA,EAAA;EAAoB;;;;EA0ER,SAYZ,MAAA,EArZE,MAqZF,GAAA,IAAA;EAAoB;;;;AA0ER;AAS7B;AASA;AAiBA;;;;;;;;;;;sFA5eK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;iBAY5B;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;iBAYA;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;AAqSkD,UAjRjC,MAAA,CAiRiC;EAAM;;;EA0DpB,SA4BnB,QAAA,EAAA,SAAA,MAAA,EAAA;EAAM;;;;EA2DgB,SA6BtB,MAAA,EArbE,MAqbF,GAAA,IAAA;EAAM;;;;;;;;;;;;;AA2NM;AAS7B;AASA;AAiBA;;sFA7pBK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;;iBAa5B;;;;;;;;;;;;;;;;;;;;;;;;;;sCA6BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;;mBAaE;;;;;;;;;;;;;;;;;;;;;;;;;;wCA6BF,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgC5B;;;;;;;;;;;;;;oBAeF;;;;;;;;;;;iBAYH;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}

package/dist/logger.d.ts

@@ -6,6 +6,7 @@
  *
  * ```typescript
  * const logger = getLogger("category");
+ * logger.trace `A trace message with ${value}`
  * logger.debug `A debug message with ${value}.`;
  * logger.info `An info message with ${value}.`;
  * logger.warn `A warning message with ${value}.`;
@@ -69,6 +70,87 @@ interface Logger {
    * @since 0.5.0
    */
   with(properties: Record<string, unknown>): Logger;
+  /**
+   * Log a trace message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.trace `A trace message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a trace message with properties.
+   *
+   * ```typescript
+   * logger.trace('A trace message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.trace(
+   *   'A trace message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  trace(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a trace values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.trace({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.trace('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.trace('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  trace(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a trace message.  Use this when the message values are expensive
+   * to compute and should only be computed if the message is actually logged.
+   *
+   * ```typescript
+   * logger.trace(l => l`A trace message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  trace(callback: LogCallback): void;
   /**
    * Log a debug message.  Use this as a template string prefix.
    *
@@ -305,6 +387,88 @@ interface Logger {
    * @throws {TypeError} If no log record was made inside the callback.
    */
   warn(callback: LogCallback): void;
+  /**
+   * Log a warning message.  Use this as a template string prefix.
+   *
+   * ```typescript
+   * logger.warning `A warning message with ${value}.`;
+   * ```
+   *
+   * @param message The message template strings array.
+   * @param values The message template values.
+   * @since 0.12.0
+   */
+  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;
+  /**
+   * Log a warning message with properties.
+   *
+   * ```typescript
+   * logger.warning('A warning message with {value}.', { value });
+   * ```
+   *
+   * If the properties are expensive to compute, you can pass a callback that
+   * returns the properties:
+   *
+   * ```typescript
+   * logger.warning(
+   *   'A warning message with {value}.',
+   *   () => ({ value: expensiveComputation() })
+   * );
+   * ```
+   *
+   * @param message The message template.  Placeholders to be replaced with
+   *                `values` are indicated by keys in curly braces (e.g.,
+   *                `{value}`).
+   * @param properties The values to replace placeholders with.  For lazy
+   *                   evaluation, this can be a callback that returns the
+   *                   properties.
+   * @since 0.12.0
+   */
+  warning(message: string, properties?: Record<string, unknown> | (() => Record<string, unknown>)): void;
+  /**
+   * Log a warning values with no message.  This is useful when you
+   * want to log properties without a message, e.g., when you want to log
+   * the context of a request or an operation.
+   *
+   * ```typescript
+   * logger.warning({ method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * Note that this is a shorthand for:
+   *
+   * ```typescript
+   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });
+   * ```
+   *
+   * If the properties are expensive to compute, you cannot use this shorthand
+   * and should use the following syntax instead:
+   *
+   * ```typescript
+   * logger.warning('{*}', () => ({
+   *   method: expensiveMethod(),
+   *   url: expensiveUrl(),
+   * }));
+   * ```
+   *
+   * @param properties The values to log.  Note that this does not take
+   *                   a callback.
+   * @since 0.12.0
+   */
+  warning(properties: Record<string, unknown>): void;
+  /**
+   * Lazily log a warning message.  Use this when the message values are
+   * expensive to compute and should only be computed if the message is actually
+   * logged.
+   *
+   * ```typescript
+   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);
+   * ```
+   *
+   * @param callback A callback that returns the message template prefix.
+   * @throws {TypeError} If no log record was made inside the callback.
+   * @since 0.12.0
+   */
+  warning(callback: LogCallback): void;
   /**
    * Log an error message.  Use this as a template string prefix.
    *

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAkSiB,UA/QA,MAAA,CA+QA;EAAM;;;EA8CK,SAYX,QAAA,EAAA,SAAA,MAAA,EAAA;EAAoB;;;;EA0ER,SAYZ,MAAA,EArZE,MAqZF,GAAA,IAAA;EAAoB;;;;AA0ER;AAS7B;AASA;AAiBA;;;;;;;;;;;sFA5eK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;iBAY5B;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;iBAYA;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../logger.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;AAqSkD,UAjRjC,MAAA,CAiRiC;EAAM;;;EA0DpB,SA4BnB,QAAA,EAAA,SAAA,MAAA,EAAA;EAAM;;;;EA2DgB,SA6BtB,MAAA,EArbE,MAqbF,GAAA,IAAA;EAAM;;;;;;;;;;;;;AA2NM;AAS7B;AASA;AAiBA;;sFA7pBK;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4Bc,0BAA0B;;;;;;;;;;;;iBAa5B;;;;;;;;;;;;;;;;;;;;;;;;;;sCA6BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;kBAaF;;;;;;;;;;;gBAYF;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;gBAYD;;;;;;;;;;;;;;;;;;;;;;;;;qCA4BC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgC/B;;;;;;;;;;;;;iBAcF;;;;;;;;;;;;mBAaE;;;;;;;;;;;;;;;;;;;;;;;;;;wCA6BF,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAgC5B;;;;;;;;;;;;;;oBAeF;;;;;;;;;;;iBAYH;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;;;;iBAYD;;;;;;;;;;;;;;;;;;;;;;;;;sCA4BA,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgC9B;;;;;;;;;;;;;kBAcF;;;;;;;;KASN,WAAA,YAAuB;;;;;;;;KASvB,iBAAA,aACD;;;;;;;;;;;;;iBAgBK,SAAA,yCAAsD"}

package/dist/logger.js

@@ -31,7 +31,7 @@ var LoggerImpl = class LoggerImpl {
 	sinks;
 	parentSinks = "inherit";
 	filters;
-	lowestLevel = "debug";
+	lowestLevel = "trace";
 	contextLocalStorage;
 	static getLogger(category = []) {
 		let rootLogger = globalRootLoggerSymbol in globalThis ? globalThis[globalRootLoggerSymbol] ?? null : null;
@@ -68,7 +68,7 @@ var LoggerImpl = class LoggerImpl {
 		while (this.sinks.length > 0) this.sinks.shift();
 		this.parentSinks = "inherit";
 		while (this.filters.length > 0) this.filters.shift();
-		this.lowestLevel = "debug";
+		this.lowestLevel = "trace";
 	}
 	/**
 	* Reset the logger and all its descendants.  This removes all sinks and
@@ -189,6 +189,12 @@ var LoggerImpl = class LoggerImpl {
 			}
 		});
 	}
+	trace(message, ...values) {
+		if (typeof message === "string") this.log("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") this.log("debug", message, values[0] ?? {});
 		else if (typeof message === "function") this.logLazily("debug", message);
@@ -207,6 +213,9 @@ var LoggerImpl = class LoggerImpl {
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
+	warning(message, ...values) {
+		this.warn(message, ...values);
+	}
 	error(message, ...values) {
 		if (typeof message === "string") this.log("error", message, values[0] ?? {});
 		else if (typeof message === "function") this.logLazily("error", message);
@@ -262,6 +271,12 @@ var LoggerCtx = class LoggerCtx {
 	logTemplate(level, messageTemplate, values) {
 		this.logger.logTemplate(level, messageTemplate, values, this.properties);
 	}
+	trace(message, ...values) {
+		if (typeof message === "string") this.log("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") this.log("debug", message, values[0] ?? {});
 		else if (typeof message === "function") this.logLazily("debug", message);
@@ -280,6 +295,9 @@ var LoggerCtx = class LoggerCtx {
 		else if (!Array.isArray(message)) this.log("warning", "{*}", message);
 		else this.logTemplate("warning", message, values);
 	}
+	warning(message, ...values) {
+		this.warn(message, ...values);
+	}
 	error(message, ...values) {
 		if (typeof message === "string") this.log("error", message, values[0] ?? {});
 		else if (typeof message === "function") this.logLazily("error", message);