hd-logging 1.0.2__tar.gz

hd_logging-1.0.2/PKG-INFO

@@ -0,0 +1,342 @@
+Metadata-Version: 2.3
+Name: hd-logging
+Version: 1.0.2
+Summary: A comprehensive logging library with OpenTelemetry support, environment variable handling, and advanced log rotation
+Keywords: logging,opentelemetry,environment,rotation
+Author: Hackerdogs.ai
+Author-email: Hackerdogs.ai <support@hackerdogs.ai>
+License: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: colorlog>=6.9.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: python-ulid>=1.1.0
+Requires-Dist: typing-extensions>=4.13.2
+Requires-Dist: pytest>=7.0.0 ; extra == 'dev'
+Requires-Dist: black>=23.0.0 ; extra == 'dev'
+Requires-Dist: flake8>=6.0.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0.0 ; extra == 'dev'
+Requires-Python: >=3.8.1
+Project-URL: Homepage, https://github.com/tejaswiredkar/hd-logging
+Project-URL: Issues, https://github.com/tejaswiredkar/hd-logging/issues
+Project-URL: Repository, https://github.com/tejaswiredkar/hd-logging
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# HD Logging
+
+A comprehensive Python logging library with OpenTelemetry support, environment variable handling, and advanced log rotation capabilities.
+
+## Features
+
+- 🎨 **Colorized Console Output** - Beautiful, color-coded log messages
+- 📊 **OpenTelemetry Integration** - JSON format logging with rich metadata
+- 🔒 **Environment Variable Security** - Automatic sensitive data masking
+- 📁 **Advanced Log Rotation** - Size and time-based rotation with compression
+- ⚙️ **Flexible Configuration** - Environment variables and programmatic setup
+- 🚀 **High Performance** - Optimized for production workloads
+- 🔧 **Easy Integration** - Simple setup with powerful features
+
+## Installation
+
+### Using pip
+```bash
+pip install hd-logging
+```
+
+### Using uv (recommended)
+```bash
+uv add hd-logging
+```
+
+### Development Installation
+```bash
+git clone https://github.com/tejaswiredkar/hd-logging.git
+cd hd-logging
+uv sync
+uv pip install -e .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from hd_logging import setup_logger
+
+# Create a logger with default settings
+logger = setup_logger("my_app")
+
+# Log messages
+logger.info("Application started")
+logger.warning("This is a warning")
+logger.error("An error occurred")
+```
+
+### OpenTelemetry Format
+
+```python
+from hd_logging import setup_logger
+
+# Create a logger with OpenTelemetry JSON format
+logger = setup_logger(
+    "my_service",
+    use_otlp_format=True,
+    service_name="my-service",
+    environment="production",
+    service_version="1.0.0",
+    log_file_path="logs/service.log"
+)
+
+# Log with custom attributes
+logger.info("User action performed", extra={
+    "user_id": "12345",
+    "action": "login",
+    "ip_address": "192.168.1.1"
+})
+```
+
+### Environment Variable Integration
+
+```python
+from hd_logging import setup_logger, load_env_file
+
+# Load environment variables from .env file
+load_env_file()
+
+# Logger will automatically use environment variables
+logger = setup_logger("env_configured")
+```
+
+## Configuration
+
+### Environment Variables
+
+The library supports configuration through environment variables:
+
+```bash
+# Log levels
+LOG_LEVEL=INFO                    # Console and file log level
+LOG_FILE_OTLP_FORMAT=true         # Enable OpenTelemetry format
+
+# Service information
+SERVICE_NAME=my-service           # Service name for OTLP logs
+ENVIRONMENT=production            # Environment name
+SERVICE_VERSION=1.0.0            # Service version
+
+# Log file settings
+LOG_FILE=logs/app.log             # Log file path
+```
+
+### Programmatic Configuration
+
+```python
+from hd_logging import setup_logger
+import logging
+
+logger = setup_logger(
+    logger_name="my_app",
+    log_file_path="logs/app.log",
+    log_level_console=logging.INFO,
+    log_level_files=logging.DEBUG,
+    use_otlp_format=True,
+    service_name="my-service",
+    environment="production",
+    service_version="1.0.0"
+)
+```
+
+## Advanced Features
+
+### Log Rotation
+
+The library includes advanced log rotation with both size and time-based rotation:
+
+```python
+# Automatic rotation when:
+# - File size exceeds 20MB (configurable)
+# - Daily rotation at midnight
+# - Automatic compression of rotated files
+# - Retention of 7 days (configurable)
+```
+
+### Sensitive Data Masking
+
+Automatic masking of sensitive environment variables:
+
+```python
+from hd_logging import log_env_vars_with_masking
+
+# Logs environment variables with sensitive data masked
+log_env_vars_with_masking()
+```
+
+### Custom Attributes
+
+Add rich metadata to your logs:
+
+```python
+logger.info("Order processed", extra={
+    "order_id": "ORD-12345",
+    "customer_id": "CUST-67890",
+    "amount": 99.99,
+    "currency": "USD",
+    "payment_method": "credit_card"
+})
+```
+
+## Examples
+
+See the `examples/` directory for comprehensive usage examples:
+
+- [Basic Usage](examples/basic_usage.py) - Simple logging setup
+- [OpenTelemetry Usage](examples/opentelemetry_usage.py) - JSON format logging
+- [Environment Variables](examples/environment_usage.py) - Environment handling
+- [Advanced Features](examples/advanced_usage.py) - Advanced logging scenarios
+- [Web Application](examples/web_application_example.py) - Web app integration
+
+Run examples:
+```bash
+python examples/basic_usage.py
+python examples/opentelemetry_usage.py
+# ... and more
+```
+
+## API Reference
+
+### setup_logger()
+
+```python
+def setup_logger(
+    logger_name: str,
+    log_file_path: Optional[str] = None,
+    log_level_console: Optional[int] = None,
+    log_level_files: Optional[int] = None,
+    use_otlp_format: bool = None,
+    service_name: Optional[str] = None,
+    environment: Optional[str] = None,
+    service_version: Optional[str] = None
+) -> logging.Logger
+```
+
+**Parameters:**
+- `logger_name`: Name of the logger
+- `log_file_path`: Path to log file (default: from LOG_FILE env var)
+- `log_level_console`: Console log level (default: from LOG_LEVEL env var)
+- `log_level_files`: File log level (default: from LOG_LEVEL env var)
+- `use_otlp_format`: Enable OpenTelemetry format (default: from LOG_FILE_OTLP_FORMAT env var)
+- `service_name`: Service name for OTLP logs (default: from SERVICE_NAME env var)
+- `environment`: Environment name (default: from ENVIRONMENT env var)
+- `service_version`: Service version (default: from SERVICE_VERSION env var)
+
+### Environment Variable Functions
+
+```python
+from hd_logging import (
+    load_env_file,           # Load .env file
+    find_env_file,           # Find .env file path
+    get_env_file_path,       # Get .env file path
+    log_env_vars_with_masking,  # Log env vars with masking
+    log_dotenv_vars_with_masking,  # Log .env vars with masking
+    get_env_vars_with_masking,    # Get env vars with masking
+    get_dotenv_vars_with_masking  # Get .env vars with masking
+)
+```
+
+## Log Formats
+
+### Standard Format
+```
+2024-01-15T10:30:45Z - my_app - INFO - Application started - [Component: main, Function: main, Line: 15]
+```
+
+### OpenTelemetry JSON Format
+```json
+{
+  "timestamp": "2024-01-15T10:30:45.123456Z",
+  "severityText": "INFO",
+  "body": "Application started",
+  "attributes": {
+    "service.name": "my-service",
+    "environment": "production",
+    "logger.name": "my_app",
+    "component": "main",
+    "function": "main",
+    "line": 15
+  },
+  "resource": {
+    "host.name": "server-01",
+    "os.type": "linux",
+    "service.name": "my-service",
+    "service.version": "1.0.0",
+    "service.instance.id": "01HZ1234567890ABCDEF",
+    "environment": "production"
+  }
+}
+```
+
+## Requirements
+
+- Python 3.8+
+- colorlog >= 6.9.0
+- python-dotenv >= 1.0.0
+- ulid-py >= 1.1.0
+
+## Development
+
+### Setup Development Environment
+
+```bash
+git clone https://github.com/tejaswiredkar/hd-logging.git
+cd hd-logging
+uv sync
+```
+
+### Run Tests
+
+```bash
+uv run pytest
+```
+
+### Code Formatting
+
+```bash
+uv run black src/
+uv run flake8 src/
+uv run mypy src/
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Run the test suite
+6. Submit a pull request
+
+## License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.
+
+## Support
+
+- 📧 Email: support@hackerdogs.ai
+- 🐛 Issues: [GitHub Issues](https://github.com/tejaswiredkar/hd-logging/issues)
+- 📖 Documentation: [GitHub Wiki](https://github.com/tejaswiredkar/hd-logging/wiki)
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a history of changes.
+
+---
+
+Made with ❤️ by [Hackerdogs.ai](https://hackerdogs.ai)

hd_logging-1.0.2/README.md

@@ -0,0 +1,309 @@
+# HD Logging
+
+A comprehensive Python logging library with OpenTelemetry support, environment variable handling, and advanced log rotation capabilities.
+
+## Features
+
+- 🎨 **Colorized Console Output** - Beautiful, color-coded log messages
+- 📊 **OpenTelemetry Integration** - JSON format logging with rich metadata
+- 🔒 **Environment Variable Security** - Automatic sensitive data masking
+- 📁 **Advanced Log Rotation** - Size and time-based rotation with compression
+- ⚙️ **Flexible Configuration** - Environment variables and programmatic setup
+- 🚀 **High Performance** - Optimized for production workloads
+- 🔧 **Easy Integration** - Simple setup with powerful features
+
+## Installation
+
+### Using pip
+```bash
+pip install hd-logging
+```
+
+### Using uv (recommended)
+```bash
+uv add hd-logging
+```
+
+### Development Installation
+```bash
+git clone https://github.com/tejaswiredkar/hd-logging.git
+cd hd-logging
+uv sync
+uv pip install -e .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from hd_logging import setup_logger
+
+# Create a logger with default settings
+logger = setup_logger("my_app")
+
+# Log messages
+logger.info("Application started")
+logger.warning("This is a warning")
+logger.error("An error occurred")
+```
+
+### OpenTelemetry Format
+
+```python
+from hd_logging import setup_logger
+
+# Create a logger with OpenTelemetry JSON format
+logger = setup_logger(
+    "my_service",
+    use_otlp_format=True,
+    service_name="my-service",
+    environment="production",
+    service_version="1.0.0",
+    log_file_path="logs/service.log"
+)
+
+# Log with custom attributes
+logger.info("User action performed", extra={
+    "user_id": "12345",
+    "action": "login",
+    "ip_address": "192.168.1.1"
+})
+```
+
+### Environment Variable Integration
+
+```python
+from hd_logging import setup_logger, load_env_file
+
+# Load environment variables from .env file
+load_env_file()
+
+# Logger will automatically use environment variables
+logger = setup_logger("env_configured")
+```
+
+## Configuration
+
+### Environment Variables
+
+The library supports configuration through environment variables:
+
+```bash
+# Log levels
+LOG_LEVEL=INFO                    # Console and file log level
+LOG_FILE_OTLP_FORMAT=true         # Enable OpenTelemetry format
+
+# Service information
+SERVICE_NAME=my-service           # Service name for OTLP logs
+ENVIRONMENT=production            # Environment name
+SERVICE_VERSION=1.0.0            # Service version
+
+# Log file settings
+LOG_FILE=logs/app.log             # Log file path
+```
+
+### Programmatic Configuration
+
+```python
+from hd_logging import setup_logger
+import logging
+
+logger = setup_logger(
+    logger_name="my_app",
+    log_file_path="logs/app.log",
+    log_level_console=logging.INFO,
+    log_level_files=logging.DEBUG,
+    use_otlp_format=True,
+    service_name="my-service",
+    environment="production",
+    service_version="1.0.0"
+)
+```
+
+## Advanced Features
+
+### Log Rotation
+
+The library includes advanced log rotation with both size and time-based rotation:
+
+```python
+# Automatic rotation when:
+# - File size exceeds 20MB (configurable)
+# - Daily rotation at midnight
+# - Automatic compression of rotated files
+# - Retention of 7 days (configurable)
+```
+
+### Sensitive Data Masking
+
+Automatic masking of sensitive environment variables:
+
+```python
+from hd_logging import log_env_vars_with_masking
+
+# Logs environment variables with sensitive data masked
+log_env_vars_with_masking()
+```
+
+### Custom Attributes
+
+Add rich metadata to your logs:
+
+```python
+logger.info("Order processed", extra={
+    "order_id": "ORD-12345",
+    "customer_id": "CUST-67890",
+    "amount": 99.99,
+    "currency": "USD",
+    "payment_method": "credit_card"
+})
+```
+
+## Examples
+
+See the `examples/` directory for comprehensive usage examples:
+
+- [Basic Usage](examples/basic_usage.py) - Simple logging setup
+- [OpenTelemetry Usage](examples/opentelemetry_usage.py) - JSON format logging
+- [Environment Variables](examples/environment_usage.py) - Environment handling
+- [Advanced Features](examples/advanced_usage.py) - Advanced logging scenarios
+- [Web Application](examples/web_application_example.py) - Web app integration
+
+Run examples:
+```bash
+python examples/basic_usage.py
+python examples/opentelemetry_usage.py
+# ... and more
+```
+
+## API Reference
+
+### setup_logger()
+
+```python
+def setup_logger(
+    logger_name: str,
+    log_file_path: Optional[str] = None,
+    log_level_console: Optional[int] = None,
+    log_level_files: Optional[int] = None,
+    use_otlp_format: bool = None,
+    service_name: Optional[str] = None,
+    environment: Optional[str] = None,
+    service_version: Optional[str] = None
+) -> logging.Logger
+```
+
+**Parameters:**
+- `logger_name`: Name of the logger
+- `log_file_path`: Path to log file (default: from LOG_FILE env var)
+- `log_level_console`: Console log level (default: from LOG_LEVEL env var)
+- `log_level_files`: File log level (default: from LOG_LEVEL env var)
+- `use_otlp_format`: Enable OpenTelemetry format (default: from LOG_FILE_OTLP_FORMAT env var)
+- `service_name`: Service name for OTLP logs (default: from SERVICE_NAME env var)
+- `environment`: Environment name (default: from ENVIRONMENT env var)
+- `service_version`: Service version (default: from SERVICE_VERSION env var)
+
+### Environment Variable Functions
+
+```python
+from hd_logging import (
+    load_env_file,           # Load .env file
+    find_env_file,           # Find .env file path
+    get_env_file_path,       # Get .env file path
+    log_env_vars_with_masking,  # Log env vars with masking
+    log_dotenv_vars_with_masking,  # Log .env vars with masking
+    get_env_vars_with_masking,    # Get env vars with masking
+    get_dotenv_vars_with_masking  # Get .env vars with masking
+)
+```
+
+## Log Formats
+
+### Standard Format
+```
+2024-01-15T10:30:45Z - my_app - INFO - Application started - [Component: main, Function: main, Line: 15]
+```
+
+### OpenTelemetry JSON Format
+```json
+{
+  "timestamp": "2024-01-15T10:30:45.123456Z",
+  "severityText": "INFO",
+  "body": "Application started",
+  "attributes": {
+    "service.name": "my-service",
+    "environment": "production",
+    "logger.name": "my_app",
+    "component": "main",
+    "function": "main",
+    "line": 15
+  },
+  "resource": {
+    "host.name": "server-01",
+    "os.type": "linux",
+    "service.name": "my-service",
+    "service.version": "1.0.0",
+    "service.instance.id": "01HZ1234567890ABCDEF",
+    "environment": "production"
+  }
+}
+```
+
+## Requirements
+
+- Python 3.8+
+- colorlog >= 6.9.0
+- python-dotenv >= 1.0.0
+- ulid-py >= 1.1.0
+
+## Development
+
+### Setup Development Environment
+
+```bash
+git clone https://github.com/tejaswiredkar/hd-logging.git
+cd hd-logging
+uv sync
+```
+
+### Run Tests
+
+```bash
+uv run pytest
+```
+
+### Code Formatting
+
+```bash
+uv run black src/
+uv run flake8 src/
+uv run mypy src/
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Run the test suite
+6. Submit a pull request
+
+## License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.
+
+## Support
+
+- 📧 Email: support@hackerdogs.ai
+- 🐛 Issues: [GitHub Issues](https://github.com/tejaswiredkar/hd-logging/issues)
+- 📖 Documentation: [GitHub Wiki](https://github.com/tejaswiredkar/hd-logging/wiki)
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a history of changes.
+
+---
+
+Made with ❤️ by [Hackerdogs.ai](https://hackerdogs.ai)

hd_logging-1.0.2/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "hd-logging"
+version = "1.0.2"
+description = "A comprehensive logging library with OpenTelemetry support, environment variable handling, and advanced log rotation"
+readme = "README.md"
+authors = [
+    { name = "Hackerdogs.ai", email = "support@hackerdogs.ai" }
+]
+license = { text = "Apache-2.0" }
+requires-python = ">=3.8.1"
+keywords = ["logging", "opentelemetry", "environment", "rotation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "colorlog>=6.9.0",
+    "python-dotenv>=1.0.0",
+    "python-ulid>=1.1.0",
+    "typing-extensions>=4.13.2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "black>=23.0.0",
+    "flake8>=6.0.0",
+    "mypy>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/tejaswiredkar/hd-logging"
+Repository = "https://github.com/tejaswiredkar/hd-logging"
+Issues = "https://github.com/tejaswiredkar/hd-logging/issues"
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"

hd_logging-1.0.2/src/hd_logging/SizeAndTimeLoggingHandler.py

@@ -0,0 +1,119 @@
+"""
+Size and Time Rotating Logging Handler with Compression
+Custom logging handler that rotates logs based on both size and time, with automatic compression.
+Supports both plain text and OpenTelemetry JSON formats.
+"""
+
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+import colorlog
+import time
+import os
+import sys
+import gzip
+from hd_logging.otlp_formatter import OpenTelemetryFormatter
+
+# Reference: https://stackoverflow.com/questions/29602352/how-to-mix-logging-handlers-file-timed-and-compress-log-in-the-same-config-f
+class SizeAndTimeLoggingHandler(TimedRotatingFileHandler):
+    """ My rotating file hander to compress rotated file """
+    def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None,
+                 delay=0, when='h', interval=1, utc=False, use_otlp_format=False, 
+                 service_name=None, environment=None, service_version=None):
+        if maxBytes > 0:
+            mode = 'a'
+        TimedRotatingFileHandler.__init__(
+            self, filename, when, interval, backupCount, encoding, delay, utc)
+        self.maxBytes = maxBytes
+        self.backupCount = backupCount
+        
+        # OpenTelemetry format support
+        self.use_otlp_format = use_otlp_format
+        if use_otlp_format:
+            from hd_logging.otlp_formatter import OpenTelemetryFormatter
+            self.formatter = OpenTelemetryFormatter(
+                service_name=service_name or "hd_logging",
+                environment=environment or "development",
+                service_version=service_version or "1.0.0"
+            )
+
+    def shouldRollover(self, record):
+        """ Determine if rollover should occur. """
+        # Check rollover by size
+        if self.stream is None:                 # delay was set...
+            self.stream = self._open()
+        if self.maxBytes > 0:                   # are we rolling over?
+            try:
+                msg = "%s\n" % self.format(record)
+                # Handle case where file was rotated/deleted by another process
+                # (common in multiprocessing with fork())
+                try:
+                    self.stream.seek(0, 2)  #due to non-posix-compliant Windows feature
+                    current_size = self.stream.tell()
+                except (OSError, IOError, ValueError) as e:
+                    # File was rotated/deleted by another process, reopen it
+                    # This prevents FileNotFoundError in multiprocessing scenarios
+                    try:
+                        self.stream.close()
+                    except Exception:
+                        pass
+                    self.stream = self._open()
+                    self.stream.seek(0, 2)
+                    current_size = self.stream.tell()
+                
+                if current_size + len(msg) >= self.maxBytes:
+                    return 1
+            except Exception as e:
+                # If format() or stream operations fail, don't rollover
+                # Log to stderr as fallback (can't use logger here - recursion risk)
+                try:
+                    print(f"WARNING: shouldRollover failed: {type(e).__name__}: {e}", file=sys.stderr)
+                except Exception:
+                    pass
+                # Return 0 to prevent rollover on error
+                return 0
+        # Check rollover by time
+        t = int(time.time())
+        if t >= self.rolloverAt:
+            return 1
+        return 0
+
+    def emit(self, record):
+        """
+        Emit a record with error handling to prevent logging failures from crashing the application.
+        
+        This wraps the parent emit() method to catch and handle exceptions that might occur
+        during formatting, file writing, or rotation. If an error occurs, it falls back to
+        stderr to ensure the error is visible without causing recursion.
+        """
+        try:
+            super().emit(record)
+        except Exception as e:
+            # If logging fails, write to stderr as fallback to prevent recursion
+            # This prevents the logging error handler from trying to log the error,
+            # which could cause infinite recursion if the handler itself is broken
+            try:
+                print(f"Logging handler error: {type(e).__name__}: {e}", file=sys.stderr)
+                print(f"Failed to log record: {record.getMessage()}", file=sys.stderr)
+            except Exception:
+                # Even stderr write failed - use absolute last resort
+                pass
+            # Don't re-raise - we've handled the error, don't let it propagate
+
+    def rotate(self, source, dest):
+        """ Compress rotated log file with error handling """
+        try:
+            os.rename(source, dest)
+            with open(dest, 'rb') as f_in:
+                with gzip.open("%s.gz" % dest, 'wb') as f_out:
+                    f_out.writelines(f_in)
+            os.remove(dest)
+        except Exception as e:
+            # If rotation fails, log to stderr and continue
+            # Don't let rotation failures break logging
+            try:
+                print(f"Log rotation error: {type(e).__name__}: {e}", file=sys.stderr)
+                print(f"Source: {source}, Dest: {dest}", file=sys.stderr)
+            except Exception:
+                pass
+            # Re-raise to let the handler know rotation failed
+            # The handler should handle this gracefully
+            raise

hd_logging-1.0.2/src/hd_logging/__init__.py

@@ -0,0 +1,40 @@
+"""
+HD Logging - A comprehensive logging library with OpenTelemetry support.
+
+This package provides advanced logging capabilities including:
+- Colorized console output
+- OpenTelemetry JSON format support
+- Environment variable handling with sensitive data masking
+- Advanced log rotation with compression
+- Size and time-based log rotation
+"""
+
+from .logger import setup_logger
+from .env_loader import load_env_file, find_env_file, get_env_file_path
+from .env_print import (
+    get_env_vars_with_masking,
+    log_env_vars_with_masking,
+    log_dotenv_vars_with_masking,
+    get_dotenv_vars_with_masking,
+    env_print
+)
+from .otlp_formatter import OpenTelemetryFormatter
+from .SizeAndTimeLoggingHandler import SizeAndTimeLoggingHandler
+
+__version__ = "1.0.2"
+__author__ = "Hackerdogs.ai"
+__email__ = "support@hackerdogs.ai"
+
+__all__ = [
+    "setup_logger",
+    "load_env_file",
+    "find_env_file", 
+    "get_env_file_path",
+    "get_env_vars_with_masking",
+    "log_env_vars_with_masking",
+    "log_dotenv_vars_with_masking",
+    "get_dotenv_vars_with_masking",
+    "env_print",
+    "OpenTelemetryFormatter",
+    "SizeAndTimeLoggingHandler",
+]

hd_logging-1.0.2/src/hd_logging/env_loader.py

@@ -0,0 +1,92 @@
+"""
+Environment File Loader
+Simple utility to find and load .env files from common locations.
+"""
+
+import os
+import glob
+from pathlib import Path
+from typing import Optional
+
+
+def find_env_file(start_path: Optional[str] = None) -> Optional[Path]:
+    """
+    Find .env file in common locations using glob patterns.
+    
+    Searches in:
+    1. Current directory
+    2. One level up
+    3. Two levels up
+    
+    Args:
+        start_path: Starting directory path (defaults to current working directory)
+        
+    Returns:
+        Path to .env file if found, None otherwise
+    """
+    if start_path is None:
+        start_path = os.getcwd()
+    
+    # Convert to Path object for easier manipulation
+    start = Path(start_path).resolve()
+    
+    # Search patterns: current dir, 1 level up, 2 levels up
+    search_paths = [
+        start,                    # Current directory
+        start.parent,            # One level up
+        start.parent.parent,     # Two levels up
+    ]
+    
+    # Use glob to search for .env files in each directory
+    for search_path in search_paths:
+        if search_path.exists():
+            # Use glob to find .env files in this directory
+            env_files = glob.glob(str(search_path / ".env"))
+            if env_files:
+                return Path(env_files[0])  # Return the first .env file found
+    
+    return None
+
+
+def load_env_file(start_path: Optional[str] = None, override: bool = True) -> bool:
+    """
+    Find and load .env file from common locations.
+    
+    Args:
+        start_path: Starting directory path (defaults to current working directory)
+        override: Whether to override existing environment variables
+        
+    Returns:
+        True if .env file was found and loaded, False otherwise
+    """
+    try:
+        from dotenv import load_dotenv
+        
+        env_file = find_env_file(start_path)
+        
+        if env_file:
+            load_dotenv(env_file, override=override)
+            return True
+        else:
+            # Fallback to default behavior
+            load_dotenv(override=override)
+            return False
+            
+    except ImportError:
+        print("Warning: python-dotenv not installed. Using system environment variables only.")
+        print("Install with: pip install python-dotenv")
+        return False
+
+
+def get_env_file_path(start_path: Optional[str] = None) -> Optional[str]:
+    """
+    Get the path to the .env file that would be loaded.
+    
+    Args:
+        start_path: Starting directory path (defaults to current working directory)
+        
+    Returns:
+        String path to .env file if found, None otherwise
+    """
+    env_file = find_env_file(start_path)
+    return str(env_file) if env_file else None

hd_logging-1.0.2/src/hd_logging/env_print.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+Environment Variable Logger Module
+Simple functions to return and log environment variables with sensitive data masking.
+"""
+
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Dict, Any
+from dotenv import dotenv_values, find_dotenv
+
+# Add the project root to the Python path
+try:
+    project_root = Path(__file__).parent.parent
+    sys.path.append(str(project_root))
+except Exception as e:
+    print(f"❌ Error setting up project path: {e}")
+
+# Logger setup with fallback
+try:
+    from hd_logging.logger import setup_logger
+    logger = setup_logger(__name__, log_file_path="logs/env_print.log")
+except Exception as e:
+    print(f"❌ Error setting up logger: {e}")
+    # Fallback to basic logging
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+def mask_sensitive_value(value: str, show_chars: int = 2) -> str:
+    """Mask sensitive values by showing only the first few characters."""
+    try:
+        if not value or len(value) <= show_chars:
+            return "*" * len(value) if value else ""
+        return value[:show_chars] + "*" * (len(value) - show_chars)
+    except Exception as e:
+        logger.error(f"❌ Error masking value: {e}")
+        return "***ERROR***"
+
+def is_sensitive_variable(var_name: str) -> bool:
+    """Check if an environment variable name contains sensitive keywords."""
+    try:
+        if not var_name:
+            return True
+        sensitive_patterns = ['_KEY', 'DATABASE_URL', 'PASSWORD', 'SECRET']
+        var_name_upper = var_name.upper()
+        return any(pattern in var_name_upper for pattern in sensitive_patterns)
+    except Exception as e:
+        logger.error(f"❌ Error checking variable sensitivity: {e}")
+        return True
+
+def get_env_vars_with_masking() -> Dict[str, Any]:
+    """
+    Function 1: Return all environment variables with sensitive values masked.
+    
+    Returns:
+        Dictionary with all environment variables, sensitive ones masked
+    """
+    try:
+        env_vars = {}
+        all_env_vars = dict(os.environ)
+        
+        for var_name, var_value in all_env_vars.items():
+            if is_sensitive_variable(var_name):
+                env_vars[var_name] = mask_sensitive_value(var_value)
+            else:
+                env_vars[var_name] = var_value
+        
+        return env_vars
+    except Exception as e:
+        logger.error(f"❌ Error getting environment variables: {e}")
+        return {}
+
+def log_env_vars_with_masking():
+    """
+    Function 2: Log all environment variables with sensitive data masked.
+    """
+    try:
+        logger.info("🔍 Logging all environment variables with sensitive data masked...")
+        
+        env_vars = get_env_vars_with_masking()
+        sensitive_count = 0
+        regular_count = 0
+        
+        for var_name, var_value in env_vars.items():
+            if is_sensitive_variable(var_name):
+                sensitive_count += 1
+                logger.info(f"🔐 {var_name} = {var_value}")
+            else:
+                regular_count += 1
+                logger.info(f"📋 {var_name} = {var_value}")
+        
+        logger.info(f"📊 Summary: {sensitive_count} sensitive, {regular_count} regular, {len(env_vars)} total")
+        logger.info("✅ Environment variable logging completed")
+        
+    except Exception as e:
+        logger.error(f"❌ Error logging environment variables: {e}")
+
+def log_dotenv_vars_with_masking():
+    """
+    Function 3: Load, log, and mask variables from a .env file.
+    """
+    try:
+        dotenv_path = find_dotenv()
+        logger.info(f"🔍 Searching for .env file...")
+
+        if not dotenv_path:
+            logger.warning("⚠️  .env file not found in current directory or parent directories.")
+            return
+
+        logger.info(f"📄 Found and reading variables from: {dotenv_path}")
+        dotenv_vars = dotenv_values(dotenv_path)
+        
+        if not dotenv_vars:
+            logger.info("✅ .env file is empty or could not be parsed.")
+            return
+
+        logger.info(f"📄 Logging {len(dotenv_vars)} variables from .env file...")
+        sensitive_count = 0
+        regular_count = 0
+
+        for var_name, var_value in dotenv_vars.items():
+            if is_sensitive_variable(var_name):
+                sensitive_count += 1
+                logger.info(f"🔐 {var_name} = {mask_sensitive_value(var_value)}")
+            else:
+                regular_count += 1
+                logger.info(f"📋 {var_name} = {var_value}")
+        
+        logger.info(f"📊 Summary: {sensitive_count} sensitive, {regular_count} regular, {len(dotenv_vars)} total from .env")
+        logger.info("✅ .env file logging completed")
+
+    except Exception as e:
+        logger.error(f"❌ Error logging variables from .env file: {e}")
+
+def get_dotenv_vars_with_masking() -> Dict[str, Any]:
+    """
+    Function 4: Return all variables from a .env file with sensitive values masked.
+
+    Returns:
+        Dictionary with all .env variables, sensitive ones masked
+    """
+    try:
+        dotenv_path = find_dotenv()
+        if not dotenv_path:
+            logger.warning("⚠️  .env file not found by find_dotenv() for get_dotenv_vars_with_masking.")
+            return {}
+
+        dotenv_vars = dotenv_values(dotenv_path)
+        if not dotenv_vars:
+            return {}
+
+        masked_vars = {}
+        for var_name, var_value in dotenv_vars.items():
+            if is_sensitive_variable(var_name):
+                masked_vars[var_name] = mask_sensitive_value(var_value)
+            else:
+                masked_vars[var_name] = var_value
+        
+        return masked_vars
+
+    except Exception as e:
+        logger.error(f"❌ Error getting variables from .env file: {e}")
+        return {}
+
+# Convenience aliases
+env_print = log_env_vars_with_masking
+
+if __name__ == "__main__":
+    # Example usage
+    print("🔍 Environment Variable Logger - Simple Usage")
+    print("=" * 50)
+    
+    # Function 1: Get all env vars with masking
+    print("\n1. Getting all environment variables with masking:")
+    env_vars = get_env_vars_with_masking()
+    print(f"   Found {len(env_vars)} environment variables")
+    
+    # Function 2: Log all env vars with masking
+    print("\n2. Logging all environment variables with masking:")
+    log_env_vars_with_masking()
+    
+    # Function 3: Log all .env vars with masking
+    print("\n3. Logging all variables from .env file with masking:")
+    log_dotenv_vars_with_masking()
+
+    # Function 4: Get all .env vars with masking
+    print("\n4. Getting all variables from .env file with masking:")
+    dotenv_vars_masked = get_dotenv_vars_with_masking()
+    print(f"   Found {len(dotenv_vars_masked)} variables in .env file")
+
+    print("\n✅ Example completed")

hd_logging-1.0.2/src/hd_logging/logger.py

@@ -0,0 +1,113 @@
+import logging
+import os
+from typing import Optional
+import colorlog
+from hd_logging.SizeAndTimeLoggingHandler import SizeAndTimeLoggingHandler as STLH
+import time
+
+def setup_logger(
+    logger_name: str,
+    log_file_path: Optional[str] = None,
+    log_level_console: Optional[int] = None,
+    log_level_files: Optional[int] = None,
+    use_otlp_format: bool = None,
+    service_name: Optional[str] = None,
+    environment: Optional[str] = None,
+    service_version: Optional[str] = None
+) -> logging.Logger:
+    """
+    Set up a standardized logger with colorized console output and size+time rotating file handler.
+    - Prevents duplicate handlers.
+    - Uses ISO 8601 timestamps.
+    - Log levels and file path can be set via environment variables or function arguments.
+
+    Args:
+        logger_name (str): Name of the logger (use 'api_service' for main app).
+        log_file_path (str, optional): Path to the log file. Defaults to 'hd_shared.log' if not specified.
+        log_level_console (int, optional): Console log level. Defaults to LOG_LEVEL env or logging.INFO.
+        log_level_files (int, optional): File log level. Defaults to LOG_LEVEL env or logging.INFO.
+
+    Returns:
+        logging.Logger: Configured logger instance.
+    """
+    # Environment/config defaults
+    log_file_path = log_file_path or os.getenv("LOG_FILE", "logs/hd_logging.log")
+    env_log_level = os.getenv("LOG_LEVEL", "INFO").upper()
+    log_level_console = log_level_console or getattr(logging, env_log_level)
+    log_level_files = log_level_files or getattr(logging, env_log_level)
+    
+    # OpenTelemetry format configuration
+    if use_otlp_format is None:
+        use_otlp_format = os.getenv("LOG_FILE_OTLP_FORMAT", "true").lower() == "true"
+    
+    service_name = service_name or os.getenv("SERVICE_NAME", "hd_logging")
+    environment = environment or os.getenv("ENVIRONMENT", "development")
+    service_version = service_version or os.getenv("SERVICE_VERSION", "1.0.0")
+
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(min(log_level_console, log_level_files))  # Set to lowest for capturing all
+
+    # Prevent duplicate handlers
+    if getattr(logger, "_custom_handlers_set", False):
+        return logger
+
+    iso_time_format = "%Y-%m-%dT%H:%M:%S%z"
+    # Set the converter for all Formatters to use UTC
+    logging.Formatter.converter = time.gmtime
+    # File formatter
+    file_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s - [Component: %(module)s, Function: %(funcName)s, Line: %(lineno)d]',
+        datefmt=iso_time_format
+    )
+
+    # Colorized console formatter
+    console_formatter = colorlog.ColoredFormatter(
+        "%(log_color)s%(asctime)s - %(name)s - %(levelname)s - %(message)s - [Component: %(module)s, Function: %(funcName)s, Line: %(lineno)d]",
+        log_colors={
+            'DEBUG': 'cyan',
+            'INFO': 'green',
+            'WARNING': 'yellow',
+            'ERROR': 'red',
+            'CRITICAL': 'bold_red',
+        },
+        datefmt=iso_time_format
+    )
+
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(log_level_console)
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+
+    # Ensure log directory exists if log_file_path is set
+    if log_file_path:
+        log_dir = os.path.dirname(log_file_path)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+    # Size and time rotating file handler
+    stime_handler = STLH(
+        filename=log_file_path,
+        when="midnight",
+        interval=1,
+        backupCount=7,
+        maxBytes=20_000_000,
+        use_otlp_format=use_otlp_format,
+        service_name=service_name,
+        environment=environment,
+        service_version=service_version
+    )
+    stime_handler.setLevel(log_level_files)
+    
+    # Set formatter based on OTLP format preference
+    if use_otlp_format:
+        # OTLP formatter is already set in the handler
+        pass
+    else:
+        stime_handler.setFormatter(file_formatter)
+    
+    logger.addHandler(stime_handler)
+
+    # Mark as configured to prevent duplicate handlers
+    logger._custom_handlers_set = True
+
+    return logger 

hd_logging-1.0.2/src/hd_logging/otlp_formatter.py

@@ -0,0 +1,128 @@
+"""
+OpenTelemetry Log Formatter
+Converts Python logging records to OpenTelemetry JSON format.
+"""
+
+import json
+import os
+import socket
+import platform
+from ulid import ULID
+import time
+from datetime import datetime, timezone
+from typing import Dict, Any, Optional
+
+
+class OpenTelemetryFormatter:
+    """Formats log records to OpenTelemetry JSON format."""
+    
+    def __init__(self, service_name: str = "hd_logging", 
+                 environment: str = "development", service_version: str = "1.0.0"):
+        self.service_name = service_name
+        self.environment = environment
+        self.service_version = service_version
+        self.resource_attributes = self._get_resource_attributes()
+    
+    def _get_resource_attributes(self) -> Dict[str, str]:
+        """Get resource attributes for the service."""
+        return {
+            "host.name": self._get_hostname(),
+            "os.type": self._get_os_type(),
+            "service.name": self.service_name,
+            "service.version": self.service_version,
+            "service.instance.id": str(ULID()),
+            "environment": self.environment
+        }
+    
+    def _get_hostname(self) -> str:
+        """Get the hostname of the system."""
+        try:
+            return socket.gethostname()
+        except:
+            return "unknown"
+    
+    def _get_os_type(self) -> str:
+        """Get the operating system type."""
+        return platform.system().lower()
+    
+    def _format_timestamp(self, timestamp: float) -> str:
+        """Format timestamp to ISO 8601 format."""
+        return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat()
+    
+    def _extract_attributes(self, record) -> Dict[str, Any]:
+        """Extract attributes from the log record."""
+        # Standard logging attributes
+        attributes = {
+            "service.name": self.service_name,
+            "environment": self.environment,
+            "logger.name": record.name,
+            "component": getattr(record, 'module', 'unknown'),
+            "function": getattr(record, 'funcName', 'unknown'),
+            "line": getattr(record, 'lineno', 0),
+            "thread.name": getattr(record, 'threadName', 'unknown'),
+            "process.name": getattr(record, 'processName', 'unknown'),
+            "process.id": getattr(record, 'process', 0)
+        }
+        
+        # Add any custom attributes from the record (otlp_attributes)
+        if hasattr(record, 'otlp_attributes'):
+            attributes.update(record.otlp_attributes)
+        
+        # Add ALL custom attributes from extra parameter
+        # Get all attributes from the record and filter out standard logging ones
+        standard_attrs = {
+            'args', 'created', 'exc_info', 'exc_text', 'filename', 'funcName', 
+            'levelname', 'levelno', 'lineno', 'module', 'msecs', 'msg', 'name', 
+            'pathname', 'process', 'processName', 'relativeCreated', 'stack_info', 
+            'taskName', 'thread', 'threadName', 'getMessage', 'otlp_attributes'
+        }
+        
+        for attr_name in dir(record):
+            if not attr_name.startswith('_') and attr_name not in standard_attrs:
+                try:
+                    attr_value = getattr(record, attr_name)
+                    if not callable(attr_value) and attr_value is not None:
+                        attributes[attr_name] = attr_value
+                except (AttributeError, TypeError):
+                    # Skip attributes that can't be accessed
+                    pass
+        
+        # Add exception info if present
+        if record.exc_info:
+            attributes["exception.type"] = record.exc_info[0].__name__ if record.exc_info[0] else "Exception"
+            attributes["exception.message"] = str(record.exc_info[1]) if record.exc_info[1] else ""
+        
+        return attributes
+    
+    def format(self, record) -> str:
+        """Format the log record to OpenTelemetry JSON format."""
+        try:
+            otlp_record = {
+                "timestamp": self._format_timestamp(record.created),
+                "severityText": record.levelname,
+                "body": record.getMessage(),
+                "attributes": self._extract_attributes(record),
+                "resource": self.resource_attributes
+            }
+            
+            # Add tracing information if available
+            if hasattr(record, 'traceId'):
+                otlp_record["traceId"] = record.traceId
+            if hasattr(record, 'spanId'):
+                otlp_record["spanId"] = record.spanId
+            
+            return json.dumps(otlp_record, ensure_ascii=False)
+            
+        except Exception as e:
+            # Fallback to simple JSON if formatting fails
+            fallback_record = {
+                "timestamp": self._format_timestamp(record.created),
+                "severityText": record.levelname,
+                "body": record.getMessage(),
+                "error": f"Failed to format log record: {str(e)}"
+            }
+            return json.dumps(fallback_record, ensure_ascii=False)
+    
+    def formatTime(self, record, datefmt=None):
+        """Format the timestamp (for compatibility with logging.Formatter)."""
+        return self._format_timestamp(record.created)