Skip to content

vllm.logger

Logging configuration for vLLM.

Functions:

_VllmLogger

Bases: Logger

Note

This class is just to provide type information. We actually patch the methods directly on the logging.Logger instance to avoid conflicting with other libraries such as intel_extension_for_pytorch.utils._logger.

Methods:

Source code in vllm/logger.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
class _VllmLogger(Logger):
    """
    Note:
        This class is just to provide type information.
        We actually patch the methods directly on the [`logging.Logger`][]
        instance to avoid conflicting with other libraries such as
        `intel_extension_for_pytorch.utils._logger`.
    """

    def debug_once(self, msg: str, *args: Hashable, scope: LogScope = "local") -> None:
        """
        As [`debug`][logging.Logger.debug], but subsequent calls with
        the same message are silently dropped.
        """
        if not _should_log_with_scope(scope):
            return
        _print_debug_once(self, msg, *args)

    def info_once(self, msg: str, *args: Hashable, scope: LogScope = "local") -> None:
        """
        As [`info`][logging.Logger.info], but subsequent calls with
        the same message are silently dropped.
        """
        if not _should_log_with_scope(scope):
            return
        _print_info_once(self, msg, *args)

    def warning_once(
        self, msg: str, *args: Hashable, scope: LogScope = "local"
    ) -> None:
        """
        As [`warning`][logging.Logger.warning], but subsequent calls with
        the same message are silently dropped.
        """
        if not _should_log_with_scope(scope):
            return
        _print_warning_once(self, msg, *args)

debug_once(msg, *args, scope='local')

As debug, but subsequent calls with the same message are silently dropped.

Source code in vllm/logger.py 
118
119
120
121
122
123
124
125
def debug_once(self, msg: str, *args: Hashable, scope: LogScope = "local") -> None:
    """
    As [`debug`][logging.Logger.debug], but subsequent calls with
    the same message are silently dropped.
    """
    if not _should_log_with_scope(scope):
        return
    _print_debug_once(self, msg, *args)

info_once(msg, *args, scope='local')

As info, but subsequent calls with the same message are silently dropped.

Source code in vllm/logger.py 
127
128
129
130
131
132
133
134
def info_once(self, msg: str, *args: Hashable, scope: LogScope = "local") -> None:
    """
    As [`info`][logging.Logger.info], but subsequent calls with
    the same message are silently dropped.
    """
    if not _should_log_with_scope(scope):
        return
    _print_info_once(self, msg, *args)

warning_once(msg, *args, scope='local')

As warning, but subsequent calls with the same message are silently dropped.

Source code in vllm/logger.py 
136
137
138
139
140
141
142
143
144
145
def warning_once(
    self, msg: str, *args: Hashable, scope: LogScope = "local"
) -> None:
    """
    As [`warning`][logging.Logger.warning], but subsequent calls with
    the same message are silently dropped.
    """
    if not _should_log_with_scope(scope):
        return
    _print_warning_once(self, msg, *args)

_should_log_with_scope(scope)

Decide whether to log based on scope

Source code in vllm/logger.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
def _should_log_with_scope(scope: LogScope) -> bool:
    """Decide whether to log based on scope"""
    if scope == "global":
        from vllm.distributed.parallel_state import is_global_first_rank

        return is_global_first_rank()
    if scope == "local":
        from vllm.distributed.parallel_state import is_local_first_rank

        return is_local_first_rank()
    return True

enable_trace_function_call(log_file_path, root_dir=None)

Enable tracing of every function call in code under root_dir. This is useful for debugging hangs or crashes. log_file_path is the path to the log file. root_dir is the root directory of the code to trace. If None, it is the vllm root directory.

Note that this call is thread-level, any threads calling this function will have the trace enabled. Other threads will not be affected.

Source code in vllm/logger.py 
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
def enable_trace_function_call(log_file_path: str, root_dir: str | None = None):
    """
    Enable tracing of every function call in code under `root_dir`.
    This is useful for debugging hangs or crashes.
    `log_file_path` is the path to the log file.
    `root_dir` is the root directory of the code to trace. If None, it is the
    vllm root directory.

    Note that this call is thread-level, any threads calling this function
    will have the trace enabled. Other threads will not be affected.
    """
    logger.warning(
        "VLLM_TRACE_FUNCTION is enabled. It will record every"
        " function executed by Python. This will slow down the code. It "
        "is suggested to be used for debugging hang or crashes only."
    )
    logger.info("Trace frame log is saved to %s", log_file_path)
    if root_dir is None:
        # by default, this is the vllm root directory
        root_dir = os.path.dirname(os.path.dirname(__file__))
    sys.settrace(partial(_trace_calls, log_file_path, root_dir))

init_logger(name)

The main purpose of this function is to ensure that loggers are retrieved in such a way that we can be sure the root vllm logger has already been configured.

Source code in vllm/logger.py 
204
205
206
207
208
209
210
211
212
213
214
def init_logger(name: str) -> _VllmLogger:
    """The main purpose of this function is to ensure that loggers are
    retrieved in such a way that we can be sure the root vllm logger has
    already been configured."""

    logger = logging.getLogger(name)

    for method_name, method in _METHODS_TO_PATCH.items():
        setattr(logger, method_name, MethodType(method, logger))

    return cast(_VllmLogger, logger)