Flutter Bug Tracker : comparatif des meilleurs outils de tracking en 2026

En 2026, une application Flutter sérieuse ne peut plus se passer d'un bug tracker. Mais entre les crash reporters historiques (Sentry, Crashlytics) et les solutions modernes de feedback visuel (SnapLogs), le choix n'est pas évident. Ce comparatif passe au crible cinq solutions majeures sur douze critères concrets, pour vous aider à choisir selon votre contexte : startup, scale-up, ou équipe produit mature.

Pourquoi un bug tracker dédié à Flutter en 2026

Flutter a une particularité : il compile vers plusieurs cibles (iOS, Android, Web, Desktop) avec un même code Dart. Un bug tracker Flutter doit donc :

• Gérer les stack traces Dart et les symboles natifs (iOS arm64, Android NDK).
• Distinguer les plateformes dans les filtres.
• Capturer le contexte spécifique à chaque cible (CORS pour web, permissions pour mobile).
• Suivre le cycle de vie des widgets (didChangeDependencies, dispose).

Un tracker générique web (ex : Rollbar historique) ne suffit pas. Un tracker purement natif (ex : Crashlytics seul) rate les bugs visuels. Voyons ce que proposent les cinq solutions majeures.

Les cinq solutions comparées

1. SnapLogs

SnapLogs est un bug tracker visuel pensé pour le mobile et le web. Sa particularité : combiner crash reporting, feedback in-app annoté, et logs structurés dans un seul SDK.

| Critère | SnapLogs | | --- | --- | | Support Flutter | Package officiel snaplogs (pub.dev) | | Capture d'écran annotée | Oui, natif | | Feedback in-app | Oui (shake, bouton, gesture) | | Breadcrumbs | Oui, automatique | | Logs structurés | Oui (API ingestion v1) | | Performance monitoring | Non (focus debug visuel) | | Prix | 0€ (free tier) à 39€/mois (team) | | Limites free | 5000 événements/mois | | Self-hosted | Non (SaaS) | | Migration depuis Sentry | Guide fourni, 2h |

Cas d'usage typique : une app Flutter grand public où les utilisateurs ne savent pas décrire un bug, et où le support doit remonter des tickets exploitables sans échange.

2. Sentry

Sentry est le standard de fait pour le crash reporting. Très mature, il couvre 80+ plateformes.

| Critère | Sentry | | --- | --- | | Support Flutter | Package officiel sentry_flutter | | Capture d'écran annotée | Non | | Feedback in-app | Limité (module User Feedback) | | Breadcrumbs | Oui | | Logs structurés | Oui (via Sentry Logs, beta) | | Performance monitoring | Oui (tracing) | | Prix | 0€ à 80€/mois (team), puis usage | | Limites free | 5000 erreurs/mois | | Self-hosted | Oui (SaaS ou self-hosted) |

Cas d'usage typique : équipe backend + frontend qui veut un seul outil pour tout le crash reporting.

3. Bugsnag

Bugsnag est historiquement positionné sur la stabilité. Racheté par SmartBear, il cible les entreprises.

| Critère | Bugsnag | | --- | --- | | Support Flutter | Package bugsnag_flutter (communautaire + officiel) | | Capture d'écran annotée | Non | | Feedback in-app | Non (module séparé) | | Breadcrumbs | Oui | | Logs structurés | Non | | Performance monitoring | Oui (stability scoring) | | Prix | 59$/mois (basic), 239$/mois (pro) | | Limites free | 7 500 événements/mois | | Self-hosted | Non |

Cas d'usage typique : PME qui veut un scoring de stabilité pour des clients B2B exigeants.

4. Firebase Crashlytics

Crashlytics est gratuit, intégré à Firebase, et donc très courant côté Android.

| Critère | Firebase Crashlytics | | --- | --- | | Support Flutter | Plugin firebase_crashlytics | | Capture d'écran annotée | Non | | Feedback in-app | Non (via Firebase In-App Messaging) | | Breadcrumbs | Oui (custom logs) | | Logs structurés | Non | | Performance monitoring | Via Firebase Performance (séparé) | | Prix | Gratuit | | Limites free | Non documentées publiquement | | Self-hosted | Non (Google Cloud) |

Cas d'usage typique : startup déjà sur Firebase qui veut un crash reporter gratuit.

5. Rollbar

Rollbar cible les équipes devops avec un fort accent backend.

| Critère | Rollbar | | --- | --- | | Support Flutter | Package communautaire | | Capture d'écran annotée | Non | | Feedback in-app | Non | | Breadcrumbs | Oui | | Logs structurés | Oui (items) | | Performance monitoring | Non | | Prix | 21$/mois (starter), 49$/mois (pro) | | Limites free | 5 000 erreurs/mois | | Self-hosted | Non |

Cas d'usage typique : équipe backend qui veut étendre à Flutter sans changer d'outil.

Tableau comparatif synthétique

| Outil | Capture visuelle | Feedback in-app | Crash reporting | Prix mini | Flutter officiel | | --- | --- | --- | --- | --- | --- | | SnapLogs | Oui (annoté) | Oui (natif) | Oui | 0€ | Oui | | Sentry | Non | Limité | Excellent | 0€ | Oui | | Bugsnag | Non | Non | Excellent | 59$ | Partiel | | Crashlytics | Non | Non | Bon | 0€ | Oui | | Rollbar | Non | Non | Bon | 21$ | Non |

Score global sur 10 combine : capture visuelle, feedback in-app, crash reporting, prix, support Flutter, integrations.

Critères de choix détaillés

1. Support Flutter officiel

Un package officiel maintenu par l'éditeur est gage de longévité. Sentry et SnapLogs ont une intégration Flutter officielle. Bugsnag et Crashlytics sont officieux. Rollbar est purement communautaire.

2. Capture d'écran annotée

C'est le critère qui sépare SnapLogs des autres. Pour les bugs visuels (layout, UI, traduction, alignment), aucune stack trace ne remplacera une capture annotée. Si votre équipe produit traite des tickets support clients, ce critère est décisif.

3. Feedback in-app

Le feedback in-app réduit la friction utilisateur. L'utilisateur secoue son téléphone, annote, et le rapport part. Sans cela, vous dépendez d'un email au support, souvent incomplet.

4. Breadcrumbs automatiques

Sentry et SnapLogs capturent automatiquement les taps et navigations. Crashlytics nécessite d'instrumenter manuellement. Pour un debug efficace, l'automatique est essentiel.

5. Logs structurés

SnapLogs expose une API d'ingestion v1 documentée. Sentry Logs est en beta. Bugsnag et Crashlytics ne supportent pas les logs structurés (seulement des custom logs attachés à un crash).

6. Performance monitoring

Si vous voulez tracer les écrans lents (jank), Sentry et Firebase Performance sont pertinents. SnapLogs ne couvre pas le perf monitoring ; il est complémentaire.

7. Prix et modèle économique

| Outil | Modèle | Facturation | | --- | --- | --- | | SnapLogs | SaaS, plans fixes | 0€ à 39€/mois | | Sentry | SaaS + self-hosted, à l'usage | 0€ à 80€/mois + overages | | Bugsnag | SaaS, sièges | 59$ à 239$/mois | | Crashlytics | Gratuit | Google Analytics side-effect | | Rollbar | SaaS, à l'usage | 21$ à 49$/mois |

8. Limites et quotas

Vérifiez les limites :

• SnapLogs : 5 000 événements/mois en free.
• Sentry : 5 000 erreurs/mois en free.
• Bugsnag : 7 500 événements/mois.
• Crashlytics : non documenté (mais throttle implicite).
• Rollbar : 5 000 erreurs/mois.

9. Intégrations (Slack, Linear, Jira)

• SnapLogs : Slack, Linear, n8n, webhook générique.
• Sentry : 80+ intégrations.
• Bugsnag : Slack, Jira, GitHub.
• Crashlytics : BigQuery, Slack (via Firebase Extensions).
• Rollbar : Slack, Jira, GitHub.

10. Self-hosted

Seul Sentry propose un self-hosted gratuit. Si vous êtes en Europe avec des contraintes RGPD strictes (banque, santé), c'est un argument.

11. RGPD et redaction

SnapLogs inclut la redaction par regex nativement. Sentry propose beforeSend pour filtrer. Bugsnag a un module de redaction (payant). Crashlytics et Rollbar laissent tout au développeur.

12. Facilité de migration

SnapLogs publie un guide de migration depuis Sentry. Bugsnag n'a pas de guide officiel Flutter. Crashlytics verrouille dans Firebase. Rollbar est trop différent pour migrer facilement.

Cas d'usage concrets

Startup Flutter B2C

Vous avez 10k MAU, 2 devs, un budget serré. Recommandation : SnapLogs free tier + Sentry free tier. SnapLogs pour le feedback visuel, Sentry pour les crashs backend. Total : 0€.

Scale-up Flutter B2B

Vous avez 100k utilisateurs, 8 devs, des clients qui payent pour la stabilité. Recommandation : SnapLogs team + Sentry team. Le scoring de stabilité de Bugsnag est tentant, mais le prix est élevé pour le retour.

Équipe produit mature

Vous avez une équipe QA, un support, des SLOs. Recommandation : SnapLogs + Crashlytics. SnapLogs pour le feedback utilisateur, Crashlytics pour le crash natif gratuit.

Équipe web-first s'étendant à Flutter

Vous utilisez déjà Sentry sur le backend. Recommandation : Sentry + SnapLogs. Sentry couvre le crash, SnapLogs apporte le visuel que Sentry n'a pas.

Exemple d'intégration SnapLogs Flutter

import 'package:flutter/material.dart';
import 'package:snaplogs/snaplogs.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await SnapLogs.init(
    apiKey: const String.fromEnvironment('SNAPLOGS_KEY'),
    environment: 'production',
    captureLayoutWarnings: true,
    redactPatterns: [r'\b[\w.]+@[\w.]+\b'],
    sampleRate: 1.0,
  );

  FlutterError.onError = (details) {
    FlutterError.presentError(details);
    SnapLogs.captureException(details.exception, stackTrace: details.stack);
  };

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: const Text('SnapLogs demo')),
        body: const Center(child: Text('Secoue pour signaler un bug')),
        floatingActionButton: FloatingActionButton(
          onPressed: () => SnapLogs.showFeedbackSheet(context),
          child: const Icon(Icons.bug_report),
        ),
      ),
    );
  }
}

Exemple d'intégration Sentry Flutter (pour comparaison)

import 'package:flutter/material.dart';
import 'package:sentry_flutter/sentry_flutter.dart';

Future<void> main() async {
  await SentryFlutter.init(
    (options) {
      options.dsn = const String.fromEnvironment('SENTRY_DSN');
      options.tracesSampleRate = 1.0;
    },
    appRunner: () => runApp(const MyApp()),
  );
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: Center(
          child: ElevatedButton(
            onPressed: () async {
              try {
                throw StateError('test sentry');
              } catch (e, st) {
                await Sentry.captureException(e, stackTrace: st);
              }
            },
            child: const Text('Throw test error'),
          ),
        ),
      ),
    );
  }
}

Notez la différence : Sentry n'expose pas de showFeedbackSheet. Tout passe par captureException. C'est parfait pour les crashs, insuffisant pour les bugs visuels.

Migration de Sentry vers SnapLogs

Voici un guide pratique en 4 étapes.

Étape 1 : audit des appels Sentry

Listez tous les Sentry.captureException, Sentry.addBreadcrumb, Sentry.captureMessage dans votre code Dart. Typiquement 5 à 20 occurrences pour une app moyenne.

Étape 2 : ajout de SnapLogs en parallèle

dependencies:
  sentry_flutter: ^8.9.0
  snaplogs: ^2.4.0

Étape 3 : remplacement progressif

Remplacez Sentry.captureException par SnapLogs.captureException. Utilisez le beforeSend de Sentry pour aussi envoyer à SnapLogs pendant la transition :

await SentryFlutter.init(
  (options) {
    options.dsn = const String.fromEnvironment('SENTRY_DSN');
    options.beforeSend = (event) {
      // Double-écriture pendant la migration
      SnapLogs.captureException(
        event.throwable,
        stackTrace: event.stackTrace,
      );
      return event;
    };
  },
  appRunner: () => runApp(const MyApp()),
);

Étape 4 : suppression de Sentry

Une fois SnapLogs validé, retirez Sentry du pubspec.yaml et nettoyez les appels. Le guide complet est dans la documentation SnapLogs.

Calcul du ROI d'un bug tracker

Un bug tracker se justifie par le temps économisé. Estimons :

• Temps moyen de reproduction d'un bug sans tracker : 2h.
• Temps moyen avec un crash reporter (Sentry) : 45 min.
• Temps moyen avec SnapLogs (feedback visuel) : 12 min.
• Nombre de bugs par mois : 30.
• Coût horaire dev : 60€.

| Solution | Temps/mois | Coût/mois | Tracker/mois | Total | | --- | --- | --- | --- | --- | | Aucun | 60h | 3 600€ | 0€ | 3 600€ | | Sentry free | 22,5h | 1 350€ | 0€ | 1 350€ | | SnapLogs free | 6h | 360€ | 0€ | 360€ | | SnapLogs team | 6h | 360€ | 39€ | 399€ |

Économie nette de SnapLogs team vs aucun tracker : 3 201€/mois pour 30 bugs.

Intégration CI/CD : automatiser la symbolication

Un bug tracker n'est utile que si les stacks sont lisibles. Cela demande d'uploader les symbols à chaque release.

GitHub Actions

name: Deploy Flutter
on:
  push:
    tags: ['v*']

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.22.1'
      - run: flutter pub get
      - name: Build APK obfuscated
        run: flutter build apk --release --obfuscate --split-debug-info=./build/symbols
      - name: Upload symbols to SnapLogs
        env:
          SNAPLOGS_KEY: ${{ secrets.SNAPLOGS_KEY }}
        run: npx snaplogs symbols upload --path=./build/symbols --version=${{ github.ref_name }}
      - name: Upload APK to Play Store
        # ... deploy step

Fastlane (iOS)

lane :release do
  flutter(
    build: "ios",
    release: true,
    obfuscate: true,
    split_debug_info: "./build/symbols"
  )
  sh("npx snaplogs symbols upload --path=./build/symbols --version=#{get_version_number}")
  upload_to_app_store
end

Sans cette automatisation, les crashes de la release 1.4.2 seront illisibles. Avec elle, chaque release a ses symbols côté serveur, prêts pour la symbolication.

Cas d'usage concrets par profil d'équipe

Startup solo dev (Flutter, 1 personne)

Vous êtes seul, vous codez, vous supportez. Budget nul.

Stack recommandée : SnapLogs free (5000 events/mois) + Sentry free.

• SnapLogs capte les bugs visuels remontés par les 100 beta-testeurs.
• Sentry capte les crashs natifs.
• Coût total : 0€.

Workflow :

• Beta-testeur secoue son téléphone.
• Vous recevez le rapport dans Slack.
• Vous fixez en moins de 30 min (le contexte est complet).

Scale-up mobile (Flutter, 8 devs, 50k utilisateurs)

Vous avez une équipe, un support, des SLOs.

Stack recommandée : SnapLogs team + Sentry team.

• SnapLogs pour le feedback visuel et les logs structurés.
• Sentry pour les crashs et le perf tracing.
• Coût : ~120€/mois.

Workflow :

• Support reçoit l'email, renvoie vers le shake-to-report.
• Le ticket part dans Linear avec capture + breadcrumbs.
• Le dev assigné ouvre, diag, fix.
• Le QA valide en staging.
• Le déploiement est automatisé via Fastlane.

Entreprise B2B (Flutter + React Native, 30 devs, 500k utilisateurs)

Vous avez des clients pro qui veulent des SLA.

Stack recommandée : SnapLogs pro + Sentry pro + Firebase Performance.

• SnapLogs pour le feedback visuel et la corrélation logs.
• Sentry pour les crashs natifs deep.
• Firebase Performance pour le jank.
• Coût : ~500€/mois.

Workflow :

• Contrats SLA avec alerting on-call.
• Post-mortem obligatoire pour tout P0.
• Métriques mensuelles : MTTD (mean time to detect), MTTR (mean time to resolve).
• SnapLogs dashboard partagé avec les clients pro (vue anonymisée).

Équipe web-first s'étendant à Flutter

Vous avez déjà Sentry sur le backend Node.js. Vous ajoutez Flutter.

Stack recommandée : Sentry (existant) + SnapLogs free.

• Sentry couvre backend + Flutter crash.
• SnapLogs ajoute le visuel que Sentry n'a pas.
• Coût : 0€ supplémentaire.

Checklist d'évaluation d'un bug tracker Flutter

Avant de choisir, posez ces 12 questions à l'éditeur.

• Le package Flutter est-il officiellement maintenu par l'éditeur ?
• La capture d'écran annotée est-elle native ?
• Le feedback in-app est-il déclenchable par shake, bouton et gesture ?
• Les breadcrumbs sont-ils automatiques (pas d'instrumentation manuelle) ?
• Les logs structurés sont-ils supportés avec une API documentée ?
• La redaction par regex est-elle native ?
• Le sampling est-il configurable par niveau ?
• Le batch et le retry sont-ils gérés côté SDK ?
• La hors-ligne est-elle gérée (file d'attente persistante) ?
• La symbolication est-elle automatisée via CLI ?
• Les intégrations (Slack, Linear, Jira, n8n) sont-elles disponibles ?
• Le prix est-il prévisible (pas d'overages surprises) ?

SnapLogs répond oui aux 12. Sentry répond oui à 9 (pas de capture, pas de feedback natif, pas de redaction native). Bugsnag répond oui à 6. Crashlytics à 5. Rollbar à 4.

Sécurité, RGPD et conformité

Le choix d'un bug tracker engage la conformité RGPD. Les crash reports et feedbacks contiennent souvent du contexte utilisateur (email, IP, user_id). Voici les points à auditer.

Hébergement et localisation

• SnapLogs : hébergé en UE (OVHcloud, France). Conforme RGPD natif.
• Sentry : SaaS US, self-hosted possible (UE possible).
• Bugsnag : SaaS US, pas de self-hosted.
• Crashlytics : Google Cloud, données aux US.
• Rollbar : SaaS US.

Pour une app européenne avec des données sensibles (banque, santé), l'hébergement UE est un argument décisif. SnapLogs et Sentry self-hosted sont les seules options.

Données collectées

Auditez ce que le tracker envoie par défaut :

| Outil | IP user | Device ID | Email si présent | Position GPS | | --- | --- | --- | --- | --- | | SnapLogs | Non par défaut | Non | Redacted si regex | Non | | Sentry | Oui (anonymisée) | Oui | Possible | Non | | Bugsnag | Oui | Oui | Possible | Non | | Crashlytics | Oui | Oui | Possible via Firebase Auth | Non | | Rollbar | Oui | Oui | Possible | Non |

SnapLogs est le seul à ne pas collecter l'IP ni le device ID par défaut. Pour les apps très sensibles, c'est un plus.

Conventions de redaction

Chaque tracker gère la redaction différemment :

• SnapLogs : redaction par regex natif, au niveau SDK, avant l'envoi.
• Sentry : beforeSend callback côté client, et server-side scrubbing.
• Bugsnag : redaction module payant (Pro plan).
• Crashlytics : pas de redaction natif, à vous de nettoyer avant recordError.
• Rollbar : scrubbing server-side configurable.

La redaction côté SDK (SnapLogs) est la plus sûre : les données sensibles ne quittent jamais le device.

DPA et contrats

Pour une conformité RGPD complète, un DPA (Data Processing Agreement) est nécessaire. Tous les éditeurs SaaS sérieux en proposent un. Vérifiez :

• SnapLogs : DPA disponible, signé numériquement.
• Sentry : DPA disponible.
• Bugsnag : DPA disponible (SmartBear).
• Crashlytics : via Google Cloud Data Processing Amendment.
• Rollbar : DPA disponible sur demande.

Audit et export

En cas d'audit RGPD, vous devez pouvoir exporter et supprimer les données d'un utilisateur. SnapLogs propose :

• Export des rapports par user_id (API v1).
• Suppression sur demande (droit à l'oubli, moins de 30 jours).
• Journal d'audit des accès.

Ces features sont incluses dans le plan Team. Vérifiez la disponibilité chez les autres éditeurs avant de choisir.

Limites et pièges à éviter

1. Multiplicité d'outils

Avoir Sentry + Bugsnag + Crashlytics est contre-productif. Vous diluez les signaux. Choisissez un crash reporter + un feedback visuel.

2. Confondre perf monitoring et bug tracking

Firebase Performance n'est pas un bug tracker. Il mesure le temps, pas les erreurs. Ne le mettez pas dans votre workflow de triage.

3. Négliger la redaction

Logger un token JWT en clair dans Sentry vous expose à une fuite. Utilisez beforeSend ou la redaction SnapLogs.

4. Oublier le mode release

Un crash en debug n'est pas représentatif. Testez toujours votre tracker en release avant de déployer :

flutter run --release

Conclusion : quel bug tracker Flutter choisir en 2026

Le choix dépend de votre maturité et de votre budget :

• Démarrage : SnapLogs free + Sentry free = 0€.
• Scale-up : SnapLogs team + Sentry team = ~120€/mois.
• Entreprise : SnapLogs team + Crashlytics (gratuit) = 39€/mois.
• Self-hosted strict : Sentry self-hosted + SnapLogs team.

Le seul outil qui couvre à la fois les crashs, les bugs visuels et les logs structurés pour Flutter est SnapLogs. Si vous ne deviez en choisir qu'un, c'est lui. Pour aller plus loin, lisez notre guide complet du bug report Flutter et notre guide de debug Flutter en production. Pour essayer SnapLogs, créez un compte gratuit, consultez nos prix ou la page dédiée à Flutter.