def parse_db_watchdog(root_path): flymeprint.debug('parsing db watchdog...') cachemanager.root_path = root_path db_event_log_files = cachemanager.get_db_event_log_files() if not db_event_log_files: flymeprint.warning('no db event log files found') return parse_event_log_for_wd_by_entries(db_event_log_files)
def append_to_merge_or_match(stateObj, state_obj_dict): key = stateObj.get_key() if key in state_obj_dict: flymeprint.debug('duplication for:' + key) state_obj_dict[key].matched_state_list.append(stateObj) else: state_obj_dict[key] = stateObj
def get_whole_trace_for_anr(content, packageName, matchedTime, anrTime, anr_in_time, root_path): if len(anrTime) == 0: return dict() if len(matchedTime) == 0: flymeprint.debug('parse data anr trace') return parse_data_anr(packageName, anrTime, anr_in_time, root_path) return flymeparser.get_whole_trace_final(matchedTime, content)
def repair_pid_if_needed(anrobj): pid = anrobj.pid repaired = False if pid is None or pid == '0': flymeprint.warning('pid:' + str(pid) + ', not valid, try to repair') anr_time = anrobj.time_and_filepath['anr_time'] if 'event_log_path' in anrobj.time_and_filepath: # find pid in event log content = cachemanager.get_am_anr_cache( anrobj.time_and_filepath['event_log_path']) # match = re.search( # '^\d{2}-\d{2} ' + anr_time + '.*?am_anr.*?\[\d+,(\d+),' # '' + anrobj.packageName, # content, re.M) pid = flymeparser.get_anr_pid_event_log(content, anr_time, anrobj.packageName) if pid and pid != '0': repaired = True else: repaired = False # if match: # pid = match.group(1) # if not pid or pid == '0': # repaired = False # else: # repaired = True # anrobj.pid = pid # else: # repaired = False if not repaired: trace_time = anrobj.time_and_filepath['trace_time'] if 'anr_trace_file_name' in anrobj.time_and_filepath: # find pid in data anr trace content = cachemanager.get_file_content( anrobj.time_and_filepath['anr_trace_file_name']) # repaired = flymeparser.fix_anr_obj_with_content(anrobj, # content) else: # find pid in dropbox trace content = anrobj.content pid = flymeparser.get_trace_pid(content, trace_time, anrobj.packageName) if pid: repaired = True anrobj.pid = pid else: repaired = False if not repaired: flymeprint.warning('repair pid failed') else: flymeprint.debug('repair pid successfully ---> pid:' + anrobj.pid)
def parse_swt(root_path): flymeprint.debug('try swt...') cachemanager.root_path = root_path res = dict() watchdog_raw_dict = parse_event_log_for_wd(root_path) if not watchdog_raw_dict: watchdog_raw_dict = parse_db_watchdog(root_path) if not watchdog_raw_dict: res['is_swt'] = False flymeprint.debug('no watchdog keyword found, not swt') return res res['is_swt'] = True flymeprint.debug('swt detected...') watchdog_formated_dict = parse_watchdog_raw_dict(watchdog_raw_dict) is_sf_hang = True for time_str in watchdog_formated_dict: if '__is_sf_hang__' not in watchdog_formated_dict[time_str] or not \ watchdog_formated_dict[time_str]['__is_sf_hang__']: is_sf_hang = False if not is_sf_hang: if not watchdog_formated_dict: flymeprint.error('parse_wachdog_raw_dict error') return res system_server_trace_time_dict = parse_data_anr_trace(root_path) if not system_server_trace_time_dict: system_server_trace_time_dict = parse_db_trace(root_path) if not system_server_trace_time_dict: flymeprint.error('no system_server trace time') return res elif len(system_server_trace_time_dict) <= 1: flymeprint.error( 'only one system_server trace found, not enough to analysis') return res matched_trace_time = get_matched_trace_time( watchdog_formated_dict, system_server_trace_time_dict, False) if not matched_trace_time: flymeprint.error('no matched time') return res pm_matched_trace_time = get_pm_matched_trace_time( system_server_trace_time_dict, watchdog_formated_dict) swtobj_dict = get_swtobj_dict(watchdog_formated_dict, matched_trace_time, pm_matched_trace_time) else: flymeprint.debug('sf hang...') swtobj_dict = get_swtobj_dict(watchdog_formated_dict, None, None) res['brief_trace'] = generate_report(swtobj_dict, root_path) return res
def parse_data_anr_entries(data_anr_entries): flymeprint.debug('parsing data anr trace...') if not data_anr_entries: flymeprint.error('no data anr files found') trace_time_dict = dict() for file_name in data_anr_entries: # fo = open(file_name, encoding='utf-8') # content = fo.read() # fo.close() content = cachemanager.get_file_content(file_name) if not content: continue # match = re.findall( # '^----- pid ' + '\d+' + ' at (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{ # 2}) ' # '-----\nCmd line: ' + 'system_server', # content, re.M) matched_list = flymeparser.get_trace_time_pid_for_wd(content) if not matched_list: continue for entry in matched_list: head = entry[0] pid = entry[1] time_str = entry[2] trace_time = datetime.strptime(time_str, '%Y-%m-%d %H:%M:%S') trace_time_dict[time_str] = { 'time_struct': trace_time, 'file_name': file_name, 'content': content, 'pid': pid, 'head': head } if len(trace_time_dict) == 0 and len(data_anr_entries) != 0: flymeprint.error('no system_server trace matches') return trace_time_dict
def parse_je(root_path, report_dir): flymeprint.debug('try je...') cachemanager.root_path = root_path res_dict = dict() index = 0 if cachemanager.mtk_db_only: res_dict['is_je'] = True flymeparser.clean_and_build_dir(report_dir) res_dict['brief_trace'] = dict() exp_main_files = cachemanager.get_db_exp_main_files() for file_name in exp_main_files: content = cachemanager.get_file_content(file_name) je_trace = flymeparser.get_je_db_trace(content) je = JE(je_trace, file_name) index += 1 je.generate_report(report_dir, 'je_' + str(index) + '.txt') res_dict['brief_trace'][file_name] = je.get_brief_trace() else: main_files = cachemanager.get_main_log_files() is_je = False time_list = list() for main_file in main_files: flymeprint.debug('parsing: ' + main_file) content = cachemanager.get_file_content(main_file) je_dict = flymeparser.parse_ss_je(content) if not je_dict: continue if je_dict['time'] in time_list: continue time_list.append(je_dict['time']) is_je = True flymeprint.debug('je detected...') flymeparser.clean_and_build_dir(report_dir) je = JE(je_dict['trace'], main_file) index += 1 je.generate_report(report_dir, 'je_' + str(index) + '.txt') # res_dict['brief_trace'][main_file] = je.get_brief_trace() break if not is_je: flymeprint.debug('not je...') res_dict['is_je'] = is_je return res_dict
def parse_excel(excel_fn, ouc_dest_dir): try: db = pymysql.connect(host='localhost', user='******', password='******', db='flyme_stability_1') table_name = 'pro7_urge_2' cursor = db.cursor() create_table_sql = 'create table if not exists ' + table_name + '(download_uri varchar(256) not null,zip_md5 varchar(40) not null,db_md5 varchar(40) not null,primary key(db_md5),db_dir varchar(1024),fdevice varchar(30),fpackage_name varchar(50),fflyme_ver varchar(80),index index_fpackage_name(fpackage_name),fimei varchar(50),index index_fimei(fimei),fos_version varchar(10),froot varchar(10),fcountry varchar(10),fnetwork varchar(10),fcrashtime varchar(40),fupload_time varchar(40),inside_id varchar(40),stat_date varchar(20), exception_class varchar(20), index index_exception_class(exception_class),subject varchar(512),index index_subject(subject),brief_trace varchar(512),index index_brief_trace(brief_trace),exception_log_time varchar(100))' flymeprint.debug('excuting create table sql:\n' + create_table_sql) cursor.execute(create_table_sql) db.commit() df = pandas.read_excel(excel_fn, sheetname=0) try: loop_count = 0 it = df.iterrows() while (True): entry_tuple = it.__next__() row = entry_tuple[1] flymeprint.debug('downloading ' + row[0]) zip_file_tuple = flymeparser.download_log(row[0], ouc_dest_dir) zip_file = zip_file_tuple[0] md5sum = zip_file_tuple[1] try: extract_log_to_db(cursor, table_name, row, zip_file, md5sum) db.commit() except Exception as ex: traceback.print_exc(file=sys.stdout) finally: cachemanager.free_cache() # loop_count += 1 # if loop_count == 10: # break except StopIteration as stop_ex: flymeprint.debug('parse excel done') # ouc_dest_dir = '/home/liucong/temp/ouc/1503385916.620414' except Exception as ex: traceback.print_exc(file=sys.stdout) finally: if not db: db.close()
def main(): start_time = datetime.datetime.now() if (len(sys.argv) != 3) and (len(sys.argv) != 4): flymeprint.error( 'invalid arguments! two or three parameter needed!\n--anr ' 'root_dir or ' '--android_reboot root_dir or --ouc_excel excel_filename [' 'dest_path]') return if os.path.isabs(sys.argv[0]): cdir = os.path.dirname(sys.argv[0]) os.chdir(cdir) else: cdir = os.path.dirname(os.path.join(os.getcwd(), sys.argv[0])) os.chdir(cdir) flymeprint.debug('current dir:' + cdir) root_path = sys.argv[2] flymeprint.debug('root dir:' + root_path) if sys.argv[1] == '--anr': anrmanager.start(root_path) elif sys.argv[1] == '--android_reboot': if swtmanager.start(root_path)['is_swt']: pass elif jemanager.start(root_path)['is_je']: pass elif nemanager.start(root_path)['is_ne']: pass else: flymeprint.warning('unkonwn reboot type...') elif sys.argv[1] == '--ouc_excel': if len(sys.argv) == 4: dest_dir = sys.argv[3] else: dest_dir = None oucmanager.start(sys.argv[2], dest_dir) else: flymeprint.error('use --anr or --android_reboot or --ouc_excel') return end_time = datetime.datetime.now() flymeprint.debug('Time took: ' + str((end_time - start_time).seconds) + ' seconds')
def extract_log_to_db(cursor, table_name, row, zip_file, zip_md5sum): # zip_list = os.listdir(dest_dir) # for zip_file in zip_list: # if os.path.isdir(os.path.join(dest_dir, zip_file)): # continue # fname = os.path.join(dest_dir, zip_file) fname = zip_file dname = fname + '_' zf = zipfile.ZipFile(fname, 'r') os.makedirs(dname, exist_ok=True) zf.extractall(dname) for root, dirs, files in os.walk(dname): for entry in dirs: if flymeparser.is_fname_match(entry, 'db\..*?dbg\.DEC'): flymeparser.clean_files(os.path.join(root, entry)) for entry in files: if flymeparser.is_fname_match(entry, 'db\..*dbg'): to_extract = os.path.join(root, entry) flymeparser.extract_db(to_extract) fd = open(to_extract, mode='rb') db_md5_sum = hashlib.md5(fd.read()).hexdigest() db_dir = os.path.join(root, entry + '.DEC') brief_trace_list = list() fd = open(os.path.join(db_dir, '__exp_main.txt'), encoding='utf-8') exp_main_content = fd.read() exception_class = flymeparser.get_exclass(exp_main_content) subject = flymeparser.get_sj(exp_main_content) exception_log_time = flymeparser.get_exlt(exp_main_content) if exception_class == 'SWT': flymeprint.debug('exception class:SWT') res_dict = swtmanager.start(root) if res_dict and res_dict['is_swt'] and res_dict[ 'brief_trace']: for i in res_dict['brief_trace']: if os.path.dirname(i) == db_dir: brief_trace_list.append( res_dict['brief_trace'][i]) elif exception_class == 'Java (JE)': flymeprint.debug('exception class:Java (JE)') res_dict = jemanager.start(root) if res_dict and res_dict['is_je'] and res_dict[ 'brief_trace']: brief_trace_list.append( res_dict['brief_trace'].popitem()[1]) elif exception_class == 'Native (NE)': flymeprint.debug('exception class:Native (NE)') res_dict = nemanager.start(root) if res_dict and res_dict['is_ne'] and res_dict[ 'brief_trace']: brief_trace_list.append( res_dict['brief_trace'].popitem()[1]) else: flymeprint.debug('exception class:' + exception_class + ',ignored...') reason = 'ignored exception class' brief_trace_list.append(reason) if not brief_trace_list: brief_trace_list.append('null brief trace') if os.path.exists(db_dir): for brief_trace in brief_trace_list: if not brief_trace: brief_trace = 'null brief trace' additional_dict = { 'db_dir': db_dir, 'zip_md5': zip_md5sum, 'db_md5': db_md5_sum, 'brief_trace': brief_trace.replace('\'', '\'\''), 'exception_class': exception_class, 'subject': subject, 'exception_log_time': exception_log_time } try: flymeparser.insert_to_database( cursor, table_name, row, additional_dict) except Exception as ex: if type(ex) is pymysql.err.IntegrityError: flymeprint.warning(ex) else: traceback.print_exc(file=sys.stdout) else: flymeprint.error('db dir not match with db file') fd.close()
def generate_report(self, dir): file = os.path.join(dir, self.time.replace(':', '_') + '_swt.txt') flymeparser.clean_files(file) # fd = open(file, 'a', encoding='utf-8') si = io.StringIO() si.write(self.file_name + '\n') si.write(self.event_log + '\n\n') ex_reason = '' ex_final_trace = '' ex_brief_trace = '' if self.is_sf_hang: ex_brief_trace = flymeparser.get_sf_hang_brief_trace( self.event_log) if ex_brief_trace is None: ex_brief_trace = 'null' ex_reason = 'sf hang' ex_final_trace = 'refer to trace file' else: self.handler_list.extend(self.monitor_list) has_dead_lock = False dead_lock_brief_trace = None dead_lock_message = None dead_lock_error_trace = None has_binder_full = False binder_full_brief_trace = None binder_full_message = None binder_full_error_trace = None has_hang = False hang_brief_trace = list() hang_message = list() hang_error_trace = list() has_unknown = False unknown_brief_trace = list() unknown_message = None unknown_error_trace = list() for checker in self.handler_list: checker.generate_report(si) si.write('\n') if checker.is_dead_lock: has_dead_lock = True dead_lock_message = checker.error_message dead_lock_error_trace = checker.error_trace dead_lock_brief_trace = checker.brief_trace break elif checker.is_binder_full: if has_binder_full: continue has_binder_full = True binder_full_message = checker.error_message binder_full_error_trace = checker.error_trace binder_full_brief_trace = checker.brief_trace elif checker.is_hang: has_hang = True if checker.brief_trace is None: continue if checker.brief_trace in hang_brief_trace and \ checker.error_message in hang_message and \ hang_brief_trace.index( checker.brief_trace) == \ hang_message.index( checker.error_message): flymeprint.debug('ignore duplication') continue hang_brief_trace.append(checker.brief_trace) if checker.error_trace is None: continue hang_error_trace.append(checker.error_trace) if checker.error_message is None: continue hang_message.append(checker.error_message) elif checker.is_unknown: has_unknown = True if checker.brief_trace is None: unknown_message = checker.error_message continue if checker.brief_trace in unknown_brief_trace: continue unknown_brief_trace.append(checker.brief_trace) unknown_error_trace.append(checker.error_trace) unknown_message = checker.error_message else: flymeprint.error( 'should not be in this case, check your code!!!') if has_dead_lock: ex_reason = dead_lock_message ex_final_trace = dead_lock_error_trace ex_brief_trace = dead_lock_brief_trace elif has_binder_full: ex_reason = binder_full_message ex_final_trace = binder_full_error_trace ex_brief_trace = binder_full_brief_trace elif has_hang: ex_reason = ', '.join(hang_message) ex_final_trace = '\n'.join(hang_error_trace) ex_brief_trace = '_'.join(hang_brief_trace) elif has_unknown: ex_reason = unknown_message ex_final_trace = '\n'.join(unknown_error_trace) ex_brief_trace = '_'.join(unknown_brief_trace) if ex_brief_trace: ex_brief_trace = ex_brief_trace.rstrip('_') else: ex_brief_trace = 'null' if ex_final_trace: ex_final_trace = ex_final_trace.rstrip('\n') else: ex_final_trace = 'null' if ex_reason: ex_reason = ex_reason.rstrip(',') else: ex_reason = 'null' self.ex_reason = ex_reason self.ex_brief_trace = ex_brief_trace self.ex_final_trace = ex_final_trace # for monitor in self.monitor_list: # monitor.generate_report(si) # si.write('\n') flymeprint.debug('exception reason:' + self.ex_reason) flymeprint.debug('exception brief trace:\n' + self.ex_brief_trace) fd = open(file, 'a', encoding='utf-8') flymeparser.write_exception_head(fd, self.ex_type, self.ex_reason, self.ex_final_trace, None) fd.write(si.getvalue().rstrip('\n')) fd.close() si.close() return self.ex_brief_trace
def parse_dropbox(root_path): cachemanager.root_path = root_path try: is_dir = os.path.isdir(root_path) if not is_dir: flymeprint.warning('invalid root dir:' + root_path) except Exception as ex: traceback.print_exc(file=sys.stdout) return # anranalyser anranalyser = os.path.join(root_path, '__anranalyser__') # extract extractall = os.path.join(anranalyser, 'extractall') # use main stack to merge content merge = os.path.join(anranalyser, 'merge') # report bug according to policy bug = os.path.join(anranalyser, 'bug') # undetermined entry which should by analysed manually undetermined = os.path.join(anranalyser, 'undetermined') # notbug directory notbug = os.path.join(anranalyser, 'notbug') if not flymeparser.clean_and_build_dir(extractall, merge, bug, undetermined, notbug): flymeprint.warning('can not cleanAndBuildDir') return state_obj_dict = dict() drop_box_entries = cachemanager.get_dropbox_files() if len(drop_box_entries) == 0: flymeprint.warning('no dropbox files found') data_anr_entries = cachemanager.get_data_anr_trace_files() if len(data_anr_entries) == 0: flymeprint.warning('no data anr files found') event_log_entries = cachemanager.get_event_log_files() if len(event_log_entries) == 0: flymeprint.warning('no event log files found') for dfile in drop_box_entries: entry = os.path.basename(dfile) flymeprint.debug('start process ---> ' + entry) dest_file = os.path.join(extractall, entry.rstrip('.gz')) file_content = cachemanager.get_file_content(dfile, dest_file) if file_content is None: flymeprint.error(dest_file + ' content empty') continue anrobj = parse_dfile(dfile, root_path) if not anrobj: continue anrobj.time_and_filepath['dropbox_file_name'] = dest_file if not is_a_valid_anr_obj(anrobj): flymeprint.error(entry + ' ---> incomplete information!!!') continue repair_pid_if_needed(anrobj) if anrobj.mainTrace["thread_state"] == 'Blocked': obj = Blocked(anrobj) elif anrobj.mainTrace["thread_state"] == 'Native': obj = Native(anrobj) elif anrobj.mainTrace["thread_state"] == 'Runnable': obj = Runnable(anrobj) elif anrobj.mainTrace["thread_state"] == 'Suspended': obj = Suspended(anrobj) elif anrobj.mainTrace["thread_state"] == 'TimedWaiting': obj = TimedWaiting(anrobj) elif anrobj.mainTrace["thread_state"] == 'Waiting': obj = Waiting(anrobj) elif anrobj.mainTrace["thread_state"] == 'WaitingForGcToComplete': obj = WaitingForGcToComplete(anrobj) elif anrobj.mainTrace["thread_state"] == 'WaitingPerformGc': obj = WaitingPerformingGc(anrobj) else: obj = Otherstate(anrobj) append_to_merge_or_match(obj, state_obj_dict) flymeprint.debug('end process ---> ' + entry) generate_report(state_obj_dict.values(), merge, bug, undetermined, notbug)
def get_matched_trace_time(watchdog_formated_dict, system_server_trace_time_dict, is_pm): flymeprint.debug('getting best-matched time...') if is_pm: middle_t = 300 pre_trunc = 600 else: middle_t = 30 pre_trunc = 120 later_trunc = 120 matched_time = dict() if len(system_server_trace_time_dict) < 2: flymeprint.error('system_server trace less than 2') return matched_time for watchdog_time_str in watchdog_formated_dict.keys(): pid = watchdog_formated_dict[watchdog_time_str]['pid'] ss_pid_matched_trace_dict = get_pid_matched_ss_trace_dict( pid, system_server_trace_time_dict) if not ss_pid_matched_trace_dict: flymeprint.warning('pid:' + pid + ' no trace') continue system_server_trace_time_list = ss_pid_matched_trace_dict.keys() best_previous_time_str = min(system_server_trace_time_list) best_previous_item = ss_pid_matched_trace_dict.pop( best_previous_time_str) best_previous_time_struct = best_previous_item['time_struct'] best_previous_time_count = best_previous_time_struct.timestamp() best_previous_file_name = best_previous_item['file_name'] best_previous_content = best_previous_item['content'] best_previou_time_head = best_previous_item['head'] if not system_server_trace_time_list: flymeprint.error('only one system trace found') continue best_later_time_str = max(system_server_trace_time_list) best_later_item = ss_pid_matched_trace_dict.pop(best_later_time_str) max_time_struct = best_later_time_struct = best_later_item[ 'time_struct'] best_later_time_count = best_later_time_struct.timestamp() best_later_file_name = best_later_item['file_name'] best_later_content = best_later_item['content'] best_later_time_head = best_later_item['head'] matched_time[watchdog_time_str] = dict() no_best_previous_time = True no_best_later_time = True no_best_time = True no_alternative_time = True new_time_struct = watchdog_formated_dict[watchdog_time_str][ 'time_struct'].replace(year=max_time_struct.year) watchdog_formated_dict[watchdog_time_str][ 'time_struct'] = new_time_struct new_time_count = new_time_struct.timestamp() if new_time_count > best_previous_time_count: no_alternative_time = False if new_time_count - best_previous_time_count >= middle_t: no_best_previous_time = False if new_time_count <= best_later_time_count: no_best_later_time = False if no_alternative_time: flymeprint.error('watchdog time and trace time not match ---> ' + watchdog_time_str) continue if no_best_previous_time: flymeprint.warning('no best previous time ---> ' + watchdog_time_str) if no_best_later_time: flymeprint.warning('no best later time ---> ' + watchdog_time_str) if (not no_best_previous_time) and (not no_best_later_time): no_best_time = False watchdog_time_struct = watchdog_formated_dict[watchdog_time_str][ 'time_struct'] watchdog_time_count = watchdog_time_struct.timestamp() for system_server_time_str in ss_pid_matched_trace_dict.keys(): system_server_trace_time_struct = ss_pid_matched_trace_dict[ system_server_time_str]['time_struct'] system_server_time_count = \ system_server_trace_time_struct.timestamp() current_time_interval = watchdog_time_count - \ system_server_time_count previous_time_interval = watchdog_time_count - \ best_previous_time_count later_time_interval = watchdog_time_count - best_later_time_count current_file_name = \ ss_pid_matched_trace_dict[system_server_time_str][ 'file_name'] current_content = \ ss_pid_matched_trace_dict[system_server_time_str]['content'] current_head = ss_pid_matched_trace_dict[system_server_time_str][ 'head'] if no_best_time: change_best_previous = False change_best_later = False if no_best_previous_time: if (current_time_interval > 0) and ( previous_time_interval < current_time_interval): change_best_previous = True else: if (current_time_interval - middle_t >= 0) and ( previous_time_interval > current_time_interval): change_best_previous = True if change_best_previous: best_previous_time_str = system_server_time_str best_previous_time_count = system_server_time_count best_previous_file_name = current_file_name best_previous_content = current_content best_previous_time_struct = system_server_trace_time_struct best_previou_time_head = current_head if no_best_later_time: if current_time_interval < later_time_interval: change_best_later = True else: if (current_time_interval <= 0) and ( current_time_interval > later_time_interval): change_best_later = True if change_best_later: best_later_time_str = system_server_time_str best_later_time_count = system_server_time_count best_later_file_name = current_file_name best_later_content = current_content best_later_time_struct = system_server_trace_time_struct best_later_time_head = current_head else: if (current_time_interval - middle_t >= 0) and ( current_time_interval < previous_time_interval): best_previous_time_str = system_server_time_str best_previous_time_count = system_server_time_count best_previous_file_name = current_file_name best_previous_content = current_content best_previous_time_struct = system_server_trace_time_struct best_previou_time_head = current_head if (current_time_interval <= 0) and (current_time_interval > later_time_interval): best_later_time_str = system_server_time_str best_later_time_count = system_server_time_count best_later_file_name = current_file_name best_later_content = current_content best_later_time_struct = system_server_trace_time_struct best_later_time_head = current_head if no_best_time: matched_time[watchdog_time_str][ 'best_alternative_previous_time_str'] = best_previous_time_str matched_time[watchdog_time_str][ 'best_alternative_later_time_str'] = best_later_time_str matched_time[watchdog_time_str][ 'best_alternative_previous_time_struct'] = \ best_previous_time_struct matched_time[watchdog_time_str][ 'best_alternative_later_time_struct'] = \ best_later_time_struct matched_time[watchdog_time_str][ 'best_alternative_previous_head'] = best_previou_time_head matched_time[watchdog_time_str][ 'best_alternative_later_head'] = best_later_time_head else: matched_time[watchdog_time_str][ 'best_previous_time_str'] = best_previous_time_str matched_time[watchdog_time_str][ 'best_later_time_str'] = best_later_time_str matched_time[watchdog_time_str][ 'best_previous_time_struct'] = best_previous_time_struct matched_time[watchdog_time_str][ 'best_later_time_struct'] = best_later_time_struct matched_time[watchdog_time_str][ 'best_previous_head'] = best_previou_time_head matched_time[watchdog_time_str][ 'best_later_head'] = best_later_time_head current_prev_trunc = watchdog_time_struct.timestamp() - \ best_previous_time_struct.timestamp() current_later_trunc = best_later_time_struct.timestamp() - \ watchdog_time_struct.timestamp() is_previous_valid = True is_later_valid = True p_ivalid_reason = None l_ivalid_reason = None if current_prev_trunc > pre_trunc: p_ivalid_reason = 'trace is ' + str( int(current_prev_trunc)) + 's long to ' \ 'watchdog ' \ 'time,' \ 'no need to ' \ 'print' is_previous_valid = False if current_later_trunc > later_trunc: is_later_valid = False l_ivalid_reason = 'trace is ' + str( int(current_later_trunc)) + 's long ' \ 'after ' \ '' \ '' \ 'watchdog ' \ 'time,' \ 'no need ' \ 'to print' matched_time[watchdog_time_str][ 'previous_file_name'] = best_previous_file_name matched_time[watchdog_time_str][ 'previous_content'] = best_previous_content matched_time[watchdog_time_str][ 'is_previous_valid'] = is_previous_valid matched_time[watchdog_time_str][ 'later_file_name'] = best_later_file_name matched_time[watchdog_time_str]['later_content'] = best_later_content matched_time[watchdog_time_str]['is_later_valid'] = is_later_valid matched_time[watchdog_time_str]['p_i_r'] = p_ivalid_reason matched_time[watchdog_time_str]['l_i_r'] = l_ivalid_reason return matched_time
def parse_db_trace(root_path): flymeprint.debug('parsing db trace...') trace_files = cachemanager.get_db_trace_files() return parse_data_anr_entries(trace_files)
def parse_watchdog_raw_dict(watchdog_lists): watchdog_formated_dict = dict() for file_name in watchdog_lists.keys(): max_time_str = None prev_content = None for content in watchdog_lists[file_name]: time_str = flymeparser.get_watchdog_time_event_log(content) if max_time_str is None: max_time_str = time_str prev_content = content elif time_str > max_time_str: max_time_str = time_str watchdog_lists[file_name].remove(prev_content) prev_content = content for content in watchdog_lists[file_name]: # matched_list = re.search('(^\d{2}-\d{2} (\d{2}):(\d{2}):(\d{ # 2}))\.(\d{ # 3})', # content, re.M) # if not matched_list: # continue # flymeparser.get_anr_time_event_log() # time_str = matched_list.group(1) time_str = flymeparser.get_watchdog_time_event_log(content) watchdog_ss_pid = flymeparser.get_wd_ss_pid(content) if not time_str: continue if time_str in watchdog_formated_dict: continue watchdog_formated_dict[time_str] = dict() watchdog_formated_dict[time_str]['checker_list'] = list() watchdog_formated_dict[time_str]['file_name'] = file_name watchdog_formated_dict[time_str]['event_log'] = content time_struct = datetime.strptime(time_str, '%m-%d %H:%M:%S') watchdog_formated_dict[time_str]['time_struct'] = time_struct watchdog_formated_dict[time_str]['pid'] = watchdog_ss_pid # matched_list = re.findall( # '(Blocked in handler on (?P<handler_name>.*?) \((' # '?P<thread_name>.*?)\))', # content) if flymeparser.is_sf_hang(content): watchdog_formated_dict[time_str]['__is_sf_hang__'] = True continue watchdog_formated_dict[time_str]['__is_sf_hang__'] = False matched_list = flymeparser.get_watchdog_hlist_event_log(content) if matched_list: for i in matched_list: watchdog_formated_dict[time_str]['checker_list'].append({ 'checker_type': 'handler', 'event_log': i[0], 'checker_name': i[1], 'thread_name': i[2] }) # matched_list = re.findall( # '(Blocked in monitor (?P<class_name>.*?) on (' # '?P<checker_name>.*?) ' # '\((?P<thread_name>.*?)\))', # content) matched_list = flymeparser.get_watchdog_mlist_event_log(content) if matched_list: for i in matched_list: watchdog_formated_dict[time_str]['checker_list'].append({ 'checker_type': 'monitor', 'event_log': i[0], 'checker_class_name': i[1], 'checker_name': i[2], 'thread_name': i[3] }) if len(watchdog_formated_dict) == 0: flymeprint.debug('no watchdog found in event log') return watchdog_formated_dict
def parse_event_log_for_wd(root_path): flymeprint.debug('parsing event log...') event_log_entries = cachemanager.get_event_log_files() if not event_log_entries: flymeprint.warning('no event log files found') return parse_event_log_for_wd_by_entries(event_log_entries)