ChronicleLogger 0.1.0__tar.gz

chroniclelogger-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ChronicleLogger
+Version: 0.1.0
+Summary: Privilege-aware, auto-rotating daily logger for Linux daemons & CLI tools (Cython-optimized)
+Author-email: Wilgat Wong <wilgat.wong@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Wilgat/ChronicleLogger
+Project-URL: Repository, https://github.com/Wilgat/ChronicleLogger
+Project-URL: Issues, https://github.com/Wilgat/ChronicleLogger/issues
+Project-URL: Documentation, https://github.com/Wilgat/ChronicleLogger#readme
+Keywords: logging,cython,linux,daemon,sudo,privilege,log rotation,daily log
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Cython
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: System :: Logging
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

chroniclelogger-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+# pyproject.toml
+[build-system]
+requires = ["setuptools>=61", "wheel", "Cython"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ChronicleLogger"
+dynamic = ["version"]
+description = "Privilege-aware, auto-rotating daily logger for Linux daemons & CLI tools (Cython-optimized)"
+readme = "README.md"
+authors = [{ name = "Wilgat Wong", email = "wilgat.wong@gmail.com" }]
+license = { text = "MIT" }
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Cython",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: System :: Logging",
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers"
+]
+keywords = ["logging", "cython", "linux", "daemon", "sudo", "privilege", "log rotation", "daily log"]
+
+[project.urls]
+Homepage = "https://github.com/Wilgat/ChronicleLogger"
+Repository = "https://github.com/Wilgat/ChronicleLogger"
+Issues = "https://github.com/Wilgat/ChronicleLogger/issues"
+Documentation = "https://github.com/Wilgat/ChronicleLogger#readme"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"chronicle_logger" = ["*.so", "*.pyx"]
+
+[tool.setuptools.dynamic]
+version = { attr = "chronicle_logger.__version__" }

chroniclelogger-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chroniclelogger-0.1.0/src/ChronicleLogger.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: ChronicleLogger
+Version: 0.1.0
+Summary: Privilege-aware, auto-rotating daily logger for Linux daemons & CLI tools (Cython-optimized)
+Author-email: Wilgat Wong <wilgat.wong@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Wilgat/ChronicleLogger
+Project-URL: Repository, https://github.com/Wilgat/ChronicleLogger
+Project-URL: Issues, https://github.com/Wilgat/ChronicleLogger/issues
+Project-URL: Documentation, https://github.com/Wilgat/ChronicleLogger#readme
+Keywords: logging,cython,linux,daemon,sudo,privilege,log rotation,daily log
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Cython
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: System :: Logging
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

chroniclelogger-0.1.0/src/ChronicleLogger.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/ChronicleLogger.egg-info/PKG-INFO
+src/ChronicleLogger.egg-info/SOURCES.txt
+src/ChronicleLogger.egg-info/dependency_links.txt
+src/ChronicleLogger.egg-info/top_level.txt
+src/chronicle_logger/ChronicleLogger.py
+src/chronicle_logger/Suroot.py
+src/chronicle_logger/__init__.py
+test/test_chronicle_logger.py

chroniclelogger-0.1.0/src/ChronicleLogger.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chroniclelogger-0.1.0/src/ChronicleLogger.egg-info/top_level.txt

@@ -0,0 +1 @@
+chronicle_logger

chroniclelogger-0.1.0/src/chronicle_logger/ChronicleLogger.py

@@ -0,0 +1,240 @@
+# src/chronicle_logger/ChronicleLogger.py
+import os
+import sys
+import ctypes
+import tarfile
+import re
+from datetime import datetime
+
+# Correct import for your actual file: Suroot.py (capital S)
+from .Suroot import _Suroot
+
+try:
+    basestring
+except NameError:
+    basestring = str
+
+
+# baseDir should be independent
+# It should never be affected by root/sudo/normal user
+# It is for cross-application configuration, not logging
+# Getting the parent of logDir() is trivial if needed
+# We should not couple them
+# 
+# baseDir()  → /var/myapp        ← user sets this explicitly
+#              /home/user/.myapp
+#              /opt/myapp
+# 
+# logDir()   → /var/log/myapp   ← automatically derived only if not set
+#              ~/.app/myapp/log
+
+
+class ChronicleLogger:
+    CLASSNAME = "ChronicleLogger"
+    MAJOR_VERSION = 0
+    MINOR_VERSION = 1
+    PATCH_VERSION = 0
+
+    LOG_ARCHIVE_DAYS = 7
+    LOG_REMOVAL_DAYS = 30
+
+    def __init__(self, logname=b"app", logdir=b"", basedir=b""):
+        self.__logname__ = None
+        self.__basedir__ = None
+        self.__logdir__ = None
+        self.__old_logfile_path__ = ctypes.c_char_p(b"")
+        self.__is_python__ = None
+
+        if not logname or logname in (b"", ""):
+            return
+
+        self.logName(logname)
+        if logdir:
+            self.logDir(logdir)
+        else:
+            self.logDir("")  # triggers default path + directory creation
+        self.baseDir(basedir if basedir else "")
+
+        self.__current_logfile_path__ = self._get_log_filename()
+        self.ensure_directory_exists(self.__logdir__)
+
+        if self._has_write_permission(self.__current_logfile_path__):
+            self.write_to_file("\n")
+
+    def strToByte(self, value):
+        if isinstance(value, basestring):
+            return value.encode()
+        elif value is None or isinstance(value, bytes):
+            return value
+        raise TypeError(f"Expected str/bytes/None, got {type(value).__name__}")
+
+    def byteToStr(self, value):
+        if value is None or isinstance(value, basestring):
+            return value
+        elif isinstance(value, bytes):
+            return value.decode()
+        raise TypeError(f"Expected str/bytes/None, got {type(value).__name__}")
+
+    def inPython(self):
+        if self.__is_python__ is None:
+            self.__is_python__ = 'python' in sys.executable.lower()
+        return self.__is_python__
+
+    def logName(self, logname=None):
+        if logname is not None:
+            self.__logname__ = self.strToByte(logname)
+            if self.inPython():
+                name = self.__logname__.decode()
+                name = re.sub(r'(?<!^)(?=[A-Z])', '-', name).lower()
+                self.__logname__ = name.encode()
+        else:
+            return self.__logname__.decode()
+
+    def __set_base_dir__(self, basedir=b""):
+        basedir_str = self.byteToStr(basedir)
+        if not basedir_str:
+            appname = self.__logname__.decode()
+            if _Suroot.should_use_system_paths():
+                path = f"/var/{appname}"
+            else:
+                home = os.path.expanduser("~")
+                path = os.path.join(home, f".app/{appname}")
+            self.__basedir__ = path
+        else:
+            self.__basedir__ = basedir_str
+
+    def baseDir(self, basedir=None):
+        if basedir is not None:
+            self.__set_base_dir__(basedir)
+        else:
+            if self.__basedir__ is None:
+                self.__set_base_dir__()
+            return self.__basedir__
+
+    def __set_log_dir__(self, logdir=b""):
+        logdir_str = self.byteToStr(logdir)
+        if logdir_str:
+            self.__logdir__ = logdir_str
+        else:
+            appname = self.__logname__.decode()
+            if _Suroot.should_use_system_paths():
+                self.__logdir__ = f"/var/log/{appname}"
+            else:
+                home = os.path.expanduser("~")
+                self.__logdir__ = os.path.join(home, f".app/{appname}", "log")
+
+    def logDir(self, logdir=None):
+        if logdir is not None:
+            self.__set_log_dir__(logdir)
+        else:
+            if self.__logdir__ is None:
+                self.__set_log_dir__()
+            return self.__logdir__
+
+    def isDebug(self):
+        if not hasattr(self, '__is_debug__'):
+            self.__is_debug__ = (
+                os.getenv("DEBUG", "").lower() == "show" or
+                os.getenv("debug", "").lower() == "show"
+            )
+        return self.__is_debug__
+
+    @staticmethod
+    def class_version():
+        return f"{ChronicleLogger.CLASSNAME} v{ChronicleLogger.MAJOR_VERSION}.{ChronicleLogger.MINOR_VERSION}.{ChronicleLogger.PATCH_VERSION}"
+
+    def ensure_directory_exists(self, dir_path):
+        if dir_path and not os.path.exists(dir_path):
+            try:
+                os.makedirs(dir_path)
+                print(f"Created directory: {dir_path}")
+            except Exception as e:
+                self.log_message(f"Failed to create directory {dir_path}: {e}", level="ERROR")
+
+    def _get_log_filename(self):
+        date_str = datetime.now().strftime('%Y%m%d')
+        filename = f"{self.__logdir__}/{self.__logname__.decode()}-{date_str}.log"
+        return ctypes.c_char_p(filename.encode()).value
+
+    def log_message(self, message, level=b"INFO", component=b""):
+        pid = os.getpid()
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        component_str = f" @{self.byteToStr(component)}" if component else ""
+        message_str = self.byteToStr(message)
+        level_str = self.byteToStr(level).upper()
+
+        log_entry = f"[{timestamp}] pid:{pid} [{level_str}]{component_str} :] {message_str}\n"
+
+        new_path = self._get_log_filename()
+
+        if self.__old_logfile_path__ != new_path:
+            self.log_rotation()
+            self.__old_logfile_path__ = new_path
+            if self.isDebug():
+                header = f"[{timestamp}] pid:{pid} [INFO] @logger :] Using {new_path.decode()}\n"
+                log_entry = header + log_entry
+
+        if self._has_write_permission(new_path):
+            if level_str in ("ERROR", "CRITICAL", "FATAL"):
+                print(log_entry.strip(), file=sys.stderr)
+            else:
+                print(log_entry.strip())
+            self.write_to_file(log_entry)
+
+    def _has_write_permission(self, file_path):
+        try:
+            with open(file_path, 'a'):
+                return True
+        except (PermissionError, IOError):
+            print(f"Permission denied for writing to {file_path}", file=sys.stderr)
+            return False
+
+    def write_to_file(self, log_entry):
+        with open(self.__current_logfile_path__, 'a', encoding='utf-8') as f:
+            f.write(log_entry)
+
+    def log_rotation(self):
+        if not os.path.exists(self.__logdir__) or not os.listdir(self.__logdir__):
+            return
+        self.archive_old_logs()
+        self.remove_old_logs()
+
+    def archive_old_logs(self):
+        try:
+            for file in os.listdir(self.__logdir__):
+                if file.endswith(".log"):
+                    date_part = file.split('-')[-1].split('.')[0]
+                    try:
+                        log_date = datetime.strptime(date_part, '%Y%m%d')
+                        if (datetime.now() - log_date).days > self.LOG_ARCHIVE_DAYS:
+                            self._archive_log(file)
+                    except ValueError:
+                        continue
+        except Exception as e:
+            print(f"Error during archive: {e}", file=sys.stderr)
+
+    def _archive_log(self, filename):
+        log_path = os.path.join(self.__logdir__, filename)
+        archive_path = log_path + ".tar.gz"
+        try:
+            with tarfile.open(archive_path, "w:gz") as tar:
+                tar.add(log_path, arcname=filename)
+            os.remove(log_path)
+            print(f"Archived log file: {archive_path}")
+        except Exception as e:
+            print(f"Error archiving {filename}: {e}", file=sys.stderr)
+
+    def remove_old_logs(self):
+        try:
+            for file in os.listdir(self.__logdir__):
+                if file.endswith(".log"):
+                    date_part = file.split('-')[-1].split('.')[0]
+                    try:
+                        log_date = datetime.strptime(date_part, '%Y%m%d')
+                        if (datetime.now() - log_date).days > self.LOG_REMOVAL_DAYS:
+                            os.remove(os.path.join(self.__logdir__, file))
+                    except ValueError:
+                        continue
+        except Exception as e:
+            print(f"Error during removal: {e}", file=sys.stderr)

chroniclelogger-0.1.0/src/chronicle_logger/Suroot.py

@@ -0,0 +1,65 @@
+# src/ChronicleLogger/Suroot.py  # Note: Filename without underscore for consistency
+# Minimal, safe, non-interactive root/sudo detector
+# ONLY for internal use by ChronicleLogger
+import os
+from subprocess import Popen, DEVNULL
+
+class _Suroot:
+    """
+    Tiny, zero-dependency, non-interactive privilege detector.
+    Used by ChronicleLogger to decide log directory (/var/log vs ~/.app).
+    NEVER prompts, NEVER prints, safe in CI/CD and tests.
+    """
+
+    CLASSNAME = "Suroot"
+    MAJOR_VERSION = 0
+    MINOR_VERSION = 1
+    PATCH_VERSION = 0
+
+    _is_root = None
+    _can_sudo_nopasswd = None
+
+    @staticmethod
+    def class_version():
+        """Return the class name and version string."""
+        return f"{_Suroot.CLASSNAME} v{_Suroot.MAJOR_VERSION}.{_Suroot.MINOR_VERSION}.{_Suroot.PATCH_VERSION}"
+
+    @staticmethod
+    def is_root() -> bool:
+        """Are we currently running as root (euid == 0)?"""
+        if _Suroot._is_root is None:
+            _Suroot._is_root = os.geteuid() == 0
+        return _Suroot._is_root
+
+    @staticmethod
+    def can_sudo_without_password() -> bool:
+        """Can we run 'sudo' commands without being asked for a password?"""
+        if _Suroot._can_sudo_nopasswd is not None:
+            return _Suroot._can_sudo_nopasswd
+
+        if _Suroot.is_root():
+            _Suroot._can_sudo_nopasswd = True
+            return True
+
+        try:
+            proc = Popen(
+                ["sudo", "-n", "true"],
+                stdin=DEVNULL,
+                stdout=DEVNULL,
+                stderr=DEVNULL,
+            )
+            proc.communicate(timeout=5)
+            _Suroot._can_sudo_nopasswd = proc.returncode == 0
+        except Exception:
+            _Suroot._can_sudo_nopasswd = False
+
+        return _Suroot._can_sudo_nopasswd
+
+    @staticmethod
+    def should_use_system_paths() -> bool:
+        """
+        Final decision method used by ChronicleLogger.
+        Returns True → use /var/log and /var/<app>
+        Returns False → use ~/.app/<app>/log
+        """
+        return _Suroot.is_root() or _Suroot.can_sudo_without_password()

chroniclelogger-0.1.0/src/chronicle_logger/__init__.py

@@ -0,0 +1,5 @@
+# logged_example/__init__.py
+from .Suroot import _Suroot
+
+__all__ = ['StateLogic']
+__version__ = "0.1.0" 

chroniclelogger-0.1.0/test/test_chronicle_logger.py

@@ -0,0 +1,99 @@
+# test/test_chronicle_logger.py
+import os
+import sys
+import tarfile
+from datetime import datetime, timedelta
+
+import pytest
+from unittest.mock import patch
+
+TEST_DIR = os.path.dirname(__file__)
+SRC_DIR = os.path.abspath(os.path.join(TEST_DIR, "..", "src"))
+sys.path.insert(0, SRC_DIR)
+
+from chronicle_logger.ChronicleLogger import ChronicleLogger
+
+
+@pytest.fixture
+def log_dir(tmp_path):
+    return tmp_path / "log"
+
+
+@pytest.fixture
+def logger(log_dir):
+    return ChronicleLogger(logname="TestApp", logdir=str(log_dir))
+
+
+def test_directory_created_on_init_when_logdir_given(log_dir):
+    assert not log_dir.exists()
+    ChronicleLogger(logname="TestApp", logdir=str(log_dir))
+    assert log_dir.exists()
+
+
+def test_logname_becomes_kebab_case():
+    logger = ChronicleLogger(logname="TestApp")
+    assert logger.logName() == "test-app"
+
+    logger = ChronicleLogger(logname="HelloWorld")
+    assert logger.logName() == "hello-world"
+
+
+@patch('chronicle_logger.ChronicleLogger.ChronicleLogger.inPython', return_value=False)
+def test_logname_unchanged_in_cython_binary(mock):
+    logger = ChronicleLogger(logname="PreserveCase")
+    logger.logName("PreserveCase")
+    assert logger.logName() == "PreserveCase"
+
+
+def test_basedir_is_user_defined_and_independent(tmp_path):
+    custom = str(tmp_path / "myconfig")
+    logger = ChronicleLogger(logname="App", basedir=custom)
+    assert logger.baseDir() == custom
+
+
+@patch('chronicle_logger.Suroot._Suroot.should_use_system_paths', return_value=True)
+def test_logdir_uses_system_path_when_privileged_and_not_set(mock):
+    logger = ChronicleLogger(logname="RootApp")
+    assert logger.logDir() == "/var/log/root-app"
+
+
+@patch('chronicle_logger.Suroot._Suroot.should_use_system_paths', return_value=False)
+def test_logdir_uses_user_path_when_not_privileged_and_not_set(mock):
+    logger = ChronicleLogger(logname="UserApp")
+    expected = os.path.join(os.path.expanduser("~"), ".app/user-app", "log")
+    assert logger.logDir() == expected
+
+
+def test_logdir_custom_path_overrides_everything(log_dir):
+    logger = ChronicleLogger(logname="AnyApp", logdir=str(log_dir))
+    assert logger.logDir() == str(log_dir)
+
+
+def test_log_message_writes_correct_filename(logger, log_dir):
+    logger.log_message("Hello!", level="INFO")
+    today = datetime.now().strftime("%Y%m%d")
+    logfile = log_dir / f"test-app-{today}.log"  # ← test-app, not testapp
+    assert logfile.exists()
+
+
+@pytest.mark.parametrize("level", ["ERROR", "CRITICAL", "FATAL"])
+def test_error_levels_go_to_stderr(logger, level, capsys):
+    logger.log_message("Boom!", level=level)
+    captured = capsys.readouterr()
+    assert "Boom!" in captured.err
+
+
+def test_archive_old_logs(log_dir):
+    logger = ChronicleLogger(logname="TestApp", logdir=str(log_dir))
+    old_file = log_dir / f"test-app-{(datetime.now() - timedelta(days=10)).strftime('%Y%m%d')}.log"
+    old_file.parent.mkdir(parents=True, exist_ok=True)
+    old_file.write_text("old")
+    logger.archive_old_logs()
+    assert (log_dir / f"{old_file.name}.tar.gz").exists()
+
+
+def test_debug_mode(monkeypatch):
+    monkeypatch.delenv("DEBUG", raising=False)
+    assert not ChronicleLogger(logname="A").isDebug()
+    monkeypatch.setenv("DEBUG", "show")
+    assert ChronicleLogger(logname="B").isDebug()