def calc_busload(single_test): messages = single_test.dbc.messages b11 = 47 b29 = 65 bitr = int(single_test.cnf['baudrate']) overhead = (b11 if single_test.cnf['id_size'] == 'Force 11 bits' else b29) auto_size = False if single_test.cnf['id_size'] == 'Auto': auto_size = True sum_message_load = 0.0 message_count = 0.0 bit_stuff = int(single_test.cnf['bit_stuffing']) / 100 output_list = [] output_not_used_list = [] output_ignored = [] message_time = 0 for message in messages: message_time = 0 message_load = 0 if message.name not in single_test.erase_message: if message.cycle > 0: ml = message.size if auto_size: overhead = (b11 if int(message.id) < 2100 else b29) message_time = ((ml * 8 + overhead) + ((ml * 8 + overhead - 13) * bit_stuff)) / bitr message_load = (message_time / message.cycle) sum_message_load += message_load message_count += 1 output_list.append( MessageOut(message.name, message.id, message.size, message.cycle, message_time, message_load)) event_log(output_list[-1]) else: output_not_used_list.append( MessageOut(message.name, message.id, message.size, message.cycle, message_time, message_load)) event_log(output_not_used_list[-1]) else: # eventLog("[-] message %s doesn't used in busload calc" % message.name) output_not_used_list.append( MessageOut(message.name, message.id, message.size, message.cycle, message_time, message_load)) event_log(output_not_used_list[-1]) result = Statistic(sum_message_load * 100, message_count, len(messages)) result_output = [output_list, output_not_used_list, result, output_ignored] event_log('---> busload: %0.6f' % sum_message_load, single_test) single_test.result = result_output
def __init__(self, config, module): self.config = config self.module = module self.handlers = None self.__setup_log(module) self.user_logger_enabled = False self.user_log_bytes = 0 self.header_params = None self.message_out = MessageOut(self.module, self.config) self.console_buffer = [] self.console_buffer_lock = threading.Lock() ## flush stdout to avoid out of order logging sys.stdout.flush()
def __init__(self, config, module): self.config = config self.module = module self.handlers = None self.log = None self.__setup_log(module) self.user_log_bytes = 0 self.message_out = MessageOut(self.module, self.config) ## flush stdout to avoid out of order logging sys.stdout.flush()
class AppLogger(object): logtype = { 'SYSTEM' : 10, 'USER' : 20, 'GLOBAL' : 30 } loglevel = { 'DEBUG': 10, 'INFO': 20, 'WARN': 30, 'ERROR': 40, 'CRITICAL': 50, } def __init__(self, config, module): self.config = config self.module = module self.handlers = None self.__setup_log(module) self.user_logger_enabled = False self.user_log_bytes = 0 self.header_params = None self.message_out = MessageOut(self.module, self.config) self.console_buffer = [] self.console_buffer_lock = threading.Lock() ## flush stdout to avoid out of order logging sys.stdout.flush() def init_user_logger(self, header_params): self.user_logger_enabled = True ## user params get published as-is in the message ## user params should be key-value pairs if type(header_params) is dict: self.header_params = header_params def debug(self, message, logtype=logtype['SYSTEM']): self.log.debug(message) if logtype == self.logtype['USER']: self.__publish_user_system_buffer(message, self.loglevel['DEBUG']) if logtype == self.logtype['SYSTEM']: self.__publish_system_buffer(message, self.loglevel['DEBUG']) def info(self, message, logtype=logtype['SYSTEM']): self.log.info(message) if logtype == self.logtype['USER']: self.__publish_user_system_buffer(message, self.loglevel['INFO']) if logtype == self.logtype['SYSTEM']: self.__publish_system_buffer(message, self.loglevel['INFO']) def warn(self, message, exc_info=None, logtype=logtype['SYSTEM']): self.log.warn(message, exc_info=exc_info) if logtype == self.logtype['USER']: self.__publish_user_system_buffer(message, self.loglevel['WARN']) if logtype == self.logtype['SYSTEM']: self.__publish_system_buffer(message, self.loglevel['WARN']) def error(self, message, exc_info=None, logtype=logtype['SYSTEM']): self.log.error(message, exc_info=exc_info) if logtype == self.logtype['USER']: self.__publish_user_system_buffer(message, self.loglevel['ERROR']) if logtype == self.logtype['SYSTEM']: self.__publish_system_buffer(message, self.loglevel['ERROR']) def critical(self, message, logtype=logtype['SYSTEM']): self.log.critical(message) if logtype == self.logtype['USER']: self.__publish_user_system_buffer( message, self.loglevel['CRITICAL']) if logtype == self.logtype['SYSTEM']: self.__publish_system_buffer(message, self.loglevel['CRITICAL']) def remove_handler(self, handler): self.log.removeHandler(handler) def __get_timestamp(self): return int(time.time() * 1000000) def __publish_system_buffer(self, message, level): if not self.config['SYSTEM_LOGGING_ENABLED']: ## DO NOT use self.log, it will cause recursion return def append_console_buffer(self, console_out): with self.console_buffer_lock: self.console_buffer.append(console_out) if len(self.console_buffer) > self.config['CONSOLE_BUFFER_LENGTH']: self.flush_console_buffer() def __publish_user_system_buffer(self, message, level): if not self.config['USER_SYSTEM_LOGGING_ENABLED']: return self.log.debug('Publishing logs: USER SYSTEM') system_output_line = { 'consoleSequenceNumber' : self.__get_timestamp(), 'output': message, } self.log.debug(system_output_line) user_system_message = { 'headers' : { 'type' : self.logtype['GLOBAL'], 'level' : level, 'step' : self.config['STEP_NAME'], 'messageDate': datetime.datetime.utcnow().isoformat(), }, 'updateSequenceNumber': self.__get_timestamp(), 'consoleLogBytes': sys.getsizeof(message), 'module': self.module, 'timestamp': self.__get_timestamp(), 'console': [system_output_line], } for header_param in self.header_params: user_system_message['headers'][header_param] = \ self.header_params[header_param] def flush_console_buffer(self): self.log.info('Flushing console buffer') if len(self.console_buffer) == 0: self.log.debug('No console output to flush') else: with self.console_buffer_lock: self.log.debug('Flushing {0} console logs'.format( len(self.console_buffer))) console_message = { 'headers' : { 'step' : self.config['STEP_NAME'], 'timestamp': self.__get_timestamp(), }, 'updateSequenceNumber': self.__get_timestamp(), 'consoleLogBytes': self.user_log_bytes, 'console' : self.console_buffer, } for header_param in self.header_params: console_message['headers'][header_param] = \ self.header_params[header_param] console_message['headers']['consoleType'] = 'build' self.message_out.console(console_message) del self.console_buffer self.console_buffer = [] def __setup_log(self, module_name): module_name = os.path.basename(module_name) module_name = module_name.split('.')[0] print 'Setting up logging for module : {0} \n'.format(module_name) logging.basicConfig(level=logging.INFO) project_root = self.config['HOME'] log_dir = (project_root + '/logs').replace('//', '/') if not os.path.exists(log_dir): os.makedirs(log_dir) logger_name = self.module log_file = self.__get_log_file_name(logger_name, 'log', log_dir) with open(log_file, 'a'): os.utime(log_file, None) log_module_name = '{0} - {1}'.format(logger_name, module_name) self.log = logging.getLogger(log_module_name) self.log.propagate = True self.log.setLevel(logging.DEBUG) #handler = logging.FileHandler(log_file) handler = logging.handlers.RotatingFileHandler( log_file, maxBytes=10000000, backupCount=2) handler.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) self.log.addHandler(handler) self.handlers = self.log.handlers self.log.info('Log Config Setup successful') def __get_log_file_name(self, name, ext, folder): new_name = '{0}/{1}.{2}'.format(folder, name, ext) return new_name def log_command_op(self, output): console_out = { 'consoleId': str(uuid.uuid4()), 'parentConsoleId': '', 'type': 'msg', 'message' : output, 'msgTimestamp': self.__get_timestamp(), 'completed' : True } self.console_buffer.append(console_out) def log_command_err(self, err): console_out = { 'consoleId': str(uuid.uuid4()), 'parentConsoleId': '', 'type': 'msg', 'message' : err, 'msgTimestamp': self.__get_timestamp(), 'completed' : False } self.console_buffer.append(console_out)