def emmit(self, event): if event.get("isDebug", False) and is_production(): return # Don't log debug messages in production. location, prefix, log_time, log_time_str, entry_text = self.parse_from(event) folder, name = build_file(self.folder, location, self.extension) try: log = LogFile(name, folder) log.write("%s %s\n\t%s\n" % (prefix, log_time_str, entry_text.replace("\n", "\n\t\t"))) log.flush() log.close() finally: if event.get("transmit", False) and not event.get("isDebug", False): self.service.write_entry(location, log_time, entry_text)
class JunebugLoggerService(Service): '''Service for :class:`junebug.logging.JunebugLogObserver`''' log_observer = None def __init__(self, worker_id, path, rotate, max_files, logger=None): ''' Create the service for the Junebug Log Observer. :param str worker_id: ID of the worker to observe logs for. :param str path: Path to place the log files. :param int rotate: Size (in bytes) before rotating log file. :param int max_files: Maximum amount of log files before old log files start to get deleted. :param logger: logger to add observer to. Defaults to twisted.python.log.theLogPublisher :type logger: :class:`twisted.python.log.LogPublisher` ''' self.setName('Junebug Worker Logger') self.logger = logger if logger is not None else log.theLogPublisher self.worker_id = worker_id self.path = path self.rotate = rotate self.max_files = max_files def startService(self): if not os.path.exists(self.path): os.makedirs(self.path, 0755) self.logfile = LogFile( self.worker_id, self.path, rotateLength=self.rotate, maxRotatedFiles=self.max_files) self.log_observer = JunebugLogObserver(self.logfile, self.worker_id) self.logger.addObserver(self.log_observer) return super(JunebugLoggerService, self).startService() def stopService(self): if self.running: self.logger.removeObserver(self.log_observer) self.logfile.close() return super(JunebugLoggerService, self).stopService() def registered(self): return self.log_observer in self.logger.observers
def receive_logs(self, logs, transport): client_mac = self.__stations[transport.client].mac; client_mac = client_mac.translate(None, ":|/\\") files = {} for time, location, msg in logs: if location in files: log_file = files[location] else: loc = [client_mac] + list(location) folder, name = build_file(self.__output_folder, loc, self.__extension) log_file = LogFile(name, folder) files[location] = log_file log_time_str = strftime("%Y-%m-%d %H:%M:%S:%f", gmtime(time)) log_file.write(">%s\n\t%s\n" % (log_time_str, msg.replace("\n", "\n\t\t"))) # Now close those files for log_file in files.itervalues(): log_file.flush() log_file.close() return {"accepted": True}
class LocalProcess(protocol.ProcessProtocol): def __init__(self, name,group): self.orgName = name self.name = "".join([x for x in name if x.isalnum()]) self.group = group self.logFile = LogFile(self.name+".log",group.groupDir,rotateLength=100000000,maxRotatedFiles=10)#10M self.updateLogFile = LogFile(self.name+".ulog",group.groupDir,rotateLength=100000000,maxRotatedFiles=5) self.ssLogFile = LogFile(self.name+".slog",group.groupDir,rotateLength=100000000,maxRotatedFiles=5) self.status = PROC_STATUS.STOP self.endTime = None self.startMemo = '' def connectionMade(self): self.status = PROC_STATUS.RUN#todo add support startCompletion check self._ssLog("startTime",datetime.now().strftime(TIME_FORMAT),self.startMemo) self.startMemo = '' global sendStatusFunc if sendStatusFunc: sendStatusFunc(self.group.name,self.orgName,self.status) def _writeLog(self,data): self.logFile.write("%s%s"%(data,CR)) def _ssLog(self,stage,time,memo=''): self.ssLogFile.write("%s%s%s%s%s%s"%(stage,SEP,time,SEP,memo,CR)) def logUpdate(self,fname): _updateLog(self.updateLogFile,fname) def outReceived(self, data): self._writeLog(data) def errReceived(self, data): self._writeLog("[ERROR DATA %s]:%s"%(datetime.now().strftime(TIME_FORMAT),data)) def childDataReceived(self, childFD, data): self._writeLog(data) def inConnectionLost(self): pass def outConnectionLost(self): pass def errConnectionLost(self): pass def childConnectionLost(self, childFD): pass def isRunning(self): return self.status == PROC_STATUS.RUN def processExited(self,reason): pass def processEnded(self,reason): self.endTime = datetime.now() if reason.value.exitCode is None: self._ssLog("endInfo","code is None,info:%s"% (reason)) elif reason.value.exitCode != 0 : self._ssLog("endInfo", "code:%d,info:%s"%(reason.value.exitCode,reason)) self.status = PROC_STATUS.STOP self._ssLog("endTime",self.endTime.strftime(TIME_FORMAT)) global sendStatusFunc if sendStatusFunc: sendStatusFunc(self.group.name,self.orgName,self.status) self.logFile.close() self.updateLogFile.close() self.ssLogFile.close() def signal(self,signalName): self.transport.signalProcess(signalName.name)