servly 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

servly/cli.py

@@ -1,52 +1,40 @@
 #!/usr/bin/env python3
 """
 Command-line interface for Servly process manager.
+使用Rich库进行终端输出格式化
 """
 import os
 import sys
 import argparse
 import logging
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Dict, Optional
 
 from servly.service import ServiceManager
-from servly.logs import LogManager
-from servly.logs import Colors, Emojis  # 导入颜色和表情符号定义
-from servly.logs import align_colored_text  # 导入对齐工具函数
+from servly.logs import LogManager, Emojis
+from servly.logs import console, print_header, print_info, print_warning, print_error, print_success, print_service_table
 
-# 配置彩色日志记录器
-class ColoredFormatter(logging.Formatter):
-    """添加颜色支持的日志格式化器"""
-    
-    def format(self, record):
-        log_message = super().format(record)
-        
-        if record.levelno >= logging.ERROR:
-            return f"{Emojis.ERROR} {Colors.BRIGHT_RED}{log_message}{Colors.RESET}"
-        elif record.levelno >= logging.WARNING:
-            return f"{Emojis.WARNING} {Colors.YELLOW}{log_message}{Colors.RESET}"
-        elif record.levelno >= logging.INFO:
-            return f"{Emojis.INFO} {Colors.GREEN}{log_message}{Colors.RESET}"
-        else:
-            return f"{Colors.BRIGHT_BLACK}{log_message}{Colors.RESET}"
+from rich.logging import RichHandler
+from rich.traceback import install
+from rich.markup import escape
 
-# 配置日志
-handler = logging.StreamHandler()
-handler.setFormatter(ColoredFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
-logger = logging.getLogger('servly')
-logger.setLevel(logging.INFO)
-logger.addHandler(handler)
+# 安装Rich的异常格式化器
+install()
 
-def print_header():
-    """打印美化的 Servly 头部"""
-    print(f"\n{Colors.CYAN}{Colors.BOLD}{'=' * 50}")
-    print(f"{Emojis.SERVICE} SERVLY {Colors.BRIGHT_BLACK}- Modern Process Manager")
-    print(f"{Colors.CYAN}{'=' * 50}{Colors.RESET}\n")
+# 配置Rich日志处理
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True, markup=True)]
+)
+
+logger = logging.getLogger("servly")
 
 def setup_arg_parser() -> argparse.ArgumentParser:
     """设置命令行参数解析器"""
     parser = argparse.ArgumentParser(
-        description=f"{Colors.CYAN}{Colors.BOLD}{Emojis.SERVICE} Servly - Modern process manager{Colors.RESET}",
+        description=f"{Emojis.SERVICE} Servly - Modern process manager",
         formatter_class=argparse.RawDescriptionHelpFormatter
     )
     
@@ -91,30 +79,30 @@ def handle_start(manager: ServiceManager, service_name: str) -> bool:
     if service_name == 'all':
         service_names = manager.get_service_names()
         if not service_names:
-            print(f"{Emojis.WARNING} {Colors.YELLOW}配置中没有定义任何服务。{Colors.RESET}")
+            print_warning("配置中没有定义任何服务。")
             return False
         
-        print(f"{Emojis.START} {Colors.BRIGHT_GREEN}正在启动所有服务...{Colors.RESET}")
+        console.print(f"{Emojis.START} 正在启动所有服务...", style="running")
         success = True
         for name in service_names:
             if not manager.start(name):
-                print(f"{Emojis.ERROR} {Colors.RED}启动服务 '{name}' 失败{Colors.RESET}")
+                print_error(f"启动服务 '{name}' 失败")
                 success = False
             else:
-                print(f"{Emojis.RUNNING} {Colors.GREEN}服务 '{name}' 已成功启动{Colors.RESET}")
+                print_success(f"服务 '{name}' 已成功启动")
         
         if success:
-            print(f"\n{Emojis.RUNNING} {Colors.BRIGHT_GREEN}所有服务已成功启动！{Colors.RESET}")
+            print_success("所有服务已成功启动！")
         else:
-            print(f"\n{Emojis.WARNING} {Colors.YELLOW}有些服务启动失败，请检查日志获取详情。{Colors.RESET}")
+            print_warning("有些服务启动失败，请检查日志获取详情。")
         
         return success
     else:
         result = manager.start(service_name)
         if result:
-            print(f"{Emojis.RUNNING} {Colors.GREEN}服务 '{service_name}' 已成功启动{Colors.RESET}")
+            print_success(f"服务 '{service_name}' 已成功启动")
         else:
-            print(f"{Emojis.ERROR} {Colors.RED}启动服务 '{service_name}' 失败{Colors.RESET}")
+            print_error(f"启动服务 '{service_name}' 失败")
         return result
 
 def handle_stop(manager: ServiceManager, service_name: str) -> bool:
@@ -122,30 +110,30 @@ def handle_stop(manager: ServiceManager, service_name: str) -> bool:
     if service_name == 'all':
         service_names = manager.get_running_services()
         if not service_names:
-            print(f"{Emojis.INFO} {Colors.BRIGHT_BLACK}当前没有正在运行的服务。{Colors.RESET}")
+            console.print(f"{Emojis.INFO} 当前没有正在运行的服务。", style="dim")
             return True
         
-        print(f"{Emojis.STOP} {Colors.YELLOW}正在停止所有服务...{Colors.RESET}")
+        console.print(f"{Emojis.STOP} 正在停止所有服务...", style="warning")
         success = True
         for name in service_names:
             if not manager.stop(name):
-                print(f"{Emojis.ERROR} {Colors.RED}停止服务 '{name}' 失败{Colors.RESET}")
+                print_error(f"停止服务 '{name}' 失败")
                 success = False
             else:
-                print(f"{Emojis.STOPPED} {Colors.YELLOW}服务 '{name}' 已停止{Colors.RESET}")
+                console.print(f"{Emojis.STOPPED} 服务 '{name}' 已停止", style="stopped")
         
         if success:
-            print(f"\n{Emojis.STOPPED} {Colors.YELLOW}所有服务已成功停止！{Colors.RESET}")
+            console.print(f"\n{Emojis.STOPPED} 所有服务已成功停止！", style="warning")
         else:
-            print(f"\n{Emojis.WARNING} {Colors.YELLOW}有些服务停止失败，请检查日志获取详情。{Colors.RESET}")
+            print_warning("有些服务停止失败，请检查日志获取详情。")
         
         return success
     else:
         result = manager.stop(service_name)
         if result:
-            print(f"{Emojis.STOPPED} {Colors.YELLOW}服务 '{service_name}' 已成功停止{Colors.RESET}")
+            console.print(f"{Emojis.STOPPED} 服务 '{service_name}' 已成功停止", style="warning")
         else:
-            print(f"{Emojis.ERROR} {Colors.RED}停止服务 '{service_name}' 失败{Colors.RESET}")
+            print_error(f"停止服务 '{service_name}' 失败")
         return result
 
 def handle_restart(manager: ServiceManager, service_name: str) -> bool:
@@ -153,30 +141,30 @@ def handle_restart(manager: ServiceManager, service_name: str) -> bool:
     if service_name == 'all':
         service_names = manager.get_service_names()
         if not service_names:
-            print(f"{Emojis.WARNING} {Colors.YELLOW}配置中没有定义任何服务。{Colors.RESET}")
+            print_warning("配置中没有定义任何服务。")
             return False
         
-        print(f"{Emojis.RESTART} {Colors.MAGENTA}正在重启所有服务...{Colors.RESET}")
+        console.print(f"{Emojis.RESTART} 正在重启所有服务...", style="restart")
         success = True
         for name in service_names:
             if not manager.restart(name):
-                print(f"{Emojis.ERROR} {Colors.RED}重启服务 '{name}' 失败{Colors.RESET}")
+                print_error(f"重启服务 '{name}' 失败")
                 success = False
             else:
-                print(f"{Emojis.RUNNING} {Colors.MAGENTA}服务 '{name}' 已成功重启{Colors.RESET}")
+                console.print(f"{Emojis.RUNNING} 服务 '{name}' 已成功重启", style="restart")
         
         if success:
-            print(f"\n{Emojis.RUNNING} {Colors.BRIGHT_GREEN}所有服务已成功重启！{Colors.RESET}")
+            print_success("所有服务已成功重启！")
         else:
-            print(f"\n{Emojis.WARNING} {Colors.YELLOW}有些服务重启失败，请检查日志获取详情。{Colors.RESET}")
+            print_warning("有些服务重启失败，请检查日志获取详情。")
         
         return success
     else:
         result = manager.restart(service_name)
         if result:
-            print(f"{Emojis.RUNNING} {Colors.MAGENTA}服务 '{service_name}' 已成功重启{Colors.RESET}")
+            console.print(f"{Emojis.RUNNING} 服务 '{service_name}' 已成功重启", style="restart")
         else:
-            print(f"{Emojis.ERROR} {Colors.RED}重启服务 '{service_name}' 失败{Colors.RESET}")
+            print_error(f"重启服务 '{service_name}' 失败")
         return result
 
 def handle_log(manager: ServiceManager, log_manager: LogManager, args) -> bool:
@@ -188,15 +176,15 @@ def handle_log(manager: ServiceManager, log_manager: LogManager, args) -> bool:
     if service_name == 'all':
         services = manager.get_service_names()
         if not services:
-            print(f"{Emojis.WARNING} {Colors.YELLOW}配置中没有定义任何服务。{Colors.RESET}")
+            print_warning("配置中没有定义任何服务。")
             return False
     else:
         if service_name not in manager.get_service_names():
-            print(f"{Emojis.ERROR} {Colors.RED}服务 '{service_name}' 在配置中未找到。{Colors.RESET}")
+            print_error(f"服务 '{service_name}' 在配置中未找到。")
             return False
         services = [service_name]
     
-    # 已经在 LogManager 中添加了彩色输出
+    # 使用LogManager查看日志
     log_manager.tail_logs(services, follow=follow, lines=lines)
     return True
 
@@ -205,50 +193,53 @@ def handle_list(manager: ServiceManager) -> bool:
     service_names = manager.get_service_names()
     
     if not service_names:
-        print(f"{Emojis.WARNING} {Colors.YELLOW}配置中没有定义任何服务。{Colors.RESET}")
+        print_warning("配置中没有定义任何服务。")
         return True
     
-    # 表头
-    print(f"\n{Colors.CYAN}{Colors.BOLD}{Emojis.SERVICE} 服务列表{Colors.RESET}")
-    print(f"{Colors.CYAN}{'─' * 60}{Colors.RESET}")
-    
-    # 列标题
-    print(f"{Colors.BOLD}{align_colored_text('  名称', 25)} {align_colored_text('状态', 20)} {align_colored_text('PID', 10)}{Colors.RESET}")
-    print(f"{Colors.BRIGHT_BLACK}{'─' * 60}{Colors.RESET}")
+    print_header("服务列表")
     
-    # 服务列表
+    # 构建服务列表数据
+    services = []
     for name in service_names:
         is_running = manager.is_running(name)
-        pid = manager.get_service_pid(name) or '-'
+        pid = manager.get_service_pid(name)
         
+        # 获取服务运行时间
+        uptime_seconds = manager.get_uptime(name) if is_running else None
+        uptime = manager.format_uptime(uptime_seconds) if is_running else "-"
+        
+        # 获取 CPU 和内存使用情况
+        cpu_mem_stats = {}
         if is_running:
-            status_text = f"{Emojis.RUNNING} {Colors.GREEN}RUNNING{Colors.RESET}"
-            pid_text = f"{Colors.GREEN}{pid}{Colors.RESET}"
+            stats = manager.get_process_stats(name)
+            cpu_mem_stats["cpu"] = manager.format_cpu_percent(stats["cpu_percent"])
+            cpu_mem_stats["memory"] = manager.format_memory(stats["memory_mb"], stats["memory_percent"])
         else:
-            status_text = f"{Emojis.STOPPED} {Colors.BRIGHT_BLACK}STOPPED{Colors.RESET}"
-            pid_text = f"{Colors.BRIGHT_BLACK}{pid}{Colors.RESET}"
-        
-        # 为不同服务使用不同颜色
-        service_color = Colors.CYAN if is_running else Colors.BRIGHT_BLACK
-        service_text = f"{service_color}{name}{Colors.RESET}"
+            cpu_mem_stats["cpu"] = "0%"
+            cpu_mem_stats["memory"] = "0b"
         
-        # 使用对齐辅助函数确保正确对齐包含颜色代码的文本
-        aligned_service = align_colored_text(f"  {service_text}", 25)
-        aligned_status = align_colored_text(status_text, 20)
-        aligned_pid = align_colored_text(pid_text, 10)
-        
-        print(f"{aligned_service}{aligned_status}{aligned_pid}")
+        services.append({
+            "name": name,
+            "status": "running" if is_running else "stopped",
+            "pid": pid,
+            "uptime": uptime,
+            "cpu": cpu_mem_stats["cpu"],
+            "memory": cpu_mem_stats["memory"]
+        })
+    
+    # 使用Rich表格显示服务列表
+    print_service_table(services)
     
-    print(f"\n{Colors.BRIGHT_BLACK}配置文件: {manager.config_path}{Colors.RESET}")
-    print(f"{Colors.BRIGHT_BLACK}运行中服务: {len(manager.get_running_services())}/{len(service_names)}{Colors.RESET}")
-    print()
+    console.print(f"[dim]配置文件: {manager.config_path}[/]")
+    console.print(f"[dim]运行中服务: {len(manager.get_running_services())}/{len(service_names)}[/]")
+    console.print()
     
     return True
 
 def main():
     """CLI 应用程序入口点"""
     # 显示头部
-    print_header()
+    print_header("SERVLY - Modern Process Manager")
     
     parser = setup_arg_parser()
     args = parser.parse_args()
@@ -261,7 +252,7 @@ def main():
     try:
         service_manager = ServiceManager(config_path=args.config)
     except Exception as e:
-        print(f"{Emojis.ERROR} {Colors.RED}加载配置文件时出错: {e}{Colors.RESET}")
+        print_error(f"加载配置文件时出错: {escape(str(e))}")
         return 1
     
     # 创建日志管理器
@@ -283,10 +274,11 @@ def main():
             parser.print_help()
             return 1
     except KeyboardInterrupt:
-        print(f"\n{Emojis.STOP} {Colors.BRIGHT_BLACK}操作被用户中断{Colors.RESET}")
+        console.print(f"\n{Emojis.STOP} 操作被用户中断", style="dim")
         return 1
     except Exception as e:
-        print(f"\n{Emojis.ERROR} {Colors.RED}执行命令时出错: {e}{Colors.RESET}")
+        print_error(f"执行命令时出错: {escape(str(e))}")
+        logger.exception("命令执行异常")
         return 1
         
     return 0 if success else 1

servly/logs.py

@@ -1,56 +1,44 @@
 """
 Log management functionality for Servly.
+使用Rich库进行日志格式化和展示，实现PM2风格的日志效果。
 """
 import os
 import sys
 import time
-import select
-import fcntl
-import termios
-import subprocess
 import re
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
-import random
 
+from rich.console import Console
+from rich.theme import Theme
+from rich.text import Text
+from rich.panel import Panel
+from rich.table import Table
+from rich.live import Live
+from rich import box
 
-# ANSI 颜色代码
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    UNDERLINE = "\033[4m"
-    
-    BLACK = "\033[30m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    BLUE = "\033[34m"
-    MAGENTA = "\033[35m"
-    CYAN = "\033[36m"
-    WHITE = "\033[37m"
-    
-    BRIGHT_BLACK = "\033[90m"
-    BRIGHT_RED = "\033[91m"
-    BRIGHT_GREEN = "\033[92m"
-    BRIGHT_YELLOW = "\033[93m"
-    BRIGHT_BLUE = "\033[94m"
-    BRIGHT_MAGENTA = "\033[95m"
-    BRIGHT_CYAN = "\033[96m"
-    BRIGHT_WHITE = "\033[97m"
-    
-    # 背景色
-    BG_BLACK = "\033[40m"
-    BG_RED = "\033[41m"
-    BG_GREEN = "\033[42m"
-    BG_YELLOW = "\033[43m"
-    BG_BLUE = "\033[44m"
-    BG_MAGENTA = "\033[45m"
-    BG_CYAN = "\033[46m"
-    BG_WHITE = "\033[47m"
+# 自定义Rich主题
+custom_theme = Theme({
+    "warning": "yellow",
+    "error": "bold red",
+    "info": "green",
+    "dim": "dim",
+    "stdout_service": "green",
+    "stderr_service": "red",
+    "header": "cyan bold",
+    "subheader": "bright_black",
+    "running": "green",
+    "stopped": "bright_black",
+    "restart": "magenta",
+    "separator": "cyan",
+})
 
+# 创建Rich控制台对象
+console = Console(theme=custom_theme)
 
 # 服务相关的 emoji
 class Emojis:
+    """服务状态相关的emoji图标"""
     SERVICE = "🔧"
     START = "🟢"
     STOP = "🔴"
@@ -66,132 +54,108 @@ class Emojis:
     STOPPED = "⛔"
     LOADING = "⏳"
 
+# Rich格式化输出工具函数
+def print_header(title: str):
+    """打印美化的标题"""
+    console.print()
+    console.rule(f"[header]{Emojis.SERVICE} {title}[/]", style="separator")
+    console.print()
 
-# 处理彩色文本对齐的辅助函数
-def strip_ansi_codes(text: str) -> str:
-    """删除字符串中的所有 ANSI 转义代码"""
-    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
-    return ansi_escape.sub('', text)
+def print_info(message: str):
+    """打印信息消息"""
+    console.print(f"{Emojis.INFO} {message}", style="info")
 
-def get_visible_length(text: str) -> int:
-    """获取文本在终端中的可见长度（排除 ANSI 代码和宽字符）"""
-    text = strip_ansi_codes(text)
-    # 处理中文等宽字符（在大多数终端中占用两个字符宽度）
-    length = 0
-    for char in text:
-        if ord(char) > 127:  # 简单判断是否是非ASCII字符
-            length += 2
-        else:
-            length += 1
-    return length
+def print_warning(message: str):
+    """打印警告消息"""
+    console.print(f"{Emojis.WARNING} {message}", style="warning")
 
-def align_colored_text(text: str, width: int, align='left') -> str:
-    """
-    将彩色文本对齐到指定宽度
+def print_error(message: str):
+    """打印错误消息"""
+    console.print(f"{Emojis.ERROR} {message}", style="error")
+
+def print_success(message: str):
+    """打印成功消息"""
+    console.print(f"{Emojis.RUNNING} {message}", style="running")
+
+def print_service_table(services: List[Dict]):
+    """打印服务状态表格，PM2风格紧凑布局"""
+    table = Table(show_header=True, header_style="header", expand=True, box=box.SIMPLE)
     
-    Args:
-        text: 可能包含 ANSI 颜色代码的文本
-        width: 期望的显示宽度
-        align: 对齐方式，'left', 'right' 或 'center'
+    # PM2风格紧凑表头
+    table.add_column("name", style="cyan")
+    table.add_column("pid", justify="right")
+    table.add_column("uptime", justify="right")
+    table.add_column("cpu", justify="right")
+    table.add_column("mem", justify="right")
+    
+    for service in services:
+        name = service["name"]
+        pid = service["pid"] or "-"
+        uptime = service.get("uptime", "-")
+        cpu = service.get("cpu", "0%")
+        memory = service.get("memory", "0b")
+        
+        status_style = "running" if service["status"] == "running" else "stopped"
         
-    Returns:
-        对齐后的文本，保留颜色代码
-    """
-    visible_length = get_visible_length(text)
-    padding = max(0, width - visible_length)
+        table.add_row(
+            Text(name, style=status_style),
+            Text(str(pid), style=status_style),
+            Text(str(uptime), style=status_style),
+            Text(str(cpu), style=status_style),
+            Text(str(memory), style=status_style)
+        )
     
-    if align == 'right':
-        return ' ' * padding + text
-    elif align == 'center':
-        left_padding = padding // 2
-        right_padding = padding - left_padding
-        return ' ' * left_padding + text + ' ' * right_padding
-    else:  # left alignment
-        return text + ' ' * padding
+    console.print(table)
+    console.print()
 
 
 class LogManager:
-    """Handles viewing and managing logs for servly services."""
+    """管理和显示服务日志"""
     
     def __init__(self, log_dir: Path):
         self.log_dir = log_dir
-        # 为每个服务分配一个固定颜色，使日志更易读
-        self.service_colors = {}
-        self.available_colors = [
-            Colors.GREEN, Colors.YELLOW, Colors.BLUE, Colors.MAGENTA, Colors.CYAN,
-            Colors.BRIGHT_GREEN, Colors.BRIGHT_YELLOW, Colors.BRIGHT_BLUE, 
-            Colors.BRIGHT_MAGENTA, Colors.BRIGHT_CYAN
-        ]
+        self.default_tail_lines = 15  # 默认展示最后15行日志
         
     def get_log_files(self, service_name: str) -> Dict[str, Path]:
-        """Get the stdout and stderr log files for a service."""
+        """获取服务的stdout和stderr日志文件路径"""
         return {
             'stdout': self.log_dir / f"{service_name}-out.log",
             'stderr': self.log_dir / f"{service_name}-error.log"
         }
     
-    def _get_service_color(self, service_name: str) -> str:
-        """为服务分配一个固定的颜色"""
-        if service_name not in self.service_colors:
-            if not self.available_colors:
-                # 如果颜色用完了，就随机分配
-                self.service_colors[service_name] = random.choice([
-                    Colors.GREEN, Colors.YELLOW, Colors.BLUE, Colors.MAGENTA, Colors.CYAN
-                ])
-            else:
-                # 从可用颜色中选择一个
-                self.service_colors[service_name] = self.available_colors.pop(0)
-        return self.service_colors[service_name]
-    
-    def _format_log_header(self, service: str, log_type: str) -> str:
-        """格式化日志头部，带颜色和 emoji"""
-        service_color = self._get_service_color(service)
-        emoji = Emojis.STDOUT if log_type == 'stdout' else Emojis.STDERR
-        type_color = Colors.GREEN if log_type == 'stdout' else Colors.YELLOW
-        
-        return (f"\n{Colors.BOLD}{Colors.WHITE}{Emojis.LOG} Log Stream: "
-                f"{service_color}{service}{Colors.RESET} "
-                f"{Colors.BRIGHT_BLACK}({type_color}{emoji} {log_type}{Colors.BRIGHT_BLACK}){Colors.RESET}\n"
-                f"{Colors.BRIGHT_BLACK}{'─' * 60}{Colors.RESET}")
-    
-    def _format_log_line(self, service: str, log_type: str, line: str, show_timestamp: bool = True) -> str:
-        """格式化单行日志，带颜色和 emoji"""
-        service_color = self._get_service_color(service)
-        timestamp = time.strftime("%Y-%m-%d %H:%M:%S") if show_timestamp else ""
+    def _parse_log_line(self, line: str) -> Tuple[str, str]:
+        """解析日志行，提取时间戳和内容"""
+        timestamp = ""
+        content = line.rstrip()
         
-        # 根据日志类型选择颜色
-        line_color = Colors.RESET
-        if log_type == 'stderr' and ('error' in line.lower() or 'exception' in line.lower()):
-            prefix = f"{Emojis.ERROR} "
-            line_color = Colors.BRIGHT_RED
-        elif log_type == 'stderr':
-            prefix = f"{Emojis.WARNING} "
-            line_color = Colors.YELLOW
+        # 尝试提取时间戳
+        timestamp_match = re.search(r'(\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})', line)
+        if timestamp_match:
+            timestamp = timestamp_match.group(1)
+            # 移除行中已有的时间戳部分
+            content = line.replace(timestamp, "", 1).lstrip().rstrip()
         else:
-            prefix = f"{Emojis.INFO} "
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
         
-        # 格式化输出
-        if show_timestamp:
-            return (f"{Colors.BRIGHT_BLACK}[{Emojis.TIME} {timestamp}]{Colors.RESET} "
-                    f"{service_color}{service}{Colors.RESET} "
-                    f"{prefix}{line_color}{line.rstrip()}{Colors.RESET}")
-        else:
-            return f"{line_color}{line.rstrip()}{Colors.RESET}"
+        return timestamp, content
     
-    def tail_logs(self, service_names: List[str], follow: bool = True, lines: int = 10):
+    def tail_logs(self, service_names: List[str], follow: bool = True, lines: int = None):
         """
-        Display logs for specified services in real-time.
+        显示服务日志
         
         Args:
-            service_names: List of service names to show logs for
-            follow: Whether to follow logs in real-time (like tail -f)
-            lines: Number of recent lines to display initially
+            service_names: 要查看的服务名称列表
+            follow: 是否实时跟踪日志（类似tail -f）
+            lines: 初始显示的行数，默认为self.default_tail_lines
         """
+        if lines is None:
+            lines = self.default_tail_lines
+            
         if not service_names:
-            print(f"{Emojis.WARNING} {Colors.YELLOW}No services specified for log viewing.{Colors.RESET}")
+            print_warning("未指定要查看日志的服务。")
             return
 
-        # Check if the logs exist
+        # 检查日志文件是否存在
         log_files = []
         for service in service_names:
             service_logs = self.get_log_files(service)
@@ -199,52 +163,53 @@ class LogManager:
                 if log_path.exists():
                     log_files.append((service, log_type, log_path))
                 else:
-                    service_color = self._get_service_color(service)
-                    print(f"{Emojis.WARNING} {Colors.YELLOW}No {log_type} logs found for {service_color}{service}{Colors.RESET}.")
+                    style = "stderr_service" if log_type == "stderr" else "stdout_service" 
+                    console.print(f"{Emojis.WARNING} 未找到服务 [{style}]{service}[/] 的 {log_type} 日志。", style="warning")
                     
         if not log_files:
-            print(f"{Emojis.WARNING} {Colors.YELLOW}No log files found for specified services.{Colors.RESET}")
+            print_warning("未找到指定服务的日志文件。")
             return
             
         if follow:
+            # 首先显示最后几行，然后再开始跟踪
+            self._display_recent_logs(log_files, lines)
             self._follow_logs(log_files)
         else:
             self._display_recent_logs(log_files, lines)
     
     def _display_recent_logs(self, log_files: List[Tuple[str, str, Path]], lines: int):
-        """Display the most recent lines from log files."""
+        """显示最近的日志行"""
         for service, log_type, log_path in log_files:
-            print(self._format_log_header(service, log_type))
+            # PM2风格的标题
+            console.print(f"\n[dim]{log_path} last {lines} lines:[/]")
+            
             try:
                 # 读取最后N行
                 with open(log_path, 'r') as f:
                     content = f.readlines()
                     last_lines = content[-lines:] if len(content) >= lines else content
                     
-                    # 打印每一行，增加格式
+                    # 打印每一行，PM2格式
                     for line in last_lines:
-                        print(self._format_log_line(service, log_type, line, show_timestamp=False))
+                        timestamp, message = self._parse_log_line(line)
+                        style = "stderr_service" if log_type == "stderr" else "stdout_service"
+                        console.print(f"[{style}]{service}[/] | {timestamp}: {message}")
             except Exception as e:
-                print(f"{Emojis.ERROR} {Colors.RED}Error reading logs: {str(e)}{Colors.RESET}")
+                print_error(f"读取日志文件出错: {str(e)}")
     
     def _follow_logs(self, log_files: List[Tuple[str, str, Path]]):
-        """Follow logs in real-time, similar to tail -f."""
-        # Dictionary to keep track of file positions
+        """实时跟踪日志（类似tail -f）"""
         file_handlers = {}
         
         try:
-            # Open all log files
+            # 打开所有日志文件
             for service, log_type, log_path in log_files:
                 f = open(log_path, 'r')
-                # Move to the end of the file
+                # 移动到文件末尾
                 f.seek(0, os.SEEK_END)
                 file_handlers[(service, log_type)] = f
                 
-                # 打印日志头部
-                print(self._format_log_header(service, log_type))
-                
-            print(f"\n{Emojis.LOADING} {Colors.BRIGHT_BLACK}Following logs... (Ctrl+C to stop){Colors.RESET}")
-            print(f"{Colors.BRIGHT_BLACK}{'─' * 60}{Colors.RESET}")
+            console.print(f"\n[dim]正在跟踪日志... (按Ctrl+C停止)[/]")
             
             while True:
                 has_new_data = False
@@ -253,14 +218,16 @@ class LogManager:
                     line = f.readline()
                     if line:
                         has_new_data = True
-                        print(self._format_log_line(service, log_type, line))
+                        timestamp, message = self._parse_log_line(line)
+                        style = "stderr_service" if log_type == "stderr" else "stdout_service"
+                        console.print(f"[{style}]{service}[/] | {timestamp}: {message}")
                 
                 if not has_new_data:
                     time.sleep(0.1)
                     
         except KeyboardInterrupt:
-            print(f"\n{Emojis.STOP} {Colors.BRIGHT_BLACK}Stopped following logs.{Colors.RESET}")
+            console.print(f"\n[dim]已停止日志跟踪[/]")
         finally:
-            # Close all file handlers
+            # 关闭所有文件
             for f in file_handlers.values():
                 f.close()

servly/service.py

@@ -7,8 +7,10 @@ import signal
 import yaml
 import logging
 import time
+import psutil
 from pathlib import Path
-from typing import Dict, Union, List, Optional, Any
+from datetime import datetime
+from typing import Dict, Union, List, Optional, Any, Tuple
 
 logger = logging.getLogger(__name__)
 
@@ -17,16 +19,40 @@ class ServiceManager:
     
     def __init__(self, config_path: str = "servly.yml", servly_dir: str = ".servly"):
         self.config_path = config_path
-        self.servly_dir = Path(servly_dir)
+        # 修改为使用配置文件所在目录
+        config_dir = os.path.dirname(os.path.abspath(config_path))
+        self.servly_dir = Path(config_dir) / servly_dir
         self.pid_dir = self.servly_dir / "pids"
         self.log_dir = self.servly_dir / "logs"
+        # 存储服务启动时间，用于计算运行时长
+        self.start_times = {}
         self._ensure_dirs()
         self.services = self._load_config()
+        # 加载现有的服务启动时间
+        self._load_start_times()
         
     def _ensure_dirs(self):
         """Create required directories if they don't exist."""
         self.pid_dir.mkdir(parents=True, exist_ok=True)
         self.log_dir.mkdir(parents=True, exist_ok=True)
+    
+    def _load_start_times(self):
+        """加载已运行服务的启动时间"""
+        for service_name in self.get_service_names():
+            if self.is_running(service_name):
+                # 尝试从文件获取启动时间，如果没有则使用当前时间
+                start_time_file = self.pid_dir / f"{service_name}.time"
+                if start_time_file.exists():
+                    try:
+                        with open(start_time_file, "r") as f:
+                            timestamp = float(f.read().strip())
+                            self.start_times[service_name] = timestamp
+                    except (ValueError, IOError):
+                        # 如果文件无法读取或格式不正确，使用当前时间
+                        self.start_times[service_name] = time.time()
+                else:
+                    # 如果没有时间文件，使用当前时间
+                    self.start_times[service_name] = time.time()
         
     def _load_config(self) -> Dict[str, Any]:
         """Load service configurations from servly.yml."""
@@ -81,10 +107,45 @@ class ServiceManager:
             else:
                 # Clean up stale PID file
                 os.remove(pid_file)
+                # 删除相关的启动时间记录
+                if service_name in self.start_times:
+                    del self.start_times[service_name]
+                start_time_file = self.pid_dir / f"{service_name}.time"
+                if start_time_file.exists():
+                    os.remove(start_time_file)
                 return None
         except (ValueError, FileNotFoundError):
             return None
     
+    def get_uptime(self, service_name: str) -> Optional[float]:
+        """获取服务运行时间（以秒为单位）"""
+        if service_name in self.start_times and self.is_running(service_name):
+            return time.time() - self.start_times[service_name]
+        return None
+    
+    def format_uptime(self, uptime_seconds: Optional[float]) -> str:
+        """将运行时间格式化为易读格式"""
+        if uptime_seconds is None:
+            return "-"
+        
+        # 转换为整数秒
+        seconds = int(uptime_seconds)
+        
+        # 计算天、小时、分钟、秒
+        days, seconds = divmod(seconds, 86400)
+        hours, seconds = divmod(seconds, 3600)
+        minutes, seconds = divmod(seconds, 60)
+        
+        # 格式化为易读字符串
+        if days > 0:
+            return f"{days}d {hours}h"
+        elif hours > 0:
+            return f"{hours}h {minutes}m"
+        elif minutes > 0:
+            return f"{minutes}m {seconds}s"
+        else:
+            return f"{seconds}s"
+    
     def _is_process_running(self, pid: int) -> bool:
         """Check if process with given PID is running."""
         try:
@@ -158,6 +219,15 @@ class ServiceManager:
             with open(self.get_pid_file(service_name), 'w') as f:
                 f.write(str(process.pid))
                 
+            # 记录启动时间
+            start_time = time.time()
+            self.start_times[service_name] = start_time
+            
+            # 保存启动时间到文件
+            start_time_file = self.pid_dir / f"{service_name}.time"
+            with open(start_time_file, 'w') as f:
+                f.write(str(start_time))
+                
             logger.info(f"Started service '{service_name}' with PID {process.pid}")
             return True
             
@@ -192,6 +262,15 @@ class ServiceManager:
             if os.path.exists(pid_file):
                 os.remove(pid_file)
                 
+            # 清理启动时间记录
+            if service_name in self.start_times:
+                del self.start_times[service_name]
+            
+            # 删除启动时间文件
+            start_time_file = self.pid_dir / f"{service_name}.time"
+            if start_time_file.exists():
+                os.remove(start_time_file)
+                
             logger.info(f"Stopped service '{service_name}'")
             return True
             
@@ -200,6 +279,16 @@ class ServiceManager:
             pid_file = self.get_pid_file(service_name)
             if os.path.exists(pid_file):
                 os.remove(pid_file)
+            
+            # 清理启动时间记录
+            if service_name in self.start_times:
+                del self.start_times[service_name]
+            
+            # 删除启动时间文件
+            start_time_file = self.pid_dir / f"{service_name}.time"
+            if start_time_file.exists():
+                os.remove(start_time_file)
+                
             logger.info(f"Service '{service_name}' was not running")
             return True
             
@@ -210,4 +299,51 @@ class ServiceManager:
     def restart(self, service_name: str) -> bool:
         """Restart a service."""
         self.stop(service_name)
-        return self.start(service_name)
+        return self.start(service_name)
+    
+    def get_process_stats(self, service_name: str) -> Dict[str, Any]:
+        """获取进程的 CPU 和内存使用情况"""
+        pid = self.get_service_pid(service_name)
+        stats = {"cpu_percent": None, "memory_percent": None, "memory_mb": None}
+        
+        if pid:
+            try:
+                process = psutil.Process(pid)
+                # 获取 CPU 使用百分比 (非阻塞模式)
+                stats["cpu_percent"] = process.cpu_percent(interval=0)
+                
+                # 获取内存使用情况
+                memory_info = process.memory_info()
+                stats["memory_mb"] = memory_info.rss / (1024 * 1024)  # 转换为 MB
+                
+                # 计算内存使用百分比
+                stats["memory_percent"] = process.memory_percent()
+                
+                return stats
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                # 如果进程已不存在或无法访问，返回默认值
+                pass
+                
+        return stats
+    
+    def format_cpu_percent(self, cpu_percent: Optional[float]) -> str:
+        """格式化 CPU 使用百分比"""
+        if cpu_percent is None:
+            return "0%"
+        return f"{cpu_percent:.1f}%"
+    
+    def format_memory(self, memory_mb: Optional[float], memory_percent: Optional[float]) -> str:
+        """格式化内存使用情况"""
+        if memory_mb is None:
+            return "0b"
+        
+        # 如果小于 1MB，显示为 KB
+        if memory_mb < 1:
+            return f"{int(memory_mb * 1024)}kb"
+        
+        # 如果大于 1GB，显示为 GB
+        if memory_mb > 1024:
+            return f"{memory_mb/1024:.1f}gb"
+            
+        # 否则显示为 MB
+        return f"{int(memory_mb)}mb"

{servly-0.2.0.dist-info → servly-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: servly
-Version: 0.2.0
+Version: 0.3.1
 Summary: simple process manager
 Author-email: simpxx <simpxx@gmail.com>
 License: MIT
@@ -10,7 +10,9 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: psutil>=7.0.0
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=14.0.0
 
 # SERVLY
 

servly-0.3.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+servly/__init__.py,sha256=HT8I94RyP6_gNoVJWOVSkeOEQIl3QnT60zCP2PJVon0,73
+servly/cli.py,sha256=2x8jI8k24_U6JiNgTbHcoJDjRXuC7fgVDG1rEprc-tw,10337
+servly/logs.py,sha256=MWnQbSR_PjLRDm9JLIO3uvEkw57DZey0Ocbu6glFJpc,8109
+servly/service.py,sha256=-qm7slEELm8PG_NErviezI6iKuG08FID2wvXSc1NBYg,13722
+servly-0.3.1.dist-info/METADATA,sha256=NHsI2XN3X13y_8NmLjj-KNJeWzX16U278tzSlzEHtoI,2687
+servly-0.3.1.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+servly-0.3.1.dist-info/entry_points.txt,sha256=enHpE2d9DYdzfIWBcnIjuIkcNVk118xghL0AeTUL0Yg,43
+servly-0.3.1.dist-info/top_level.txt,sha256=JLi7GX0KwWF-mh8i1-lVJ2q4SO1KfI2CNxQk_VNfNZE,7
+servly-0.3.1.dist-info/RECORD,,

servly-0.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-servly/__init__.py,sha256=HT8I94RyP6_gNoVJWOVSkeOEQIl3QnT60zCP2PJVon0,73
-servly/cli.py,sha256=HeOOsnaJGMaiSWQ5Z-hkCLjxpmoUfES37hgfTHBuDMk,12142
-servly/logs.py,sha256=HfC_EByTbgz6MpW8IpemEwpRPPE0xME46zUy2CyJvqU,9779
-servly/service.py,sha256=5xhSD0HkfQw8xnY5J0GRxyFE8_CHBq5yfatbhL625PM,8123
-servly-0.2.0.dist-info/METADATA,sha256=YICRthT2IW92tOXYTUmZN1cCGZ3LtWBhtLPIIZADKeA,2630
-servly-0.2.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-servly-0.2.0.dist-info/entry_points.txt,sha256=enHpE2d9DYdzfIWBcnIjuIkcNVk118xghL0AeTUL0Yg,43
-servly-0.2.0.dist-info/top_level.txt,sha256=JLi7GX0KwWF-mh8i1-lVJ2q4SO1KfI2CNxQk_VNfNZE,7
-servly-0.2.0.dist-info/RECORD,,