diff --git a/sylk/applications/webrtcgateway/janus/logger.py b/sylk/applications/webrtcgateway/janus/logger.py
index ac5bb81..c04b84c 100644
--- a/sylk/applications/webrtcgateway/janus/logger.py
+++ b/sylk/applications/webrtcgateway/janus/logger.py
@@ -1,95 +1,95 @@
 
 """
 Logging support for Janus traffic.
 """
 
 __all__ = ["Logger"]
 
 import os
 import sys
 
 from application.system import makedirs
 from sipsimple.configuration.settings import SIPSimpleSettings
 from sipsimple.threading import run_in_thread
 
 
 class Logger(object):
     def __init__(self):
         self.stopped = False
         self._janustrace_filename = None
         self._janustrace_file = None
         self._janustrace_error = False
         self._janustrace_start_time = None
         self._janustrace_packet_count = 0
 
         self._log_directory_error = False
 
     def start(self):
         # try to create the log directory
         try:
             self._init_log_directory()
             self._init_log_file()
         except Exception:
             pass
         self.stopped = False
 
     def stop(self):
         self.stopped = True
         if self._janustrace_file is not None:
             self._janustrace_file.close()
             self._janustrace_file = None
 
     def msg(self, direction, timestamp, packet):
         if self._janustrace_start_time is None:
             self._janustrace_start_time = timestamp
         self._janustrace_packet_count += 1
-        buf = ["%s: Packet %d, +%s" % (direction, self._janustrace_packet_count, (timestamp - self._janustrace_start_time))]
-        buf.append(packet)
-        buf.append('--')
+        buf = ("%s: Packet %d, +%s" % (direction, self._janustrace_packet_count, (timestamp - self._janustrace_start_time)),
+               packet,
+               '--')
         message = '\n'.join(buf)
         self._process_log((message, timestamp))
 
     @run_in_thread('log-io')
     def _process_log(self, record):
         if self.stopped:
             return
         message, timestamp = record
         try:
             self._init_log_file()
         except Exception:
             pass
         else:
             self._janustrace_file.write('%s [%s %d]: %s\n' % (timestamp, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._janustrace_file.flush()
 
     def _init_log_directory(self):
         settings = SIPSimpleSettings()
         log_directory = settings.logs.directory.normalized
         try:
             makedirs(log_directory)
         except Exception, e:
             if not self._log_directory_error:
                 print "failed to create logs directory '%s': %s" % (log_directory, e)
                 self._log_directory_error = True
             self._janustrace_error = True
             raise
         else:
             self._log_directory_error = False
             if self._janustrace_filename is None:
                 self._janustrace_filename = os.path.join(log_directory, 'janus_trace.log')
                 self._janustrace_error = False
 
     def _init_log_file(self):
         if self._janustrace_file is None:
             self._init_log_directory()
             filename = self._janustrace_filename
             try:
                 self._janustrace_file = open(filename, 'a')
             except Exception, e:
                 if not self._janustrace_error:
                     print "failed to create log file '%s': %s" % (filename, e)
                     self._janustrace_error = True
                 raise
             else:
                 self._janustrace_error = False
 
diff --git a/sylk/applications/webrtcgateway/websocket_logger.py b/sylk/applications/webrtcgateway/websocket_logger.py
index bc0e5c5..c3cbda0 100644
--- a/sylk/applications/webrtcgateway/websocket_logger.py
+++ b/sylk/applications/webrtcgateway/websocket_logger.py
@@ -1,95 +1,95 @@
 
 """
 Logging support for WebSocket traffic.
 """
 
 __all__ = ["Logger"]
 
 import os
 import sys
 
 from application.system import makedirs
 from sipsimple.configuration.settings import SIPSimpleSettings
 from sipsimple.threading import run_in_thread
 
 
 class Logger(object):
     def __init__(self):
         self.stopped = False
         self._wstrace_filename = None
         self._wstrace_file = None
         self._wstrace_error = False
         self._wstrace_start_time = None
         self._wstrace_packet_count = 0
 
         self._log_directory_error = False
 
     def start(self):
         # try to create the log directory
         try:
             self._init_log_directory()
             self._init_log_file()
         except Exception:
             pass
         self.stopped = False
 
     def stop(self):
         self.stopped = True
         if self._wstrace_file is not None:
             self._wstrace_file.close()
             self._wstrace_file = None
 
     def msg(self, direction, timestamp, packet):
         if self._wstrace_start_time is None:
             self._wstrace_start_time = timestamp
         self._wstrace_packet_count += 1
-        buf = ["%s: Packet %d, +%s" % (direction, self._wstrace_packet_count, (timestamp - self._wstrace_start_time))]
-        buf.append(packet)
-        buf.append('--')
+        buf = ("%s: Packet %d, +%s" % (direction, self._wstrace_packet_count, (timestamp - self._wstrace_start_time)),
+               packet,
+               '--')
         message = '\n'.join(buf)
         self._process_log((message, timestamp))
 
     @run_in_thread('log-io')
     def _process_log(self, record):
         if self.stopped:
             return
         message, timestamp = record
         try:
             self._init_log_file()
         except Exception:
             pass
         else:
             self._wstrace_file.write('%s [%s %d]: %s\n' % (timestamp, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._wstrace_file.flush()
 
     def _init_log_directory(self):
         settings = SIPSimpleSettings()
         log_directory = settings.logs.directory.normalized
         try:
             makedirs(log_directory)
         except Exception, e:
             if not self._log_directory_error:
                 print "failed to create logs directory '%s': %s" % (log_directory, e)
                 self._log_directory_error = True
             self._wstrace_error = True
             raise
         else:
             self._log_directory_error = False
             if self._wstrace_filename is None:
                 self._wstrace_filename = os.path.join(log_directory, 'webrtcgateway_trace.log')
                 self._wstrace_error = False
 
     def _init_log_file(self):
         if self._wstrace_file is None:
             self._init_log_directory()
             filename = self._wstrace_filename
             try:
                 self._wstrace_file = open(filename, 'a')
             except Exception, e:
                 if not self._wstrace_error:
                     print "failed to create log file '%s': %s" % (filename, e)
                     self._wstrace_error = True
                 raise
             else:
                 self._wstrace_error = False
 
diff --git a/sylk/applications/xmppgateway/xmpp/logger.py b/sylk/applications/xmppgateway/xmpp/logger.py
index 6e2f4d9..0aa656d 100644
--- a/sylk/applications/xmppgateway/xmpp/logger.py
+++ b/sylk/applications/xmppgateway/xmpp/logger.py
@@ -1,97 +1,97 @@
 
 """
 Logging support for XMPP traffic.
 """
 
 __all__ = ["Logger"]
 
 import os
 import sys
 
 from application.system import makedirs
 from sipsimple.configuration.settings import SIPSimpleSettings
 from sipsimple.threading import run_in_thread
 
 
 class Logger(object):
 
     def __init__(self):
         self.stopped = False
         self._xmpptrace_filename = None
         self._xmpptrace_file = None
         self._xmpptrace_error = False
         self._xmpptrace_start_time = None
         self._xmpptrace_packet_count = 0
 
         self._log_directory_error = False
 
     def start(self):
         # try to create the log directory
         try:
             self._init_log_directory()
             self._init_log_file()
         except Exception:
             pass
         self.stopped = False
 
     def stop(self):
         self.stopped = True
         if self._xmpptrace_file is not None:
             self._xmpptrace_file.close()
             self._xmpptrace_file = None
 
     def msg(self, direction, timestamp, packet):
         if self._xmpptrace_start_time is None:
             self._xmpptrace_start_time = timestamp
         self._xmpptrace_packet_count += 1
-        buf = ["%s: Packet %d, +%s" % (direction, self._xmpptrace_packet_count, (timestamp - self._xmpptrace_start_time))]
-        buf.append(packet)
-        buf.append('--')
+        buf = ("%s: Packet %d, +%s" % (direction, self._xmpptrace_packet_count, (timestamp - self._xmpptrace_start_time)),
+               packet,
+               '--')
         message = '\n'.join(buf)
         self._process_log((message, timestamp))
 
     @run_in_thread('log-io')
     def _process_log(self, record):
         if self.stopped:
             return
         message, timestamp = record
         try:
             self._init_log_file()
         except Exception:
             pass
         else:
             self._xmpptrace_file.write('%s [%s %d]: %s\n' % (timestamp, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._xmpptrace_file.flush()
 
     def _init_log_directory(self):
         settings = SIPSimpleSettings()
         log_directory = settings.logs.directory.normalized
         try:
             makedirs(log_directory)
         except Exception, e:
             if not self._log_directory_error:
                 print "failed to create logs directory '%s': %s" % (log_directory, e)
                 self._log_directory_error = True
             self._xmpptrace_error = True
             raise
         else:
             self._log_directory_error = False
             if self._xmpptrace_filename is None:
                 self._xmpptrace_filename = os.path.join(log_directory, 'xmpp_trace.log')
                 self._xmpptrace_error = False
 
     def _init_log_file(self):
         if self._xmpptrace_file is None:
             self._init_log_directory()
             filename = self._xmpptrace_filename
             try:
                 self._xmpptrace_file = open(filename, 'a')
             except Exception, e:
                 if not self._xmpptrace_error:
                     print "failed to create log file '%s': %s" % (filename, e)
                     self._xmpptrace_error = True
                 raise
             else:
                 self._xmpptrace_error = False
 
 
diff --git a/sylk/log.py b/sylk/log.py
index 9b222bb..7973cc6 100644
--- a/sylk/log.py
+++ b/sylk/log.py
@@ -1,295 +1,295 @@
 
 """
 Logging support adapted from SIP SIMPLE Client logger.
 """
 
 __all__ = ["Logger"]
 
 import datetime
 import os
 import sys
 
 from pprint import pformat
 
 from application import log
 from application.notification import IObserver, NotificationCenter
 from application.python import Null
 from application.system import makedirs
 from sipsimple.configuration.settings import SIPSimpleSettings
 from sipsimple.threading import run_in_thread
 from zope.interface import implements
 
 
 class Logger(object):
     implements(IObserver)
 
     # public methods
     #
 
     def __init__(self):
         self.stopped = False
         self.msrp_level = log.level.ERROR
 
         self._siptrace_filename = None
         self._siptrace_file = None
         self._siptrace_error = False
         self._siptrace_start_time = None
         self._siptrace_packet_count = 0
 
         self._msrptrace_filename = None
         self._msrptrace_file = None
         self._msrptrace_error = False
 
         self._pjsiptrace_filename = None
         self._pjsiptrace_file = None
         self._pjsiptrace_error = False
 
         self._notifications_filename = None
         self._notifications_file = None
         self._notifications_error = False
 
         self._log_directory_error = False
 
     def start(self):
         # try to create the log directory
         try:
             self._init_log_directory()
         except Exception:
             pass
 
         # register to receive log notifications
         NotificationCenter().add_observer(self)
         self.stopped = False
 
     def stop(self):
         NotificationCenter().remove_observer(self)
         self.stopped = False
         self._close_files()
 
     @run_in_thread('log-io')
     def _close_files(self):
         # close sip trace file
         if self._siptrace_file is not None:
             self._siptrace_file.close()
             self._siptrace_file = None
 
         # close msrp trace file
         if self._msrptrace_file is not None:
             self._msrptrace_file.close()
             self._msrptrace_file = None
 
         # close pjsip trace file
         if self._pjsiptrace_file is not None:
             self._pjsiptrace_file.close()
             self._pjsiptrace_file = None
 
         # close notifications trace file
         if self._notifications_file is not None:
             self._notifications_file.close()
             self._notifications_file = None
 
     def handle_notification(self, notification):
         if self.stopped:
             return
         self._process_notification(notification)
 
     @run_in_thread('log-io')
     def _process_notification(self, notification):
         settings = SIPSimpleSettings()
         handler = getattr(self, '_NH_%s' % notification.name, Null)
         handler(notification)
 
         handler = getattr(self, '_LH_%s' % notification.name, Null)
         handler(notification)
 
         if notification.name not in ('SIPEngineLog', 'SIPEngineSIPTrace') and settings.logs.trace_notifications:
             message = 'Notification name=%s sender=%s' % (notification.name, notification.sender)
             if notification.data is not None:
                 message += '\n%s' % pformat(notification.data.__dict__)
             if settings.logs.trace_notifications:
                 try:
                     self._init_log_file('notifications')
                 except Exception:
                     pass
                 else:
                     self._notifications_file.write('%s [%s %d]: %s\n' % (datetime.datetime.now(), os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
                     self._notifications_file.flush()
 
     # notification handlers
     #
 
     def _NH_CFGSettingsObjectDidChange(self, notification):
         settings = SIPSimpleSettings()
         if notification.sender is settings:
             if 'logs.directory' in notification.data.modified:
                 # sip trace
                 if self._siptrace_file is not None:
                     self._siptrace_file.close()
                     self._siptrace_file = None
                 # pjsip trace
                 if self._pjsiptrace_file is not None:
                     self._pjsiptrace_file.close()
                     self._pjsiptrace_file = None
                 # notifications trace
                 if self._notifications_file is not None:
                     self._notifications_file.close()
                     self._notifications_file = None
                 # try to create the log directory
                 try:
                     self._init_log_directory()
                 except Exception:
                     pass
 
     # log handlers
     #
 
     def _LH_SIPEngineSIPTrace(self, notification):
         settings = SIPSimpleSettings()
         if not settings.logs.trace_sip:
             return
         if self._siptrace_start_time is None:
             self._siptrace_start_time = notification.datetime
         self._siptrace_packet_count += 1
         if notification.data.received:
             direction = "RECEIVED"
         else:
             direction = "SENDING"
-        buf = ["%s: Packet %d, +%s" % (direction, self._siptrace_packet_count, (notification.datetime - self._siptrace_start_time))]
-        buf.append("%(source_ip)s:%(source_port)d -(SIP over %(transport)s)-> %(destination_ip)s:%(destination_port)d" % notification.data.__dict__)
-        buf.append(notification.data.data)
-        buf.append('--')
+        buf = ("%s: Packet %d, +%s" % (direction, self._siptrace_packet_count, (notification.datetime - self._siptrace_start_time)),
+               "%(source_ip)s:%(source_port)d -(SIP over %(transport)s)-> %(destination_ip)s:%(destination_port)d" % notification.data.__dict__,
+               notification.data.data,
+               '--')
         message = '\n'.join(buf)
         try:
             self._init_log_file('siptrace')
         except Exception:
             pass
         else:
             self._siptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._siptrace_file.flush()
 
     def _LH_SIPEngineLog(self, notification):
         settings = SIPSimpleSettings()
         if not settings.logs.trace_pjsip:
             return
         message = "(%(level)d) %(message)s" % notification.data.__dict__
         try:
             self._init_log_file('pjsiptrace')
         except Exception:
             pass
         else:
             self._pjsiptrace_file.write('%s [%s %d] %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._pjsiptrace_file.flush()
 
     def _LH_DNSLookupTrace(self, notification):
         settings = SIPSimpleSettings()
         if not settings.logs.trace_sip:
             return
         message = 'DNS lookup %(query_type)s %(query_name)s' % notification.data.__dict__
         if notification.data.error is None:
             message += ' succeeded, ttl=%d: ' % notification.data.answer.ttl
             if notification.data.query_type == 'A':
                 message += ", ".join(record.address for record in notification.data.answer)
             elif notification.data.query_type == 'SRV':
                 message += ", ".join('%d %d %d %s' % (record.priority, record.weight, record.port, record.target) for record in notification.data.answer)
             elif notification.data.query_type == 'NAPTR':
                 message += ", ".join('%d %d "%s" "%s" "%s" %s' % (record.order, record.preference, record.flags, record.service, record.regexp, record.replacement) for record in notification.data.answer)
         else:
             import dns.resolver
             message_map = {dns.resolver.NXDOMAIN: 'DNS record does not exist',
                            dns.resolver.NoAnswer: 'DNS response contains no answer',
                            dns.resolver.NoNameservers: 'no DNS name servers could be reached',
                            dns.resolver.Timeout: 'no DNS response received, the query has timed out'}
             message += ' failed: %s' % message_map.get(notification.data.error.__class__, '')
         try:
             self._init_log_file('siptrace')
         except Exception:
             pass
         else:
             self._siptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._siptrace_file.flush()
 
     def _LH_MSRPTransportTrace(self, notification):
         settings = SIPSimpleSettings()
         if not settings.logs.trace_msrp:
             return
         arrow = {'incoming': '<--', 'outgoing': '-->'}[notification.data.direction]
         local_address = notification.sender.getHost()
         local_address = '%s:%d' % (local_address.host, local_address.port)
         remote_address = notification.sender.getPeer()
         remote_address = '%s:%d' % (remote_address.host, remote_address.port)
         message = '%s %s %s\n' % (local_address, arrow, remote_address) + notification.data.data
         try:
             self._init_log_file('msrptrace')
         except Exception:
             pass
         else:
             self._msrptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._msrptrace_file.flush()
 
     def _LH_MSRPLibraryLog(self, notification):
         settings = SIPSimpleSettings()
         if not settings.logs.trace_msrp:
             return
         if notification.data.level < self.msrp_level:
             return
         message = '%s%s' % (notification.data.level.prefix, notification.data.message)
         try:
             self._init_log_file('msrptrace')
         except Exception:
             pass
         else:
             self._msrptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
             self._msrptrace_file.flush()
 
     # private methods
     #
 
     def _init_log_directory(self):
         settings = SIPSimpleSettings()
         log_directory = settings.logs.directory.normalized
         try:
             makedirs(log_directory)
         except Exception, e:
             if not self._log_directory_error:
                 print "failed to create logs directory '%s': %s" % (log_directory, e)
                 self._log_directory_error = True
             self._siptrace_error = True
             self._pjsiptrace_error = True
             self._notifications_error = True
             raise
         else:
             self._log_directory_error = False
             # sip trace
             if self._siptrace_filename is None:
                 self._siptrace_filename = os.path.join(log_directory, 'sip_trace.log')
                 self._siptrace_error = False
 
             # msrp trace
             if self._msrptrace_filename is None:
                 self._msrptrace_filename = os.path.join(log_directory, 'msrp_trace.log')
                 self._msrptrace_error = False
 
             # pjsip trace
             if self._pjsiptrace_filename is None:
                 self._pjsiptrace_filename = os.path.join(log_directory, 'core_trace.log')
                 self._pjsiptrace_error = False
 
             # notifications trace
             if self._notifications_filename is None:
                 self._notifications_filename = os.path.join(log_directory, 'notifications_trace.log')
                 self._notifications_error = False
 
     def _init_log_file(self, type):
         if getattr(self, '_%s_file' % type) is None:
             self._init_log_directory()
             filename = getattr(self, '_%s_filename' % type)
             try:
                 setattr(self, '_%s_file' % type, open(filename, 'a'))
             except Exception, e:
                 if not getattr(self, '_%s_error' % type):
                     print "failed to create log file '%s': %s" % (filename, e)
                     setattr(self, '_%s_error' % type, True)
                 raise
             else:
                 setattr(self, '_%s_error' % type, False)