Skip to content

vllm_omni.metrics

Modules:

Name Description
definitions

Single source of truth for vLLM-Omni Prometheus + bench CLI metric naming.

modality

OmniModalityMetrics — per-modality Prometheus families (audio path only).

prometheus
realtime
stat_logger

OmniPrometheusStatLogger — wrap upstream PrometheusStatLogger.

stats
transfer

OmniTransferMetrics — cross-stage transfer Prometheus families.

utils

OmniPrometheusMetrics

Label-bound wrapper around the raw Prometheus metrics.

Metric collectors use the vllm_omni: prefix, distinct from the upstream vllm:* families.

inc_image_count

inc_image_count(n_images: int = 1) -> None

inc_requests_failed

inc_requests_failed(reason: str) -> None

observe_image_pixels

observe_image_pixels(n_pixels: int) -> None

observe_kv_wait

observe_kv_wait(
    connector_type: str, kv_wait_s: float
) -> None

observe_num_inference_steps

observe_num_inference_steps(n_steps: int) -> None

observe_queue_wait

observe_queue_wait(queue_wait_s: float) -> None

observe_stage_gen_time

observe_stage_gen_time(
    stage: int, stage_type: str, gen_time_s: float
) -> None

observe_stage_in_queue

observe_stage_in_queue(
    stage: int, in_queue_s: float
) -> None

observe_tokens

observe_tokens(
    prompt_tokens: int, generation_tokens: int
) -> None

request_failed

request_failed() -> None

request_succeeded

request_succeeded(
    e2e_seconds: float, finished_reason: str = "stop"
) -> None

set_peak_memory

set_peak_memory(stage: int, peak_memory_mb: float) -> None

set_running

set_running(n: int) -> None

set_stage_waiting_requests

set_stage_waiting_requests(
    stage: int, n_waiting: int
) -> None

set_waiting

set_waiting(n: int) -> None

OmniRequestCounter

Running-request counter written by the orchestrator thread, read by the client thread.

value instance-attribute

value = 0

decrement

decrement() -> None

increment

increment() -> None

OrchestratorAggregator

e2e_events instance-attribute

e2e_events: list[RequestE2EStats] = []

final_stage_id_for_e2e instance-attribute

final_stage_id_for_e2e = final_stage_id_for_e2e

log_stats instance-attribute

log_stats = bool(log_stats)

num_stages instance-attribute

num_stages = int(num_stages)

stage_events instance-attribute

stage_events: dict[str, list[StageRequestStats]] = {}

stage_table_exclude instance-attribute

stage_table_exclude = frozenset(stage_table_exclude)

transfer_events instance-attribute

transfer_events: dict[
    tuple[int, int, str], TransferEdgeStats
] = {}

accumulate_diffusion_metrics

accumulate_diffusion_metrics(
    stage_type: str, req_id: Any, engine_outputs: Any
) -> None

Accumulate diffusion metrics for a request.

Engine emits *_ms timings; the accumulator converts them to _s keys via _MS_TO_S so downstream observers read a uniform seconds-bearing dict. Per-chunk timing keys are summed; non-timing keys (e.g. image_num / resolution from format_diffusion_outputs) preserve the existing += semantics.

Parameters:

Name Type Description Default
req_id Any

Request ID

required
engine_outputs Any

Engine output object containing metrics

required

build_and_log_summary

build_and_log_summary() -> dict[str, Any]

init_run_state

init_run_state(wall_start_ts: float) -> None

on_finalize_request

on_finalize_request(
    stage_id: int, req_id: Any, req_start_ts: float
) -> None

on_forward

on_forward(
    from_stage: int,
    to_stage: int,
    req_id: Any,
    size_bytes: int,
    tx_ms: float,
    used_shm: bool,
) -> None

on_stage_metrics

on_stage_metrics(
    stage_id: int,
    req_id: Any,
    metrics: StageRequestStats,
    final_output_type: str | None = None,
) -> None

process_stage_metrics

process_stage_metrics(
    *,
    result: dict[str, Any],
    stage_type: str,
    stage_id: int,
    req_id: str,
    engine_outputs: Any,
    finished: bool,
    final_output_type: str | None,
    output_to_yield: Any | None,
    event_cursor: int = 0,
) -> None

Process and record stage metrics.

Parameters:

Name Type Description Default
result dict[str, Any]

Result dict containing metrics from stage

required
stage_type str

Type of the stage (e.g., 'llm', 'diffusion')

required
stage_id int

Stage identifier

required
req_id str

Request identifier

required
engine_outputs Any

Engine output object

required
finished bool

Whether stage processing is finished

required
final_output_type str | None

Type of final output (e.g., 'text', 'audio')

required
output_to_yield Any | None

Output object to attach metrics to

required

record_audio_generated_frames

record_audio_generated_frames(
    output_to_yield: Any, stage_id: int, request_id: str
) -> None

record_stage_postprocess_time

record_stage_postprocess_time(
    stage_id: int, req_id: Any, postproc_time_ms: float
) -> None

record_transfer_rx

record_transfer_rx(
    stats: StageRequestStats,
) -> TransferEdgeStats | None

record_transfer_tx

record_transfer_tx(
    from_stage: int,
    to_stage: int,
    request_id: Any,
    size_bytes: int,
    tx_time_ms: float,
    used_shm: bool,
) -> TransferEdgeStats | None

stage_event_cursor

stage_event_cursor(req_id: str) -> int

stage_postprocess_timer

stage_postprocess_timer(stage_id: int, req_id: Any)

Context manager for measuring and recording stage postprocessing time.

Usage

with metrics.stage_postprocess_timer(stage_id, request_id): next_inputs = next_stage.process_engine_inputs(...)

StageRequestStats dataclass

audio_duration_s class-attribute instance-attribute

audio_duration_s: float = 0.0

audio_generated_frames class-attribute instance-attribute

audio_generated_frames: int = 0

audio_sample_rate class-attribute instance-attribute

audio_sample_rate: int = 0

batch_id instance-attribute

batch_id: int

batch_size instance-attribute

batch_size: int

denoise_step_latency_ms class-attribute instance-attribute

denoise_step_latency_ms: float = 0.0

diffusion_metrics class-attribute instance-attribute

diffusion_metrics: dict[str, float] | None = None

final_output_type class-attribute instance-attribute

final_output_type: str | None = None

finish_reason class-attribute instance-attribute

finish_reason: str | None = None

image_pixels class-attribute instance-attribute

image_pixels: int = 0

image_time_to_first_output_ms class-attribute instance-attribute

image_time_to_first_output_ms: float = 0.0

inter_output_latencies_ms class-attribute instance-attribute

inter_output_latencies_ms: list[float] | None = None

inter_output_latency_ms class-attribute instance-attribute

inter_output_latency_ms: float = 0.0

num_inference_steps class-attribute instance-attribute

num_inference_steps: int = 0

num_tokens_in instance-attribute

num_tokens_in: int

num_tokens_out instance-attribute

num_tokens_out: int

output_unit_count class-attribute instance-attribute

output_unit_count: int = 0

output_unit_type class-attribute instance-attribute

output_unit_type: str | None = None

pipeline_timings class-attribute instance-attribute

pipeline_timings: dict[str, float] | None = None

postprocess_time_ms class-attribute instance-attribute

postprocess_time_ms: float = 0.0

replica_id class-attribute instance-attribute

replica_id: int | None = None

request_id class-attribute instance-attribute

request_id: str | None = None

rx_decode_time_ms instance-attribute

rx_decode_time_ms: float

rx_in_flight_time_ms instance-attribute

rx_in_flight_time_ms: float

rx_mbps property

rx_mbps: float

rx_transfer_bytes instance-attribute

rx_transfer_bytes: int

serving_time_to_first_output_ms class-attribute instance-attribute

serving_time_to_first_output_ms: float = 0.0

stage_gen_time_ms instance-attribute

stage_gen_time_ms: float

stage_id class-attribute instance-attribute

stage_id: int | None = None

stage_stats instance-attribute

stage_stats: StageStats

time_per_output_unit_ms class-attribute instance-attribute

time_per_output_unit_ms: float = 0.0

tokens_per_s property

tokens_per_s: float

vllm_itl_ms class-attribute instance-attribute

vllm_itl_ms: float = 0.0

vllm_itls_ms class-attribute instance-attribute

vllm_itls_ms: list[float] | None = None

vllm_tpot_ms class-attribute instance-attribute

vllm_tpot_ms: float = 0.0

vllm_ttft_ms class-attribute instance-attribute

vllm_ttft_ms: float = 0.0

StageStats dataclass

avg_tokens_per_s property

avg_tokens_per_s: float

total_gen_time_ms class-attribute instance-attribute

total_gen_time_ms: float = 0.0

total_token class-attribute instance-attribute

total_token: int = 0

count_audio_chunk_frames

count_audio_chunk_frames(audio_chunk: object) -> int

Count frames (samples) in one audio tensor / chunk.

Audio chunks are concatenated on dim=-1 in the output processor, so the frame/sample axis is the last dim (e.g. [channels, frames]). Keep this aligned with serving_chat.py: audio tensors are consumed as (T,), (C, T), or (B, C, T). Flattening would corrupt multi-channel audio.

Parameters:

Name Type Description Default
audio_chunk object

A single audio tensor/array-like, or a scalar-like value.

required

Returns:

Type Description
int

Frame count for this chunk. Uses shape[-1] when shaped; otherwise

int

len(...); scalars / unlenable values count as 1.

count_audio_frames

count_audio_frames(mm_out: Mapping[str, Any]) -> int

Sum frame counts over all audio chunks in mm_out["audio"] or with other related keys.

For multi-dim tensors (e.g. shape [channels, samples]) the last axis is the sample dim; for 1-D tensors the only axis is the sample dim; scalars count as 1. Missing or empty audio yields 0.

Parameters:

Name Type Description Default
mm_out Mapping[str, Any]

A multimodal_output Mapping (plain dict or MultimodalPayload) that may contain an audio or related key whose value is one chunk or a list of chunks.

required

Returns:

Type Description
int

Total audio frames (samples) across all chunks.

count_image_pixels

count_image_pixels(value: object) -> int

Count pixels in one image value, or sum over a nested list/tuple.

Accepts PIL-like objects (size=(W, H)), tensors / arrays with a shape attribute, and nested list / tuple containers.

Shape heuristics (aligned with StagePool image metrics):

  • ndim >= 4 (e.g. BCHW): B * H * W via dims[0] * dims[-2] * dims[-1]
  • ndim == 3 and dims[0] in (1, 3, 4): CHW → H * W
  • ndim == 3 and dims[-1] in (1, 3, 4): HWC → H * W
  • otherwise: dims[-2] * dims[-1]

Returns 0 when value is missing or cannot be interpreted.

count_tokens_from_outputs

count_tokens_from_outputs(engine_outputs: list[Any]) -> int

count_video_frames

count_video_frames(video: object) -> int | None

Return the frame count for common nested and tensor video layouts.