All Products
Search
Document Center

Platform For AI:Service monitoring overview

Last Updated:Sep 28, 2026

After an EAS service is deployed, you can view metrics such as QPS, latency, error rate, and resource usage on the Monitoring tab of the service details page to understand the service invocation and running status.

View monitoring data

Access the monitoring page

  1. Log on to the PAI console. Select a region on the top of the page. Then, select the desired workspace and click Enter Elastic Algorithm Service (EAS).

  2. Click the name of the target service to go to the service details page, and then switch to the Monitor tab.

Select dimensions and dashboards

The monitoring page provides two-level selection in the upper-left corner: first select a monitoring dimension (Service or Instance) from the drop-down list, and then select a dashboard.

Note
  • LLM dashboards are available for LLM inference services that use the vLLM or SGLang engine. You must use an official PAI-EAS image or configure ServiceEngineType to sglang or vllm in the service labels. For more information, see LLM monitoring metrics > Prerequisites.

  • GPU dashboards are available only for services that use GPUs.

  • Service dimension: View monitoring metrics for the entire service. After you select Service from the drop-down list, the following dashboards are available:

    • Service-<service_name> (where <service_name> is the name of the EAS service): the service monitoring dashboard. This dashboard displays general service monitoring metrics such as QPS, RT, CPU, and Memory.

    • LLM: Displays service monitoring metrics based on the inference engine (SGLang or vLLM) used by the LLM service, such as request throughput and token usage.

    • GPU: Displays GPU hardware metrics such as SM utilization, memory bandwidth, and NVSwitch errors.

  • Instance dimension: View monitoring metrics for individual instances. After you select Instance from the drop-down list, the following dashboards are available:

    • Single Instance: The single-instance monitoring dashboard. You can select only one instance at a time. Only minute-level monitoring metrics are available.

    • Multiple Instance: The multi-instance monitoring dashboard. You can select multiple instances for comparison. Both minute-level and second-level monitoring metrics are available.

    • LLM Instance: The LLM instance monitoring dashboard. You can select one or more instances for comparison. This dashboard displays instance-level LLM inference metrics.

    • GPU Instance: The GPU instance monitoring dashboard. You can select one or more instances for comparison. This dashboard displays fine-grained GPU hardware metrics at the instance level.

The following table maps each dashboard to the corresponding metrics section.

Dashboard

Metrics section

Service-<service_name>

Monitoring metrics > Service Monitoring Dashboard

Single Instance

Monitoring metrics > Single Instance Monitoring Dashboard (Minute-Level)

Multiple Instance

Monitoring metrics > Multiple Instance Monitoring Dashboard

GPU / GPU Instance

Monitoring metrics > GPU Monitoring Dashboard

LLM / LLM Instance

LLM monitoring metrics

Change time range

Click image on the right side of the Monitor area to change the time range of the dashboards.

In the time picker panel that opens, you can specify a custom start and end time (From / To) under Absolute time range on the left, or select a preset range, such as Last 5 minutes to Last 7 days, from the Relative time ranges list on the right. The selected time range is marked with a check mark (✓).

Important

Minute-level metrics are retained for up to 1 month. Second-level metrics are retained for up to 1 hour.

Monitoring metrics

Service Monitoring Dashboard (Minute-Level)

This dashboard tracks the following metrics:

Metric

Description

QPS

Requests per second, grouped by return code. Summed across instances for multi-instance services. The 1d offset shows the previous day's QPS for trend comparison.

Response

Total responses in the selected time range, grouped by return code. Summed across instances for multi-instance services.

RT

Request response time.

  • Avg: Average response time of all requests.

  • TPXX: The XX-th percentile response time.

    For example, TP5 is the 5th-percentile max response time. TP100 is the max across all requests.

    For multi-instance services, TP100 is the max across all instances. Other TPXX values are averaged across instances.

Daily Invoke

Daily call count, grouped by return code. Summed across instances for multi-instance services.

More Metrics (CPU | Memory | GPU | Network | Resources)

Metric

Description

CPU

CPU

Average CPU usage of the service. Unit: CPU cores. Averaged across instances for multi-instance services.

CPU Utilization

Average CPU utilization of the service. Calculation: Average CPU usage ÷ Maximum available CPU cores. Averaged across instances for multi-instance services.

CPU Total

Total available CPU cores for the service. Calculation: Available CPU cores per single instance × Number of service instances.

Memory

Memory

Average memory usage of the service. Averaged across instances for multi-instance services.

  • RSS: Resident physical memory size.

  • Cache: Cache size.

  • Total: Maximum available physical memory size for a single instance.

Memory Utilization

Average memory utilization of the service. Calculation: Memory RSS ÷ Memory Total. Averaged across instances for multi-instance services.

GPU

GPU Utilization

For GPU-enabled services, average GPU utilization. Averaged across instances for multi-instance services.

GPU Memory

For GPU-enabled services, GPU memory usage. Averaged across instances for multi-instance services.

GPU Total

For GPU-enabled services, total GPU amount. For services with multiple instances, this metric is the sum of GPUs across all instances.

GPU Memory Utilization

For GPU-enabled services, GPU memory utilization. Averaged across instances for multi-instance services.

Network

Traffic

Traffic received and sent by the service, in bits per second. Averaged across instances for multi-instance services.

Where:

  • In: Traffic received.

  • Out: Traffic sent.

TCP Connections

Number of TCP connections.

Resources

Replicas

Number of service instances in different states: Total, Pending, Available.

Replicas By Resource

Number of service instances by resource type: Total, Dedicated (dedicated resources), Public (public resources).

Single Instance Monitoring Dashboard (Minute-Level)

This dashboard tracks the following metrics:

Metric

Description

QPS

Requests per second received by this instance. Grouped by return code.

RT

Response time of requests for this instance.

Response

Total responses received by this instance within the selected time range. Grouped by return code.

More Metrics (CPU | Memory | GPU | Network | Resources)

Metric

Description

CPU

CPU

CPU usage of this instance, in CPU cores.

CPU Utilization

Average CPU utilization of this instance. Calculation: Average CPU usage ÷ Maximum available CPU cores.

Memory

Memory

Memory usage of this instance.

  • RSS: Resident physical memory size.

  • Cache: Cache size.

  • Total: Maximum available physical memory size for a single instance.

Memory Utilization

Average memory utilization of this instance. Calculation: Memory RSS ÷ Memory Total.

GPU

GPU Utilization

GPU utilization of this instance.

GPU Memory

GPU memory usage of this instance.

GPU Memory Utilization

GPU memory utilization of this instance.

Network

Traffic

Traffic received and sent by this instance, in bits per second.

Where:

  • In: Traffic received.

  • Out: Traffic sent.

TCP Connections

Number of TCP connections.

Multiple Instance Monitoring Dashboard

Minute-level and second-level metrics:

  • Minute-Level

    Metric

    Description

    Instance QPS

    Requests per second for each instance. Grouped by return code.

    Instance RT

    Average response time for each instance.

    Instance CPU

    CPU usage for each instance, in CPU cores.

    Instance Memory -- RSS

    Resident physical memory size for each instance.

    Instance Memory -- Cache

    Cache size for each instance.

    Instance GPU

    GPU utilization for each instance.

    Instance GPU Memory

    GPU memory usage for each instance.

    Instance TCP Connections

    Number of TCP connections for each instance.

  • Second-Level

    Important

    Data granularity is 5 seconds. Only the last 1 hour of data is retained.

    Metric

    Description

    Instance QPS Fine

    Requests per second received by each instance. Grouped by return code.

    Instance RT Fine

    Average response time for requests received by each instance.

GPU Monitoring Dashboard

GPU metrics at service and instance levels. Service-level values are averaged across all instances.

Metric

Description

GPU Utilization

GPU utilization of the service.

GPU Memory

GPU memory usage and total GPU memory of the service.

  • Used: GPU memory usage.

  • Total: Total GPU memory.

Memory Copy Utilization

GPU memory copy utilization of the service.

GPU Memory Utilization

GPU memory utilization of the service. Calculation: Memory usage ÷ Total memory.

PCIe

PCIe (Peripheral Component Interconnect Express) rate of the service, measured by DCGM. PCIe is a high-speed serial computer expansion bus standard.

  • PCIe Transmit: PCIe transmission rate.

  • PCIe Receive: PCIe reception rate.

Memory Bandwidth

GPU memory bandwidth metric of the service.

SM Utilization and Occupancy

SM (Streaming Multiprocessor) related metrics of the service. SMs are core components of a GPU, responsible for executing and scheduling parallel computing tasks.

  • SM Utilization: SM utilization.

  • SM Occupancy: Ratio of Warp threads residing on the SM.

Graphics Engine Utilization

GPU graphics engine utilization of the service.

Pipe Active Ratio

Activity rate of the GPU compute pipelines of the service.

  • Pipe Fp32 Active Ratio: FP32 pipeline activity rate.

  • Pipe Fp16 Active Ratio: FP16 pipeline activity rate.

  • Pipe Tensor Active Ratio: Tensor pipeline activity rate.

Tflops Usage

Tflops (Tera floating-point operations per second) compute volume of the GPU compute pipelines of the service.

  • FP32 Tflops Used: FP32 pipeline Tflops compute volume.

  • FP16 Tflops Used: FP16 pipeline Tflops compute volume.

  • Tensor Tflops Used: Tensor pipeline Tflops compute volume.

DRAM Active Ratio

Activity rate of the GPU device memory interface sending or receiving data.

SM Clock

SM clock frequency of the service.

GPU Temperature

GPU temperature related metrics of the service.

  • GPU Temperature: GPU temperature.

  • GPU Slowdown Temperature: GPU throttling temperature threshold. When the GPU temperature reaches this value, the GPU automatically reduces its operating frequency to prevent overheating.

  • GPU Shutdown Temperature: GPU shutdown temperature threshold. When the GPU temperature reaches this value, the system forces the GPU device to shut down. This prevents hardware damage or more severe system failures due to GPU overheating.

Power Usage

GPU power consumption of the service.

The following are GPU health status and anomaly information metrics:

Metric

Description

GPU Health Count

Number of healthy GPU cards for the service.

GPU Lost Card Num

Number of lost GPU cards for the service.

ECC Error Count

Number of ECC errors for the service. ECC (Error Correction Code) detects and corrects errors during GPU memory data transmission or storage.

  • Volatile SBE ECC Error: Number of single-bit volatile ECC errors for the service.

  • Volatile DBE ECC Error: Number of double-bit volatile ECC errors for the service.

  • Aggregate SBE ECC Error: Number of single-bit persistent ECC errors for the service.

  • Aggregate DBE ECC Error: Number of double-bit persistent ECC errors for the service.

  • Uncorrectable ECC Error: Number of uncorrectable ECC errors for the service.

NVSwitch Error Count

Number of NVSwitch errors for the service. NVSwitch provides high-bandwidth, low-latency communication channels for high-speed communication between multiple GPUs.

  • NVSwitch Fatal Error: Number of fatal NVSwitch errors for the service.

  • NVSwitch Non-Fatal Error: Number of non-fatal NVSwitch errors for the service.

Xid Error Count

Number of Xid errors for the service. Xid errors are error codes reported by the GPU driver. They indicate issues encountered by the GPU during operation. These errors are typically recorded in system logs (such as Linux dmesg or Windows Event Viewer) and represented as Xid codes.

  • Xid Error: Number of non-fatal Xid errors for the service.

  • Fatal Xid Error: Number of fatal Xid errors for the service.

Kernel Error Count

Number of non-Xid errors for the service. Non-Xid errors refer to other types of errors reported in kernel logs, excluding Xid errors.

Driver Hang

Number of GPU driver hangs for the service.

Remap Status

The state of the service when the GPU attempts to remap GPU memory rows.

LLM monitoring metrics

LLM monitoring metrics are displayed in the LLM or LLM Instance dashboard regardless of whether the service uses the vLLM or SGLang engine. View the corresponding monitoring metrics based on the engine used.

Prerequisites

LLM dashboards are displayed when any of the following conditions are met:

  • An official PAI-EAS image is used.

  • ServiceEngineType is set to sglang or vllm in the service labels. Example:

    {
      "labels": {
        "ServiceEngineType": "sglang"
      }
    }

Note:

  • The EAS backend calls the /metrics endpoint of the engine every 10 to 15 seconds to collect Prometheus metrics. Therefore, /metrics 200 entries appear regularly in the service logs.

  • Minute-level metrics are retained for up to 1 month.

Multi-instance aggregation rules

For multi-instance services, throughput, count, and capacity metrics are summed across all instances. Ratio, utilization, and average latency metrics are averaged across all instances.

SGLang Monitoring Dashboard

Requests

Metric

Description

Prometheus metric

Running & Waiting Reqs

Number of requests at this point in time.

  • Running: Number of requests currently running on the GPU (real-time concurrency).

  • Waiting: Number of requests queued in the waiting queue. A value consistently greater than 0 indicates overload.

For multi-instance services, this metric is summed across all instances.

sglang:num_running_reqs

sglang:num_queue_reqs

Request Rate (success/abort/fail)

Request rate at this point in time, in requests per second.

  • requests: Rate of completed requests.

  • aborted: Rate of requests aborted due to client disconnection, timeout, or explicit abort.

  • transfer_failed: Rate of requests with KV cache transfer failures in PD disaggregation mode.

  • failed_session_recoveries: Rate of Mooncake transport session recoveries (removed from blocklist) in PD disaggregation mode.

For multi-instance services, this metric is summed across all instances.

sglang:num_requests_total

sglang:num_aborted_requests_total

sglang:num_transfer_failed_reqs_total

sglang:failed_session_recoveries_total

Prompt & Generation Token Rate

Input and output token rate at this point in time.

  • TPS_IN: Number of input (Prefill) tokens processed per second.

  • TPS_OUT: Number of output (Decode) tokens generated per second.

For multi-instance services, this metric is summed across all instances.

sglang:prompt_tokens_total

sglang:generation_tokens_total

Latency

Metric

Description

Prometheus metric

Queue Time

Queue waiting latency for all requests at this point in time, from when a request enters the waiting queue to when it is scheduled by the scheduler for computation.

  • Avg: Weighted average queue latency across all requests.

  • P50/P95/P99: Percentile values of queue latency across all requests.

sglang:queue_time_seconds

Time To First Token

Time to first token (TTFT) latency for all requests at this point in time, from when a request is received to when the first token is generated.

  • Avg: Weighted average TTFT across all requests.

  • P50/P95/P99: Percentile values of TTFT across all requests.

sglang:time_to_first_token_seconds

Time Per Output Token

Time per output token (TPOT/ITL) latency for all requests at this point in time, the time required for each subsequent output token after the first token is generated.

  • Avg: Weighted average TPOT across all requests.

  • P50/P95/P99: Percentile values of TPOT across all requests.

sglang:inter_token_latency_seconds

E2E Request Latency

End-to-end latency for all requests at this point in time, from when a request is received to when all tokens are returned.

  • Avg: Weighted average end-to-end latency across all requests.

  • P50/P95/P99: Percentile values of end-to-end latency across all requests.

Note

This metric is provided by the SGLang engine. The RT metric in the service monitoring dashboard is provided by the EAS engine (easworker). For LLM scenarios, this metric is recommended.

sglang:e2e_request_latency_seconds

Latency by PD Stage (Avg)

Average time spent in each processing stage at this point in time, plotted as separate curves by the stage label. Use this metric to identify which stage consumes the most latency. Common stages include:

  • tokenize (tokenization), api_server_dispatch (API Server dispatch), dpc_dispatch (DP controller dispatch), request_process (scheduler receive and process)

  • prefill_waiting/decode_waiting (queue waiting)

  • prefill_forward/prefill_chunked_forward/decode_forward/decode_loop (forward computation)

  • mm_encode (multimodal encoding)

  • spec_draft/spec_verify (speculative decoding draft and verify)

  • PD disaggregation stages: prefill_bootstrap/prefill_transfer_kv_cache/decode_prealloc/decode_bootstrap/decode_transferred

sglang:per_stage_req_latency_seconds

Token Length Distribution

Metric

Description

Prometheus metric

Prompt Tokens Length

Distribution of input token lengths for all requests at this point in time.

  • Avg: Weighted average input token length.

  • P50/P95/P99: Percentile values of input token length.

sglang:prompt_tokens_histogram

Uncached Prompt Tokens Length

Distribution of input token lengths that missed the cache and require actual computation at this point in time (equal to input token length minus prefix cache hit token length). This metric represents the actual compute overhead of the Prefill stage.

  • Avg: Weighted average uncached input token length.

  • P50/P95/P99: Percentile values of uncached input token length.

sglang:uncached_prompt_tokens_histogram

Generation Tokens Length

Distribution of output token lengths for all requests at this point in time.

  • Avg: Weighted average output token length.

  • P50/P95/P99: Percentile values of output token length.

sglang:generation_tokens_histogram

Token Throughput

Metric

Description

Prometheus metric

Token Rate by Phase (Prefill/Decode)

Token processing rate by phase at this point in time, plotted as separate curves by the mode label.

  • prefill_compute: Token rate actually computed during the Prefill stage.

  • prefill_cache: Token rate served from prefix cache hits during the Prefill stage (no computation required).

  • decode: Token rate generated during the Decode stage.

For multi-instance services, this metric is summed across all instances.

sglang:realtime_tokens_total

Decode Sum Seq Lens

Sum of all sequence lengths in Decode batches at this point in time. This reflects the actual read scale of the Attention computation in the Decode stage.

For multi-instance services, this metric is summed across all instances.

sglang:decode_sum_seq_lens

Cache Hierarchy

Metric

Description

Prometheus metric

Prefix Cache Hit Rate

Average prefix cache hit rate for all requests at this point in time.

For multi-instance services, this metric is averaged across all instances.

sglang:cache_hit_rate

Cached Prompt Tokens by Source

Rate of cached input tokens at this point in time, plotted as separate curves by the cache_source label to show cache hierarchy levels.

  • device: Prefix cache hits in GPU memory (L1).

  • host: HiCache host memory cache hits (L2).

  • storage_<backend>: HiCache external storage backend hits (L3), suffixed with the backend name.

For multi-instance services, this metric is summed across all instances.

sglang:cached_tokens_total

Cache Hit Ratio by Source

Cache hit ratio by hierarchy level at this point in time. Calculation: token rate for each level ÷ total input token rate. Values are normalized to 0–1.

  • <cache_source> ratio: Hit ratio for each level (device/host/storage_<backend>).

  • uncached: Ratio of input tokens that missed all cache levels and require actual computation.

sglang:cached_tokens_total

sglang:prompt_tokens_total

HiCache Host Tokens

HiCache host memory cache (L2) token watermark at this point in time. Displayed only when HiCache is enabled.

  • used: Number of tokens used in the host cache.

  • total: Total token capacity of the host cache.

For multi-instance services, this metric is summed across all instances.

sglang:hicache_host_used_tokens

sglang:hicache_host_total_tokens

Eviction Duration (GPU→CPU)

Time to evict KV cache from GPU to host memory at this point in time.

  • Avg: Weighted average eviction duration.

  • P99: 99th percentile eviction duration.

sglang:eviction_duration_seconds

Load Back Duration (CPU→GPU)

Time to load KV cache from host memory back to GPU at this point in time. This duration is directly added to the TTFT of requests that hit the L2 cache.

  • Avg: Weighted average load duration.

  • P99: 99th percentile load duration.

sglang:load_back_duration_seconds

Cache Tokens Flow (L1↔L2↔L3)

Token flow rate of KV cache between the three storage tiers at this point in time. Use this metric to determine the direction and pressure of HiCache data movement.

  • L3→L2 prefetched (storage→host): Token rate prefetched from external storage to host memory.

  • L2→L1 load_back (host→GPU): Token rate loaded from host memory back to GPU.

  • L2→L3 backuped (host→storage): Token rate backed up from host memory to external storage.

  • L1→L2 evicted (GPU→host): Token rate evicted from GPU to host memory.

For multi-instance services, this metric is summed across all instances.

sglang:prefetched_tokens_total

sglang:load_back_tokens_total

sglang:backuped_tokens_total

sglang:evicted_tokens_total

KV Cache Pool

The following panels show the composition and pressure of each memory pool by slot dimension and utilization dimension. For multi-instance services, slot metrics are summed across all instances, and utilization and ratio metrics are averaged across all instances.

Metric

Description

Prometheus metric

KV Cache Tokens Pool

Slot composition of the main KV cache pool at this point in time.

  • available: Number of completely idle token slots that can be allocated directly.

  • evictable: Number of token slots occupied by Radix prefix cache that can be evicted and reused when needed.

  • used: Number of token slots currently occupied by running requests.

Note

It is normal for available to be 0 while evictable is large. This indicates that GPU memory is fully utilized by prefix cache. Only when both available and evictable approach 0 does it indicate true GPU memory shortage.

sglang:kv_available_tokens

sglang:kv_evictable_tokens

sglang:kv_used_tokens

SWA Tokens Pool

Slot composition of the sliding window attention (SWA) pool at this point in time, with available/evictable/used curves. The meanings are the same as above. Displayed only for hybrid SWA models.

sglang:swa_available_tokens

sglang:swa_evictable_tokens

sglang:swa_used_tokens

Mamba SSM Pool

Slot composition of the Mamba SSM state pool at this point in time, with available/evictable/used curves. The meanings are the same as above. Displayed only for hybrid SSM (Mamba/GDN/KDA) models.

Note

Slots in this pool are allocated per request rather than per token. This is a common hard constraint for concurrency in hybrid models.

sglang:mamba_available_tokens

sglang:mamba_evictable_tokens

sglang:mamba_used_tokens

KV Cache Used Tokens

Number of KV cache tokens used at this point in time.

For multi-instance services, this metric is summed across all instances.

sglang:num_used_tokens

KV Cache Usage Ratio

Average KV cache token utilization at this point in time. A value consistently close to 1 indicates that the GPU memory pool has become a throughput bottleneck, which triggers request queuing or retraction.

For multi-instance services, this metric is averaged across all instances.

sglang:token_usage

KV Usage by Pool (Full/SWA/Mamba)

Average utilization of each memory pool at this point in time. Use this metric for hybrid attention models to identify which pool is saturated first.

  • full: Full attention layer KV pool utilization.

  • swa: Sliding window attention (SWA) layer KV pool utilization. Displayed only for hybrid SWA models.

  • mamba: Mamba/linear attention layer state pool utilization. Displayed only for hybrid SSM models.

  • pending_prealloc: Ratio of tokens pre-reserved but not yet pre-allocated in PD disaggregation mode.

For multi-instance services, this metric is averaged across all instances.

sglang:full_token_usage

sglang:swa_token_usage

sglang:mamba_usage

sglang:pending_prealloc_token_usage

KV Transfer

The following panels have data only when the service is deployed in PD disaggregation (Prefill/Decode Disaggregation) mode. For multi-instance services, latency metrics are weighted averages across all instances.

Metric

Description

Prometheus metric

KV Transfer Latency

Time to transfer KV cache from Prefill instances to Decode instances at this point in time, in milliseconds.

  • Avg: Weighted average transfer duration.

  • P50/P95/P99: Percentile values of transfer duration.

sglang:kv_transfer_latency_ms

KV Transfer Total MB

Data size of a single KV transfer at this point in time, in MB.

  • Avg: Weighted average data size per transfer.

  • P99: 99th percentile data size per transfer.

sglang:kv_transfer_total_mb

KV Transfer Speed

KV transfer bandwidth at this point in time.

  • Avg: Weighted average transfer bandwidth.

  • P99: 99th percentile transfer bandwidth.

sglang:kv_transfer_speed_gb_s

KV Transfer Bootstrap

Time for KV transfer handshake (bootstrap) connection establishment at this point in time, in milliseconds. A high value usually indicates metadata exchange or network connection issues between Prefill and Decode instances, rather than bandwidth issues.

  • Avg: Weighted average connection establishment duration.

  • P50/P95/P99: Percentile values of connection establishment duration.

sglang:kv_transfer_bootstrap_ms

KV Transfer Alloc Wait

Time that Decode instances spend waiting for GPU memory allocation to receive KV cache at this point in time, in milliseconds. A high value indicates GPU memory contention on the Decode side, which signals an imbalanced PD cluster ratio.

  • Avg: Weighted average wait duration.

  • P99: 99th percentile wait duration.

sglang:kv_transfer_alloc_ms

Speculative Decoding

The following panels have data only when speculative decoding is enabled. Panels are plotted as separate curves by pp_rank/moe_ep_rank (legend format: pp{pp_rank}/ep{moe_ep_rank}). Each curve is averaged across all instances.

Metric

Description

Prometheus metric

Spec Accept Length (draft→target)

Average acceptance length of speculative decoding at this point in time (τ in the paper), which is the number of tokens actually produced per verify step, including the bonus token that the target model always produces. A value of 1 means speculative decoding has no effect (only the bonus token is produced per step). A higher value indicates a higher speedup.

sglang:spec_accept_length

Spec Accept Rate

Draft acceptance rate of speculative decoding at this point in time (α in the paper). Calculation: accepted draft tokens ÷ proposed draft tokens, excluding bonus tokens. This reflects how closely the draft model matches the target model distribution.

sglang:spec_accept_rate

Spec Steps & Draft Tokens

Active speculative decoding configuration parameters at this point in time.

  • steps: Current speculative steps (speculative_num_steps).

  • draft_tokens: Current draft token count (speculative_num_draft_tokens). When topk > 1, this value is decoupled from the number of steps.

Note

When adaptive speculative decoding is enabled, this configuration changes dynamically with the workload. Compare this with the Accept Length curve to determine whether the adaptive strategy is appropriate.

sglang:spec_num_steps

sglang:spec_num_draft_tokens

Scheduling

Metric

Description

Prometheus metric

Queue Reqs by PD Stage

Number of requests in each PD disaggregation queue at this point in time. Use this metric to identify where requests accumulate in the PD pipeline.

  • prefill_bootstrap: Requests waiting for handshake connection on the Prefill side.

  • prefill_inflight: Requests with KV cache in transit on the Prefill side.

  • decode_prealloc: Requests waiting for GPU memory pre-allocation on the Decode side.

  • decode_transfer: Requests waiting for KV cache transfer completion on the Decode side.

For multi-instance services, this metric is summed across all instances.

sglang:num_prefill_bootstrap_queue_reqs

sglang:num_prefill_inflight_queue_reqs

sglang:num_decode_prealloc_queue_reqs

sglang:num_decode_transfer_queue_reqs

SLO Utilization

Load level relative to SLO capacity at this point in time. Calculation: max(running requests ÷ max concurrency under SLO, KV cache utilization ÷ 0.9). This metric can be used as a reference for auto scaling.

For multi-instance services, this metric is averaged across all instances.

sglang:utilization

CUDA Graph Passes

Rate of forward passes classified by CUDA Graph hit status at this point in time, plotted as separate curves by the mode label.

  • decode_cuda_graph/decode_none: Rate of Decode forward passes with/without CUDA Graph hits.

  • prefill_cuda_graph/prefill_none: Rate of Prefill forward passes with/without CUDA Graph hits.

Note

A high *_none ratio indicates that batch shapes frequently fall outside the captured Graphs. You can optimize this by adjusting the batch size list for CUDA Graph capture.

For multi-instance services, this metric is summed across all instances.

sglang:cuda_graph_passes_total

Forward Occupancy

GPU occupancy by forward computation at this point in time. Calculation: GPU forward execution time ÷ wall clock time within the statistics window. Value range: 0 to 100. A low value indicates CPU scheduling overhead or GPU idle time. This is the first metric to check when throughput does not meet expectations.

Note

Data is available only when the engine-side device timer is enabled. After the service becomes idle, this value is set to NaN to avoid polluting statistics.

For multi-instance services, this metric is averaged across all instances.

sglang:fwd_occupancy

New Token Ratio

New token quota ratio of the scheduler at this point in time. This value is an adaptive conservatism coefficient for GPU memory pressure: it decreases when GPU memory is tight to reduce new request admission and avoid retraction, and gradually recovers to 1 when pressure eases.

For multi-instance services, this metric is averaged across all instances.

sglang:new_token_ratio

CUDA Graph Active

Whether batches are running on CUDA Graph at this point in time. 1 means enabled, 0 means fallback to eager mode.

For multi-instance services, this metric is averaged across all instances (which can be understood as the ratio of instances with CUDA Graph enabled).

sglang:is_cuda_graph

HTTP

Metric

Description

Prometheus metric

HTTP Requests Rate

Request rate grouped by request method and path at this point in time, in requests per second.

For multi-instance services, this metric is summed across all instances.

sglang:http_requests_total

HTTP Responses Rate by Status

Response rate grouped by path and response status code at this point in time, in requests per second. Use this metric to distinguish client errors (4xx) from server errors (5xx).

For multi-instance services, this metric is summed across all instances.

sglang:http_responses_total

HTTP Active Requests

Number of in-flight (not yet returned) requests grouped by request method and path at this point in time. This metric counts HTTP-layer in-flight requests, including those still in queue that have not entered the engine. Therefore, this value is usually greater than Running Reqs.

For multi-instance services, this metric is summed across all instances.

sglang:http_requests_active

System & Engine

Metric

Description

Prometheus metric

Disaggregation Routing Keys

Number of routing keys at this point in time. Use this metric to observe the distribution of PD disaggregation or multi-instance affinity routing.

  • routing_keys_active: Number of unique routing keys with in-flight requests at the HTTP layer.

  • unique_running_routing_keys: Number of unique routing keys in the current running batch.

For multi-instance services, this metric is summed across all instances.

sglang:routing_keys_active

sglang:num_unique_running_routing_keys

Process CPU by Component

CPU cores (user + kernel) consumed by each engine process at this point in time, plotted as separate curves by the component label (tokenizer, detokenizer, data_parallel_controller). Use this metric to identify CPU-side bottlenecks. For example, if the tokenizer saturates a single core, overall throughput is directly limited.

For multi-instance services, this metric is summed across all instances.

sglang:process_cpu_seconds_total

Engine Meta

Static engine configuration and startup information of the service. Use this metric to verify whether the actual parameters match expectations.

  • max_total_num_tokens: Maximum token capacity of the KV cache pool.

  • num_pages: Number of KV cache pages.

  • page_size: KV cache page size (number of tokens).

  • context_len: Maximum context length of the model.

  • startup_available_gpu_memory_gb: Available GPU memory at startup (GB), summed across all instances.

  • engine_startup_time: End-to-end engine startup duration (seconds).

  • engine_load_weights_time: Model weight loading duration (seconds).

Except for the memory items, all metrics take the maximum value across all instances.

sglang:max_total_num_tokens

sglang:num_pages

sglang:page_size

sglang:context_len

sglang:startup_available_gpu_memory_gb

sglang:startup_time_seconds

Request State (retracted/paused)

Number of requests in abnormal execution states at this point in time.

  • retracted: Number of requests retracted to the waiting queue due to GPU memory shortage that need to be prefilled again. A value consistently greater than 0 means that compute resources are wasted on redundant computation. Consider reducing concurrency or scaling up.

  • paused: Number of requests paused due to asynchronous weight synchronization (for example, weight updates in RLHF scenarios).

For multi-instance services, this metric is summed across all instances.

sglang:num_retracted_reqs

sglang:num_paused_reqs

Common troubleshooting paths

Symptom

Recommended check order

High TTFT

Queue Time → Waiting Reqs → Uncached Prompt Tokens Length → Prefix Cache Hit Rate → Load Back Duration

High TPOT

Running Reqs (excessive concurrency) → Decode Sum Seq Lens → KV Cache Usage Ratio → Forward Occupancy → decode_none ratio in CUDA Graph Passes

Low throughput but GPU utilization is not high

Forward Occupancy → Process CPU by Component → CUDA Graph Passes → New Token Ratio

GPU memory shortage / requests retracted

retracted in Request State → KV Cache Tokens Pool (check whether both available and evictable drop to zero) → KV Usage by Pool → New Token Ratio

Hybrid attention model cannot scale up concurrency

KV Usage by Pool (compare full/swa/mamba) → Mamba SSM Pool

PD disaggregation pipeline is slow

Queue Reqs by PD Stage → KV Transfer Bootstrap → KV Transfer Latency/Speed → KV Transfer Alloc Wait

Speculative decoding provides no speedup

Spec Accept Length (close to 1?) → Spec Accept Rate → Spec Steps & Draft Tokens

Find the recent maximum concurrency

Change the time range and then find the peak of the Running curve in Running & Waiting Reqs

VLLM Monitoring Dashboard

For multi-instance services, throughput metrics are summed and latency metrics are averaged across instances.

Metric

Description

Requests Status

Total requests for the service.

  • Running: Number of requests running on the GPU.

  • Waiting: Number of requests waiting for processing.

  • Swapped: Number of requests swapped to the CPU.

Token Throughput

Number of input and generated tokens for all requests of the service.

  • TPS_IN: Number of input tokens.

  • TPS_OUT: Number of output tokens.

Request Completion Status

Completion status statistics for all requests of the service.

  • preemptions: Requests preempted.

  • stop: Requests successfully completed due to natural termination (the model output a stop token, such as <EOS>).

  • length: Requests reached the maximum output token length.

  • abort: Requests forcibly terminated.

Time To First Token

Time to first token latency for all requests of the service (time from receiving a request to generating the first token).

  • Avg: Average time to first token latency for all requests.

  • TPXX: Percentile values for time to first token latency for all requests.

Time Per Output Token

Time per output token latency for all requests of the service (average time required for each output token after the first token is generated).

  • Avg: Average time per token latency for all requests.

  • TPXX: Percentile values for time per token latency for all requests.

E2E Request Latency

End-to-end latency for all requests of the service (time from receiving a request to returning all tokens).

  • Avg: Average end-to-end latency for all requests.

  • TPXX: Percentile values for end-to-end latency for all requests.

Queue Time

Queue waiting latency for all requests of the service (time requests wait in queue for engine processing).

  • Avg: Average queue waiting latency for all requests.

  • TPXX: Percentile values for queue waiting latency for all requests.

Inference Time

Inference latency for all requests of the service (time requests are processed by the engine).

  • Avg: Average inference latency for all requests.

  • TPXX: Percentile values for inference latency for all requests.

Prefill Time

Prefill stage latency for all requests of the service (time the engine processes request input tokens).

  • Avg: Average prefill latency for all requests.

  • TPXX: Percentile values for prefill latency for all requests.

Decode Time

Decode stage latency for all requests of the service (time the engine generates output tokens).

  • Avg: Average decode latency for all requests.

  • TPXX: Percentile values for decode latency for all requests.

Input Token Length

Number of input tokens processed by the service.

  • Avg: Average input token length for all requests.

  • TPXX: Percentile values for input token length for all requests.

Output Token Length

Number of output tokens generated by the service.

  • Avg: Average output token length for all requests.

  • TPXX: Percentile values for output token length for all requests.

Request Parameters(params_n & max_tokens)

Parameter N and parameter max_tokens for all requests of the service.

  • Params_n: Average value of parameter N for all requests.

  • Params_max_tokens: Average value of parameter max_tokens for all requests.

GPU KV Cache Usage

Average GPU KV cache utilization of the service.

CPU KV Cache Usage

Average CPU KV cache utilization of the service.

Prefix Cache Hit Rate

Average prefix cache hit rate for all requests of the service.

  • GPU: Average GPU prefix cache hit rate for all requests.

  • CPU: Average CPU prefix cache hit rate for all requests.

HTTP Requests by Endpoint

Number of requests for the service, grouped by request method, path, and response status code.

HTTP Request Latency

Average latency for different request paths of the service.

Speculative Decoding Throughput

Speculative decoding count for the service. Averaged across instances for multi-instance services.

  • Drafts: Number of Drafts Tokens generated.

  • Draft Tokens: Number of Drafts Tokens processed.

  • Accepted Tokens: Number of Drafts Tokens accepted.

  • Emitted Tokens: Number of Drafts Tokens emitted.

Speculative Decoding Efficiency

Speculative decoding performance of the service.

  • Draft Acceptance Rate: Average ratio of Drafts Tokens accepted.

  • Efficiency: Average efficiency of speculative decoding.

Token Acceptance by Position

Number of Drafts Tokens accepted at different generation positions for the service. Averaged across instances for multi-instance services.

FAQ

LLM monitoring dashboard not displayed

Problem: After custom EAS deployment, the monitoring page shows only Service and GPU dashboards. LLM monitoring is missing.

Cause: The service configuration is missing the ServiceEngineType tag, which declares the inference engine type.

Note

Only the ServiceEngineType tag affects LLM monitoring. Other Model Gallery deployment parameters have no impact.

Solution: Update the service configuration to add the ServiceEngineType tag and set its value based on the inference engine used (only vllm or sglang are supported). For example:

{
  "labels": {
    "ServiceEngineType": "vllm"
  }
}

Q: Why do /metrics 200 frequently appear in logs?

Once the ServiceEngineType tag takes effect, the EAS backend polls the inference framework's /metrics endpoint every 10-15 seconds across all pods. This endpoint returns real-time metrics in Prometheus format for the LLM monitoring dashboard.

Q: How to check the maximum concurrency in monitoring?

EAS monitoring does not provide a direct "maximum concurrency" metric. You can determine concurrency based on the service type:

  • LLM inference services (vllm or sglang engine): Switch to the VLLM Monitoring Dashboard or SGLang Monitoring Dashboard, and check the Running metric under Requests Status or Requests Num. This metric indicates the number of requests currently running on the GPU, which represents the real-time concurrency. By changing the time range (for example, selecting Last 1 hours or Last 6 hours), you can find the peak value of the Running curve, which is the maximum concurrency within that period.

  • General services: You can estimate concurrency using the QPS (queries per second) and RT (response time) metrics from the service monitoring dashboard. Based on Little's Law: Concurrency ≈ QPS × Average RT (seconds). For example, if QPS is 10 and average RT is 2 seconds, the concurrency is approximately 20. Apply this formula during peak periods to estimate the maximum concurrency.

Q: What is the difference between E2E Request Latency and RT?

E2E Request Latency is provided by the LLM inference engine, while RT is provided by the EAS engine (easworker). For LLM scenarios, E2E Request Latency is recommended.

Reference