From c3d22ccb1898bd396f04444a4584e848845f541b Mon Sep 17 00:00:00 2001
From: Qu4k <pippo.reds@gmail.com>
Date: Sat, 25 Jul 2020 23:51:17 +0200
Subject: [PATCH] feat: add custom logger

---
 denon.config.ts          |  17 +++--
 denon.ts                 |  48 +++++-------
 deps.ts                  |   2 +
 examples/denon.config.ts |   9 +--
 examples/simple.ts       |   6 +-
 src/args.ts              |  23 ++----
 src/cli.ts               |  94 ++++++++++-------------
 src/config.ts            |  60 ++++++---------
 src/daemon.ts            |  65 ++++++++--------
 src/log.ts               | 157 +++++++++++++++++++++++++++++----------
 src/merge.ts             |   6 +-
 src/runner.ts            |  63 +++++++---------
 src/runner_test.ts       |  21 ++----
 src/scripts.ts           | 118 ++++++++++-------------------
 src/scripts_test.ts      |  16 ++--
 src/watcher.ts           |  55 ++++++--------
 src/watcher_test.ts      |   7 +-
 17 files changed, 363 insertions(+), 404 deletions(-)

diff --git a/denon.config.ts b/denon.config.ts
index 0b1e2a8..03c9be6 100644
--- a/denon.config.ts
+++ b/denon.config.ts
@@ -5,19 +5,22 @@ const config: DenonConfig = {
     test: [
       {
         cmd: "deno fmt",
-        desc: "run denon format",
+        desc: "format code",
+      },
+      {
+        cmd: "deno lint --unstable",
+        desc: "lint code",
       },
       {
         cmd: "deno test",
-        desc: "run denon format",
-        allow: [
-          "all",
-        ],
-        unstable: true,
-        watch: false,
+        desc: "test code",
+        allow: "all",
       },
     ],
   },
+  logger: {
+    debug: true,
+  },
 };
 
 export default config;
diff --git a/denon.ts b/denon.ts
index 4bf0bff..ec97ab8 100644
--- a/denon.ts
+++ b/denon.ts
@@ -1,7 +1,5 @@
 // Copyright 2020-present the denosaurs team. All rights reserved. MIT license.
 
-import { log } from "./deps.ts";
-
 import { Watcher, FileEvent } from "./src/watcher.ts";
 import { Runner } from "./src/runner.ts";
 import { Daemon } from "./src/daemon.ts";
@@ -14,27 +12,23 @@ import {
   upgrade,
   autocomplete,
 } from "./src/cli.ts";
-import {
-  readConfig,
-  CompleteDenonConfig,
-  reConfig,
-} from "./src/config.ts";
+import { readConfig, CompleteDenonConfig, reConfig } from "./src/config.ts";
 import { parseArgs } from "./src/args.ts";
-import { setupLog } from "./src/log.ts";
+import log from "./src/log.ts";
 
 export const VERSION = "v2.2.1";
 export const BRANCH = "master";
 
-/**
- * Events you can listen to when creating a `denon`
+const logger = log.prefix("main");
+
+/** Events you can listen to when creating a `denon`
  * instance as module:
  * ```typescript
  * const denon = new Denon(config);
  * for await (let event of denon.run(script)) {
  *   // event handling here
  * }
- * ```
- */
+ * ``` */
 export declare type DenonEventType =
   | "start"
   | "reload"
@@ -72,11 +66,9 @@ export declare interface DenonExitEvent {
   type: "exit";
 }
 
-/**
- * Denon instance.
+/** Denon instance.
  * Holds loaded configuration and handles creation
- * of daemons with the `start(script)` method.
- */
+ * of daemons with the `start(script)` method. */
 export class Denon {
   watcher: Watcher;
   runner: Runner;
@@ -91,20 +83,18 @@ export class Denon {
   }
 }
 
-/**
- * CLI starts here,
+/** CLI starts here,
  * other than the awesome `denon` cli this is an
- * example on how the library should be used if
- * included as a module.
- */
+ * example on how the library could be used if
+ * included as a module. */
 if (import.meta.main) {
-  await setupLog();
+  await log.setup();
 
   await grantPermissions();
 
   const args = parseArgs(Deno.args);
   let config = await readConfig(args.config);
-  await setupLog(config.logger);
+  await log.setup(config.logger);
 
   autocomplete(config);
 
@@ -117,7 +107,7 @@ if (import.meta.main) {
   }
 
   // show version number.
-  log.info(VERSION);
+  logger.info(`${VERSION}-${BRANCH}`);
   if (args.version) Deno.exit(0);
 
   // update denon to latest release
@@ -144,22 +134,24 @@ if (import.meta.main) {
 
   if (config.logger.fullscreen) console.clear();
 
+  const conf = log.prefix("conf");
   if (config.watcher.match) {
-    log.info(`watching path(s): ${config.watcher.match.join(" ")}`);
+    conf.info(`watching path(s): ${config.watcher.match.join(" ")}`);
   }
   if (config.watcher.exts) {
-    log.info(`watching extensions: ${config.watcher.exts.join(",")}`);
+    conf.info(`watching extensions: ${config.watcher.exts.join(",")}`);
   }
 
   // TODO(@qu4k): events
   for await (let event of denon.run(script)) {
     if (event.type === "reload") {
       if (
-        event.change.some((_) =>
-          reConfig.test(_.path) && _.path === config.configPath
+        event.change.some(
+          (_) => reConfig.test(_.path) && _.path === config.configPath,
         )
       ) {
         config = await readConfig(args.config);
+        logger.debug("reloading config");
       }
     }
   }
diff --git a/deps.ts b/deps.ts
index 0dbf1b9..16f7c05 100644
--- a/deps.ts
+++ b/deps.ts
@@ -15,7 +15,9 @@ export {
   reset,
   bold,
   blue,
+  green,
   yellow,
+  italic,
   red,
   gray,
 } from "https://deno.land/std@0.61.0/fmt/colors.ts";
diff --git a/examples/denon.config.ts b/examples/denon.config.ts
index f27504f..5d19f1a 100644
--- a/examples/denon.config.ts
+++ b/examples/denon.config.ts
@@ -6,17 +6,12 @@ const config: DenonConfig = {
     run: {
       cmd: "simple.ts",
       desc: "Run main app",
-      allow: [
-        "env",
-      ],
+      allow: ["env"],
     },
     oak: {
       cmd: "oak.ts",
       desc: "Run oak instance",
-      allow: [
-        "env",
-        "net",
-      ],
+      allow: ["env", "net"],
       env: {
         PORT: "9001",
       },
diff --git a/examples/simple.ts b/examples/simple.ts
index 432c934..3406ad1 100644
--- a/examples/simple.ts
+++ b/examples/simple.ts
@@ -9,11 +9,7 @@ console.log(
   Deno.env.get("SECRET_ENV_VARIABLE"),
 );
 
-console.log(
-  Deno.pid,
-  green("args:"),
-  Deno.args,
-);
+console.log(Deno.pid, green("args:"), Deno.args);
 
 let i = 50;
 
diff --git a/src/args.ts b/src/args.ts
index 15ea76f..9c0b177 100644
--- a/src/args.ts
+++ b/src/args.ts
@@ -1,16 +1,10 @@
 // Copyright 2020-present the denosaurs team. All rights reserved. MIT license.
 
-import { reConfig } from "./config.ts";
-
-/**
- * Regex to test if string matches version format
- */
+/** Regex to test if string matches version format */
 const reVersion = /^v?[0-9]+\.[0-9]+\.[0-9]+$/;
 
-/**
- * Map of supported flags that modify
- * `denon` behavior.
- */
+/** Map of supported flags that modify
+ * `denon` behavior. */
 export interface Args {
   help: boolean;
   version: boolean;
@@ -22,10 +16,8 @@ export interface Args {
   cmd: string[];
 }
 
-/**
- * Parse Deno.args into a flag map (`Args`)
- * to be handled by th CLI.
- */
+/** Parse Deno.args into a flag map (`Args`)
+ * to be handled by th CLI. */
 export function parseArgs(args: string[] = Deno.args): Args {
   if (args[0] === "--") {
     args = args.slice(1);
@@ -40,10 +32,7 @@ export function parseArgs(args: string[] = Deno.args): Args {
     cmd: [],
   };
 
-  if (
-    (args.includes("--config") || args.includes("-c")) &&
-    args.length > 1
-  ) {
+  if ((args.includes("--config") || args.includes("-c")) && args.length > 1) {
     flags.config = args[1];
     args = args.slice(2);
   }
diff --git a/src/cli.ts b/src/cli.ts
index 1d11334..770eca7 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,7 +1,6 @@
 // Copyright 2020-present the denosaurs team. All rights reserved. MIT license.
 
 import {
-  log,
   yellow,
   bold,
   gray,
@@ -11,7 +10,6 @@ import {
   grant,
   exists,
   omelette,
-  red,
 } from "../deps.ts";
 
 import {
@@ -21,10 +19,12 @@ import {
 } from "./config.ts";
 import { Runner } from "./runner.ts";
 import { VERSION } from "../denon.ts";
-import { Watcher } from "./watcher.ts";
 
-/**
- * These are the permissions required for a clean run
+import log from "./log.ts";
+
+const logger = log.prefix("main");
+
+/** These are the permissions required for a clean run
  * of `denon`. If not provided through installation they
  * will be asked on every run by the `grant()` std function.
  *
@@ -35,8 +35,7 @@ import { Watcher } from "./watcher.ts";
  * - *write*, write configuration templates.
  * - *run*, used to run scripts as child processes.
  * - *write*, download configuration templates and import
- * `denon.config.ts` file.
- */
+ * `denon.config.ts` file. */
 export const PERMISSIONS: Deno.PermissionDescriptor[] = [
   { name: "read" },
   { name: "write" },
@@ -44,11 +43,9 @@ export const PERMISSIONS: Deno.PermissionDescriptor[] = [
   { name: "net" },
 ];
 
-/**
- * These permissions are required on specific situations,
+/** These permissions are required on specific situations,
  * `denon` should not be installed with this permissions
- * but you should be granting them when they are required.
- */
+ * but you should be granting them when they are required. */
 export const PERMISSION_OPTIONAL: {
   [key: string]: Deno.PermissionDescriptor[];
 } = {
@@ -60,41 +57,36 @@ export async function grantPermissions(): Promise<void> {
   // @see PERMISSIONS .
   let permissions = await grant([...PERMISSIONS]);
   if (!permissions || permissions.length < PERMISSIONS.length) {
-    log.critical("Required permissions `read` and `run` not granted");
+    logger.critical("Required permissions `read` and `run` not granted");
     Deno.exit(1);
   }
 }
-
-/**
- * Create configuration file in the root of current work directory.
- * // TODO: make it interactive
- */
+/** Create configuration file in the root of current work directory.
+ * // TODO: make it interactive */
 export async function initializeConfig(template: string): Promise<void> {
   let permissions = await grant(PERMISSION_OPTIONAL.initializeConfig);
   if (
     !permissions ||
     permissions.length < PERMISSION_OPTIONAL.initializeConfig.length
   ) {
-    log.critical("Required permissions for this operation not granted");
+    logger.critical("Required permissions for this operation not granted");
     Deno.exit(1);
   }
-  if (!await exists(template)) {
+  if (!(await exists(template))) {
     await writeConfigTemplate(template);
   } else {
-    log.error(`\`${template}\` already exists in root dir`);
+    logger.error(`\`${template}\` already exists in root dir`);
   }
 }
 
-/**
- * Grab a fresh copy of denon
- */
+/** Grab a fresh copy of denon */
 export async function upgrade(version?: string): Promise<void> {
   const url = `https://deno.land/x/denon${
     version ? `@${version}` : ""
   }/denon.ts`;
 
   if (version === VERSION) {
-    log.info(`Version ${version} already installed`);
+    logger.info(`Version ${version} already installed`);
     Deno.exit(0);
   }
 
@@ -103,19 +95,17 @@ export async function upgrade(version?: string): Promise<void> {
     !permissions ||
     permissions.length < PERMISSION_OPTIONAL.upgradeExe.length
   ) {
-    log.critical("Required permissions for this operation not granted");
+    logger.critical("Required permissions for this operation not granted");
     Deno.exit(1);
   }
 
-  log.debug(`Checking if ${url} exists`);
+  logger.debug(`Checking if ${url} exists`);
   if ((await fetch(url)).status !== 200) {
-    log.critical(`Upgrade url ${url} does not exist`);
+    logger.critical(`Upgrade url ${url} does not exist`);
     Deno.exit(1);
   }
 
-  log.info(
-    `Running \`deno install -Af --unstable ${url}\``,
-  );
+  logger.info(`Running \`deno install -Af --unstable ${url}\``);
   await Deno.run({
     cmd: [
       "deno",
@@ -132,9 +122,7 @@ export async function upgrade(version?: string): Promise<void> {
   Deno.exit(0);
 }
 
-/**
- * Generate autocomplete suggestions
- */
+/** Generate autocomplete suggestions */
 export function autocomplete(config: CompleteDenonConfig): void {
   // Write your CLI template.
   const completion = omelette.default(`denon <script>`);
@@ -156,13 +144,11 @@ export function autocomplete(config: CompleteDenonConfig): void {
   completion.init();
 }
 
-/**
- * List all available scripts declared in the config file.
- * // TODO(@qu4k): make it interactive
- */
+/** List all available scripts declared in the config file.
+ * // TODO(@qu4k): make it interactive */
 export function printAvailableScripts(config: CompleteDenonConfig): void {
   if (Object.keys(config.scripts).length) {
-    log.info("available scripts:");
+    logger.info("available scripts:");
     const runner = new Runner(config);
     for (const name of Object.keys(config.scripts)) {
       const script = config.scripts[name];
@@ -178,35 +164,33 @@ export function printAvailableScripts(config: CompleteDenonConfig): void {
         .map((command) => command.cmd.join(" "))
         .join(bold(" && "));
 
-      console.log(
-        gray(`   $ ${commands}`),
-      );
+      console.log(gray(`   $ ${commands}`));
     }
     console.log();
     console.log(
       `You can run scripts with \`${blue("denon")} ${yellow("<script>")}\``,
     );
   } else {
-    log.error("It looks like you don't have any scripts...");
+    logger.error("It looks like you don't have any scripts...");
     const config = getConfigFilename();
     if (config) {
-      log.info(
+      logger.info(
         `You can add scripts to your \`${config}\` file. Check the docs.`,
       );
     } else {
-      log.info(
-        `You can create a config to add scripts to with \`${blue("denon")} ${
-          yellow("--init")
-        }${reset("\`.")}`,
+      logger.info(
+        `You can create a config to add scripts to with \`${
+          blue(
+            "denon",
+          )
+        } ${yellow("--init")}${reset("`.")}`,
       );
     }
   }
 }
 
-/**
- * Help message to be shown if `denon`
- * is run with `--help` flag.
- */
+/** Help message to be shown if `denon`
+ * is run with `--help` flag. */
 export function printHelp(version: string): void {
   setColorEnabled(true);
   console.log(
@@ -215,10 +199,14 @@ Monitor any changes in your Deno application and automatically restart.
 
 Usage:
     ${blue("denon")} ${yellow("<script name>")}     ${
-      gray("-- eg: denon start")
+      gray(
+        "-- eg: denon start",
+      )
     }
     ${blue("denon")} ${yellow("<command>")}         ${
-      gray("-- eg: denon run helloworld.ts")
+      gray(
+        "-- eg: denon run helloworld.ts",
+      )
     }
     ${blue("denon")} [options]         ${gray("-- eg: denon --help")}
 
diff --git a/src/config.ts b/src/config.ts
index c5e8f7c..4ae1122 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -4,28 +4,26 @@ import {
   existsSync,
   extname,
   JSON_SCHEMA,
-  log,
   parseYaml,
   readFileStr,
   readJson,
-  writeJson,
   resolve,
   globToRegExp,
 } from "../deps.ts";
 
 import { WatcherConfig } from "./watcher.ts";
 import { RunnerConfig } from "./runner.ts";
-import { LogConfig } from "./log.ts";
+import log, { LogConfig } from "./log.ts";
 
 import { merge } from "./merge.ts";
 import { Args } from "./args.ts";
-import { BRANCH, VERSION } from "../denon.ts";
+import { BRANCH } from "../denon.ts";
 
 const TS_CONFIG = "denon.config.ts";
 
-/**
- * Possible default configuration files.
- */
+const logger = log.prefix("conf");
+
+/** Possible default configuration files. */
 export const configs = [
   "denon",
   "denon.yaml",
@@ -52,9 +50,7 @@ export const reConfig = new RegExp(
     .join("|"), // i know, right
 );
 
-/**
- * The denon configuration format
- */
+/** The denon configuration format */
 // export interface DenonConfig extends RunnerConfig {
 //   [key: string]: any;
 //   watcher?: WatcherConfig;
@@ -64,9 +60,7 @@ export const reConfig = new RegExp(
 
 export type DenonConfig = RunnerConfig & Partial<CompleteDenonConfig>;
 
-/**
- * Parameters are not optional
- */
+/** Parameters are not optional */
 export interface CompleteDenonConfig extends RunnerConfig {
   [key: string]: unknown;
   watcher: WatcherConfig;
@@ -89,9 +83,7 @@ export const DEFAULT_DENON_CONFIG: CompleteDenonConfig = {
   configPath: "",
 };
 
-/**
- * Read YAML config, throws if YAML format is not valid
- */
+/** Read YAML config, throws if YAML format is not valid */
 async function readYaml(file: string): Promise<unknown> {
   const source = await readFileStr(file);
   return parseYaml(source, {
@@ -100,9 +92,7 @@ async function readYaml(file: string): Promise<unknown> {
   });
 }
 
-/**
- * Safe import a TypeScript file
- */
+/** Safe import a TypeScript file */
 async function importConfig(
   file: string,
 ): Promise<Partial<DenonConfig> | undefined> {
@@ -110,14 +100,12 @@ async function importConfig(
     const configRaw = await import(`file://${resolve(file)}`);
     return configRaw.default as Partial<DenonConfig>;
   } catch (error) {
-    log.error(error.message ?? "Error opening ts config config");
+    logger.error(error.message ?? "Error opening ts config config");
     return;
   }
 }
 
-/**
- * Clean config from malformed strings
- */
+/** Clean config from malformed strings */
 function cleanConfig(
   config: Partial<DenonConfig>,
   file?: string,
@@ -133,18 +121,14 @@ function cleanConfig(
   return config;
 }
 
-/**
- * Returns, if exists, the config filename
- */
+/** Returns, if exists, the config filename */
 export function getConfigFilename(): string | undefined {
   return configs.find((filename) => {
     return existsSync(filename) && Deno.statSync(filename).isFile;
   });
 }
 
-/**
- * Reads the denon config from a file
- */
+/** Reads the denon config from a file */
 export async function readConfig(
   file: string | undefined = getConfigFilename(),
 ): Promise<CompleteDenonConfig> {
@@ -192,44 +176,42 @@ export async function readConfig(
           }
         }
       } catch {
-        log.warning(`unsupported configuration \`${file}\``);
+        logger.warning(`unsupported configuration \`${file}\``);
       }
     }
   }
   return config;
 }
 
-/**
- * Reads the denon config from a file
- */
+/** Reads the denon config from a file */
 export async function writeConfigTemplate(template: string): Promise<void> {
   const templates = `https://deno.land/x/denon@${BRANCH}/templates`;
   const url = `${templates}/${template}`;
-  log.info(`fetching template from ${url}`);
+  logger.info(`fetching template from ${url}`);
 
   let res;
   try {
     res = await fetch(url);
   } catch (e) {
-    log.error(`${url} cannot be fetched`);
+    logger.error(`${url} cannot be fetched`);
   }
 
   if (res) {
     if (res.status === 200) {
       try {
-        log.info(`writing template to \`${template}\``);
+        logger.info(`writing template to \`${template}\``);
         await Deno.writeTextFile(
           resolve(Deno.cwd(), template),
           await res.text(),
         );
-        log.info(`\`${template}\` created in current working directory`);
+        logger.info(`\`${template}\` created in current working directory`);
       } catch (e) {
-        log.error(
+        logger.error(
           `\`${template}\` cannot be saved in current working directory`,
         );
       }
     } else {
-      log.error(
+      logger.error(
         `\`${template}\` is not a denon template. All templates are available on ${templates}/`,
       );
     }
diff --git a/src/daemon.ts b/src/daemon.ts
index dc68f27..eac4d4b 100644
--- a/src/daemon.ts
+++ b/src/daemon.ts
@@ -1,17 +1,17 @@
 // Copyright 2020-present the denosaurs team. All rights reserved. MIT license.
 
-import { log } from "../deps.ts";
+import log from "./log.ts";
 
 import { Denon, DenonEvent } from "../denon.ts";
 import { CompleteDenonConfig } from "./config.ts";
 import { ScriptOptions } from "./scripts.ts";
 
-/**
- * Daemon instance.
+const logger = log.prefix("daem");
+
+/** Daemon instance.
  * Returned by Denon instance when
  * `start(script)` is called. It can be used in a for
- * loop to listen to DenonEvents.
- */
+ * loop to listen to DenonEvents. */
 export class Daemon implements AsyncIterable<DenonEvent> {
   #denon: Denon;
   #script: string;
@@ -24,22 +24,22 @@ export class Daemon implements AsyncIterable<DenonEvent> {
     this.#config = denon.config; // just as a shortcut
   }
 
-  /**
-   * Restart current process.
-   */
+  /** Restart current process. */
   private async reload(): Promise<void> {
     if (this.#config.logger && this.#config.logger.fullscreen) {
-      log.debug("clearing screen");
+      logger.debug("clearing screen");
       console.clear();
     }
 
     if (this.#config.watcher.match) {
-      log.info(`watching path(s): ${this.#config.watcher.match.join(" ")}`);
+      logger.info(`watching path(s): ${this.#config.watcher.match.join(" ")}`);
     }
     if (this.#config.watcher.exts) {
-      log.info(`watching extensions: ${this.#config.watcher.exts.join(",")}`);
+      logger.info(
+        `watching extensions: ${this.#config.watcher.exts.join(",")}`,
+      );
     }
-    log.info("restarting due to changes...");
+    logger.info("restarting due to changes...");
 
     this.killAll();
 
@@ -53,35 +53,39 @@ export class Daemon implements AsyncIterable<DenonEvent> {
     // *sequentially*, the last process is named `main` and is the
     // one that will actually be demonized.
     for (let i = 0; i < commands.length; i++) {
+      const plog = log.prefix(`#${i}`);
       const command = commands[i];
       let process = command.exe();
-      log.debug(`S: starting process with pid ${process.pid}`);
+      plog.debug(`starting process with pid ${process.pid}`);
 
       if (i === commands.length - 1) {
-        log.warning(`starting main \`${command.cmd.join(" ")}\``);
+        plog.warning(`starting main \`${command.cmd.join(" ")}\``);
         this.#processes[process.pid] = process;
         this.monitor(process, command.options);
         return command.options;
       } else {
-        log.info(`starting sequential \`${command.cmd.join(" ")}\``);
+        plog.info(`starting sequential \`${command.cmd.join(" ")}\``);
         await process.status();
+        process.close();
       }
     }
     return {};
   }
 
   private killAll(): void {
-    log.debug(`K: killing ${Object.keys(this.#processes).length} process[es]`);
+    logger.debug(
+      `killing ${Object.keys(this.#processes).length} orphan process[es]`,
+    );
     // kill all processes spawned
     let pcopy = Object.assign({}, this.#processes);
     this.#processes = {};
     for (let id in pcopy) {
       const p = pcopy[id];
       if (Deno.build.os === "windows") {
-        log.debug(`K: closing (windows) process with pid ${p.pid}`);
+        logger.debug(`closing (windows) process with pid ${p.pid}`);
         p.close();
       } else {
-        log.debug(`K: killing (unix) process with pid ${p.pid}`);
+        logger.debug(`killing (unix) process with pid ${p.pid}`);
         Deno.kill(p.pid, Deno.Signal.SIGKILL);
       }
     }
@@ -91,42 +95,43 @@ export class Daemon implements AsyncIterable<DenonEvent> {
     process: Deno.Process,
     options: ScriptOptions,
   ): Promise<void> {
-    log.debug(`M: monitoring status of process with pid ${process.pid}`);
+    logger.debug(`monitoring status of process with pid ${process.pid}`);
     const pid = process.pid;
     let s: Deno.ProcessStatus | undefined;
     try {
       s = await process.status();
-      log.debug(`M: got status of process with pid ${process.pid}`);
+      process.close();
+      logger.debug(`got status of process with pid ${process.pid}`);
     } catch (error) {
-      log.debug(`M: error getting status of process with pid ${process.pid}`);
+      logger.debug(`error getting status of process with pid ${process.pid}`);
     }
     let p = this.#processes[pid];
     if (p) {
-      log.debug(`M: process with pid ${process.pid} exited on its own`);
+      logger.debug(`process with pid ${process.pid} exited on its own`);
       // process exited on its own, so we should wait a reload
       // remove it from processes array as it is already dead
       delete this.#processes[pid];
 
       if (s) {
-        // log status status
+        // logger status status
         if (s.success) {
           if (options.watch) {
-            log.info("clean exit - waiting for changes before restart");
+            logger.info("clean exit - waiting for changes before restart");
           } else {
-            log.info("clean exit - denon is exiting ...");
+            logger.info("clean exit - denon is exiting ...");
           }
         } else {
           if (options.watch) {
-            log.error(
+            logger.error(
               "app crashed - waiting for file changes before starting ...",
             );
           } else {
-            log.error("app crashed - denon is exiting ...");
+            logger.error("app crashed - denon is exiting ...");
           }
         }
       }
     } else {
-      log.debug(`M: process with pid ${process.pid} was killed`);
+      logger.debug(`process with pid ${process.pid} was killed`);
     }
   }
 
@@ -157,8 +162,8 @@ export class Daemon implements AsyncIterable<DenonEvent> {
     if (options.watch) {
       for await (const watchE of this.#denon.watcher) {
         if (watchE.some((_) => _.type.includes("modify"))) {
-          log.debug(
-            `R: reload event detected, starting the reload procedure...`,
+          logger.debug(
+            `reload event detected, starting the reload procedure...`,
           );
           yield {
             type: "reload",
diff --git a/src/log.ts b/src/log.ts
index 2e74099..0d365b3 100644
--- a/src/log.ts
+++ b/src/log.ts
@@ -6,34 +6,27 @@ import {
   bold,
   blue,
   yellow,
+  green,
   red,
+  gray,
+  italic,
   LogRecord,
   LogLevels,
   BaseHandler,
   LogLevelName,
 } from "../deps.ts";
 
-import { DenonConfig } from "./config.ts";
-
 export declare interface LogConfig {
-  /**
-   * Disables logging
-   */
+  /** Disables logging */
   quiet?: boolean;
-  /**
-   * Enables debugging
-   */
+  /** Enables debugging */
   debug?: boolean;
-  /**
-   * Clear the console on reload events
-   */
+  /** Clear the console on reload events */
   fullscreen?: boolean;
 }
 
-/**
- * Logger tag
- */
-const TAG = "[denon]";
+/** Logger tag */
+const TAG = `${bold("[denon]")}`;
 
 const DEBUG_LEVEL = "DEBUG";
 const QUIET_LEVEL = "ERROR";
@@ -41,38 +34,47 @@ const DEFAULT_LEVEL = "INFO";
 
 const DEFAULT_HANDLER = "format_fn";
 
-/**
- * Deno logger, but slightly better.
- */
+/** Deno logger, but slightly better. */
 export class ConsoleHandler extends BaseHandler {
   format(record: LogRecord): string {
+    if (record.args.length === 0) throw new Error("Logger Error");
     let msg = "";
+    let tag = TAG;
+    let op = record.args[0] as string;
+    let error: Error | undefined = undefined;
+
     switch (record.level) {
+      case LogLevels.DEBUG:
+        tag = green("[&]");
+        break;
       case LogLevels.INFO:
-        msg += blue(TAG);
+        tag = blue("[*]");
         break;
       case LogLevels.WARNING:
-        msg += yellow(TAG);
+        tag = yellow("[!]");
         break;
       case LogLevels.ERROR:
-        msg += red(TAG);
+        tag = red("[E]");
+        error = record.args[1] as Error;
         break;
       case LogLevels.CRITICAL:
-        msg += bold(red(TAG));
-        break;
-      default:
+        tag = bold(red("[@]"));
+        error = record.args[1] as Error;
         break;
     }
 
+    let action = gray(`[${italic(op)}]`);
+
+    msg += tag;
+    msg += ` ${action}`;
     msg += ` ${reset(record.msg)}`;
 
-    for (const arg of record.args) {
-      if (arg instanceof Object) {
-        msg += ` ${JSON.stringify(arg)}`;
-      } else {
-        msg += ` ${String(arg)}`;
-      }
+    if (error) {
+      msg += `\n`;
+      msg += `${bold(red("error"))}: Uncaught `;
+      msg += Deno.inspect(error);
     }
+
     return msg;
   }
 
@@ -81,10 +83,8 @@ export class ConsoleHandler extends BaseHandler {
   }
 }
 
-/**
- * Determines the log level based on configuration
- * preferences.
- */
+/** Determines the log level based on configuration
+ * preferences. */
 function logLevel(config: LogConfig): LogLevelName {
   let level: LogLevelName = DEFAULT_LEVEL;
   if (config.debug) level = DEBUG_LEVEL;
@@ -92,11 +92,9 @@ function logLevel(config: LogConfig): LogLevelName {
   return level;
 }
 
-/**
- * Modify default deno logger with configurable
- * log level.
- */
-export async function setupLog(config: LogConfig = {}): Promise<void> {
+/** Modify default deno logger with configurable
+ * log level. */
+export async function setup(config: LogConfig = {}): Promise<void> {
   const level = config ? logLevel(config) : DEBUG_LEVEL;
   await log.setup({
     handlers: {
@@ -110,3 +108,84 @@ export async function setupLog(config: LogConfig = {}): Promise<void> {
     },
   });
 }
+
+type Message<T> = (T extends Function ? never : T) | (() => T);
+
+export function debug<T>(msg: Message<T>, op?: string): T | undefined {
+  // Assist TS compiler with pass-through generic type
+  op = op ?? "main";
+  if (msg instanceof Function) {
+    return log.debug(msg, op);
+  }
+  return log.debug(msg, op);
+}
+
+export function info<T>(msg: Message<T>, op?: string): T | undefined {
+  // Assist TS compiler with pass-through generic type
+  op = op ?? "main";
+  if (msg instanceof Function) {
+    return log.info(msg, op);
+  }
+  return log.info(msg, op);
+}
+
+export function warning<T>(msg: Message<T>, op?: string): T | undefined {
+  // Assist TS compiler with pass-through generic type
+  op = op ?? "main";
+  if (msg instanceof Function) {
+    return log.warning(msg, op);
+  }
+  return log.warning(msg, op);
+}
+
+export function error<T>(
+  msg: Message<T>,
+  op?: string,
+  error?: Error,
+): T | undefined {
+  // Assist TS compiler with pass-through generic type
+  op = op ?? "main";
+  error = error ?? undefined;
+  if (msg instanceof Function) {
+    return log.error(msg, op, error);
+  }
+  return log.error(msg, op, error);
+}
+
+export function critical<T>(
+  msg: Message<T>,
+  op?: string,
+  error?: Error,
+): T | undefined {
+  // Assist TS compiler with pass-through generic type
+  op = op ?? "main";
+  error = error ?? undefined;
+  if (msg instanceof Function) {
+    return log.critical(msg, op, error);
+  }
+  return log.critical(msg, op, error);
+}
+
+function build() {
+  return {
+    setup,
+    prefix,
+    // debug,
+    // info,
+    // warning,
+    // error,
+    // critical,
+  };
+}
+
+export function prefix<T>(op: string) {
+  return {
+    debug: (msg: Message<T>) => debug(msg, op),
+    info: (msg: Message<T>) => info(msg, op),
+    warning: (msg: Message<T>) => warning(msg, op),
+    error: (msg: Message<T>, err?: Error) => error(msg, op, err),
+    critical: (msg: Message<T>, err?: Error) => critical(msg, op, err),
+  };
+}
+
+export default build();
diff --git a/src/merge.ts b/src/merge.ts
index f2eb444..f88d6c1 100644
--- a/src/merge.ts
+++ b/src/merge.ts
@@ -3,10 +3,8 @@
 // deno-lint-ignore-file
 export type Indexable = Record<string, any>;
 
-/**
- * Performs a deep merge of `source` into `target`.
- * Mutates `target` only but not its objects and arrays.
- */
+/** Performs a deep merge of `source` into `target`.
+ * Mutates `target` only but not its objects and arrays. */
 export function merge<T extends Record<string, any>>(
   target: T,
   source: Indexable,
diff --git a/src/runner.ts b/src/runner.ts
index 0af2ff5..0cb1f44 100644
--- a/src/runner.ts
+++ b/src/runner.ts
@@ -10,12 +10,10 @@ import {
 
 import { merge } from "./merge.ts";
 
-/**
- * `Runner` configuration.
+/** `Runner` configuration.
  * This configuration is, in contrast to other, extended
  * by `Denon` config as scripts has to be a top level
- * parameter.
- */
+ * parameter. */
 export interface RunnerConfig extends ScriptOptions {
   scripts: Scripts;
 }
@@ -26,12 +24,10 @@ const reCompact = new RegExp(
 );
 const reCliCompact = new RegExp(/^(run|test|fmt) *(.*)$/);
 
-/**
- * Handle all the things related to process management.
+/** Handle all the things related to process management.
  * Scripts are built into executable commands that are
  * executed by `Deno.run()` and managed in an `Executable`
- * object to make available process events.
- */
+ * object to make available process events. */
 export class Runner {
   #config: RunnerConfig;
   #args: string[];
@@ -41,6 +37,17 @@ export class Runner {
     this.#args = args;
   }
 
+  private cmd(cmd: string[], options: ScriptOptions): Command {
+    const command = {
+      cmd,
+      options,
+      exe: (): Deno.Process => {
+        return this.execute(command);
+      },
+    };
+    return command;
+  }
+
   private buildCliCommand(args: string[], global: ScriptOptions): Command {
     const cmd = args.join(" ");
     let out: string[];
@@ -53,14 +60,7 @@ export class Runner {
     } else {
       out = stdCmd(cmd);
     }
-    const command = {
-      cmd: out,
-      options: global,
-      exe: (): Deno.Process => {
-        return this.execute(command);
-      },
-    };
-    return command; // single command
+    return this.cmd(out, global); // single command
   }
 
   private buildCommands(
@@ -115,27 +115,20 @@ export class Runner {
     }
 
     if (cli) out = out.concat(cli);
-
-    const command = {
-      cmd: out,
-      options: options,
-      exe: (): Deno.Process => {
-        return this.execute(command);
-      },
-    };
-    return command;
+    return this.cmd(out, options); // single command
   }
 
-  /**
-   * Build the script, in whatever form it is declared in,
+  /** Build the script, in whatever form it is declared in,
    * to be compatible with `Deno.run()`.
-   * This function add flags, arguments and actions.
-   */
+   * This function add flags, arguments and actions. */
   build(script: string): Command[] {
     // global options
-    const g = Object.assign({
-      watch: true, // this is a file watcher after all :)
-    }, this.#config);
+    const g = Object.assign(
+      {
+        watch: true, // this is a file watcher after all :)
+      },
+      this.#config,
+    );
     delete g.scripts;
 
     const s: Script = this.#config.scripts[script];
@@ -159,10 +152,8 @@ export class Runner {
     return commands;
   }
 
-  /**
-   * Create an `Execution` object to handle the lifetime
-   * of the process that is executed.
-   */
+  /** Create an `Execution` object to handle the lifetime
+   * of the process that is executed. */
   execute(command: Command): Deno.Process {
     const options = {
       cmd: command.cmd,
diff --git a/src/runner_test.ts b/src/runner_test.ts
index 787454e..34a2ec3 100644
--- a/src/runner_test.ts
+++ b/src/runner_test.ts
@@ -4,7 +4,7 @@ import { RunnerConfig, Runner } from "./runner.ts";
 import { assertEquals } from "../test_deps.ts";
 
 Deno.test({
-  name: "runner:build:oneliner",
+  name: "runner | build | oneliner",
   async fn(): Promise<void> {
     const config: RunnerConfig = {
       scripts: {
@@ -26,19 +26,13 @@ Deno.test({
       "test",
       "helloworld.ts",
     ]);
-    assertEquals(runner.build("oneliner-3")[0].cmd, [
-      "deno",
-      "test",
-    ]);
-    assertEquals(runner.build("oneliner-4")[0].cmd, [
-      "sh",
-      "build.sh",
-    ]);
+    assertEquals(runner.build("oneliner-3")[0].cmd, ["deno", "test"]);
+    assertEquals(runner.build("oneliner-4")[0].cmd, ["sh", "build.sh"]);
   },
 });
 
 Deno.test({
-  name: "runner:build:compact",
+  name: "runner | build | compact",
   async fn(): Promise<void> {
     const config: RunnerConfig = {
       scripts: {
@@ -60,7 +54,7 @@ Deno.test({
 });
 
 Deno.test({
-  name: "runner:build:extended",
+  name: "runner | build | extended",
   async fn(): Promise<void> {
     const config: RunnerConfig = {
       scripts: {
@@ -91,9 +85,6 @@ Deno.test({
       "test",
       "--allow-all",
     ]);
-    assertEquals(runner.build("extended-3")[0].cmd, [
-      "sh",
-      "build.sh",
-    ]);
+    assertEquals(runner.build("extended-3")[0].cmd, ["sh", "build.sh"]);
   },
 });
diff --git a/src/scripts.ts b/src/scripts.ts
index 6fa1237..248ccf4 100644
--- a/src/scripts.ts
+++ b/src/scripts.ts
@@ -1,21 +1,16 @@
 // Copyright 2020-present the denosaurs team. All rights reserved. MIT license.
 
-/**
- * Map of declared scripts,
- * Used by `Runner`.
- */
+/** Map of declared scripts,
+ * Used by `Runner`. */
 export interface Scripts {
   [key: string]: Script;
 }
 
-/**
- * A collection of runnable scripts.
- * See Script
- */
+/** A collection of runnable scripts.
+ * See Script */
 export type ScriptArray = (string | ScriptObject)[];
 
-/**
- * A runnable script.
+/** A runnable script.
  * Can be as simple as a string:
  * ```json
  * {
@@ -31,119 +26,88 @@ export type ScriptArray = (string | ScriptObject)[];
  *      "allow": [ "env", "read" ]
  *   }
  * }
- * ```
- */
+ * ``` */
 export type Script = string | ScriptObject | ScriptArray;
 
-/**
- * Most complete representation of a script. Can
+/** Most complete representation of a script. Can
  * be configured in details as it extends `ScriptOptions`
  * and can also contain a `desc` that is displayed along
- * script name when`denon` is run without any arguments .
- */
+ * script name when`denon` is run without any arguments . */
 export interface ScriptObject extends ScriptOptions {
   cmd: string;
   desc?: string;
 }
 
-/**
- * Deno CLI flags in a map.
- * `{ allow: [ run, env ]}` -> `[--allow-run, --allow-env]`
- */
+/** Deno CLI flags in a map.
+ * `{ allow: { "write": "/tmp", "read": "/tmp" }}`
+ * -> `[--allow-write=/tmp, --allow-read=/tmp]` */
 export interface FlagsObject {
   [key: string]: unknown;
 }
 
-/**
- * Environment variables in a map.
- * `{ TOKEN: "SECRET!" }` -> `TOKEN=SECRET`
- */
+/** Environment variables in a map.
+ * `{ TOKEN: "SECRET!" }`
+ * -> `TOKEN=SECRET` */
 export interface EnvironmentVariables {
   [key: string]: string;
 }
 
-/**
- * Additional script options.
+/** Additional script options.
  *
  * These can be applied both in `ScriptObject`s and at top-level
- * in which case they're applied to all the scripts defined in the file
- */
+ * in which case they're applied to all the scripts defined in the file */
 export interface ScriptOptions {
-  /**
-   * A map of environment variables to be passed to the script
-   */
+  /** A map of environment variables to be passed to the script */
   env?: EnvironmentVariables;
-  /**
-   * A list of boolean `--allow-*` deno cli options or
-   * a map of option names to values
-   */
-  allow?: string[] | FlagsObject;
-  /**
-   * The path to an importmap json file,
+  /** A list of boolean `--allow-*` deno cli options or
+   * a map of option names to values */
+  allow?: string[] | FlagsObject | "all";
+  /** The path to an importmap json file,
    * passed to deno cli's `--importmap` option.
    *
-   * **Note** This currently requires the `--unstable` flag
-   */
+   * **Note** This currently requires the `--unstable` flag */
   importmap?: string;
-  /**
-   * The path to a tsconfig json file,
-   * passed to deno cli's `--tsconfig` option.
-   */
+  /** The path to a tsconfig json file,
+   * passed to deno cli's `--tsconfig` option. */
   tsconfig?: string;
-  /**
-   * If the code that has to be run is using unstable features
+  /** If the code that has to be run is using unstable features
    * from deno standard library this option should be set to
-   * `true` so that `--unstable` option is passed to deno cli's.
-   */
+   * `true` so that `--unstable` option is passed to deno cli's. */
   unstable?: boolean;
-  /**
-   * The hostname and port where to start the inspector,
-   * passed to deno cli's `--inspect` option.
-   */
+  /** The hostname and port where to start the inspector,
+   * passed to deno cli's `--inspect` option. */
   inspect?: string;
-  /**
-   * Same as `inspect`, but breaks at start of user script.
-   */
+  /** Same as `inspect`, but breaks at start of user script. */
   inspectBrk?: string;
-  /**
-   * The path to an _existing_ lockfile,
+  /** The path to an _existing_ lockfile,
    * passed to deno cli's `--lock` option.
    *
    * **Note** This doesn't create the lockfile, use `--lock-write` manually
-   * when appropriate
-   */
+   * when appropriate */
   lock?: string;
-  /**
-   * The path to a PEM certificate file,
-   * passed to deno cli's `--cert` option.
-   */
+  /** The path to a PEM certificate file,
+   * passed to deno cli's `--cert` option. */
   cert?: string;
-  /**
-   * The log level, passed to deno cli's `--log-level` option.
-   */
+  /** The log level, passed to deno cli's `--log-level` option. */
   log?: string;
-  /**
-   * Should watch. Enabled by default. Toggle file watching
-   * for particular script.
-   */
+  /** Should watch. Enabled by default. Toggle file watching
+   * for particular script. */
   watch?: boolean;
-  /**
-   * Standard i/o/err, to be passed directly to Deno.run.
-   */
+  /** Standard i/o/err, to be passed directly to Deno.run. */
   stdin?: "inherit" | "piped" | "null" | number;
   stdout?: "inherit" | "piped" | "null" | number;
   stderr?: "inherit" | "piped" | "null" | number;
 }
 
-/**
- * Build deno flags from ScriptOptions.
- * `{ allow: [ run, env ]}` -> `[--allow-run, --allow-env]`
- */
+/** Build deno flags from ScriptOptions.
+ * `{ allow: [ run, env ]}` -> `[--allow-run, --allow-env]` */
 export function buildFlags(options: ScriptOptions): string[] {
   let flags: string[] = [];
   if (options.allow) {
     if (Array.isArray(options.allow)) {
       options.allow.forEach((flag) => flags.push(`--allow-${flag}`));
+    } else if (options.allow === "all") {
+      flags.push(`--allow-all`);
     } else if (typeof options.allow === "object") {
       Object.entries(options.allow).map(([flag, value]) => {
         if (!value || (typeof value === "boolean" && value)) {
diff --git a/src/scripts_test.ts b/src/scripts_test.ts
index a8364b8..d4e11a6 100644
--- a/src/scripts_test.ts
+++ b/src/scripts_test.ts
@@ -4,15 +4,11 @@ import { buildFlags, ScriptOptions } from "./scripts.ts";
 import { assert, assertEquals } from "../test_deps.ts";
 
 Deno.test({
-  name: "scripts:flags",
+  name: "scripts | flags",
   fn: () => {
     const options: ScriptOptions = {
       watch: false, // not going to show up
-      allow: [
-        "net",
-        "env",
-        "write",
-      ],
+      allow: ["net", "env", "write"],
       cert: "secure.pem",
       env: {
         SECRET: "123", // not going to show up
@@ -55,8 +51,9 @@ Deno.test({
       len--;
     };
 
-    ["--watch", "--env", "--stderr", "--stdin", "--stdout"]
-      .forEach((_) => noExist(_));
+    ["--watch", "--env", "--stderr", "--stdin", "--stdout"].forEach((_) =>
+      noExist(_)
+    );
 
     [
       "--allow-net",
@@ -65,8 +62,7 @@ Deno.test({
       "--unstable",
       "--inspect=127.0.0.1:4321",
       "--inspect-brk=127.0.0.1:1234",
-    ]
-      .forEach((_) => exist(_));
+    ].forEach((_) => exist(_));
 
     const values = {
       "--cert": "secure.pem",
diff --git a/src/watcher.ts b/src/watcher.ts
index 6afe46b..229e54c 100644
--- a/src/watcher.ts
+++ b/src/watcher.ts
@@ -1,7 +1,6 @@
 // Copyright 2020-present the denosaurs team. All rights reserved. MIT license.
 
 import {
-  log,
   deferred,
   globToRegExp,
   extname,
@@ -10,16 +9,13 @@ import {
   delay,
 } from "../deps.ts";
 
-/**
- * Represents a change in the filesystem.
- * Should reflect the Deno.FsEvent.
- */
-type FileAction =
-  | "any"
-  | "access"
-  | "create"
-  | "modify"
-  | "remove";
+import log from "./log.ts";
+
+const logger = log.prefix("path");
+
+/** Represents a change in the filesystem.
+ * Should reflect the Deno.FsEvent. */
+type FileAction = "any" | "access" | "create" | "modify" | "remove";
 
 /** A file that was changed, created or removed */
 export interface FileEvent {
@@ -45,14 +41,12 @@ export interface WatcherConfig {
   legacy?: boolean;
 }
 
-/**
- * Watches for file changes in `paths` path
+/** Watches for file changes in `paths` path
  * yielding an array of all of the changes
  * each time one or more changes are detected.
  * It is debounced by `interval`, `recursive`, `exts`,
  * `match` and `skip` are filtering the files which
- * will yield a change
- */
+ * will yield a change */
 export class Watcher implements AsyncIterable<FileEvent[]> {
   #signal = deferred();
   #changes: { [key: string]: FileAction[] } = {};
@@ -97,23 +91,26 @@ export class Watcher implements AsyncIterable<FileEvent[]> {
   isWatched(path: string): boolean {
     path = this.verifyPath(path);
     if (
-      extname(path) && this.#exts?.length &&
+      extname(path) &&
+      this.#exts?.length &&
       this.#exts?.every((ext) => !path.endsWith(ext))
     ) {
-      log.debug(`path ${path} does not have right extension`);
+      logger.debug(`path ${path} does not have right extension`);
       return false;
     } else if (
-      this.#skip?.length && this.#skip?.some((skip) => path.match(skip))
+      this.#skip?.length &&
+      this.#skip?.some((skip) => path.match(skip))
     ) {
-      log.debug(`path ${path} is skipped`);
+      logger.debug(`path ${path} is skipped`);
       return false;
     } else if (
-      this.#match?.length && this.#match?.every((match) => !path.match(match))
+      this.#match?.length &&
+      this.#match?.every((match) => !path.match(match))
     ) {
-      log.debug(`path ${path} is not matched`);
+      logger.debug(`path ${path} is not matched`);
       return false;
     }
-    log.debug(`path ${path} is matched`);
+    logger.debug(`path ${path} is matched`);
     return true;
   }
 
@@ -136,10 +133,10 @@ export class Watcher implements AsyncIterable<FileEvent[]> {
     this.#watch();
     while (true) {
       await this.#signal;
-      yield Object.entries(this.#changes).map(([
+      yield Object.entries(this.#changes).map(([path, type]) => ({
         path,
         type,
-      ]) => ({ path, type }));
+      }));
       this.reset();
     }
   }
@@ -156,9 +153,7 @@ export class Watcher implements AsyncIterable<FileEvent[]> {
     };
 
     const run = async () => {
-      for await (
-        const event of Deno.watchFs(this.#paths)
-      ) {
+      for await (const event of Deno.watchFs(this.#paths)) {
         const { kind, paths } = event;
         for (const path of paths) {
           if (this.isWatched(path)) {
@@ -214,11 +209,7 @@ export class Watcher implements AsyncIterable<FileEvent[]> {
         const post = current[path];
         if (pre && !post) {
           this.#changes[path].push("remove");
-        } else if (
-          pre &&
-          post &&
-          pre.getTime() !== post.getTime()
-        ) {
+        } else if (pre && post && pre.getTime() !== post.getTime()) {
           this.#changes[path].push("modify");
         }
       }
diff --git a/src/watcher_test.ts b/src/watcher_test.ts
index a19ce4e..7b5fcb2 100644
--- a/src/watcher_test.ts
+++ b/src/watcher_test.ts
@@ -3,12 +3,10 @@
 import { assert } from "../test_deps.ts";
 
 import { Watcher, WatcherConfig } from "./watcher.ts";
-import { setupLog } from "./log.ts";
 
 Deno.test({
-  name: "watcher:exts",
+  name: "watcher | exts",
   async fn(): Promise<void> {
-    await setupLog();
     const config: WatcherConfig = {
       paths: [Deno.cwd()],
       interval: 350,
@@ -52,9 +50,8 @@ Deno.test({
 });
 
 Deno.test({
-  name: "watcher:skip",
+  name: "watcher | skip",
   async fn(): Promise<void> {
-    await setupLog();
     const config: WatcherConfig = {
       paths: [Deno.cwd()],
       interval: 350,