[Troubleshooting HelpRequest] How to set log-levels/handlers for all threads in prologue when compiled with `--threads:on`?
Heyho, I've recently found myself struggling with some debugging in my application. I use norm as my ORM together with prologue on an sqlite database. Normally, when compiled with `-d:normDebug`, norm will log its SQL queries to the commandline using std/logging. However, when I use norm for a db-query within a controller proc, norm no longer logs to the console, even when the compiler flag is present. 

Edit: I was an idiot and thus did a strike-through on the irrelevant text bits below I wrote previously. It turns out I should've read the logging lib better. There it states:

>    There are a few details to keep in mind when using this module within multiple threads:
    - The global log filter is actually a thread-local variable, so it needs to be set in each thread that uses this module.
    - The list of registered handlers is also a thread-local variable. If a handler will be used in multiple threads, it needs to be registered in each of those threads.

This changes my question: How do I set the log-level to debug / add handlers for all threads in prologue if I compile with --threads:on ? I assume prologue does the heavy lifting regarding instantiation of threads, since my own code doesn't do any of that, therefore the question.

~~I have ascertained that the calls to the log-proc within norm still happen, as when I write an `echo` statement into norm at the proc I can see an output in the terminal.~~

~~Find below a minimal example. If you ping the URL `localhost:8080/creature/1/` you'll see no output in the terminal of an sql, even though norm just made one to fetch an entry. Why is that?~~

~~In my testing I compiled the code below with `nim c -r -d:normDebug --threads:on ./src/testendpoint.nim`. This issue **only** happened when compiling with `--threads:on`.~~

```nim
import prologue
import tinypool
import std/[options, strformat, strutils, logging]
import norm/[model, sqlite, pragmas]

type MyDbConn = sqlite.DbConn | db_sqlite.DbConn

type CreatureRead* {.tableName: "wikientries_creature".} = ref object of Model
    name*: string 
    description*: Option[string]
    creation_datetime*: string
    update_datetime*: string

proc newModel*(T: typedesc[CreatureRead]): CreatureRead = CreatureRead(name: "", description: none(string), creation_datetime: "", update_datetime: "")


proc getEntryById*[M: Model](connection: MyDbConn, entryId: int64, modelType: typedesc[M]): M =
    ##[ Retrieves a single row/entry of a Model M from the database, whose id matches the given id. ]##
    var targetEntry: M = newModel(M)
    const modelTableName: string = M.table()
    var sqlCondition: string = fmt "{modelTableName}.id = ?"

    connection.select(targetEntry, sqlCondition, entryId)

    result = targetEntry


proc getCreatureByIdView*(ctx: Context) {.async.} =    
    let creatureId: int = parseInt(ctx.getPathParams("id"))
    var creature: CreatureRead
    withDbConn(connection):
      creature = connection.getEntryById(creatureId, CreatureRead)


proc main() =
    let connectionPoolSize: int = 4
    let databasePath: string = "mydb.sqlite3"
    initConnectionPool(databasePath, connectionPoolSize)

    # init database
    withDbConn(connection):
      connection.createTables(newModel(CreatureRead))
      var dummy1 = newModel(CreatureRead)
      dummy1.name = "la"
      dummy1.creation_datetime = "some time"
      dummy1.update_datetime = "some time"
      connection.insert(dummy1)

    # run prologue
    let settings = newSettings(debug = true)
    var app: Prologue = newApp(settings)
    app.addRoute(
        re fmt"/creature/(?P<id>[\d]+)/", 
        getCreatureByIdView, 
        httpMethod = HttpGet,
    )
    app.run()

    destroyConnectionPool()


setLogFilter(lvlDebug)
addHandler(newConsoleLogger())
main()
```