Tiny add --log-requests-target (#16338)

python/sglang/srt/managers/tokenizer_manager.py

@@ -370,6 +370,7 @@ class TokenizerManager(TokenizerCommunicatorMixin, TokenizerManagerMultiItemMixi
             log_requests=self.server_args.log_requests,
             log_requests_level=self.server_args.log_requests_level,
             log_requests_format=self.server_args.log_requests_format,
+            log_requests_target=self.server_args.log_requests_target,
         )
 
         # Dumping

python/sglang/srt/server_args.py

@@ -339,6 +339,7 @@ class ServerArgs:
     log_requests: bool = False
     log_requests_level: int = 2
     log_requests_format: str = "text"
+    log_requests_target: Optional[List[str]] = None
     crash_dump_folder: Optional[str] = None
     show_time_cost: bool = False
     enable_metrics: bool = False
@@ -3013,6 +3014,14 @@ class ServerArgs:
             choices=["text", "json"],
             help="Format for request logging: 'text' (human-readable) or 'json' (structured)",
         )
+        parser.add_argument(
+            "--log-requests-target",
+            type=str,
+            nargs="+",
+            default=ServerArgs.log_requests_target,
+            help="Target(s) for request logging: 'stdout' and/or directory path(s) for file output. "
+            "Can specify multiple targets, e.g., '--log-requests-target stdout /my/path'. ",
+        )
         parser.add_argument(
             "--crash-dump-folder",
             type=str,

python/sglang/srt/utils/request_logger.py

@@ -16,9 +16,14 @@ from __future__ import annotations
 import dataclasses
 import json
 import logging
+import os
+import socket
 from datetime import datetime
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Optional, Set, Tuple, Union
+from logging.handlers import TimedRotatingFileHandler
+from typing import TYPE_CHECKING, Any, List, Optional, Set, Tuple, Union
+
+import torch.distributed as dist
 
 from sglang.srt.environ import envs
 from sglang.srt.utils.common import get_bool_env_var
@@ -28,12 +33,6 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-_json_logger = logging.getLogger(__name__ + ".json")
-_json_logger.propagate = False
-_json_handler = logging.StreamHandler()
-_json_handler.setFormatter(logging.Formatter("%(message)s"))
-_json_logger.addHandler(_json_handler)
-
 
 class RequestLogger:
     def __init__(
@@ -41,20 +40,31 @@ class RequestLogger:
         log_requests: bool,
         log_requests_level: int,
         log_requests_format: str,
+        log_requests_target: Optional[List[str]],
     ):
         self.log_requests = log_requests
         self.log_requests_level = log_requests_level
         self.log_requests_format = log_requests_format
+        self.log_requests_target = log_requests_target
+
         self.metadata: Tuple[Optional[int], Optional[Set[str]], Optional[Set[str]]] = (
             self._compute_metadata()
         )
+        self.targets = self._setup_targets()
+
         self.log_exceeded_ms = envs.SGLANG_LOG_REQUEST_EXCEEDED_MS.get()
 
+    def _setup_targets(self) -> List[logging.Logger]:
+        if not self.log_requests_target:
+            return [_create_log_target_stdout()]
+        return [_create_log_target(t) for t in self.log_requests_target]
+
     def configure(
         self,
         log_requests: Optional[bool] = None,
         log_requests_level: Optional[int] = None,
         log_requests_format: Optional[str] = None,
+        log_requests_target: Optional[List[str]] = None,
     ) -> None:
         if log_requests is not None:
             self.log_requests = log_requests
@@ -62,7 +72,11 @@ class RequestLogger:
             self.log_requests_level = log_requests_level
         if log_requests_format is not None:
             self.log_requests_format = log_requests_format
+        if log_requests_target is not None:
+            self.log_requests_target = log_requests_target
+
         self.metadata = self._compute_metadata()
+        self.targets = self._setup_targets()
 
     def log_received_request(
         self, obj: Union["GenerateReqInput", "EmbeddingReqInput"], tokenizer: Any = None
@@ -76,9 +90,9 @@ class RequestLogger:
                 "rid": obj.rid,
                 "obj": _transform_data_for_logging(obj, max_length, skip_names),
             }
-            _log_json("request.received", log_data)
+            self._log_json("request.received", log_data)
         else:
-            logger.info(
+            self._log(
                 f"Receive: obj={_dataclass_to_string_truncated(obj, max_length, skip_names=skip_names)}"
             )
 
@@ -116,13 +130,13 @@ class RequestLogger:
                 log_data["out"] = _transform_data_for_logging(
                     out, max_length, out_skip_names
                 )
-            _log_json("request.finished", log_data)
+            self._log_json("request.finished", log_data)
         else:
             if is_multimodal_gen:
                 msg = f"Finish: obj={_dataclass_to_string_truncated(obj, max_length, skip_names=skip_names)}"
             else:
                 msg = f"Finish: obj={_dataclass_to_string_truncated(obj, max_length, skip_names=skip_names)}, out={_dataclass_to_string_truncated(out, max_length, skip_names=out_skip_names)}"
-            logger.info(msg)
+            self._log(msg)
 
     def _compute_metadata(
         self,
@@ -164,6 +178,18 @@ class RequestLogger:
                 )
         return max_length, skip_names, out_skip_names
 
+    def _log_json(self, event: str, data: dict) -> None:
+        log_data = {
+            "timestamp": datetime.now().isoformat(),
+            "event": event,
+            **data,
+        }
+        self._log(json.dumps(log_data, ensure_ascii=False))
+
+    def _log(self, msg: str) -> None:
+        for target in self.targets:
+            target.info(msg)
+
 
 # TODO remove this?
 @lru_cache(maxsize=2)
@@ -171,14 +197,37 @@ def disable_request_logging() -> bool:
     return get_bool_env_var("SGLANG_DISABLE_REQUEST_LOGGING")
 
 
-# TODO unify logging, e.g. allow normal logs to be JSON as well
-def _log_json(event: str, data: dict) -> None:
-    log_data = {
-        "timestamp": datetime.now().isoformat(),
-        "event": event,
-        **data,
-    }
-    _json_logger.info(json.dumps(log_data, ensure_ascii=False))
+def _create_log_target(target: str) -> logging.Logger:
+    if target.lower() == "stdout":
+        return _create_log_target_stdout()
+    return _create_log_target_file(target)
+
+
+def _create_log_target_stdout() -> logging.Logger:
+    return _create_logger_with_handler(f"{__name__}.stdout", logging.StreamHandler())
+
+
+def _create_log_target_file(directory: str) -> logging.Logger:
+    os.makedirs(directory, exist_ok=True)
+    hostname = socket.gethostname()
+    rank = dist.get_rank() if dist.is_initialized() else 0
+    filename = os.path.join(directory, f"{hostname}_{rank}.log")
+    handler = TimedRotatingFileHandler(
+        filename, when="H", backupCount=0, encoding="utf-8"
+    )
+    return _create_logger_with_handler(
+        f"{__name__}.file.{directory}.{hostname}_{rank}", handler
+    )
+
+
+def _create_logger_with_handler(name: str, handler: logging.Handler) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    if not logger.handlers:
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        logger.addHandler(handler)
+    return logger
 
 
 # TODO unify this w/ `_transform_data_for_logging` if we find performance enough