bunnylogs 0.1.0__tar.gz

bunnylogs-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # required for trusted publishing (no API token needed)
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build
+        run: |
+          pip install build
+          python -m build
+
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

bunnylogs-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+*.egg

bunnylogs-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: bunnylogs
+Version: 0.1.0
+Summary: Python logging handler for BunnyLogs
+Project-URL: Homepage, https://bunnylogs.com
+Project-URL: Repository, https://github.com/RubenNorgaard/bunnylogs-python
+License: MIT
+Keywords: bunnylogs,log handler,logging
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT 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: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# bunnylogs
+
+Python logging handler for [BunnyLogs](https://bunnylogs.com) — ship your logs to a live stream with three lines of code.
+
+## Install
+
+```bash
+pip install bunnylogs
+```
+
+## Usage
+
+```python
+import logging
+from bunnylogs import BunnyLogsHandler
+
+logging.getLogger().addHandler(BunnyLogsHandler("your-uuid-here"))
+```
+
+That's it. Every log record at `WARNING` and above (or whatever level your root logger is set to) will appear in your BunnyLogs stream in real time.
+
+### Capture a specific logger
+
+```python
+import logging
+from bunnylogs import BunnyLogsHandler
+
+handler = BunnyLogsHandler("your-uuid-here")
+handler.setLevel(logging.DEBUG)
+
+logger = logging.getLogger("myapp")
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG)
+```
+
+### Django — `settings.py`
+
+```python
+LOGGING = {
+    "version": 1,
+    "handlers": {
+        "bunnylogs": {
+            "class": "bunnylogs.BunnyLogsHandler",
+            "uuid": "your-uuid-here",
+        },
+    },
+    "root": {
+        "handlers": ["bunnylogs"],
+        "level": "WARNING",
+    },
+}
+```
+
+### Self-hosted deployments
+
+```python
+BunnyLogsHandler("your-uuid-here", endpoint="https://your-own-host.com")
+```
+
+## How it works
+
+Log records are placed on an in-process queue and flushed by a daemon thread, so `emit()` is non-blocking (~microseconds on the calling thread). The background thread sends one HTTPS POST per record using only the Python standard library — no external dependencies.
+
+On process exit the daemon thread is killed. Call `handler.close()` explicitly if you need to guarantee all queued records are flushed before shutdown.
+
+## Parameters
+
+| Parameter  | Default                    | Description                              |
+|------------|----------------------------|------------------------------------------|
+| `uuid`     | —                          | Your logspace UUID                       |
+| `level`    | `logging.NOTSET`           | Minimum level to forward                 |
+| `endpoint` | `https://bunnylogs.com`    | Base URL (override for self-hosted)      |
+| `timeout`  | `5`                        | HTTP request timeout in seconds          |
+
+## License
+
+MIT

bunnylogs-0.1.0/README.md

@@ -0,0 +1,77 @@
+# bunnylogs
+
+Python logging handler for [BunnyLogs](https://bunnylogs.com) — ship your logs to a live stream with three lines of code.
+
+## Install
+
+```bash
+pip install bunnylogs
+```
+
+## Usage
+
+```python
+import logging
+from bunnylogs import BunnyLogsHandler
+
+logging.getLogger().addHandler(BunnyLogsHandler("your-uuid-here"))
+```
+
+That's it. Every log record at `WARNING` and above (or whatever level your root logger is set to) will appear in your BunnyLogs stream in real time.
+
+### Capture a specific logger
+
+```python
+import logging
+from bunnylogs import BunnyLogsHandler
+
+handler = BunnyLogsHandler("your-uuid-here")
+handler.setLevel(logging.DEBUG)
+
+logger = logging.getLogger("myapp")
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG)
+```
+
+### Django — `settings.py`
+
+```python
+LOGGING = {
+    "version": 1,
+    "handlers": {
+        "bunnylogs": {
+            "class": "bunnylogs.BunnyLogsHandler",
+            "uuid": "your-uuid-here",
+        },
+    },
+    "root": {
+        "handlers": ["bunnylogs"],
+        "level": "WARNING",
+    },
+}
+```
+
+### Self-hosted deployments
+
+```python
+BunnyLogsHandler("your-uuid-here", endpoint="https://your-own-host.com")
+```
+
+## How it works
+
+Log records are placed on an in-process queue and flushed by a daemon thread, so `emit()` is non-blocking (~microseconds on the calling thread). The background thread sends one HTTPS POST per record using only the Python standard library — no external dependencies.
+
+On process exit the daemon thread is killed. Call `handler.close()` explicitly if you need to guarantee all queued records are flushed before shutdown.
+
+## Parameters
+
+| Parameter  | Default                    | Description                              |
+|------------|----------------------------|------------------------------------------|
+| `uuid`     | —                          | Your logspace UUID                       |
+| `level`    | `logging.NOTSET`           | Minimum level to forward                 |
+| `endpoint` | `https://bunnylogs.com`    | Base URL (override for self-hosted)      |
+| `timeout`  | `5`                        | HTTP request timeout in seconds          |
+
+## License
+
+MIT

bunnylogs-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bunnylogs"
+version = "0.1.0"
+description = "Python logging handler for BunnyLogs"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = []
+keywords = ["logging", "bunnylogs", "log handler"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT 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",
+    "Topic :: System :: Logging",
+]
+
+[project.urls]
+Homepage = "https://bunnylogs.com"
+Repository = "https://github.com/RubenNorgaard/bunnylogs-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/bunnylogs"]

bunnylogs-0.1.0/src/bunnylogs/__init__.py

@@ -0,0 +1,4 @@
+from .handler import BunnyLogsHandler
+
+__all__ = ["BunnyLogsHandler"]
+__version__ = "0.1.0"

bunnylogs-0.1.0/src/bunnylogs/handler.py

@@ -0,0 +1,113 @@
+"""
+BunnyLogs logging handler.
+
+Sends log records to a BunnyLogs stream endpoint in a background thread so
+that logging calls never block the caller.
+"""
+
+import logging
+import queue
+import threading
+import urllib.error
+import urllib.parse
+import urllib.request
+from datetime import datetime, timezone
+
+
+_STOP = object()  # sentinel that tells the worker thread to exit
+
+
+class BunnyLogsHandler(logging.Handler):
+    """
+    A logging.Handler that ships records to a BunnyLogs live stream.
+
+    Records are placed on an in-process queue and flushed by a daemon thread,
+    so ``emit()`` is non-blocking (~microseconds).
+
+    Usage::
+
+        import logging
+        from bunnylogs import BunnyLogsHandler
+
+        logging.getLogger().addHandler(BunnyLogsHandler("your-uuid-here"))
+
+    Parameters
+    ----------
+    uuid:
+        The logspace UUID shown in your BunnyLogs stream URL.
+    level:
+        Minimum log level to forward (default: ``logging.NOTSET``, i.e. all).
+    endpoint:
+        Override the base URL (default: ``https://bunnylogs.com``).
+        Useful for self-hosted deployments.
+    timeout:
+        HTTP request timeout in seconds (default: 5).
+    """
+
+    def __init__(
+        self,
+        uuid: str,
+        level: int = logging.NOTSET,
+        endpoint: str = "https://bunnylogs.com",
+        timeout: float = 5,
+    ) -> None:
+        super().__init__(level)
+        self._url = f"{endpoint.rstrip('/')}/live/{uuid}/"
+        self._timeout = timeout
+        self._queue: queue.SimpleQueue = queue.SimpleQueue()
+        self._thread = threading.Thread(
+            target=self._worker,
+            name="bunnylogs-worker",
+            daemon=True,  # won't block process exit
+        )
+        self._thread.start()
+
+    # ------------------------------------------------------------------
+    # logging.Handler interface
+    # ------------------------------------------------------------------
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Put the record on the queue; returns immediately."""
+        try:
+            self._queue.put_nowait(record)
+        except Exception:
+            self.handleError(record)
+
+    def close(self) -> None:
+        """Flush remaining records then shut down the worker thread."""
+        self._queue.put_nowait(_STOP)
+        # Give the worker up to 5 s to drain before the handler is torn down.
+        self._thread.join(timeout=5)
+        super().close()
+
+    # ------------------------------------------------------------------
+    # Background worker
+    # ------------------------------------------------------------------
+
+    def _worker(self) -> None:
+        while True:
+            item = self._queue.get()
+            if item is _STOP:
+                return
+            self._send(item)
+
+    def _send(self, record: logging.LogRecord) -> None:
+        try:
+            ts = datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat()
+            data = urllib.parse.urlencode(
+                {
+                    "message": self.format(record),
+                    "level": record.levelname,
+                    "program": record.name,
+                    "timestamp": ts,
+                }
+            ).encode()
+            req = urllib.request.Request(
+                self._url,
+                data=data,
+                method="POST",
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+            )
+            urllib.request.urlopen(req, timeout=self._timeout)
+        except Exception:
+            self.handleError(record)