> ## 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.

# Installa e usa la CLI di LogBrew

> Installa la CLI di LogBrew su macOS, Linux o Windows. Accedi, scegli un progetto e indaga sui problemi con l'output JSON.

L'interfaccia a riga di comando (CLI) di LogBrew legge log, problemi, tracce e
azioni da un terminale. Può anche aggiornare lo stato dei problemi. Usa
`--json` per avere un output strutturato per script e agenti IA.

Prima di eseguire un comando, sostituisci ogni segnaposto tra parentesi
angolari. Usa gli ID di progetto, problema e traccia restituiti da LogBrew.

## Installa la CLI

Scegli un metodo di installazione.

macOS o 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
```

Su Windows puoi anche installare il pacchetto MSI dall'[ultima
release](https://github.com/LogBrewCo/cli/releases/latest).

<Note>
  Cargo richiede Rust 1.87 o successivo. Gli altri metodi installano un
  binario nativo e non richiedono Rust.
</Note>

## Aggiorna la CLI

La CLI non si aggiorna da sola. Usa lo stesso metodo con cui l'hai installata.

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
```

Se hai usato l'installer per shell o PowerShell, eseguilo di nuovo.

Poi leggi la versione e confrontala con l'[ultima
release](https://github.com/LogBrewCo/cli/releases/latest):

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

Il JSON restituisce `ok`, `name`, `version`, `binary`, `os` e `arch`.

## Accedi e verifica la sessione

Leggi l'account associato al terminale corrente:

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

Se `whoami` mostra l'account previsto, continua. Altrimenti, accedi. Una
persona completa l'accesso al provider nel browser. Un agente di codifica deve
chiedere a una persona di eseguire questo passaggio.

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

Il provider è `github` (predefinito), `gitlab` o `bitbucket`. Usa `--no-open`
per stampare l'URL di accesso senza aprire un browser. Anche `--json` stampa i
dati per completare l'accesso senza aprire un browser.

Dopo l'accesso, esegui di nuovo `status` e `whoami`. Non inserire le
credenziali dell'account in un prompt, in un report o in un file sorgente.

## Pianifica la configurazione dell'SDK

Vai nella directory che contiene il manifest del pacchetto o della build
dell'app. In un monorepo, scegli un'app o un servizio. Poi esegui:

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

Leggi `detected`, `install_ready`, `install_plan` e `next`. Il piano di
installazione indica runtime, framework, gestore di pacchetti e comando di
installazione. La CLI non installa pacchetti e non modifica file.
`logbrew init`, `install`, `configure` e `sdk` restituiscono lo stesso piano.

<Warning>
  Nella configurazione dell'SDK inserisci una chiave di ingestione del
  progetto. Non usare mai una credenziale dell'account come chiave dell'SDK.
  Tieni le chiavi di ingestione fuori dal controllo di versione.
</Warning>

Per i passaggi specifici di ogni runtime, vedi [Invia telemetria con l'SDK](/it/guides/sdk-ingestion). Esegui `logbrew examples` per un breve
elenco dei comandi più comuni.

## Leggi, crea e configura i progetti

Elenca i progetti attivi del tuo account:

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

Scegli un ID progetto dal risultato. Usalo per le chiavi e per le letture.

Per creare una chiave di ingestione per un progetto esistente, scegli un nuovo
file fuori dal controllo di versione. La CLI scrive la chiave in quel file,
leggibile solo dal proprietario. Non stampa né la chiave né il percorso del
file.

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

| Flag | Valore |
| - | - |
| `--kind` | `sdk` (predefinito), `browser`, `server`, `cli` o `artifact`. Una chiave `artifact` carica source map e file di debug nativi. Non può inviare telemetria. |
| `--label` | Un nome per la chiave, fino a 120 caratteri. Il valore predefinito è `CLI-created SDK key`. |

Il risultato JSON contiene `status`, `project_id`, `ingest_key`, `checks` e
`next`. `ingest_key` contiene `id`, `label`, `kind`, `created_at` e
`expires_at` della chiave. Per sostituire una chiave, vedi [Ruota una chiave di
ingestione](/it/guides/rotate-ingest-key).

Questo comando crea una credenziale. Prima di eseguirlo, verifica che il
progetto sia quello giusto. Se il risultato è incerto, esegui di nuovo lo
stesso comando: la CLI riprende il tentativo in sospeso. Usa `--abandon-retry`
solo per avviare un nuovo tentativo.

Per creare un nuovo progetto, segui la [guida rapida](/it/quickstart). La guida
usa `logbrew projects create "<name>" --ingest-key-file "<private_key_file>"`,
che salva la prima chiave allo stesso modo. Esegui
`logbrew setup --create-project` per leggere l'aiuto sulla creazione del
progetto. Quel comando non crea un progetto.

Dopo un passaggio di configurazione, puoi registrarlo nel progetto. Il valore
di `--source` è `api`, `cli` o `sdk`:

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

Poi verifica se il progetto è pronto:

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

Il codice di uscita `0` non significa che tutti i controlli siano superati.
Leggi lo `status` del report e ogni controllo. Vedi il [riferimento del report di diagnostica](/it/reference/cli#read-a-project-doctor-report).

## Leggi l'utilizzo dell'account

Leggi utilizzo e limiti. Questo comando non cambia lo stato dell'account né
della fatturazione.

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

`logbrew account usage --json` restituisce lo stesso risultato. La risposta
indica il piano, lo stato della quota, la data di azzeramento, i totali di
utilizzo per progetto e per tipo di telemetria, e un passo successivo. Tra i
campi ci sono `plan`, `state`, `reset_at`, `by_project`, `by_stream` e
`next`.

## Indagini comuni

Filtra ogni lettura per progetto. Aggiungi filtri per release, ambiente, tempo
o gravità quando il comando li supporta. Vedi [Filtri](/it/reference/cli#filters).

<CardGroup cols={2}>
  <Card title="Problemi in una release" icon="tag">
    ```bash theme={null}
    logbrew read issues --project "<project_id>" --release api@1.2.3 --status unresolved --json
    ```
  </Card>

  <Card title="Una richiesta non riuscita" icon="route">
    ```bash theme={null}
    logbrew read trace "<trace_id>" --project "<project_id>" --json
    ```
  </Card>

  <Card title="Log di una release" icon="file-text">
    ```bash theme={null}
    logbrew read logs --project "<project_id>" --release api@1.2.3 --since 24h --json
    ```
  </Card>

  <Card title="Problemi assegnati a te" icon="user">
    ```bash theme={null}
    logbrew read issues --project "<project_id>" --assignee me --status unresolved --json
    ```
  </Card>
</CardGroup>

## Segui gli eventi in tempo reale

Usa watch per vedere i nuovi eventi mentre provi una modifica. Premi Ctrl+C per
fermarlo.

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

Watch trasmette solo JSON. Senza `--json`, il comando si interrompe con un
errore. Aggiungi `logs`, `issues` o `actions` per seguire un solo tipo, come
`logbrew watch logs --json`. Watch non supporta tracce né span.

Watch non ha filtri per progetto, release o ambiente. Per un solo progetto, usa
le letture qui sopra. Per le risorse e i filtri supportati, vedi [Monitoraggio in tempo reale](/it/reference/cli#live-watch).

## Spiega prima di modificare il codice

Leggi il contesto prima di proporre una correzione.

<Steps>
  <Step title="Leggi il problema">
    ```bash theme={null}
    logbrew read issue "<issue_id>" --json
    ```
  </Step>

  <Step title="Leggi la traccia">
    Esegui questo passaggio solo se il problema ha un ID traccia. Un problema
    senza traccia è comunque valido.

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

  <Step title="Leggi la spiegazione">
    ```bash theme={null}
    logbrew explain issue "<issue_id>" --json
    ```

    Per un log, usa `logbrew explain log "<log_id>" --json`. Per un'azione, usa
    `logbrew explain action "<action_id>" --json`.
  </Step>

  <Step title="Risolvi dopo la verifica">
    ```bash theme={null}
    logbrew set issue "<issue_id>" resolved --json
    ```

    Per cambiare stato, priorità o assegnatario di molti problemi, vedi
    [Cambia stato e priorità dei problemi](/it/reference/cli#change-issue-status-and-priority)
    e il [flusso di lavoro dei problemi](/it/guides/issue-workflow).
  </Step>
</Steps>

## Output JSON

* Metti `--json` prima o dopo il comando, come `logbrew --json status` o
  `logbrew status --json`.
* Leggi il codice di uscita prima di usare l'output.
* Gli errori JSON contengono `ok`, `error`, `message` e `next`. Un timeout non
  dimostra che una scrittura sia fallita. Prima di ripetere una scrittura,
  leggi le sue regole per i nuovi tentativi.
* Non automatizzare con un output senza `--json`: può cambiare.

Per i codici di uscita e gli esempi di errori, vedi [Leggi risultati ed
errori](/it/reference/cli#read-results-and-errors).


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