Number of times per-thread statistics were summed into the global counters.

How long the child process has been running.

Count of sessions successfully accepted

Count of failures to accept TCP connection.

This counter is the sum of the sess_fail_* counters, which give more detailed information.

Detailed reason for sess_fail: Connection aborted by the client, usually harmless.

Detailed reason for sess_fail: The accept() call was interrupted, usually harmless

Detailed reason for sess_fail: No file descriptor was available. Consider raising RLIMIT_NOFILE (see ulimit -n).

Detailed reason for sess_fail: The listen socket file descriptor was invalid. Should never happen.

Detailed reason for sess_fail: Most likely insufficient socket buffer memory. Should never happen

Detailed reason for sess_fail: neither of the above, see SessError log (varnishlog -g raw -i SessError).

400 means we couldn't make sense of the request, it was malformed in some drastic way.

417 means that something went wrong with an Expect: header.

The count of parseable client requests seen.

Number of ESI subrequests made.

Count of cache hits. A cache hit indicates that an object has been delivered to a client without fetching it from a backend server.

Count of cache hits with grace. A cache hit with grace is a cache hit where the object is expired. Note that such hits are also included in the cache_hit counter.

Count of hits for pass. A cache hit for pass indicates that Varnish is going to pass the request to the backend and this decision has been cached in it self. This counts how many times the cached decision is being used.

Count of hits for miss. A cache hit for miss indicates that Varnish is going to proceed as for a cache miss without request coalescing, and this decision has been cached. This counts how many times the cached decision is being used.

Count of misses. A cache miss indicates the object was fetched from the backend before delivering it to the client.

Count of backend responses considered uncacheable.

Count of objects created with ttl+grace+keep shorter than the 'shortlived' runtime parameter.

How many backend connections have successfully been established.

Count of backend connection reuses. This counter is increased whenever we reuse a recycled connection.

Count of backend connection recycles. This counter is increased whenever we have a keep-alive connection that is put back into the pool of connections. It has not yet been used, but it might be, unless the backend closes it.

beresp with no body because the request is HEAD.

beresp.body with Content-Length.

beresp.body with Chunked.

beresp.body with EOF.

beresp.body length/fetch could not be determined.

beresp.body empty

beresp with no body because of 1XX response.

beresp with no body because of 204 response.

beresp with no body because of 304 response.

beresp fetch failed.

beresp fetch failed, no thread available.

Number of thread pools. See also parameter thread_pools. NB: Presently pools cannot be removed once created.

Number of threads in all pools. See also parameters thread_pools, thread_pool_min and thread_pool_max.

Number of times more threads were needed, but limit was reached in a thread pool. See also parameter thread_pool_max.

Total number of threads created in all pools.

Total number of threads destroyed in all pools.

Number of times creating a thread failed. See VSL::Debug for diagnostics. See also parameter thread_fail_delay.

Length of session queue waiting for threads. NB: Only updates once per second. See also parameter thread_queue_limit.

Number of requests sent to sleep without a worker thread because they found a busy object.

Number of requests taken off the busy object sleep list and rescheduled.

Number of requests killed from the busy object sleep list due to lack of resources.

Number of times session was queued waiting for a thread. See also parameter thread_queue_limit.

Number of times an HTTP/1 session was dropped because the queue was too long already. See also parameter thread_queue_limit.

Number of times an HTTP/2 stream was refused because the queue was too long already. See also parameter thread_queue_limit.

Approximate number of HTTP objects (headers + body, if present) in the cache.

Number of unresurrected objects

Approximate number of object metadata elements in the cache. Each object needs an objectcore, extra objectcores are for hit-for-miss, hit-for-pass and busy objects.

Approximate number of different hash entries in the cache.

Number of backends known to us.

Number of objects that expired from cache because of old age.

How many objects have been forcefully evicted from storage to make room for a new object.

Number of move operations done on the LRU list.

Number of times more storage space were needed, but limit was reached in a nuke_limit. See also parameter nuke_limit.

Number of times more pipes were needed, but the limit was reached. See also parameter pipe_sess_max.

Total backend fetches initiated, including background fetches.

Total request header bytes received

Total request body bytes received

Total response header bytes transmitted

Total response body bytes transmitted

Total request bytes received for piped sessions

Total number of bytes forwarded from clients in pipe sessions

Total number of bytes forwarded to clients in pipe sessions

Total number of sessions closed with errors. See sc_* diag counters for detailed breakdown

Number of times the timeout_linger triggered

Number of session closes with REM_CLOSE (Client Closed)

Number of session closes with REQ_CLOSE (Client requested close)

Number of session closes with Error REQ_HTTP10 (Proto < HTTP/1.1)

Number of session closes with Error RX_BAD (Received bad req/resp)

Number of session closes with Error RX_BODY (Failure receiving req.body)

Number of session closes with Error RX_JUNK (Received junk data)

Number of session closes with Error RX_OVERFLOW (Received buffer overflow)

Number of session closes with Error RX_TIMEOUT (Receive timeout)

Number of session closes with Error RX_CLOSE_IDLE: timeout_idle has been exceeded while waiting for a client request.

Number of session closes with TX_PIPE (Piped transaction)

Number of session closes with Error TX_ERROR (Error transaction)

Number of session closes with TX_EOF (EOF transmission)

Number of session closes with RESP_CLOSE (Backend/VCL requested close)

Number of session closes with Error OVERLOAD (Out of some resource)

Number of session closes with Error PIPE_OVERFLOW (Session pipe overflow)

Number of session closes with Error RANGE_SHORT (Insufficient data for range)

Number of session closes with Error REQ_HTTP20 (HTTP2 not accepted)

Number of session closes with Error VCL_FAILURE (VCL failure)

Number of times we failed a response due to running out of workspace memory during delivery.

Number of times we ran out of space in workspace_backend.

Number of times we ran out of space in workspace_client.

Number of times we ran out of space in workspace_thread.

Number of times we ran out of space in workspace_session.

Count of failures which prevented VCL from completing.

Number of all bans in system, including bans superseded by newer bans and bans already checked by the ban-lurker.

Number of bans which are no longer active, either because they got checked by the ban-lurker or superseded by newer identical bans.

Number of bans which use obj.* variables. These bans can possibly be washed by the ban-lurker.

Number of bans which use req.* variables. These bans can not be washed by the ban-lurker.

Counter of bans added to ban list.

Counter of bans deleted from ban list.

Count of how many bans and objects have been tested against each other during hash lookup.

Number of objects killed by bans during object lookup.

Count of how many bans and objects have been tested against each other by the ban-lurker.

Count of how many tests and objects have been tested against each other during lookup. 'ban req.url == foo && req.http.host == bar' counts as one in 'bans_tested' and as two in 'bans_tests_tested'

Count of how many tests and objects have been tested against each other by the ban-lurker. 'ban req.url == foo && req.http.host == bar' counts as one in 'bans_tested' and as two in 'bans_tests_tested'

Number of objects killed by the ban-lurker.

Number of objects killed by the ban-lurker to keep the number of bans below ban_cutoff.

Count of bans replaced by later identical bans.

Number of times the ban-lurker had to wait for lookups.

Number of bytes used by the persisted ban lists.

Number of extra bytes accumulated through dropped and completed bans in the persistent ban lists.

Number of objects mailed to expiry thread for handling.

Number of objects received by expiry thread for handling.

Those operations occur when Varnish receives a compressed object from a backend. They are done to verify the gzip stream while it's inserted in storage.

Uptime in seconds of the management process

Number of times the child process has been started

Number of times the child process has been cleanly stopped

Number of times the child process has exited with an unexpected return code

Number of times the child process has died due to signals

Number of times the child process has produced core dumps

Number of times the management process has caught a child panic

Number of times the storage has been asked to provide a storage segment.

Number of times the storage has failed to provide a storage segment.

Number of total bytes allocated by this storage.

Number of total bytes returned to this storage.

Number of storage allocations outstanding.

Number of bytes allocated from the storage.

Number of bytes left in the storage.

Number of times the storage has been asked to provide a storage segment.

Number of times the storage has failed to provide a storage segment.

Number of total bytes allocated by this storage.

Number of total bytes returned to this storage.

Number of storage allocations outstanding.

Number of bytes allocated from the storage.

Number of bytes left in the storage.

Number of times the storage has been asked to provide a storage segment.

Number of times the storage has failed to provide a storage segment.

Number of total bytes allocated by this storage.

Number of total bytes returned to this storage.

Number of storage allocations outstanding.

Number of bytes allocated from the storage.

Number of bytes left in the storage.

Represents the last probe results as a bitmap. Happy probes are bits set to 1, and the unhappy ones are set to 0. The highest bits represent the oldest probes.

Total backend request header bytes sent

Total backend request body bytes sent

Total backend response header bytes received

Total backend response body bytes received

Total request bytes sent for piped sessions

Total number of bytes forwarded to backend in pipe sessions

Total number of bytes forwarded from backend in pipe sessions

The number of currently used connections to the backend. This number is always less or equal to the number of connections to the backend (as, for example shown as ESTABLISHED for TCP connections in netstat) due to connection pooling.

Number of times the max_connections limit was reached

Counter of failed opens. Detailed reasons are given in the fail_* counters (DIAG level) and in the log under the FetchError tag.

This counter is the sum of all detailed fail_* counters.

All fail_* counters may be slightly inaccurate for efficiency.

Connections not attempted during the backend_local_error_holddown or backend_remote_error_holddown interval after a fundamental connection issue.

The counts may be slightly wrong if there are more than one lock instantiated in each class (ie: .creat > 1)

If the lck debug bit is set: Lock operations which returned EBUSY on the first locking attempt.

If the lck debug bit is unset, this counter will never be incremented even if lock operations are contended.

If the lck debug bit is set: Trylock operations which returned EBUSY.

If the lck debug bit is unset, this counter will never be incremented even if lock operations are contended.