From d3a704601591efc2badd80daacdb65997eaa1078 Mon Sep 17 00:00:00 2001
From: Dexter <dexter.lee@dataintellect.com>
Date: Thu, 16 Apr 2026 17:39:05 +0800
Subject: [PATCH 1/2] New basic logging module using kx.log as reference

---
 di/log/init.q   |   4 ++
 di/log/log.md   |  62 +++++++++++++++++
 di/log/log.q    | 180 ++++++++++++++++++++++++++++++++++++++++++++++++
 di/log/test.csv | 109 +++++++++++++++++++++++++++++
 4 files changed, 355 insertions(+)
 create mode 100644 di/log/init.q
 create mode 100644 di/log/log.md
 create mode 100644 di/log/log.q
 create mode 100644 di/log/test.csv

diff --git a/di/log/init.q b/di/log/init.q
new file mode 100644
index 00000000..0d9eaadc
--- /dev/null
+++ b/di/log/init.q
@@ -0,0 +1,4 @@
+// simple stdout logger - default log dependency for di.* modules
+\l ::log.q
+
+export:([trace;debug;info;warn;error;fatal;createLog])
diff --git a/di/log/log.md b/di/log/log.md
new file mode 100644
index 00000000..aeb143e8
--- /dev/null
+++ b/di/log/log.md
@@ -0,0 +1,62 @@
+# Log
+
+`log.q` is the default logging implementation for `di.*` modules. It writes formatted lines to stdout and satisfies the log dependency contract expected by modules such as `di.email`.
+
+## Usage
+
+```q
+log:use`di.log
+log.info[`mymodule;"starting up"]
+log.warn[`mymodule;"disk usage above 80%"]
+log.error[`mymodule;"connection failed"]
+```
+
+Output format:
+
+```
+2026-04-09T12:00:00.000000000 [INFO] [mymodule] starting up
+2026-04-09T12:00:00.001000000 [WARN] [mymodule] disk usage above 80%
+2026-04-09T12:00:00.002000000 [ERROR] [mymodule] connection failed
+```
+
+## Injecting into other modules
+
+All `di.*` modules that accept a log dependency expect a dictionary with keys `` `info`warn`error ``, each a function with signature `{[ctx;msg]}`.
+
+```q
+log:use`di.log
+logdep:`info`warn`error!(log.info;log.warn;log.error)
+
+email:use`di.email
+email.init[emailconfig;`log`send!(logdep;::)]
+```
+
+## API
+
+### `info`
+Parameters: `[ctx; msg]`
+
+Write an info-level message to stdout.
+
+- `ctx` — symbol context tag (e.g. `` `mymodule ``)
+- `msg` — string message
+
+### `warn`
+Parameters: `[ctx; msg]`
+
+Write a warning-level message to stdout.
+
+### `error`
+Parameters: `[ctx; msg]`
+
+Write an error-level message to stdout.
+
+## Log dependency contract
+
+The log dependency contract used across `di.*` modules requires a dictionary:
+
+```q
+`info`warn`error!({[ctx;msg] ...};{[ctx;msg] ...};{[ctx;msg] ...})
+```
+
+`di.log` satisfies this contract. You can also supply any custom implementation with the same signatures.
diff --git a/di/log/log.q b/di/log/log.q
new file mode 100644
index 00000000..88952a0c
--- /dev/null
+++ b/di/log/log.q
@@ -0,0 +1,180 @@
+// simple stdout logger for di.* modules
+// provides info, warn, error, trace, debug, fatal with signature {[ctx;msg]}
+// ctx is a symbol context tag, msg is a string
+// also provides createLog, a factory for rich structured logger instances
+
+// os-aware newline
+nl:$[.z.o in `w32`w64;"\r\n";"\n"];
+
+// log levels in priority order
+lvls:`trace`debug`info`warn`error`fatal;
+
+// syslog severity per level (rfc5424)
+syslogLvl:lvls!7 7 6 4 3 2i;
+
+// built-in format templates for createLog instances
+fmts:`basic`syslog`raw!("$p $l PID[$i] HOST[$h] $m";"<$s> $m";"$m");
+
+// format pattern handlers for createLog instances; each takes {[level;msg]}
+// level is an uppercase string (e.g. "INFO"), msg is the formatted message string
+pattern:"plihms~"!(
+  {[x;y] string .z.p};
+  {[x;y] x};
+  {[x;y] string .z.i};
+  {[x;y] string .z.h};
+  {[x;y] y};
+  {[x;y] string .z.M.syslogLvl`$lower x};
+  {[x;y] "$"});
+
+// split a format template on delimiter, returning (textparts; substitutionfunctions)
+// escaped delimiter (e.g. $$) is replaced by $~ which resolves to literal $
+fmtprep:{[del;rep;fmt]
+  fmt:ssr[fmt;del,del;del,"~"];
+  parts:del vs fmt;
+  fns:rep@first each 1_parts;
+  (enlist[first parts],1_/:1_parts;fns)
+  };
+
+// apply a prepared format returning the assembled line string
+// level is an uppercase string, msg is the formatted message string
+fmtapply:{[prep;level;msg]
+  textparts:prep 0;
+  fns:prep 1;
+  vals:fns .\:(level;msg);
+  raze first[textparts],vals,'1_textparts
+  };
+
+// apply printf-style variable substitution to a message
+// msg is a plain string or (fmtstring;arg1;arg2;...)
+// %s converts to string, %r uses .Q.s1, %% becomes a literal percent
+fmtmsg:{[msg]
+  $[10h=abs type msg;
+    msg;
+    [fmt:first msg;
+     args:1_msg;
+     fmt:ssr[fmt;"%%";"\000"];
+     parts:"%" vs fmt;
+     subs:"sr"!({$[10h=abs type x;x;-11h=type x;string x;'`type]};.Q.s1);
+     result:first[parts],raze {[subs;args;parts;i]
+       part:parts[1+i];
+       code:first part;
+       rest:1_part;
+       if[not code in key subs;'`$"unsupported format char: ",enlist code];
+       (subs[code] args[i]),rest
+     }[subs;args;parts;] each til count[parts]-1;
+     ssr[result;"\000";"%"]
+    ]
+  ]};
+
+// format and write a log line to stdout using the dependency-contract format
+logline:{[level;ctx;msg]
+  -1 (string .z.p)," [",level,"] [",string[ctx],"] ",msg;
+  };
+
+// simple dependency-contract-compatible log functions; each has signature {[ctx;msg]}
+trace:{[ctx;msg] logline["TRACE";ctx;msg];};
+debug:{[ctx;msg] logline["DEBUG";ctx;msg];};
+info:{[ctx;msg] logline["INFO";ctx;msg];};
+warn:{[ctx;msg] logline["WARN";ctx;msg];};
+error:{[ctx;msg] logline["ERROR";ctx;msg];};
+fatal:{[ctx;msg] logline["FATAL";ctx;msg];};
+
+// instance counter and per-instance state; bare names fall back to .z.M when .z.m not yet set
+i:0;
+inst:()!();
+
+// factory helper: returns a 1-arg {[msg]} log function for the given level and instance
+// each entry in sink is a (handle;sender) pair; sender is called with the formatted text
+makelevel:{[id;gv;lvl]
+  {[id;gv;lvl;msg]
+    if[(lvls?lvl)<lvls?gv`lvl;:()];
+    txt:fmtapply[gv`prep;upper string lvl;fmtmsg msg],nl;
+    {[txt;pair]
+      @[last pair;txt;{x}]
+    }[txt;] each (gv`sink)[lvl];
+  }[id;gv;lvl;]
+  };
+
+// update field k with value v in instance id's state
+updInst:{[id;k;v]
+  state:inst;
+  state[id;k]:v;
+  .z.m.inst:state;
+  };
+
+// create a logger instance with level filtering, multiple formatters and sinks
+// returns a dictionary of functions; each call returns an independent instance
+// sink entries are (handle;sender) pairs; sender is called with the formatted text
+createLog:{[]
+  // increment instance counter and capture id
+  .z.m.i+:1;
+  id:i;
+  // initialise state for this instance; no separate handler dict needed
+  snk:lvls!(count lvls)#enlist();
+  prp:fmtprep["$";pattern;fmts`basic];
+  state:inst;
+  state[id]:`sink`lvl`fmtname`fmts`prep!(snk;`info;`basic;fmts;prp);
+  .z.m.inst:state;
+
+  // helpers that close over id to read and write this instance's state
+  gv:{.z.m.inst[x][y]}[id;];
+  wv:updInst[id;;];
+
+  // set active format by name; recomputes the prepared format template
+  setfmt:{[gv;wv;name]
+    f:gv`fmts;
+    if[not name in key f;'"invalid format: ",string name];
+    wv[`prep;fmtprep["$";pattern;f name]];
+    wv[`fmtname;name];
+  }[gv;wv;];
+
+  // get the current format name; 1-arg (dummy ignored) so gv executes in module context
+  getfmt:{[gv;x] gv`fmtname}[gv;];
+
+  // add a custom named format template string
+  addfmt:{[gv;wv;name;fmt]
+    wv[`fmts;@[gv`fmts;name;:;fmt]];
+  }[gv;wv;;];
+
+  // set minimum log level; messages below this level are suppressed
+  setlvl:{[gv;wv;newlvl]
+    if[not newlvl in lvls;'"invalid level: ",string newlvl];
+    wv[`lvl;newlvl];
+  }[gv;wv;];
+
+  // get the current minimum log level; 1-arg (dummy ignored) so gv executes in module context
+  getlvl:{[gv;x] gv`lvl}[gv;];
+
+  // add a sink (handle or (handle;fn) pair) for one or more log levels
+  // each sink entry is stored as (handle;sender) so mixed types never collide in a dict
+  add:{[id;gv;h;sinklvls]
+    handle:$[0h=type h;first h;h];
+    sender:$[0h=type h;last h;h];
+    {[id;handle;sender;lvl]
+      state:.z.m.inst;
+      sink:state[id;`sink];
+      sink[lvl],:enlist(handle;sender);
+      state[id;`sink]:sink;
+      .z.m.inst:state;
+    }[id;handle;sender;] each (),sinklvls;
+    handle
+  }[id;gv;;];
+
+  // remove a handle from a log level's sink list
+  remove:{[id;h;lvl]
+    state:.z.m.inst;
+    sink:state[id;`sink];
+    sink[lvl]:sink[lvl] where {[h;p] not h~first p}[h;] each sink[lvl];
+    state[id;`sink]:sink;
+    .z.m.inst:state;
+    h
+  }[id;;];
+
+  // initialise default sink: stdout for all levels
+  add[1i;lvls];
+
+  // return public interface as a dictionary of functions
+  (lvls,`add`remove`setfmt`getfmt`addfmt`setlvl`getlvl)!
+    (makelevel[id;gv;] each lvls),
+    (add;remove;setfmt;getfmt;addfmt;setlvl;getlvl)
+  };
diff --git a/di/log/test.csv b/di/log/test.csv
new file mode 100644
index 00000000..a42986e5
--- /dev/null
+++ b/di/log/test.csv
@@ -0,0 +1,109 @@
+action,ms,bytes,lang,code,repeat,minver,comment
+before,0,0,q,lg:use`di.log,1,,load module into session
+
+/ Test 0: simple ctx-based functions exist and are callable
+true,0,0,q,100h=type lg.trace,1,,trace is a function
+true,0,0,q,100h=type lg.debug,1,,debug is a function
+true,0,0,q,100h=type lg.info,1,,info is a function
+true,0,0,q,100h=type lg.warn,1,,warn is a function
+true,0,0,q,100h=type lg.error,1,,error is a function
+true,0,0,q,100h=type lg.fatal,1,,fatal is a function
+
+/ Test 1: simple functions conform to {[ctx;msg]} contract signature
+true,0,0,q,2=count (value lg.info)1,1,,info takes 2 parameters
+true,0,0,q,2=count (value lg.warn)1,1,,warn takes 2 parameters
+true,0,0,q,2=count (value lg.error)1,1,,error takes 2 parameters
+true,0,0,q,2=count (value lg.trace)1,1,,trace takes 2 parameters
+true,0,0,q,2=count (value lg.debug)1,1,,debug takes 2 parameters
+true,0,0,q,2=count (value lg.fatal)1,1,,fatal takes 2 parameters
+
+/ Test 2: simple functions do not throw on valid inputs
+run,0,0,q,lg.info[`di.log;"test info message"],1,,info with symbol ctx and string msg
+run,0,0,q,lg.warn[`di.log;"test warn message"],1,,warn with symbol ctx and string msg
+run,0,0,q,lg.error[`di.log;"test error message"],1,,error with symbol ctx and string msg
+run,0,0,q,lg.trace[`di.log;"test trace message"],1,,trace with symbol ctx and string msg
+run,0,0,q,lg.debug[`di.log;"test debug message"],1,,debug with symbol ctx and string msg
+run,0,0,q,lg.fatal[`di.log;"test fatal message"],1,,fatal with symbol ctx and string msg
+
+/ Test 3: simple functions accept any symbol ctx
+run,0,0,q,lg.info[`mymodule;"processing data"],1,,info with custom module ctx
+run,0,0,q,lg.warn[`mymodule;"approaching limit"],1,,warn with custom module ctx
+run,0,0,q,lg.error[`mymodule;"operation failed"],1,,error with custom module ctx
+
+/ Test 4: createLog is exported and is a function
+true,0,0,q,100h=type lg.createLog,1,,createLog is a function
+
+/ Test 5: createLog returns a dictionary with all expected keys
+before,0,0,q,log1:lg.createLog[],1,,create first logger instance
+true,0,0,q,`trace`debug`info`warn`error`fatal`add`remove`setfmt`getfmt`addfmt`setlvl`getlvl~key log1,1,,createLog returns dict with expected keys
+
+/ Test 6: all level functions in returned dict are callable (projections: 104h)
+true,0,0,q,104h=type log1`trace,1,,instance trace is a function
+true,0,0,q,104h=type log1`debug,1,,instance debug is a function
+true,0,0,q,104h=type log1`info,1,,instance info is a function
+true,0,0,q,104h=type log1`warn,1,,instance warn is a function
+true,0,0,q,104h=type log1`error,1,,instance error is a function
+true,0,0,q,104h=type log1`fatal,1,,instance fatal is a function
+
+/ Test 7: management functions are callable (all projections: 104h)
+true,0,0,q,104h=type log1`setlvl,1,,setlvl is a function
+true,0,0,q,104h=type log1`getlvl,1,,getlvl is a function
+true,0,0,q,104h=type log1`setfmt,1,,setfmt is a function
+true,0,0,q,104h=type log1`getfmt,1,,getfmt is a function
+true,0,0,q,104h=type log1`addfmt,1,,addfmt is a function
+true,0,0,q,104h=type log1`add,1,,add is a function
+true,0,0,q,104h=type log1`remove,1,,remove is a function
+
+/ Test 8: default level is info
+true,0,0,q,`info~log1.getlvl[0],1,,default log level is info
+
+/ Test 9: default format is basic
+true,0,0,q,`basic~log1.getfmt[0],1,,default format is basic
+
+/ Test 10: setlvl changes the active level
+run,0,0,q,log1.setlvl `warn,1,,set level to warn
+true,0,0,q,`warn~log1.getlvl[0],1,,getlvl returns warn after setlvl
+
+/ Test 11: setlvl rejects invalid levels
+true,0,0,q,@[log1.setlvl;`notexist;{1b}],1,,setlvl throws on unknown level
+
+/ Test 12: messages below filter level return () silently
+true,0,0,q,()~log1.info "this should be suppressed",1,,info below warn filter returns ()
+run,0,0,q,log1.setlvl `info,1,,restore level to info
+
+/ Test 13: level functions do not throw on valid messages
+run,0,0,q,log1.info "test message",1,,instance info accepts plain string
+run,0,0,q,log1.warn "test warning",1,,instance warn accepts plain string
+
+/ Test 14: setfmt changes the active format
+run,0,0,q,log1.setfmt `syslog,1,,set format to syslog
+true,0,0,q,`syslog~log1.getfmt[0],1,,getfmt returns syslog after setfmt
+run,0,0,q,log1.setfmt `raw,1,,set format to raw
+true,0,0,q,`raw~log1.getfmt[0],1,,getfmt returns raw after setfmt
+run,0,0,q,log1.setfmt `basic,1,,restore format to basic
+
+/ Test 15: setfmt rejects unknown format names
+true,0,0,q,@[log1.setfmt;`notexist;{1b}],1,,setfmt throws on unknown format
+
+/ Test 16: addfmt adds a new named format
+run,0,0,q,log1.addfmt[`compact;"$l $m"],1,,add compact format
+run,0,0,q,log1.setfmt `compact,1,,switch to custom compact format
+true,0,0,q,`compact~log1.getfmt[0],1,,getfmt returns custom format name
+run,0,0,q,log1.setfmt `basic,1,,restore to basic
+
+/ Test 17: each createLog call returns an independent instance
+before,0,0,q,log2:lg.createLog[],1,,create second logger instance
+run,0,0,q,log2.setlvl `error,1,,set log2 level to error
+true,0,0,q,`info~log1.getlvl[0],1,,log1 level unaffected by log2 setlvl
+true,0,0,q,`error~log2.getlvl[0],1,,log2 level is error independently
+
+/ Test 18: add with a function sink returns the function handle
+before,0,0,q,nosink:{[msg] 1b},1,,define a no-op function sink
+true,0,0,q,nosink~log1.add[nosink;`info],1,,add returns the registered function handle
+run,0,0,q,log1.remove[nosink;`info],1,,remove function sink from info level
+
+/ Test 19: fmtmsg plain string passes through (internal helper, tested indirectly)
+run,0,0,q,log1.info "plain string message",1,,instance info with plain string
+run,0,0,q,log1.info ("message with %s";`symbol),1,,instance info with %s substitution
+run,0,0,q,log1.info ("message with %r";"raw repr"),1,,instance info with %r substitution
+run,0,0,q,log1.info "literal 100%% complete",1,,instance info with %% escape

From f5c81ef43527e8b3dd1febf09c97297913aca7ea Mon Sep 17 00:00:00 2001
From: Dexter <dexter.lee@dataintellect.com>
Date: Thu, 16 Apr 2026 17:47:12 +0800
Subject: [PATCH 2/2] Update changes not included in testing and markdown doc
 for trace, debug and fatal

---
 di/log/log.md   | 100 +++++++++++++++++++++++++++++++++++++++++++++---
 di/log/test.csv |  34 ++++++++++++++++
 2 files changed, 129 insertions(+), 5 deletions(-)

diff --git a/di/log/log.md b/di/log/log.md
index aeb143e8..5d05cddd 100644
--- a/di/log/log.md
+++ b/di/log/log.md
@@ -6,17 +6,23 @@
 
 ```q
 log:use`di.log
+log.trace[`mymodule;"entering function"]
+log.debug[`mymodule;"value is 42"]
 log.info[`mymodule;"starting up"]
 log.warn[`mymodule;"disk usage above 80%"]
 log.error[`mymodule;"connection failed"]
+log.fatal[`mymodule;"unrecoverable error, shutting down"]
 ```
 
 Output format:
 
 ```
-2026-04-09T12:00:00.000000000 [INFO] [mymodule] starting up
-2026-04-09T12:00:00.001000000 [WARN] [mymodule] disk usage above 80%
-2026-04-09T12:00:00.002000000 [ERROR] [mymodule] connection failed
+2026-04-09T12:00:00.000000000 [TRACE] [mymodule] entering function
+2026-04-09T12:00:00.001000000 [DEBUG] [mymodule] value is 42
+2026-04-09T12:00:00.002000000 [INFO] [mymodule] starting up
+2026-04-09T12:00:00.003000000 [WARN] [mymodule] disk usage above 80%
+2026-04-09T12:00:00.004000000 [ERROR] [mymodule] connection failed
+2026-04-09T12:00:00.005000000 [FATAL] [mymodule] unrecoverable error, shutting down
 ```
 
 ## Injecting into other modules
@@ -31,16 +37,77 @@ email:use`di.email
 email.init[emailconfig;`log`send!(logdep;::)]
 ```
 
+You can extend the injected dictionary with `trace`, `debug`, and `fatal` for modules that support them:
+
+```q
+logdep:`trace`debug`info`warn`error`fatal!(log.trace;log.debug;log.info;log.warn;log.error;log.fatal)
+```
+
+## createLog
+
+`createLog` is a factory that returns an independent logger instance with level filtering, multiple output sinks, and configurable format templates. Each call to `createLog` produces a separate instance with its own state.
+
+```q
+log:use`di.log
+mylog:log.createLog[]
+
+mylog.setlvl `warn                        / suppress trace, debug, info
+mylog.info "this is suppressed"           / returns () silently
+mylog.warn "this appears"
+
+mylog.setfmt `syslog                      / switch to syslog format
+mylog.addfmt[`compact;"$l $m"]           / add a custom format
+mylog.setfmt `compact
+
+mylog.add[2i;`error`fatal]               / add stderr sink for error and fatal
+mylog.remove[1i;`trace]                  / remove stdout from trace level
+```
+
+### Sinks
+
+A sink is a handle (integer file descriptor or function) passed to `add`. If a function is provided it is called with the formatted line string. Built-in handles follow standard q conventions: `1i` is stdout, `2i` is stderr.
+
+```q
+buf:();
+capture:{[msg] buf,:enlist msg};         / function sink - captures output
+mylog.add[capture;`info`warn`error]
+mylog.info "captured"
+buf                                      / ("2026-...captured\n")
+mylog.remove[capture;`info]
+```
+
+### Format templates
+
+Three built-in formats are available:
+
+| Name | Template | Example output |
+|---|---|---|
+| `basic` (default) | `$p $l PID[$i] HOST[$h] $m` | `2026-04-09T12:00:00.000000000 INFO PID[1234] HOST[myhost] message` |
+| `syslog` | `<$s> $m` | `<6> message` |
+| `raw` | `$m` | `message` |
+
+Template variables: `$p` timestamp, `$l` level, `$i` PID, `$h` hostname, `$m` message, `$s` syslog severity number.
+
 ## API
 
-### `info`
+### `trace`
 Parameters: `[ctx; msg]`
 
-Write an info-level message to stdout.
+Write a trace-level message to stdout.
 
 - `ctx` — symbol context tag (e.g. `` `mymodule ``)
 - `msg` — string message
 
+### `debug`
+Parameters: `[ctx; msg]`
+
+Write a debug-level message to stdout.
+
+### `info`
+Parameters: `[ctx; msg]`
+
+Write an info-level message to stdout.
+
 ### `warn`
 Parameters: `[ctx; msg]`
 
@@ -51,6 +118,29 @@ Parameters: `[ctx; msg]`
 
 Write an error-level message to stdout.
 
+### `fatal`
+Parameters: `[ctx; msg]`
+
+Write a fatal-level message to stdout.
+
+### `createLog`
+Parameters: none
+
+Returns an independent logger instance as a dictionary of functions. Each call returns a new instance with isolated state.
+
+Returned keys: `` `trace`debug`info`warn`error`fatal`add`remove`setfmt`getfmt`addfmt`setlvl`getlvl ``
+
+| Function | Parameters | Description |
+|---|---|---|
+| `trace`..`fatal` | `[msg]` | Write a message at the given level (filtered by active level) |
+| `setlvl` | `[lvl]` | Set minimum level; one of `` `trace`debug`info`warn`error`fatal `` |
+| `getlvl` | `[_]` | Return current minimum level |
+| `setfmt` | `[name]` | Switch to a named format template |
+| `getfmt` | `[_]` | Return current format name |
+| `addfmt` | `[name;template]` | Register a new named format template |
+| `add` | `[handle;lvls]` | Add a sink for one or more levels; returns the handle |
+| `remove` | `[handle;lvl]` | Remove a sink from a level |
+
 ## Log dependency contract
 
 The log dependency contract used across `di.*` modules requires a dictionary:
diff --git a/di/log/test.csv b/di/log/test.csv
index a42986e5..f3012440 100644
--- a/di/log/test.csv
+++ b/di/log/test.csv
@@ -107,3 +107,37 @@ run,0,0,q,log1.info "plain string message",1,,instance info with plain string
 run,0,0,q,log1.info ("message with %s";`symbol),1,,instance info with %s substitution
 run,0,0,q,log1.info ("message with %r";"raw repr"),1,,instance info with %r substitution
 run,0,0,q,log1.info "literal 100%% complete",1,,instance info with %% escape
+
+/ Test 20: trace, debug and fatal accept any symbol ctx
+run,0,0,q,lg.trace[`mymodule;"trace custom ctx"],1,,trace with custom module ctx
+run,0,0,q,lg.debug[`mymodule;"debug custom ctx"],1,,debug with custom module ctx
+run,0,0,q,lg.fatal[`mymodule;"fatal custom ctx"],1,,fatal with custom module ctx
+
+/ Test 21: instance trace, debug and fatal do not throw
+run,0,0,q,log1.setlvl `trace,1,,lower level to trace so trace and debug are not suppressed
+run,0,0,q,log1.trace "test trace",1,,instance trace accepts plain string
+run,0,0,q,log1.debug "test debug",1,,instance debug accepts plain string
+run,0,0,q,log1.fatal "test fatal",1,,instance fatal accepts plain string
+run,0,0,q,log1.setlvl `info,1,,restore level to info
+
+/ Test 22: function sink captures formatted output
+before,0,0,q,log3:lg.createLog[],1,,create logger for sink capture test
+before,0,0,q,captured:(),1,,initialise capture buffer
+before,0,0,q,"capfn:{captured::captured,enlist x}",1,,define capture function that appends to global
+run,0,0,q,log3.add[capfn;`info],1,,add function sink to info level
+run,0,0,q,log3.info "sink test message",1,,send message through function sink
+true,0,0,q,0<count captured,1,,function sink received output
+true,0,0,q,"any {0<count x ss ""sink test message""} each captured",1,,captured output contains the message text
+
+/ Test 23: setlvl `fatal suppresses all levels below fatal
+before,0,0,q,log4:lg.createLog[],1,,create logger for fatal-level filter test
+before,0,0,q,fcaptured:(),1,,initialise fatal capture buffer
+before,0,0,q,"ffn:{fcaptured::fcaptured,enlist x}",1,,define fatal capture function
+run,0,0,q,"log4.add[ffn;`trace`debug`info`warn`error`fatal]",1,,add sink to all levels
+run,0,0,q,log4.setlvl `fatal,1,,set level to fatal
+true,0,0,q,"()~log4.info ""suppressed""",1,,info suppressed at fatal level
+true,0,0,q,"()~log4.warn ""suppressed""",1,,warn suppressed at fatal level
+true,0,0,q,"()~log4.error ""suppressed""",1,,error suppressed at fatal level
+true,0,0,q,0=count fcaptured,1,,no messages captured below fatal level
+run,0,0,q,"log4.fatal ""fatal passes through""",1,,fatal level passes through
+true,0,0,q,0<count fcaptured,1,,fatal level message was captured