Comprender los bloqueos de un juego de Unity utilizando funciones avanzadas de Crashlytics,Comprender los bloqueos de un juego de Unity utilizando funciones avanzadas de Crashlytics

1. Introducción

En este codelab, aprenderá a utilizar funciones avanzadas de Crashlytics que le brindarán una mejor visibilidad de los bloqueos y las circunstancias que podrían haberlos causado.

Agregarás nuevas funciones a un juego de muestra, MechaHamster: Level Up with Firebase Edition . Este juego de muestra es una nueva versión del clásico juego de Firebase, MechaHamster, que elimina la mayor parte de su funcionalidad integrada de Firebase, lo que te brinda la oportunidad de implementar nuevos usos de Firebase en su lugar.

Agregarás un menú de depuración al juego. Este menú de depuración llama a los métodos que crearás y te permite ejercitar las diferentes funcionalidades de Crashlytics. Estos métodos le mostrarán cómo anotar sus informes automáticos de fallos con claves personalizadas, registros personalizados, errores no fatales y más.

Después de desarrollar el juego, utilizarás el menú de depuración e inspeccionarás los resultados para comprender la vista única que brindan sobre cómo se ejecuta tu juego en la naturaleza.

lo que aprenderás

• Los tipos de errores que Crashlytics detecta automáticamente.
• Errores adicionales que se pueden registrar intencionalmente.
• Cómo agregar más información a estos errores para que sean más fáciles de entender.

Lo que necesitarás

• Unity (versión mínima recomendada 2019+) con uno o ambos de los siguientes:
  • Soporte de compilación de iOS
  • Soporte de compilación de Android
• (Solo para Android) Firebase CLI (utilizado para cargar símbolos para informes de fallos)
  • Siga las instrucciones para instalar Firebase CLI .
    Si ya instaló la CLI, asegúrese de actualizar a su última versión .

2. Configure su entorno de desarrollo

Las siguientes secciones describen cómo descargar el código Level Up with Firebase y abrirlo en Unity.

Tenga en cuenta que este juego de muestra Level Up with Firebase lo utilizan varios otros codelabs de Firebase + Unity, por lo que es posible que ya haya completado las tareas de esta sección. Si es así, puede ir directamente al último paso de esta página: "Agregar SDK de Firebase para Unity".

Descarga el código

Clona el repositorio GitHub de este codelab desde la línea de comando:

git clone https://github.com/firebase/level-up-with-firebase.git

Alternativamente, si no tienes git instalado, puedes descargar el repositorio como un archivo ZIP .

Abra Level Up con Firebase en el editor de Unity

1. Inicie Unity Hub y, desde la pestaña Proyectos , haga clic en la flecha desplegable junto a Abrir .
2. Haga clic en Agregar proyecto desde el disco .
3. Navegue hasta el directorio que contiene el código y luego haga clic en Aceptar .
4. Si se le solicita, seleccione una versión del editor de Unity para usar y su plataforma de destino (Android o iOS).
5. Haga clic en el nombre del proyecto, subir de nivel con firebase , y el proyecto se abrirá en el editor de Unity.
6. Si su editor no lo abre automáticamente, abra MainGameScene en Activos > Hamster en la pestaña Proyecto del Editor de Unity.
   

Para obtener más información sobre la instalación y el uso de Unity, consulte Trabajar en Unity .

3. Agrega Firebase a tu proyecto de Unity

Crear un proyecto de Firebase

1. En Firebase console , haz clic en Agregar proyecto .
2. Para crear un nuevo proyecto, ingrese el nombre del proyecto deseado.
   Esto también establecerá el ID del proyecto (que se muestra debajo del nombre del proyecto) en algo basado en el nombre del proyecto. Opcionalmente, puede hacer clic en el icono de edición en el ID del proyecto para personalizarlo aún más.
3. Si se te solicita, revisa y acepta los términos de Firebase .
4. Haga clic en Continuar .
5. Seleccione la opción Habilitar Google Analytics para este proyecto y luego haga clic en Continuar .
6. Seleccione una cuenta de Google Analytics existente para usar o seleccione Crear una cuenta nueva para crear una cuenta nueva.
7. Haga clic en Crear proyecto .
8. Cuando se haya creado el proyecto, haga clic en Continuar .

Registra tu aplicación con Firebase

1. Aún en Firebase console , desde el centro de la página de descripción general del proyecto, haz clic en el ícono de Unity para iniciar el flujo de trabajo de configuración o, si ya agregaste una aplicación a tu proyecto de Firebase, haz clic en Agregar aplicación para mostrar las opciones de la plataforma.
2. Seleccione para registrar los objetivos de compilación de Apple (iOS) y Android.
3. Ingrese los ID específicos de la plataforma de su proyecto de Unity. Para este codelab, ingresa lo siguiente:
   • Para Apple (iOS) : ingrese com.google.firebase.level-up en el campo ID del paquete de iOS .
   • Para Android : ingrese com.google.firebase.level_up en el campo de nombre del paquete de Android .

   Importante : El ID del paquete de iOS y el nombre del paquete de Android anteriores son diferentes . El identificador de iOS no es válido para Android y viceversa. Asegúrate de estar utilizando el identificador correcto.

4. (Opcional) Ingrese los apodos específicos de la plataforma de su proyecto de Unity.
5. Haga clic en Registrar aplicación y luego vaya a la sección Descargar archivo de configuración .

Agregar archivos de configuración de Firebase

Después de hacer clic en Registrar aplicación , se le pedirá que descargue dos archivos de configuración (un archivo de configuración para cada destino de compilación). Tu proyecto de Unity necesita los metadatos de Firebase en estos archivos para conectarse con Firebase.

1. Descargue ambos archivos de configuración disponibles:
   • Para Apple (iOS) : descargue GoogleService-Info.plist .
   • Para Android : descargue google-services.json .
2. Abra la ventana Proyecto de su proyecto de Unity, luego mueva ambos archivos de configuración a la carpeta Activos .

   Importante: Incluso si planeas crear solo iOS o Android, debes descargar ambos archivos y agregarlos a tu proyecto.

3. De vuelta en Firebase console, en el flujo de trabajo de configuración, haga clic en Siguiente y continúe con Agregar SDK de Firebase para Unity.

Nota: Siempre puedes volver a descargar estos archivos más adelante abriendo la configuración general de tu proyecto, desplazándote hacia abajo hasta la sección Tus aplicaciones y luego haciendo clic en el botón de descarga del archivo de configuración deseado.

Agregar SDK de Firebase para Unity

1. Haga clic en Descargar Firebase Unity SDK en Firebase console.

   Nota: Es posible que este SDK tarde un poco en descargarse. Tomen un café o un té y manténganse hidratados, amigos míos.

2. Descomprima el SDK en algún lugar conveniente.
3. En su proyecto Unity abierto, navegue hasta Activos > Importar paquete > Paquete personalizado .
4. En el cuadro de diálogo Importar paquete , navegue hasta el directorio que contiene el SDK descomprimido, seleccione FirebaseAnalytics.unitypackage y luego haga clic en Abrir .
5. En el cuadro de diálogo Importar paquete de Unity que aparece, haga clic en Importar .
6. Repita los pasos anteriores para importar FirebaseCrashlytics.unitypackage .
7. Regrese a Firebase console y, en el flujo de trabajo de configuración, haga clic en Siguiente .

Para obtener más información sobre cómo agregar SDK de Firebase a proyectos de Unity, consulte Opciones de instalación adicionales de Unity .

4. Configura Crashlytics en tu proyecto de Unity

Para usar Crashlytics en proyectos de Unity, deberá realizar algunos pasos de configuración más. Por supuesto, necesitarás inicializar el SDK. Pero también deberá cargar sus símbolos para poder ver los seguimientos de pila simbolizados en Firebase console y deberá forzar una prueba de bloqueo para asegurarse de que Firebase reciba sus eventos de bloqueo.

Inicializar el SDK de Crashlytics

1. En Assets/Hamster/Scripts/MainGame.cs , agregue las siguientes instrucciones using :

   using Firebase.Crashlytics;
   using Firebase.Extensions;
   

   El primer módulo le permite usar métodos del SDK de Crashlytics y el segundo contiene algunas extensiones de la API de tareas de C# . Sin ambos using declaraciones, el siguiente código no funcionará.
2. Aún en MainGame.cs , agregue la inicialización de Firebase al método Start() existente llamando a InitializeFirebaseAndStartGame() :

   void Start()
   {
     Screen.SetResolution(Screen.width / 2, Screen.height / 2, true);
     InitializeFirebaseAndStartGame();
   }
   

3. Y nuevamente, en MainGame.cs , busque InitializeFirebaseAndStartGame() , declare una variable de aplicación y luego sobrescriba la implementación del método de esta manera:

   public Firebase.FirebaseApp app = null;
   
   // Begins the firebase initialization process and afterwards, opens the main menu.
   private void InitializeFirebaseAndStartGame()
   {
     Firebase.FirebaseApp.CheckAndFixDependenciesAsync()
     .ContinueWithOnMainThread(
       previousTask => 
       {
         var dependencyStatus = previousTask.Result;
         if (dependencyStatus == Firebase.DependencyStatus.Available) {
           // Create and hold a reference to your FirebaseApp,
           app = Firebase.FirebaseApp.DefaultInstance;
           // Set the recommended Crashlytics uncaught exception behavior.
           Crashlytics.ReportUncaughtExceptionsAsFatal = true;
           InitializeCommonDataAndStartGame();
         } else {
           UnityEngine.Debug.LogError(
             $"Could not resolve all Firebase dependencies: {dependencyStatus}\n" +
             "Firebase Unity SDK is not safe to use here");
         }
       });
   }
   

Colocar la lógica de inicialización aquí evita la interacción del jugador antes de que se inicialicen las dependencias de Firebase.

Los beneficios y efectos de informar excepciones no controladas como fatales se analizan en las preguntas frecuentes de Crashlytics .

Construye tu proyecto y sube símbolos

Nota: Complete los pasos de esta sección para configurar Crashlytics. Luego, en el futuro, completa estos pasos cada vez que crees una compilación de lanzamiento o cualquier compilación para la cual quieras ver seguimientos de pila simbolizados en Firebase console (en este codelab, después de cada paso).

Los pasos para crear y cargar símbolos son diferentes para las aplicaciones de iOS y Android.

iOS+ (plataforma Apple)

1. Desde el cuadro de diálogo Configuración de compilación , exporte su proyecto a un espacio de trabajo de Xcode.
2. Crea tu aplicación.
   Para las plataformas Apple, el complemento Firebase Unity Editor configura automáticamente su proyecto Xcode para generar y cargar un archivo de símbolos compatible con Crashlytics en los servidores de Firebase para cada compilación. Esta información de símbolos es necesaria para ver seguimientos de pila simbolizados en el panel de Crashlytics.

Androide

1. (solo durante la configuración inicial, no para cada compilación) Configure su compilación:
   1. Cree una nueva carpeta llamada Builds en la raíz del directorio de su proyecto (es decir, como un hermano de su directorio de Activos ) y luego cree una subcarpeta llamada Android .
   2. En Archivo > Configuración de compilación > Configuración del reproductor > Configuración , establezca Scripting Backend en IL2CPP.
      • IL2CPP generalmente hace que las compilaciones sean más pequeñas y tengan mejor rendimiento.
      • IL2CPP también es la ÚNICA opción disponible en iOS y seleccionarla aquí permite que las dos plataformas tengan una mejor paridad y simplifique las diferencias de depuración entre las dos (si elige compilar ambas).
2. Crea tu aplicación. En Archivo > Configuración de compilación , complete lo siguiente:
   1. Asegúrese de que Crear símbolos.zip esté marcado (o si se presenta con un menú desplegable, seleccione Depurar ).
   2. Cree su APK directamente desde Unity Editor en la subcarpeta Builds/Android que acaba de crear.
3. Una vez que haya finalizado la compilación, deberá generar un archivo de símbolos compatible con Crashlytics y cargarlo en los servidores de Firebase. Esta información de símbolos es necesaria para ver seguimientos de pila simbolizados para fallas de la biblioteca nativa en el panel de Crashlytics.
   
   Genere y cargue este archivo de símbolos ejecutando el siguiente comando de Firebase CLI :

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

   • FIREBASE_APP_ID : el ID de tu aplicación Firebase para Android (no el nombre de tu paquete). Busque este valor en el archivo google-services.json que descargó anteriormente. Es el valor mobilesdk_app_id .
     Ejemplo de ID de aplicación de Firebase para Android: 1:567383003300:android:17104a2ced0c9b9b
   • PATH/TO/SYMBOLS : la ruta del archivo de símbolos comprimido generado en el directorio Builds/Android cuando finalizó la compilación (por ejemplo: Builds/Android/myapp-1.0-v100.symbols.zip ).

     Nota: Este nombre de archivo cambiará a medida que el proyecto se cree con diferentes números configurados para Version y Bundle Version Code en Archivo > Configuración de compilación > Configuración del reproductor > Identificación .

Forzar un bloqueo de prueba para finalizar la configuración

Para terminar de configurar Crashlytics y ver los datos iniciales en el panel de Crashlytics de Firebase console, debes forzar una prueba de bloqueo.

1. En MainGameScene, busque el objeto vacío GameObject en el editor Hierarchy , agréguele el siguiente script y luego guarde la escena. Este script provocará un bloqueo de la prueba unos segundos después de ejecutar la aplicación.

   using System;
   using UnityEngine;
   
   public class CrashlyticsTester : MonoBehaviour {
       // Update is called once per frame
       void Update()
       {
           // Tests your Crashlytics implementation by
           // throwing an exception every 60 frames.
           // You should see reports in the Firebase console
           // a few minutes after running your app with this method.
           if(Time.frameCount >0 && (Time.frameCount%60) == 0)
           {
               throw new System.Exception("Test exception; please ignore");
           }
       }
   }
   

2. Cree su aplicación y cargue información de símbolos una vez finalizada la compilación.
   • iOS : el complemento Firebase Unity Editor configura automáticamente su proyecto Xcode para cargar su archivo de símbolos.
   • Android : ejecute el comando crashlytics:symbols:upload Firebase CLI para cargar su archivo de símbolos.

   Nota: Si es la primera vez que creas para un objetivo móvil en particular, este tiempo de construcción podría ser de varios minutos. Las compilaciones posteriores serán mucho más rápidas.

3. Ejecute su aplicación. Una vez que su aplicación se esté ejecutando, observe el registro del dispositivo y espere a que se active la excepción desde CrashlyticsTester .
   • iOS : vea los registros en el panel inferior de Xcode.
   • Android : vea registros ejecutando el siguiente comando en la terminal: adb logcat .
4. ¡Visite el panel de Crashlytics para ver la excepción! Lo verá en la tabla Problemas en la parte inferior del panel. Más adelante en el codelab, aprenderá más sobre cómo explorar estos informes.
5. Una vez que hayas confirmado que el evento se cargó en Crashlytics, selecciona el GameObject vacío al que lo adjuntaste, elimina solo el componente CrashlyticsTester y luego guarda la escena para restaurarla a su condición original.

5. Habilite y comprenda el menú de depuración.

Hasta ahora, agregó Crashlytics a su proyecto de Unity, finalizó la configuración y confirmó que el SDK de Crashlytics está cargando eventos en Firebase. Ahora crearás un menú en tu proyecto de Unity que demostrará cómo usar la funcionalidad Crashlytics más avanzada en tu juego. El proyecto Level Up with Firebase Unity ya tiene un menú de depuración oculto que harás visible y para el que escribirás la funcionalidad.

Habilitar el menú de depuración

El botón para acceder al menú Depurar existe en su proyecto de Unity, pero no está habilitado actualmente. Debes habilitar el botón para acceder desde el prefabricado MainMenu :

1. En Unity Editor, abra el prefabricado llamado MainMenu .
2. En la jerarquía prefabricada, busque el subobjeto deshabilitado llamado DebugMenuButton y luego selecciónelo.
3. Habilite DebugMenuButton marcando la casilla en la esquina superior izquierda a la izquierda del campo de texto que contiene DebugMenuButton .
4. Guarde la casa prefabricada.
5. Ejecute el juego en el editor o en su dispositivo. El menú ahora debería ser accesible.

Importante : dado que los métodos de bloqueo no están implementados actualmente, al tocar sus respectivos botones se generará una System.NotImplementedException y, de lo contrario, no se hará nada.

Obtenga una vista previa y comprenda los cuerpos de los métodos para el menú de depuración.

Más adelante en este codelab, escribirás cuerpos de métodos para algunos métodos de depuración preconfigurados de Crashlytics. Sin embargo, en el proyecto Level Up with Firebase Unity, los métodos se definen y se llaman desde DebugMenu.cs .

Si bien algunos de estos métodos llamarán a métodos de Crashlytics y arrojarán errores, la capacidad de Crashlytics para detectar estos errores no depende de llamar a esos métodos primero. Más bien, los informes de fallos generados a partir de la detección automática de errores se mejorarán con la información agregada por estos métodos.

Abra DebugMenu.cs y luego busque los siguientes métodos:

Métodos para generar y anotar problemas de Crashlytics:

• CrashNow
• LogNonfatalError
• LogStringsAndCrashNow
• SetAndOverwriteCustomKeyThenCrash
• SetLogsAndKeysBeforeANR

Métodos para registrar eventos de Analytics para ayudar en la depuración:

• LogProgressEventWithStringLiterals
• LogIntScoreWithBuiltInEventAndParams

En pasos posteriores de este codelab, implementará estos métodos y aprenderá cómo ayudan a abordar situaciones específicas que pueden ocurrir en el desarrollo de juegos.

6. Garantizar la entrega de informes de fallos en desarrollo.

Antes de comenzar a implementar estos métodos de depuración y ver cómo afectan los informes de fallos, asegúrese de comprender cómo se informan los eventos a Crashlytics.

Para proyectos de Unity, los eventos de fallas y excepciones en tu juego se escriben inmediatamente en el disco. Para las excepciones no detectadas que no bloquean el juego (por ejemplo, excepciones de C# no detectadas en la lógica del juego), puedes hacer que el SDK de Crashlytics las informe como eventos fatales configurando la propiedad Crashlytics.ReportUncaughtExceptionsAsFatal en true cuando inicializas Crashlytics en tu proyecto de Unity. . Estos eventos se informan a Crashlytics en tiempo real sin necesidad de que el usuario final reinicie el juego. Tenga en cuenta que los fallos nativos siempre se informan como eventos fatales y se envían cuando un usuario final reinicia el juego.

Nota: Para informar excepciones no detectadas como eventos fatales, su proyecto de Unity debe usar Firebase Crashlytics Unity SDK v10.4.0 y versiones posteriores.

Además, tenga en cuenta las siguientes pequeñas (pero significativas) diferencias entre cómo los distintos entornos de ejecución envían información de Crashlytics a Firebase:

Simulador de iOS:

• La información de Crashlytics se informa si y solo si desconecta Xcode del simulador. Si se adjunta Xcode, detecta los errores en sentido ascendente, impidiendo la entrega de información.

Dispositivos físicos móviles (Android e iOS):

• Específico de Android: los ANR solo se informan en Android 11+. Los ANR y los eventos no fatales se informan en la siguiente ejecución.

Editor de unidad:

• La información de Crashlytics del editor en modo de reproducción o en modo independiente NO se registra ni se carga en Firebase. Además, el flujo de trabajo de desarrollo de Firebase Desktop no es compatible con Crashlytics .

Prueba a bloquear tu juego con solo tocar un botón en CrashNow()

Después de configurar Crashlytics en tu juego, el SDK de Crashlytics registra automáticamente los fallos y las excepciones no detectadas y los sube a Firebase para su análisis. Y los informes se muestran en el panel de Crashlytics en Firebase console.

1. Para demostrar que esto es realmente automático: abra DebugMenu.cs y luego sobrescriba el método CrashNow() de la siguiente manera:

   void CrashNow()
   {
       TestCrash();
   }
   

2. Crea tu aplicación.
3. (Solo Android) Cargue sus símbolos ejecutando el siguiente comando de Firebase CLI:

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

4. Toque el botón Crash Now y continúe con el siguiente paso de este codelab para descubrir cómo ver e interpretar el informe de fallos.

7. Comprender los informes de problemas en Firebase console

Cuando se trata de ver sus informes de fallos, hay un poco más que necesita saber sobre cómo aprovecharlos al máximo. Cada uno de los métodos que escriba mostrará cómo agregar diferentes tipos de información a los informes de Crashlytics.

1. Toque el botón Crash Now y luego reinicie su aplicación.
2. Vaya al panel de Crashlytics . Desplácese hacia abajo hasta la tabla Problemas en la parte inferior del panel, donde Crashlytics agrupa los eventos que tienen la misma causa raíz en "problemas".
3. Haga clic en el nuevo problema que aparece en la tabla Problemas . Al hacer esto, se muestra el resumen del evento sobre cada evento individual que se envió a Firebase.
   
   Deberías ver algo como la siguiente captura de pantalla. Observe cómo el resumen del evento presenta de manera destacada el seguimiento de la pila de la llamada que provocó el bloqueo.

Metadatos adicionales

Otra pestaña útil es la pestaña Metadatos de Unity . Esta sección le informa sobre los atributos del dispositivo en el que ocurrió el evento, incluidas las características físicas, el modelo/especificaciones de la CPU y todo tipo de métricas de GPU.

A continuación se muestra un ejemplo en el que la información de esta pestaña podría resultar útil:
Imagine que su juego hace un uso intensivo de sombreadores para lograr una apariencia determinada, pero no todos los teléfonos tienen GPU que sean capaces de representar esta función. La información en la pestaña Metadatos de Unity puede brindarle una mejor idea de qué hardware debe probar su aplicación al decidir qué funciones poner a disposición automáticamente o deshabilitar por completo.

Si bien es posible que nunca se produzca un error o una falla en su dispositivo, debido a la enorme diversidad de dispositivos Android existentes, es útil comprender mejor los "puntos de acceso" particulares de los dispositivos de su audiencia.

8. Lanzar, capturar y registrar una excepción

A menudo, como desarrollador, incluso si su código detecta y maneja adecuadamente una excepción de tiempo de ejecución, es bueno tener en cuenta qué ocurrió y bajo qué circunstancias. Crashlytics.LogException se puede utilizar exactamente para este propósito: enviar un evento de excepción a Firebase para que puedas depurar aún más el problema en Firebase console.

1. En Assets/Hamster/Scripts/States/DebugMenu.cs , agregue lo siguiente a las instrucciones using :

   // Import Firebase
   using Firebase.Crashlytics;
   

2. Aún en DebugMenu.cs , sobrescriba LogNonfatalError() de la siguiente manera:

   void LogNonfatalError()
   {
       try
       {
           throw new System.Exception($"Test exception thrown in {nameof(LogNonfatalError)}");
       }
       catch(System.Exception exception)
       {
           Crashlytics.LogException(exception);
       }
   }
   

3. Crea tu aplicación.
4. (Solo Android) Cargue sus símbolos ejecutando el siguiente comando de Firebase CLI:

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

5. Toque el botón Registrar error no fatal y luego reinicie su aplicación.
6. Vaya al panel de Crashlytics y debería ver algo similar a lo que vio en el último paso de este codelab.
7. Esta vez, sin embargo, restrinja el filtro de tipo de evento a No fatales para que solo vea errores no fatales, como el que acaba de registrar.
   

9. Registre cadenas en Crashlytics para comprender mejor el flujo de ejecución del programa.

¿Alguna vez ha intentado descubrir por qué una línea de código que se llama desde múltiples rutas, cientos, si no miles, de veces por sesión, puede generar repentinamente una excepción o un bloqueo? Si bien podría ser bueno revisar el código en un IDE y observar los valores más de cerca, ¿qué pasa si esto sucede solo entre un porcentaje cada vez más pequeño de sus usuarios? Peor aún, ¿qué harías si no puedes replicar este accidente sin importar lo que hagas?

En situaciones como esta, tener algo de contexto puede marcar una gran diferencia. Con Crashlytics.Log , tienes la capacidad de escribir el contexto que necesitas. Piensa en estos mensajes como pistas para tu yo futuro sobre lo que podría estar pasando.

Si bien los registros se pueden utilizar de innumerables maneras, suelen ser más útiles para registrar situaciones en las que el orden y/o la ausencia de llamadas es un dato de vital importancia.

1. En Assets/Hamster/Scripts/States/DebugMenu.cs , sobrescriba LogStringsAndCrashNow() de la siguiente manera:

   void LogStringsAndCrashNow()
   {
       Crashlytics.Log($"This is the first of two descriptive strings in {nameof(LogStringsAndCrashNow)}");
       const bool RUN_OPTIONAL_PATH = false;
       if(RUN_OPTIONAL_PATH)
       {
           Crashlytics.Log(" As it stands, this log should not appear in your records because it will never be called.");
       }
       else
       {
           Crashlytics.Log(" A log that will simply inform you which path of logic was taken. Akin to print debugging.");
       }
       Crashlytics.Log($"This is the second of two descriptive strings in {nameof(LogStringsAndCrashNow)}");
       TestCrash();
   }
   

2. Crea tu aplicación.
3. (Solo Android) Cargue sus símbolos ejecutando el siguiente comando de Firebase CLI:

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

4. Toque el botón Log Strings and Crash Now y luego reinicie su aplicación.
5. Vuelva al panel de Crashlytics y haga clic en el problema más reciente que figura en la tabla Problemas . Nuevamente deberías ver algo similar a los números anteriores.
   
6. Sin embargo, si hace clic en la pestaña Registros dentro de un resumen de eventos , obtendrá una vista como esta:
   

Nota: Estos registros son útiles no solo por su mensaje, sino también por las marcas de tiempo, que le ayudan a comprender el orden en que se generaron.

Importante: Para evitar ralentizar su aplicación, Crashlytics limita los registros a 64 KB y elimina las entradas de registro más antiguas cuando el registro de una sesión supera ese límite.

10. Escribe y sobrescribe una clave personalizada.

Supongamos que desea comprender mejor un bloqueo correspondiente a variables establecidas en una pequeña cantidad de valores o configuraciones. Sería bueno poder filtrar, según la combinación de variables y posibles valores que esté viendo, en un momento dado.

Además de registrar cadenas arbitrarias, Crashlytics ofrece otra forma de depuración cuando es beneficioso conocer el estado exacto de su programa cuando falla: claves personalizadas.

Estos son pares clave-valor que puede configurar para una sesión. A diferencia de los registros que se acumulan y son puramente aditivos, las claves se pueden sobrescribir para reflejar únicamente el estado más reciente de una variable o condición.

Además de ser un libro de contabilidad del último estado registrado de su programa, estas claves se pueden utilizar como filtros potentes para problemas de Crashlytics.

1. En Assets/Hamster/Scripts/States/DebugMenu.cs , sobrescriba SetAndOverwriteCustomKeyThenCrash() de la siguiente manera:

   void SetAndOverwriteCustomKeyThenCrash()
   {
       const string CURRENT_TIME_KEY = "Current Time";
       System.TimeSpan currentTime = System.DateTime.Now.TimeOfDay;
       Crashlytics.SetCustomKey(
           CURRENT_TIME_KEY,
           DayDivision.GetPartOfDay(currentTime).ToString() // Values must be strings
           );
   
       // Time Passes
       currentTime += DayDivision.DURATION_THAT_ENSURES_PHASE_CHANGE;
   
       Crashlytics.SetCustomKey(
           CURRENT_TIME_KEY,
           DayDivision.GetPartOfDay(currentTime).ToString()
           );
       TestCrash();
   }
   

2. Crea tu aplicación.
3. (Solo Android) Cargue sus símbolos ejecutando el siguiente comando de Firebase CLI:

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

4. Toque el botón Establecer clave personalizada y bloqueo y luego reinicie su aplicación.
5. Vuelva al panel de Crashlytics y haga clic en el problema más reciente que figura en la tabla Problemas . Nuevamente deberías ver algo similar a los números anteriores.
6. Esta vez, sin embargo, haga clic en la pestaña Claves en el resumen del evento para que pueda ver el valor de las claves, incluida Current Time :
   

   Importante : Crashlytics solo completa automáticamente la clave de crash_info_entry_0 cuando el simulador de iOS ejecuta su aplicación.

¿Por qué querrías utilizar claves personalizadas en lugar de registros personalizados?

• Los registros son buenos para almacenar datos secuenciales, pero las claves personalizadas son mejores si solo desea el valor más reciente .
• En Firebase console, puedes filtrar fácilmente los problemas por los valores de las claves en el cuadro de búsqueda de la tabla de problemas .

Sin embargo, al igual que los registros, las claves personalizadas tienen un límite. Crashlytics admite un máximo de 64 pares clave-valor. Una vez alcanzado este umbral, no se guardan valores adicionales. Cada par clave-valor puede tener un tamaño de hasta 1 KB.

11. (Solo Android) Utilice claves y registros personalizados para comprender y diagnosticar un ANR

Importante : la siguiente clase de problema está relacionada principalmente con Android 11 y versiones posteriores. Si esto no coincide con su caso de uso de desarrollo, omita esta sección.

Una de las clases de problemas más difíciles de depurar para los desarrolladores de Android es el error La aplicación no responde (ANR). Los ANR ocurren cuando una aplicación no responde a una entrada durante más de 5 segundos. Si esto sucede, significa que la aplicación se congeló o va muy lentamente. Se muestra un cuadro de diálogo a los usuarios y pueden elegir entre "Esperar" o "Cerrar aplicación".

Los ANR son una mala experiencia para el usuario y (como se menciona en el enlace ANR anterior) pueden afectar la visibilidad de su aplicación en Google Play Store. Debido a su complejidad y a que a menudo son causados ​​por código multiproceso con comportamiento muy diferente en diferentes modelos de teléfono, reproducir ANR durante la depuración suele ser muy difícil, si no casi imposible. Como tal, abordarlos analítica y deductivamente suele ser el mejor enfoque.

En este método, usaremos una combinación de Crashlytics.LogException , Crashlytics.Log y Crashlytics.SetCustomKey para complementar el registro automático de problemas y brindarnos más información.

Importante: tenga en cuenta que el código de bloqueo se ejecuta en el hilo de la interfaz de usuario de UnityPlayerActivity . Esto es algo antinatural en Unity, ya que el hilo no es el mismo que el hilo principal de Unity, que es el lugar predeterminado donde se ejecuta el código del juego. Los ANR pueden ser especialmente difíciles de depurar porque pueden ser causados ​​por complementos u otro código que se ejecuta de forma no idiomática en el subproceso de la interfaz de usuario.

1. En Assets/Hamster/Scripts/States/DebugMenu.cs , sobrescriba SetLogsAndKeysBeforeANR() de la siguiente manera:

   void SetLogsAndKeysBeforeANR()
   {
       System.Action<string,long> WaitAndRecord =
       (string methodName, long targetCallLength)=>
       {
           System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
           const string CURRENT_FUNCTION = "Current Async Function";
   
           // Initialize key and start timing
           Crashlytics.SetCustomKey(CURRENT_FUNCTION, methodName);
           stopWatch.Start();
   
           // The actual (simulated) work being timed.
           BusyWaitSimulator.WaitOnSimulatedBlockingWork(targetCallLength);
   
           // Stop timing
           stopWatch.Stop();
   
           if(stopWatch.ElapsedMilliseconds>=BusyWaitSimulator.EXTREME_DURATION_MILLIS)
           {
             Crashlytics.Log($"'{methodName}' is long enough to cause an ANR.");
           }
           else if(stopWatch.ElapsedMilliseconds>=BusyWaitSimulator.SEVERE_DURATION_MILLIS)
           {
             Crashlytics.Log($"'{methodName}' is long enough it may cause an ANR");
           }
       };
   
       WaitAndRecord("DoSafeWork",1000L);
       WaitAndRecord("DoSevereWork",BusyWaitSimulator.SEVERE_DURATION_MILLIS);
       WaitAndRecord("DoExtremeWork",2*BusyWaitSimulator.EXTREME_DURATION_MILLIS);
   }
   

2. Crea tu aplicación.
3. Cargue sus símbolos ejecutando el siguiente comando de Firebase CLI:

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

4. Toque el botón etiquetado Establecer registros y claves → ANR y luego reinicie su aplicación.
5. Vuelva al panel de Crashlytics y luego haga clic en el nuevo problema en la tabla Problemas para ver el resumen del evento . Si la llamada se realizó correctamente, debería ver algo como esto:
   
   
   Como puede ver, Firebase identificó la espera ocupada en el hilo como la razón principal por la que su aplicación activó un ANR.
   
6. Si observa los registros en la pestaña Registros del resumen de eventos , verá que el último método registrado como completo es DoSevereWork .
   
   
   Por el contrario, el último método listado como inicial es DoExtremeWork , lo que indica que el ANR ocurrió durante este método y el juego se cerró antes de que pudiera iniciar sesión en DoExtremeWork .
   
   

Importante : si no ve un ANR en Android y en su lugar ve un error que menciona una InvalidOperationException , lea los registros. Este error personalizado se incluye como parte de este codelab. Siga las instrucciones (registradas por la excepción) para solucionarlo. Reconstruya, implemente e itere y eventualmente obtendrá el error deseado.

¿Por qué hacer esto?

• Reproducir ANR es increíblemente difícil, por lo que poder obtener información valiosa sobre el área del código y las métricas es increíblemente importante para descubrirlo deductivamente.
• Con la información almacenada en las claves personalizadas, ahora sabe qué subproceso asíncrono tardó más en ejecutarse y cuáles estaban en peligro de activar ANR. Este tipo de datos lógicos y numéricos relacionados le mostrarán en qué parte de su código es más necesario optimizar.

12. Intercalar eventos de Analytics para enriquecer aún más los informes

Los siguientes métodos también se pueden llamar desde el menú de depuración, pero en lugar de generar problemas por sí mismos, utilizan Google Analytics como otra fuente de información para comprender mejor el funcionamiento de tu juego.

A diferencia de los otros métodos que has escrito en este codelab, debes utilizar estos métodos en combinación con los demás. Llame a estos métodos (presionando su botón correspondiente en el menú de depuración) en el orden arbitrario que desee antes de ejecutar uno de los demás. Luego, cuando examine la información del problema específico de Crashlytics, verá un registro ordenado de eventos de Analytics. Estos datos se pueden utilizar en un juego para comprender mejor una combinación de flujo de programa o entrada del usuario, dependiendo de cómo haya instrumentado su aplicación.

Nota : Los siguientes son casos de uso bastante simples para Analytics. Las profundidades de Analytics están más allá del alcance de este codelab. Si desea obtener más información, comprender mejor qué registran exactamente estos registros o saber cómo depurar el proceso de generación de informes, consulte Introducción a Google Analytics para Unity .

1. En Assets/Hamster/Scripts/States/DebugMenu.cs , sobrescriba las implementaciones existentes de los siguientes métodos:

   public void LogProgressEventWithStringLiterals()
   {
         Firebase.Analytics.FirebaseAnalytics.LogEvent("progress", "percent", 0.4f);
   }
   

   public void LogIntScoreWithBuiltInEventAndParams()
   {
         Firebase.Analytics.FirebaseAnalytics
           .LogEvent(
             Firebase.Analytics.FirebaseAnalytics.EventPostScore,
             Firebase.Analytics.FirebaseAnalytics.ParameterScore,
             42
           );
   }
   

2. Crea e implementa tu juego y luego ingresa al menú de depuración .
3. (Solo Android) Cargue sus símbolos ejecutando el siguiente comando de Firebase CLI:

   firebase crashlytics:symbols:upload --app=<FIREBASE_APP_ID> <PATH/TO/SYMBOLS>
   

4. Presione al menos uno de los siguientes botones una o más veces para llamar a las funciones anteriores:
   • Evento de cadena de registro
   • Evento de inicio de sesión
5. Presione el botón Crash Now .
6. Reinicia tu juego para que cargue el evento de bloqueo en Firebase.
7. Cuando registras varias secuencias arbitrarias de eventos de Analytics y luego haces que tu juego genere un evento del cual Crashlytics crea un informe (como lo acabas de hacer), se agregan a la pestaña Registros del Resumen de eventos de Crashlytics de esta manera:
   

Importante: Los eventos personalizados pueden tardar más en aparecer en el panel de Analytics de Firebase console que en aparecer en un registro de fallos dentro del panel de Crashlytics. Además, es posible que los eventos de Analytics no aparezcan en ambos lugares inmediatamente después de registrarlos.

13. Avanzando

Y con eso, debería tener una mejor base teórica sobre la cual complementar sus informes de fallos generados automáticamente. Esta nueva información le permite utilizar el estado actual, los registros de eventos pasados ​​y los eventos existentes de Google Analytics para desglosar mejor la secuencia de eventos y la lógica que llevaron a su resultado.

Si su aplicación está destinada a Android 11 (nivel de API 30) o superior, considere incorporar GWP-ASan , una función de asignación de memoria nativa útil para depurar fallas causadas por errores de memoria nativa, como errores use-after-free y heap-buffer-overflow . Para aprovechar esta función de depuración, habilite explícitamente GWP-ASan .

Próximos pasos

Continúe con el codelab Instrumentar su juego Unity con Remote Config , donde aprenderá cómo usar Remote Config y las pruebas A/B en Unity.