---
title: "Napraw błąd HTTP 499 i ustal, kto przestał czekać"
description: "HTTP 499 to status, który nginx zapisuje, gdy klient zamyka połączenie przed odpowiedzią. Klient nigdy go nie widzi, a w naszym teście upstream dokończył każde żądanie."
canonical: "https://logbrew.co/pl/errors/http-499"
last_updated: "2026-11-21"
---

# Napraw błąd HTTP 499 i ustal, kto przestał czekać

HTTP 499 to status, który nginx zapisuje, gdy klient zamyka połączenie przed odpowiedzią. Klient nigdy go nie widzi, a w naszym teście upstream dokończył każde żądanie.

Przetestowane 21 listopada 2026 z użyciem nginx 1.31.8, curl 8.7.1, Python 3.13.5 i logbrew CLI 0.1.96

Autor [Furkan Erday](https://github.com/furkanerday). Furkan Erday jest założycielem LogBrew. Codziennie rozwija LogBrew z pomocą Claude Code i Codex.

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

## Kto przestał czekać i co zapisał nginx

| Kto przestał czekać | Klient dostał odpowiedź | Zapisano `499` |
| --- | --- | --- |
| Nikt, upstream odpowiedział po 0,2 s | `200` | `200` |
| Klient, po 2 s | Nie | `499` |
| Klient, po 0,3 s | Nie | `499` |
| nginx, po `proxy_read_timeout 3s` | `504` | `504` |
| Klient, nginx czekał dalej | Nie | `200` |

5 żądań przez nginx 1.31.8, wysłanych curl 8.7.1. Ostatnie wysłaliśmy z `proxy_ignore_client_abort on`.

## Ustal, kto przestał czekać

### Znajdź linie 499 w logu dostępu

nginx zapisuje `499` w logu dostępu i tylko tam. W domyślnym formacie `combined` linia pokazuje żądanie i 0 wysłanych bajtów, ale nie to, jak długo ktoś czekał.

Wynik

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

### Zapisuj, jak długo czekała każda strona

Dodaj `$request_time`, `$upstream_status` i `$upstream_response_time` do `log_format` w bloku `http`, obok domyślnego logu. Potem uruchom `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;
```

### Sprawdź czas oczekiwania klienta w liniach 499

`request_time` to czas, przez który klient czekał, zanim się rozłączył. Nasi klienci zrezygnowali po 2 s i po 0,3 s, a nginx zapisał 2,006 i 0,301. `upstream_status` to `-`, bo upstream jeszcze nie odpowiedział.

Wynik

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

### Szukaj 1 powtarzającej się wartości

Wiele linii 499 z prawie tym samym `request_time` wskazuje na stały timeout przed nginx, na przykład timeout samego klienta. 3 klientów z `--max-time 2` dało 3 linie od 2,008 do 2,011 s. Porównaj tę wartość z `upstream_response_time` w liniach 200 tej samej ścieżki. Jeśli upstream często potrzebuje więcej czasu, jest dla tego klienta za wolny.

Wynik

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

### Odróżnij 499 od 504

Gdy pierwszy przestaje czekać nginx, zapisuje `504`, a klient dostaje stronę 504. Wtedy `request_time` to Twój `proxy_read_timeout`, w naszym teście 3 s, a `upstream_status` to `504`, nie `-`. Log błędów podaje `upstream timed out`.

Wynik

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

## Napraw

### Niech upstream odpowie, zanim klient zrezygnuje

Jeśli linie 499 mają wspólny `request_time`, a linie 200 tej ścieżki trwają dłużej, przyspiesz ten endpoint albo zwiększ timeout w kliencie. Krótki `request_time`, jak nasze 0,301, oznacza, że klient sam anulował żądanie, na przykład gdy użytkownik opuścił stronę.

### Zatrzymaj pracę, na którą nikt nie czeka

Nasz upstream zapisał 200 dla obu żądań, które nginx zapisał jako 499. Dokończył je 3 s i 0,7 s po odejściu klienta. nginx zamknął połączenie z upstreamem, ale upstream tego nie zauważył. W długich handlerach sprawdzaj, czy połączenie jest zamknięte, albo przenieś wolną pracę do zadania w tle.

Wynik

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

### Zostaw proxy_ignore_client_abort wyłączone

Z `proxy_ignore_client_abort on` nginx czekał na upstream i zapisał `200` z `request_time` równym 5,006, choć curl rozłączył się po 2 s. 499 zniknęło z logu. `off` to wartość domyślna.

```bash
proxy_ignore_client_abort off;
```

Wynik

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

### Wyślij linie 499 do LogBrew

LogBrew nie ma integracji z nginx, ale przyjmuje logi OTLP. To polecenie wysyła każdą linię 499 i 504 jako 1 log. Ustaw `LOGBREW_INGEST_KEY` na klucz `server` swojego projektu. Nasze lokalne API LogBrew odpowiedziało `{}`, więc przyjęło każdą linię.

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

Wynik

```text
{}
```

### Przeszukaj je w CLI LogBrew

Każda linia to 1 log z poziomem `warning`, a jego wiadomość to cała linia. Otocz 499 spacjami w wyszukiwaniu, żeby nie trafić na 499 w ścieżce albo w godzinie.

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

Wynik

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

## Co zobaczyliśmy w teście

Uruchomiliśmy nginx 1.31.8 na macOS 27.2 pod `127.0.0.1:28499`, przed upstreamem w Pythonie 3.13, który czeka tyle sekund, ile podano w `?delay=`, a potem odpowiada 200. curl 8.7.1 wysłał 5 żądań, 3 z nich z `--max-time`.

W obu liniach 499 `request_time` różnił się od timeoutu curl o najwyżej 6 ms, a `upstream_status` miał wartość `-`. W linii 504 zgadzał się z `proxy_read_timeout`, a `upstream_status` miał wartość `504`.

|  | `$status` | `$request_time` | `$upstream_status` |
| --- | --- | --- | --- |
| Nikt nie zrezygnował | `200` | 0,206 sek. | `200` |
| Klient zrezygnował po 2 s | `499` | 2,006 sek. | `-` |
| Klient zrezygnował po 0,3 s | `499` | 0,301 sek. | `-` |
| nginx zrezygnował po 3 s | `504` | 3,001 sek. | `504` |
| Klient zrezygnował, nginx czekał dalej | `200` | 5,006 sek. | `200` |

## Dlaczego tylko nginx widzi 499

499 nie jest kodem statusu HTTP. RFC 9110 definiuje kody 4xx, a 499 do nich nie należy. nginx definiuje go w `src/http/ngx_http_request.h` jako `NGX_HTTP_CLIENT_CLOSED_REQUEST`, dla klienta, który zamknął połączenie, zanim nginx wysłał nagłówek odpowiedzi.

Klient nigdy nie dostaje 499, bo jego połączenie jest już zamknięte. nginx zamyka też połączenie z upstreamem i zapisuje `499` w logu dostępu.

Na domyślnym poziomie logu błędów, `error`, nginx nie zapisuje o 499 nic więcej. Na poziomie `info` zapisuje `client prematurely closed connection`. 504 pojawia się na poziomie `error`.

1. Klient zamyka połączenie
2. nginx zamyka połączenie z upstreamem
3. nginx zapisuje 499 w logu dostępu

## Co zapisuje LogBrew

LogBrew zapisał każdą wysłaną linię jako 1 log usługi `nginx` z poziomem `warning`. Trzyma całą linię jako wiadomość i nie dzieli jej na pola, więc przeszukuj tekst.

Panel, CLI i serwer MCP czytają te logi jak każdy inny log LogBrew.

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

## Najczęściej zadawane pytania

### Co oznacza kod statusu HTTP 499?

Klient zamknął połączenie, zanim nginx wysłał odpowiedź, a nginx zapisał 499. Ten status nie należy do HTTP i klient nigdy go nie dostaje.

### Czy błąd 499 powoduje klient, czy serwer?

Połączenie zamyka klient, ale przyczyną jest często wolny upstream. Porównaj `request_time` w liniach 499 z `upstream_response_time` w liniach 200 tej samej ścieżki.

### Czym się różni 499 od 504?

499 oznacza, że pierwszy przestał czekać klient. 504 oznacza, że pierwszy przestał czekać nginx, po `proxy_read_timeout`, a klient dostaje 504.

### Jak naprawić błędy 499 w nginx?

Znajdź timeout klienta w `request_time`, a potem spraw, żeby upstream odpowiadał szybciej, albo zwiększ ten timeout. `proxy_ignore_client_abort on` tylko ukrywa 499 w logu.

### Czy upstream wie, że klient odszedł?

W naszym teście nie. Nasz upstream w Pythonie zapisał 200 dla obu żądań, które nginx zapisał jako 499, i dokończył każde z nich, gdy klienta już nie było.

## Przeszukuj każdą linię 499 w 1 miejscu

Wysyłaj linie logu nginx do LogBrew jako logi OTLP i przeszukuj je w panelu, w CLI albo przez swojego agenta AI. Zacznij od hojnego darmowego planu, bez karty.

[Zacznij za darmo](https://logbrew.co/pl)

## Źródła

- [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)

## Więcej napraw błędów

- [Napraw błąd Script error, który ukrywa komunikat, plik i wiersz](https://logbrew.co/pl/errors/script-error)
- [Napraw błąd Failed to fetch i odróżnij jego 3 przyczyny](https://logbrew.co/pl/errors/failed-to-fetch)
- [Napraw java.lang.NullPointerException w Kotlinie i Androidzie po jego komunikacie](https://logbrew.co/pl/errors/nullpointerexception)
- [Napraw Minified React error #418 i #185 z pełnego komunikatu i własnego wiersza kodu](https://logbrew.co/pl/errors/minified-react-error)
- [Napraw Cannot use import statement outside a module w przeglądarce i w Node.js](https://logbrew.co/pl/errors/cannot-use-import-statement-outside-a-module)
- [Napraw AxiosError Network Error i ustal, którą z 3 przyczyn masz](https://logbrew.co/pl/errors/axios-network-error)
- [Błędy, które odtworzyliśmy, i jak naprawić każdy z nich](https://logbrew.co/pl/errors)
