Metrics

varnishstat metrics

Out-of-the-box Varnish metric (i.e. varnishtat) don’t exactly match the Opentelemetry guidelines so varnish-otel renames them to more closely align with the standard. Notably, it tries to make use of labels as much as possible, and to respect hierarchy.

Because of the attributes, it notably means that some varnishstat metrics will end up with the same otel name, but different attributes.

Otel Name	Original Name
`varnish.accounting.backend.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.backend_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.backend.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.backend_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.backend.requests`	`ACCG.<NAMESPACE>.<KEY>.backend_req_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.backend.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.backend_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.backend.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.backend_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_200_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 200`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_304_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 304`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_404_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 404`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_503_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 503`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_2xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 2xx`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_3xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 3xx`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_4xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 4xx`
`varnish.accounting.backend.responses`	`ACCG.<NAMESPACE>.<KEY>.backend_5xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 5xx`
`varnish.accounting.client.graced_hits`	`ACCG.<NAMESPACE>.<KEY>.client_grace_hit_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.hits`	`ACCG.<NAMESPACE>.<KEY>.client_hit_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.misses`	`ACCG.std.total.client_miss_count` attributes: `accounting.level: total`
`varnish.accounting.client.misses`	`ACCG.<NAMESPACE>.<KEY>.client_miss_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.passes`	`ACCG.<NAMESPACE>.<KEY>.client_pass_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.pipes`	`ACCG.<NAMESPACE>.<KEY>.client_pipe_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_hit_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: hit`
`varnish.accounting.client.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_miss_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: miss`
`varnish.accounting.client.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_pass_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pass`
`varnish.accounting.client.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_synth_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: synth`
`varnish.accounting.client.request.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_pipe_req_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pipe`
`varnish.accounting.client.request.hdrbytes`	`ACCG.std.total.client_pipe_req_hdrbytes` attributes: `accounting.level: total` `handling: pipe`
`varnish.accounting.client.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_hit_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: hit`
`varnish.accounting.client.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_miss_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: miss`
`varnish.accounting.client.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_pass_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pass`
`varnish.accounting.client.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_synth_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: synth`
`varnish.accounting.client.request.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_pipe_req_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pipe`
`varnish.accounting.client.requests`	`ACCG.<NAMESPACE>.<KEY>.client_req_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.requests`	`ACCG.<NAMESPACE>.total.client_req_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.level: total`
`varnish.accounting.client.requests`	`ACCG.<NAMESPACE>.sub.client_req_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.level: sub`
`varnish.accounting.client.requests`	`ACCG.std.total.client_req_count` attributes: `accounting.level: total`
`varnish.accounting.client.requests`	`ACCG.std.sub.client_req_count` attributes: `accounting.level: sub`
`varnish.accounting.client.requests`	`ACCG.<NAMESPACE>.<KEY>.client_req_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_hit_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: hit`
`varnish.accounting.client.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_miss_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: miss`
`varnish.accounting.client.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_pass_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pass`
`varnish.accounting.client.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_synth_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: synth`
`varnish.accounting.client.response.bodybytes`	`ACCG.<NAMESPACE>.<KEY>.client_pipe_resp_bodybytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pipe`
`varnish.accounting.client.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.accounting.client.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_hit_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: hit`
`varnish.accounting.client.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_miss_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: miss`
`varnish.accounting.client.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_pass_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pass`
`varnish.accounting.client.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_synth_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: synth`
`varnish.accounting.client.response.hdrbytes`	`ACCG.<NAMESPACE>.<KEY>.client_pipe_resp_hdrbytes` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `handling: pipe`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_200_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 200`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_304_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 304`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_404_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 404`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_503_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 503`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_2xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 2xx`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_3xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 3xx`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_4xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 4xx`
`varnish.accounting.client.responses`	`ACCG.<NAMESPACE>.<KEY>.client_5xx_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>` `status.code: 5xx`
`varnish.accounting.client.synths`	`ACCG.<NAMESPACE>.<KEY>.client_synth_count` attributes: `accounting.namespace: <NAMESPACE>` `accounting.key: <KEY>`
`varnish.backend.busy`	`VBE.<vcl_name>.<backend_name>.busy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.busy`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).busy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.busy`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).busy` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.connect.in`	`VBE.<vcl_name>.<backend_name>.connect_in` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.connect.in`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).connect_in` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.connect.out`	`VBE.<vcl_name>.<backend_name>.connect_out` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.connect.out`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).connect_out` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.connections`	`VBE.<vcl_name>.<backend_name>.conn` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.connections`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).conn` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.connections`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).conn` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail_eacces` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: eacces`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail_eaddrnotavail` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: eaddrnotavail`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail_econnrefused` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: econnrefused`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail_enetunreach` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: enetunreach`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail_etimedout` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: etimedout`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.fail_other` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: other`
`varnish.backend.failed`	`VBE.<vcl_name>.<backend_name>.helddown` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: helddown`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail_eacces` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: eacces` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail_eaddrnotavail` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: eaddrnotavail` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail_econnrefused` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: econnrefused` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail_enetunreach` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: enetunreach` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail_etimedout` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: etimedout` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).fail_other` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: other` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).helddown` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `failure.type: helddown` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail_eacces` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: eacces`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail_eaddrnotavail` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: eaddrnotavail`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail_econnrefused` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: econnrefused`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail_enetunreach` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: enetunreach`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail_etimedout` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: etimedout`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).fail_other` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: other`
`varnish.backend.failed`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).helddown` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto` `failure.type: helddown`
`varnish.backend.happy`	`VBE.<vcl_name>.<backend_name>.happy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.happy`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).happy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.happy`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).happy` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.is_healthy`	`VBE.<vcl_name>.<backend_name>.is_healthy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.is_healthy`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).is_healthy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.is_healthy`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).is_healthy` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.pipe.hdrbytes`	`VBE.<vcl_name>.<backend_name>.pipe_hdrbytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.pipe.hdrbytes`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).pipe_hdrbytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.pipe.hdrbytes`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).pipe_hdrbytes` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.pipe.in`	`VBE.<vcl_name>.<backend_name>.pipe_in` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.pipe.in`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).pipe_in` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.pipe.in`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).pipe_in` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.pipe.out`	`VBE.<vcl_name>.<backend_name>.pipe_out` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.pipe.out`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).pipe_out` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.pipe.out`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).pipe_out` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.request.bodybytes`	`VBE.<vcl_name>.<backend_name>.bereq_bodybytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.request.bodybytes`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).bereq_bodybytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.request.bodybytes`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).bereq_bodybytes` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.request.hdrbytes`	`VBE.<vcl_name>.<backend_name>.bereq_hdrbytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.request.hdrbytes`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).bereq_hdrbytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.request.hdrbytes`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).bereq_hdrbytes` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.requests`	`VBE.<vcl_name>.<backend_name>.req` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.requests`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).req` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.requests`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).req` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.response.bodybytes`	`VBE.<vcl_name>.<backend_name>.beresp_bodybytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.response.bodybytes`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).beresp_bodybytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.response.bodybytes`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).beresp_bodybytes` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.response.hdrbytes`	`VBE.<vcl_name>.<backend_name>.beresp_hdrbytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.response.hdrbytes`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).beresp_hdrbytes` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.response.hdrbytes`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).beresp_hdrbytes` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.backend.unhealthy`	`VBE.<vcl_name>.<backend_name>.unhealthy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>`
`varnish.backend.unhealthy`	`VBE.<vcl_name>.udo.<backend_name>.(<ip_version>:<backend_ip>:<backend_port>).unhealthy` attributes: `vcl: <vcl_name>` `backend.name: <backend_name>` `backend.ip: <backend_ip>` `backend.port: <backend_port>` `backend.type: udo`
`varnish.backend.unhealthy`	`VBE.<vcl_name>.goto.<backend_id>.(<backend_ip>).(<backend_url>).(ttl:<ignored_TTL>).unhealthy` attributes: `vcl: <vcl_name>` `backend.id: <backend_id>` `backend.ip: <backend_ip>` `backend.url: <backend_url>` `backend.type: goto`
`varnish.brotli.byte.in`	`BROTLI.c_br_bytes_in`
`varnish.brotli.byte.out`	`BROTLI.c_br_bytes_out`
`varnish.brotli.compressions`	`BROTLI.c_br`
`varnish.brotli.decompression.byte.in`	`BROTLI.c_unbr_bytes_in`
`varnish.brotli.decompression.byte.out`	`BROTLI.c_unbr_bytes_out`
`varnish.brotli.decompression.fail`	`BROTLI.c_unbr_fail`
`varnish.brotli.decompressions`	`BROTLI.c_unbr`
`varnish.brotli.fail`	`BROTLI.c_br_fail`
`varnish.brotli.test.decompression`	`BROTLI.c_testunbr`
`varnish.brotli.test.decompression.fail`	`BROTLI.c_testunbr_fail`
`varnish.child.deaths`	`MGT.child_died`
`varnish.child.dumps`	`MGT.child_dump`
`varnish.child.exits`	`MGT.child_exit`
`varnish.child.panics`	`MGT.child_panic`
`varnish.child.starts`	`MGT.child_start`
`varnish.child.stops`	`MGT.child_stop`
`varnish.gravestones.messages.cleared`	`MGT.vgs_msg_cleared`
`varnish.gravestones.messages.frozen`	`MGT.vgs_msg_frozen`
`varnish.gravestones.messages.rescued`	`MGT.vgs_msg_rescued`
`varnish.gravestones.registered`	`MGT.vgs_registered`
`varnish.lock.creations`	`LCK.<lock_name>.creat` attributes: `lock.name: <lock_name>`
`varnish.lock.destructions`	`LCK.<lock_name>.destroy` attributes: `lock.name: <lock_name>`
`varnish.lock.locks`	`LCK.<lock_name>.locks` attributes: `lock.name: <lock_name>`
`varnish.main.backend`	`MAIN.n_backend`
`varnish.main.backend.busy`	`MAIN.backend_busy`
`varnish.main.backend.connections`	`MAIN.backend_conn`
`varnish.main.backend.failed`	`MAIN.backend_fail`
`varnish.main.backend.recycles`	`MAIN.backend_recycle`
`varnish.main.backend.req`	`MAIN.backend_req`
`varnish.main.backend.retries`	`MAIN.backend_retry`
`varnish.main.backend.reuses`	`MAIN.backend_reuse`
`varnish.main.backend.unhealthy`	`MAIN.backend_unhealthy`
`varnish.main.backend.wait_failed`	`MAIN.backend_wait_fail`
`varnish.main.backend.waited`	`MAIN.backend_wait`
`varnish.main.ban.added`	`MAIN.bans_added`
`varnish.main.ban.completed`	`MAIN.bans_completed`
`varnish.main.ban.deleted`	`MAIN.bans_deleted`
`varnish.main.ban.dups`	`MAIN.bans_dups`
`varnish.main.ban.lurker.contention`	`MAIN.bans_lurker_contention`
`varnish.main.ban.lurker.obj.killed`	`MAIN.bans_lurker_obj_killed`
`varnish.main.ban.lurker.obj.killed.cutoff`	`MAIN.bans_lurker_obj_killed_cutoff`
`varnish.main.ban.lurker.test.tested`	`MAIN.bans_lurker_tests_tested`
`varnish.main.ban.lurker.tested`	`MAIN.bans_lurker_tested`
`varnish.main.ban.obj`	`MAIN.bans_obj`
`varnish.main.ban.obj.killed`	`MAIN.bans_obj_killed`
`varnish.main.ban.req`	`MAIN.bans_req`
`varnish.main.ban.test.tested`	`MAIN.bans_tests_tested`
`varnish.main.ban.tested`	`MAIN.bans_tested`
`varnish.main.bankrupt`	`MAIN.sc_bankrupt`
`varnish.main.bans`	`MAIN.bans`
`varnish.main.bgfetch_no_thread`	`MAIN.bgfetch_no_thread`
`varnish.main.busy.killed`	`MAIN.busy_killed`
`varnish.main.busy.sleeps`	`MAIN.busy_sleep`
`varnish.main.busy.wakeups`	`MAIN.busy_wakeup`
`varnish.main.cache.graced_hits`	`MAIN.cache_hit_grace`
`varnish.main.cache.hitmisses`	`MAIN.cache_hitmiss`
`varnish.main.cache.hitpasses`	`MAIN.cache_hitpass`
`varnish.main.cache.hits`	`MAIN.cache_hit`
`varnish.main.cache.misses`	`MAIN.cache_miss`
`varnish.main.client.req_400`	`MAIN.client_req_400`
`varnish.main.client.req_417`	`MAIN.client_req_417`
`varnish.main.client.requests`	`MAIN.client_req`
`varnish.main.client.resp.500`	`MAIN.client_resp_500`
`varnish.main.esi.errors`	`MAIN.esi_errors`
`varnish.main.esi.maxdepth`	`MAIN.esi_maxdepth`
`varnish.main.esi.requests`	`MAIN.esi_req`
`varnish.main.esi.warnings`	`MAIN.esi_warnings`
`varnish.main.exp.mailed`	`MAIN.exp_mailed`
`varnish.main.exp.received`	`MAIN.exp_received`
`varnish.main.expired`	`MAIN.n_expired`
`varnish.main.failed_fetches`	`MAIN.fetch_failed`
`varnish.main.fetch`	`MAIN.s_fetch`
`varnish.main.fetches`	`MAIN.fetch_head` attributes: `fetch.type: head`
`varnish.main.fetches`	`MAIN.fetch_length` attributes: `fetch.type: length`
`varnish.main.fetches`	`MAIN.fetch_chunked` attributes: `fetch.type: chunked`
`varnish.main.fetches`	`MAIN.fetch_eof` attributes: `fetch.type: eof`
`varnish.main.fetches`	`MAIN.fetch_bad` attributes: `fetch.type: bad`
`varnish.main.fetches`	`MAIN.fetch_none` attributes: `fetch.type: none`
`varnish.main.fetches`	`MAIN.fetch_1xx` attributes: `fetch.type: 1xx`
`varnish.main.fetches`	`MAIN.fetch_204` attributes: `fetch.type: 204`
`varnish.main.fetches`	`MAIN.fetch_304` attributes: `fetch.type: 304`
`varnish.main.goto.dns.cache.hits`	`MAIN.goto_dns_cache_hits`
`varnish.main.goto.dns.lookup.failed`	`MAIN.goto_dns_lookup_fails`
`varnish.main.goto.dns.lookups`	`MAIN.goto_dns_lookups`
`varnish.main.gunzip`	`MAIN.n_gunzip`
`varnish.main.gzip`	`MAIN.n_gzip`
`varnish.main.hcb.insert`	`MAIN.hcb_insert`
`varnish.main.hcb.lock`	`MAIN.hcb_lock`
`varnish.main.hcb.nolock`	`MAIN.hcb_nolock`
`varnish.main.http1.iov.flush`	`MAIN.http1_iovs_flush`
`varnish.main.losthdr`	`MAIN.losthdr`
`varnish.main.lru.limited`	`MAIN.n_lru_limited`
`varnish.main.lru.moved`	`MAIN.n_lru_moved`
`varnish.main.lru.nuked`	`MAIN.n_lru_nuked`
`varnish.main.mem.file`	`MAIN.g_mem_file`
`varnish.main.mem.private`	`MAIN.g_mem_private`
`varnish.main.mem.rss`	`MAIN.g_mem_rss`
`varnish.main.mem.swap`	`MAIN.g_mem_swap`
`varnish.main.obj.purged`	`MAIN.n_obj_purged`
`varnish.main.object.count`	`MAIN.n_object`
`varnish.main.object.hitmiss`	`MAIN.n_object_hitmiss`
`varnish.main.object.hitpass`	`MAIN.n_object_hitpass`
`varnish.main.objectcore`	`MAIN.n_objectcore`
`varnish.main.objecthead`	`MAIN.n_objecthead`
`varnish.main.overload`	`MAIN.sc_overload`
`varnish.main.pass`	`MAIN.s_pass`
`varnish.main.pipe`	`MAIN.s_pipe`
`varnish.main.pipe.hdrbytes`	`MAIN.s_pipe_hdrbytes`
`varnish.main.pipe.in`	`MAIN.s_pipe_in`
`varnish.main.pipe.out`	`MAIN.s_pipe_out`
`varnish.main.pipe.overflow`	`MAIN.sc_pipe_overflow`
`varnish.main.pools`	`MAIN.pools`
`varnish.main.purges`	`MAIN.n_purges`
`varnish.main.range.short`	`MAIN.sc_range_short`
`varnish.main.rapid.reset`	`MAIN.sc_rapid_reset`
`varnish.main.rem.close`	`MAIN.sc_rem_close`
`varnish.main.req.http20`	`MAIN.sc_req_http20`
`varnish.main.request.bodybytes`	`MAIN.s_req_bodybytes`
`varnish.main.request.close`	`MAIN.sc_req_close`
`varnish.main.request.dropped`	`MAIN.req_dropped`
`varnish.main.request.hdrbytes`	`MAIN.s_req_hdrbytes`
`varnish.main.request.http10`	`MAIN.sc_req_http10`
`varnish.main.request.reset`	`MAIN.req_reset`
`varnish.main.resp.close`	`MAIN.sc_resp_close`
`varnish.main.response.bodybytes`	`MAIN.s_resp_bodybytes`
`varnish.main.response.hdrbytes`	`MAIN.s_resp_hdrbytes`
`varnish.main.rx.bad`	`MAIN.sc_rx_bad`
`varnish.main.rx.body`	`MAIN.sc_rx_body`
`varnish.main.rx.junk`	`MAIN.sc_rx_junk`
`varnish.main.rx.overflow`	`MAIN.sc_rx_overflow`
`varnish.main.rx.timeout`	`MAIN.sc_rx_timeout`
`varnish.main.sess`	`MAIN.s_sess`
`varnish.main.sess.queued`	`MAIN.sess_queued`
`varnish.main.session.accepted`	`MAIN.sess_conn`
`varnish.main.session.closed`	`MAIN.sess_closed`
`varnish.main.session.closed_with_err`	`MAIN.sess_closed_err`
`varnish.main.session.dropped`	`MAIN.sess_dropped`
`varnish.main.session.failed`	`MAIN.sess_fail`
`varnish.main.session.failed`	`MAIN.sess_fail_econnaborted` attributes: `failure.type: econnaborted`
`varnish.main.session.failed`	`MAIN.sess_fail_eintr` attributes: `failure.type: eintr`
`varnish.main.session.failed`	`MAIN.sess_fail_emfile` attributes: `failure.type: emfile`
`varnish.main.session.failed`	`MAIN.sess_fail_ebadf` attributes: `failure.type: ebadf`
`varnish.main.session.failed`	`MAIN.sess_fail_enomem` attributes: `failure.type: enomem`
`varnish.main.session.failed`	`MAIN.sess_fail_other` attributes: `failure.type: other`
`varnish.main.session.herd`	`MAIN.sess_herd`
`varnish.main.session.readahead`	`MAIN.sess_readahead`
`varnish.main.shm.bytes`	`MAIN.shm_bytes`
`varnish.main.shm.cont`	`MAIN.shm_cont`
`varnish.main.shm.cycles`	`MAIN.shm_cycles`
`varnish.main.shm.flushes`	`MAIN.shm_flushes`
`varnish.main.shm.records`	`MAIN.shm_records`
`varnish.main.shm.writes`	`MAIN.shm_writes`
`varnish.main.sock.closed`	`MAIN.sc_sock_closed`
`varnish.main.stale.fetch_delivers`	`MAIN.fetch_stale_deliver`
`varnish.main.stale.fetch_rearms`	`MAIN.fetch_stale_rearm`
`varnish.main.stream.failure`	`MAIN.sc_stream_failure`
`varnish.main.summs`	`MAIN.summs`
`varnish.main.superseded`	`MAIN.n_superseded`
`varnish.main.synth`	`MAIN.s_synth`
`varnish.main.task_track.failed`	`MAIN.task_track_failed`
`varnish.main.task_track.slots`	`MAIN.task_track_slots`
`varnish.main.test.gunzip`	`MAIN.n_test_gunzip`
`varnish.main.thread.created`	`MAIN.threads_created`
`varnish.main.thread.destroyed`	`MAIN.threads_destroyed`
`varnish.main.thread.failed`	`MAIN.threads_failed`
`varnish.main.thread.limited`	`MAIN.threads_limited`
`varnish.main.thread.live`	`MAIN.threads`
`varnish.main.thread.queue_length`	`MAIN.thread_queue_len`
`varnish.main.tx.eof`	`MAIN.sc_tx_eof`
`varnish.main.tx.error`	`MAIN.sc_tx_error`
`varnish.main.tx.pipe`	`MAIN.sc_tx_pipe`
`varnish.main.uptime`	`MAIN.uptime`
`varnish.main.vampireobject`	`MAIN.n_vampireobject`
`varnish.main.vcl.avail`	`MAIN.n_vcl_avail`
`varnish.main.vcl.discard`	`MAIN.n_vcl_discard`
`varnish.main.vcl.failed`	`MAIN.vcl_fail`
`varnish.main.vcl.failure`	`MAIN.sc_vcl_failure`
`varnish.main.vcl.loaded`	`MAIN.n_vcl`
`varnish.main.vdp.error`	`MAIN.sc_vdp_error`
`varnish.main.vgs.msg.created`	`MAIN.vgs_msg_created`
`varnish.main.vgs.msg.frozen`	`MAIN.vgs_msg_frozen`
`varnish.main.vgs.msg.locked`	`MAIN.vgs_msg_locked`
`varnish.main.vgs.msg.nospace`	`MAIN.vgs_msg_nospace`
`varnish.main.vmods`	`MAIN.vmods`
`varnish.main.ws.backend.overflow`	`MAIN.ws_backend_overflow`
`varnish.main.ws.client.overflow`	`MAIN.ws_client_overflow`
`varnish.main.ws.session.overflow`	`MAIN.ws_session_overflow`
`varnish.main.ws.thread.overflow`	`MAIN.ws_thread_overflow`
`varnish.main.ykey.purges`	`MAIN.c_ykey_purges`
`varnish.main.ykey.purges_slicer`	`MAIN.c_ykey_purges_slicer`
`varnish.main.ykey.stats`	`MAIN.c_ykey_stats`
`varnish.mempool.allocations`	`MEMPOOL.<pool_name>.allocs` attributes: `pool.name: <pool_name>`
`varnish.mempool.frees`	`MEMPOOL.<pool_name>.frees` attributes: `pool.name: <pool_name>`
`varnish.mempool.live`	`MEMPOOL.<pool_name>.live` attributes: `pool.name: <pool_name>`
`varnish.mempool.pooled`	`MEMPOOL.<pool_name>.pool` attributes: `pool.name: <pool_name>`
`varnish.mempool.randry`	`MEMPOOL.<pool_name>.randry` attributes: `pool.name: <pool_name>`
`varnish.mempool.recycles`	`MEMPOOL.<pool_name>.recycle` attributes: `pool.name: <pool_name>`
`varnish.mempool.surplus`	`MEMPOOL.<pool_name>.surplus` attributes: `pool.name: <pool_name>`
`varnish.mempool.sz_actual`	`MEMPOOL.<pool_name>.sz_actual` attributes: `pool.name: <pool_name>`
`varnish.mempool.sz_wanted`	`MEMPOOL.<pool_name>.sz_wanted` attributes: `pool.name: <pool_name>`
`varnish.mempool.timeouts`	`MEMPOOL.<pool_name>.timeout` attributes: `pool.name: <pool_name>`
`varnish.mempool.toosmall`	`MEMPOOL.<pool_name>.toosmall` attributes: `pool.name: <pool_name>`
`varnish.mse3.allocator.failed.all`	`MSE.mse.c_fail`
`varnish.mse3.allocator.failed.malloc`	`MSE.mse.c_fail_malloc`
`varnish.mse3.allocator.outstanding`	`MSE.mse.g_alloc`
`varnish.mse3.allocator.requests`	`MSE.mse.c_req`
`varnish.mse3.book.banlist.byte.unused`	`MSE_BOOK.<book_name>.g_banlist_space` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.banlist.byte.used`	`MSE_BOOK.<book_name>.g_banlist_bytes` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.banlist.database`	`MSE_BOOK.<book_name>.g_banlist_database` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.byte.unused`	`MSE_BOOK.<book_name>.g_space` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.byte.used`	`MSE_BOOK.<book_name>.g_bytes` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.insert.timeout`	`MSE_BOOK.<book_name>.c_insert_timeout` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.vary`	`MSE_BOOK.<book_name>.n_vary` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.waterlevel.purged`	`MSE_BOOK.<book_name>.c_waterlevel_purge` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.waterlevel.queued.count`	`MSE_BOOK.<book_name>.c_waterlevel_queue` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.waterlevel.queued.current`	`MSE_BOOK.<book_name>.g_waterlevel_queue` attributes: `mse3.book: <book_name>`
`varnish.mse3.book.waterlevel.runs`	`MSE_BOOK.<book_name>.c_waterlevel_runs` attributes: `mse3.book: <book_name>`
`varnish.mse3.byte.allocated`	`MSE.mse.c_bytes`
`varnish.mse3.byte.freed`	`MSE.mse.c_freed`
`varnish.mse3.byte.unused`	`MSE.mse.g_space`
`varnish.mse3.byte.used`	`MSE.mse.g_bytes`
`varnish.mse3.degradable.inherited`	`MSE.mse.g_da_inherited`
`varnish.mse3.degradable.inserts`	`MSE.mse.c_da_inserts`
`varnish.mse3.degradable.removals`	`MSE.mse.c_da_removals`
`varnish.mse3.lru.moved`	`MSE.mse.n_lru_moved`
`varnish.mse3.lru.nuked`	`MSE.mse.n_lru_nuked`
`varnish.mse3.memcache.hits`	`MSE.mse.c_memcache_hit`
`varnish.mse3.memcache.misses`	`MSE.mse.c_memcache_miss`
`varnish.mse3.store.aio.finished`	`MSE_STORE.<store_name>.c_aio_finished_write` attributes: `mse3.store: <store_name>` `io.type: write`
`varnish.mse3.store.aio.finished`	`MSE_STORE.<store_name>.c_aio_finished_bytes` attributes: `mse3.store: <store_name>` `io.type: bytes`
`varnish.mse3.store.aio.finished`	`MSE_STORE.<store_name>.c_aio_finished_bytes_read` attributes: `mse3.store: <store_name>` `io.type: bytes_read`
`varnish.mse3.store.aio.finished.all`	`MSE_STORE.<store_name>.c_aio_finished` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.aio.finished.byte.writes`	`MSE_STORE.<store_name>.c_aio_finished_bytes_write` attributes: `mse3.store: <store_name>` `io.type: bytes_write`
`varnish.mse3.store.aio.queue.all`	`MSE_STORE.<store_name>.c_aio_queue` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.aio.queue.total.reads`	`MSE_STORE.<store_name>.c_aio_queue_read` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.aio.queue.total.write.overflows`	`MSE_STORE.<store_name>.c_aio_write_queue_overflow` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.aio.queue.total.writes`	`MSE_STORE.<store_name>.c_aio_queue_write` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.aio.queue.write`	`MSE_STORE.<store_name>.g_aio_queue_write` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.aio.running`	`MSE_STORE.<store_name>.g_aio_running_read` attributes: `mse3.store: <store_name>` `io.type: read`
`varnish.mse3.store.aio.running`	`MSE_STORE.<store_name>.g_aio_running_write` attributes: `mse3.store: <store_name>` `io.type: write`
`varnish.mse3.store.aio.running`	`MSE_STORE.<store_name>.g_aio_running_bytes` attributes: `mse3.store: <store_name>` `io.type: bytes`
`varnish.mse3.store.aio.running`	`MSE_STORE.<store_name>.g_aio_running_bytes_read` attributes: `mse3.store: <store_name>` `io.type: bytes_read`
`varnish.mse3.store.aio.running`	`MSE_STORE.<store_name>.g_aio_running_bytes_write` attributes: `mse3.store: <store_name>` `io.type: bytes_write`
`varnish.mse3.store.aio.running.all`	`MSE_STORE.<store_name>.g_aio_running` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.byte.all.unused`	`MSE_STORE.<store_name>.g_free_bytes` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.byte.all.used`	`MSE_STORE.<store_name>.g_alloc_bytes` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.byte.unused`	`MSE_STORE.<store_name>.g_free_<extent_size>_bytes` attributes: `mse3.store: <store_name>` `mse3.extent_size: <extent_size>`
`varnish.mse3.store.byte.used`	`MSE_STORE.<store_name>.g_alloc_<extent_size>_bytes` attributes: `mse3.store: <store_name>` `mse3.extent_size: <extent_size>`
`varnish.mse3.store.database.queued`	`MSE_STORE.<store_name>.g_database_queue` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.extent.all.unused`	`MSE_STORE.<store_name>.g_free_extents` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.extent.all.used`	`MSE_STORE.<store_name>.g_alloc_extents` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.extent.unused`	`MSE_STORE.<store_name>.g_free_<extent_size>_extents` attributes: `mse3.store: <store_name>` `mse3.extent_size: <extent_size>`
`varnish.mse3.store.extent.used`	`MSE_STORE.<store_name>.g_alloc_<extent_size>_extents` attributes: `mse3.store: <store_name>` `mse3.extent_size: <extent_size>`
`varnish.mse3.store.finished`	`MSE_STORE.<store_name>.c_aio_finished_read` attributes: `mse3.store: <store_name>` `io.type: read`
`varnish.mse3.store.lru.moved`	`MSE_STORE.<store_name>.n_lru_moved` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.objects`	`MSE_STORE.<store_name>.g_objects` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.queue.all`	`MSE_STORE.<store_name>.g_aio_queue` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.queue.read`	`MSE_STORE.<store_name>.g_aio_queue_read` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.waterlevel.purged`	`MSE_STORE.<store_name>.c_waterlevel_purge` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.waterlevel.queued.count`	`MSE_STORE.<store_name>.c_waterlevel_queue` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.waterlevel.queued.current`	`MSE_STORE.<store_name>.g_waterlevel_queue` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.ykey.keys`	`MSE_STORE.<store_name>.g_ykey_keys` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.ykey.purged`	`MSE_STORE.<store_name>.c_ykey_purged` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.ykey.purged.slicer`	`MSE_STORE.<store_name>.c_ykey_purged_slicer` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.ykey.stats`	`MSE_STORE.<store_name>.c_ykey_stats` attributes: `mse3.store: <store_name>`
`varnish.mse3.store.ykey.stats.slicer`	`MSE_STORE.<store_name>.c_ykey_stats_slicer` attributes: `mse3.store: <store_name>`
`varnish.mse3.vary`	`MSE.mse.n_vary`
`varnish.mse3.ykey.keys`	`MSE.mse.g_ykey_keys`
`varnish.mse3.ykey.stats`	`MSE.mse.c_ykey_stats`
`varnish.mse3.ykey.stats.slicer`	`MSE.mse.c_ykey_stats_slicer`
`varnish.mse4.allocation.ephemeral`	`MSE4_MEM.c_allocation_ephemeral`
`varnish.mse4.allocation.invoked`	`MSE4_MEM.c_allocation`
`varnish.mse4.allocation.pass`	`MSE4_MEM.c_allocation_pass`
`varnish.mse4.allocation.persisted`	`MSE4_MEM.c_allocation_persisted`
`varnish.mse4.allocation.reqbody`	`MSE4_MEM.c_allocation_reqbody`
`varnish.mse4.allocation.synthetic`	`MSE4_MEM.c_allocation_synthetic`
`varnish.mse4.allocation.used`	`MSE4_MEM.g_allocations`
`varnish.mse4.ban.bytes`	`MSE4_BANJRN.<book_name>.g_ban_bytes` attributes: `mse4.book: <book_name>`
`varnish.mse4.ban.persisted`	`MSE4_BANJRN.<book_name>.g_bans` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.dirty_blocks`	`MSE4_BOOK.<book_name>.g_dirty_blocks` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.io.read_bytes`	`MSE4_BOOK.<book_name>.c_io_read_bytes` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.liberated`	`MSE4_BOOK.<book_name>.c_objects_liberated` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.liberation_failed`	`MSE4_BOOK.<book_name>.c_slot_liberation_failure` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.objects`	`MSE4_BOOK.<book_name>.g_objects` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.online`	`MSE4_BOOK.<book_name>.online` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.slot.unused`	`MSE4_BOOK.<book_name>.g_slots_unused` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.slot.used`	`MSE4_BOOK.<book_name>.g_slots_used` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.varyspecs`	`MSE4_BOOK.<book_name>.g_varyspec` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.bytes`	`MSE4_BOOK.<book_name>.g_ykey_bytes` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.keys`	`MSE4_BOOK.<book_name>.g_ykey_keys` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.nodes`	`MSE4_BOOK.<book_name>.g_ykey_nodes` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.purged`	`MSE4_BOOK.<book_name>.c_ykey_purged` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.slicer_purged`	`MSE4_BOOK.<book_name>.c_ykey_purged_slicer` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.stats`	`MSE4_BOOK.<book_name>.c_ykey_stats` attributes: `mse4.book: <book_name>`
`varnish.mse4.book.ykey.stats_slicer`	`MSE4_BOOK.<book_name>.c_ykey_stats_slicer` attributes: `mse4.book: <book_name>`
`varnish.mse4.byte.buffer`	`MSE4_MEM.g_bytes_buffer`
`varnish.mse4.byte.ephemeral`	`MSE4_MEM.g_bytes_ephemeral`
`varnish.mse4.byte.pass`	`MSE4_MEM.g_bytes_pass`
`varnish.mse4.byte.persisted`	`MSE4_MEM.g_bytes_persisted`
`varnish.mse4.byte.reqbody`	`MSE4_MEM.g_bytes_reqbody`
`varnish.mse4.byte.synthetic`	`MSE4_MEM.g_bytes_synthetic`
`varnish.mse4.byte.unused`	`MSE4_MEM.g_space`
`varnish.mse4.byte.unused`	`MSE4_BANJRN.<book_name>.g_space` attributes: `mse4.book: <book_name>`
`varnish.mse4.byte.used`	`MSE4_MEM.g_bytes`
`varnish.mse4.byte.used`	`MSE4_BANJRN.<book_name>.g_bytes` attributes: `mse4.book: <book_name>`
`varnish.mse4.eviction.reorder`	`MSE4_MEM.c_eviction_reorder`
`varnish.mse4.free.ephemeral`	`MSE4_MEM.c_free_ephemeral`
`varnish.mse4.free.pass`	`MSE4_MEM.c_free_pass`
`varnish.mse4.free.release`	`MSE4_MEM.c_free`
`varnish.mse4.free.reqbody`	`MSE4_MEM.c_free_reqbody`
`varnish.mse4.free.synthetic`	`MSE4_MEM.c_free_synthetic`
`varnish.mse4.memcache.hit`	`MSE4_MEM.c_memcache_hit`
`varnish.mse4.memcache.miss`	`MSE4_MEM.c_memcache_miss`
`varnish.mse4.object.ephemeral`	`MSE4_MEM.g_objects_ephemeral`
`varnish.mse4.object.pass`	`MSE4_MEM.g_objects_pass`
`varnish.mse4.object.persisted`	`MSE4_MEM.g_objects_persisted`
`varnish.mse4.object.reqbody`	`MSE4_MEM.g_objects_reqbody`
`varnish.mse4.object.synthetic`	`MSE4_MEM.g_objects_synthetic`
`varnish.mse4.object.used`	`MSE4_MEM.g_objects`
`varnish.mse4.store.allocations`	`MSE4_STORE.<book_name>.<store_name>.g_allocations` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.byte.unused`	`MSE4_STORE.<book_name>.<store_name>.g_bytes_unused` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.byte.used`	`MSE4_STORE.<book_name>.<store_name>.g_bytes_used` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.chunks.reserved`	`MSE4_STORE.<book_name>.<store_name>.g_reserve_class_<class_value>` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>` `mse4.class: <class_value>`
`varnish.mse4.store.io.finished`	`MSE4_STORE.<book_name>.<store_name>.c_io_finished` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.io.finished`	`MSE4_STORE.<book_name>.<store_name>.c_io_finished_read` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>` `io.type: read`
`varnish.mse4.store.io.finished`	`MSE4_STORE.<book_name>.<store_name>.c_io_finished_bytes` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>` `io.type: bytes`
`varnish.mse4.store.io.finished`	`MSE4_STORE.<book_name>.<store_name>.c_io_finished_bytes_read` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>` `io.type: bytes_read`
`varnish.mse4.store.io.queued`	`MSE4_STORE.<book_name>.<store_name>.g_io_queued` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.mapped_segments`	`MSE4_STORE.<book_name>.<store_name>.g_mapped_segments` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.objects`	`MSE4_STORE.<book_name>.<store_name>.g_objects` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.online`	`MSE4_STORE.<book_name>.<store_name>.online` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.prune_failed`	`MSE4_STORE.<book_name>.<store_name>.c_segment_prune_fail` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.pruned_objects`	`MSE4_STORE.<book_name>.<store_name>.c_segment_pruned_objects` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.prunes`	`MSE4_STORE.<book_name>.<store_name>.c_segment_prune` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.remap_failed`	`MSE4_STORE.<book_name>.<store_name>.c_segment_remap_fail` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.remaps`	`MSE4_STORE.<book_name>.<store_name>.c_segment_remap` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.reserve.bytes`	`MSE4_STORE.<book_name>.<store_name>.g_reserve_bytes` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.reserve.map.usage`	`MSE4_STORE.<book_name>.<store_name>.g_reserve_map_usage` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.mse4.store.slist.bytes`	`MSE4_STORE.<book_name>.<store_name>.g_slist_usage` attributes: `mse4.book: <book_name>` `mse4.store: <store_name>`
`varnish.rlcol.accounts`	`RLCOL.(<collection>).accounts` attributes: `collection.name: <collection>`
`varnish.slicer.meta.cache.hit`	`SLICER.meta_cache_hit`
`varnish.slicer.meta.cache.miss`	`SLICER.meta_cache_miss`
`varnish.slicer.meta.requests`	`SLICER.meta_req`
`varnish.slicer.slice.backend.response.200`	`SLICER.slice_beresp_200`
`varnish.slicer.slice.backend.response.206`	`SLICER.slice_beresp_206`
`varnish.slicer.slice.cache.hit`	`SLICER.slice_cache_hit`
`varnish.slicer.slice.cache.miss`	`SLICER.slice_cache_miss`
`varnish.slicer.slice.requests`	`SLICER.slice_req`
`varnish.something._foo_.bar`	`SOMETHING.(foo).bar`
`varnish.something._foo_.baz`	`SOMETHING.(_foo_).baz`
`varnish.uptime`	`MGT.uptime`
`varnish.waiter.actions`	`WAITER.<waiter_name>.action` attributes: `waiter.name: <waiter_name>`
`varnish.waiter.connections`	`WAITER.<waiter_name>.conns` attributes: `waiter.name: <waiter_name>`
`varnish.waiter.remote.closes`	`WAITER.<waiter_name>.remclose` attributes: `waiter.name: <waiter_name>`
`varnish.waiter.timeouts`	`WAITER.<waiter_name>.timeout` attributes: `waiter.name: <waiter_name>`

Histograms

varnish-otel also leverages logging data to generate histograms regarding latency and volumes.

Name	Description
`varnish.backend.duration.connection`	time for Varnish to establish connection to the back
`varnish.backend.duration.total`	duration of a backend transaction (TTLB)
`varnish.backend.duration.ttfb`	time it took before receiving the first bytes from the backend
`varnish.backend.request.bytes`	size of the request sent to the backend
`varnish.backend.response.bytes`	size of the response received from the backend
`varnish.client.duration.total`	duration of a client transaction
`varnish.client.duration.ttfb`	time it took before sending the first bytes to the client
`varnish.client.duration.waitlist`	cumulated time a request spent on the waiting list
`varnish.client.request.bytes`	size of the response sent to the client
`varnish.client.response.bytes`	size of the request received from the client

Histogram buckets can be configured both for size and duration using the following environment variables:

OTEL_VARNISH_DURATION_BUCKETS: a list of durations in milliseconds. For example OTEL_VARNISH_DURATION_BUCKETS=100,10_000,60_000 defaults to 5, 20, 50, 100, 200, 500, 1_000, 5_000, 10_000, 30_000, 60_000
OTEL_VARNISH_SIZE_BUCKETS: a list of sizes in bytes, for example: OTEL_VARNISH_SIZE_BUCKETS=10,1024,1048576 defaults to 100,1024,10240,102400,1048576,10485760,104857600,1073741824 (equivalent 100B, 1KB, 10KB, 100KB, 1MB, 10MB, 100MB, 1GB)

All histograms have two attributes:

handling: which explains how Varnish treated the request, e.g. hit, miss.
http.response.status_code: the status code of the response

Optionally, http.route can be added by the VCL using vmod-otel.

Filtering metrics

Metrics can be filtered using the OTEL_VARNISH_METRICS_FILTER environment variable (which defaults to !varnish.lock.*).

This variable is a comma-separated list of globbing patterns. A ! before a glob make it “negative. To know if a metric should be exported, varnish-otel goes through the full list of globs, with the following logic:

if the glob matches the metric name:
- export the metric if the glob is positive
- ignore it if the glob is negative
otherwise, try the next glob in the list
if no glob matched, export the metric