Le taux d'erreur JavaScript mesure le pourcentage de vos applications de navigateur qui rencontrent des erreurs JavaScript, ce qui peut interrompre les fonctionnalités de l'utilisateur et créer une mauvaise expérience utilisateur. Cette règle de dashboard vous aide à identifier et à hiérarchiser la résolution des problèmes frontaux qui ont un impact direct sur la satisfaction des clients.
À propos de cette règle de dashboard
Cette règle de taux d’erreur JavaScript fait partie du niveau 1 (réactif) du modèle de maturité de l’expérience numérique. Il évalue si vos applications de navigateur présentent des erreurs JavaScript non résolues qui pourraient affecter l'utilisateur.
Pourquoi cela est important : les erreurs JavaScript peuvent interrompre des fonctionnalités critiques pour l'utilisateur, telles que les formulaires, la navigation, les paiements ou les fonctionnalités interactives. Les utilisateurs qui rencontrent des fonctionnalités défectueuses abandonnent souvent leurs tâches, ce qui entraîne des conversions perdues et une perception négative de la marque.
Comment fonctionne cette règle
Cette règle évalue le pourcentage d'entités de navigateur (applications monitorées par New Relic Browser) qui présentent des erreurs JavaScript. Il identifie les applications dans lesquelles l'utilisateur peut rencontrer des problèmes de fonctionnalité en raison de problèmes de code frontal.
Comprendre votre score
- Pass (Vert) : Un faible pourcentage d'applications de navigateur présentent des erreurs JavaScript affectant l'utilisateur
- Échec (rouge) : un pourcentage élevé d'applications de navigateur présentent des erreurs JavaScript non résolues
- Objectif : minimiser les erreurs JavaScript dans toutes les applications de navigateur, en particulier celles avec un trafic utilisateur élevé
Ce que cela signifie :
- Score de réussite : vos applications front-end offrent une expérience utilisateur fiable avec un minimum de fonctionnalités interrompues
- Score d'échec : l'utilisateur peut rencontrer des fonctionnalités, des formulaires ou des interactions défaillants qui pourraient avoir un impact sur la satisfaction et les conversions
Comment réduire le taux d'erreur JavaScript
Si votre score affiche un taux d'erreur JavaScript élevé, suivez ces étapes pour identifier et résoudre les problèmes frontend :
1. Analyser les modèles d'erreur dans la boîte de réception des erreurs
- Accéder à la boîte de réception des erreurs : accédez à la boîte de réception des erreurs de New Relic pour voir toutes les erreurs JavaScript dans vos applications
- Identifier les erreurs à fort impact : se concentrer sur les erreurs affectant les parcours utilisateurs les plus critiques
- Regrouper les erreurs similaires : rechercher des modèles dans les messages d'erreur, les pages affectées ou les segments d'utilisateurs
- Prioriser en fonction de l'impact sur l'entreprise : traitez d'abord les erreurs sur les pages à fort trafic ou les flux critiques pour la conversion
2. Catégoriser et trier les erreurs
Erreurs critiques (à corriger immédiatement) :
- Échecs du traitement des paiements
- Problèmes d'authentification des utilisateurs
- Problèmes de soumission de données
- Échecs de navigation ou de routage
Erreurs prioritaires (correction dans le sprint) :
- Échecs de validation de formulaire
- Problèmes de fonctionnalité de recherche
- Problèmes interaction utilisateur
- Échecs de chargement du contenu
Erreurs de priorité moyenne (correction dans la prochaine sortie) :
- Problèmes mineurs de l'interface utilisateur
- Échecs de fonctionnalités non critiques
- Problèmes esthétiques ou de style
- Scénarios extrêmes
3. Mettre en œuvre une résolution systématique des erreurs
Reproduire et diagnostiquer :
- Utiliser la trace d'appels : examiner les détails de l'erreur pour comprendre quel code échoue
- Vérifiez la compatibilité du navigateur : vérifiez que les erreurs ne sont pas des problèmes spécifiques au navigateur
- Scénarios utilisateur de test : reproduisez les actions utilisateur qui déclenchent des erreurs
- Examiner le déploiement récent : vérifier si les erreurs correspondent aux modifications récentes du code
Corriger les causes profondes :
- Vérifications nulles/non définies : ajoutez une gestion des erreurs appropriée pour les données manquantes
- Gestion des erreurs d'API : implémenter des solutions de secours élégantes pour requestsréseau ayant échoué
- Validation des intrants : s'assurer que les formulaires gèrent les cas limites et les entrées non valides
- Chargement des ressources : ajouter une gestion des erreurs pour les images, les scripts ou les feuilles de style manquants
4. Établir des pratiques de prévention des erreurs
Mettre en œuvre une meilleure gestion des erreurs :
- Blocs try-catch : encapsuler les opérations risquées dans une gestion des erreurs appropriée
- Valeurs par défaut : fournir des solutions de secours pour les données manquantes ou non valides
- Dégradation gracieuse : garantir que les fonctionnalités principales fonctionnent même en cas de défaillance de la fonctionnalité
- Messages conviviaux : afficher un message d'erreur utile au lieu de détails techniques
Améliorer les pratiques de développement :
- Révision du code : se concentrer sur la gestion des erreurs lors des révisions par les pairs
- Stratégies de test : inclure des scénarios d'erreur dans les tests unitaires et d'intégration
- Environnement de simulation : tester minutieusement avant la sortie en production
- Intégration du monitoring : Ajouter le suivi des erreurs aux environnements de développement et de simulation
Mesurer l'amélioration
Suivez ces mesures pour vérifier vos efforts de réduction des erreurs JavaScript :
- Réduction du taux d'erreur : pourcentage décroissant d'applications présentant des erreurs JavaScript
- Métriques d'impact utilisateur : taux de conversion amélioré, taux de rebond réduits, satisfaction utilisateur plus élevée
- Temps de résolution des erreurs : identification et résolution plus rapides des problèmes JavaScript
- Récurrence des erreurs : moins d'erreurs répétées après l'application des correctifs
Scénarios d'erreur JavaScript courants
Échecs de script tiers :
- Problème : une bibliothèque ou un widget externe provoque des erreurs lorsqu'il ne parvient pas à se charger ou rencontre des problèmes
- Solution : implémenter des limites d’erreur, utiliser des solutions de secours et monitorer les dépendances tierces
Problèmes de compatibilité Browser :
- Problème : le code fonctionne dans certains navigateurs mais échoue dans d’autres
- Solution : tester sur plusieurs navigateurs, utiliser des polyfills et mettre en œuvre une amélioration progressive
Pannes de réseau et d'API :
- Problème : erreurs JavaScript lorsque requests réseau échouent ou renvoient des données inattendues
- Solution : ajouter une gestion des erreurs appropriée pour l'appel d'API, implémenter une logique de nouvelle tentative et fournir un retour d'information à l'utilisateur
Cas limites de saisie utilisateur :
- Problème : les formulaires ou l'interaction sont interrompus en cas de saisie utilisateur inattendue
- Solution : Mettre en œuvre une validation complète des entrants et de l'assainissement
Stratégies avancées de gestion des erreurs
Automatisation du suivi des erreurs
- Alertes automatisées : configurez des alertes pour les erreurs JavaScript nouvelles ou fréquentes
- Regroupement des erreurs : utilisez le regroupement intelligent pour éviter la fatigue due aux alertes auxiliaires
- Évaluation de l'impact : hiérarchiser les erreurs en fonction de l'impact sur l'utilisateur et de la fréquence
Intégration avec workflows de développement
- Intégration CI/CD (intégration et livraison continue) : Bloquer le déploiement si des erreurs critiques sont détectées
- Budgets de performance : définir le taux d'erreur seuil en tant que portes déployées
- Attribution des erreurs : connectez les erreurs à une déploiement ou une fonctionnalité spécifique
Accent mis sur l'expérience utilisateur
- Monitoring des utilisateurs réels : suivez comment les erreurs affectent le comportement réel de l'utilisateur
- Impact de conversion : mesurez la corrélation entre le taux d'erreur et les indicateurs commerciaux
- Analyse du parcours utilisateur : comprendre où dans le flux utilisateur les erreurs se produisent le plus fréquemment
Considérations importantes
- Prioriser en fonction de l'impact sur l'utilisateur : se concentrer d'abord sur les erreurs affectant les fonctions les plus critiques ou les plus importantes de l'entreprise
- Équilibrez la perfection avec l'aspect pratique : certaines erreurs peuvent être acceptables si elles n'ont pas d'impact significatif sur l'expérience utilisateur
- Tenez compte du contexte commercial : les applications à fort trafic peuvent nécessiter une tolérance aux erreurs inférieure à celle des outils internes.
- Monitoring post-déploiement : s'assurer que les correctifs n'introduisent pas de nouvelles erreurs
Prochaines étapes
- Action immédiate : examinez la boîte de réception des erreurs et identifiez les erreurs JavaScript ayant le plus d'impact sur l'utilisateur.
- Amélioration des processus : Établir des réunions régulières de tri des erreurs et un flux de travail de résolution
- Priorité à la prévention : mettre en œuvre de meilleures pratiques de gestion des erreurs dans les processus de développement
- Monitoring avancé : Vers une prévention proactive des erreurs et une optimisation de l'expérience utilisateur
- Progression vers le niveau 2 : une fois les erreurs JavaScript sous contrôle, concentrez-vous sur l'optimisation des Core Web Vitals
Pour obtenir des conseils détaillés sur monitoring et la résolution des erreurs JavaScript, consultez notre documentation du monitoring des navigateurs et notre guide sur la boîte de réception des erreurs.