<h2> Structured and hierarchical logging with :token-parametric API </h2>

 * <small> State: ***experimental*** </small>
 * <small> Category: logging </small>
 * <small> Features: journaling, structured, hierarchical </small>
 * <small> Backend: SQLite, JSON, <del>fluentd</del>, <del>logstash</del> </small>
 * <small> Signature: hybrid, parametric </small>

**logStruck <kbd>`ł`</kbd>** implements a logging API and SQLite/JSON storage backend.

 * Its purpose is storing *structured* log data and retaining log event hierarchies.
 * Implements a hybrid and terse function interface.
 * Accepts plain string messages, Ruby-style `:token` categorizers and placeholders, and array data.
 * Implicitly captures and maps PHP errors, unhandled exceptions, and most importantly *`assert()`ions*.

Unlike other PHP logging frameworks it's not primarily a text/line-oriented message dump.


## Quick example

Invocations can be along the lines of:

     ł(':warn', ':wikiauth', "User doesn't have permission", $pageObj, ':vars', $_SESSION);

All the fun is in the `:token` literals, and passing arrays or objects.


## Database scheme, primary fields

All columns in the database scheme are *primary fields*. Any extra data/values end up in the `context` array.

<style>
 table.dbstruct {
   width: 75%;
   margin-left: 3%;
 }
 table.dbstruct td {
   vertical-align: top;
 }
 table.dbstruct tr:nth-child(2n) {
   background: #efefef;
 }
</style>
<table class=dbstruct>
<tr><td> <kbd>i</kbd>  </td>  <td>PRIM</td>  <td rowspan=3>Where `i` is the primary index, `g` the event group, and `p` the parent reference. Which allows displaying event group hierarchies. <img align=bottom width=485 height=93 alt="log
<tr><td> <kbd>g</kbd>  </td>  <td>INT</td>            </tr>
<tr><td> <kbd>p</kbd>  </td>  <td>INT</td>            </tr>
<tr><td> <kbd>timestamp</kbd>   </td>  <td>REAL</td> <td>Timestamp with
<tr><td> <td>TEXT</td> <td>ISO DateTime string. In GMT/UTC of
<tr><td> <kbd>host</kbd>   </td>  <td>TEXT</td>
<tr><td> <kbd>pri</kbd>    </td>  <td>INT</td> <td>Priority number
<tr><td> <td>TEXT</td> <td>Priority string
<tr><td> <kbd>source</kbd> </td>  <td>TEXT</td> <td>log | sys | lang | excpt |
<tr><td> <kbd>errno</kbd>  </td>  <td>INT</td>
<tr><td> <kbd>app</kbd>    </td>  <td>TEXT</td>
<tr><td> <td>TEXT</td> <td>Application structure / module / part /
<tr><td> <kbd>file</kbd>   </td>  <td>TEXT</td>
<tr><td> <kbd>line</kbd>   </td>  <td>INT</td>
<tr><td> <td>TEXT</td> <td>Meta data from source
<tr><td> <td>TEXT</td> <td>Primary log event message
<tr><td> <kbd>doc</kbd>    </td>  <td>TEXT</td> <td>Extra documentation / long message /
<tr><td> <td>JSON</td> <td>Array of
<tr><td> <kbd>code</kbd>   </td>  <td>TEXT</td> <td>Extracted code context (3
<tr><td> <kbd>vars</kbd>   </td>  <td>JSON</td> <td>Main $vars[]
<tr><td> <td>JSON</td> <td>Additional / user-defined
<table>


## Flexible parametric API

The chief invocation method is <kbd>ł()</kbd>. On the outset it's a procedural function, thus available globally. Behind the scenes it keeps a primary logger group. Alternatively it can be invoked via <kbd>ł::<em style=color:#630>option</em>_<em

For plain old log messages it's as simple to use as:

     ł("A thing happened.");

Usually you also want to convey a <u>priority</u> however:

     ł("Warnful warning", ':warn');

The <kbd>:token</kbd> attributes are the most interesting concept in this logging API. They simulate Ruby-style symbols. In PHP they need to be enquoted as strings however.

Besides priority levels, an *important* use is classifying an <u>application section</u>. Anything that isn't a reserved keyword :token will simply be assumed to refer to an application module:

     ł(':auth', "Authorization error", ':notice');

Make up memorable designators to categorize your log messages according to your application structure and code flow.

An obvious benefit of the :token syntax is that it allows <u>freely ordered</u> parameter lists.
These are all equivalent:

     ł(':warn', ':db', "Database error");
     ł(':db', ':warn', "Database error");
     ł(':warn', "Database error", ':db');

You'd probably want to be somewhat consistent though. But flexibility occasionally helps readability, in particular when passing functional :tokens or arrays/lists.


#### Array data

As mentioned, this logger API isn't meant for just string data. You often want to convey <u>context data</u>, and additional attributes. It's often as simple as just attaching an array to the parameter list:

     ł(':debug', "Front controller state", $RequestVars);

Now those would end up in the `context` database field.<br>
To retain them in the `vars` column, you have two options:

     ł(':debug', "Front controller state", ['vars' => $RequestVars]);

Or the more fancy <kbd>:vars</kbd> <u>array designator</u>:

     ł(':debug', "Front controller state", ':vars', ⃕$RequestVars);

You might also use this for other fields like `:message` / `:code` / `:doc`, as long as the following parameter is an array.


#### Data mapping with `"field: value"`

Plain strings usually end up in the `message` field. But the structured database scheme has more <u>fields</u>, each with specific purposes. You can easily populate them with the key:value syntax.

     ł("File reading error", "errno: EACCESS");

Here `errno` is actually an integer field, thus will be converted afterwards.

A more interesting field to take care of is the <u>`doc`</u> column.

     ł("Cache directory locked", "doc: ?wiki=SetCachePerm");

Nowadays logs are often consumed by machines rather than humans. For some projects you may however wish to be more descriptive. You can augment the coarse and technical message summary. Supply a human-readable description for non-programmers. (In other logging APIs this is usually an afterthought, if at all implemented, seldomly even manageable in log processors/viewers).

While you could use the `doc:` field for a long prosaic documentation, this needlessly stuffs the datastore. Instead prefer hyperlinks, or references. A `"?tktid=12345"` or `"See setup.txt on chmod cache"` are helpful minimums. Relative link references are easiest to process.

All of the *primary fields* could also be set using the key:value scheme:

     ł('section: auth', "Auth warning");
     ł("message: $php_errormsg");
     ł('source: sys', "Exec failure", "errno: $retval", [$cmd]);
     ł("Regex failed", "code: $rx", "errno: $preg_last_error");

And fields that aren't primary log event columns/fields will end up in the `context` database array.

     ł("Special needs logging", "var1: $var1", "method: $callback");

This is basically equivalent to using a `["key"=>"value", ...]` list. Again, prefer what's more readable in whatever context.


#### Injectors

As if there wasn't enough flexibility already, <kbd>:tokens</kbd> can also refer to data source functions.

You can augment log events with a <kbd>:backtrace</kbd> most of the time:

     ł(':warn', "How did we get here?", ':backtrace');

The placeholder token will be substituted by an array, before being pushed to the log store.

Likewise you can interpolate some common vars:

     ł(':debug', "Front Controller startup", ':server');

Or extract pretty much all available meta data:

     ł(':debug', "Debug by logging", ':backtrace', ':file', ':code', ':version');

The built-in error / exception / assert handlers do this automatically for example, to varying degrees.


#### Hybrid <kbd>ł::<em style=color:#630>option</em>_<em

The :token scheme is pretty neat, but certainly not to everyones liking, and sometimes less readable than plain boring method calls. Therefore the `ł()` function and `ł::` class go hand in hand. Instead of listing tokens as arguments, you can just compact them into a virtual method name:

     ł::debug_auth("Authorization failed", $UserObject);

You can even freely mix in injector callbacks and *one* array designator:

     ł::warn_db_backtrace_file_vars("DB error", $stmt);

Again, you're the programmer. Make sound choices on a case-by-case basis. Don't be clingy with stale semantics.


## All the <kbd>:tokens</kbd>!

Around two dozen :token names are reserved keywords / internal field names:

<table class=dbstruct style="width:75%">

<tr><th colspan=3>Priority
<td>`7`</td> <td>Low-level debug
<td>`6`</td> <td>Process flow infos
<tr><td><kbd>:notice</kbd>, <td>`5`</td> <td>Lowest priority language
<tr><td><kbd>:warning</kbd>, <td>`4`</td>
<tr><td><kbd>:error</kbd>, <td>`3`</td> <td>PHP or system
<tr><td><kbd>:critical</kbd>, <td>`2`</td> <td>This can't be
<tr><td><kbd>:alert</kbd>, <td>`1`</td> <td>Turn on the bat
<tr><td><kbd>:emergency</kbd>, <td>`0`</td> <td>Someone call the

<tr><th colspan=3>Source /
<td></td> <td>Application origin, normal/manual log
<td></td> <td>System-level events and errno
<td></td> <td>Language errors, warnings, notices,
<td></td> <td>Langauge/runtime
<td></td> <td>`Assert()`

<tr><th colspan=3>Field
<tr><td colspan=3>Any database column / primary field name can be represented as `:token`. It's pretty much only useful to use <kbd>:vars</kbd> however to map the following array

<tr><th
<tr><td colspan=3>Besides the prio levels, there are a few more shortened aliases to common fields. Among them  <kbd>:documentation</kbd> for :doc,   <kbd>:priority</kbd> for :prio, <kbd>:help</kbd> for :doc, <kbd>:msg</kbd> for :message, <kbd>:language</kbd> for <kbd>lang</kbd>, <kbd>:exc</kbd> for :exception, <kbd>:app</kbd> as <kbd>:log</kbd> generator source alias, <kbd>:trace</kbd> and <kbd>:stack</kbd> as aliases for :backtrace, and <kbd>:env</kbd> for :server

<tr><th colspan=3>Injector
<td></td> <td>Populates
<td></td> <td>Inserts $_SERVER array into
<td></td> <td>Uncovers `file` and `line` from
<td></td> <td>Reads out meta data (file/scm version, and section) from script
<td></td> <td>Inserts 3 lines of `code`
<td></td> <td>Tries to deduce log event hierarchy from prior calls, sections, and backtraces. (Not yet

</table>

Any other `:token` name can be used freely to classify and group your application flow. They'll be used as **section** names.


## Setup

You obviously need a readily available `log.db` SQLite store. Best keep it `DOCUMENT_ROOT`-relative, so it's easy to declare on instantiation:

    ł::$db =
    ł::$app = "YourAppID";

You can of course manually load the library. Most autoloaders would already load it implicitly because of the class reference. (Even PSR-x ones, and they'd even be accidentially correct for once with case-sensitive Unicode lookups here).

While you ought to use `:section` names for logging calls, you can also override/update the default throughout your application flow with:

    ł::$section = "forum";

Or likewise adapt properties of the global logger group `ł()->section=..`.


#### Default injectors

The `$logger` instance in `ł()` takes a list of default :token options and injectors. You should adapt it directly to enable further features.

       $logger = new ł(":log", ':backtrace', ':file', ':version', ':p');

For instance would engage full event population for all/manual logging calls.


#### Avoid complexity

  *  Yes, you could actually run multiple logger groups, or pass around the `$logger` handler. Don't do it. (Kind of works, but wasn't intended to.)

  *  The alternative branches and `store()` implementations are meant to be patched in. It makes zero sense to DI / runtime-bind them. You're only going to use one approach in practice, so don't complicate instantiation.

  *  Take care with leaking information through logs. It's tempting to include a backtrace for all calls. But in particular authorization-sensitive variable states may only be useful for concrete debugging tasks, not in all log events. (That's in important consideration for any logging scheme; but moreso for logStruck due to its much simpler API and utilization.)


<br>
<br>


### Notes / Rationale

 * So, this is all either genius, or completely bonkers.

 * logStruck is decidedly different to most other logging libraries in PHP. It doesn't follow PSR-3 (lowest common denominator) and historic line/text-oriented logging. In particular it tries to avoid parsing+reformatting backends or making structured/JSON logging an afterthought.

 * Entirely intended as userland runtime. Mostly suitable for wee projects. It's primary use case is application-level debugging and auditability.

 * The function name <kbd>ł</kbd> isn't completely settled on. (Maybe a bit too much novelty strive.)

 * Extensibility of the database scheme is easily done, but not planned for.

 * Alternative logging backends are best implemented in branches.

      * (In the time and age of GitHub forkeritis anyway.)

      * It doesn't seem senseful to impose a configuration-centric instantiation.

      * However making `$ł->db` just a Callable would be trivial.

      * The API and JSON-logging design is specifically meant to avoid
       MonoLog-style message formatting / parsing / filter chains.
       Events are structured from the start, shouldn't be downconverted
       to suit textdump interfaces.

<!-- -->

 * Inspired by structlog, cabin, journald, graylog, PEAR log even, and with logstash/fluentd in mind.

 * The fancy ':token' signature is used in place of named params and constant literals in PHP.

 * Currently just inserts one-dimensional events. The API mapping is
   too crude still for spatial collections.


### ToDo

 * Log events are only associated to a primary group event as of now.
   The `:p` filter will allow to regroup events automatically from context information.

      * It'll scan the backtrace for matching prior code paths, and obviously the used :sections to relate events to another.

      * Alternatively control it manually:

              $p = ł("first");
              ł("second", "p:$p");

        A logger call returns the new event id. And `p:` is just the field that keeps the handle.

<!-- -->

 * The alternative JSON file-append store just keeps event-local ids. This needs an insertion transaction or trigger for reconverting into a SQLite store. (Rather simple.)

 * To mix application and server-level logging an injector for Apaches `UNIQUE_ID` might make sense. Still would require log post-processing to turn it into a sequential event id. Or alternatively stash all entries with a UUID.

 * Investigate whether logstash (supposedly works with multiline/mutate), fluentd or graylog2 make suitable targets. Neither seems to provide incremental log ids on submission. Each requires post processing on pushed events, or incremental json/sqlite imports.

 * Most obiously this implementation hinges an a proper GUI. It's kinda pointless to make another ETL toy, if it wasn't for the absence of hierarchical support in existing log viewers. While a web viewer would suffice, only an actual desktop tool would benefit from the intended JSON → SQLite storage.