Construir una automatización de informes de accidente para iOS y Android

Hola, soy Vilian Iaumbaev! recientemente construí un sistema que maneja automáticamente nuevos informes de accidentes para iOS y Android - hace que el seguimiento y la reparación de problemas sea mucho más fácil. Por qué hicimos esto. Asignar manualmente los accidentes a los desarrolladores adecuados rápidamente se convirtió en una tarea aburrida e insegura.Fue fácil olvidar algo, ignorar casos de borde o saltar problemas complejos.Queríamos hacer el proceso más predecible y sistemático, para que nadie en el equipo tuviese que perder tiempo triando los accidentes, y ningún problema crítico caería a través de las grietas. Resumen Para empezar, necesitarás herramientas de Google como: , de Y también Jira. Crashlytics Google Cloud Platform Crashlytics Plataforma de Google Cloud Una vez que sus proyectos estén configurados en los servicios de Google, configure la transferencia de datos de Crashlytics a GCP utilizando el Después de eso, todos los informes de accidente aparecerán en las tablas de BigQuery. Página de integración Página de integración Las estructuras de datos de accidente para iOS y Android son casi idénticas, con solo algunas pequeñas diferencias, lo que significa que podemos usar un único script para procesar ambos. Así que ahora tienes tus colisiones en BigQuery lo que significa que puedes ejecutar algún trabajo sobre estos datos. Primero necesitamos obtener todos los datos de accidentes para ser analizados, pero si tiene una gran cantidad de datos sobre más de un millón de usuarios, es mejor que preprocesen todos los datos en el lado de Google, hagan algunas agregaciones. El Plan Aprenda algunos SQL básicos para obtener datos de accidente de BigQuery Query crash de datos usando Python Obtener todos los comitentes del repositorio y combinar duplicados Mapar cada problema en un archivo repo y su propietario Crear una tarea Jira para el propietario del archivo, si una tarea ya no existe Aprende algunos básicos de SQL para obtener datos de BigQuery BigQuery utiliza su propio dialecto SQL, que es similar al SQL estándar, pero ofrece una conveniencia adicional para el análisis de datos. Para nuestra integración, necesitamos trabajar con el conjunto de datos completo de accidente, pero en una forma agregada. Especificamente, agrupamos los informes de accidente individuales únicos en firmas de accidente y luego agregamos los datos relevantes dentro de cada grupo, como el número de ocurrencias, el número de usuarios afectados, la fragmentación de la versión y más. Puedes encontrar el script SQL a continuación y probarlo en tu propio entorno a través del siguiente enlace: 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 Como resultado, obtendrá una fila por issue_id único, junto con los siguientes campos agregados: issue_titles — una lista de todos los títulos de crash. Este es un conjunto de casos en los que existen varios títulos únicos para el mismo problema. blame_files — una lista de los mejores archivos de rastreo que causaron el accidente. Esto será no vacío si el accidente ocurrió en su base de código (en lugar de en las bibliotecas del sistema). blame_libraries — una lista de bibliotecas asociadas con el accidente. Esta también es una matriz, construida por razones similares a issue_titles. blame_symbols: una lista de símbolos de código (funciones/métodos) donde ocurrió el accidente. total_events: el número total de accidentes ocurridos durante el período de tiempo seleccionado. total_users — el número de usuarios únicos afectados. A veces un accidente puede ocurrir sólo para un grupo específico de usuarios. events_info — una matriz JSON (como una cadena) que contiene total_events y total_users divididos por versión de la aplicación. [ { "version": "1.0.1", "events": 131, "users": 110 }, { "version": "1.2.1", "events": 489, "users": 426 } ] Request crashes datos de BigQuery usando Python Para comenzar, instale la biblioteca de clientes BigQuery Python desde Después de la instalación, crea un archivo BigQueryExecutor.py - este módulo manejará toda la comunicación con Google Cloud BigQuery. PyPI 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) Para comenzar a usar el script, solo necesitarás dos cosas: Un archivo de credenciales JSON de la cuenta de servicio de Google El nombre (o id) de su proyecto BigQuery Una vez que haya estos, puede autenticar y comenzar a ejecutar consultas a través del script. La cuenta de Google JSON credencial Para crear una cuenta de servicio, vaya a y asignarle el El rol. Google Cloud Console BigQuery Data Editor Consola de nube de Google Una vez que se haya creado la cuenta, abrirla, navegar a la Tab, clic y elegir Esto generará y descargará un archivo de credenciales JSON para la cuenta de servicio. “Keys” “Add key” “JSON” Una cuenta de servicio JSON suele parecer así: { "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" } Para fines de prueba, puede convertir las credenciales de JSON en una cadena de una sola línea e incorporarla directamente a su script. Utilice un Gerente de Secretos para almacenar y gestionar de forma segura sus credenciales. not recommended for production También puede extraer su bqProjectId del campo project_id dentro de las credenciales JSON. Los modelos Para trabajar con los datos de BigQuery de una manera segura de tipo, es útil definir modelos de datos que reflejen la estructura de los resultados de la consulta. Esto le permite escribir código más limpio, más seguro y más mantenible. A continuación se muestra un ejemplo de tales clases de modelos: 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 Funciones de Crashlytics Y por último, podemos recuperar datos de BigQuery. Añade el siguiente método a su clase BigQueryExecutor existente — ejecutará la consulta SQL descrita anteriormente en la Sección y devuelve los resultados parsados en instancias de modelo. Conexión 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 Ahora podemos ejecutar nuestra solicitud SQL a BigQuery directamente desde Python. Aquí está un ejemplo completo de cómo ejecutar la consulta y trabajar con los resultados: 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! 🎉 Ahora que somos capaces de recuperar datos de colisiones de BigQuery, podemos pasar al siguiente paso - tomando las 5 colisiones más frecuentes y creando automáticamente tareas de Jira para ellas. Obtener todos los comisarios del repositorio y fusionarlos Antes de asignar problemas de accidente a los desarrolladores, primero necesitamos identificar a los propietarios potenciales para cada accidente. Dado que estamos utilizando GitHub, debemos ser conscientes de algunos detalles específicos: Algunos desarrolladores pueden usar múltiples direcciones de correo electrónico entre los compromisos, por lo que necesitaremos fusionar las identidades cuando sea necesario. GitHub a menudo utiliza correos electrónicos no necesarios (por ejemplo, username@users.noreply.github.com), por lo que trataremos esos casos en consecuencia. El objetivo principal en este paso es extraer y normalizar la lista de autores de Git con sus nombres y correos electrónicos, usando el siguiente comando: 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 En el código a continuación, intentamos combinar diferentes identidades de compromiso que probablemente pertenezcan a la misma persona, por ejemplo, user@gmail.com y user@users.noreply.github.com. También extraemos y agrupamos sus nombres y nombres de usuario de GitHub (donde están disponibles) por conveniencia. Con el script de abajo, puede iniciar este proceso y obtener una lista limpia y deduplicada de todos los comitentes en el repositorio: projectRootPath="/IOS_project_path" blamer = GitBlamer() allUsers = blamer.getAllRepoUsersMap(projectRootPath=projectRootPath) for user in allUsers: print(", ".join(user.nicknames)) Mapar cada problema a archivo de repositorio y propietario de archivo En este punto, tenemos información detallada sobre nuestros accidentes y los usuarios afectados por ellos. Esto nos permite asociar un accidente específico con un usuario específico y crear automáticamente una tarea Jira correspondiente. Antes de implementar la lógica de mapeo crash-to-user, separamos los flujos de trabajo para iOS y Android.Estas plataformas utilizan diferentes formatos de símbolos, y los criterios para vincular los archivos de crash a los problemas también difieren.Para manejar esto limpiamente, introducimos una clase abstracta con implementaciones específicas de la plataforma, lo que nos permite encapsular las diferencias y resolver el problema de una manera estructurada. 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 La implementación específica puede variar dependiendo de su proyecto, pero la principal responsabilidad de esta clase es determinar si un accidente dado ocurrió en un archivo en particular. Una vez que esta lógica esté en su lugar, podemos proceder a mapear los archivos a los problemas y asignarlos a los propietarios de archivos correspondientes. 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 Todo lo que necesita hacer en este momento es actualizar la propiedad githubMainBranch con el enlace a su propio repositorio. A continuación, recopilamos los problemas y los propietarios de archivos, mapeamos los archivos en consecuencia utilizando el código de abajo, y obtenemos un resultado final: una lista de problemas ordenados por total_users en orden descendente. 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) Crear una tarea de Jira para un propietario del archivo del accidente En este punto, tenemos todo lo que necesitamos para comenzar a crear tareas de Jira para los propietarios de accidentes. Sin embargo, tenga en cuenta que las configuraciones de Jira a menudo varían entre las empresas: los campos personalizados, los flujos de trabajo y los permisos pueden variar. Aquí hay algunos consejos prácticos basados en nuestra experiencia: No crea tareas para cada problema.Concentrarse en los 5 a 10 principales problemas basados en el número de usuarios afectados o un cierto umbral de impacto. Mantenga la información sobre las tareas creadas en un almacenamiento persistente.Uso BigQuery, guardando los datos en una tabla separada y actualizándolos en cada ejecución de scripts. Recrear tareas cerradas si el problema se repite en versiones más recientes de la aplicación, lo que garantiza que las regresiones no se ignoren. Enlazar tareas para el mismo problema para simplificar futuras investigaciones y evitar la duplicación. Incluya el mayor detalle posible en la descripción de la tarea.Añade agregaciones de colisiones, números de usuarios afectados, versiones, etc. Los problemas relacionados con los enlaces si proceden del mismo archivo, esto proporciona un contexto adicional. Notifica a tu equipo en Slack (o otro sistema de mensajería) cuando se creen nuevas tareas o las existentes necesiten atención. Incluya enlaces útiles al informe de accidente, tareas, archivos GitHub relevantes, etc. Use try/except blocks y envíe alertas de Slack cuando algo falla. Cache operaciones lentas durante el desarrollo. Por ejemplo, cache BigQuery recupera fallos localmente para acelerar la iteración. En esos casos, es probable que necesite asignar manualmente la tarea, pero todavía es útil crear el problema Jira automáticamente con el contexto completo del accidente. Conclusión Este sistema nos permite procesar miles de informes de accidentes diariamente y dirigirlos al desarrollador correcto en solo unos minutos, sin ningún trabajo manual. Si tu equipo se ahoga en problemas de accidente sin categorizar, automatízalo.