volcengine-python-sdk-aicc 0.0.41__py3-none-any.whl

bytedance/jeddak_secure_channel/log/config.py

@@ -0,0 +1,31 @@
+__all__ = [
+    "DEBUG",
+    "INFO",
+    "WARNING",
+    "ERROR",
+    "CRITICAL",
+    "FORMAT",
+    "LogConfig"
+]
+
+# Log level constants
+DEBUG = "DEBUG"
+INFO = "INFO"
+WARNING = "WARNING"
+ERROR = "ERROR"
+CRITICAL = "CRITICAL"
+# Log output format
+FORMAT = "{time:YYYY-MM-DD HH:mm:ss} | {level} | {file.path}:{line} | {message}"
+
+
+class LogConfig:
+    """Log configuration class."""
+
+    def __init__(self):
+        self.rotation = 100  # Size limit for log files in MB
+        self.retention = 7  # Days to retain log files
+        self.compression = "zip"
+        self.dir = "jsc_log"
+        self.filename = "jsc.log"
+        self.format = FORMAT
+        self.level = INFO

bytedance/jeddak_secure_channel/log/logger.py

@@ -0,0 +1,88 @@
+__all__ = [
+    "debug",
+    "info",
+    "warning",
+    "error",
+    "critical",
+    "init_log_config"
+]
+
+import os.path
+import sys
+from typing import Any
+
+from loguru import logger
+
+from . import LogConfig, FORMAT
+
+
+def init_log_config(*configs: LogConfig):
+    """Initialize logging configuration with given configs."""
+    logger.remove()
+
+    log_level = "INFO"
+    if os.environ.get("log_level"):
+        log_level = os.environ.get("log_level")
+    if os.environ.get("LOG_LEVEL"):
+        log_level = os.environ.get("LOG_LEVEL")
+
+    logger.add(sink=sys.stdout, format=FORMAT, level=log_level)
+
+    for config in configs:
+        if not config.dir:
+            config.dir = os.environ.get("LOG_DIR", "aicc_log")
+
+        if not config.filename:
+            config.filename = "jsc.log"
+
+        os.makedirs(config.dir, exist_ok=True)
+        fullpath = os.path.join(config.dir, config.filename)
+
+        if config.rotation <= 0:
+            config.rotation = 100
+        rotation = f"{config.rotation} MB"
+
+        if config.retention <= 0:
+            config.retention = 7
+        retention = f"{config.retention} days"
+
+        logger.add(
+            sink=fullpath,
+            rotation=rotation,
+            retention=retention,
+            compression=config.compression,
+            format=config.format,
+            level=config.level
+        )
+
+
+def msg_proc(message: str) -> str:
+    if message:
+        return f"[jsc]:{message}"
+    else:
+        return message
+
+
+def debug(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log debug message."""
+    logger.opt(depth=1).debug(msg_proc(message), *args, **kwargs)
+
+
+def info(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log info message."""
+    logger.opt(depth=1).info(msg_proc(message), *args, **kwargs)
+
+
+def warning(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log warning message."""
+    logger.opt(depth=1).warning(msg_proc(message), *args, **kwargs)
+
+
+def error(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log error message."""
+    logger.opt(depth=1).error(msg_proc(message), *args, **kwargs)
+
+
+def critical(message: str, *args: Any, **kwargs: Any) -> None:
+    """Log critical message."""
+    logger.opt(depth=1).critical(msg_proc(message), *args, **kwargs)

bytedance/jeddak_secure_channel/logger_factory.py

@@ -0,0 +1,134 @@
+import logging
+import multiprocessing
+import os
+import sys
+
+mutex = multiprocessing.Lock()
+
+
+class Factory(object):
+    @staticmethod
+    def init(*args):
+        """
+        Initialize a global instance
+        :param args:
+        :return:
+        """
+        pass
+
+    @staticmethod
+    def get_global_instance():
+        """
+        Get the global instance
+        :return:
+        """
+        pass
+
+    @staticmethod
+    def get_instance(*args):
+        """
+        Get an instance
+        :param args:
+        :return:
+        """
+        pass
+
+    @staticmethod
+    def _raise_value_error(invalid_type, invalid_value):
+        """
+
+        :param invalid_type: str
+        :param invalid_value: str
+        :return:
+        """
+        raise ValueError("invalid {}: {}".format(invalid_type, invalid_value))
+
+
+class LoggerFactory(Factory):
+    logger = None
+    root_dir = ""
+    task_logger_level = ""
+    local_logger = {}
+
+    @staticmethod
+    def init():
+        top_logger_level = os.getenv("TOP_LOGGER_LEVEL", "DEBUG").strip('"')
+        log_path = os.getenv("LOGDIR", f"./jsc_log").strip('"')
+        task_logger_level = os.getenv("TASK_LOGGER_LEVEL", "DEBUG").strip('"')
+
+        LoggerFactory.task_logger_level = task_logger_level
+
+        try:
+            import bytedlogger
+
+            bytedlogger.config_default()
+            LoggerFactory.logger = logging.getLogger("top")
+        except ImportError:
+            LoggerFactory.logger = logging.getLogger("top")
+        LoggerFactory.logger.setLevel(top_logger_level)
+
+        if log_path is None or log_path == "":
+            log_path = "/home/jeddak/log"
+            print(f"Root logger path is not set, use log_path {log_path}")
+
+        print(f"log_path: {log_path}")
+        LoggerFactory.root_dir = log_path
+
+        if not os.path.exists(log_path):
+            os.makedirs(log_path)
+
+        top_logger_path = os.path.join(log_path, "top.log")
+
+        fh = logging.FileHandler(top_logger_path, mode="a")
+        fh.setLevel(top_logger_level)
+        formatter = logging.Formatter(
+            "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
+        )
+        fh.setFormatter(formatter)
+        LoggerFactory.logger.addHandler(fh)
+        # LoggerFactory.logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    @staticmethod
+    def get_global_instance():
+        if LoggerFactory.logger is None:
+            LoggerFactory.init()
+        return LoggerFactory.logger
+
+    @staticmethod
+    def attach_logger(logger, log_path, log_file_name, logger_level, _formatter):
+        with mutex:
+            if not os.path.exists(log_path):
+                os.makedirs(log_path)
+        logger.setLevel(logger_level)
+        _fh = logging.FileHandler(log_file_name, mode="a")
+        _fh.setLevel(logger_level)
+        # _formatter = logging.Formatter(
+        #     f'%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - {logger_str} - %(message)s')
+        _fh.setFormatter(_formatter)
+
+        logger.addHandler(_fh)
+        logger.addHandler(logging.StreamHandler(sys.stdout))
+        return logger
+
+    @staticmethod
+    def get_local_instance(log_id="jsc_log"):
+        if LoggerFactory.logger is None:
+            LoggerFactory.init()
+
+        logger_name = log_id
+        if logger_name in LoggerFactory.local_logger:
+            return LoggerFactory.local_logger[logger_name]
+
+        log_path = os.path.join(LoggerFactory.root_dir, log_id)
+        log_file_name = os.path.join(log_path, logger_name + ".log")
+
+        _logger = logging.getLogger(log_id)
+
+        _formatter = logging.Formatter(
+            f"%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - {logger_name} - %(message)s"
+        )
+        _logger = LoggerFactory.attach_logger(
+            _logger, log_path, log_file_name, LoggerFactory.task_logger_level, _formatter
+        )
+        LoggerFactory.local_logger[logger_name] = _logger
+        return _logger