ConsoleLogger.py
class SocketLogger( threading.Thread ):
    def __init__( self, clogger ):
        self.clogger = clogger
        self.socketname = self.clogger.socketname

        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        try:
            os.remove(self.socketname)
        except OSError:
            pass
        self.sock.bind(self.socketname)

        threading.Thread.__init__ ( self )
        self.setDaemon ( True )

    def run ( self ):
        self.sock.listen(1)
        while 1:
            rate = self.clogger.rate if (not self.clogger.miner.idle) else 0
            type = " [" + str(self.clogger.connectionType) + "]" if self.clogger.connectionType is not None else ''
            status = (
                "[" + formatNumber(rate) + "hash/sec] "
                "[" + str(self.clogger.accepted) + " Accepted] "
                "[" + str(self.clogger.invalid) + " Rejected]" + type)
            conn, addr = self.sock.accept()
            conn.send(status)
            conn.close()



class ConsoleLogger(object):
    """This class will handle printing messages to the console."""

    TIME_FORMAT = '[%d/%m/%Y %H:%M:%S]'

    UPDATE_TIME = 1.0

    def __init__(self, miner, socketname, verbose=False):
        self.verbose = verbose
        self.miner = miner
        self.lastUpdate = time() - 1
        self.lastUpdateWrite = time() - 1
        self.rate = 0
        self.accepted = 0
        self.invalid = 0
        self.lineLength = 0
        self.connectionType = None
        self.socketname = socketname
        SocketLogger (self).start()


phoenix.py:
class CommandLineOptions(object):
    """Implements the Options interface for user-specified command-line
    arguments.
    """

    def __init__(self):
        self.parsedSettings = None
        self.url = None

        self.logger = None
        self.connection = None
        self.kernel = None
        self.queue = None
        self.socketname = None

        self.kernelOptions = {}

        self._parse()

    def _parse(self):
        parser = OptionParser(usage="%prog -u URL [-k kernel] [kernel params]")
        parser.add_option("-v", "--verbose", action="store_true",
            dest="verbose", default=False, help="show debug messages")
        parser.add_option("-k", "--kernel", dest="kernel", default="poclbm",
            help="the name of the kernel to use")
        parser.add_option("-u", "--url", dest="url", default=None,
            help="the URL of the mining server to work for [REQUIRED]")
        parser.add_option("-s", "--socketname", dest="socketname", default=None,
            help="Full path to file for outputting current status.")
        parser.add_option("-q", "--queuesize", dest="queuesize", type="int",
            default=1, help="how many work units to keep queued at all times")
        parser.add_option("-a", "--avgsamples", dest="avgsamples", type="int",
            default=10,
            help="how many samples to use for hashrate average")

        self.parsedSettings, args = parser.parse_args()

        if self.parsedSettings.url is None:
            parser.print_usage()
            exit()
        else:
            self.url = self.parsedSettings.url

        for arg in args:
            self._kernelOption(arg)

    def getQueueSize(self):
        return self.parsedSettings.queuesize
    def getAvgSamples(self):
        return self.parsedSettings.avgsamples

    def _kernelOption(self, arg):
        pair = arg.split('=',1)
        if len(pair) < 2:
            pair.append(None)
        var, value = tuple(pair)
        self.kernelOptions[var.upper()] = value

    def makeLogger(self, requester, miner):
        if not self.logger:
            self.logger = ConsoleLogger(miner, self.parsedSettings.socketname, self.parsedSettings.verbose)
        return self.logger