Aufbau einer Crash Report Automation für iOS und Android

Hallo, ich bin Vilian Iaumbaev!Ich habe vor kurzem ein System gebaut, das automatisch neue Crash-Berichte für iOS und Android bearbeitet - es macht das Verfolgen und Beheben von Problemen viel einfacher. Warum wir das getan haben. Es war leicht, etwas zu vergessen, Edge-Fälle zu übersehen oder komplexe Probleme zu überspringen.Wir wollten den Prozess vorhersehbarer und systematischer machen – so dass niemand im Team Zeit verschwenden musste, Crash-Trialing zu machen, und kein kritisches Problem würde durch die Risse fallen. Zusammenfassung Um zu starten, benötigen Sie Google Tools wie , der Und auch Jira. Krampfadern Google Cloud Platform Krampfadern Die Google Cloud-Plattform Nachdem Ihre Projekte in Google-Diensten eingerichtet wurden, konfigurieren Sie die Datenübertragung von Crashlytics auf GCP mithilfe der Danach werden alle Crash-Berichte in BigQuery-Tabellen angezeigt. Integrationsseite Integrationsseite Die Crash-Datenstrukturen für iOS und Android sind fast identisch, mit nur wenigen kleinen Unterschieden - was bedeutet, dass wir ein einziges Skript verwenden können, um beide zu verarbeiten. So haben Sie jetzt Ihre Crashes in BigQuery, was bedeutet, dass Sie einige Arbeit an diesen Daten ausführen können. Zuerst müssen wir alle Crash-Daten analysieren, aber wenn Sie eine große Menge an Daten über mehr als eine Million Benutzer haben, sollten Sie alle Daten auf der Seite von Google vorverarbeiten, einige Aggregationen vornehmen. Plan ist Erfahren Sie einige grundlegende SQL, um Crash-Daten aus BigQuery zu erhalten Query Crash Daten mit Python Holen Sie alle Committers aus dem Repository und fusionieren Sie Duplikate Mapping jedes Problem in eine Repo-Datei und seinen Eigentümer Erstellen einer Jira-Aufgabe für den Dateiinhaber, wenn eine Aufgabe noch nicht vorhanden ist Lernen Sie einige SQL-Grundlagen, um Daten aus BigQuery zu erhalten BigQuery verwendet seinen eigenen SQL-Dialekt, der dem Standard SQL ähnlich ist, aber zusätzliche Bequemlichkeit für die Datenanalyse bietet. Für unsere Integration mussten wir mit dem kompletten Crash-Datenpaket arbeiten, aber in aggregierter Form. Insbesondere haben wir einzelne Crash-Berichte in eindeutige Crash-Signaturen gruppiert und dann relevante Daten innerhalb jeder Gruppe aggregiert – wie die Anzahl der Vorkommnisse, die Anzahl der betroffenen Benutzer, die Versionsauflösung und mehr. 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 Als Ergebnis erhalten Sie eine Zeile pro eindeutigen issue_id, zusammen mit den folgenden aggregierten Feldern: issue_titles — eine Liste aller Crash-Titel. Dies ist ein Array, um Fälle zu berücksichtigen, in denen mehrere eindeutige Titel für dasselbe Problem existieren. blame_files — eine Liste der Top Stacktrace-Dateien, die für den Absturz verantwortlich sind. Dies wird nicht leer sein, wenn der Absturz in Ihrer Codebase aufgetreten ist (anstatt in Systembibliotheken). blame_libraries – eine Liste von Bibliotheken, die mit dem Crash verbunden sind. Dies ist auch eine Array, die aus Gründen wie issue_titles erstellt wurde. blame_symbols – eine Liste von Code-Symbolen (Funktionen/Methoden), in denen der Absturz aufgetreten ist. total_events – die Gesamtzahl der Unfallereignisse während des ausgewählten Zeitraums. total_users — die Anzahl der betroffenen einzigartigen Benutzer. Manchmal kann ein Absturz nur für eine bestimmte Gruppe von Benutzern auftreten. events_info – ein JSON-Array (als Zeichenfolge), das total_events und total_users enthält, die nach App-Version aufgeteilt sind. [ { "version": "1.0.1", "events": 131, "users": 110 }, { "version": "1.2.1", "events": 489, "users": 426 } ] Request crashes Daten aus BigQuery mit Python Um zu starten, installieren Sie die BigQuery Python Client-Bibliothek von Nach der Installation erstellen Sie eine BigQueryExecutor.py-Datei – dieses Modul wird alle Kommunikation mit Google Cloud BigQuery verarbeiten. Pipi Pipi 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) Um mit dem Skript zu beginnen, benötigen Sie nur zwei Dinge: Ein Google-Dienstkonto JSON-Authentifizierungsdatei Der Name (oder die ID) Ihres BigQuery-Projekts Sobald Sie diese haben, können Sie authentifizieren und mit der Ausführung von Abfragen über das Skript beginnen. Google-Dienstkonto JSON Credential Um ein Service-Konto zu erstellen, gehen Sie zu und verleiht ihm die Die Rolle. Die Google Cloud Console BigQuery Data Editor Die Google Cloud Console Sobald das Konto erstellt ist, öffnen Sie es, navigieren Sie zu TAB, Klick und wählen Sie Dadurch wird eine JSON-Authentifizierungsdatei für das Service-Konto generiert und heruntergeladen. “Keys” “Add key” “JSON” Ein JSON-Dienstkonto sieht typischerweise so aus: { "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" } Für Testzwecke können Sie die JSON-Akkreditien in eine einzelne Zeilenfolge konvertieren und direkt in Ihr Skript einbinden. Verwenden Sie einen Secrets Manager, um Ihre Anmeldeinformationen sicher zu speichern und zu verwalten. not recommended for production Sie können auch Ihre bqProjectId aus dem Projekt_id-Feld innerhalb der Anmeldeinformationen JSON extrahieren. Modelle Um mit BigQuery-Daten typsicher zu arbeiten, ist es hilfreich, Datenmodelle zu definieren, die die Struktur der Abfrageergebnisse widerspiegeln. Unten ist ein Beispiel für solche Modellklassen: 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 getCrashlyticsIssues Funktion Und schließlich können wir Daten aus BigQuery abrufen. Fügen Sie die folgende Methode zu Ihrer bestehenden BigQueryExecutor-Klasse hinzu – es wird die SQL-Abfrage ausführen, die früher in der Abschnitt und die Ergebnisse in Modellinstanzen zurückgeben. 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 Jetzt können wir unsere SQL-Anfrage direkt aus Python an BigQuery ausführen. Hier ist ein vollständiges Beispiel, wie Sie die Abfrage ausführen und mit den Ergebnissen arbeiten: 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! 🎉 Jetzt, da wir Crash-Daten von BigQuery abrufen können, können wir auf den nächsten Schritt gehen - die Top 5 häufigsten Crashs zu nehmen und automatisch Jira-Tasks für sie zu erstellen. Holen Sie sich alle Kommissare des Repositoriums und verschmelzen Sie sie Bevor wir Crash-Probleme den Entwicklern zuweisen, müssen wir zuerst potenzielle Eigentümer für jeden Crash identifizieren. Da wir GitHub verwenden, sollten wir uns ein paar spezifische Details bewusst sein: Einige Entwickler können mehrere E-Mail-Adressen über Kommitte verwenden, so dass wir Identitäten fusionieren müssen, wenn zutreffend. GitHub verwendet häufig noreply E-Mails (z. B. username@users.noreply.github.com), also werden wir diese Fälle entsprechend behandeln. Das Hauptziel in diesem Schritt ist es, die Liste der Git-Autoren mit ihren Namen und E-Mails zu extrahieren und zu normalisieren, indem Sie den folgenden Befehl verwenden: git log Unibertsitatea grep '^Author' Unibertsitatea sortieren 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 Im Code unten versuchen wir, verschiedene Commit-Identitäten zu matchen, die wahrscheinlich der gleichen Person angehören - zum Beispiel user@gmail.com und user@users.noreply.github.com. Wir extrahieren und gruppieren auch ihre Namen und GitHub-Benutzernamen (falls verfügbar) für die Bequemlichkeit. Mit dem unten stehenden Skript können Sie diesen Prozess starten und eine gereinigte, deduplizierte Liste aller Committers im Repository erhalten: projectRootPath="/IOS_project_path" blamer = GitBlamer() allUsers = blamer.getAllRepoUsersMap(projectRootPath=projectRootPath) for user in allUsers: print(", ".join(user.nicknames)) Mapping jedes Problem in eine Datei von Repository und Datei-Eigentümer Zu diesem Zeitpunkt haben wir detaillierte Informationen über unsere Crashes und die von ihnen betroffenen Benutzer.Dies ermöglicht es uns, einen bestimmten Crash mit einem bestimmten Benutzer zu assoziieren und automatisch eine entsprechende Jira-Task zu erstellen. Vor der Implementierung der Crash-to-User-Mapping-Logik trennten wir die Workflows für iOS und Android. Diese Plattformen verwenden unterschiedliche Symbolformate, und die Kriterien für die Verknüpfung von Crash-Dateien zu Problemen unterscheiden sich ebenfalls. 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 Die spezifische Implementierung kann je nach Projekt variieren, aber die Hauptaufgabe dieser Klasse besteht darin, festzustellen, ob ein bestimmter Absturz in einer bestimmten Datei aufgetreten ist. Sobald diese Logik vorhanden ist, können wir die Dateien zu Problemen mappen und den entsprechenden Dateigebern zuzuordnen. 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 Alles, was Sie zu diesem Zeitpunkt tun müssen, ist, die GithubMainBranch-Eigenschaft mit dem Link zu Ihrem eigenen Repository zu aktualisieren. Als nächstes sammeln wir Probleme und Datei-Eigentümer, mappen Dateien entsprechend mit dem Code unten und erhalten ein Endergebnis - eine Liste von Problemen, die nach total_users in absteigender Reihenfolge sortiert sind. 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) Erstellen von Jira-Aufgaben für einen Dateiinhaber des Crash Zu diesem Zeitpunkt haben wir alles, was wir brauchen, um mit der Erstellung von Jira-Aufgaben für Crash-Besitzer zu beginnen.Denken Sie jedoch daran, dass die Jira-Konfigurationen zwischen den Unternehmen häufig variieren – benutzerdefinierte Felder, Workflows und Berechtigungen können unterschiedlich sein. Hier sind einige praktische Tipps basierend auf unserer Erfahrung: Konzentrieren Sie sich auf die Top-5-10-Probleme basierend auf der Anzahl der betroffenen Benutzer oder einer bestimmten Auswirkungsgrenze. Persistente Aufgabenmetadaten Speichern Sie Informationen über erstellte Aufgaben in einem persistenten Speicher. Ich verwende BigQuery, speichere Daten in einer separaten Tabelle und aktualisiert sie bei jedem Skriptlauf. Erstellen Sie geschlossene Aufgaben wieder, wenn das Problem in neueren Versionen der App erneut auftritt – dies sorgt dafür, dass Regressionen nicht ignoriert werden. Verknüpfen Sie Aufgaben für das gleiche Problem, um zukünftige Untersuchungen zu vereinfachen und Doppelarbeit zu vermeiden. Fügen Sie so viele Details wie möglich in die Aufgabenbeschreibung ein. Fügen Sie Crash-Aggregationen, betroffene Nutzerzahlen, Versionen usw. hinzu. Link-bezogene Abstürze, wenn sie aus der gleichen Datei stammen – dies bietet zusätzlichen Kontext. Benachrichtigen Sie Ihr Team in Slack (oder einem anderen Messaging-System), wenn neue Aufgaben erstellt werden oder bestehende Aufgaben Aufmerksamkeit benötigen. Verwenden Sie Try/Except Blocks und senden Sie Slack-Benachrichtigungen, wenn etwas fehlschlägt. Cache langsame Operationen während der Entwicklung. z. B. Cache BigQuery Crash Recovery lokal, um die Iteration zu beschleunigen. In diesen Fällen müssen Sie die Aufgabe wahrscheinlich manuell zuweisen, aber es ist immer noch hilfreich, das Jira-Problem automatisch mit vollem Zusammenbruchskontext zu erstellen. Schlussfolgerung Dieses System ermöglicht es uns, täglich Tausende von Unfallberichten zu verarbeiten und sie in wenigen Minuten an den richtigen Entwickler zu leiten – ohne manuelle Arbeit. Wenn Ihr Team in unkategorisierten Crash-Themen ertrinkt - automatisieren Sie es.