Nelaimės ataskaitų automatizavimo kūrimas „iOS“ ir „Android“

Sveiki, aš esu Vilian Iaumbaev! neseniai sukūriau sistemą, kuri automatiškai tvarko naujas avarijų ataskaitas tiek "iOS", tiek "Android" - tai palengvina problemų sekimą ir ištaisymą. Kodėl mes tai padarėme. Rankiniu būdu priskirti avarijas tinkamiems kūrėjams greitai tapo nuobodu ir nepatikima užduotis. buvo lengva pamiršti kažką, praleisti krašto atvejus arba praleisti sudėtingus klausimus. Norėjome, kad procesas būtų labiau nuspėjamas ir sistemingas, kad niekas iš komandos neturėtų švaistyti laiko išbandyti avarijas, ir jokia kritinė problema nepatektų per įtrūkimus. Santrauka Norėdami pradėti, jums reikės "Google" įrankių, tokių kaip , Taip pat ir Jira. Crashlytikų „Google Cloud“ platforma Crashlytikų „Google Cloud“ platforma Kai jūsų projektai yra sukonfigūruoti „Google“ paslaugose, konfigūruokite duomenų perdavimą iš „Crashlytics“ į GCP naudodami Po to visos avarijos ataskaitos pasirodys BigQuery lentelėse. Integracijos puslapis Integracijos puslapis "iOS" ir "Android" avarijos duomenų struktūros yra beveik identiškos, tik keletas nedidelių skirtumų - tai reiškia, kad mes galime naudoti vieną scenarijų, kad apdorotume abu. Taigi dabar jūs turite savo avarijas "BigQuery", o tai reiškia, kad galite atlikti tam tikrą darbą su šiais duomenimis. Pirma, mes turime gauti visus avarijų duomenis, kad būtų analizuojami, bet jei turite didelį kiekį duomenų apie daugiau nei milijoną vartotojų, geriau iš anksto apdoroti visus duomenis "Google" pusėje, atlikti kai kurias agregacijas. planą Sužinokite keletą pagrindinių SQL, kad gautumėte avarijos duomenis iš BigQuery Užklausų nusileidimo duomenys naudojant Python Paimkite visus komitetus iš saugyklos ir sumaišykite dublikatus Žemėlapis kiekvieną problemą į repo failą ir jo savininkas Sukurkite „Jira“ užduotį failų savininkui, jei užduoties jau nėra Sužinokite kai kuriuos SQL pagrindus, kad gautumėte duomenis iš BigQuery BigQuery naudoja savo SQL dialektą, kuris yra panašus į standartinį SQL, bet siūlo papildomą patogumą duomenų analizei. Mūsų integracijai mums reikėjo dirbti su pilnu avarijos duomenų rinkiniu, bet agreguota forma. Konkrečiai kalbant, mes grupavome atskiras avarijos ataskaitas unikaliomis avarijos parašais ir tada agreguojame atitinkamus duomenis kiekvienoje grupėje, pvz., įvykių skaičių, paveiktų naudotojų skaičių, versijų suskaidymą ir dar daugiau. 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 Kaip rezultatas, gausite vieną eilutę už unikalų issue_id, kartu su šiais agreguotais laukais: issue_titles — visų crash pavadinimų sąrašas. Tai yra skaičių, kad būtų atsižvelgta į atvejus, kai keli unikalūs pavadinimai egzistuoja dėl tos pačios problemos. blame_files – sąrašas geriausių stacktrace failų, kurie buvo kaltinami dėl avarijos. tai bus ne tuščias, jei avarija įvyko jūsų kodų bazėje (o ne sistemos bibliotekose). blame_libraries – su avarija susijusių bibliotekų sąrašas.Tai taip pat yra matrica, sukurta dėl priežasčių, panašių į issue_titles. blame_symbols – kodų simbolių (funkcijų/metodų), kuriuose įvyko gedimas, sąrašas. Total_events – bendras įvykių, kurie įvyko per pasirinktą laikotarpį, skaičius. total_users – paveiktų unikalių naudotojų skaičius. Kartais gedimas gali pasireikšti tik konkrečiai naudotojų grupei. events_info – JSON diapazonas (kaip eilutė), kuriame yra total_events ir total_users, suskirstyti pagal programos versiją. [ { "version": "1.0.1", "events": 131, "users": 110 }, { "version": "1.2.1", "events": 489, "users": 426 } ] Prašymas nukrenta duomenis iš BigQuery naudojant Python Norėdami pradėti, įdiekite BigQuery Python kliento biblioteką iš Po diegimo sukurkite BigQueryExecutor.py failą – šis modulis tvarkys visą bendravimą su „Google Cloud BigQuery“. PyPI Pypės 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) Norėdami pradėti naudoti scenarijų, jums reikės tik dviejų dalykų: „Google“ paslaugų paskyros JSON įgaliojimų failas Jūsų „BigQuery“ projekto pavadinimas (arba ID) Kai turite juos, galite autentifikuoti ir pradėti vykdyti užklausas per scenarijų. Google Paslaugų Paskyra JSON Credential Norėdami sukurti paskyrą, eikite į ir paskirstykite jį vaidmenį . „Google Cloud“ konsolė BigQuery Data Editor „Google Cloud“ konsolė Kai sąskaita yra sukurta, atidarykite ją, naršykite į Žymės, KLIK ir pasirinkti Tai sukurs ir atsisiųs JSON įgaliojimų failą paslaugų paskyrai. “Keys” “Add key” “JSON” Paslaugų sąskaita JSON paprastai atrodo taip: { "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" } Testavimo tikslais galite konvertuoti JSON įgaliojimus į vienos eilutės eilutę ir įterpti ją tiesiai į savo scenarijų. Naudokite paslapčių tvarkyklę saugiai saugoti ir tvarkyti savo įgaliojimus. not recommended for production Taip pat galite ištraukti savo bqProjectId iš projekto_id lauko įgaliojimų JSON. Modelių Norėdami dirbti su BigQuery duomenimis tipas saugiu būdu, naudinga apibrėžti duomenų modelius, kurie atspindi užklausos rezultatų struktūrą. Žemiau pateikiamas tokių modelių klasių pavyzdys: 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 Šlapimo funkcijos funkcijos Ir galiausiai, mes galime gauti duomenis iš BigQuery. Įtraukite šį metodą į esamą BigQueryExecutor klasę – ji vykdys SQL užklausą, aprašytą anksčiau sekciją ir grąžina rezultatus, parsetuotus į modelio egzempliorius. Pagrindinis » 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 Dabar mes galime vykdyti mūsų SQL užklausą į BigQuery tiesiogiai iš Python. Štai pilnas pavyzdys, kaip paleisti užklausą ir dirbti su rezultatais: 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 Hooray! 🎉 Dabar, kai mes galime gauti avarijų duomenis iš BigQuery, mes galime pereiti prie kito žingsnio - paimti 5 dažniausiai pasitaikančias avarijas ir automatiškai sukurti Jira užduotis. Gaukite visus saugyklos komitetus ir sujungsite juos Prieš priskiriant avarijos problemas kūrėjams, pirmiausia turime nustatyti potencialius savininkus kiekvienam avarijai. Kadangi mes naudojame GitHub, turėtume žinoti keletą konkrečių detalių: Kai kurie kūrėjai gali naudoti kelis el. Pašto adresus per įsipareigojimus, todėl prireikus turėsime sujungti tapatybes. GitHub dažnai naudoja elektroninius laiškus (pvz., username@users.noreply.github.com), todėl mes atitinkamai tvarkysime šiuos atvejus. Pagrindinis tikslas šiame žingsnyje yra ištraukti ir normalizuoti Git autorių sąrašą su jų vardais ir el. Laiškais, naudojant šią komandą: git log Unibertsitatea grep ‘^Autor’ Unibertsitatea sort Unibertsitatea uniq -c 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 Žemiau esančiame kode mes stengiamės suderinti skirtingas komiteto tapatybes, kurios tikriausiai priklauso tam pačiam asmeniui, pvz., user@gmail.com ir user@users.noreply.github.com. Taip pat išgauname ir grupuojame jų vardus ir GitHub vartotojo vardus (jei jie yra) patogumui. Naudodamiesi žemiau pateiktu scenarijumi, galite paleisti šį procesą ir gauti išvalytą, deduplikuotą visų komiterių sąrašą saugykloje: projectRootPath="/IOS_project_path" blamer = GitBlamer() allUsers = blamer.getAllRepoUsersMap(projectRootPath=projectRootPath) for user in allUsers: print(", ".join(user.nicknames)) Žemėlapis kiekvieną problemą į failą saugyklos ir failų savininkas Šiuo metu mes turime išsamią informaciją apie mūsų avarijas ir naudotojus, kuriuos jie paveikė.Tai leidžia mums susieti konkrečią avariją su konkrečiu vartotoju ir automatiškai sukurti atitinkamą Jira užduotį. Prieš įgyvendindami „crash-to-user“ žemėlapio logiką, mes atskyrėme „iOS“ ir „Android“ darbo eigą. Šios platformos naudoja skirtingus simbolių formatus, o kriterijai, pagal kuriuos sudėtingus failus galima susieti su problemomis, taip pat skiriasi. 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 Konkretus įgyvendinimas gali skirtis priklausomai nuo jūsų projekto, tačiau pagrindinė šios klasės atsakomybė yra nustatyti, ar tam tikrame faile įvyko tam tikras gedimas. Kai ši logika yra vietoje, mes galime pereiti prie failų žemėlapio problemų ir priskirti juos atitinkamiems failų savininkams. 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 Viskas, ką jums reikia padaryti šiuo metu, yra atnaujinti githubMainBranch savybę su nuoroda į savo saugyklą. Tada mes surenkame problemas ir failų savininkus, atitinkamai žemėlapių failus, naudojant žemiau pateiktą kodą, ir gauname galutinį rezultatą - problemų sąrašą, rūšiuojamą pagal bendrą_naudotojai mažėjančia tvarka. 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) Sukurkite „Jira“ užduotį failo savininkui Šiuo metu turime viską, ko reikia, kad pradėtume kurti „Jira“ užduotis avarijų savininkams. tačiau nepamirškite, kad „Jira“ konfigūracijos dažnai skiriasi tarp įmonių – individualizuoti laukai, darbo eigos ir leidimai gali skirtis. Štai keletas praktinių patarimų, pagrįstų mūsų patirtimi: Sutelkite dėmesį į 5–10 geriausių problemų, pagrįstų paveiktų naudotojų skaičiumi arba tam tikra poveikio riba. Išlaiko užduočių metaduomenis. Saugo informaciją apie sukurtas užduotis nuolatinėje saugykloje. Naudoju „BigQuery“, taupydamas duomenis atskiroje lentelėje ir atnaujindamas ją kiekviename scenarijaus paleidime. Atkurkite uždaras užduotis, jei problema pasikartoja naujesnėse programos versijose – tai užtikrina, kad regresijos nebūtų ignoruojamos. Sujungti užduotis dėl tos pačios problemos, siekiant supaprastinti būsimą tyrimą ir išvengti dubliavimo. Į užduoties aprašymą įtraukite kiek įmanoma daugiau detalių. Įtraukite avarijos agregacijas, paveiktus naudotojų skaičius, versijas ir kt. Susiję ryšiai žlunga, jei jie kilę iš to paties failo – tai suteikia papildomą kontekstą. Praneškite savo komandai „Slack“ (arba kitoje pranešimų sistemoje), kai kuriamos naujos užduotys arba kai reikia atkreipti dėmesį į esamas užduotis. Naudokite bandykite / išskyrus blokus ir siųskite Slack įspėjimus, kai kažkas nepavyksta. Pavyzdžiui, „BigQuery“ talpyklos atkūrimai įvyksta vietoje, kad pagreitintų iteraciją. Kai kurie gedimai gali būti susiję su bendromis arba pagrindinėmis bibliotekomis. Tokiais atvejais jums tikriausiai reikės rankiniu būdu priskirti užduotį, tačiau vis tiek naudinga automatiškai sukurti „Jira“ problemą su pilnu gedimo kontekstu. Išvada Ši sistema leidžia mums kasdien apdoroti tūkstančius avarijų ataskaitų ir per kelias minutes nukreipti juos į tinkamą kūrėją - be jokių rankinių darbų. Jei jūsų komanda nuskendo nekategorizuotose avarijų problemose – automatizuokite.