> ## Documentation Index
> Fetch the complete documentation index at: https://docs.logbrew.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Installer et utiliser la CLI LogBrew

> Installez la CLI LogBrew sur macOS, Linux ou Windows. Connectez-vous, choisissez un projet et investiguez les problèmes avec une sortie JSON.

L’interface en ligne de commande (CLI) de LogBrew lit les logs, problèmes,
traces et actions depuis un terminal. Elle peut aussi modifier le statut des
problèmes. Utilisez `--json` pour obtenir une sortie structurée destinée aux
scripts et aux agents IA.

Avant d’exécuter une commande, remplacez chaque espace réservé entre chevrons.
Utilisez les ID de projet, de problème et de trace renvoyés par LogBrew.

## <span id="install-the-cli">Installer la CLI</span>

Choisissez une méthode d’installation.

macOS ou Linux :

```bash theme={null}
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/LogBrewCo/cli/releases/latest/download/logbrew-cli-installer.sh | sh
```

Windows (PowerShell) :

```powershell theme={null}
powershell -ExecutionPolicy Bypass -c "irm https://github.com/LogBrewCo/cli/releases/latest/download/logbrew-cli-installer.ps1 | iex"
```

Homebrew :

```bash theme={null}
brew install LogBrewCo/tap/logbrew
```

npm :

```bash theme={null}
npm install -g logbrew-cli@latest
```

Cargo :

```bash theme={null}
cargo install logbrew-cli
```

Sous Windows, vous pouvez aussi installer le MSI depuis la
[dernière version publiée](https://github.com/LogBrewCo/cli/releases/latest).

<Note>
  Cargo nécessite Rust 1.87 ou une version plus récente. Les autres méthodes
  installent un binaire natif et n’ont pas besoin de Rust.
</Note>

## <span id="update-the-cli">Mettre à jour la CLI</span>

La CLI ne se met pas à jour automatiquement. Utilisez la méthode qui a servi à
l’installer.

Homebrew :

```bash theme={null}
brew update && brew upgrade LogBrewCo/tap/logbrew
```

npm :

```bash theme={null}
npm install -g logbrew-cli@latest
```

Cargo :

```bash theme={null}
cargo install --locked logbrew-cli
```

Si vous avez utilisé l’installateur shell ou PowerShell, exécutez-le de
nouveau.

Lisez ensuite la version. Comparez-la avec la
[dernière version publiée](https://github.com/LogBrewCo/cli/releases/latest) :

```bash theme={null}
logbrew version --json
```

Le JSON contient `ok`, `name`, `version`, `binary`, `os` et `arch`.

## <span id="sign-in-and-verify-the-session">Se connecter et vérifier la session</span>

Lisez le compte associé au terminal actuel :

```bash theme={null}
logbrew status --json
logbrew whoami --json
```

Si `whoami` affiche le compte attendu, continuez. Sinon, connectez-vous. Une
personne termine la connexion auprès du fournisseur dans le navigateur. Un
agent de codage doit demander à une personne de faire cette étape.

```bash theme={null}
logbrew login --provider github
```

Le fournisseur est `github` (par défaut), `gitlab` ou `bitbucket`. Utilisez
`--no-open` pour afficher l’URL de connexion sans ouvrir de navigateur.
`--json` affiche aussi les informations de connexion à transmettre, sans
ouvrir de navigateur.

Après la connexion, exécutez de nouveau `status` et `whoami`. Ne mettez pas
les identifiants du compte dans un prompt, un rapport ou un fichier source.

## <span id="plan-sdk-setup">Planifier la configuration du SDK</span>

Placez-vous dans le répertoire qui contient le manifeste de paquet ou de build
de l’application. Dans un monorepo, choisissez une seule application ou un
seul service. Puis exécutez :

```bash theme={null}
logbrew setup --json
```

Lisez `detected`, `install_ready`, `install_plan` et `next`. Le plan indique
le runtime, le framework, le gestionnaire de paquets et la commande
d’installation. La CLI n’installe aucun paquet et ne modifie aucun fichier.
`logbrew init`, `install`, `configure` et `sdk` donnent le même plan.

<Warning>
  Mettez une clé d’ingestion de projet dans la configuration du SDK.
  N’utilisez jamais un identifiant de compte comme clé SDK. Gardez les clés
  d’ingestion hors du dépôt de code.
</Warning>

Pour les étapes propres à chaque runtime, consultez
[Intégration du SDK](/fr/guides/sdk-ingestion). Exécutez
`logbrew examples` pour obtenir une courte liste des commandes courantes.

## <span id="read-create-and-configure-projects">Lire, créer et configurer des projets</span>

Listez les projets actifs de votre compte :

```bash theme={null}
logbrew projects --json
```

Choisissez un ID de projet dans le résultat. Utilisez-le pour les clés et les
lectures.

Pour créer une clé d’ingestion pour un projet existant, choisissez un nouveau
fichier hors du dépôt de code. La CLI écrit la clé dans ce fichier, lisible
uniquement par son propriétaire. Elle n’affiche ni la clé ni le chemin du
fichier.

```bash theme={null}
logbrew projects keys create "<project_id>" --ingest-key-file "<private_key_file>" --json
```

| Option | Valeur |
| - | - |
| `--kind` | `sdk` (par défaut), `browser`, `server`, `cli` ou `artifact`. Une clé `artifact` importe des source maps et des fichiers de débogage natifs. Elle ne peut pas envoyer de télémétrie. |
| `--label` | Un nom pour la clé, jusqu’à 120 caractères. La valeur par défaut est `CLI-created SDK key`. |

Le résultat JSON contient `status`, `project_id`, `ingest_key`, `checks` et
`next`. `ingest_key` contient les champs `id`, `label`, `kind`, `created_at`
et `expires_at` de la clé. Pour remplacer une clé, consultez
[Renouveler une clé d’ingestion](/fr/guides/rotate-ingest-key).

Cette commande crée un identifiant. Avant de l’exécuter, vérifiez que le
projet est le bon. Si le résultat est incertain, exécutez de nouveau la même
commande. La CLI réutilise alors la tentative en attente. Utilisez
`--abandon-retry` uniquement pour démarrer une nouvelle tentative.

Pour créer un nouveau projet, suivez le [démarrage rapide](/fr/quickstart). Il
utilise `logbrew projects create "<name>" --ingest-key-file "<private_key_file>"`,
qui enregistre la première clé de la même façon. Exécutez
`logbrew setup --create-project` pour lire l’aide sur la création de projet.
Cette commande ne crée pas de projet.

Après une étape de configuration, vous pouvez l’enregistrer pour le projet. La
valeur de `--source` est `api`, `cli` ou `sdk` :

```bash theme={null}
logbrew projects setup "<project_id>" --source cli --environment production --json
```

Lisez ensuite l’état de préparation du projet :

```bash theme={null}
logbrew doctor --project "<project_id>" --json
```

Le code de sortie `0` ne signifie pas que toutes les vérifications ont réussi.
Lisez le `status` du rapport et chaque vérification. Consultez la
[référence du rapport de diagnostic](/fr/reference/cli#read-a-project-doctor-report).

## <span id="read-account-usage">Lire l’utilisation du compte</span>

Lisez l’utilisation et les limites. Cette lecture ne modifie ni le compte ni
la facturation.

```bash theme={null}
logbrew usage --json
```

`logbrew account usage --json` donne le même résultat. La réponse indique le
forfait, l’état du quota, la date de réinitialisation, les totaux
d’utilisation par projet et par type de télémétrie, ainsi qu’une étape
suivante. Les champs comprennent `plan`, `state`, `reset_at`, `by_project`,
`by_stream` et `next`.

## <span id="common-investigations">Investigations courantes</span>

Filtrez chaque lecture par projet. Ajoutez des filtres de version,
d’environnement, de période ou de gravité quand la commande les prend en
charge. Consultez [Filtres](/fr/reference/cli#filters).

<CardGroup cols={2}>
  <Card title="Problèmes d’une version" icon="tag">
    ```bash theme={null}
    logbrew read issues --project "<project_id>" --release api@1.2.3 --status unresolved --json
    ```
  </Card>

  <Card title="Une requête en échec" icon="route">
    ```bash theme={null}
    logbrew read trace "<trace_id>" --project "<project_id>" --json
    ```
  </Card>

  <Card title="Logs d’une version" icon="file-text">
    ```bash theme={null}
    logbrew read logs --project "<project_id>" --release api@1.2.3 --since 24h --json
    ```
  </Card>

  <Card title="Problèmes qui vous sont attribués" icon="user">
    ```bash theme={null}
    logbrew read issues --project "<project_id>" --assignee me --status unresolved --json
    ```
  </Card>
</CardGroup>

## <span id="watch-live-events">Suivre les événements en direct</span>

Utilisez la commande watch pour voir les nouveaux événements pendant que vous
testez une modification. Appuyez sur Ctrl+C pour l’arrêter.

```bash theme={null}
logbrew watch --severity error,critical --json
```

Watch diffuse uniquement du JSON. Sans `--json`, la commande s’arrête avec une
erreur. Ajoutez `logs`, `issues` ou `actions` pour suivre un seul type, par
exemple `logbrew watch logs --json`. Watch ne prend en charge ni les traces ni
les spans.

Watch n’a pas de filtre de projet, de version ni d’environnement. Pour un seul
projet, utilisez les lectures ci-dessus. Pour les ressources et les filtres
pris en charge, consultez [Suivi en direct](/fr/reference/cli#live-watch).

## <span id="explain-before-you-change-code">Obtenir une explication avant de modifier le code</span>

Lisez le contexte avant de proposer un correctif.

<Steps>
  <Step title="Lire le problème">
    ```bash theme={null}
    logbrew read issue "<issue_id>" --json
    ```
  </Step>

  <Step title="Lire la trace">
    Faites cette étape seulement si le problème a un ID de trace. Un problème
    sans trace reste valide.

    ```bash theme={null}
    logbrew read trace "<trace_id>" --project "<project_id>" --json
    ```
  </Step>

  <Step title="Lire l’explication">
    ```bash theme={null}
    logbrew explain issue "<issue_id>" --json
    ```

    Pour un log, utilisez `logbrew explain log "<log_id>" --json`. Pour une
    action, utilisez `logbrew explain action "<action_id>" --json`.
  </Step>

  <Step title="Résoudre après vérification">
    ```bash theme={null}
    logbrew set issue "<issue_id>" resolved --json
    ```

    Pour modifier le statut, la priorité ou le responsable de nombreux
    problèmes, consultez
    [Modifier le statut et la priorité des problèmes](/fr/reference/cli#change-issue-status-and-priority)
    et le [workflow des problèmes](/fr/guides/issue-workflow).
  </Step>
</Steps>

## <span id="json-output">Sortie JSON</span>

* Placez `--json` avant ou après la commande, par exemple
  `logbrew --json status` ou `logbrew status --json`.
* Lisez le code de sortie avant d’utiliser la sortie.
* Les erreurs JSON contiennent `ok`, `error`, `message` et `next`. Un délai
  dépassé ne prouve pas qu’une écriture a échoué. Avant de répéter une
  écriture, lisez ses règles de nouvelle tentative.
* N’automatisez rien avec une sortie sans `--json`. Elle peut changer.

Pour les codes de sortie et des exemples d’erreurs, consultez
[Lire les résultats et les erreurs](/fr/reference/cli#read-results-and-errors).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.