Chapter 9. Distributed Inference with llm-d Observability


You can use Observability to analyze your llm-d deployments, improving overall model management and monitoring on the platform.

Use Prometheus to collect metrics from Distributed Inference with llm-d deployments and build custom observability dashboards to monitor token throughput, cache utilization, routing decisions, and inference performance. On OpenShift, the controller automatically creates PodMonitor and ServiceMonitor resources to scrape metrics from vLLM engines and the inference scheduler. On other Kubernetes platforms, configure Prometheus scrape targets manually to collect metrics from the vLLM and inference scheduler endpoints.

Important

Distributed Inference with llm-d Monitoring is a Developer Preview feature only. Developer Preview features are not supported by Red Hat in any way and are not functionally complete or production-ready. Do not use Developer Preview features for production or business-critical workloads. Developer Preview features provide early access to upcoming product features in advance of their possible inclusion in a Red Hat product offering, enabling customers to test functionality and provide feedback during the development process. These features might not have any documentation, are subject to change or removal at any time, and testing is limited. Red Hat might provide ways to submit feedback on Developer Preview features without an associated SLA.

9.1. Metrics for llm-d inference deployments

Distributed Inference with llm-d deployments expose Prometheus metrics that you can use to monitor inference performance, track resource usage, and detect operational issues. On OpenShift, the controller automatically creates PodMonitor and ServiceMonitor resources to collect these metrics when you deploy an LLMInferenceService. On other Kubernetes platforms, you must configure Prometheus scrape targets manually to collect metrics from the vLLM engine and inference scheduler endpoints. You can build custom dashboards for SLO compliance and capacity planning.

llm-d components expose three distinct categories of Prometheus metrics:

vLLM engine metrics
The vLLM model servers expose metrics on port 8000 at the /metrics endpoint. These metrics cover token throughput, request latency distributions, KV cache utilization, request queue depth, and model loading status. vLLM metrics provide the foundation for understanding individual model server performance and resource consumption.
EPP and inference scheduler metrics
The Endpoint Picker (EPP) exposes metrics at the /metrics endpoint on the metrics service port. These metrics cover request routing decisions, endpoint scoring, scheduling latency, plugin processing times, and prefix cache indexing performance. EPP metrics help you understand how requests are distributed across model server replicas and how efficiently the scheduler routes traffic.
Inference objective metrics
The inference scheduler also exposes higher-level metrics that track end-to-end inference performance against service level objectives. These metrics include request error rates, time to first token (TTFT), time per output token (TPOT), SLO violation counts, and request duration distributions. Inference objective metrics provide the basis for SLO-based alerting and compliance monitoring.

These three metric categories work together to provide a complete picture of your llm-d deployment health. Use vLLM metrics to monitor individual model server capacity, EPP metrics to evaluate routing efficiency, and inference objective metrics to track overall service quality.

On OpenShift, the controller automatically creates PodMonitor and ServiceMonitor resources to scrape metrics from vLLM engines and the inference scheduler when you deploy an LLMInferenceService. On other Kubernetes platforms, the controller does not create these resources. You must configure Prometheus scrape targets manually to collect metrics.

The following scrape targets expose llm-d metrics:

vLLM engine metrics
Exposed on port 8000 at the /metrics endpoint on each model server pod.
EPP and inference scheduler metrics
Exposed at the /metrics endpoint on the metrics service port of the scheduler service.

Prerequisites

  • You have a deployed Distributed Inference with llm-d inference deployment on Red Hat OpenShift AI 3.4.
  • You have cluster administrator access.
  • You have a Prometheus-based monitoring stack configured in your cluster.

    On OpenShift, enable user workload monitoring. The Prometheus Operator is included automatically. See Configuring user workload monitoring.

    On other Kubernetes platforms, you must have the Prometheus Operator installed if you want to use PodMonitor and ServiceMonitor resources, or a standalone Prometheus deployment configured with static or service-discovery-based scrape targets.

Procedure

On OpenShift:

  1. Verify that the PodMonitor resource for vLLM engine metrics exists in your deployment namespace:

    $ kubectl get podmonitors -n <NAMESPACE> -l app.kubernetes.io/component=llm-monitoring

    Replace <NAMESPACE> with the namespace where your llm-d deployment runs.

    The output shows a PodMonitor resource with a name that begins with kserve-llm-isvc-vllm-engine. This resource scrapes vLLM metrics from port 8000 on all model server pods.

  2. Verify that the ServiceMonitor resource for inference scheduler metrics exists in your deployment namespace:

    $ kubectl get servicemonitors -n <NAMESPACE> -l app.kubernetes.io/component=llm-monitoring

    The output shows a ServiceMonitor resource with a name that begins with kserve-llm-isvc-scheduler. This resource scrapes EPP and inference scheduler metrics from the metrics port on the scheduler service.

On other Kubernetes platforms without the Prometheus Operator:

  1. Configure your Prometheus instance to scrape the following targets in your deployment namespace:

    Expand
    Table 9.1. llm-d scrape targets
    ComponentPortPathPod selector

    vLLM engine

    8000

    /metrics

    Pods with the label app: <POOL_NAME>, where <POOL_NAME> is the name of your InferencePool resource.

    EPP and inference scheduler

    9090

    /metrics

    The EPP service, selected by the label app: <EPP_NAME>, where <EPP_NAME> is the name of your EPP deployment.

On all platforms:

  1. Verify that Prometheus is scraping vLLM metrics by running the following PromQL query against your Prometheus instance:

    vllm:num_requests_running{namespace="<NAMESPACE>"}

    Replace <NAMESPACE> with your deployment namespace.

    On OpenShift, run this query from the web console by navigating to Observe > Metrics.

    On other Kubernetes platforms, run this query by using your Prometheus web UI or API.

    If the query returns results, Prometheus is successfully scraping vLLM metrics.

  2. Verify that Prometheus is scraping EPP and inference scheduler metrics by running the following PromQL query:

    llm_d_inference_scheduler_disagg_decision_total{namespace="<NAMESPACE>"}

    Replace <NAMESPACE> with your deployment namespace.

    If the query returns results, Prometheus is successfully scraping inference scheduler metrics.

Note

Metrics might take up to 60 seconds to appear after the LLMInferenceService is deployed. If metrics do not appear, verify that your monitoring stack is configured to scrape metrics from the deployment namespace. On OpenShift, verify that user workload monitoring is enabled and that PodMonitor and ServiceMonitor resources are present. On other platforms, verify that the Prometheus scrape configuration targets the correct namespace, ports, and label selectors.

9.3. PromQL queries for llm-d monitoring

You can use the following PromQL queries to monitor your Distributed Inference with llm-d deployments. The queries are organized into two groups: immediate failure and saturation indicators that drive operational alerts, and diagnostic drill-down queries that support deeper investigation.

Failure and saturation indicators

Use the following queries for dashboards and alerts that track service health and capacity limits.

Expand
Table 9.2. Failure and saturation PromQL queries
Operational concernPromQL query

Overall error rate

sum(rate(inference_objective_request_error_total[5m])) / sum(rate(inference_objective_request_total[5m]))

Per-model error rate

sum by(model_name) (rate(inference_objective_request_error_total[5m])) / sum by(model_name) (rate(inference_objective_request_total[5m]))

Error rate by error code

sum by(error_code) (rate(inference_objective_request_error_total[5m]))

Request rate by model

sum by(model_name, target_model_name) (rate(inference_objective_request_total[5m]))

Overall latency P99

histogram_quantile(0.99, sum by(le) (rate(inference_objective_request_duration_seconds_bucket[5m])))

Overall latency P90

histogram_quantile(0.90, sum by(le) (rate(inference_objective_request_duration_seconds_bucket[5m])))

Model-specific TTFT P99

histogram_quantile(0.99, sum by(le, model_name) (rate(vllm:time_to_first_token_seconds_bucket[5m])))

Model-specific TPOT P99

histogram_quantile(0.99, sum by(le, model_name) (rate(vllm:inter_token_latency_seconds_bucket[5m])))

EPP end-to-end latency P99

histogram_quantile(0.99, sum by(le) (rate(inference_extension_scheduler_e2e_duration_seconds_bucket[5m])))

Plugin processing latency P99

histogram_quantile(0.99, sum by(le, plugin_type) (rate(inference_extension_plugin_duration_seconds_bucket[5m])))

Scheduler health

avg_over_time(up{job=~".*epp.*"}[5m])

Request preemptions per vLLM instance

sum by(pod, instance) (rate(vllm:num_preemptions_total[5m]))

Diagnostic drill-down queries

Use the following queries for deeper investigation when failure and saturation indicators signal issues.

Expand
Table 9.3. Model serving and scaling queries
Operational concernPromQL query

KV cache utilization by pod

avg by(pod, model_name) (vllm:kv_cache_usage_perc)

Request queue length by pod

sum by(pod, model_name) (vllm:num_requests_waiting)

Model throughput in tokens per second

sum by(model_name, pod) (rate(vllm:prompt_tokens_total[5m]) + rate(vllm:generation_tokens_total[5m]))

Generation token rate by pod

sum by(model_name, pod) (rate(vllm:generation_tokens_total[5m]))

Active requests per pod

avg by(pod) (vllm:num_requests_running)

Expand
Table 9.4. Routing and load balancing queries
Operational concernPromQL query

Request distribution per instance

sum by(pod) (rate(inference_objective_request_total{target_model_name!=""}[5m]))

Token distribution across pods

sum by(pod) (rate(vllm:prompt_tokens_total[5m]) + rate(vllm:generation_tokens_total[5m]))

Routing decision latency P99

histogram_quantile(0.99, sum by(le) (rate(inference_extension_plugin_duration_seconds_bucket[5m])))

Expand
Table 9.5. Prefix caching queries
Operational concernPromQL query

Prefix cache hit rate

sum(rate(vllm:prefix_cache_hits_total[5m])) / sum(rate(vllm:prefix_cache_queries_total[5m]))

Per-instance prefix cache hit rate

sum by(pod) (rate(vllm:prefix_cache_hits_total[5m])) / sum by(pod) (rate(vllm:prefix_cache_queries_total[5m]))

KV cache utilization percentage

avg by(pod, model_name) (vllm:kv_cache_usage_perc * 100)

EPP prefix indexer size

inference_extension_prefix_indexer_size

EPP prefix indexer hit ratio P90

histogram_quantile(0.90, sum by(le) (rate(inference_extension_prefix_indexer_hit_ratio_bucket[5m])))

Expand
Table 9.6. Prefill/decode disaggregation queries
Operational concernPromQL query

Prefill worker utilization

avg by(pod) (vllm:num_requests_running{pod=~".*prefill.*"})

Decode worker KV cache utilization

avg by(pod) (vllm:kv_cache_usage_perc{pod=~".*decode.*"})

Prefill queue length

sum by(pod) (vllm:num_requests_waiting{pod=~".*prefill.*"})

Disaggregation decision rate by type

sum by(decision_type) (rate(llm_d_inference_scheduler_disagg_decision_total[5m]))

Disaggregation decision ratio

sum(rate(llm_d_inference_scheduler_disagg_decision_total{decision_type="prefill-decode"}[5m])) / sum(rate(llm_d_inference_scheduler_disagg_decision_total[5m]))

9.4. Import Grafana dashboards for llm-d

You can import community Grafana dashboards to get a baseline monitoring view of your Distributed Inference with llm-d deployments. The dashboards provide pre-built visualizations for vLLM performance, failure and saturation indicators, diagnostic drill-downs, KV cache performance, and prefill/decode disaggregation metrics.

Prerequisites

  • You have a Grafana instance deployed and connected to a Prometheus data source that collects llm-d metrics. Grafana is not included with OpenShift. You must deploy Grafana separately, for example, by using the Grafana community Operator.
  • Metrics collection is enabled for your Distributed Inference with llm-d deployment.

Procedure

  1. Download the community Grafana dashboard JSON files from the llm-d project.

    The following dashboards are available:

    llm-d vLLM Overview
    General vLLM metrics overview for monitoring llm-d inference servers. Download from llm-d-vllm-overview.json.
    llm-d Failure and Saturation Indicators
    Key failure and saturation indicators for identifying system issues and capacity constraints. Download from llm-d-failure-saturation-dashboard.json.
    llm-d Diagnostic Drill-Down
    Detailed diagnostic metrics for investigating performance issues. Download from llm-d-diagnostic-drilldown-dashboard.json.
    llm-d Performance Dashboard
    Performance metrics including KV cache utilization. Download from llm-performance-kv-cache.json.
    P/D Coordinator Metrics
    Prefill/decode disaggregation performance metrics, including vLLM end-to-end latency, prefill duration, decode duration, and phase breakdown. Download from pd-coordinator-metrics.json.
  2. In the Grafana web interface, navigate to Dashboards > New > Import.
  3. Upload a dashboard JSON file or paste the JSON content into the import dialog.
  4. Select the Prometheus data source that collects metrics from your llm-d deployment.
  5. Click Import to create the dashboard.
  6. Repeat the import process for each dashboard JSON file.

Verification

  • Navigate to a newly imported dashboard and verify that the panels display data from your llm-d deployment. If a "No data" message is shown, verify that the Prometheus data source is correctly configured and that metrics collection is enabled for the llm-d namespace.
Note

In disconnected environments, download the dashboard JSON files from a connected network and transfer them to a workstation with access to the Grafana instance. The dashboards do not reference external data sources, so they function in disconnected environments after Prometheus and Grafana are available.

9.5. vLLM metrics for llm-d

The vLLM model servers in Distributed Inference with llm-d deployments expose Prometheus metrics on port 8000 at the /metrics endpoint. You can use these metrics to monitor token throughput, request latency, KV cache usage, and request queue depth for individual model server replicas.

Token throughput metrics

Expand
Table 9.7. Token throughput metrics
Metric nameTypeLabelsDescription

vllm:prompt_tokens_total

counter

model_name

The total number of prompt tokens processed by the model server.

vllm:generation_tokens_total

counter

model_name

The total number of generation tokens produced by the model server.

vllm:e2e_request_latency_seconds

histogram

model_name

The end-to-end request latency distribution in seconds, measured from request receipt to response completion.

Latency metrics

Expand
Table 9.8. Latency metrics
Metric nameTypeLabelsDescription

vllm:time_to_first_token_seconds

histogram

model_name

The time to first token (TTFT) distribution in seconds. This measures the latency from request submission to the first generated token.

vllm:inter_token_latency_seconds

histogram

model_name

The inter-token latency distribution in seconds. This measures the time between consecutive output tokens.

KV cache metrics

Expand
Table 9.9. KV cache metrics
Metric nameTypeLabelsDescription

vllm:kv_cache_usage_perc

gauge

model_name

The GPU KV cache utilization as a percentage between 0.0 and 1.0.

vllm:num_preemptions_total

counter

model_name

The total number of request preemptions caused by KV cache pressure. Preemptions occur when the cache is full and running requests must be evicted to make room for new requests.

Request queue metrics

Expand
Table 9.10. Request queue metrics
Metric nameTypeLabelsDescription

vllm:num_requests_running

gauge

model_name

The current number of requests being actively processed by the model server.

vllm:num_requests_waiting

gauge

model_name

The current number of requests waiting in the queue for processing.

vllm:request_success_total

counter

engine, model_name, finished_reason

The total number of successfully completed inference requests, broken down by completion reason.

Prefix cache metrics

Expand
Table 9.11. Prefix cache metrics
Metric nameTypeLabelsDescription

vllm:prefix_cache_hits_total

counter

model_name

The total number of prefix cache hits. A cache hit occurs when a request prompt matches cached key-value data, avoiding redundant computation.

vllm:prefix_cache_queries_total

counter

model_name

The total number of prefix cache queries. Use this metric with prefix_cache_hits_total to calculate the cache hit rate.

9.6. EPP and inference scheduler metrics for llm-d

The Endpoint Picker (EPP) and inference scheduler in Distributed Inference with llm-d deployments expose Prometheus metrics at the /metrics endpoint on the metrics service port. You can use these metrics to monitor request routing decisions, scheduling latency, inference objective compliance, and prefix cache indexing performance.

Inference objective metrics

The inference objective metrics track end-to-end inference performance and SLO compliance. These metrics use the inference_objective_ prefix.

Expand
Table 9.12. Inference objective metrics
Metric nameTypeLabelsDescription

inference_objective_request_total

counter

model_name, target_model_name, priority

The total number of inference requests processed by the scheduler.

inference_objective_request_error_total

counter

model_name, target_model_name, error_code

The total number of inference request errors, broken down by error code.

inference_objective_request_duration_seconds

histogram

model_name, target_model_name

The end-to-end inference request duration distribution in seconds.

inference_objective_request_ttft_seconds

histogram

model_name, target_model_name

The time to first token (TTFT) distribution in seconds.

inference_objective_request_tpot_seconds

histogram

model_name, target_model_name

The time per output token (TPOT) distribution in seconds.

inference_objective_request_predicted_ttft_seconds

histogram

model_name, target_model_name

The predicted TTFT distribution in seconds, used by the scheduler for routing decisions.

inference_objective_request_predicted_tpot_seconds

histogram

model_name, target_model_name

The predicted TPOT distribution in seconds, used by the scheduler for routing decisions.

inference_objective_request_slo_violation_total

counter

model_name, target_model_name, type

The total number of SLO violations, broken down by violation type: tpot_slo_violation or ttft_slo_violation.

inference_objective_running_requests

gauge

model_name

The current number of active inference requests.

inference_objective_input_tokens

histogram

model_name, target_model_name

The input token count distribution per request.

inference_objective_output_tokens

histogram

model_name, target_model_name

The output token count distribution per request.

Scheduling and routing metrics

The scheduling and routing metrics track the internal performance of the Endpoint Picker. These metrics use the inference_extension_ prefix.

Expand
Table 9.13. Scheduling and routing metrics
Metric nameTypeLabelsDescription

inference_extension_scheduler_e2e_duration_seconds

histogram

None

The end-to-end scheduling duration in seconds, measured from request receipt to endpoint selection.

inference_extension_scheduler_attempts_total

counter

status

The total number of scheduling attempts, broken down by status: success or failure.

inference_extension_plugin_duration_seconds

histogram

extension_point, plugin_type, plugin_name

The plugin processing duration in seconds, broken down by extension point, plugin type, and plugin name. Use this metric to identify slow plugins that impact scheduling latency.

inference_extension_model_rewrite_decisions_total

counter

model_rewrite_name, model_name, target_model

The total number of model rewrite decisions made by the scheduler.

Prefix cache indexer metrics

The prefix cache indexer metrics track KV cache prefix matching performance in the scheduler. These metrics use the inference_extension_ prefix.

Expand
Table 9.14. Prefix cache indexer metrics
Metric nameTypeLabelsDescription

inference_extension_prefix_indexer_size

gauge

None

The current size of the prefix cache index maintained by the scheduler.

inference_extension_prefix_indexer_hit_ratio

histogram

None

The prefix cache hit ratio distribution. A higher hit ratio indicates that requests frequently match cached prefixes, reducing redundant computation.

inference_extension_prefix_indexer_hit_bytes

histogram

None

The prefix cache hit size distribution in bytes. Larger hit sizes indicate more effective prefix reuse.

Inference pool metrics

The inference pool metrics track aggregate statistics across all endpoints in a pool. These metrics use the inference_pool_ prefix.

Expand
Table 9.15. Inference pool metrics
Metric nameTypeLabelsDescription

inference_pool_average_kv_cache_utilization

gauge

name

The average KV cache utilization across all endpoints in the inference pool.

inference_pool_average_queue_size

gauge

name

The average request queue size across all endpoints in the inference pool.

inference_pool_average_running_requests

gauge

name

The average number of running requests across all endpoints in the inference pool.

inference_pool_ready_pods

gauge

name

The number of ready pods in the inference pool.

inference_pool_per_pod_queue_size

gauge

name, model_server_pod

The request queue size for a specific pod in the inference pool.

Red Hat logoGithubredditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat Documentation

Legal Notice

Theme

© 2026 Red Hat
Back to top