I do struggle with the logging a bit. I'd like to roll over the logs after certain period of time and also after reaching certain size.

Rollover after a period of time is made by [`TimedRotatingFileHandler`](http://docs.python.org/library/logging.handlers.html#logging.handlers.TimedRotatingFileHandler),
and rollover after reaching certain log size is made by [`RotatingFileHandler`](http://docs.python.org/library/logging.handlers.html#rotatingfilehandler).

But the `TimedRotatingFileHandler` doesn't have the attribute `maxBytes` and the `RotatingFileHandler` can not rotate after a certain period of time.
I also tried to add both handlers to logger, but the result was doubled logging.

Do I miss something?

I also looked into source code of `logging.handlers`. I tried to subclass `TimedRotatingFileHandler` and override the method `shouldRollover()` to create a class with capabilities of both:

```
class EnhancedRotatingFileHandler(logging.handlers.TimedRotatingFileHandler):
    def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=0, utc=0, maxBytes=0):
        """ This is just a combination of TimedRotatingFileHandler and RotatingFileHandler (adds maxBytes to TimedRotatingFileHandler)  """
        # super(self). #It's old style class, so super doesn't work.
        logging.handlers.TimedRotatingFileHandler.__init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=0, utc=0)
        self.maxBytes=maxBytes

    def shouldRollover(self, record):
        """
        Determine if rollover should occur.

        Basically, see if the supplied record would cause the file to exceed
        the size limit we have.

        we are also comparing times        
        """
        if self.stream is None:                 # delay was set...
            self.stream = self._open()
        if self.maxBytes > 0:                   # are we rolling over?
            msg = "%s\n" % self.format(record)
            self.stream.seek(0, 2)  #due to non-posix-compliant Windows feature
            if self.stream.tell() + len(msg) >= self.maxBytes:
                return 1
        t = int(time.time())
        if t >= self.rolloverAt:
            return 1
        #print "No need to rollover: %d, %d" % (t, self.rolloverAt)
        return 0         

```

But like this the log creates one backup and the gets overwritten. Seems like I have to override also method `doRollover()` which is not so easy.

Any other idea how to create a logger which rolls the file over after certain time and also after certain size reached?