Skip to content

Logger Exceptions API

Exception classes specific to the logger module.

Base Logger Exception

JPYLoggerError

JPYLoggerError

Bases: JPYLoggingError

Base exception for all logger-related errors.

This extends JPYLoggingError to provide logger-specific error handling while maintaining consistency with the base exception system.

Source code in src/jinpy_utils/logger/exceptions.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class JPYLoggerError(JPYLoggingError):
    """Base exception for all logger-related errors.

    This extends JPYLoggingError to provide logger-specific error handling
    while maintaining consistency with the base exception system.
    """

    def __init__(
        self,
        message: str,
        logger_name: str | None = None,
        operation: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize logger error."""
        details = kwargs.pop("details", {})
        if logger_name:
            details["logger_name"] = logger_name
        if operation:
            details["operation"] = operation

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type=kwargs.pop("handler_type", "Logger"),
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Check logger configuration",
                    "Verify logging permissions",
                    "Ensure proper initialization",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    logger_name: str | None = None,
    operation: str | None = None,
    **kwargs: Any
) -> None

Initialize logger error.

Source code in src/jinpy_utils/logger/exceptions.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
def __init__(
    self,
    message: str,
    logger_name: str | None = None,
    operation: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize logger error."""
    details = kwargs.pop("details", {})
    if logger_name:
        details["logger_name"] = logger_name
    if operation:
        details["operation"] = operation

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type=kwargs.pop("handler_type", "Logger"),
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Check logger configuration",
                "Verify logging permissions",
                "Ensure proper initialization",
            ],
        ),
        **kwargs,
    )

Specific Logger Exceptions

JPYLoggerBackendError

JPYLoggerBackendError

Bases: JPYLoggingError

Exception raised for backend-specific errors.

Source code in src/jinpy_utils/logger/exceptions.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
class JPYLoggerBackendError(JPYLoggingError):
    """Exception raised for backend-specific errors."""

    def __init__(
        self,
        message: str,
        backend_type: str | None = None,
        backend_config: dict[str, Any] | None = None,
        logger_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize backend error."""
        details = kwargs.pop("details", {})
        if backend_type:
            details["backend_type"] = backend_type
        if backend_config:
            details["backend_config"] = backend_config

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type=(
                f"LoggerBackend:{backend_type}" if backend_type else "LoggerBackend"
            ),
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Check backend connectivity",
                    "Verify backend configuration",
                    "Ensure backend dependencies are installed",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    backend_type: str | None = None,
    backend_config: dict[str, Any] | None = None,
    logger_name: str | None = None,
    **kwargs: Any
) -> None

Initialize backend error.

Source code in src/jinpy_utils/logger/exceptions.py 
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
def __init__(
    self,
    message: str,
    backend_type: str | None = None,
    backend_config: dict[str, Any] | None = None,
    logger_name: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize backend error."""
    details = kwargs.pop("details", {})
    if backend_type:
        details["backend_type"] = backend_type
    if backend_config:
        details["backend_config"] = backend_config

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type=(
            f"LoggerBackend:{backend_type}" if backend_type else "LoggerBackend"
        ),
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Check backend connectivity",
                "Verify backend configuration",
                "Ensure backend dependencies are installed",
            ],
        ),
        **kwargs,
    )

JPYLoggerConfigurationError

JPYLoggerConfigurationError

Bases: JPYLoggingError

Exception raised for logger configuration errors.

Source code in src/jinpy_utils/logger/exceptions.py 
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
class JPYLoggerConfigurationError(JPYLoggingError):
    """Exception raised for logger configuration errors."""

    def __init__(
        self,
        message: str,
        config_section: str | None = None,
        config_value: Any | None = None,
        logger_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize configuration error."""
        details = kwargs.pop("details", {})
        if config_section:
            details["config_section"] = config_section
        if config_value is not None:
            details["config_value"] = str(config_value)

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type="LoggerConfiguration",
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Check logger configuration syntax",
                    "Verify all required settings",
                    "Ensure valid configuration values",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    config_section: str | None = None,
    config_value: Any | None = None,
    logger_name: str | None = None,
    **kwargs: Any
) -> None

Initialize configuration error.

Source code in src/jinpy_utils/logger/exceptions.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
def __init__(
    self,
    message: str,
    config_section: str | None = None,
    config_value: Any | None = None,
    logger_name: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize configuration error."""
    details = kwargs.pop("details", {})
    if config_section:
        details["config_section"] = config_section
    if config_value is not None:
        details["config_value"] = str(config_value)

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type="LoggerConfiguration",
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Check logger configuration syntax",
                "Verify all required settings",
                "Ensure valid configuration values",
            ],
        ),
        **kwargs,
    )

JPYLoggerConnectionError

JPYLoggerConnectionError

Bases: JPYLoggingError

Exception raised for connection-related errors.

Source code in src/jinpy_utils/logger/exceptions.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
class JPYLoggerConnectionError(JPYLoggingError):
    """Exception raised for connection-related errors."""

    def __init__(
        self,
        message: str,
        endpoint: str | None = None,
        connection_type: str | None = None,
        logger_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize connection error."""
        details = kwargs.pop("details", {})
        if endpoint:
            details["endpoint"] = endpoint
        if connection_type:
            details["connection_type"] = connection_type

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type=(
                f"LoggerConnection:{connection_type}"
                if connection_type
                else "LoggerConnection"
            ),
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Check network connectivity",
                    "Verify endpoint availability",
                    "Check firewall settings",
                    "Validate authentication credentials",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    endpoint: str | None = None,
    connection_type: str | None = None,
    logger_name: str | None = None,
    **kwargs: Any
) -> None

Initialize connection error.

Source code in src/jinpy_utils/logger/exceptions.py 
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
def __init__(
    self,
    message: str,
    endpoint: str | None = None,
    connection_type: str | None = None,
    logger_name: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize connection error."""
    details = kwargs.pop("details", {})
    if endpoint:
        details["endpoint"] = endpoint
    if connection_type:
        details["connection_type"] = connection_type

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type=(
            f"LoggerConnection:{connection_type}"
            if connection_type
            else "LoggerConnection"
        ),
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Check network connectivity",
                "Verify endpoint availability",
                "Check firewall settings",
                "Validate authentication credentials",
            ],
        ),
        **kwargs,
    )

JPYLoggerPerformanceError

JPYLoggerPerformanceError

Bases: JPYLoggingError

Exception raised for performance-related errors.

Source code in src/jinpy_utils/logger/exceptions.py 
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
class JPYLoggerPerformanceError(JPYLoggingError):
    """Exception raised for performance-related errors."""

    def __init__(
        self,
        message: str,
        performance_metric: str | None = None,
        threshold_value: float | None = None,
        actual_value: float | None = None,
        logger_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize performance error."""
        details = kwargs.pop("details", {})
        if performance_metric:
            details["performance_metric"] = performance_metric
        if threshold_value is not None:
            details["threshold_value"] = threshold_value
        if actual_value is not None:
            details["actual_value"] = actual_value

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type="LoggerPerformance",
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Increase buffer sizes",
                    "Reduce log frequency",
                    "Optimize backend configuration",
                    "Scale backend resources",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    performance_metric: str | None = None,
    threshold_value: float | None = None,
    actual_value: float | None = None,
    logger_name: str | None = None,
    **kwargs: Any
) -> None

Initialize performance error.

Source code in src/jinpy_utils/logger/exceptions.py 
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
def __init__(
    self,
    message: str,
    performance_metric: str | None = None,
    threshold_value: float | None = None,
    actual_value: float | None = None,
    logger_name: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize performance error."""
    details = kwargs.pop("details", {})
    if performance_metric:
        details["performance_metric"] = performance_metric
    if threshold_value is not None:
        details["threshold_value"] = threshold_value
    if actual_value is not None:
        details["actual_value"] = actual_value

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type="LoggerPerformance",
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Increase buffer sizes",
                "Reduce log frequency",
                "Optimize backend configuration",
                "Scale backend resources",
            ],
        ),
        **kwargs,
    )

JPYLoggerSecurityError

JPYLoggerSecurityError

Bases: JPYLoggingError

Exception raised for security-related errors.

Source code in src/jinpy_utils/logger/exceptions.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
class JPYLoggerSecurityError(JPYLoggingError):
    """Exception raised for security-related errors."""

    def __init__(
        self,
        message: str,
        security_context: str | None = None,
        logger_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize security error."""
        details = kwargs.pop("details", {})
        if security_context:
            details["security_context"] = security_context

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type="LoggerSecurity",
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Check authentication credentials",
                    "Verify API key permissions",
                    "Ensure secure connection",
                    "Review security policies",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    security_context: str | None = None,
    logger_name: str | None = None,
    **kwargs: Any
) -> None

Initialize security error.

Source code in src/jinpy_utils/logger/exceptions.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
def __init__(
    self,
    message: str,
    security_context: str | None = None,
    logger_name: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize security error."""
    details = kwargs.pop("details", {})
    if security_context:
        details["security_context"] = security_context

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type="LoggerSecurity",
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Check authentication credentials",
                "Verify API key permissions",
                "Ensure secure connection",
                "Review security policies",
            ],
        ),
        **kwargs,
    )

JPYLoggerWebSocketError

JPYLoggerWebSocketError

Bases: JPYLoggingError

Exception raised for WebSocket-related errors.

Source code in src/jinpy_utils/logger/exceptions.py 
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
class JPYLoggerWebSocketError(JPYLoggingError):
    """Exception raised for WebSocket-related errors."""

    def __init__(
        self,
        message: str,
        ws_endpoint: str | None = None,
        ws_state: str | None = None,
        logger_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Initialize WebSocket error."""
        details = kwargs.pop("details", {})
        if ws_endpoint:
            details["ws_endpoint"] = ws_endpoint
        if ws_state:
            details["ws_state"] = ws_state

        super().__init__(
            message=message,
            logger_name=logger_name,
            handler_type="LoggerWebSocket",
            details=details,
            suggestions=kwargs.pop(
                "suggestions",
                [
                    "Check WebSocket endpoint availability",
                    "Verify WebSocket connection state",
                    "Check network connectivity",
                    "Review WebSocket authentication",
                ],
            ),
            **kwargs,
        )

Functions

__init__ 

__init__(
    message: str,
    ws_endpoint: str | None = None,
    ws_state: str | None = None,
    logger_name: str | None = None,
    **kwargs: Any
) -> None

Initialize WebSocket error.

Source code in src/jinpy_utils/logger/exceptions.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
def __init__(
    self,
    message: str,
    ws_endpoint: str | None = None,
    ws_state: str | None = None,
    logger_name: str | None = None,
    **kwargs: Any,
) -> None:
    """Initialize WebSocket error."""
    details = kwargs.pop("details", {})
    if ws_endpoint:
        details["ws_endpoint"] = ws_endpoint
    if ws_state:
        details["ws_state"] = ws_state

    super().__init__(
        message=message,
        logger_name=logger_name,
        handler_type="LoggerWebSocket",
        details=details,
        suggestions=kwargs.pop(
            "suggestions",
            [
                "Check WebSocket endpoint availability",
                "Verify WebSocket connection state",
                "Check network connectivity",
                "Review WebSocket authentication",
            ],
        ),
        **kwargs,
    )

Usage Examples

Configuration Errors

from jinpy_utils.logger import LoggerConfig, ConsoleBackendConfig
from jinpy_utils.logger import JPYLoggerConfigurationError

try:
    config = LoggerConfig(
        level="INVALID_LEVEL",  # Invalid level
        backends=[ConsoleBackendConfig()]
    )
    config.validate()
except JPYLoggerConfigurationError as e:
    print(f"Configuration error: {e.message}")
    print(f"Config key: {e.config_key}")
    print(f"Suggestions: {e.suggestions}")

Backend Errors

from jinpy_utils.logger import get_logger, LoggerConfig, FileBackendConfig
from jinpy_utils.logger import JPYLoggerBackendError

try:
    config = LoggerConfig(
        backends=[
            FileBackendConfig(
                file_path="/invalid/path/app.log"  # Invalid path
            )
        ]
    )
    logger = get_logger("app", config)
    logger.info("This will fail")
except JPYLoggerBackendError as e:
    print(f"Backend error: {e.message}")
    print(f"Backend type: {e.backend_type}")
    print(f"Operation: {e.operation}")
    print(f"Suggestions: {e.suggestions}")

Connection Errors

from jinpy_utils.logger import get_logger, LoggerConfig, RestApiBackendConfig
from jinpy_utils.logger import JPYLoggerConnectionError

try:
    config = LoggerConfig(
        backends=[
            RestApiBackendConfig(
                endpoint="https://invalid-domain.com/logs"
            )
        ]
    )
    logger = get_logger("app", config)
    logger.error("This will fail to send")
except JPYLoggerConnectionError as e:
    print(f"Connection error: {e.message}")
    print(f"Endpoint: {e.endpoint}")
    print(f"Status code: {e.status_code}")
    print(f"Retry count: {e.retry_count}")

WebSocket Errors

from jinpy_utils.logger import get_logger, LoggerConfig, WebSocketBackendConfig
from jinpy_utils.logger import JPYLoggerWebSocketError

try:
    config = LoggerConfig(
        backends=[
            WebSocketBackendConfig(
                endpoint="wss://invalid-ws.com/logs"
            )
        ]
    )
    logger = get_logger("app", config)
    logger.info("This will fail WebSocket connection")
except JPYLoggerWebSocketError as e:
    print(f"WebSocket error: {e.message}")
    print(f"Endpoint: {e.endpoint}")
    print(f"Connection state: {e.connection_state}")
    print(f"Reconnect attempts: {e.reconnect_attempts}")

Performance Errors

from jinpy_utils.logger import get_logger, create_production_config
from jinpy_utils.logger import JPYLoggerPerformanceError
import time

try:
    logger = get_logger("perf_app", create_production_config())

    # Simulate performance issue
    for i in range(100000):
        logger.info(f"Message {i}")

except JPYLoggerPerformanceError as e:
    print(f"Performance error: {e.message}")
    print(f"Operation: {e.operation}")
    print(f"Duration: {e.duration_seconds}s")
    print(f"Threshold: {e.threshold_seconds}s")

Security Errors

from jinpy_utils.logger import get_logger, LoggerConfig, RestApiBackendConfig
from jinpy_utils.logger import JPYLoggerSecurityError

try:
    config = LoggerConfig(
        backends=[
            RestApiBackendConfig(
                endpoint="http://insecure-endpoint.com/logs",  # HTTP instead of HTTPS
                verify_ssl=True
            )
        ]
    )
    logger = get_logger("secure_app", config)
    logger.info("Sensitive information", credit_card="1234-5678-9012-3456")

except JPYLoggerSecurityError as e:
    print(f"Security error: {e.message}")
    print(f"Security violation: {e.violation_type}")
    print(f"Severity: {e.severity}")
    print(f"Suggestions: {e.suggestions}")

Error Handling Patterns

Comprehensive Error Handling

from jinpy_utils.logger import get_logger, create_production_config
from jinpy_utils.logger import (
    JPYLoggerError,
    JPYLoggerBackendError,
    JPYLoggerConnectionError,
    JPYLoggerConfigurationError
)
from jinpy_utils.base import JPYBaseException

def setup_logger_with_error_handling(name: str):
    """Set up logger with comprehensive error handling."""
    try:
        config = create_production_config()
        logger = get_logger(name, config)
        return logger

    except JPYLoggerConfigurationError as e:
        print(f"Configuration error: {e.message}")
        # Fall back to basic console logging
        return get_logger(name)

    except JPYLoggerBackendError as e:
        print(f"Backend error: {e.message}")
        # Fall back to console-only logging
        fallback_config = create_development_config()
        return get_logger(name, fallback_config)

    except JPYLoggerError as e:
        print(f"General logger error: {e.message}")
        # Use Python's built-in logging as last resort
        import logging
        return logging.getLogger(name)

    except Exception as e:
        print(f"Unexpected error: {e}")
        import logging
        return logging.getLogger(name)

Retry Logic for Connection Errors

import time
from typing import Optional
from jinpy_utils.logger import get_logger, LoggerConfig
from jinpy_utils.logger import JPYLoggerConnectionError

def create_logger_with_retry(config: LoggerConfig, max_retries: int = 3) -> Optional:
    """Create logger with retry logic for connection errors."""
    for attempt in range(max_retries):
        try:
            logger = get_logger("retry_app", config)
            # Test the connection
            logger.info("Logger initialized successfully")
            return logger

        except JPYLoggerConnectionError as e:
            print(f"Attempt {attempt + 1} failed: {e.message}")
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                print("Max retries exceeded, using fallback logger")
                return get_logger("retry_app")  # Fallback to default config

    return None

Graceful Degradation

from jinpy_utils.logger import (
    get_logger,
    LoggerConfig,
    ConsoleBackendConfig,
    FileBackendConfig,
    RestApiBackendConfig
)
from jinpy_utils.logger import JPYLoggerBackendError

def create_resilient_logger(name: str) -> Logger:
    """Create logger with graceful degradation."""
    # Start with full configuration
    backends = [
        RestApiBackendConfig(endpoint="https://logs.example.com/api"),
        FileBackendConfig(file_path="logs/app.log"),
        ConsoleBackendConfig()
    ]

    # Try to remove backends that fail
    working_backends = []
    for backend_config in backends:
        try:
            test_config = LoggerConfig(backends=[backend_config])
            test_logger = get_logger(f"{name}_test", test_config)
            test_logger.info("Backend test")
            working_backends.append(backend_config)
        except JPYLoggerBackendError as e:
            print(f"Backend {type(backend_config).__name__} failed: {e.message}")
            continue

    # Use working backends
    if working_backends:
        config = LoggerConfig(backends=working_backends)
        return get_logger(name, config)
    else:
        # Last resort: basic Python logging
        import logging
        return logging.getLogger(name)

Error Reporting

from jinpy_utils.logger import get_logger
from jinpy_utils.logger import JPYLoggerError
from jinpy_utils.base import JPYBaseException

class LoggerErrorReporter:
    """Report logger errors to monitoring system."""

    def __init__(self):
        self.error_logger = get_logger("logger_errors")

    def report_error(self, error: JPYLoggerError, context: dict = None):
        """Report a logger error."""
        error_data = {
            "error_type": type(error).__name__,
            "error_code": error.error_code,
            "message": error.message,
            "context": context or {}
        }

        # Add specific error details
        if hasattr(error, 'backend_type'):
            error_data["backend_type"] = error.backend_type
        if hasattr(error, 'endpoint'):
            error_data["endpoint"] = error.endpoint
        if hasattr(error, 'config_key'):
            error_data["config_key"] = error.config_key

        self.error_logger.error("Logger error occurred", **error_data)

        # Send to monitoring system
        self._send_to_monitoring(error_data)

    def _send_to_monitoring(self, error_data: dict):
        """Send error data to monitoring system."""
        # Implementation depends on your monitoring system
        pass

# Usage
error_reporter = LoggerErrorReporter()

try:
    # Logger operations
    pass
except JPYLoggerError as e:
    error_reporter.report_error(e, {"operation": "logger_setup"})

Custom Error Handling

Custom Logger Exception

from jinpy_utils.logger import JPYLoggerError

class CustomLoggerError(JPYLoggerError):
    """Custom logger exception for application-specific errors."""

    def __init__(self, message: str, custom_field: str = None, **kwargs):
        super().__init__(
            error_code="CUSTOM_LOGGER_ERROR",
            message=message,
            custom_field=custom_field,
            **kwargs
        )

Error Context Management

from contextlib import contextmanager
from jinpy_utils.logger import get_logger
from jinpy_utils.logger import JPYLoggerError

@contextmanager
def logger_error_context(operation: str, logger_name: str = "app"):
    """Context manager for logger error handling."""
    logger = get_logger("error_handler")
    logger.info(f"Starting {operation}")

    try:
        yield
        logger.info(f"Completed {operation}")
    except JPYLoggerError as e:
        logger.error(f"Logger error in {operation}",
                    error_code=e.error_code,
                    error_message=e.message)
        raise
    except Exception as e:
        logger.error(f"Unexpected error in {operation}", error=str(e))
        raise

# Usage
with logger_error_context("log_setup"):
    # Logger setup code that might fail
    pass