Informe de excepciones del seguimiento de excepciones de Google Analytics analytics.js

Google Universal Analytics tiene un tipo de excepción de hit

ga('send', 'exception', {
  'exDescription': 'DatabaseError'
});

Esperaba poder ir a la consola de Google Analytics y encontrar un informe de excepción al mismo nivel que 'eventos', sin embargo, no se ve por ninguna parte.

Las API de Android e iOS dicen Crash and exception data is available primarily in the Crash and Exceptions reportpero no puedo encontrar ningún informe con ese nombre.

Lo averigué. No estoy seguro de por qué no lo convierten en un informe integrado, pero tal vez algún día.

Hice un widget personalizado en un panel con la Exception Descriptiondimensión y 'Bloqueos' para la métrica:

Lo que me da un informe como este:

También puede ir a la Customizationpestaña y crear un informe personalizado para darle una tabla de errores y luego agregarlo a su tablero.

Usado con este manejador de excepciones global

if (typeof window.onerror == "object")
{
    window.onerror = function (err, url, line)
    {
        if (ga) 
        {
           ga('send', 'exception', {
               'exDescription': line + " " + err
           });
        }
    };
}

Puede colocar este controlador en cualquier lugar de la inicialización de su Javascript, que dependerá de cómo haya configurado todos sus archivos JS. Alternativamente, puede ponerlo dentro de una <script>etiqueta cerca de la parte superior de su etiqueta html body.

Tomé la guía de Simon_Weaver para hacer un informe personalizado unos pasos más y desarrollé un informe de excepciones personalizado de Google Analytics bastante completo. Pensé que valdría la pena compartirlo, así que lo subí a la "Galería de soluciones" de GA.

Mi plantilla: Informe de excepciones de Google Analytics

Aquí hay una imagen del resultado final:

Solo quería ampliar un poco la excelente respuesta de @Simon_Weaver para proporcionar informes de error con algunos detalles adicionales:

• Asegúrese de que ga()esté definido antes de intentar llamarlo (ya que se podría desencadenar un error antes de que se cargue la biblioteca de Analytics).
• Números de línea de excepción de registro e índice de columna en los informes de análisis (aunque el código JavaScript reducido que se usa en producción puede ser difícil de leer).
• Ejecute cualquier window.onerrordevolución de llamada definida previamente .

/**
 * Send JavaScript error information to Google Analytics.
 * 
 * @param  {Window} window A reference to the "window".
 * @return {void}
 * @author Philippe Sawicki <https://github.com/philsawicki>
 */
(function (window) {
    // Retain a reference to the previous global error handler, in case it has been set:
    var originalWindowErrorCallback = window.onerror;

    /**
     * Log any script error to Google Analytics.
     *
     * Third-party scripts without CORS will only provide "Script Error." as an error message.
     * 
     * @param  {String}           errorMessage Error message.
     * @param  {String}           url          URL where error was raised.
     * @param  {Number}           lineNumber   Line number where error was raised.
     * @param  {Number|undefined} columnNumber Column number for the line where the error occurred.
     * @param  {Object|undefined} errorObject  Error Object.
     * @return {Boolean}                       When the function returns true, this prevents the 
     *                                         firing of the default event handler.
     */
    window.onerror = function customErrorHandler (errorMessage, url, lineNumber, columnNumber, errorObject) {
        // Send error details to Google Analytics, if the library is already available:
        if (typeof ga === 'function') {
            // In case the "errorObject" is available, use its data, else fallback 
            // on the default "errorMessage" provided:
            var exceptionDescription = errorMessage;
            if (typeof errorObject !== 'undefined' && typeof errorObject.message !== 'undefined') {
                exceptionDescription = errorObject.message;
            }

            // Format the message to log to Analytics (might also use "errorObject.stack" if defined):
            exceptionDescription += ' @ ' + url + ':' + lineNumber + ':' + columnNumber;

            ga('send', 'exception', {
                'exDescription': exceptionDescription,
                'exFatal': false, // Some Error types might be considered as fatal.
                'appName': 'Application_Name',
                'appVersion': '1.0'
            });
        }

        // If the previous "window.onerror" callback can be called, pass it the data:
        if (typeof originalWindowErrorCallback === 'function') {
            return originalWindowErrorCallback(errorMessage, url, lineNumber, columnNumber, errorObject);
        }
        // Otherwise, Let the default handler run:
        return false;
    };
})(window);

// Generate an error, for demonstration purposes:
//throw new Error('Crash!');

Editar: como @Simon_Weaver señaló debidamente, Google Analytics ahora tiene documentación sobre el seguimiento de excepciones (a la que debería haberme vinculado en mi respuesta original, ¡lo siento, error de novato!):

• https://developers.google.com/analytics/devguides/collection/analyticsjs/exceptions
• https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#exception

Esto es lo que se me ocurrió para que no sea necesario incluir el código en todas partes. Simplemente agregue new ErrorHandler();a cada archivo .js. Esto se hizo para una extensión de Chrome, pero creo que debería funcionar en cualquier lugar. Implemento las cosas reales de ga () en un archivo separado (de ahí la aplicación.GA), pero también puedes hornearlo aquí.

/*
 *  Copyright (c) 2015-2017, Michael A. Updike All rights reserved.
 *  Licensed under the BSD-3-Clause
 *  https://opensource.org/licenses/BSD-3-Clause
 *  https://github.com/opus1269/photo-screen-saver/blob/master/LICENSE.md
 */
// noinspection ThisExpressionReferencesGlobalObjectJS
(function(window, factory) {
    window.ExceptionHandler = factory(window);
}(this, function(window) {
    'use strict';

    return ExceptionHandler;

    /**
     * Log Exceptions with analytics. Include: new ExceptionHandler();<br />
     * at top of every js file
     * @constructor
     * @alias ExceptionHandler
     */
    function ExceptionHandler() {
        if (typeof window.onerror === 'object') {
            // global error handler
            window.onerror = function(message, url, line, col, errObject) {
                if (app && app.GA) {
                    let msg = message;
                    let stack = null;
                    if (errObject && errObject.message && errObject.stack) {
                        msg = errObject.message;
                        stack = errObject.stack;
                    }
                    app.GA.exception(msg, stack);
                }
            };
        }
    }
}));

Ahora puede encontrar una vista de "Bloqueos y excepciones" en Comportamiento (si la propiedad se crea como una "aplicación móvil" en Google Analytics).