Modèle de backend de l'application de journalisation des erreurs centralisée
Suivi des erreurs et gestion des résolutions

Points forts

Aperçu

Un produit de journalisation d'erreurs centralisé nécessite une journalisation complète, un suivi des exceptions et une gestion des résolutions.

Ce modèle décrit le journal des erreurs, la fréquence des exceptions et le statut de résolution avec des fonctionnalités de partage et de contrôle d'accès intégrées pour une mise en œuvre rapide.

Pourquoi construire votre application Centralized Error Logger avec Back4app ?

Back4app fournit d'excellents primitives de journalisation des erreurs qui libèrent votre équipe pour se concentrer sur le suivi et la résolution des erreurs sans gérer l'infrastructure.

• •Gestion des erreurs robuste: Structure du journal des erreurs avec des informations détaillées et une classe d'exception pour le suivi des exceptions.
• •Capacités de suivi et de mise à jour sécurisées: Gérez les journaux d'erreurs de manière sécurisée avec des rôles d'utilisateur pour gérer efficacement les chemins de résolution.
• •Flexibilité en temps réel + API: Utilisez les requêtes en direct pour des mises à jour immédiates sur les résolutions tout en maintenant l'accès REST et GraphQL pour tous les clients.

Construisez et adaptez rapidement des fonctionnalités de journalisation d'erreurs centralisées avec une solution backend unique sur plusieurs plateformes.

Avantages principaux

Un backend de journalisation des erreurs qui permet une itération rapide sans compromettre la sécurité.

Stack et plateforme

Tout inclus dans ce modèle de backend de journalisation d'erreurs centralisé.

Relations d'entité

Modèle de relation d'entité pour le schéma de backend de journalisation d'erreurs centralisé.

erDiagram
    User ||--o{ ErrorLog : "reporter"
    ErrorLog ||--o{ ExceptionFrequency : "logs"
    ErrorLog ||--o{ ResolutionStatus : "status"

    User {
        String objectId PK
        String username
        String email
        String password
        String role
        Date createdAt
        Date updatedAt
    }

    ErrorLog {
        String objectId PK
        String message
        String stackTrace
        Date timestamp
        Pointer user FK
        Date createdAt
        Date updatedAt
    }

    ExceptionFrequency {
        String objectId PK
        Pointer error FK
        Number frequency
        Date createdAt
        Date updatedAt
    }

    ResolutionStatus {
        String objectId PK
        Pointer error FK
        String status
        Pointer resolver FK
        Date createdAt
        Date updatedAt
    }

Séquence et intégration

Flux d'exécution typique pour l'authentification, la journalisation des erreurs, le suivi des exceptions et les mises à jour de résolution.

sequenceDiagram
  participant User
  participant App as Centralized Error Logger App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Report an error
  App->>Back4app: POST /classes/ErrorLog
  Back4app-->>App: ErrorLog objectId

  User->>App: Check error frequency
  App->>Back4app: GET /classes/ExceptionFrequency
  Back4app-->>App: Exception frequency details

  User->>App: Check resolution status
  App->>Back4app: GET /classes/ResolutionStatus
  Back4app-->>App: Resolution status details

Dictionnaire de données

Référence complète au niveau des champs pour chaque classe dans le schéma centralisé du journal des erreurs.

Contrôle d'accès

Comment la stratégie ACL et CLP sécurise les journaux d'erreurs, les fréquences d'exceptions et les états de résolution.

Schéma (JSON)

Définition du schéma JSON brut prête à être copiée dans Back4app ou utilisée comme référence d'implémentation.

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "role": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "ErrorLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "message": {
          "type": "String",
          "required": true
        },
        "stackTrace": {
          "type": "String",
          "required": true
        },
        "timestamp": {
          "type": "Date",
          "required": true
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "ExceptionFrequency",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "error": {
          "type": "Pointer",
          "required": true,
          "targetClass": "ErrorLog"
        },
        "frequency": {
          "type": "Number",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "ResolutionStatus",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "error": {
          "type": "Pointer",
          "required": true,
          "targetClass": "ErrorLog"
        },
        "status": {
          "type": "String",
          "required": true
        },
        "resolver": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Terrain de jeu REST & GraphQL

Essayez les points de terminaison REST et GraphQL contre le schéma de journalisation d'erreurs centralisé. Les réponses utilisent des données fictives et ne nécessitent pas de compte Back4app.

Utilise le même schéma que ce modèle.

Ce que vous obtenez sur chaque stack

Chaque stack utilise le même schéma de backend de journalisation des erreurs centralisé et les contrats API.

FAQ

Questions courantes sur la création d'un backend de journaliseur d'erreurs centralisé avec ce modèle.