> For the complete documentation index, see [llms.txt](https://docs.thewalletcrew.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.thewalletcrew.io/guides-monitoring/fr/monitor/recuperer-les-journaux-de-la-plateforme.md).

# Récupérer les journaux de la plateforme

Trouvez, filtrez et exportez les journaux de la plateforme The Wallet Crew depuis le back office, l’API Insights ou un assistant IA connecté via MCP.

Les journaux de la plateforme retracent l’activité de la plateforme pour un locataire. Ils couvrent les rendus de Carte, les envois planifiés, les appels de connecteur, les rechargements de configuration et les importations en échec.

Les journaux sont disponibles via trois systèmes :

| Système                        | Idéal pour                                                                             | Accès                                  |
| ------------------------------ | -------------------------------------------------------------------------------------- | -------------------------------------- |
| **Interface d’administration** | Recherches rapides, support quotidien et exports CSV                                   | Un compte Back-office                  |
| **API Insights**               | Requêtes répétables, agrégation, alerting et pipelines BI                              | Une clé API avec `Insights:Read`       |
| **MCP**                        | Investigations en langage clair à travers les journaux, la configuration et les Cartes | Un compte Back-office et un client MCP |

## Source de données de journaux partagée

L’interface d’administration, l’API Insights et MCP lisent tous la même `Journaux` table. Chaque requête est limitée à un seul locataire. Les données d’un autre locataire sont inaccessibles.

Les journaux de la plateforme sont conservés pendant **45 jours**. Exportez les preuves nécessaires pour les audits, les analyses post-mortem ou les litiges avant la fin de cette période.

<details>

<summary><strong>Exemples concrets</strong></summary>

* Un agent de support vérifie si une notification push a quitté la plateforme.
* Un ingénieur d’intégration retrace un appel d’API en échec à l’aide de son identifiant d’opération.
* Une équipe des opérations compte les erreurs de composant avant d’escalader un incident.
* Un assistant IA enquête sur un incident et résume les lignes de journal pertinentes.

</details>

{% hint style="warning" %}
Les journaux de la plateforme peuvent contenir des identifiants, des chemins de requête, des agents utilisateurs et des charges utiles d’erreur. Traitez-les comme des données opérationnelles sensibles. Partagez des extraits, pas des exports, et uniquement avec les personnes qui en ont besoin.
{% endhint %}

{% hint style="danger" %}
Les journaux de la plateforme restent disponibles pendant **45 jours seulement**. Les lignes plus anciennes ne peuvent pas être récupérées.
{% endhint %}

## Ce qu’un enregistrement de journal contient

Chaque route expose le même enregistrement. Le back-office affiche un sous-ensemble de ces colonnes. L’API Insights et MCP exposent toutes les colonnes.

| Colonne                                                                    | Type       | Ce qu’elle contient                                                                       |
| -------------------------------------------------------------------------- | ---------- | ----------------------------------------------------------------------------------------- |
| `Horodatage`                                                               | date/heure | Quand la ligne a été émise, en UTC                                                        |
| `Message`                                                                  | chaîne     | Message rendu lisible par l’humain                                                        |
| `Niveau de gravité`                                                        | entier     | Niveau de gravité ; voir ci-dessous                                                       |
| `Nom de catégorie`                                                         | chaîne     | Composant de la plateforme émetteur, tel que `Neo.Runtime.Wallet.Apple.AppleCarteHandler` |
| `Nom de l’opération`                                                       | chaîne     | Opération active, telle que `HTTP POST /api/mcp` ou le nom d’une tâche planifiée          |
| `Identifiant d’opération`                                                  | chaîne     | Identifiant de corrélation pour suivre une requête de bout en bout                        |
| `Identifiant de requête`                                                   | chaîne     | Identifiant individuel de requête au sein d’une opération                                 |
| `Propriétés`                                                               | dynamique  | Champs structurés, tels que `requestPath` et `originalFormat`                             |
| `UserAgent`                                                                | chaîne     | Client déclencheur, lorsque disponible                                                    |
| `Identifiant utilisateur` / `Nom d’utilisateur` / `Identifiant de session` | chaîne     | Contexte de l’acteur, lorsqu’attribué                                                     |
| `Nom du rôle d’application`                                                | chaîne     | Rôle de la plateforme qui a généré la ligne                                               |
| `Identifiant du locataire`                                                 | chaîne     | Identifiant du locataire actuel                                                           |
| `Id`                                                                       | guid       | Identifiant unique de l’enregistrement                                                    |

### Niveaux de gravité

`Niveau de gravité` est stocké sous forme de nombre. Le back office l’affiche sous forme d’un badge libellé.

| Valeur | Libellé       | À lire comme                                                |
| ------ | ------------- | ----------------------------------------------------------- |
| `0`    | Très détaillé | Détails de bas niveau, rarement émis                        |
| `1`    | Information   | Fonctionnement normal et la majorité du volume des journaux |
| `2`    | Avertissement | Un élément s’est rétabli, est dégradé ou a été retenté      |
| `3`    | Erreur        | Une opération a échoué                                      |
| `4`    | Critique      | Une défaillance à large impact                              |

{% hint style="info" %}
Les locataires sains génèrent de nombreuses `Information` lignes. Filtrez sur `SeverityLevel >= 2` avant de tirer des conclusions.
{% endhint %}

## Interface d’administration : journaux d’application

L’interface d’administration est le moyen le plus rapide pour le travail de support.

{% stepper %}
{% step %}

#### Ouvrez la page

Dans le back office, accédez à **Paramètres → Surveillance → Journaux**.

```
https://admin.thewalletcrew.io/tenant/~/settings/tools/logs
```

Le `~` renvoie au locataire actuel de l'utilisateur connecté. Ce lien peut être partagé sans modification.
{% endstep %}

{% step %}

#### Définir la période

Le sélecteur de date est défini par défaut sur **30 derniers jours**. Les préréglages incluent Aujourd'hui, les 7 derniers jours, cette semaine, les 30 derniers jours, ce mois-ci, cette année, le mois dernier, les 3 derniers mois, les 12 derniers mois, l'année dernière et toute la période. Une **Personnalisée** plage est également disponible.

Les plages de plus de 45 jours ne renvoient rien au-delà de la rétention. Réduisez d'abord la période.
{% endstep %}

{% step %}

#### Rechercher

La zone de recherche fait correspondre le texte dans toutes les colonnes, y compris `Propriétés`. Il n'y a pas de sélecteur de champ.

Les termes de recherche utiles incluent un numéro de série de Carte, un `Identifiant d’opération`, un fragment d'erreur ou un chemin de requête tel que `/api/mcp`.

Le terme est stocké dans l'adresse sous la forme `?search=...`. Une vue filtrée peut donc être partagée telle quelle.
{% endstep %}

{% step %}

#### Lire les résultats

Les résultats sont classés du plus récent au plus ancien. Le **Horodatage** en-tête modifie l'ordre de tri. Développez une **Propriétés** cellule pour afficher les champs structurés.

Copiez un **ID d'opération** et recherchez-le pour suivre une requête. Chaque ligne écrite pendant cette requête partage cet identifiant.
{% endstep %}

{% step %}

#### Exporter

**Exporter les journaux** télécharge la vue actuelle au format CSV, limitée à **10 000 lignes**. Réduisez la période et le terme de recherche avant d'exporter.

Utilisez l'API Insights pour des exportations plus volumineuses ou récurrentes.
{% endstep %}
{% endstepper %}

## API Insights

Le [API Insights](/developers-guides/fr/integration-guides/insights-api.md) interroge les données de journal partagées avec [Kusto Query Language (KQL)](https://learn.microsoft.com/en-us/kusto/query/). L'interface d'administration utilise cette API.

### S'authentifier

Créez une clé API dans **Paramètres → Sécurité → Clés API**. Accordez la **`Insights:Read`** autorisation. Copiez la clé lorsqu'elle s'affiche, car elle ne sera plus affichée.

{% hint style="info" %}
Le back-office appelle l'autorisation `Insights:Read`. La référence du point de terminaison l'appelle `Insights.Read`. Les deux noms désignent la même portée.
{% endhint %}

```http
POST /api/{tenantId}/insights/query
X-API-KEY: <API_KEY>
Content-Type: application/json
```

| Environnement | URL de base                     |
| ------------- | ------------------------------- |
| Production    | `https://app.neostore.cloud`    |
| QA            | `https://app-qa.neostore.cloud` |

### Première requête

```bash
curl -X POST "https://app.neostore.cloud/api/<TENANT_ID>/insights/query" \
  -H "X-API-KEY: <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Logs | where Timestamp > ago(1h) and SeverityLevel >= 3 | project Timestamp, CategoryName, OperationId, Message | order by Timestamp desc | take 50"
  }'
```

La réponse est tabulaire :

```json
{
  "columns": ["Timestamp", "CategoryName", "OperationId", "Message"],
  "lignes": [
    ["2026-09-14T19:15:02.117Z", "Neo.Runtime.Http...", "4454c9229...", "..."]
  ]
}
```

{% hint style="warning" %}
Chaque table Insights, `Journaux` et `Événements` inclus, utilise **PascalCase** noms de colonne. KQL est sensible à la casse, donc `horodatage` ne se résout pas là où `Horodatage` le fait.
{% endhint %}

### Recettes de requêtes

**Erreurs et avertissements au fil du temps**

```kql
Journaux
| where Timestamp > ago(7d)
| summarize Errors = countif(SeverityLevel >= 3),
          Warnings = countif(SeverityLevel == 2)
  by bin(Timestamp, 1h)
| order by Timestamp asc
```

**Quel composant est défaillant**

```kql
Journaux
| where Timestamp > ago(7d) and SeverityLevel >= 3
| summarize Failures = count() by CategoryName
| trier par Échecs décroissant
| prenez 20
```

**Tracez une requête de bout en bout**

```kql
Journaux
| where OperationId == "<OPERATION_ID>"
| projet Horodatage, NiveauDegravité, NomDeCatégorie, NomD’opération, Message, Propriétés
| order by Timestamp asc
```

**Tout ce qui touche une Carte**

```kql
Journaux
| where Timestamp > ago(30d)
| où * contient "<PASS_SERIAL>"
| project Timestamp, SeverityLevel, CategoryName, Message
| trier par horodatage décroissant
```

**Filtrer sur une propriété structurée**

```kql
Journaux
| where Timestamp > ago(2d)
| where tostring(Properties.requestPath) startswith "/api/"
| summarize Calls = count() by tostring(Properties.requestPath)
| order by Calls desc
| take 25
```

**Taux d’erreur en pourcentage**

```kql
Journaux
| where Timestamp > ago(24h)
| summarize Total = count(), Failures = countif(SeverityLevel >= 3)
| extend ErrorRate = round(100.0 * Failures / Total, 2)
```

### Requêtes paramétrées

Passez les valeurs séparément du texte de la requête. Les paramètres arrivent sous forme de **chaînes**, alors convertissez-les dans la requête.

```json
{
  "query": "Logs\n| where Timestamp between (todatetime(start) .. todatetime(stop))\n| where * contains searchQuery\n| order by Timestamp desc\n| take toint(pageSize)\n| project Timestamp, Message, OperationName, OperationId, SeverityLevel, CategoryName, Properties",
  "parameters": {
    "start": "2026-09-01T00:00:00.000Z",
    "stop": "2026-09-14T23:59:59.999Z",
    "searchQuery": "outdated",
    "pageSize": "100"
  }
}
```

Parcourez de grands résultats en numérotant et en découpant les lignes :

```kql
| serialize rowNum = row_number()
| where rowNum > (toint(pageIndex) * toint(pageSize))
  and rowNum <= ((toint(pageIndex) + 1) * toint(pageSize))
```

### Limites

| Limite              | Valeur                                                                                                                                                                                   |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Portée requise      | `Insights:Read`                                                                                                                                                                          |
| Limite de débit     | 60 requêtes par minute                                                                                                                                                                   |
| Portée du locataire | Locataire unique ; les données d’un autre locataire sont inaccessibles                                                                                                                   |
| Limite de lignes    | A `maxRows` protège contre les requêtes incontrôlées. Le dépasser fait échouer la requête plutôt que de renvoyer un échantillon tronqué. Augmentez-la délibérément pour une exportation. |
| Mise en cache       | Aucune. Mettez en cache côté client lors du sondage.                                                                                                                                     |

{% hint style="info" %}
Une requête dépassant `maxRows` échoue volontairement. Un résultat tronqué peut paraître complet tout en omettant des lignes.
{% endhint %}

## MCP : pour les assistants d’IA

Un assistant connecté à MCP peut lire les journaux partagés. Il peut aussi vérifier la configuration, l’historique des cartes et les exécutions d’automatisation au cours d’une seule investigation. Voir [Model Context Protocol (MCP)](/connectors/fr/model-context-protocol-mcp.md) pour les instructions de configuration.

| Environnement | Point de terminaison                        |
| ------------- | ------------------------------------------- |
| Production    | `https://admin.thewalletcrew.io/api/mcp`    |
| QA            | `https://admin-qa.thewalletcrew.io/api/mcp` |

Connectez-vous avec les identifiants Back-office. La connexion est en lecture seule.

### Les outils qui comptent pour les journaux

| Outil                                   | Utilisation                                      |
| --------------------------------------- | ------------------------------------------------ |
| `insights_schema`                       | Confirmer les tables et les colonnes disponibles |
| `exemples_de_requêtes_sur_les_analyses` | Récupérer des modèles de requêtes fonctionnels   |
| `requête_d'analyses`                    | Exécuter KQL et renvoyer les résultats           |

### Modèles de prompt

> Affichez toutes les erreurs et tous les avertissements des dernières 24 heures, regroupés par composant. Pour les trois les plus bruyants, expliquez le composant et les messages.

> Rechercher les lignes de journal pour Carte `<PASS_ID>` des 7 derniers jours. Reconstituez ce qui s'est passé et identifiez les étapes ayant échoué.

> Opération `<OPERATION_ID>` a échoué. Récupérez ses lignes dans l'ordre et identifiez où cela a cassé.

> Comparez le volume d'erreurs de cette semaine avec celui de la semaine dernière. Signalez les composants dont les échecs ont plus que doublé.

{% hint style="info" %}
Gardez la plage temporelle étroite. Chaque appel d'outil est limité à deux minutes. Les requêtes larges `Journaux` peuvent atteindre cette limite.
{% endhint %}

## Dépannage

| Ce qui apparaît                                     | Signification                                                                                                 |
| --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `401 Non autorisé`                                  | La clé API est manquante, mal saisie ou révoquée.                                                             |
| `403 Interdit`                                      | La clé ou le compte ne dispose pas `Insights:Read` des autorisations pour ce locataire.                       |
| Aucune ligne alors que des lignes étaient attendues | Vérifiez la fenêtre de conservation de 45 jours, puis la casse des colonnes. Chaque table utilise PascalCase. |
| `400` sur une requête apparemment correcte          | Un nom de colonne est incorrect ou un paramètre n'a pas de cast. Utilisez `todatetime()` ou `toint()`.        |
| La requête expire                                   | Réduisez la plage temporelle, filtrez par `Niveau de gravité`et ne sélectionnez que les colonnes nécessaires. |
| Erreurs de limitation de débit                      | La limite est de 60 requêtes par minute. Regroupez avec `summarize` au lieu de boucles d'interrogation.       |
| Nombres inconnus                                    | Confirmez l'environnement. QA contient des données de test, pas des données de production.                    |

## Bonne pratique

* Commencez de manière ciblée. Une plage temporelle et un filtre de gravité accélèrent les étapes suivantes.
* Corrélez avec `Identifiant d’opération`et non avec les horodatages. Les horodatages s'entremêlent entre les requêtes.
* Exportez les preuves d'audit avant la fin de leur fenêtre de 45 jours.
* Citez les lignes pertinentes dans les tickets, les chats et les prompts d'IA. Évitez les exportations complètes.
* Testez les requêtes en QA. Utilisez la production lorsque des preuves de production sont requises.

## FAQ

<details>

<summary>Combien de temps les journaux sont-ils conservés ?</summary>

Les journaux sont conservés pendant 45 jours. Les événements Wallet dans `Événements` restent disponibles indéfiniment. Exportez tout élément de valeur durable avant la fermeture de la fenêtre.

</details>

<details>

<summary>Peut-on exporter plus de 10 000 lignes ?</summary>

Le back office ne peut pas exporter plus de 10 000 lignes. Utilisez l'API Insights, paginez les résultats avec `row_number()`et augmentez `maxRows` délibérément.

</details>

<details>

<summary>Pourquoi une requête `Events` ne fonctionne-t-elle pas sur `Logs` ?</summary>

Les deux tables contiennent des colonnes différentes. `Événements` contient l'événement dans `Nom` et son charge utile dans `EventData`, tandis que `Journaux` contient `Niveau de gravité`, `Message`, `Nom de catégorie` et `Propriétés`. Les deux utilisent PascalCase. Le [API Insights](/developers-guides/fr/integration-guides/insights-api.md) page répertorie les colonnes de chaque table.

</details>

<details>

<summary>Peut-on interroger les journaux d’un autre tenant ?</summary>

Non. Chaque route est limitée à un tenant et appliquée côté serveur.

</details>

<details>

<summary>Un live tail est-il disponible ?</summary>

Aucun live tail en libre-service n’est disponible. Réglez la période sur **Aujourd’hui** et actualisez le back office, ou interrogez l’API Insights sur une plage étroite.

</details>

<details>

<summary>Faut-il utiliser les journaux ou l’API Insights pour les rapports ?</summary>

Utilisez les événements du wallet pour les rapports. Les journaux de la plateforme décrivent le comportement du système, pas les performances du programme. Pour l’adoption, les installations et les scans, voir Interrogez vos données — API Insights et définitions des KPI.

</details>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.thewalletcrew.io/guides-monitoring/fr/monitor/recuperer-les-journaux-de-la-plateforme.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.