Lines Matching refs:self
54 def __init__(self, filename, mode, encoding=None, delay=False, errors=None):
58 logging.FileHandler.__init__(self, filename, mode=mode,
61 self.mode = mode
62 self.encoding = encoding
63 self.errors = errors
65 def emit(self, record):
73 if self.shouldRollover(record):
74 self.doRollover()
75 logging.FileHandler.emit(self, record)
77 self.handleError(record)
79 def rotation_filename(self, default_name):
92 if not callable(self.namer):
95 result = self.namer(default_name)
98 def rotate(self, source, dest):
112 if not callable(self.rotator):
117 self.rotator(source, dest)
124 def __init__(self, filename, mode='a', maxBytes=0, backupCount=0,
155 BaseRotatingHandler.__init__(self, filename, mode, encoding=encoding,
157 self.maxBytes = maxBytes
158 self.backupCount = backupCount
160 def doRollover(self):
164 if self.stream:
165 self.stream.close()
166 self.stream = None
167 if self.backupCount > 0:
168 for i in range(self.backupCount - 1, 0, -1):
169 sfn = self.rotation_filename("%s.%d" % (self.baseFilename, i))
170 dfn = self.rotation_filename("%s.%d" % (self.baseFilename,
176 dfn = self.rotation_filename(self.baseFilename + ".1")
179 self.rotate(self.baseFilename, dfn)
180 if not self.delay:
181 self.stream = self._open()
183 def shouldRollover(self, record):
191 if os.path.exists(self.baseFilename) and not os.path.isfile(self.baseFilename):
193 if self.stream is None: # delay was set...
194 self.stream = self._open()
195 if self.maxBytes > 0: # are we rolling over?
196 msg = "%s\n" % self.format(record)
197 self.stream.seek(0, 2) #due to non-posix-compliant Windows feature
198 if self.stream.tell() + len(msg) >= self.maxBytes:
210 def __init__(self, filename, when='h', interval=1, backupCount=0,
214 BaseRotatingHandler.__init__(self, filename, 'a', encoding=encoding,
216 self.when = when.upper()
217 self.backupCount = backupCount
218 self.utc = utc
219 self.atTime = atTime
232 if self.when == 'S':
233 self.interval = 1 # one second
234 self.suffix = "%Y-%m-%d_%H-%M-%S"
235 self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$"
236 elif self.when == 'M':
237 self.interval = 60 # one minute
238 self.suffix = "%Y-%m-%d_%H-%M"
239 self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.\w+)?$"
240 elif self.when == 'H':
241 self.interval = 60 * 60 # one hour
242 self.suffix = "%Y-%m-%d_%H"
243 self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}(\.\w+)?$"
244 elif self.when == 'D' or self.when == 'MIDNIGHT':
245 self.interval = 60 * 60 * 24 # one day
246 self.suffix = "%Y-%m-%d"
247 self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
248 elif self.when.startswith('W'):
249 self.interval = 60 * 60 * 24 * 7 # one week
250 if len(self.when) != 2:
251 raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
252 if self.when[1] < '0' or self.when[1] > '6':
253 raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
254 self.dayOfWeek = int(self.when[1])
255 self.suffix = "%Y-%m-%d"
256 self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
258 raise ValueError("Invalid rollover interval specified: %s" % self.when)
260 self.extMatch = re.compile(self.extMatch, re.ASCII)
261 self.interval = self.interval * interval # multiply by units requested
263 # path object (see Issue #27493), but self.baseFilename will be a string
264 filename = self.baseFilename
269 self.rolloverAt = self.computeRollover(t)
271 def computeRollover(self, currentTime):
275 result = currentTime + self.interval
283 if self.when == 'MIDNIGHT' or self.when.startswith('W'):
285 if self.utc:
294 if self.atTime is None:
297 rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 +
298 self.atTime.second)
304 # self.rotateAt is 13:45 and it now 14:15), rotation is
324 if self.when.startswith('W'):
326 if day != self.dayOfWeek:
327 if day < self.dayOfWeek:
328 daysToWait = self.dayOfWeek - day
330 daysToWait = 6 - day + self.dayOfWeek + 1
332 if not self.utc:
344 def shouldRollover(self, record):
352 if t >= self.rolloverAt:
354 if os.path.exists(self.baseFilename) and not os.path.isfile(self.baseFilename):
357 self.rolloverAt = self.computeRollover(t)
363 def getFilesToDelete(self):
369 dirName, baseName = os.path.split(self.baseFilename)
377 if self.namer is None:
395 if self.extMatch.match(part):
398 if len(result) < self.backupCount:
402 result = result[:len(result) - self.backupCount]
405 def doRollover(self):
413 if self.stream:
414 self.stream.close()
415 self.stream = None
419 t = self.rolloverAt - self.interval
420 if self.utc:
431 dfn = self.rotation_filename(self.baseFilename + "." +
432 time.strftime(self.suffix, timeTuple))
435 self.rotate(self.baseFilename, dfn)
436 if self.backupCount > 0:
437 for s in self.getFilesToDelete():
439 if not self.delay:
440 self.stream = self._open()
441 newRolloverAt = self.computeRollover(currentTime)
443 newRolloverAt = newRolloverAt + self.interval
445 if (self.when == 'MIDNIGHT' or self.when.startswith('W')) and not self.utc:
453 self.rolloverAt = newRolloverAt
475 def __init__(self, filename, mode='a', encoding=None, delay=False,
479 logging.FileHandler.__init__(self, filename, mode=mode,
482 self.dev, self.ino = -1, -1
483 self._statstream()
485 def _statstream(self):
486 if self.stream:
487 sres = os.fstat(self.stream.fileno())
488 self.dev, self.ino = sres[ST_DEV], sres[ST_INO]
490 def reopenIfNeeded(self):
504 sres = os.stat(self.baseFilename)
508 if not sres or sres[ST_DEV] != self.dev or sres[ST_INO] != self.ino:
509 if self.stream is not None:
511 self.stream.flush()
512 self.stream.close()
513 self.stream = None # See Issue #21742: _open () might fail.
515 self.stream = self._open()
516 self._statstream()
518 def emit(self, record):
525 self.reopenIfNeeded()
526 logging.FileHandler.emit(self, record)
542 def __init__(self, host, port):
550 logging.Handler.__init__(self)
551 self.host = host
552 self.port = port
554 self.address = host
556 self.address = (host, port)
557 self.sock = None
558 self.closeOnError = False
559 self.retryTime = None
563 self.retryStart = 1.0
564 self.retryMax = 30.0
565 self.retryFactor = 2.0
567 def makeSocket(self, timeout=1):
572 if self.port is not None:
573 result = socket.create_connection(self.address, timeout=timeout)
578 result.connect(self.address)
584 def createSocket(self):
594 if self.retryTime is None:
597 attempt = (now >= self.retryTime)
600 self.sock = self.makeSocket()
601 self.retryTime = None # next time, no delay before trying
604 if self.retryTime is None:
605 self.retryPeriod = self.retryStart
607 self.retryPeriod = self.retryPeriod * self.retryFactor
608 if self.retryPeriod > self.retryMax:
609 self.retryPeriod = self.retryMax
610 self.retryTime = now + self.retryPeriod
612 def send(self, s):
619 if self.sock is None:
620 self.createSocket()
621 #self.sock can be None either because we haven't reached the retry
624 if self.sock:
626 self.sock.sendall(s)
628 self.sock.close()
629 self.sock = None # so we can call createSocket next time
631 def makePickle(self, record):
639 dummy = self.format(record)
653 def handleError(self, record):
661 if self.closeOnError and self.sock:
662 self.sock.close()
663 self.sock = None #try to reconnect next time
665 logging.Handler.handleError(self, record)
667 def emit(self, record):
677 s = self.makePickle(record)
678 self.send(s)
680 self.handleError(record)
682 def close(self):
686 self.acquire()
688 sock = self.sock
690 self.sock = None
692 logging.Handler.close(self)
694 self.release()
707 def __init__(self, host, port):
711 SocketHandler.__init__(self, host, port)
712 self.closeOnError = False
714 def makeSocket(self):
719 if self.port is None:
726 def send(self, s):
734 if self.sock is None:
735 self.createSocket()
736 self.sock.sendto(s, self.address)
848 def __init__(self, address=('localhost', SYSLOG_UDP_PORT),
861 logging.Handler.__init__(self)
863 self.address = address
864 self.facility = facility
865 self.socktype = socktype
866 self.socket = None
867 self.createSocket()
869 def _connect_unixsocket(self, address):
870 use_socktype = self.socktype
873 self.socket = socket.socket(socket.AF_UNIX, use_socktype)
875 self.socket.connect(address)
876 # it worked, so set self.socktype to the used type
877 self.socktype = use_socktype
879 self.socket.close()
880 if self.socktype is not None:
884 self.socket = socket.socket(socket.AF_UNIX, use_socktype)
886 self.socket.connect(address)
887 # it worked, so set self.socktype to the used type
888 self.socktype = use_socktype
890 self.socket.close()
893 def createSocket(self):
901 address = self.address
902 socktype = self.socktype
905 self.unixsocket = True
911 self._connect_unixsocket(address)
915 self.unixsocket = False
936 self.socket = sock
937 self.socktype = socktype
939 def encodePriority(self, facility, priority):
947 facility = self.facility_names[facility]
949 priority = self.priority_names[priority]
952 def close(self):
956 self.acquire()
958 sock = self.socket
960 self.socket = None
962 logging.Handler.close(self)
964 self.release()
966 def mapPriority(self, levelName):
974 return self.priority_map.get(levelName, "warning")
979 def emit(self, record):
987 msg = self.format(record)
988 if self.ident:
989 msg = self.ident + msg
990 if self.append_nul:
995 prio = '<%d>' % self.encodePriority(self.facility,
996 self.mapPriority(record.levelname))
1002 if not self.socket:
1003 self.createSocket()
1005 if self.unixsocket:
1007 self.socket.send(msg)
1009 self.socket.close()
1010 self._connect_unixsocket(self.address)
1011 self.socket.send(msg)
1012 elif self.socktype == socket.SOCK_DGRAM:
1013 self.socket.sendto(msg, self.address)
1015 self.socket.sendall(msg)
1017 self.handleError(record)
1023 def __init__(self, mailhost, fromaddr, toaddrs, subject,
1041 logging.Handler.__init__(self)
1043 self.mailhost, self.mailport = mailhost
1045 self.mailhost, self.mailport = mailhost, None
1047 self.username, self.password = credentials
1049 self.username = None
1050 self.fromaddr = fromaddr
1053 self.toaddrs = toaddrs
1054 self.subject = subject
1055 self.secure = secure
1056 self.timeout = timeout
1058 def getSubject(self, record):
1065 return self.subject
1067 def emit(self, record):
1078 port = self.mailport
1081 smtp = smtplib.SMTP(self.mailhost, port, timeout=self.timeout)
1083 msg['From'] = self.fromaddr
1084 msg['To'] = ','.join(self.toaddrs)
1085 msg['Subject'] = self.getSubject(record)
1087 msg.set_content(self.format(record))
1088 if self.username:
1089 if self.secure is not None:
1091 smtp.starttls(*self.secure)
1093 smtp.login(self.username, self.password)
1097 self.handleError(record)
1109 def __init__(self, appname, dllname=None, logtype="Application"):
1110 logging.Handler.__init__(self)
1113 self.appname = appname
1114 self._welu = win32evtlogutil
1116 dllname = os.path.split(self._welu.__file__)
1119 self.dllname = dllname
1120 self.logtype = logtype
1125 self._welu.AddSourceToRegistry(appname, dllname, logtype)
1131 self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
1132 self.typemap = {
1142 self._welu = None
1144 def getMessageID(self, record):
1154 def getEventCategory(self, record):
1163 def getEventType(self, record):
1174 return self.typemap.get(record.levelno, self.deftype)
1176 def emit(self, record):
1183 if self._welu:
1185 id = self.getMessageID(record)
1186 cat = self.getEventCategory(record)
1187 type = self.getEventType(record)
1188 msg = self.format(record)
1189 self._welu.ReportEvent(self.appname, id, cat, type, [msg])
1191 self.handleError(record)
1193 def close(self):
1203 #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
1204 logging.Handler.close(self)
1211 def __init__(self, host, url, method="GET", secure=False, credentials=None,
1217 logging.Handler.__init__(self)
1224 self.host = host
1225 self.url = url
1226 self.method = method
1227 self.secure = secure
1228 self.credentials = credentials
1229 self.context = context
1231 def mapLogRecord(self, record):
1239 def getConnection(self, host, secure):
1248 connection = http.client.HTTPSConnection(host, context=self.context)
1253 def emit(self, record):
1261 host = self.host
1262 h = self.getConnection(host, self.secure)
1263 url = self.url
1264 data = urllib.parse.urlencode(self.mapLogRecord(record))
1265 if self.method == "GET":
1271 h.putrequest(self.method, url)
1280 if self.method == "POST":
1284 if self.credentials:
1286 s = ('%s:%s' % self.credentials).encode('utf-8')
1290 if self.method == "POST":
1294 self.handleError(record)
1302 def __init__(self, capacity):
1306 logging.Handler.__init__(self)
1307 self.capacity = capacity
1308 self.buffer = []
1310 def shouldFlush(self, record):
1317 return (len(self.buffer) >= self.capacity)
1319 def emit(self, record):
1326 self.buffer.append(record)
1327 if self.shouldFlush(record):
1328 self.flush()
1330 def flush(self):
1336 self.acquire()
1338 self.buffer.clear()
1340 self.release()
1342 def close(self):
1349 self.flush()
1351 logging.Handler.close(self)
1359 def __init__(self, capacity, flushLevel=logging.ERROR, target=None,
1373 BufferingHandler.__init__(self, capacity)
1374 self.flushLevel = flushLevel
1375 self.target = target
1377 self.flushOnClose = flushOnClose
1379 def shouldFlush(self, record):
1383 return (len(self.buffer) >= self.capacity) or \
1384 (record.levelno >= self.flushLevel)
1386 def setTarget(self, target):
1390 self.acquire()
1392 self.target = target
1394 self.release()
1396 def flush(self):
1404 self.acquire()
1406 if self.target:
1407 for record in self.buffer:
1408 self.target.handle(record)
1409 self.buffer.clear()
1411 self.release()
1413 def close(self):
1419 if self.flushOnClose:
1420 self.flush()
1422 self.acquire()
1424 self.target = None
1425 BufferingHandler.close(self)
1427 self.release()
1441 def __init__(self, queue):
1445 logging.Handler.__init__(self)
1446 self.queue = queue
1448 def enqueue(self, record):
1456 self.queue.put_nowait(record)
1458 def prepare(self, record):
1480 msg = self.format(record)
1491 def emit(self, record):
1498 self.enqueue(self.prepare(record))
1500 self.handleError(record)
1511 def __init__(self, queue, *handlers, respect_handler_level=False):
1516 self.queue = queue
1517 self.handlers = handlers
1518 self._thread = None
1519 self.respect_handler_level = respect_handler_level
1521 def dequeue(self, block):
1528 return self.queue.get(block)
1530 def start(self):
1537 self._thread = t = threading.Thread(target=self._monitor)
1541 def prepare(self, record):
1551 def handle(self, record):
1558 record = self.prepare(record)
1559 for handler in self.handlers:
1560 if not self.respect_handler_level:
1567 def _monitor(self):
1575 q = self.queue
1579 record = self.dequeue(True)
1580 if record is self._sentinel:
1584 self.handle(record)
1590 def enqueue_sentinel(self):
1598 self.queue.put_nowait(self._sentinel)
1600 def stop(self):
1608 self.enqueue_sentinel()
1609 self._thread.join()
1610 self._thread = None