Production Metrics

vLLM exposes a number of metrics that can be used to monitor the health of the system. These metrics are exposed via the /metrics endpoint on the vLLM OpenAI compatible API server.

The following metrics are exposed:

  1. class Metrics:
  2.     labelname_finish_reason = "finished_reason"
  3.     _gauge_cls = prometheus_client.Gauge
  4.     _counter_cls = prometheus_client.Counter
  5.     _histogram_cls = prometheus_client.Histogram
  7.     def __init__(self, labelnames: List[str], max_model_len: int):
  8.         # Unregister any existing vLLM collectors
  9.         self._unregister_vllm_metrics()
  11.         # Config Information
  12.         self._create_info_cache_config()
  14.         # System stats
  15.         #   Scheduler State
  16.         self.gauge_scheduler_running = self._gauge_cls(
  17.             name="vllm:num_requests_running",
  18.             documentation="Number of requests currently running on GPU.",
  19.             labelnames=labelnames)
  20.         self.gauge_scheduler_waiting = self._gauge_cls(
  21.             name="vllm:num_requests_waiting",
  22.             documentation="Number of requests waiting to be processed.",
  23.             labelnames=labelnames)
  24.         self.gauge_scheduler_swapped = self._gauge_cls(
  25.             name="vllm:num_requests_swapped",
  26.             documentation="Number of requests swapped to CPU.",
  27.             labelnames=labelnames)
  28.         #   KV Cache Usage in %
  29.         self.gauge_gpu_cache_usage = self._gauge_cls(
  30.             name="vllm:gpu_cache_usage_perc",
  31.             documentation="GPU KV-cache usage. 1 means 100 percent usage.",
  32.             labelnames=labelnames)
  33.         self.gauge_cpu_cache_usage = self._gauge_cls(
  34.             name="vllm:cpu_cache_usage_perc",
  35.             documentation="CPU KV-cache usage. 1 means 100 percent usage.",
  36.             labelnames=labelnames)
  38.         # Iteration stats
  39.         self.counter_num_preemption = self._counter_cls(
  40.             name="vllm:num_preemptions_total",
  41.             documentation="Cumulative number of preemption from the engine.",
  42.             labelnames=labelnames)
  43.         self.counter_prompt_tokens = self._counter_cls(
  44.             name="vllm:prompt_tokens_total",
  45.             documentation="Number of prefill tokens processed.",
  46.             labelnames=labelnames)
  47.         self.counter_generation_tokens = self._counter_cls(
  48.             name="vllm:generation_tokens_total",
  49.             documentation="Number of generation tokens processed.",
  50.             labelnames=labelnames)
  51.         self.histogram_time_to_first_token = self._histogram_cls(
  52.             name="vllm:time_to_first_token_seconds",
  53.             documentation="Histogram of time to first token in seconds.",
  54.             labelnames=labelnames,
  55.             buckets=[
  56.                 0.001, 0.005, 0.01, 0.02, 0.04, 0.06, 0.08, 0.1, 0.25, 0.5,
  57.                 0.75, 1.0, 2.5, 5.0, 7.5, 10.0
  58.             ])
  59.         self.histogram_time_per_output_token = self._histogram_cls(
  60.             name="vllm:time_per_output_token_seconds",
  61.             documentation="Histogram of time per output token in seconds.",
  62.             labelnames=labelnames,
  63.             buckets=[
  64.                 0.01, 0.025, 0.05, 0.075, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.75,
  65.                 1.0, 2.5
  66.             ])
  68.         # Request stats
  69.         #   Latency
  70.         self.histogram_e2e_time_request = self._histogram_cls(
  71.             name="vllm:e2e_request_latency_seconds",
  72.             documentation="Histogram of end to end request latency in seconds.",
  73.             labelnames=labelnames,
  74.             buckets=[1.0, 2.5, 5.0, 10.0, 15.0, 20.0, 30.0, 40.0, 50.0, 60.0])
  75.         #   Metadata
  76.         self.histogram_num_prompt_tokens_request = self._histogram_cls(
  77.             name="vllm:request_prompt_tokens",
  78.             documentation="Number of prefill tokens processed.",
  79.             labelnames=labelnames,
  80.             buckets=build_1_2_5_buckets(max_model_len),
  81.         )
  82.         self.histogram_num_generation_tokens_request = \
  83.             self._histogram_cls(
  84.                 name="vllm:request_generation_tokens",
  85.                 documentation="Number of generation tokens processed.",
  86.                 labelnames=labelnames,
  87.                 buckets=build_1_2_5_buckets(max_model_len),
  88.             )
  89.         self.histogram_best_of_request = self._histogram_cls(
  90.             name="vllm:request_params_best_of",
  91.             documentation="Histogram of the best_of request parameter.",
  92.             labelnames=labelnames,
  93.             buckets=[1, 2, 5, 10, 20],
  94.         )
  95.         self.histogram_n_request = self._histogram_cls(
  96.             name="vllm:request_params_n",
  97.             documentation="Histogram of the n request parameter.",
  98.             labelnames=labelnames,
  99.             buckets=[1, 2, 5, 10, 20],
  100.         )
  101.         self.counter_request_success = self._counter_cls(
  102.             name="vllm:request_success_total",
  103.             documentation="Count of successfully processed requests.",
  104.             labelnames=labelnames + [Metrics.labelname_finish_reason])
  106.         # Speculatie decoding stats
  107.         self.gauge_spec_decode_draft_acceptance_rate = self._gauge_cls(
  108.             name="vllm:spec_decode_draft_acceptance_rate",
  109.             documentation="Speulative token acceptance rate.",
  110.             labelnames=labelnames)
  111.         self.gauge_spec_decode_efficiency = self._gauge_cls(
  112.             name="vllm:spec_decode_efficiency",
  113.             documentation="Speculative decoding system efficiency.",
  114.             labelnames=labelnames)
  115.         self.counter_spec_decode_num_accepted_tokens = (self._counter_cls(
  116.             name="vllm:spec_decode_num_accepted_tokens_total",
  117.             documentation="Number of accepted tokens.",
  118.             labelnames=labelnames))
  119.         self.counter_spec_decode_num_draft_tokens = self._counter_cls(
  120.             name="vllm:spec_decode_num_draft_tokens_total",
  121.             documentation="Number of draft tokens.",
  122.             labelnames=labelnames)
  123.         self.counter_spec_decode_num_emitted_tokens = (self._counter_cls(
  124.             name="vllm:spec_decode_num_emitted_tokens_total",
  125.             documentation="Number of emitted tokens.",
  126.             labelnames=labelnames))
  128.         # Deprecated in favor of vllm:prompt_tokens_total
  129.         self.gauge_avg_prompt_throughput = self._gauge_cls(
  130.             name="vllm:avg_prompt_throughput_toks_per_s",
  131.             documentation="Average prefill throughput in tokens/s.",
  132.             labelnames=labelnames,
  133.         )
  134.         # Deprecated in favor of vllm:generation_tokens_total
  135.         self.gauge_avg_generation_throughput = self._gauge_cls(
  136.             name="vllm:avg_generation_throughput_toks_per_s",
  137.             documentation="Average generation throughput in tokens/s.",
  138.             labelnames=labelnames,
  139.         )
  141.     def _create_info_cache_config(self) -> None:
  142.         # Config Information
  143.         self.info_cache_config = prometheus_client.Info(
  144.             name='vllm:cache_config',
  145.             documentation='information of cache_config')
  147.     def _unregister_vllm_metrics(self) -> None:
  148.         for collector in list(prometheus_client.REGISTRY._collector_to_names):
  149.             if hasattr(collector, "_name") and "vllm" in collector._name:
  150.                 prometheus_client.REGISTRY.unregister(collector)