@darksheep/logger 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.0.2](https://github.com/DarkSheepSoftware/node-packages/compare/logger-v1.0.1...logger-v1.0.2) (2024-08-01)
+
+
+### 📦 Dependencies
+
+* **dev:** update dependency eslint to ~9.8.0 ([#284](https://github.com/DarkSheepSoftware/node-packages/issues/284)) ([dc02a80](https://github.com/DarkSheepSoftware/node-packages/commit/dc02a801cb982cd3ed2bf685db62a21b6c2c15cd))
+
+## [1.0.1](https://github.com/DarkSheepSoftware/node-packages/compare/logger-v1.0.0...logger-v1.0.1) (2024-07-23)
+
+
+### 📦 Dependencies
+
+* **dev:** update dependency @darksheep/eslint to v5 ([25aabab](https://github.com/DarkSheepSoftware/node-packages/commit/25aababd9295e3e47b945c91b5d6fbf121f8168b))
+* **dev:** update dependency @types/eslint to v9 ([#271](https://github.com/DarkSheepSoftware/node-packages/issues/271)) ([6600b26](https://github.com/DarkSheepSoftware/node-packages/commit/6600b267a99b0e320b52c78d2727f0576b0fb027))
+* **dev:** update dependency eslint to ~9.7.0 ([#263](https://github.com/DarkSheepSoftware/node-packages/issues/263)) ([af98723](https://github.com/DarkSheepSoftware/node-packages/commit/af9872336b01026496bc1a48807fd396eb361483))
+* **pkg:** update dependency deepmerge-ts to v7.1.0 ([#269](https://github.com/DarkSheepSoftware/node-packages/issues/269)) ([3123ead](https://github.com/DarkSheepSoftware/node-packages/commit/3123ead700e145ba35228d44ff7847b11764e15d))
+
+
+### 🧹 Miscellaneous Chores
+
+* eslint --fix . ([48b5728](https://github.com/DarkSheepSoftware/node-packages/commit/48b5728b6cd0bcd2ac2f8ec04f45d155c0682dc8))
+
 ## 1.0.0 (2024-07-02)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksheep/logger",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Logging your stuff to where ever you want it",
   "license": "UNLICENCED",
   "type": "module",
@@ -24,16 +24,16 @@
     "test:watch": "node --watch --test src/**/*.test.js"
   },
   "dependencies": {
-    "deepmerge-ts": "7.0.3",
+    "deepmerge-ts": "7.1.0",
     "stacktrace-parser": "0.1.10",
     "traverse": "0.6.9"
   },
   "devDependencies": {
-    "@darksheep/eslint": "~4.4.0",
-    "@types/eslint": "~8.56.0",
+    "@darksheep/eslint": "~5.1.0",
+    "@types/eslint": "~9.6.0",
     "@types/node": "~20.14.0",
     "@types/traverse": "~0.6.33",
-    "eslint": "~9.6.0",
+    "eslint": "~9.8.0",
     "nock": "~13.5.0",
     "typescript": "~5.5.0",
     "zod": "~3.23.0"

package/src/create-logger.js

@@ -1,8 +1,5 @@
 import { Logger } from './logger.js';
-
 import {
-  SecretDelete,
-  SecretObscure,
   BufferReplacer,
   ErrorReplacer,
   HttpClientRequestReplacer,
@@ -10,6 +7,8 @@ import {
   HttpServerResponseReplacer,
   LongStringReplacer,
   NetSocketReplacer,
+  SecretDelete,
+  SecretObscure,
 } from './replacers/index.js';
 
 /**

package/src/formatter.js

@@ -1,6 +1,6 @@
-import { environment } from './utilities/environment.js';
-import { formatterJson } from './formatters/formatter-json.js';
 import { formatterConsole } from './formatters/formatter-console.js';
+import { formatterJson } from './formatters/formatter-json.js';
+import { environment } from './utilities/environment.js';
 
 const isConsole = (
   process.stdout.isTTY === true &&

package/src/formatters/formatter-console.js

@@ -1,6 +1,7 @@
 import { inspect } from 'node:util';
-import { LogNames } from '../utilities/log-types.js';
+
 import { colourString, shouldColour } from '../utilities/colour.js';
+import { LogNames } from '../utilities/log-types.js';
 
 /** @typedef {import('../utilities/log-types.js').LogContext} LogContext */
 /** @typedef {import('../utilities/log-types.js').LogEntry} LogEntry */

package/src/index.js

@@ -6,15 +6,11 @@ import { createLogger } from './create-logger.js';
 /** @typedef {import('./formatter.js').Formatter} Formatter */
 /** @typedef {import('./replacer.js').Replacer} Replacer */
 
-export { Logger } from './logger.js';
+export { createLogger } from './create-logger.js';
 export const logger = createLogger();
 
-export { environment } from './utilities/environment.js';
-export { createLogger } from './create-logger.js';
-export { LogLevels } from './utilities/log-types.js';
+export { Logger } from './logger.js';
 export {
-  SecretDelete,
-  SecretObscure,
   BufferReplacer,
   ErrorReplacer,
   HttpClientRequestReplacer,
@@ -22,4 +18,8 @@ export {
   HttpServerResponseReplacer,
   LongStringReplacer,
   NetSocketReplacer,
+  SecretDelete,
+  SecretObscure,
 } from './replacers/index.js';
+export { environment } from './utilities/environment.js';
+export { LogLevels } from './utilities/log-types.js';

package/src/logger.js

@@ -1,15 +1,15 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { deepmerge } from 'deepmerge-ts';
 
-import { environment } from './utilities/environment.js';
-import { getLastCallsite } from './utilities/last-callsite.js';
-import { LogLevels } from './utilities/log-types.js';
-import { checkLogLevel, checkLogFilters } from './utilities/log-filters.js';
+import { deepmerge } from 'deepmerge-ts';
 
+import { formatter } from './formatter.js';
 import { replace } from './replacer.js';
 import { ErrorReplacer } from './replacers/error.js';
 import { stdoutWrite } from './stdout-write.js';
-import { formatter } from './formatter.js';
+import { environment } from './utilities/environment.js';
+import { getLastCallsite } from './utilities/last-callsite.js';
+import { checkLogFilters, checkLogLevel } from './utilities/log-filters.js';
+import { LogLevels } from './utilities/log-types.js';
 
 /**
  * @typedef {Object} Options
@@ -23,77 +23,20 @@ export class Logger {
   /** @type {AsyncLocalStorage<import('./utilities/log-types.js').LogContext[]>} */
   static storage = new AsyncLocalStorage();
 
-  /**
-   * @template [R=unknown]
-   * @overload
-   * @param {() => R} callback The function to wrap the context in
-   * @returns {R}
-   */
-  /**
-   * @template [R=unknown]
-   * @overload
-   * @param {import('./utilities/log-types.js').LogContext} context Context to bind ot the async context
-   * @param {() => R} callback The function to wrap the context in
-   * @returns {R}
-   */
-  /**
-   * @template [R=unknown]
-   * @param {unknown} context Context to bind ot the async context
-   * @param {unknown} [callback] The function to wrap the context in
-   * @returns {R}
-   */
-  static wrap(context, callback) {
-    // If there is already some context, keep it around
-    const store = Logger.storage.getStore() ?? [];
-
-    if (typeof context === 'function') {
-      return Logger.storage.run(
-        [ ...store ],
-        /** @type {() => R} */ (context),
-      );
-    }
-
-    return Logger.storage.run(
-      [ ...store, /** @type {import('./utilities/log-types.js').LogContext} */ (context) ],
-      /** @type {() => R} */ (callback),
-    );
-  }
-
-  /**
-   * @template [R=unknown]
-   * @param {() => R} callback The function to wrap the context in
-   * @returns {R}
-   */
-  wrap(callback) {
-    return Logger.wrap(this.#context, callback);
-  }
-
-  /**
-   * @param {import('./utilities/log-types.js').LogContext} context Context to bind ot the async context
-   * @returns {void}
-   */
-  static addAsyncContext(context) {
-    const store = Logger.storage.getStore();
-
-    if (store == null) {
-      throw new Error('Context not inside Context#wrap');
-    }
-
-    store.push(context);
-  }
-
-  /** @type {import('./replacer.js').Replacer[]} */
-  replacers = [];
+  /** @type {import('./utilities/log-types.js').LogContext} */
+  #context;
 
   /** @type {typeof formatter} */
   #format = formatter;
+
   /** @type {typeof replace} */
   #replace = replace;
+
   /** @type {typeof stdoutWrite} */
   #write = stdoutWrite;
-  /** @type {import('./utilities/log-types.js').LogContext} */
-  #context;
 
+  /** @type {import('./replacer.js').Replacer[]} */
+  replacers = [];
   /**
    * @param {import('./utilities/log-types.js').LogContext} [context] Context to add to the logger
    * @param {Options} [options] Options for the loggers output
@@ -115,136 +58,55 @@ export class Logger {
   }
 
   /**
-   * Write a new log entry
-   * @param {import('./utilities/log-types.js').LogLevel} level the log level of the message to log
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Context to add to the log (merged with this.context, and Logger.contexts)
+   * @param {import('./utilities/log-types.js').LogContext} context Context to bind ot the async context
    * @returns {void}
    */
-  write(level, message, context) {
-    /** @type {import('./utilities/log-types.js').LogContext[]} */
-    const contexts = [];
-
-    const asyncContexts = Logger.storage.getStore();
-    if (asyncContexts instanceof Array) {
-      contexts.push(...asyncContexts);
-    }
-
-    contexts.push(this.#context);
-    if (context instanceof Object) {
-      contexts.push(context);
-    }
-
-    const fullContext =
-      /** @type {import('./utilities/log-types.js').LogContext} */
-      (deepmerge(...contexts));
-
-    if (
-      checkLogLevel(level) === false ||
-      checkLogFilters(fullContext?.channel) === false
-    ) {
-      return;
-    }
-
-    /** @type {import('./utilities/log-types.js').LogEntry} */
-    const entry = (
-      typeof message === 'string'
-        ? { ...fullContext, message, level }
-        : { ...fullContext, ...ErrorReplacer.replace(message), level }
-    );
+  static addAsyncContext(context) {
+    const store = Logger.storage.getStore();
 
-    if (environment.includeCallsite === true) {
-      entry.source = getLastCallsite();
+    if (store == null) {
+      throw new Error('Context not inside Context#wrap');
     }
 
-    const normalised =
-      /** @type {import('./utilities/log-types.js').LogEntry} */
-      (this.#replace(entry, this.replacers));
-
-    const formatted = this.#format(normalised);
-
-    return this.#write(formatted);
-  }
-
-  // =========
-  //   Level
-  // =========
-
-  /**
-   * Write a log with the level 'critical' - A crucial part of the application is not working
-   *
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
-   */
-  critical(message, context) {
-    return this.write(LogLevels.critical, message, context);
-  }
-
-  /**
-   * Write a log with the level 'error' - A non critical operation fails
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
-   */
-  error(message, context) {
-    return this.write(LogLevels.error, message, context);
+    store.push(context);
   }
 
   /**
-   * Write a log with the level 'warning' - An operation might fail in the future
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
+   * @template [R=unknown]
+   * @overload
+   * @param {() => R} callback The function to wrap the context in
+   * @returns {R}
    */
-  warning(message, context) {
-    return this.write(LogLevels.warning, message, context);
-  }
-
   /**
-   * Write a log with the level 'notice' - Information about events that may be unusual
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
+   * @template [R=unknown]
+   * @overload
+   * @param {import('./utilities/log-types.js').LogContext} context Context to bind ot the async context
+   * @param {() => R} callback The function to wrap the context in
+   * @returns {R}
    */
-  notice(message, context) {
-    return this.write(LogLevels.notice, message, context);
-  }
-
   /**
-   * Write a log with the level 'info' - Information about successful operations
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
+   * @template [R=unknown]
+   * @param {unknown} context Context to bind ot the async context
+   * @param {unknown} [callback] The function to wrap the context in
+   * @returns {R}
    */
-  info(message, context) {
-    return this.write(LogLevels.info, message, context);
-  }
+  static wrap(context, callback) {
+    // If there is already some context, keep it around
+    const store = Logger.storage.getStore() ?? [];
 
-  /**
-   * Write a log with the level 'debug' - Information that is unlikely to help in production
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
-   */
-  debug(message, context) {
-    return this.write(LogLevels.debug, message, context);
-  }
+    if (typeof context === 'function') {
+      return Logger.storage.run(
+        [ ...store ],
+        /** @type {() => R} */ (context),
+      );
+    }
 
-  /**
-   * Write a log with the level 'silly' - Information to help resolve complex logic issues
-   * @param {Error | string} message The message to log
-   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-   * @returns {void}
-   */
-  silly(message, context) {
-    return this.write(LogLevels.silly, message, context);
+    return Logger.storage.run(
+      [ ...store, /** @type {import('./utilities/log-types.js').LogContext} */ (context) ],
+      /** @type {() => R} */ (callback),
+    );
   }
 
-  // =========
-  //  Context
-  // =========
-
   /**
    * @param {import('./utilities/log-types.js').LogContext} context The new context
    * @param {import('./utilities/log-types.js').LogLevel} [level] The log level at which we allow this context
@@ -269,6 +131,19 @@ export class Logger {
     );
   }
 
+  /**
+   * Set the channel in the new logger
+   * @param {string} channel The channel name
+   * @returns {Logger}
+   */
+  channel(channel) {
+    return this.set('channel', channel);
+  }
+
+  // =========
+  //   Level
+  // =========
+
   /**
    * Creating a new logger with {context, ...this.context}
    * @overload
@@ -325,6 +200,37 @@ export class Logger {
     throw new TypeError('Invalid LogContext in Logger#context()');
   }
 
+  /**
+   * Write a log with the level 'critical' - A crucial part of the application is not working
+   *
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
+   */
+  critical(message, context) {
+    return this.write(LogLevels.critical, message, context);
+  }
+
+  /**
+   * Write a log with the level 'debug' - Information that is unlikely to help in production
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
+   */
+  debug(message, context) {
+    return this.write(LogLevels.debug, message, context);
+  }
+
+  /**
+   * Write a log with the level 'error' - A non critical operation fails
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
+   */
+  error(message, context) {
+    return this.write(LogLevels.error, message, context);
+  }
+
   /**
    * Get a value from the context by key
    * @param {string} key The key to get from the context
@@ -334,6 +240,30 @@ export class Logger {
     return this.#context[key];
   }
 
+  /**
+   * Write a log with the level 'info' - Information about successful operations
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
+   */
+  info(message, context) {
+    return this.write(LogLevels.info, message, context);
+  }
+
+  /**
+   * Write a log with the level 'notice' - Information about events that may be unusual
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
+   */
+  notice(message, context) {
+    return this.write(LogLevels.notice, message, context);
+  }
+
+  // =========
+  //  Context
+  // =========
+
   /**
    * Set a value into a new context by key
    * @param {string} key The key to set
@@ -345,12 +275,13 @@ export class Logger {
   }
 
   /**
-   * Set the channel in the new logger
-   * @param {string} channel The channel name
-   * @returns {Logger}
+   * Write a log with the level 'silly' - Information to help resolve complex logic issues
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
    */
-  channel(channel) {
-    return this.set('channel', channel);
+  silly(message, context) {
+    return this.write(LogLevels.silly, message, context);
   }
 
   /**
@@ -366,4 +297,75 @@ export class Logger {
 
     return this.set('trail', trail);
   }
+
+  /**
+   * Write a log with the level 'warning' - An operation might fail in the future
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+   * @returns {void}
+   */
+  warning(message, context) {
+    return this.write(LogLevels.warning, message, context);
+  }
+
+  /**
+   * @template [R=unknown]
+   * @param {() => R} callback The function to wrap the context in
+   * @returns {R}
+   */
+  wrap(callback) {
+    return Logger.wrap(this.#context, callback);
+  }
+
+  /**
+   * Write a new log entry
+   * @param {import('./utilities/log-types.js').LogLevel} level the log level of the message to log
+   * @param {Error | string} message The message to log
+   * @param {import('./utilities/log-types.js').LogContext} [context] Context to add to the log (merged with this.context, and Logger.contexts)
+   * @returns {void}
+   */
+  write(level, message, context) {
+    /** @type {import('./utilities/log-types.js').LogContext[]} */
+    const contexts = [];
+
+    const asyncContexts = Logger.storage.getStore();
+    if (asyncContexts instanceof Array) {
+      contexts.push(...asyncContexts);
+    }
+
+    contexts.push(this.#context);
+    if (context instanceof Object) {
+      contexts.push(context);
+    }
+
+    const fullContext =
+      /** @type {import('./utilities/log-types.js').LogContext} */
+      (deepmerge(...contexts));
+
+    if (
+      checkLogLevel(level) === false ||
+      checkLogFilters(fullContext?.channel) === false
+    ) {
+      return;
+    }
+
+    /** @type {import('./utilities/log-types.js').LogEntry} */
+    const entry = (
+      typeof message === 'string'
+        ? { ...fullContext, message, level }
+        : { ...fullContext, ...ErrorReplacer.replace(message), level }
+    );
+
+    if (environment.includeCallsite === true) {
+      entry.source = getLastCallsite();
+    }
+
+    const normalised =
+      /** @type {import('./utilities/log-types.js').LogEntry} */
+      (this.#replace(entry, this.replacers));
+
+    const formatted = this.#format(normalised);
+
+    return this.#write(formatted);
+  }
 }

package/src/replacer.js

@@ -1,6 +1,7 @@
 /* eslint no-invalid-this: 0 */
 
 import Traverse from 'traverse';
+
 import { nodesToPath } from './utilities/json-path.js';
 
 /**

package/src/replacers/index.js

@@ -4,5 +4,5 @@ export { HttpClientRequestReplacer } from './http-client-request.js';
 export { HttpIncomingMessageReplacer } from './http-incoming-message.js';
 export { HttpServerResponseReplacer } from './http-server-response.js';
 export { LongStringReplacer } from './long-strings.js';
-export { SecretDelete, SecretObscure } from './secrets.js';
 export { NetSocketReplacer } from './net-socket.js';
+export { SecretDelete, SecretObscure } from './secrets.js';

package/src/utilities/environment.js

@@ -1,5 +1,5 @@
-import { parseLogLevel } from './parse-log-level.js';
 import { parseFilters } from './parse-filters.js';
+import { parseLogLevel } from './parse-log-level.js';
 
 /**
  * @param {undefined | string} input The env var to check for booleaness

package/src/utilities/stacktrace.js

@@ -1,4 +1,5 @@
-import { resolve, relative } from 'node:path';
+import { relative, resolve } from 'node:path';
+
 import { parse } from 'stacktrace-parser';
 
 /**

package/types/index.d.ts

@@ -1,11 +1,11 @@
-export { Logger } from "./logger.js";
+export { createLogger } from "./create-logger.js";
 export const logger: import("./logger.js").Logger;
+export { Logger } from "./logger.js";
 export { environment } from "./utilities/environment.js";
-export { createLogger } from "./create-logger.js";
 export { LogLevels } from "./utilities/log-types.js";
 export type LogContext = import("./utilities/log-types.js").LogContext;
 export type LogEntry = import("./utilities/log-types.js").LogEntry;
 export type LogLevel = import("./utilities/log-types.js").LogLevel;
 export type Formatter = import("./formatter.js").Formatter;
 export type Replacer = import("./replacer.js").Replacer;
-export { SecretDelete, SecretObscure, BufferReplacer, ErrorReplacer, HttpClientRequestReplacer, HttpIncomingMessageReplacer, HttpServerResponseReplacer, LongStringReplacer, NetSocketReplacer } from "./replacers/index.js";
+export { BufferReplacer, ErrorReplacer, HttpClientRequestReplacer, HttpIncomingMessageReplacer, HttpServerResponseReplacer, LongStringReplacer, NetSocketReplacer, SecretDelete, SecretObscure } from "./replacers/index.js";

package/types/logger.d.ts

@@ -8,6 +8,11 @@
 export class Logger {
     /** @type {AsyncLocalStorage<import('./utilities/log-types.js').LogContext[]>} */
     static storage: AsyncLocalStorage<import("./utilities/log-types.js").LogContext[]>;
+    /**
+     * @param {import('./utilities/log-types.js').LogContext} context Context to bind ot the async context
+     * @returns {void}
+     */
+    static addAsyncContext(context: import("./utilities/log-types.js").LogContext): void;
     /**
      * @template [R=unknown]
      * @overload
@@ -23,32 +28,42 @@ export class Logger {
      * @returns {R}
      */
     static wrap<R = unknown>(context: import("./utilities/log-types.js").LogContext, callback: () => R): R;
-    /**
-     * @param {import('./utilities/log-types.js').LogContext} context Context to bind ot the async context
-     * @returns {void}
-     */
-    static addAsyncContext(context: import("./utilities/log-types.js").LogContext): void;
     /**
      * @param {import('./utilities/log-types.js').LogContext} [context] Context to add to the logger
      * @param {Options} [options] Options for the loggers output
      */
     constructor(context?: import("./utilities/log-types.js").LogContext | undefined, options?: Options | undefined);
-    /**
-     * @template [R=unknown]
-     * @param {() => R} callback The function to wrap the context in
-     * @returns {R}
-     */
-    wrap<R = unknown>(callback: () => R): R;
     /** @type {import('./replacer.js').Replacer[]} */
     replacers: import("./replacer.js").Replacer[];
     /**
-     * Write a new log entry
-     * @param {import('./utilities/log-types.js').LogLevel} level the log level of the message to log
-     * @param {Error | string} message The message to log
-     * @param {import('./utilities/log-types.js').LogContext} [context] Context to add to the log (merged with this.context, and Logger.contexts)
-     * @returns {void}
+     * Set the channel in the new logger
+     * @param {string} channel The channel name
+     * @returns {Logger}
      */
-    write(level: import("./utilities/log-types.js").LogLevel, message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
+    channel(channel: string): Logger;
+    /**
+     * Creating a new logger with {context, ...this.context}
+     * @overload
+     * @param {import('./utilities/log-types.js').LogContext} context The new context
+     * @returns {Logger}
+     */
+    context(context: import("./utilities/log-types.js").LogContext): Logger;
+    /**
+     * Creating a new logger with {context, ...this.context}
+     * @overload
+     * @param {import('./utilities/log-types.js').LogContext} context The new context
+     * @param {import('./utilities/log-types.js').LogLevel} level The log level at which we allow this context
+     * @returns {Logger}
+     */
+    context(context: import("./utilities/log-types.js").LogContext, level: import("./utilities/log-types.js").LogLevel): Logger;
+    /**
+     * Creating a new logger with {context, ...this.context}
+     * @overload
+     * @param {import('./utilities/log-types.js').LogLevel} level The log level at which we allow this context
+     * @param {import('./utilities/log-types.js').LogContext} context The new context
+     * @returns {Logger}
+     */
+    context(level: import("./utilities/log-types.js").LogLevel, context: import("./utilities/log-types.js").LogContext): Logger;
     /**
      * Write a log with the level 'critical' - A crucial part of the application is not working
      *
@@ -58,26 +73,25 @@ export class Logger {
      */
     critical(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     /**
-     * Write a log with the level 'error' - A non critical operation fails
+     * Write a log with the level 'debug' - Information that is unlikely to help in production
      * @param {Error | string} message The message to log
      * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
      * @returns {void}
      */
-    error(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
+    debug(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     /**
-     * Write a log with the level 'warning' - An operation might fail in the future
+     * Write a log with the level 'error' - A non critical operation fails
      * @param {Error | string} message The message to log
      * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
      * @returns {void}
      */
-    warning(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
+    error(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     /**
-     * Write a log with the level 'notice' - Information about events that may be unusual
-     * @param {Error | string} message The message to log
-     * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
-     * @returns {void}
+     * Get a value from the context by key
+     * @param {string} key The key to get from the context
+     * @returns {unknown}
      */
-    notice(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
+    get(key: string): unknown;
     /**
      * Write a log with the level 'info' - Information about successful operations
      * @param {Error | string} message The message to log
@@ -86,12 +100,19 @@ export class Logger {
      */
     info(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     /**
-     * Write a log with the level 'debug' - Information that is unlikely to help in production
+     * Write a log with the level 'notice' - Information about events that may be unusual
      * @param {Error | string} message The message to log
      * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
      * @returns {void}
      */
-    debug(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
+    notice(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
+    /**
+     * Set a value into a new context by key
+     * @param {string} key The key to set
+     * @param {unknown} value The value to set
+     * @returns {Logger}
+     */
+    set(key: string, value: unknown): Logger;
     /**
      * Write a log with the level 'silly' - Information to help resolve complex logic issues
      * @param {Error | string} message The message to log
@@ -100,53 +121,32 @@ export class Logger {
      */
     silly(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     /**
-     * Creating a new logger with {context, ...this.context}
-     * @overload
-     * @param {import('./utilities/log-types.js').LogContext} context The new context
-     * @returns {Logger}
-     */
-    context(context: import("./utilities/log-types.js").LogContext): Logger;
-    /**
-     * Creating a new logger with {context, ...this.context}
-     * @overload
-     * @param {import('./utilities/log-types.js').LogContext} context The new context
-     * @param {import('./utilities/log-types.js').LogLevel} level The log level at which we allow this context
-     * @returns {Logger}
-     */
-    context(context: import("./utilities/log-types.js").LogContext, level: import("./utilities/log-types.js").LogLevel): Logger;
-    /**
-     * Creating a new logger with {context, ...this.context}
-     * @overload
-     * @param {import('./utilities/log-types.js').LogLevel} level The log level at which we allow this context
-     * @param {import('./utilities/log-types.js').LogContext} context The new context
+     * Set the trail in the new logger
+     * @param {string} [trail] The trail id
      * @returns {Logger}
      */
-    context(level: import("./utilities/log-types.js").LogLevel, context: import("./utilities/log-types.js").LogContext): Logger;
-    /**
-     * Get a value from the context by key
-     * @param {string} key The key to get from the context
-     * @returns {unknown}
-     */
-    get(key: string): unknown;
+    trail(trail?: string | undefined): Logger;
     /**
-     * Set a value into a new context by key
-     * @param {string} key The key to set
-     * @param {unknown} value The value to set
-     * @returns {Logger}
+     * Write a log with the level 'warning' - An operation might fail in the future
+     * @param {Error | string} message The message to log
+     * @param {import('./utilities/log-types.js').LogContext} [context] Additional context
+     * @returns {void}
      */
-    set(key: string, value: unknown): Logger;
+    warning(message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     /**
-     * Set the channel in the new logger
-     * @param {string} channel The channel name
-     * @returns {Logger}
+     * @template [R=unknown]
+     * @param {() => R} callback The function to wrap the context in
+     * @returns {R}
      */
-    channel(channel: string): Logger;
+    wrap<R = unknown>(callback: () => R): R;
     /**
-     * Set the trail in the new logger
-     * @param {string} [trail] The trail id
-     * @returns {Logger}
+     * Write a new log entry
+     * @param {import('./utilities/log-types.js').LogLevel} level the log level of the message to log
+     * @param {Error | string} message The message to log
+     * @param {import('./utilities/log-types.js').LogContext} [context] Context to add to the log (merged with this.context, and Logger.contexts)
+     * @returns {void}
      */
-    trail(trail?: string | undefined): Logger;
+    write(level: import("./utilities/log-types.js").LogLevel, message: Error | string, context?: import("./utilities/log-types.js").LogContext | undefined): void;
     #private;
 }
 export type Options = {