בניית אוטומציה לדו"ח תאונה עבור iOS ו- Android

שלום, אני ויליאן Iaumbaev! לאחרונה נבנה מערכת שמטופלת באופן אוטומטי דיווחים על תאונות חדשות עבור iOS ו- Android - זה עושה מעקב ותיקון בעיות הרבה יותר קל. למה עשינו את זה. הקצאת התרסקות ידנית למפתחים הנכונים הפכה במהירות למשימה משעממת ולא אמין.זה היה קל לשכוח משהו, להתעלם מקרים קצה, או לעקוף את הבעיות המורכבות.רצינו להפוך את התהליך יותר צפוי ושיטתי - כך שאף אחד בקבוצה לא היה צריך לבזבז זמן בדיקת התרסקות, ואין בעיה קריטית תיפול דרך התפרצויות. סיכום כדי להתחיל, תזדקקו לכלים של Google כמו: , וגם את ג'ירה Crashlytics פלטפורמת Google Cloud Crashlytics פלטפורמת Google Cloud לאחר שהפרויקטים שלך מוגדרים בשירותים של Google, הגדר את העברת הנתונים מ- Crashlytics ל- GCP באמצעות לאחר מכן, כל דוחות התרסקות יופיעו בטבלאות BigQuery. דף אינטגרציה דף אינטגרציה המבנים של נתוני התרסקות עבור iOS ו- Android הם כמעט זהים, עם רק כמה הבדלים קטנים - מה שאומר שאנחנו יכולים להשתמש בסקריפט אחד כדי לעבד את שניהם. אז עכשיו יש לך את ההתרסקות שלך ב- BigQuery מה שאומר שאתה יכול לבצע קצת עבודה על נתונים אלה. ראשית, אנחנו צריכים לקבל את כל נתוני התרסקות לנתח, אבל אם יש לך כמות גדולה של נתונים על יותר ממיליון משתמשים, עדיף לעיבוד מראש את כל הנתונים בצד של Google, לעשות כמה ציטוטים. תוכנית למד כמה SQL בסיסיים כדי לקבל נתוני התרסקות מ- BigQuery Query Crash נתונים באמצעות Python להוריד את כל הקומטרים מהתיקייה ולשלב את העותקים מפה כל בעיה קובץ repo ואת הבעלים שלה יצירת משימה Jira עבור בעל הקובץ, אם משימה עדיין לא קיימת למד כמה יסודות SQL כדי לקבל נתונים מ- BigQuery BigQuery משתמשת בשפה SQL משלה, אשר דומה ל- SQL סטנדרטי, אך מציעה נוחות נוספת לניתוח נתונים. לצורך האינטגרציה שלנו, היינו צריכים לעבוד עם קבוצת הנתונים של התרסקות המלאה, אך בצורה מצטברת.במיוחד, קבוצנו דוחות התרסקות בודדים לחתימות התרסקות ולאחר מכן מצטברים נתונים רלוונטיים בתוך כל קבוצה - כגון מספר התרחשות, מספר משתמשים מושפע, פירוק גרסה ועוד. https://console.cloud.google.com/bigquery https://console.cloud.google.com/bigquery WITH pre as( SELECT issue_id, ARRAY_AGG(DISTINCT issue_title IGNORE NULLS) as issue_titles, ARRAY_AGG(DISTINCT blame_frame.file IGNORE NULLS) as blame_files, ARRAY_AGG(DISTINCT blame_frame.library IGNORE NULLS) as blame_libraries, ARRAY_AGG(DISTINCT blame_frame.symbol IGNORE NULLS) as blame_symbols, COUNT(DISTINCT event_id) as total_events, COUNT(DISTINCT installation_uuid) as total_users, '{"version":"' || application.display_version || '","events":' || COUNT(DISTINCT event_id) || ',"users":' || COUNT(DISTINCT installation_uuid) || '}' AS events_info FROM `YOUR TABLE NAME` WHERE 1=1 AND event_timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 24 HOUR) AND event_timestamp < CURRENT_TIMESTAMP() AND error_type = "FATAL" GROUP BY issue_id, application.display_version ) SELECT issue_id, ARRAY_CONCAT_AGG(issue_titles) as issue_titles, ARRAY_CONCAT_AGG(blame_files) as blame_files, ARRAY_CONCAT_AGG(blame_libraries) as blame_libraries, ARRAY_CONCAT_AGG(blame_symbols) as blame_symbols, SUM(total_events) as total_events, SUM(total_users) as total_users, '[' || STRING_AGG(events_info, ",") || ']' as events_info FROM pre WHERE 1=1 AND issue_id IS NOT NULL AND events_info IS NOT NULL GROUP BY issue_id ORDER BY total_users DESC כתוצאה מכך, תקבל שורה אחת לכל issue_id ייחודי, יחד עם השדות המצטברים הבאים: issue_titles — רשימה של כל כותרות התרסקות. זוהי רשימה כדי לקחת בחשבון מקרים שבהם קיימים כותרות ייחודיות מרובות עבור אותה בעיה. blame_files — רשימה של קבצי stacktrace העליונים האשמים על התרסקות.זה לא יהיה ריק אם התרסקות אירעה בסיס הקוד שלך (במקום בספריות המערכת). blame_libraries – רשימה של ספריות הקשורות לתאונה.זהו גם מסדר, שנבנה מסיבות דומות ל- issue_titles. blame_symbols – רשימה של סמלים קודים (פונקציות/שיטות) שבהם התרחשה התנגשות. total_events – מספר התאונות המתרחשות במהלך התקופה שנבחרה. total_users – מספר המשתמשים הייחודיים שהושפעו.לפעמים התנגשות עשויה להתרחש רק עבור קבוצה מסוימת של משתמשים. events_info – ערכת JSON (כסדר) המכילה total_events ו- total_users מחולקים לפי גרסה של האפליקציה. [ { "version": "1.0.1", "events": 131, "users": 110 }, { "version": "1.2.1", "events": 489, "users": 426 } ] בקשה להתמוטט נתונים מ BigQuery באמצעות Python כדי להתחיל, להתקין את ספריית הלקוח BigQuery Python מ לאחר ההתקנה, ליצור קובץ BigQueryExecutor.py – מודול זה יטפל בכל התקשורת עם Google Cloud BigQuery. פיפי פיפי import os import json import tempfile from google.oauth2 import service_account from google.cloud import bigquery from collections import Counter class BigQueryExecutor: def __init__(self, credentialsJson: str, bqProjectId: str = ''): temp_file_path='' with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file: json.dump(json.loads(credentialsJson), temp_file, indent=4) temp_file_path = temp_file.name credentials = service_account.Credentials.from_service_account_file(temp_file_path) os.remove(temp_file_path) self.client = bigquery.Client(project=bqProjectId, credentials=credentials) כדי להתחיל להשתמש בתסריט, תצטרך רק שני דברים: חשבונית שירות Google JSON Credentials File שם (או מזהה) של הפרויקט BigQuery שלך ברגע שיש לך אלה, אתה יכול לאמת ולהתחיל להפעיל שאילתות באמצעות התסריט. חשבון Google JSON Credential כדי ליצור חשבון שירות, עבור אל ולתת לו את תפקיד עקבו אחרי google cloud console BigQuery Data Editor עקבו אחרי google cloud console לאחר שהחשבון נוצר, פתח אותו, ניווט אל תגית: click ולבחור זה יפיק ולהוריד קובץ אישורים JSON עבור חשבון השירות. “Keys” “Add key” “JSON” חשבון שירות JSON בדרך כלל נראה כך: { "type": "service_account", "project_id": YOUR_PROJECT, "private_key_id": private_key_id, "private_key": GCP_PRIVATE_KEY, "client_email": "email", "client_id": "id", "auth_uri": "auth_uri", "token_uri": "token_uri", "auth_provider_x509_cert_url": "auth_provider_x509_cert_url", "client_x509_cert_url": "url", "universe_domain": "universe_domain" } למטרות בדיקה, באפשרותך להמיר את אישורים JSON לסדרת שורה אחת ולהדביק אותו ישירות לתוך התסריט שלך. השתמש ב- Secrets Manager כדי לאחסן ולנהל באופן מאובטח את האישורים שלך במקום. not recommended for production באפשרותך גם לחלץ את bqProjectId מהשדה project_id בתוך הרשאות JSON. מודלים כדי לעבוד עם נתונים BigQuery בצורה בטוחה טופס, זה שימושי להגדיר מודלים נתונים המשקפים את המבנה של תוצאות השאילתה. להלן דוגמה לכיתות מודל כאלה: class BQCrashlyticsVersionsModel: def __init__(self, version: str, events: int, users: int ): self.version = version self.events = events self.users = users class BQCrashlyticsIssueModel: def __init__(self, issue_id: str, issue_title: str, blame_file: str, blame_library: str, blame_symbol: str, total_events: int, total_users: int, versions: list[BQCrashlyticsVersionsModel] ): self.issue_id = issue_id self.issue_title = issue_title self.blame_file = blame_file self.blame_library = blame_library self.blame_symbol = blame_symbol self.total_events = total_events self.total_users = total_users self.versions = versions פתרון בעיות תפקוד ובסופו של דבר, אנו יכולים להשיג נתונים מ- BigQuery. הוסף את השיטה הבאה לכיתה BigQueryExecutor הקיימת שלך – היא תפעיל את השאילתה SQL המתוארת בעבר ב- החזיר את התוצאות שפורסמו למקרים של מודל. BigQuery SQL def getCrashlyticsIssues(self, lastHoursCount: int, tableName: str) -> list[BQCrashlyticsIssueModel]: firstEventsInfo = """'[' || STRING_AGG(events_info, ",") || ']' as events_info""" asVersions = """ '{"version":"' || application.display_version || '","events":' || COUNT(DISTINCT event_id) || ',"users":' || COUNT(DISTINCT installation_uuid) || '}' AS events_info """ query = f""" WITH pre as( SELECT issue_id, ARRAY_AGG(DISTINCT issue_title IGNORE NULLS) as issue_titles, ARRAY_AGG(DISTINCT blame_frame.file IGNORE NULLS) as blame_files, ARRAY_AGG(DISTINCT blame_frame.library IGNORE NULLS) as blame_libraries, ARRAY_AGG(DISTINCT blame_frame.symbol IGNORE NULLS) as blame_symbols, COUNT(DISTINCT event_id) as total_events, COUNT(DISTINCT installation_uuid) as total_users, {asVersions} FROM `{tableName}` WHERE 1=1 AND event_timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL {lastHoursCount} HOUR) AND event_timestamp < CURRENT_TIMESTAMP() AND error_type = "FATAL" GROUP BY issue_id, application.display_version ) SELECT issue_id, ARRAY_CONCAT_AGG(issue_titles) as issue_titles, ARRAY_CONCAT_AGG(blame_files) as blame_files, ARRAY_CONCAT_AGG(blame_libraries) as blame_libraries, ARRAY_CONCAT_AGG(blame_symbols) as blame_symbols, SUM(total_events) as total_events, SUM(total_users) as total_users, {firstEventsInfo} FROM pre WHERE 1=1 AND issue_id IS NOT NULL AND events_info IS NOT NULL GROUP BY issue_id ORDER BY total_users DESC """ bqRows = self.client.query(query).result() rows: list[BQCrashlyticsIssueModel] = [] def mergeArray(array: list[str]) -> str: if not array: return '' counter = Counter(array) most_common = counter.most_common(1) return most_common[0][0] if most_common else '' for row in bqRows: issueModel = BQCrashlyticsIssueModel( issue_id=row.issue_id, issue_title=mergeArray(row.issue_titles), blame_file=mergeArray(row.blame_files), blame_library=mergeArray(row.blame_libraries), blame_symbol=mergeArray(row.blame_symbols), total_events=row.total_events, total_users=row.total_users, versions=[BQCrashlyticsVersionsModel(version=jj['version'], events=jj['events'], users=jj['users']) for jj in json.loads(row.events_info)] ) rows.append(issueModel) return rows עכשיו אנחנו יכולים לבצע את בקשת SQL שלנו ל- BigQuery ישירות מ- Python. הנה דוגמה מלאה של איך להפעיל את השאילתה ולעבוד עם התוצאות: executor = BigQueryExecutor(credentialsJson=_jsonToken, bqProjectId=_bqProjectId) allCrashes = executor.getCrashlyticsIssues(lastHoursCount=24, tableName="tableNAME_IOS_REALTIME") for i in allCrashes: print(i.issue_title) [libswift_Concurrency.dylib] swift::swift_Concurrency_fatalError(unsigned int, char const*, ...) [SwiftUI] static DisplayList.ViewUpdater.Platform.updateClipShapesAsync(layer:oldState:newState:) Foundation [SwiftUI] __swift_memcpy112_8 [libswift_Concurrency.dylib] swift::AsyncTask::waitFuture(swift::AsyncTask*, swift::AsyncContext*, void (swift::AsyncContext* swift_async_context) swiftasynccall*, swift::AsyncContext*, swift::OpaqueValue*) [libobjc.A.dylib] objc_opt_respondsToSelector [VectorKit] void md::COverlayRenderLayer::layoutRibbon (std::__1::unique_ptr , std::__1::default_delete > > const&, ggl::CommandBuffer*, md::PolylineOverlayLayoutContext&, unsigned int, unsigned long long, bool, bool, float) [libswiftCore.dylib] _swift_release_dealloc [libobjc.A.dylib] objc_msgSend עכשיו שאנו מסוגלים להשיג נתוני התרסקות מ-BigQuery, אנו יכולים לעבור לשלב הבא – לקחת את 5 התרסקות הנפוצות ביותר וליצור באופן אוטומטי משימות Jira עבורן. קח את כל קומיקרים של אחסון ולהיפוך אותם לפני הקצאת בעיות התרסקות למפתחים, אנו צריכים קודם כל לזהות את הבעלים הפוטנציאליים עבור כל התרסקות. מאחר שאנחנו משתמשים ב- GitHub, עלינו להיות מודעים לכמה פרטים ספציפיים: כמה מפתחים עשויים להשתמש בכתובות דואר אלקטרוני מרובות על פני מחויבות, ולכן נצטרך לשלב זהויות במידת הצורך. GitHub משתמשת לעתים קרובות בדואר אלקטרוני (לדוגמה, username@users.noreply.github.com), כך שנוכל לטפל במקרים אלה בהתאם. המטרה העיקרית בשלב זה היא לחלץ ולנורמליזציה את רשימת המחברים של Git עם שמותיהם וכתובות הדואר האלקטרוני שלהם, באמצעות הפקודה הבאה: תגיות קשורות לתגיות קשורות לתגיות קשורות לתגיות קשורות לתגיות קשורות לתגיות קשורות לתגיות קשורות לתגיות קשורות import re class GitUserModel: def __init__(self, nicknames: set[str], emails: set[str], gitLogins: set[str] ): self.nicknames = nicknames self.emails = emails self.gitLogins = gitLogins def returnPossibleNicknames(text: str) -> set[str]: res = [findEmail(text), loginFromEmail(text), findGitNoreplyLogin(text)] return set(list(filter(None, res))) def findEmail(text: str) -> str: e = re.match(r"(([A-Za-z0-9+\.\_\-]*@[A-Za-z0-9+]*\.[A-Za-z0-9+]*))", text) if e: return e.group(1) def loginFromEmail(text: str) -> str: e = re.match(r"(([A-Za-z0-9+\.\_\-]*))@[A-Za-z0-9+]*\.[A-Za-z0-9+]*", text) if e: return e.group(1) def findGitNoreplyLogin(text: str) -> str: gu = re.match(r"\d+\+(([A-Za-z0-9+\.\_\-]*))@users\.noreply\.github\.com", text) if gu: return gu.group(1) else: gu = re.match(r"(([A-Za-z0-9+\.\_\-]*))@users\.noreply\.github\.com", text) if gu: return gu.group(1) class GitBlamer: def getAllRepoUsersMap(self, projectRootPath: str) -> list[GitUserModel]: users: list[GitUserModel] = [] allGitLog = os.popen("cd {}; git log | grep '^Author' | sort | uniq -c".format(projectRootPath)).read() for line in allGitLog.split('\n'): user = self._createUserFromBlameLine(line) if user: users.append(user) self._enrichUsersNicknames(users=users) users = self._mergeSameUsers(users) users = sorted(users, key=lambda x: list(x.emails)[0] if x.emails else list(x.gitLogins)[0] if x.gitLogins else "") return users def _createUserFromBlameLine(self, line): m = re.match(r".* Author: (.*) ", line) user = GitUserModel(nicknames=set(), emails=set(), gitLogins=set()) if m: val=set() if m.group(1): val.add(m.group(1)) if m.group(2): val.add(m.group(2)) user.nicknames = val else: return return user def _enrichUsersNicknames(self, users: list[GitUserModel]): for user in users: possibleNicknames = set() for nick in user.nicknames: possibleNicknames = possibleNicknames.union(returnPossibleNicknames(text=nick)) e = findEmail(text=nick) if e: user.emails.add(e) gu = findGitNoreplyLogin(text=nick) if gu: user.gitLogins.add(gu) user.nicknames = user.nicknames.union(possibleNicknames) def _mergeSameUsers(self, users: list[GitUserModel]): for i in range(0, len(users)): if i >= len(users): break for j in range(i+1, len(users)): if j >= len(users): break setLoweredJNicknames=set([u.lower() for u in users[j].nicknames]) for k in range(0, j): if k >= j: break setLoweredKNicknames=set([u.lower() for u in users[k].nicknames]) isSameNickname=len(setLoweredKNicknames.intersection(setLoweredJNicknames)) > 0 if isSameNickname: users[j].gitLogins = users[j].gitLogins.union(users[k].gitLogins) users[j].emails = users[j].emails.union(users[k].emails) users.pop(k) break return users בקוד למטה, אנו מנסים להתאים זהויות קומיקס שונות שאולי שייכות לאותו אדם – לדוגמה, user@gmail.com ו- user@users.noreply.github.com. אנו גם לחלץ ולסווג את שמותיהם ואת שמות המשתמשים של GitHub (כאשר זמינים) למטרות נוחות. עם התסריט למטה, אתה יכול להפעיל את התהליך הזה ולקבל רשימה נקיה, deduplicated של כל קומיטרים באחסון: projectRootPath="/IOS_project_path" blamer = GitBlamer() allUsers = blamer.getAllRepoUsersMap(projectRootPath=projectRootPath) for user in allUsers: print(", ".join(user.nicknames)) מפות כל בעיה לקובץ של אחסון וקובץ בעל בשלב זה, יש לנו מידע מפורט על התרסקות שלנו ואת המשתמשים המשפיעים עליהן.זה מאפשר לנו לקשר התרסקות ספציפית למשתמש ספציפי וליצור באופן אוטומטי משימה Jira מתאימה. לפני יישום ההיגיון של מפת התרסקות למשתמש, נפרדנו את זרימי העבודה עבור iOS ו- Android. הפלטפורמות האלה משתמשות בפורמטים שונים של סמלים, והקריטריונים לקשר קבצי התרסקות לבעיות שונים גם כן. class AbstractFileToIssueMapper: def isPathBelongsToIssue(self, file: str, filePath: str, issue: BQCrashlyticsIssueModel) -> bool: raise Exception('Not implemented method AbstractFileToIssueMapper') class AndroidFileToIssueMapper(AbstractFileToIssueMapper): def __init__(self): self.libraryName = 'inDrive' def isPathBelongsToIssue(self, file: str, filePath: str, issue: BQCrashlyticsIssueModel) -> bool: if file != issue.blame_file or not issue.blame_symbol.startswith(self.libraryName): return False fileNameNoExtension = file.split('.')[0] fileNameIndexInSymbol = issue.blame_symbol.find(fileNameNoExtension) if fileNameIndexInSymbol < 0: return False relativeFilePathFromSymbol = issue.blame_symbol[0:fileNameIndexInSymbol].replace('.', '/') relativeFilePathFromSymbol = relativeFilePathFromSymbol + file return filePath.endswith(relativeFilePathFromSymbol) class IosFileToIssueMapper(AbstractFileToIssueMapper): def __init__(self): self.indriveLibraryName = 'inDrive' self.indriveFolderName = 'inDrive' self.modulesFolderName = 'Modules' def isPathBelongsToIssue(self, file: str, filePath: str, issue: BQCrashlyticsIssueModel) -> bool: if file != issue.blame_file: return False isMatchFolder = False if issue.blame_library == self.indriveLibraryName: isMatchFolder = filePath.startswith('{}/'.format(self.indriveFolderName)) else: isMatchFolder = filePath.startswith('{}/{}/'.format(self.modulesFolderName, issue.blame_library)) return isMatchFolder יישום ספציפי עשוי להשתנות בהתאם לפרוייקט שלך, אך האחריות העיקרית של כיתה זו היא לקבוע אם התרחש תקלה מסוימת בקובץ מסוים. ברגע שההיגיון הזה נמצא במקומו, אנו יכולים להמשיך למפות קבצים לבעיות ולהקצות אותם לבעלי הקבצים המתאימים. import subprocess class MappedIssueFileModel: def __init__(self, fileGitLink: str, filePath: str, issue: BQCrashlyticsIssueModel, fileOwner: GitUserModel ): self.fileGitLink = fileGitLink self.filePath = filePath self.issue = issue self.fileOwner = fileOwner class BigQueryCrashesFilesMapper: def getBlameOut(self, filePath: str, projectRootPath: str) -> list[str]: dangerousChars = re.compile(r'[;|&\r\n]|\.\.') if dangerousChars.search(filePath) or dangerousChars.search(projectRootPath): return None if not subprocess.check_output(['git', 'ls-files', filePath], cwd=projectRootPath, text=True): return None blameProc = subprocess.Popen(['git', 'blame', filePath, '-cwe'], cwd=projectRootPath, stdout=subprocess.PIPE, text=True) blameRegex=r' ' grepProc = subprocess.Popen(['grep', '-o', blameRegex], stdin=blameProc.stdout, stdout=subprocess.PIPE, text=True) blameProc.stdout.close() sortProc = subprocess.Popen(['sort'], stdin=grepProc.stdout, stdout=subprocess.PIPE, text=True) grepProc.stdout.close() uniqProc = subprocess.Popen(['uniq', '-c'], stdin=sortProc.stdout, stdout=subprocess.PIPE, text=True) sortProc.stdout.close() finalProc = subprocess.Popen(['sort', '-bgr'], stdin=uniqProc.stdout, stdout=subprocess.PIPE, text=True) uniqProc.stdout.close() blameOut, _ = finalProc.communicate() blameArray=list(filter(len, blameOut.split('\n'))) return blameArray def findFileOwner(self, filePath: str, gitFileOwners: list[GitUserModel], projectRootPath: str) -> GitUserModel: blameArray = self.getBlameOut(filePath=filePath, projectRootPath=projectRootPath) if not blameArray: return foundAuthor = None for blameI in range(0, len(blameArray)): author = re.match(r".*\d+ ", blameArray[blameI]) if author: possibleNicknames = returnPossibleNicknames(text=author.group(1)) for gitFileOwner in gitFileOwners: if len(gitFileOwner.nicknames.intersection(possibleNicknames)) > 0: foundAuthor = gitFileOwner break if foundAuthor: break return foundAuthor def mapBQResultsWithFiles(self, fileToIssueMapper: AbstractFileToIssueMapper, issues: list[BQCrashlyticsIssueModel], gitFileOwners: list[GitUserModel], projectRootPath: str ) -> list[MappedIssueFileModel]: mappedArray: list[MappedIssueFileModel] = [] githubMainBranch = "https://github.com/inDriver/UDF/blob/master" for root, dirs, files in os.walk(projectRootPath): for file in files: filePath = os.path.join(root, file).removeprefix(projectRootPath).strip('/') gitFileOwner = None for issue in issues: if fileToIssueMapper.isPathBelongsToIssue(file, filePath, issue): if not gitFileOwner: gitFileOwner = self.findFileOwner(filePath=filePath, gitFileOwners=gitFileOwners, projectRootPath=projectRootPath) mappedIssue = MappedIssueFileModel( fileGitLink='{}/{}'.format(githubMainBranch, filePath.strip('/')), filePath=filePath, issue=issue, fileOwner=gitFileOwner ) mappedArray.append(mappedIssue) mappedArray.sort(key=lambda x: x.issue.total_users, reverse=True) return mappedArray כל מה שאתה צריך לעשות בשלב זה הוא לעדכן את המאפיין githubMainBranch עם הקישור לאחסון שלך. לאחר מכן, אנו אוספים את הבעיות ואת בעלי הקבצים, מפות את הקבצים בהתאם באמצעות הקוד למטה, ולקבל תוצאה סופית - רשימה של בעיות מסודרות לפי total_users בסדר יורד. mapper = BigQueryCrashesFilesMapper() mappedIssues = mapper.mapBQResultsWithFiles( fileToIssueMapper=IosFileToIssueMapper(), issues=allCrashes, gitFileOwners=allUsers, projectRootPath=projectRootPath ) for issue in mappedIssues: if issue.fileOwner: print(list(issue.fileOwner.nicknames)[0], issue.issue.total_users, issue.issue.issue_title) else: print('no owner', issue.issue.total_users, issue.issue.issue_title) יצירת משימה Jira עבור בעל קובץ של התרסקות בשלב זה, יש לנו את כל מה שאנחנו צריכים כדי להתחיל ליצור משימות Jira עבור בעלי התרסקות. עם זאת, יש לזכור כי הגדרות Jira משתנות לעתים קרובות בין חברות – שדות מותאם אישית, זרימות עבודה ורשיונות עשויים להשתנות. הנה כמה טיפים מעשיים המבוססים על החוויה שלנו: לא ליצור משימות עבור כל בעיה, להתמקד ב-5-10 הבעיות המובילות בהתבסס על מספר המשתמשים המושפעים או על סף השפעה מסוים. שמור מידע על המשימות שנוצרו באחסון קבוע.אני משתמש ב-BigQuery, שמור את הנתונים בטבלה נפרדת ומעדכן אותם בכל תרגיל סקריפט. הפעל מחדש משימות סגורות אם הבעיה חוזרת בגירסאות חדשות יותר של האפליקציה – זה מבטיח שחזרות לא מתעלמות. קישור משימות עבור אותה בעיה כדי להקל על חקירה עתידית ולהימנע מתפשטות. הוסף כמה שיותר פרטים לתוך תיאור המשימה.הוספת צירופי תאונות, מספר המשתמשים המשפיעים, גירסאות וכו '. קישורים קשורים התרסקות אם הם נובעים מאותו קובץ - זה מספק kontext נוסף. הודע לצוות שלך ב- Slack (או מערכת הודעות אחרת) כאשר משימות חדשות נוצרות או משימות קיימות זקוקות לתשומת לב.כלול קישורים שימושיים לדו"ח התרסקות, משימות, קבצי GitHub רלוונטיים וכו '. השתמש בבלוקים של try/except ושלח אזהרות Slack כאשר משהו נכשל. קטע פעולות איטיות במהלך פיתוח, לדוגמה, קטע BigQuery תקלות חיפושים מקומיים כדי להאיץ iteration. במקרים אלה, ייתכן שתצטרך להקצות את המשימה באופן ידני, אך עדיין מועיל ליצור את הבעיה Jira באופן אוטומטי עם הקשר המלא של התרסקות. מסקנה מערכת זו מאפשרת לנו לעבד אלפי דיווחים על תאונות ביום, ומעבירה אותם למפתחים הנכונים תוך דקות בלבד - ללא כל עבודה ידנית. אם הצוות שלך מתייבש בנושאים של תאונות ללא קטגוריות – אוטומטיז את זה.