emergency-logging 0.1.0__tar.gz

emergency_logging-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BenLin0
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

emergency_logging-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: emergency-logging
+Version: 0.1.0
+Summary: A Python logging handler that buffers DEBUG/INFO and flushes them only when WARNING or ERROR fires
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/BenLin0/EmergencyLogging
+Keywords: logging,handler,debug,buffer
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# EmergencyLogging
+
+A Python logging handler that stays silent during normal operation and only writes logs when something goes wrong.
+
+## The problem
+
+Verbose debug logging helps diagnose issues, but writing every `DEBUG` and `INFO` message to a file or console creates noise that obscures what matters. The usual workaround — raising the log level to `WARNING` — means you lose the context that would have explained *why* the warning happened.
+
+## How it works
+
+`EmergencyHandler` wraps any standard `logging.Handler`. It buffers `DEBUG` and `INFO` records silently. The moment a `WARNING`, `ERROR`, or `CRITICAL` is emitted, it flushes the buffered context followed by the triggering message — then clears the buffer and starts over.
+
+```
+Normal operation:        DEBUG INFO DEBUG INFO DEBUG INFO  →  (nothing written)
+Something goes wrong:    DEBUG INFO DEBUG INFO ERROR       →  DEBUG INFO DEBUG INFO ERROR
+```
+
+The buffer holds the **most recent** N records (default 30). Older records are dropped as new ones arrive, so the buffer always contains the last N lines of context leading up to the problem.
+
+## Installation
+
+### Via pip (recommended)
+
+```bash
+pip install emergency-logging
+```
+
+### Manual
+
+No dependencies outside the standard library. Copy `emergency_logging.py` directly into your project.
+
+Requires Python 3.8+.
+
+## Usage
+
+### Basic — wrap the default stderr handler
+
+```python
+import logging
+from emergency_logging import EmergencyHandler
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler())
+
+logger.debug("connecting to database")   # buffered
+logger.info("query executed in 4 ms")    # buffered
+logger.error("connection pool exhausted") # flushes both lines above, then this
+```
+
+### With a custom handler and buffer size
+
+```python
+import logging
+from emergency_logging import EmergencyHandler
+
+stream = logging.StreamHandler()
+stream.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler(target_handler=stream, buffer_size=50))
+```
+
+### With RotatingFileHandler
+
+The log file stays empty during normal operation and only grows when an incident occurs — keeping file sizes minimal while preserving full diagnostic context when you need it.
+
+```python
+import logging
+from logging.handlers import RotatingFileHandler
+from emergency_logging import EmergencyHandler
+
+rotating = RotatingFileHandler("app.log", maxBytes=1024 * 1024, backupCount=5)
+rotating.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(name)s: %(message)s"))
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler(target_handler=rotating, buffer_size=30))
+```
+
+## API
+
+### `EmergencyHandler(target_handler=None, buffer_size=30)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `target_handler` | `logging.Handler` | `StreamHandler()` | The handler that receives flushed records |
+| `buffer_size` | `int` | `30` | Maximum number of `DEBUG`/`INFO` records to buffer; oldest are dropped when exceeded |
+
+The handler passes through `WARNING`, `ERROR`, and `CRITICAL` records immediately (after flushing the buffer). `DEBUG` and `INFO` records are only ever written as part of a flush.
+
+## Running the demos
+
+```bash
+python3 demo.py
+```
+
+## Running the tests
+
+```bash
+python3 -m unittest test_emergency_logging -v
+```

emergency_logging-0.1.0/README.md

@@ -0,0 +1,103 @@
+# EmergencyLogging
+
+A Python logging handler that stays silent during normal operation and only writes logs when something goes wrong.
+
+## The problem
+
+Verbose debug logging helps diagnose issues, but writing every `DEBUG` and `INFO` message to a file or console creates noise that obscures what matters. The usual workaround — raising the log level to `WARNING` — means you lose the context that would have explained *why* the warning happened.
+
+## How it works
+
+`EmergencyHandler` wraps any standard `logging.Handler`. It buffers `DEBUG` and `INFO` records silently. The moment a `WARNING`, `ERROR`, or `CRITICAL` is emitted, it flushes the buffered context followed by the triggering message — then clears the buffer and starts over.
+
+```
+Normal operation:        DEBUG INFO DEBUG INFO DEBUG INFO  →  (nothing written)
+Something goes wrong:    DEBUG INFO DEBUG INFO ERROR       →  DEBUG INFO DEBUG INFO ERROR
+```
+
+The buffer holds the **most recent** N records (default 30). Older records are dropped as new ones arrive, so the buffer always contains the last N lines of context leading up to the problem.
+
+## Installation
+
+### Via pip (recommended)
+
+```bash
+pip install emergency-logging
+```
+
+### Manual
+
+No dependencies outside the standard library. Copy `emergency_logging.py` directly into your project.
+
+Requires Python 3.8+.
+
+## Usage
+
+### Basic — wrap the default stderr handler
+
+```python
+import logging
+from emergency_logging import EmergencyHandler
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler())
+
+logger.debug("connecting to database")   # buffered
+logger.info("query executed in 4 ms")    # buffered
+logger.error("connection pool exhausted") # flushes both lines above, then this
+```
+
+### With a custom handler and buffer size
+
+```python
+import logging
+from emergency_logging import EmergencyHandler
+
+stream = logging.StreamHandler()
+stream.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler(target_handler=stream, buffer_size=50))
+```
+
+### With RotatingFileHandler
+
+The log file stays empty during normal operation and only grows when an incident occurs — keeping file sizes minimal while preserving full diagnostic context when you need it.
+
+```python
+import logging
+from logging.handlers import RotatingFileHandler
+from emergency_logging import EmergencyHandler
+
+rotating = RotatingFileHandler("app.log", maxBytes=1024 * 1024, backupCount=5)
+rotating.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(name)s: %(message)s"))
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler(target_handler=rotating, buffer_size=30))
+```
+
+## API
+
+### `EmergencyHandler(target_handler=None, buffer_size=30)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `target_handler` | `logging.Handler` | `StreamHandler()` | The handler that receives flushed records |
+| `buffer_size` | `int` | `30` | Maximum number of `DEBUG`/`INFO` records to buffer; oldest are dropped when exceeded |
+
+The handler passes through `WARNING`, `ERROR`, and `CRITICAL` records immediately (after flushing the buffer). `DEBUG` and `INFO` records are only ever written as part of a flush.
+
+## Running the demos
+
+```bash
+python3 demo.py
+```
+
+## Running the tests
+
+```bash
+python3 -m unittest test_emergency_logging -v
+```

emergency_logging-0.1.0/emergency_logging.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: emergency-logging
+Version: 0.1.0
+Summary: A Python logging handler that buffers DEBUG/INFO and flushes them only when WARNING or ERROR fires
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/BenLin0/EmergencyLogging
+Keywords: logging,handler,debug,buffer
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# EmergencyLogging
+
+A Python logging handler that stays silent during normal operation and only writes logs when something goes wrong.
+
+## The problem
+
+Verbose debug logging helps diagnose issues, but writing every `DEBUG` and `INFO` message to a file or console creates noise that obscures what matters. The usual workaround — raising the log level to `WARNING` — means you lose the context that would have explained *why* the warning happened.
+
+## How it works
+
+`EmergencyHandler` wraps any standard `logging.Handler`. It buffers `DEBUG` and `INFO` records silently. The moment a `WARNING`, `ERROR`, or `CRITICAL` is emitted, it flushes the buffered context followed by the triggering message — then clears the buffer and starts over.
+
+```
+Normal operation:        DEBUG INFO DEBUG INFO DEBUG INFO  →  (nothing written)
+Something goes wrong:    DEBUG INFO DEBUG INFO ERROR       →  DEBUG INFO DEBUG INFO ERROR
+```
+
+The buffer holds the **most recent** N records (default 30). Older records are dropped as new ones arrive, so the buffer always contains the last N lines of context leading up to the problem.
+
+## Installation
+
+### Via pip (recommended)
+
+```bash
+pip install emergency-logging
+```
+
+### Manual
+
+No dependencies outside the standard library. Copy `emergency_logging.py` directly into your project.
+
+Requires Python 3.8+.
+
+## Usage
+
+### Basic — wrap the default stderr handler
+
+```python
+import logging
+from emergency_logging import EmergencyHandler
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler())
+
+logger.debug("connecting to database")   # buffered
+logger.info("query executed in 4 ms")    # buffered
+logger.error("connection pool exhausted") # flushes both lines above, then this
+```
+
+### With a custom handler and buffer size
+
+```python
+import logging
+from emergency_logging import EmergencyHandler
+
+stream = logging.StreamHandler()
+stream.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler(target_handler=stream, buffer_size=50))
+```
+
+### With RotatingFileHandler
+
+The log file stays empty during normal operation and only grows when an incident occurs — keeping file sizes minimal while preserving full diagnostic context when you need it.
+
+```python
+import logging
+from logging.handlers import RotatingFileHandler
+from emergency_logging import EmergencyHandler
+
+rotating = RotatingFileHandler("app.log", maxBytes=1024 * 1024, backupCount=5)
+rotating.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(name)s: %(message)s"))
+
+logger = logging.getLogger("myapp")
+logger.setLevel(logging.DEBUG)
+logger.addHandler(EmergencyHandler(target_handler=rotating, buffer_size=30))
+```
+
+## API
+
+### `EmergencyHandler(target_handler=None, buffer_size=30)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `target_handler` | `logging.Handler` | `StreamHandler()` | The handler that receives flushed records |
+| `buffer_size` | `int` | `30` | Maximum number of `DEBUG`/`INFO` records to buffer; oldest are dropped when exceeded |
+
+The handler passes through `WARNING`, `ERROR`, and `CRITICAL` records immediately (after flushing the buffer). `DEBUG` and `INFO` records are only ever written as part of a flush.
+
+## Running the demos
+
+```bash
+python3 demo.py
+```
+
+## Running the tests
+
+```bash
+python3 -m unittest test_emergency_logging -v
+```

emergency_logging-0.1.0/emergency_logging.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+emergency_logging.py
+pyproject.toml
+emergency_logging.egg-info/PKG-INFO
+emergency_logging.egg-info/SOURCES.txt
+emergency_logging.egg-info/dependency_links.txt
+emergency_logging.egg-info/top_level.txt

emergency_logging-0.1.0/emergency_logging.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

emergency_logging-0.1.0/emergency_logging.egg-info/top_level.txt

@@ -0,0 +1 @@
+emergency_logging

emergency_logging-0.1.0/emergency_logging.py

@@ -0,0 +1,31 @@
+import logging
+import collections
+
+
+class EmergencyHandler(logging.Handler):
+    """
+    Buffers DEBUG/INFO records and flushes them only when WARN or ERROR is emitted.
+    Keeps the last `buffer_size` buffered records (oldest are dropped when full).
+    """
+
+    def __init__(self, target_handler=None, buffer_size=30):
+        super().__init__()
+        self.target_handler = target_handler or logging.StreamHandler()
+        self.buffer_size = buffer_size
+        self._buffer = collections.deque(maxlen=buffer_size)
+
+    def emit(self, record):
+        if record.levelno >= logging.WARNING:
+            for buffered in self._buffer:
+                self.target_handler.emit(buffered)
+            self._buffer.clear()
+            self.target_handler.emit(record)
+        else:
+            self._buffer.append(record)
+
+    def flush(self):
+        self.target_handler.flush()
+
+    def close(self):
+        self.target_handler.close()
+        super().close()

emergency_logging-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "emergency-logging"
+version = "0.1.0"
+description = "A Python logging handler that buffers DEBUG/INFO and flushes them only when WARNING or ERROR fires"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+keywords = ["logging", "handler", "debug", "buffer"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: System :: Logging",
+]
+
+[tool.setuptools]
+py-modules = ["emergency_logging"]
+
+[project.urls]
+Homepage = "https://github.com/BenLin0/EmergencyLogging"

emergency_logging-0.1.0/setup.cfg

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