Question

I need a logging library for my multi-threaded Tcl aplication. Can I use standard logger package? If I can, what restrictions are applied in multi-threading environment?

I’d like to share logging services among the threads, if possible.

Thanks

Answer 1

Tcl threads do not share data (unless you explicitly use certain facilities from the Thread package) and instead are communicating via message passing. So it seems like the way to go would be to setup a dedicated “logger” thread and just queue logging messages into it from the worker threads.

Otherwise the point of contention will probably be somewhere in the OS resource used by the logger to actually write data.

Update Okay, here’s a working sketch of what I actually proposed to implement:

package require Tcl 8.5
package require Thread

proc make_worker_thread {logger_id body} {
  set newbody [list set ::logger $logger_id]
  append newbody \n {
    proc ::log {severity msg} {
      global logger
      thread::send $logger [list ::log $severity $msg]
    }
  } \n $body
  thread::create $newbody
}

set logger [thread::create {
  package require logger

  proc log {severity msg} {
    puts "hey, that's it: ($severity) $msg"
  }

  puts "logger thread created: [thread::id]"

  thread::wait
}]

for {set i 0} {$i < 3} {incr i} {
  make_worker_thread $logger {
    proc post_msg {} {
      log notice "A message from [thread::id]"
        after 1000 ::post_msg
    }

    puts "worker thread created: [thread::id]"

    after 1000 ::post_msg

    thread::wait
  }
}

vwait forever

This code creates one logger thread and four worker threads each of which posts a message to the logger thread once per second. The code runs until manually interrupted. The logger thread just simple-mindedly outputs the message it was passed to the console, but as someone else in this thread already mentioned, you could probably use the “logger” package from Tcllib, if you need fancy stuff like facilities.

To reiterate my points:

• The logger package itself does not presumably know anything about threading.
• Tcl threads are well-separated and usually communicate via message passing.
• Hence create a thread for the logger and teach worker threads send messages to it; therefore working threads are not concerned with how logger is implemented.

P.S. In the worker threads, you can use [thread::send -async ...] to make sending log messages fully asynchronous.