Lecture des journaux détaillés

Cette page explique comment interpréter les journaux détaillés générés par le SDK Braze. Pour chaque canal de communication, vous trouverez les entrées de journal importantes à rechercher, leur signification et les problèmes courants à surveiller.

Avant de commencer, assurez-vous d’avoir activé la journalisation détaillée et de savoir comment collecter les journaux sur votre plateforme.

Sessions

Les sessions constituent la base de l’analytique et de la distribution des messages dans Braze. De nombreuses fonctionnalités de communication, y compris les messages in-app et les Content Cards, nécessitent le démarrage d’une session valide avant de pouvoir fonctionner. Si les sessions ne sont pas correctement enregistrées, commencez par investiguer ce point. Pour plus d’informations sur l’activation du suivi des sessions, consultez Étape 5 : Activer le suivi des sessions utilisateur.

Entrées de journal clés

• swift
• android

1
Started user session (id: <SESSION_ID>)

1
2
3
4
5
Ended user session (id: <SESSION_ID>, duration: <DURATION>s)
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: sessionEnd(duration: <DURATION>)

1
2
3
4
New session created with ID: <SESSION_ID>
Session start event for new session received
Completed the openSession call
Opened session with activity: <ACTIVITY_NAME>

1
2
3
Closed session with activity: <ACTIVITY_NAME>
Closed session with session ID: <SESSION_ID>
Requesting data flush on internal session close flush timer.

Points à vérifier

• Vérifiez qu’un journal de démarrage de session apparaît lorsque l’application se lance.
• Si vous ne voyez pas de démarrage de session, vérifiez que le SDK est correctement initialisé et que openSession (Android) est bien appelé.
• Sur Android, confirmez qu’une requête réseau est envoyée à l’endpoint Braze. Si vous ne la voyez pas, vérifiez votre clé API et la configuration de l’endpoint.

Notifications push

Les journaux de notifications push vous aident à vérifier que les jetons d’appareil sont enregistrés, que les notifications sont distribuées et que les événements de clic sont suivis.

Enregistrement du jeton

Lorsqu’une session démarre, le SDK enregistre le jeton push de l’appareil auprès de Braze.

• swift
• android

1
2
3
4
Updated push notification authorization:
- authorization: authorized

Received remote notifications device token: <PUSH_TOKEN>

1
2
3
4
5
6
"attributes": [
  {
    "push_token": "<PUSH_TOKEN>",
    "user_id": "<USER_ID>"
  }
]

1
2
3
4
"device": {
  "ios_push_auth": "authorized",
  "remote_notification_enabled": 1
}

1
Registering for Firebase Cloud Messaging token using sender id: <SENDER_ID>

Points à vérifier

• Si push_token est absent du corps de la requête, le jeton n’a pas été capturé. Vérifiez la configuration push dans les paramètres de votre application.
• Si ios_push_auth affiche denied ou provisional, l’utilisateur n’a pas accordé l’autorisation push complète.
• Sur Android, si vous voyez SENDER_ID_MISMATCH, mettez à jour votre ID d’expéditeur FCM pour qu’il corresponde à votre projet Firebase.

Distribution et clic push

Lorsqu’une notification push est tapée, le SDK enregistre les événements de traitement et de clic.

• swift
• android

1
2
3
4
5
6
7
8
9
10
11
12
13
Processing push notification:
- date: <TIMESTAMP>
- silent: false
- userInfo: {
  "ab": { ... },
  "ab_uri": "<DEEP_LINK_OR_URL>",
  "aps": {
    "alert": {
      "body": "<MESSAGE_BODY>",
      "title": "<MESSAGE_TITLE>"
    }
  }
}

1
2
3
4
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: pushClick(campaignId: ...)

1
2
3
4
Opening '<URL>':
- channel: notification
- useWebView: false
- isUniversalLink: false

1
BrazeFirebaseMessagingService: Got Remote Message from FCM

Points à vérifier

• Vérifiez que le payload push contient le title, le body et les éventuels deep links (ab_uri) attendus.
• Confirmez qu’un événement pushClick est enregistré après avoir tapé sur la notification.
• Si l’événement de clic est manquant, vérifiez que votre app delegate ou votre gestionnaire de notifications transmet correctement les événements push au SDK Braze.

Messages in-app

Les journaux de messages in-app vous montrent le cycle de vie complet : distribution depuis le serveur, déclenchement basé sur les événements, affichage, enregistrement des impressions et suivi des clics.

Distribution des messages

Lorsqu’un utilisateur démarre une session et est éligible à un message in-app, le SDK reçoit le payload du message depuis le serveur.

• swift
• android

1
2
3
4
5
6
7
8
9
"templated_message": {
  "data": {
    "message": "...",
    "type": "HTML",
    "message_close": "SWIPE",
    "trigger_id": "<TRIGGER_ID>"
  },
  "type": "inapp"
}

1
Triggering action: <CAMPAIGN_BSON_ID>

Affichage du message et impression

• swift
• android

1
2
3
In-app message ready for display:
- triggerId: (campaignId: <CAMPAIGN_ID>, ...)
- extras: { ... }

1
2
3
4
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: inAppMessageImpression(triggerIds: [...])

1
handleExistingInAppMessagesInStackWithDelegate:: Displaying in-app message

Événements de clic et de bouton

Lorsqu’un utilisateur appuie sur un bouton ou ferme le message :

• swift
• android

1
2
3
4
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: inAppMessageButtonClick(triggerIds: [...], buttonId: "<BUTTON_ID>")

1
No matching trigger for event.

Points à vérifier

• Si le message in-app ne s’affiche pas, vérifiez qu’un démarrage de session a bien été enregistré au préalable.
• Filtrez les réponses provenant de votre endpoint Braze configuré pour confirmer que le payload du message a été distribué.
• Si les impressions ne sont pas enregistrées, vérifiez que vous n’avez pas implémenté un délégué inAppMessageDisplay personnalisé qui supprime l’enregistrement.
• Si « No matching trigger for event » apparaît, c’est normal et indique qu’aucun message in-app supplémentaire n’est configuré pour cet événement.

Content Cards

Les journaux des Content Cards vous permettent de vérifier que les cartes sont synchronisées avec l’appareil, affichées à l’utilisateur et que les interactions (impressions, clics, rejets) sont suivies.

Synchronisation des cartes

Les Content Cards se synchronisent au début de la session et lorsqu’une actualisation manuelle est demandée. Si aucune session n’est enregistrée, aucune Content Card n’est affichée.

• swift
• android

1
2
3
4
5
6
7
8
9
10
11
"cards": [
  {
    "id": "<CARD_ID>",
    "tt": "<CARD_TITLE>",
    "ds": "<CARD_DESCRIPTION>",
    "tp": "short_news",
    "v": 0,
    "cl": 0,
    "p": 1
  }
]

1
Requesting content cards sync.

Impressions, clics et rejets

• swift
• android

1
2
3
4
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: contentCardImpression(cardIds: [...])

1
2
3
4
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: contentCardClick(cardIds: [...])

1
2
3
Opening '<URL>':
- channel: contentCard
- useWebView: true

1
2
3
4
Logged event:
- userId: <USER_ID>
- sessionId: <SESSION_ID>
- data: contentCardDismissed(cardIds: [...])

Éléments à vérifier

• Aucune carte affichée : vérifiez qu’un début de session est bien enregistré. Les Content Cards nécessitent une session active pour se synchroniser.
• Cartes manquantes pour les nouveaux utilisateurs : les nouveaux utilisateurs lors de leur première session peuvent ne pas voir les Content Cards avant la session suivante. Il s’agit d’un comportement normal.
• La carte dépasse la limite de taille : les Content Cards de plus de 2 Ko ne sont pas affichées et le message est abandonné.
• La carte persiste après l’arrêt de la campagne : vérifiez que la synchronisation s’est terminée après l’arrêt de la campagne. Les Content Cards sont supprimées de l’appareil après une synchronisation réussie. Lorsque vous arrêtez une campagne, assurez-vous que l’option permettant de supprimer les cartes actives des flux des utilisateurs est sélectionnée.

Deep links

Les journaux de deep links apparaissent dans les notifications push, les messages in-app et les Content Cards. La structure du journal est cohérente quel que soit le canal source.

• swift
• android

1
2
3
4
5
Opening '<DEEP_LINK_URL>':
- channel: <SOURCE_CHANNEL>
- useWebView: false
- isUniversalLink: false
- extras: { ... }

1
adb shell am start -W -a android.intent.action.VIEW -d "<YOUR_DEEP_LINK>" "<YOUR_PACKAGE_NAME>"

Points à vérifier

• Vérifiez que l’URL du deep link correspond à ce que vous avez configuré dans la Campaign.
• Si le deep link fonctionne depuis un canal (par exemple, les notifications push) mais pas depuis un autre (par exemple, les Content Cards), vérifiez que votre implémentation de gestion des deep links prend en charge tous les canaux.
• Sur iOS, les liens universels nécessitent une gestion supplémentaire. Si les liens universels ne fonctionnent pas depuis les canaux Braze, vérifiez que votre application implémente le protocole BrazeDelegate pour la gestion des URL.
• Sur Android, vérifiez que la gestion automatique des deep links est désactivée si vous utilisez un gestionnaire personnalisé. Sinon, le gestionnaire par défaut pourrait entrer en conflit avec votre implémentation.

Identification des utilisateurs

Lorsqu’un utilisateur est identifié avec un external_id, le SDK enregistre un événement de changement d’utilisateur.

• android
• swift

1
changeUser called with: <EXTERNAL_ID>

1
"user_id": "<EXTERNAL_ID>"

Requêtes réseau

Les logs détaillés incluent les détails complets des requêtes et réponses HTTP pour la communication du SDK avec les serveurs Braze. Ils sont utiles pour diagnostiquer les problèmes de connectivité.

Structure des requêtes

Filtrez les requêtes vers votre endpoint Braze configuré (par exemple, sdk.iad-01.braze.com). La structure des requêtes comprend :

• swift
• android

1
2
3
4
5
6
7
[http] request POST: <YOUR_BRAZE_ENDPOINT>
- Headers:
  - Content-Type: application/json
  - X-Braze-Api-Key: <REDACTED>
  - X-Braze-Req-Attempt: 1
  - X-Braze-Req-Tokens-Remaining: <COUNT>
- Body: { ... }

1
Making request(id = <REQUEST_ID>) to <YOUR_BRAZE_ENDPOINT>

Points à vérifier

• Clé API : Vérifiez que XBraze-ApiKey correspond à la clé API de votre espace de travail.
• Endpoint : Confirmez que l’URL de la requête correspond à l’endpoint SDK configuré.
• Tentatives de renvoi : Une valeur de XBraze-Req-Attempt supérieure à 1 indique que le SDK retente une requête échouée, ce qui peut signaler des problèmes de connectivité.
• Limitation du débit : XBraze-Req-Tokens-Remaining affiche les jetons de requête restants. Un nombre faible peut indiquer que le SDK approche des limites de débit.
• Requêtes manquantes : Sur Android, si vous ne voyez pas de requête vers l’endpoint Braze après le démarrage de la session, vérifiez la configuration de votre clé API et de votre endpoint.

Abréviations courantes des événements

Dans les payloads des journaux détaillés, Braze utilise des noms d’événements abrégés. Voici une référence :

Résolution des problèmes

Les géorepérages ne se déclenchent pas sur le SDK Android 13.1.0–15.x

Le SDK Android Braze 13.1.0 à 15.x présentait une régression qui pouvait empêcher l’enregistrement des événements de mise à jour de géorepérage. Sur les appareils fonctionnant sous Android 10 ou antérieur, les mises à jour de localisation au démarrage de session pouvaient également échouer. Passez au SDK Android 16.0.0 ou ultérieur. Pour la configuration du SDK, consultez Géorepérages.

Dans quels cas un utilisateur peut-il avoir 0 session enregistrée sur son profil ?

Un profil utilisateur peut afficher 0 session lorsque vous importez l’utilisateur via la REST API (/users/track) ou l’importation CSV sans les champs First session ou Last session. Les sessions sont enregistrées lorsque les utilisateurs interagissent avec votre application via le SDK. Pour plus de détails, consultez Le profil utilisateur a 0 session.

Divergences de données lors de l’utilisation conjointe du SDK et de la REST API

Lorsque vous utilisez le SDK et la REST API en même temps, des conditions de concurrence peuvent provoquer des divergences de données. Après avoir appelé changeUser(), laissez le SDK vider les données en attente avant d’effectuer des appels REST API critiques, évitez de regrouper les mises à jour sensibles au temps, et envisagez d’ajouter un court délai entre les requêtes SDK et API. Pour le comportement de changeUser(), consultez Fonctionnement de changeUser().

Les données n’arrivent pas à Braze

Si les données n’arrivent pas à Braze, vérifiez que votre pare-feu autorise le trafic sortant vers les endpoints de l’API Braze et les fournisseurs de CDN. Exécutez un test MTR et utilisez Fastly Debug pendant que le problème se produit. Pour la mise en liste d’autorisation et la résolution des problèmes de connectivité, consultez Problèmes de connectivité réseau API.