---
title: "Corriger l’erreur HTTP 499 et trouver qui a cessé d’attendre"
description: "HTTP 499 est le statut que nginx journalise quand le client ferme la connexion avant la réponse. Le client ne le voit jamais, et dans notre test l’upstream a terminé chaque requête."
canonical: "https://logbrew.co/fr/errors/http-499"
last_updated: "2026-11-21"
---

# Corriger l’erreur HTTP 499 et trouver qui a cessé d’attendre

HTTP 499 est le statut que nginx journalise quand le client ferme la connexion avant la réponse. Le client ne le voit jamais, et dans notre test l’upstream a terminé chaque requête.

Testé le 21 novembre 2026 avec nginx 1.31.8, curl 8.7.1, Python 3.13.5 et logbrew CLI 0.1.96

Par [Furkan Erday](https://github.com/furkanerday). Furkan Erday est le fondateur de LogBrew. Il développe LogBrew avec Claude Code et Codex tous les jours.

Canonical: https://logbrew.co/fr/errors/http-499

## Qui a cessé d’attendre, et ce que nginx a journalisé

| Qui a cessé d’attendre | Le client a reçu une réponse | `499` journalisé |
| --- | --- | --- |
| Personne, l’upstream a répondu en 0,2 s | `200` | `200` |
| Le client, après 2 s | Non | `499` |
| Le client, après 0,3 s | Non | `499` |
| nginx, après `proxy_read_timeout 3s` | `504` | `504` |
| Le client, nginx a continué d’attendre | Non | `200` |

5 requêtes via nginx 1.31.8, envoyées avec curl 8.7.1. Pour la dernière, `proxy_ignore_client_abort on` était actif.

## Trouver qui a cessé d’attendre

### Trouver les lignes 499 dans le log d’accès

nginx écrit `499` dans le log d’accès, et uniquement là. Au format par défaut `combined`, la ligne montre la requête et 0 octet envoyé, mais pas combien de temps chacun a attendu.

Sortie

```text
127.0.0.1 - - [21/Nov/2026:17:09:07 +0300] "GET /api/report?delay=5 HTTP/1.1" 499 0 "-" "curl/8.7.1"
127.0.0.1 - - [21/Nov/2026:17:09:08 +0300] "GET /api/report?delay=1 HTTP/1.1" 499 0 "-" "curl/8.7.1"
```

### Journaliser combien de temps chaque côté a attendu

Ajoutez `$request_time`, `$upstream_status` et `$upstream_response_time` à un `log_format` dans le bloc `http`, à côté de votre log par défaut. Lancez ensuite `nginx -s reload`.

```bash
log_format timing '$remote_addr "$request" $status $body_bytes_sent '
                  'request_time=$request_time '
                  'upstream_status=$upstream_status '
                  'upstream_response_time=$upstream_response_time';
access_log /var/log/nginx/timing.log timing;
```

### Lire request_time sur chaque ligne 499

`request_time` est le temps que le client a attendu avant de raccrocher. Nos clients ont abandonné après 2 s et après 0,3 s, et nginx a journalisé 2,006 et 0,301. `upstream_status` vaut `-`, car l’upstream n’avait pas encore répondu.

Sortie

```text
127.0.0.1 "GET /api/report?delay=5 HTTP/1.1" 499 0 request_time=2.006 upstream_status=- upstream_response_time=2.006
127.0.0.1 "GET /api/report?delay=1 HTTP/1.1" 499 0 request_time=0.301 upstream_status=- upstream_response_time=0.301
```

### Chercher 1 valeur qui revient

Beaucoup de lignes 499 avec presque le même `request_time` indiquent un timeout fixe devant nginx, par exemple celui du client lui-même. 3 clients avec `--max-time 2` ont donné 3 lignes entre 2,008 et 2,011 s. Comparez cette valeur avec `upstream_response_time` sur les lignes 200 du même chemin. Si l’upstream met souvent plus longtemps, il est trop lent pour ce client.

Sortie

```text
127.0.0.1 "GET /api/report?delay=4 HTTP/1.1" 499 0 request_time=2.011 upstream_status=- upstream_response_time=2.011
127.0.0.1 "GET /api/report?delay=4 HTTP/1.1" 499 0 request_time=2.011 upstream_status=- upstream_response_time=2.012
127.0.0.1 "GET /api/report?delay=4 HTTP/1.1" 499 0 request_time=2.008 upstream_status=- upstream_response_time=2.007
```

### Distinguer 499 et 504

Quand nginx cesse d’attendre en premier, il journalise `504`, et le client reçoit une page 504. `request_time` vaut alors votre `proxy_read_timeout`, 3 s dans notre test, et `upstream_status` vaut `504`, pas `-`. Le log d’erreurs indique `upstream timed out`.

Sortie

```text
127.0.0.1 "GET /short/report?delay=5 HTTP/1.1" 504 167 request_time=3.001 upstream_status=504 upstream_response_time=3.001
2026/11/21 17:09:11 [error] 61151#0: *35 upstream timed out (60: Operation timed out) while reading response header from upstream, client: 127.0.0.1, server: , request: "GET /short/report?delay=5 HTTP/1.1", upstream: "http://127.0.0.1:28500/api/report?delay=5", host: "127.0.0.1:28499"
```

## Corriger

### Faire répondre l’upstream avant que le client abandonne

Si les lignes 499 partagent 1 `request_time` et que les lignes 200 de ce chemin prennent plus longtemps, accélérez cet endpoint ou augmentez le timeout du client. Un `request_time` court, comme notre 0,301, signifie que le client a annulé la requête lui-même, par exemple quand l’utilisateur quitte la page.

### Arrêter le travail que personne n’attend

Notre upstream a journalisé 200 pour les deux requêtes que nginx a journalisées en 499. Il les a terminées 3 s et 0,7 s après le départ du client. nginx a fermé sa connexion upstream, mais l’upstream ne s’en est pas aperçu. Vérifiez si la connexion est fermée dans les handlers longs, ou déplacez le travail lent dans une tâche de fond.

Sortie

```text
14:09:05.796 upstream got /api/report?delay=5
14:09:07.822 upstream got /api/report?delay=1
14:09:08.827 upstream answered 200 after 1.0s
14:09:10.802 upstream answered 200 after 5.0s
```

### Laisser proxy_ignore_client_abort désactivé

Avec `proxy_ignore_client_abort on`, nginx a attendu l’upstream et journalisé `200` avec un `request_time` de 5,006, alors que curl avait raccroché après 2 s. Le 499 avait disparu du log. `off` est la valeur par défaut.

```bash
proxy_ignore_client_abort off;
```

Sortie

```text
127.0.0.1 "GET /keep/report?delay=5 HTTP/1.1" 200 12 request_time=5.006 upstream_status=200 upstream_response_time=5.006
```

### Envoyer les lignes 499 à LogBrew

LogBrew n’a pas d’intégration nginx, mais il accepte les logs OTLP. Cette commande envoie chaque ligne 499 et 504 comme 1 log. Définissez `LOGBREW_INGEST_KEY` avec une clé `server` de votre projet. Notre API LogBrew locale a répondu `{}`, elle a donc accepté chaque ligne.

```bash
grep -E '" (499|504) ' /var/log/nginx/timing.log |
  jq -Rn '{resourceLogs: [{resource: {attributes: [{key: "service.name", value: {stringValue: "nginx"}}]}, scopeLogs: [{logRecords: [inputs | {severityText: "WARN", body: {stringValue: .}}]}]}]}' |
  curl -sS https://api.logbrew.co/v1/logs -H "x-logbrew-key: $LOGBREW_INGEST_KEY" \
    -H 'Content-Type: application/json' --data-binary @-
```

Sortie

```text
{}
```

### Les rechercher avec la CLI LogBrew

Chaque ligne est 1 log de niveau `warning`, et son message est la ligne entière. Entourez 499 d’espaces dans la recherche, pour qu’un 499 dans un chemin ou une heure ne corresponde pas.

```bash
logbrew read logs --project "<project_id>" --service nginx --search ' 499 ' --since 1h
```

Sortie

```text
Logs (2)
- warning 127.0.0.1 "GET /api/report?delay=1 HTTP/1.1" 499 0 request_time=0.301 upstream_status=- upstream_response_time=0.301 service=nginx trace=3ded5398edda96df764625b26d6274f2 [unversioned / production]
- warning 127.0.0.1 "GET /api/report?delay=5 HTTP/1.1" 499 0 request_time=2.006 upstream_status=- upstream_response_time=2.006 service=nginx trace=4ad4df7e9d1f37c7dc182a77a1e83012 [unversioned / production]
```

## Ce que nous avons vu pendant le test

Nous avons lancé nginx 1.31.8 sur macOS 27.2 à `127.0.0.1:28499`, devant un upstream Python 3.13 qui attend les secondes de `?delay=` puis répond 200. curl 8.7.1 a envoyé 5 requêtes, dont 3 avec `--max-time`.

Dans les deux lignes 499, `request_time` correspondait au timeout de curl à 6 ms près, et `upstream_status` valait `-`. Dans la ligne 504, il correspondait à `proxy_read_timeout`, et `upstream_status` valait `504`.

|  | `$status` | `$request_time` | `$upstream_status` |
| --- | --- | --- | --- |
| Personne n’a abandonné | `200` | 0,206 s | `200` |
| Le client a abandonné après 2 s | `499` | 2,006 s | `-` |
| Le client a abandonné après 0,3 s | `499` | 0,301 s | `-` |
| nginx a abandonné après 3 s | `504` | 3,001 s | `504` |
| Le client a abandonné, nginx a continué d’attendre | `200` | 5,006 s | `200` |

## Pourquoi seul nginx voit le 499

499 n’est pas un code de statut HTTP. La RFC 9110 définit les codes 4xx, et 499 n’en fait pas partie. nginx le définit dans `src/http/ngx_http_request.h` sous le nom `NGX_HTTP_CLIENT_CLOSED_REQUEST`, pour un client qui a fermé la connexion avant que nginx envoie l’en-tête de la réponse.

Le client ne reçoit jamais de 499, car sa connexion est déjà fermée. nginx ferme aussi la connexion upstream et écrit `499` dans le log d’accès.

Au niveau par défaut du log d’erreurs, `error`, nginx n’écrit rien d’autre sur un 499. Au niveau `info`, il écrit `client prematurely closed connection`. Un 504 apparaît au niveau `error`.

1. Le client ferme la connexion
2. nginx ferme la connexion upstream
3. nginx écrit 499 dans le log d’accès

## Ce que LogBrew enregistre

LogBrew a stocké chaque ligne envoyée comme 1 log du service `nginx`, de niveau `warning`. Il garde la ligne entière comme message et ne la découpe pas en champs. Cherchez donc dans le texte.

Le tableau de bord, la CLI et le serveur MCP lisent ces logs comme n’importe quel autre log LogBrew.

- `nginx`
  - `level`: `warning`
  - Message: `… 499 0 request_time=0.301 …`
  - `trace`: `3ded5398edda96df764625b26d6274f2`

## Questions fréquentes

### Que signifie le code de statut HTTP 499 ?

Le client a fermé la connexion avant que nginx envoie la réponse, et nginx a journalisé 499. Ce statut ne fait pas partie de HTTP, et le client ne le reçoit jamais.

### Une erreur 499 vient-elle du client ou du serveur ?

C’est le client qui ferme la connexion, mais un upstream lent en est souvent la raison. Comparez `request_time` sur les lignes 499 avec `upstream_response_time` sur les lignes 200 du même chemin.

### Quelle est la différence entre 499 et 504 ?

499 signifie que le client a cessé d’attendre en premier. 504 signifie que nginx a cessé d’attendre en premier, après `proxy_read_timeout`, et le client reçoit le 504.

### Comment corriger les erreurs 499 dans nginx ?

Trouvez le timeout du client dans `request_time`, puis faites répondre l’upstream avant, ou augmentez ce timeout. `proxy_ignore_client_abort on` ne fait que cacher le 499 dans le log.

### L’upstream sait-il que le client est parti ?

Pas dans notre test. Notre upstream Python a journalisé 200 pour les deux requêtes que nginx a journalisées en 499, et a terminé chacune après le départ du client.

## Recherchez chaque ligne 499 au même endroit

Envoyez vos lignes de log nginx à LogBrew en logs OTLP, et recherchez-les depuis le tableau de bord, la CLI ou votre agent IA. Commencez avec le généreux forfait Free, sans carte bancaire.

[Commencer gratuitement](https://logbrew.co/fr)

## Sources

- [RFC 9110, HTTP Semantics, 15.5 Client Error 4xx](https://www.rfc-editor.org/rfc/rfc9110#section-15.5)
- [MDN, 504 Gateway Timeout](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/504)
- [LogBrew docs, Send OpenTelemetry data to LogBrew with OTLP](https://docs.logbrew.co/guides/opentelemetry)
- [LogBrewCo/docs, guides/opentelemetry.mdx](https://github.com/LogBrewCo/docs/blob/main/guides/opentelemetry.mdx)

## D’autres correctifs d’erreurs

- [Corriger l’erreur de script qui cache son message, son fichier et sa ligne](https://logbrew.co/fr/errors/script-error)
- [Corriger l’erreur Failed to fetch et distinguer ses 3 causes](https://logbrew.co/fr/errors/failed-to-fetch)
- [Corriger java.lang.NullPointerException en Kotlin et Android d’après son message](https://logbrew.co/fr/errors/nullpointerexception)
- [Corriger l’erreur Minified React #418 et #185 avec le message complet et votre ligne de code](https://logbrew.co/fr/errors/minified-react-error)
- [Corriger Cannot use import statement outside a module dans le navigateur et dans Node.js](https://logbrew.co/fr/errors/cannot-use-import-statement-outside-a-module)
- [Corriger l’erreur réseau AxiosError et trouver laquelle de ses 3 causes vous avez](https://logbrew.co/fr/errors/axios-network-error)
- [Les erreurs que nous avons reproduites, et comment corriger chacune](https://logbrew.co/fr/errors)
