Ping Reporter

import threading, logging, time, locale

logging.TRACE = 5
logging.NOTICE = 15
logging.addLevelName(logging.TRACE, 'TRACE')
logging.addLevelName(logging.NOTICE, 'NOTICE')

def setup_log(name,level=logging.ERROR):
    log = logging.getLogger(name)
    setattr(log.__class__, 'notice', log_notice)
    setattr(log.__class__, 'trace', log_trace)
    log.setLevel(level)
    return log

def start_log(logger,stream=logging.NOTICE,logs=logging.TRACE):
    logger.setLevel(min(stream,logs))
    addStreamHandler(logger,stream)
    addFileHandler(logger,logs)

def addFileHandler(log,level=None):
    formatter = logging.Formatter('[%(levelname)-6s] '+'[%s]'%log.name+' %(message)s')
    handler = logging.FileHandler('pingfs.log')
    if level: handler.setLevel(level)
    handler.setFormatter(formatter)
    log.addHandler(handler)

def addStreamHandler(log,level=None):
    formatter = logging.Formatter('[%(levelname)s] %(message)s')
    handler = logging.StreamHandler()
    if level: handler.setLevel(level)
    handler.setFormatter(formatter)
    log.addHandler(handler)

def log_generic(self, level, msg, *args, **kwargs):
    if self.manager.disable >= level: return
    if level >= self.getEffectiveLevel():
        apply(self._log, (level,msg,args), kwargs)

def log_notice(self, msg, *args, **kwargs):
    log_generic(self,logging.NOTICE,msg,*args,**kwargs)

def log_trace(self, msg, *args, **kwargs):
    log_generic(self,logging.TRACE,msg,*args,**kwargs)

def enableAllLogs(screen=logging.INFO,logs=logging.TRACE):
    import ping_filesystem, ping_fuse
    import ping, ping_disk, ping_server
    #start_log(ping.log,          screen,logs)
    start_log(ping_server.log,    screen,logs)
    start_log(ping_disk.log,      screen,logs)
    start_log(ping_filesystem.log,screen,logs)
    start_log(ping_fuse.log,      screen,logs)

import ping
def humanize_bytes(bytes, precision=2):
    # by Doug Latornell
    # http://code.activestate.com/recipes/577081-humanized-representation-of-a-number-of-bytes/
    abbrevs = (
        (1<<50L, 'PB'),
        (1<<40L, 'TB'),
        (1<<30L, 'GB'),
        (1<<20L, 'MB'),
        (1<<10L, 'kB'),
        (1, 'bytes')
    )
    if bytes == 1: return '1 byte'
    for factor, suffix in abbrevs:
        if bytes >= factor: break
    return '%.*f %s' % (precision, float(bytes) / factor, suffix)

class PingReporter(threading.Thread):
    def __init__(self, log, server, interval=90):
        locale.setlocale(locale.LC_ALL,'')
        threading.Thread.__init__(self)
        self.interval = interval
        self.server = server
        self.running = 1
        self.log = log

    def stop(self):
        self.log.info('reporter terminated')
        self.running = 0
        self.stats()

    def run(self):
        self.start = time.time()
        self.log.info('reporter started at %s'%time.ctime())
        self.last_time = self.start
        self.last_data = 0
        while self.running:
            time.sleep(self.interval)
            self.stats()

    def stats(self):
        interval_time = time.time() - self.last_time
        interval_data = ping.ping_bandwidth - self.last_data
        bw = humanize_bytes(interval_data / interval_time)

        data = humanize_bytes(ping.ping_bandwidth)
        num = locale.format('%d', ping.ping_count, True)
        tstr = time.strftime('%H:%M:%S',time.gmtime(time.time()-self.start))
        self.log.info('%s (%s pings) -> %s elapsed (%s / second)'%(data,num,tstr,bw))

        self.last_data = ping.ping_bandwidth
        self.last_time = time.time()