feat: wrap log configs in LogConfig, add log rotation, fix empty file creation (#261)

- Create new LogConfig class to wrap all log-related configuration
- Update OpenVikingConfig to use nested log config instead of separate fields
- Add log rotation support with TimedRotatingFileHandler in logger.py
- Add configure_uvicorn_logging to make uvicorn use OpenViking's logging config
- Fix empty file being created in current directory by properly handling log.output=file in logging_init.py
- Update examples/ov.conf.example to use new nested log config structure
- Update __init__.py to export LogConfig and initialize_openviking_config

Co-authored-by: openviking <openviking@example.com>

Author: MaojiaSheng

examples/ov.conf.example

@@ -67,9 +67,14 @@
   "default_search_limit": 3,
   "enable_memory_decay": true,
   "memory_decay_check_interval": 3600,
-  "log_level": "INFO",
-  "log_format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-  "log_output": "stdout",
+  "log": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "output": "stdout",
+    "rotation": true,
+    "rotation_days": 3,
+    "rotation_interval": "midnight"
+  },
   "parsers": {
     "pdf": {
       "strategy": "auto",

openviking/server/bootstrap.py

@@ -9,6 +9,7 @@
 
 from openviking.server.app import create_app
 from openviking.server.config import load_server_config
+from openviking_cli.utils.logger import configure_uvicorn_logging
 
 
 def main():
@@ -52,9 +53,12 @@ def main():
     if args.port is not None:
         config.port = args.port
 
+    # Configure logging for Uvicorn
+    configure_uvicorn_logging()
+
     # Create and run app
     app = create_app(config)
-    uvicorn.run(app, host=config.host, port=config.port)
+    uvicorn.run(app, host=config.host, port=config.port, log_config=None)
 
 
 if __name__ == "__main__":

openviking/storage/vectordb/utils/logging_init.py

@@ -55,12 +55,21 @@ def init_cpp_logging():
 
             config = get_openviking_config()
 
-            log_level = config.log_level.upper() if config.log_level else "INFO"
-            log_output = config.log_output if config.log_output else "stdout"
+            log_level = config.log.level.upper() if config.log.level else "INFO"
+            log_output = config.log.output if config.log.output else "stdout"
+
+            # If log_output is "file", convert it to the actual file path
+            if log_output == "file":
+                from pathlib import Path
+
+                workspace_path = Path(config.storage.workspace).resolve()
+                log_dir = workspace_path / "log"
+                log_dir.mkdir(parents=True, exist_ok=True)
+                log_output = str(log_dir / "openviking.log")
 
             py_log_format = (
-                config.log_format
-                if config.log_format
+                config.log.format
+                if config.log.format
                 else "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
             )
             spd_log_format = _convert_python_format_to_spdlog(py_log_format)

openviking_cli/utils/config/__init__.py

@@ -12,10 +12,12 @@
     resolve_config_path,
 )
 from .embedding_config import EmbeddingConfig
+from .log_config import LogConfig
 from .open_viking_config import (
     OpenVikingConfig,
     OpenVikingConfigSingleton,
     get_openviking_config,
+    initialize_openviking_config,
     is_valid_openviking_config,
     set_openviking_config,
 )
@@ -44,6 +46,7 @@
     "DEFAULT_OV_CONF",
     "DEFAULT_OVCLI_CONF",
     "EmbeddingConfig",
+    "LogConfig",
     "OPENVIKING_CLI_CONFIG_ENV",
     "OPENVIKING_CONFIG_ENV",
     "OpenVikingConfig",
@@ -65,6 +68,7 @@
     "load_parser_configs_from_dict",
     "PARSER_CONFIG_REGISTRY",
     "get_openviking_config",
+    "initialize_openviking_config",
     "load_json_config",
     "require_config",
     "resolve_config_path",

openviking_cli/utils/config/log_config.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Dict
+
+from pydantic import BaseModel, Field
+
+
+class LogConfig(BaseModel):
+    """Logging configuration for OpenViking."""
+
+    level: str = Field(
+        default="WARNING", description="Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL"
+    )
+
+    format: str = Field(
+        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        description="Log format string",
+    )
+
+    output: str = Field(default="stdout", description="Log output: stdout, stderr, or file path")
+
+    rotation: bool = Field(default=True, description="Enable log file rotation")
+
+    rotation_days: int = Field(default=3, description="Number of days to retain rotated log files")
+
+    rotation_interval: str = Field(
+        default="midnight",
+        description="Log rotation interval: 'midnight', 'H' (hourly), 'D' (daily), 'W0'-'W6' (weekly)",
+    )
+
+    @classmethod
+    def from_dict(cls, config: Dict[str, Any]) -> "LogConfig":
+        """Create configuration from dictionary."""
+        return cls(**config)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary."""
+        return self.model_dump()

openviking_cli/utils/config/open_viking_config.py

@@ -15,6 +15,7 @@
     resolve_config_path,
 )
 from .embedding_config import EmbeddingConfig
+from .log_config import LogConfig
 from .parser_config import (
     AudioConfig,
     CodeConfig,
@@ -115,18 +116,7 @@ class OpenVikingConfig(BaseModel):
         ),
     )
 
-    log_level: str = Field(
-        default="WARNING", description="Logging level: DEBUG, INFO, WARNING, ERROR, CRITICAL"
-    )
-
-    log_format: str = Field(
-        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        description="Log format string",
-    )
-
-    log_output: str = Field(
-        default="stdout", description="Log output: stdout, stderr, or file path"
-    )
+    log: LogConfig = Field(default_factory=lambda: LogConfig(), description="Logging configuration")
 
     model_config = {"arbitrary_types_allowed": True, "extra": "forbid"}
 
@@ -143,14 +133,19 @@ def from_dict(cls, config: Dict[str, Any]) -> "OpenVikingConfig":
         parser_configs = {}
         if "parsers" in config_copy:
             parser_configs = config_copy.pop("parsers")
-
-        # Also check for individual parser configs at root level
         parser_types = ["pdf", "code", "image", "audio", "video", "markdown", "html", "text"]
         for parser_type in parser_types:
             if parser_type in config_copy:
                 parser_configs[parser_type] = config_copy.pop(parser_type)
+        # Handle log configuration from nested "log" section
+        log_config_data = None
+        if "log" in config_copy:
+            log_config_data = config_copy.pop("log")
 
         instance = cls(**config_copy)
+        # Apply log configuration
+        if log_config_data is not None:
+            instance.log = LogConfig.from_dict(log_config_data)
 
         # Apply parser configurations
         for parser_type, parser_data in parser_configs.items():

openviking_cli/utils/logger.py

@@ -6,59 +6,116 @@
 
 import logging
 import sys
-from typing import Optional
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+from typing import Any, Optional, Tuple
+
+
+def _load_log_config() -> Tuple[str, str, str, Optional[Any]]:
+    config = None
+    try:
+        from openviking_cli.utils.config import get_openviking_config
+
+        config = get_openviking_config()
+        log_level_str = config.log.level.upper()
+        log_format = config.log.format
+        log_output = config.log.output
+
+        if log_output == "file":
+            workspace_path = Path(config.storage.workspace).resolve()
+            log_dir = workspace_path / "log"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            log_output = str(log_dir / "openviking.log")
+    except Exception:
+        log_level_str = "INFO"
+        log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        log_output = "stdout"
+
+    return log_level_str, log_format, log_output, config
+
+
+def _create_log_handler(log_output: str, config: Optional[Any]) -> logging.Handler:
+    # Prevent creating a file literally named "file"
+    if log_output == "file":
+        log_output = "stdout"
+
+    if log_output == "stdout":
+        return logging.StreamHandler(sys.stdout)
+    elif log_output == "stderr":
+        return logging.StreamHandler(sys.stderr)
+    else:
+        if config is not None:
+            try:
+                log_rotation = config.log.rotation
+                if log_rotation:
+                    log_rotation_days = config.log.rotation_days
+                    log_rotation_interval = config.log.rotation_interval
+
+                    if log_rotation_interval == "midnight":
+                        when = "midnight"
+                        interval = 1
+                    else:
+                        when = log_rotation_interval
+                        interval = 1
+
+                    return TimedRotatingFileHandler(
+                        log_output,
+                        when=when,
+                        interval=interval,
+                        backupCount=log_rotation_days,
+                        encoding="utf-8",
+                    )
+                else:
+                    return logging.FileHandler(log_output, encoding="utf-8")
+            except Exception:
+                return logging.FileHandler(log_output, encoding="utf-8")
+        else:
+            return logging.FileHandler(log_output, encoding="utf-8")
 
 
 def get_logger(
     name: str = "openviking",
     format_string: Optional[str] = None,
 ) -> logging.Logger:
-    """
-    Get a configured logger.
-
-    Args:
-        name: Logger name
-        format_string: Custom format string (overrides config)
-
-    Returns:
-        Configured logger
-    """
     logger = logging.getLogger(name)
 
     if not logger.handlers:
-        try:
-            from openviking_cli.utils.config import get_openviking_config
-
-            config = get_openviking_config()
-            log_level_str = config.log_level.upper()
-            log_format = config.log_format
-            log_output = config.log_output
-        except Exception:
-            log_level_str = "INFO"
-            log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            log_output = "stdout"
-
+        log_level_str, log_format, log_output, config = _load_log_config()
         level = getattr(logging, log_level_str, logging.INFO)
-
-        if log_output == "stdout":
-            handler = logging.StreamHandler(sys.stdout)
-        elif log_output == "stderr":
-            handler = logging.StreamHandler(sys.stderr)
-        else:
-            handler = logging.FileHandler(log_output)
+        handler = _create_log_handler(log_output, config)
 
         if format_string is None:
             format_string = log_format
-
         formatter = logging.Formatter(format_string)
         handler.setFormatter(formatter)
         logger.addHandler(handler)
         logger.propagate = False
-
         logger.setLevel(level)
 
     return logger
 
 
 # Default logger instance
 default_logger = get_logger()
+
+
+def configure_uvicorn_logging() -> None:
+    """Configure Uvicorn loggers to use OpenViking's logging configuration.
+
+    This function configures the 'uvicorn', 'uvicorn.error', and 'uvicorn.access'
+    loggers to use the same handlers and format as our openviking loggers.
+    """
+    log_level_str, log_format, log_output, config = _load_log_config()
+    level = getattr(logging, log_level_str, logging.INFO)
+    handler = _create_log_handler(log_output, config)
+    formatter = logging.Formatter(log_format)
+    handler.setFormatter(formatter)
+
+    # Configure all Uvicorn loggers
+    uvicorn_logger_names = ["uvicorn", "uvicorn.error", "uvicorn.access"]
+    for logger_name in uvicorn_logger_names:
+        logger = logging.getLogger(logger_name)
+        logger.handlers.clear()
+        logger.addHandler(handler)
+        logger.setLevel(level)
+        logger.propagate = False