kavach-logger 0.0.1__tar.gz

kavach_logger-0.0.1/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: kavach-logger
+Version: 0.0.1
+Summary: Centralized logging and masking for Kavach security suite
+Home-page: https://github.com/shivamnamdeo0101/kavach-agent-ecosystem
+Author: Shivam Namdeo
+Author-email: shivamnamdeo0101@gmail.com
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+# Kavach Logger
+
+Centralized logging with automatic sensitive data masking for security-critical applications.
+
+## Features
+
+✅ **Automatic Data Masking** - Detects and redacts API keys, tokens, PII, passwords, and other sensitive information  
+✅ **Pluggable Implementations** - Switch between masked/plain loggers or implement custom backends  
+✅ **Structured Logging** - JSON-compatible log output with **kwargs support  
+✅ **Singleton Logger Manager** - Unified logger lifecycle management  
+✅ **Zero Dependencies** - No external requirements
+
+## Installation
+
+```bash
+pip install kavach-logger
+```
+
+## Quick Start
+
+### Basic Usage - Auto-Masking
+
+```python
+from kavach_logger import get_logger
+
+# Creates a masked logger (auto-masks sensitive data)
+logger = get_logger("myapp")
+logger.info("API Key: sk-1234567890")  
+# Output: API Key: sk-***
+logger.error("Password: secret123")     
+# Output: Password: ***
+```
+
+### Plain Logger (No Masking)
+
+```python
+from kavach_logger import get_logger
+
+logger = get_logger("myapp", masked=False)
+logger.info("Debug: token=abc123")  
+# Output: Debug: token=abc123 (unmodified)
+```
+
+### Manual Data Masking
+
+```python
+from kavach_logger import mask_sensitive_data
+
+data = "credit_card=4532123456789012"
+masked = mask_sensitive_data(data)
+print(masked)  # credit_card=****
+```
+
+### Custom Logger Implementation
+
+```python
+from kavach_logger import BaseLogger, DefaultLogger
+
+class CustomLogger(DefaultLogger):
+    def info(self, msg, **kwargs):
+        msg = f"[CUSTOM] {msg}"
+        super().info(msg, **kwargs)
+
+custom = CustomLogger()
+custom.info("Custom implementation!")  
+# Output: [CUSTOM] Custom implementation!
+```
+
+### Logger Manager (Singleton)
+
+```python
+from kavach_logger import LoggerManager
+
+# Get or create logger
+logger1 = LoggerManager.get_logger("app", masked=True)
+logger2 = LoggerManager.get_logger("app")  # Returns same instance
+
+# Control all loggers
+LoggerManager.enable_all()
+LoggerManager.disable_all()
+LoggerManager.enable_masking()  # Enable masking globally
+LoggerManager.disable_masking()  # Disable masking globally
+```
+
+## API Reference
+
+### `get_logger(name: str, masked: bool = True) -> BaseLogger`
+Creates or retrieves a logger instance.
+
+**Parameters:**
+- `name` (str): Logger identifier
+- `masked` (bool): Enable automatic masking (default: True)
+
+**Returns:** `BaseLogger` instance
+
+### `mask_sensitive_data(text: str) -> str`
+Manually masks sensitive patterns in text.
+
+**Patterns Masked:**
+- API keys (sk-*, pk-*)
+- Bearer tokens
+- AWS credentials
+- Passwords
+- Credit card numbers
+- Social security numbers
+- Email addresses (partial)
+
+### Logger Methods
+
+```python
+logger.info(msg, **kwargs)      # Info level
+logger.error(msg, **kwargs)     # Error level
+logger.debug(msg, **kwargs)     # Debug level
+logger.warning(msg, **kwargs)   # Warning level
+```
+
+## Configuration
+
+### Global Masking Control
+
+```python
+from kavach_logger import LoggerManager
+
+# Disable masking for all loggers
+LoggerManager.disable_masking()
+
+# Re-enable masking
+LoggerManager.enable_masking()
+```
+
+## Examples
+
+### Logging with Structured Data
+
+```python
+logger = get_logger("security")
+
+logger.info(
+    "Security event detected",
+    event_type="login",
+    user_id="user123",
+    token="sk-abc123xyz"
+)
+# Automatically masks the token
+```
+
+### Processing Sensitive Logs
+
+```python
+from kavach_logger import mask_sensitive_data
+
+logs = [
+    "User created with password: MyPass123!",
+    "API call to https://api.example.com?token=abc123"
+]
+
+for log in logs:
+    safe_log = mask_sensitive_data(log)
+    print(safe_log)  # Safe to output/store
+```
+
+## Use Cases
+
+- **Security Auditing** - Track security events without exposing credentials
+- **PCI/HIPAA Compliance** - Automatic redaction for sensitive logs
+- **Agent Logging** - Mask AI-generated content containing API keys/tokens
+- **Production Debugging** - Safe log output in production environments
+
+## License
+
+MIT License

kavach_logger-0.0.1/README.md

@@ -0,0 +1,171 @@
+# Kavach Logger
+
+Centralized logging with automatic sensitive data masking for security-critical applications.
+
+## Features
+
+✅ **Automatic Data Masking** - Detects and redacts API keys, tokens, PII, passwords, and other sensitive information  
+✅ **Pluggable Implementations** - Switch between masked/plain loggers or implement custom backends  
+✅ **Structured Logging** - JSON-compatible log output with **kwargs support  
+✅ **Singleton Logger Manager** - Unified logger lifecycle management  
+✅ **Zero Dependencies** - No external requirements
+
+## Installation
+
+```bash
+pip install kavach-logger
+```
+
+## Quick Start
+
+### Basic Usage - Auto-Masking
+
+```python
+from kavach_logger import get_logger
+
+# Creates a masked logger (auto-masks sensitive data)
+logger = get_logger("myapp")
+logger.info("API Key: sk-1234567890")  
+# Output: API Key: sk-***
+logger.error("Password: secret123")     
+# Output: Password: ***
+```
+
+### Plain Logger (No Masking)
+
+```python
+from kavach_logger import get_logger
+
+logger = get_logger("myapp", masked=False)
+logger.info("Debug: token=abc123")  
+# Output: Debug: token=abc123 (unmodified)
+```
+
+### Manual Data Masking
+
+```python
+from kavach_logger import mask_sensitive_data
+
+data = "credit_card=4532123456789012"
+masked = mask_sensitive_data(data)
+print(masked)  # credit_card=****
+```
+
+### Custom Logger Implementation
+
+```python
+from kavach_logger import BaseLogger, DefaultLogger
+
+class CustomLogger(DefaultLogger):
+    def info(self, msg, **kwargs):
+        msg = f"[CUSTOM] {msg}"
+        super().info(msg, **kwargs)
+
+custom = CustomLogger()
+custom.info("Custom implementation!")  
+# Output: [CUSTOM] Custom implementation!
+```
+
+### Logger Manager (Singleton)
+
+```python
+from kavach_logger import LoggerManager
+
+# Get or create logger
+logger1 = LoggerManager.get_logger("app", masked=True)
+logger2 = LoggerManager.get_logger("app")  # Returns same instance
+
+# Control all loggers
+LoggerManager.enable_all()
+LoggerManager.disable_all()
+LoggerManager.enable_masking()  # Enable masking globally
+LoggerManager.disable_masking()  # Disable masking globally
+```
+
+## API Reference
+
+### `get_logger(name: str, masked: bool = True) -> BaseLogger`
+Creates or retrieves a logger instance.
+
+**Parameters:**
+- `name` (str): Logger identifier
+- `masked` (bool): Enable automatic masking (default: True)
+
+**Returns:** `BaseLogger` instance
+
+### `mask_sensitive_data(text: str) -> str`
+Manually masks sensitive patterns in text.
+
+**Patterns Masked:**
+- API keys (sk-*, pk-*)
+- Bearer tokens
+- AWS credentials
+- Passwords
+- Credit card numbers
+- Social security numbers
+- Email addresses (partial)
+
+### Logger Methods
+
+```python
+logger.info(msg, **kwargs)      # Info level
+logger.error(msg, **kwargs)     # Error level
+logger.debug(msg, **kwargs)     # Debug level
+logger.warning(msg, **kwargs)   # Warning level
+```
+
+## Configuration
+
+### Global Masking Control
+
+```python
+from kavach_logger import LoggerManager
+
+# Disable masking for all loggers
+LoggerManager.disable_masking()
+
+# Re-enable masking
+LoggerManager.enable_masking()
+```
+
+## Examples
+
+### Logging with Structured Data
+
+```python
+logger = get_logger("security")
+
+logger.info(
+    "Security event detected",
+    event_type="login",
+    user_id="user123",
+    token="sk-abc123xyz"
+)
+# Automatically masks the token
+```
+
+### Processing Sensitive Logs
+
+```python
+from kavach_logger import mask_sensitive_data
+
+logs = [
+    "User created with password: MyPass123!",
+    "API call to https://api.example.com?token=abc123"
+]
+
+for log in logs:
+    safe_log = mask_sensitive_data(log)
+    print(safe_log)  # Safe to output/store
+```
+
+## Use Cases
+
+- **Security Auditing** - Track security events without exposing credentials
+- **PCI/HIPAA Compliance** - Automatic redaction for sensitive logs
+- **Agent Logging** - Mask AI-generated content containing API keys/tokens
+- **Production Debugging** - Safe log output in production environments
+
+## License
+
+MIT License

kavach_logger-0.0.1/kavach_logger/__init__.py

@@ -0,0 +1,6 @@
+from .base_logger import BaseLogger
+from .default_logger import DefaultLogger, MaskedLogger
+from .logger_manager import LoggerManager, get_logger, set_custom_logger, mask_sensitive_data
+
+__version__ = "0.1.0"
+__all__ = ["BaseLogger", "DefaultLogger", "MaskedLogger", "LoggerManager", "get_logger", "set_custom_logger", "mask_sensitive_data"]

kavach_logger-0.0.1/kavach_logger/base_logger.py

@@ -0,0 +1,12 @@
+class BaseLogger:
+    def info(self, msg, **kwargs):
+        raise NotImplementedError
+
+    def error(self, msg, **kwargs):
+        raise NotImplementedError
+
+    def debug(self, msg, **kwargs):
+        raise NotImplementedError
+
+    def warning(self, msg, **kwargs):
+        raise NotImplementedError

kavach_logger-0.0.1/kavach_logger/default_logger.py

@@ -0,0 +1,66 @@
+import logging
+import re
+from .base_logger import BaseLogger
+
+class DefaultLogger(BaseLogger):
+    def __init__(self, name="kavach", level=logging.INFO):
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(level)
+        self.logger.propagate = False
+
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter("[%(levelname)s] %(asctime)s | %(message)s", datefmt="%H:%M:%S")
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+    def info(self, msg, **kwargs):
+        if kwargs:
+            msg = f"{msg} | {kwargs}"
+        self.logger.info(msg)
+
+    def error(self, msg, **kwargs):
+        if kwargs:
+            msg = f"{msg} | {kwargs}"
+        self.logger.error(msg)
+
+    def debug(self, msg, **kwargs):
+        if kwargs:
+            msg = f"{msg} | {kwargs}"
+        self.logger.debug(msg)
+
+    def warning(self, msg, **kwargs):
+        if kwargs:
+            msg = f"{msg} | {kwargs}"
+        self.logger.warning(msg)
+
+class MaskedLogger(DefaultLogger):
+    def __init__(self, name="kavach", level=logging.INFO, enable_masking=True):
+        super().__init__(name, level)
+        self.enable_masking = enable_masking
+
+    def _mask_sensitive(self, text: str) -> str:
+        if not self.enable_masking or not isinstance(text, str):
+            return text
+        text = re.sub(r'(AKIA|sk-|api[_-]?key)[^\s]{10,}', r'\1***', text, flags=re.I)
+        text = re.sub(r'(bearer|token)[=:\s]+[^\s]{10,}', r'\1 ***', text, flags=re.I)
+        text = re.sub(r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b', '****-****-****-****', text)
+        text = re.sub(r'(password|passwd)[=:\s]+[^\s,}]+', r'\1=***', text, flags=re.I)
+        text = re.sub(r'(access_key|secret)[=:\s]+[^\s,}]+', r'\1=***', text, flags=re.I)
+        return text
+
+    def info(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().info(msg, **kwargs)
+
+    def error(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().error(msg, **kwargs)
+
+    def debug(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().debug(msg, **kwargs)
+
+    def warning(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().warning(msg, **kwargs)

kavach_logger-0.0.1/kavach_logger/logger_manager.py

@@ -0,0 +1,51 @@
+from .base_logger import BaseLogger
+from .default_logger import DefaultLogger, MaskedLogger
+
+class LoggerManager:
+    _instance = None
+    _logger: BaseLogger = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(LoggerManager, cls).__new__(cls)
+        return cls._instance
+
+    def set_logger(self, logger: BaseLogger):
+        self._logger = logger
+
+    def get_logger(self, masked: bool = True):
+        if self._logger is None:
+            self._logger = MaskedLogger() if masked else DefaultLogger()
+        return self._logger
+
+_manager = LoggerManager()
+
+def get_logger(name: str = "kavach", masked: bool = True) -> BaseLogger:
+    """Get logger instance. Use masked=True for automatic sensitive data masking."""
+    logger = MaskedLogger(name) if masked else DefaultLogger(name)
+    return logger
+
+def set_custom_logger(logger: BaseLogger):
+    """Override default logger with custom implementation."""
+    _manager.set_logger(logger)
+
+def mask_sensitive_data(text: str) -> str:
+    """Utility to mask sensitive data."""
+    logger = MaskedLogger()
+    return logger._mask_sensitive(text)
+
+    def info(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().info(msg, **kwargs)
+
+    def error(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().error(msg, **kwargs)
+
+    def debug(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().debug(msg, **kwargs)
+
+    def warning(self, msg, **kwargs):
+        msg = self._mask_sensitive(str(msg))
+        super().warning(msg, **kwargs)

kavach_logger-0.0.1/kavach_logger/setup.py

@@ -0,0 +1,45 @@
+import logging
+import re
+
+_logging_enabled = True
+_masking_enabled = True
+
+class LoggingFilter(logging.Filter):
+    def filter(self, record):
+        return _logging_enabled
+
+def enable_logging(enabled: bool = True):
+    global _logging_enabled
+    _logging_enabled = enabled
+
+def enable_masking(enabled: bool = True):
+    global _masking_enabled
+    _masking_enabled = enabled
+
+def is_logging_enabled() -> bool:
+    return _logging_enabled
+
+def is_masking_enabled() -> bool:
+    return _masking_enabled
+
+def mask_sensitive_data(text: str) -> str:
+    if not _masking_enabled or not isinstance(text, str):
+        return text
+    text = re.sub(r'(AKIA|sk-|api[_-]?key)[^\s]{10,}', r'\1***', text, flags=re.I)
+    text = re.sub(r'(bearer|token)[=:\s]+[^\s]{10,}', r'\1 ***', text, flags=re.I)
+    text = re.sub(r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b', '****-****-****-****', text)
+    text = re.sub(r'(password|passwd)[=:\s]+[^\s,}]+', r'\1=***', text, flags=re.I)
+    text = re.sub(r'(access_key|secret)[=:\s]+[^\s,}]+', r'\1=***', text, flags=re.I)
+    return text
+
+def get_logger(name: str = "kavach") -> logging.Logger:
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+        logger.propagate = False
+        handler = logging.StreamHandler()
+        handler.addFilter(LoggingFilter())
+        formatter = logging.Formatter("[%(levelname)s] %(asctime)s | %(message)s", datefmt="%H:%M:%S")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    return logger

kavach_logger-0.0.1/kavach_logger.egg-info/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: kavach-logger
+Version: 0.0.1
+Summary: Centralized logging and masking for Kavach security suite
+Home-page: https://github.com/shivamnamdeo0101/kavach-agent-ecosystem
+Author: Shivam Namdeo
+Author-email: shivamnamdeo0101@gmail.com
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+# Kavach Logger
+
+Centralized logging with automatic sensitive data masking for security-critical applications.
+
+## Features
+
+✅ **Automatic Data Masking** - Detects and redacts API keys, tokens, PII, passwords, and other sensitive information  
+✅ **Pluggable Implementations** - Switch between masked/plain loggers or implement custom backends  
+✅ **Structured Logging** - JSON-compatible log output with **kwargs support  
+✅ **Singleton Logger Manager** - Unified logger lifecycle management  
+✅ **Zero Dependencies** - No external requirements
+
+## Installation
+
+```bash
+pip install kavach-logger
+```
+
+## Quick Start
+
+### Basic Usage - Auto-Masking
+
+```python
+from kavach_logger import get_logger
+
+# Creates a masked logger (auto-masks sensitive data)
+logger = get_logger("myapp")
+logger.info("API Key: sk-1234567890")  
+# Output: API Key: sk-***
+logger.error("Password: secret123")     
+# Output: Password: ***
+```
+
+### Plain Logger (No Masking)
+
+```python
+from kavach_logger import get_logger
+
+logger = get_logger("myapp", masked=False)
+logger.info("Debug: token=abc123")  
+# Output: Debug: token=abc123 (unmodified)
+```
+
+### Manual Data Masking
+
+```python
+from kavach_logger import mask_sensitive_data
+
+data = "credit_card=4532123456789012"
+masked = mask_sensitive_data(data)
+print(masked)  # credit_card=****
+```
+
+### Custom Logger Implementation
+
+```python
+from kavach_logger import BaseLogger, DefaultLogger
+
+class CustomLogger(DefaultLogger):
+    def info(self, msg, **kwargs):
+        msg = f"[CUSTOM] {msg}"
+        super().info(msg, **kwargs)
+
+custom = CustomLogger()
+custom.info("Custom implementation!")  
+# Output: [CUSTOM] Custom implementation!
+```
+
+### Logger Manager (Singleton)
+
+```python
+from kavach_logger import LoggerManager
+
+# Get or create logger
+logger1 = LoggerManager.get_logger("app", masked=True)
+logger2 = LoggerManager.get_logger("app")  # Returns same instance
+
+# Control all loggers
+LoggerManager.enable_all()
+LoggerManager.disable_all()
+LoggerManager.enable_masking()  # Enable masking globally
+LoggerManager.disable_masking()  # Disable masking globally
+```
+
+## API Reference
+
+### `get_logger(name: str, masked: bool = True) -> BaseLogger`
+Creates or retrieves a logger instance.
+
+**Parameters:**
+- `name` (str): Logger identifier
+- `masked` (bool): Enable automatic masking (default: True)
+
+**Returns:** `BaseLogger` instance
+
+### `mask_sensitive_data(text: str) -> str`
+Manually masks sensitive patterns in text.
+
+**Patterns Masked:**
+- API keys (sk-*, pk-*)
+- Bearer tokens
+- AWS credentials
+- Passwords
+- Credit card numbers
+- Social security numbers
+- Email addresses (partial)
+
+### Logger Methods
+
+```python
+logger.info(msg, **kwargs)      # Info level
+logger.error(msg, **kwargs)     # Error level
+logger.debug(msg, **kwargs)     # Debug level
+logger.warning(msg, **kwargs)   # Warning level
+```
+
+## Configuration
+
+### Global Masking Control
+
+```python
+from kavach_logger import LoggerManager
+
+# Disable masking for all loggers
+LoggerManager.disable_masking()
+
+# Re-enable masking
+LoggerManager.enable_masking()
+```
+
+## Examples
+
+### Logging with Structured Data
+
+```python
+logger = get_logger("security")
+
+logger.info(
+    "Security event detected",
+    event_type="login",
+    user_id="user123",
+    token="sk-abc123xyz"
+)
+# Automatically masks the token
+```
+
+### Processing Sensitive Logs
+
+```python
+from kavach_logger import mask_sensitive_data
+
+logs = [
+    "User created with password: MyPass123!",
+    "API call to https://api.example.com?token=abc123"
+]
+
+for log in logs:
+    safe_log = mask_sensitive_data(log)
+    print(safe_log)  # Safe to output/store
+```
+
+## Use Cases
+
+- **Security Auditing** - Track security events without exposing credentials
+- **PCI/HIPAA Compliance** - Automatic redaction for sensitive logs
+- **Agent Logging** - Mask AI-generated content containing API keys/tokens
+- **Production Debugging** - Safe log output in production environments
+
+## License
+
+MIT License

kavach_logger-0.0.1/kavach_logger.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+kavach_logger/__init__.py
+kavach_logger/base_logger.py
+kavach_logger/default_logger.py
+kavach_logger/logger_manager.py
+kavach_logger/setup.py
+kavach_logger.egg-info/PKG-INFO
+kavach_logger.egg-info/SOURCES.txt
+kavach_logger.egg-info/dependency_links.txt
+kavach_logger.egg-info/top_level.txt

kavach_logger-0.0.1/kavach_logger.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kavach_logger-0.0.1/kavach_logger.egg-info/top_level.txt

@@ -0,0 +1 @@
+kavach_logger

kavach_logger-0.0.1/setup.cfg

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

kavach_logger-0.0.1/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="kavach-logger",
+    version="0.0.1",
+    description="Centralized logging and masking for Kavach security suite",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Shivam Namdeo",
+    author_email="shivamnamdeo0101@gmail.com",
+    url="https://github.com/shivamnamdeo0101/kavach-agent-ecosystem",
+    license="MIT",
+    packages=find_packages(),
+    python_requires=">=3.7",
+    install_requires=[],
+)