Budowanie automatyzacji raportów o awarii dla iOS i Androida

Witam, jestem Vilian Iaumbaev! niedawno zbudowałem system, który automatycznie obsługuje nowe raporty o awarii zarówno dla systemu iOS, jak i Androida - sprawia, że śledzenie i naprawianie problemów jest znacznie łatwiejsze. Dlaczego to zrobiliśmy. Ręczne przypisywanie awarii właściwym deweloperom szybko stało się nudnym i niezawodnym zadaniem. Łatwo było zapomnieć o czymś, pominąć skrajne przypadki lub pominąć skomplikowane problemy.Chcieliśmy, aby proces był bardziej przewidywalny i systematyczny – aby nikt w zespole nie musiał tracić czasu na przetestowanie awarii, a żaden krytyczny problem nie spadłby przez pęknięcia. Podsumowanie Aby zacząć, będziesz potrzebował narzędzi Google, takich jak: , A także Jira. Crashlytics Google Cloud Platform Crashlytics Platforma Google Cloud Po skonfigurowaniu projektów w usługach Google skonfiguruj przesyłanie danych z Crashlytics do GCP za pomocą Następnie wszystkie raporty o awarii pojawią się w tabelach BigQuery. Strona integracji Strona integracji Struktura danych zderzeniowych dla systemu iOS i Androida jest prawie identyczna, z zaledwie kilkoma małymi różnicami - co oznacza, że możemy użyć jednego skryptu do przetwarzania obu. Więc teraz masz swoje awarii w BigQuery co oznacza, że można wykonać jakąś pracę na tych danych. Najpierw musimy uzyskać wszystkie dane wypadków do analizy, ale jeśli masz dużą ilość danych na ponad milion użytkowników lepiej preproces wszystkich danych na stronie Google, zrobić kilka agregacji. Planem Dowiedz się kilku podstawowych SQL, aby uzyskać dane o awarii z BigQuery Query Crash danych za pomocą Pythona Pobierz wszystkie komitety z repozytorium i połączyć duplikaty Mapuj każdy problem do pliku repo i jego właściciela Tworzenie zadania Jira dla właściciela pliku, jeśli zadania nie istnieje już Dowiedz się podstaw SQL, aby uzyskać dane z BigQuery BigQuery używa własnego dialektu SQL, który jest podobny do standardowego SQL, ale oferuje dodatkowe wygody w analizie danych. Do naszej integracji potrzebowaliśmy pracować z pełnym zbiorem danych o awarii, ale w formie zbiorczej. 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 W rezultacie otrzymasz jeden wiersz na unikalny problem_id wraz z następującymi zbiorczymi polami: issue_titles — lista wszystkich tytułów awarii. Jest to lista przypadków, w których istnieje wiele unikalnych tytułów dla tego samego problemu. blame_files — lista najlepszych plików stacktrace obarczonych winą za awarię. blame_libraries — lista bibliotek związanych z awarią. Jest to również array, zbudowany z powodów podobnych do issue_titles. blame_symbols — lista symboli kodu (funkcji/metod), w których doszło do awarii. total_events – całkowita liczba zdarzeń w wybranym okresie czasu. total_users — liczba unikalnych użytkowników dotkniętych. Czasami awarię może wystąpić tylko dla określonej grupy użytkowników. events_info — array JSON (jako string) zawierające total_events i total_users podzielone na wersje aplikacji. [ { "version": "1.0.1", "events": 131, "users": 110 }, { "version": "1.2.1", "events": 489, "users": 426 } ] Poproś o usunięcie danych z BigQuery przy użyciu Pythona Aby rozpocząć, zainstaluj bibliotekę klienta BigQuery Python z Po zakończeniu instalacji utwórz plik BigQueryExecutor.py – ten moduł będzie obsługiwał całą komunikację z Google Cloud BigQuery. Pypy Pypy 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) Aby rozpocząć korzystanie ze scenariusza, będziesz potrzebował tylko dwóch rzeczy: Konto usługi Google JSON Credentials File Nazwa (lub identyfikator) projektu BigQuery Gdy już je masz, możesz uwierzytelnić i rozpocząć wykonywanie zapytań za pośrednictwem skryptów. Konto Google JSON Credential Aby utworzyć konto, przejdź do i przydzielić mu Rola w roli. Konsola Google Cloud BigQuery Data Editor Konsola Google Cloud Po utworzeniu konta, otwórz go, przejdź do TAB, kliknij i wybierz W ten sposób zostanie wygenerowany i pobrany plik identyfikatorów JSON dla konta usługi. “Keys” “Add key” “JSON” Konto usługi JSON zwykle wygląda tak: { "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" } W celach testowych, można przekonwertować poufności JSON do pojedynczego wiersza i osadzić go bezpośrednio w skrypt. Użyj Menedżera tajemnic, aby bezpiecznie przechowywać i zarządzać swoimi zaufaniami. not recommended for production Możesz również wyodrębnić bqProjectId z pola project_id w credentials JSON. Modele Aby pracować z danymi BigQuery w sposób bezpieczny od typowania, przydatne jest zdefiniowanie modeli danych, które odzwierciedlają strukturę wyników zapytania. Poniżej znajduje się przykład takich klas modelowych: 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 funkcja chrapanie funkcja I wreszcie możemy pobrać dane z BigQuery. Dodaj następującą metodę do istniejącej klasy BigQueryExecutor — będzie ona wykonywać zapytanie SQL opisane wcześniej w sekcji i zwrócić wyniki analizowane w instancjach modelu. 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 Teraz możemy wykonać nasze żądanie SQL do BigQuery bezpośrednio z Pythona. Oto pełny przykład, jak uruchomić zapytanie i pracować z wynikami: 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 Teraz, gdy jesteśmy w stanie pobrać dane o awarii z BigQuery, możemy przejść do następnego kroku - wziąć 5 najczęstszych awarii i automatycznie utworzyć zadania Jira dla nich. Pobierz wszystkich komendantów repozytorium i połączyć je Przed przypisaniem problemów z awarią programistom, musimy najpierw zidentyfikować potencjalnych właścicieli dla każdego awarii. Ponieważ używamy GitHub, powinniśmy pamiętać o kilku szczegółach: Niektórzy deweloperzy mogą używać wielu adresów e-mail w połączeniu z zobowiązaniami, więc będziemy musieli połączyć tożsamości tam, gdzie jest to właściwe. GitHub często używa wiadomości e-mail (np. username@users.noreply.github.com), więc będziemy odpowiednio radzić sobie z tymi przypadkami. Głównym celem w tym kroku jest wyodrębnienie i normalizacja listy autorów Git z ich imionami i adresami e-mail, używając następującego polecenia: git log Unibertsitatea grep ‘^Author’ 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 W poniższym kodzie staramy się dopasować różne tożsamości komitujące, które prawdopodobnie należą do tej samej osoby – na przykład user@gmail.com i user@users.noreply.github.com. Dla wygody również wyodrębniamy i grupujemy ich nazwy i nazwy użytkowników GitHub (gdzie są dostępne). Za pomocą poniższego skryptu możesz uruchomić ten proces i uzyskać wyczyszczoną, deduplikowaną listę wszystkich komendantów w repozytorium: projectRootPath="/IOS_project_path" blamer = GitBlamer() allUsers = blamer.getAllRepoUsersMap(projectRootPath=projectRootPath) for user in allUsers: print(", ".join(user.nicknames)) Mapuj każdy problem do pliku repozytorium i właściciela pliku W tym momencie posiadamy szczegółowe informacje na temat naszych awarii i użytkowników dotkniętych tymi awariami, co pozwala nam powiązać konkretny awarię z konkretnym użytkownikiem i automatycznie utworzyć odpowiednie zadanie Jira. Przed wdrożeniem logiki mapowania zderzeń użytkowników oddzieliliśmy przepływy pracy dla systemów iOS i Android. Platformy te wykorzystują różne formaty symboli, a kryteria łączenia plików zderzeń z problemami również się różnią. 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 Specyficzne wdrożenie może się różnić w zależności od projektu, ale główną odpowiedzialnością tej klasy jest ustalenie, czy dany awariusz wystąpił w danym pliku. Gdy ta logika jest na miejscu, możemy przejść do mapowania plików do problemów i przypisać je do odpowiednich właścicieli plików. 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 Wszystko, co musisz zrobić w tym momencie, to zaktualizować właściwość githubMainBranch za pomocą linku do własnego repozytorium. Następnie gromadzimy problemy i właścicieli plików, mapujemy pliki odpowiednio za pomocą poniższego kodu i otrzymujemy ostateczny wynik — listę problemów sortowanych według total_users w kolejności malejącej. 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) Tworzenie zadania Jira dla właściciela pliku W tym momencie mamy wszystko, czego potrzebujemy, aby zacząć tworzyć zadania Jira dla właścicieli awarii.Należy jednak pamiętać, że konfiguracje Jira często różnią się w zależności od firmy – niestandardowe pola, przepływy pracy i uprawnienia mogą się różnić. Oto kilka praktycznych wskazówek opartych na naszym doświadczeniu: Koncentruj się na pięciu do dziesięciu najlepszych problemów w oparciu o liczbę użytkowników lub określony próg wpływu. Przetrwanie metadanych zadań. Przechowywanie informacji o utworzonych zadaniach w trwałym magazynie. Używam BigQuery, zapisując dane w oddzielnej tabeli i aktualizując je przy każdym uruchomieniu skryptów. Ponowne utworzenie zamkniętych zadań, jeśli problem pojawia się ponownie w nowszych wersjach aplikacji – zapewnia to, że regresje nie są ignorowane. Łączenie zadań dla tego samego problemu w celu uproszczenia przyszłego dochodzenia i uniknięcia powielania. Wpisz jak najwięcej szczegółów w opisie zadania. Dodaj agregacje awarii, liczbę użytkowników, wersje itp. Połączenia związane z awariami, jeśli pochodzą z tego samego pliku — zapewnia to dodatkowy kontekst. Powiadom swój zespół w Slack (lub innym systemie przesyłania wiadomości), gdy tworzone są nowe zadania lub istniejące wymagają uwagi. Użyj try/except bloków i wysyłaj ostrzeżenia Slack, gdy coś się nie uda. Cache powolnych operacji podczas rozwoju. Na przykład, cache BigQuery odzyskiwania awarii lokalnie, aby przyspieszyć iterację. W takich przypadkach prawdopodobnie będziesz musiał ręcznie przypisać zadanie, ale nadal przydatne jest automatyczne tworzenie problemu Jira z pełnym kontekstem awarii. konkluzji Ten system pozwala nam codziennie przetwarzać tysiące raportów o awarii i kierować je do właściwego dewelopera w zaledwie kilka minut – bez żadnej pracy ręcznej. Jeśli Twój zespół utonął w nieokreślonych problemach zderzeniowych – zautomatyzuj je.