boxfusion-log 0.1.0__tar.gz

boxfusion_log-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+*.db
+*.db-wal
+*.db-shm
+.env

boxfusion_log-0.1.0/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.1.0
+
+First release, extracted from the RSL service-automation app.
+
+- One-call setup: `boxlog.setup(service=...)`, with JSON or text output to stdout.
+- Correlation context via `bind(...)`, carried across `await` and into asyncio tasks.
+- `log_step()`, which logs start, ok (with `duration_ms`) or failed (with traceback) for a unit of
+  work. Each traceback is logged once, even when steps are nested.
+- Secret redaction for bearer and basic auth, credentials embedded in URLs, and password, token,
+  key and cookie fields. You can add your own keys and patterns.
+- A non-blocking handler that ships records to a backend off-thread in batches.
+- Memory, SQLite and Redis backends, selectable with `backend_from_url()`.
+- ASGI and WSGI request-id middleware.
+- A web viewer as a dependency-free ASGI app you can mount anywhere, plus `boxlog serve`.

boxfusion_log-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Boxfusion
+
+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.

boxfusion_log-0.1.0/PKG-INFO

@@ -0,0 +1,252 @@
+Metadata-Version: 2.5
+Name: boxfusion-log
+Version: 0.1.0
+Summary: Structured JSON logging with request tracing, secret redaction, pluggable storage and a built-in web log viewer.
+Author: Boxfusion
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asgi,fastapi,json,log-viewer,logging,structured-logging,tracing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Logging
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: all
+Requires-Dist: redis>=4.5; extra == 'all'
+Requires-Dist: uvicorn>=0.23; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: redis>=4.5; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Requires-Dist: uvicorn>=0.23; extra == 'dev'
+Provides-Extra: redis
+Requires-Dist: redis>=4.5; extra == 'redis'
+Provides-Extra: web
+Requires-Dist: uvicorn>=0.23; extra == 'web'
+Description-Content-Type: text/markdown
+
+# boxlog
+
+Structured JSON logging for Python, with request and job tracing, secret redaction,
+pluggable storage and a built-in web log viewer.
+
+```bash
+pip install boxfusion-log              # core: stdlib only, no dependencies
+pip install "boxfusion-log[redis]"     # + Redis storage
+pip install "boxfusion-log[web]"       # + the standalone `boxlog serve` viewer
+pip install "boxfusion-log[all]"
+```
+
+```python
+import boxlog   # the package installs as boxfusion-log but imports as boxlog
+```
+
+boxlog builds on the standard `logging` module, so it needs no new logger API. Your existing
+`logging.getLogger(__name__)` calls, and every third-party library's logs, flow through it
+unchanged.
+
+## Quick start
+
+```python
+import logging
+import boxlog
+
+boxlog.setup(service="billing", backend="sqlite:///logs/billing.db")
+log = logging.getLogger(__name__)
+
+log.info("Service started", extra={"event": "app.startup", "version": "1.4.2"})
+```
+
+Output on stdout, one JSON object per line:
+
+```json
+{"ts": "2026-09-29T09:16:21.180+00:00", "level": "INFO", "logger": "__main__",
+ "message": "Service started", "event": "app.startup", "service": "billing",
+ "extra": {"version": "1.4.2"}}
+```
+
+Use `stdout="text"` for readable lines during development.
+
+## Logging a unit of work: `log_step`
+
+One `with` block logs the start of the work, then either its success (with duration and
+any result fields) or its failure (with the traceback), and re-raises the error:
+
+```python
+with boxlog.log_step(log, "payment.charge", customer="c-42", amount=1999) as step:
+    receipt = gateway.charge(...)
+    step["receipt_id"] = receipt.id
+```
+
+| outcome | event                   | level | extras                                                  |
+|---------|-------------------------|-------|---------------------------------------------------------|
+| start   | `payment.charge.start`  | DEBUG | `customer`, `amount`                                    |
+| success | `payment.charge.ok`     | INFO  | `customer`, `amount`, `receipt_id`, `duration_ms`       |
+| failure | `payment.charge.failed` | ERROR | the fields, `duration_ms`, `error_type` and a traceback |
+
+It works around `await` too. Nested steps log each traceback only once, in the innermost
+step; outer steps still log `.failed`, so you see the chain of work that broke without
+reading the same traceback five times. In your own `except` blocks, check
+`boxlog.already_logged(exc)` for the same effect.
+
+## Tracing: `bind`
+
+Fields you bind are added to every record logged inside the block, including records
+from awaited code and from asyncio tasks started inside it:
+
+```python
+with boxlog.bind(job_id=job.id, tenant="acme"):
+    process(job)          # every record in here carries job_id and tenant
+```
+
+Field names must be lower_snake_case. The web middleware binds `request_id` for you.
+
+## Web frameworks
+
+**FastAPI / Starlette (ASGI):**
+
+```python
+import os
+from fastapi import FastAPI
+import boxlog
+
+boxlog.setup(service="api", backend="redis://localhost:6379/0?key=api:logs")
+
+app = FastAPI()
+app.add_middleware(boxlog.RequestIdMiddleware, quiet_paths=("/health", "/logs"))
+app.mount("/logs", boxlog.create_viewer(
+    boxlog.backend_from_url("redis://localhost:6379/0?key=api:logs"),
+    token=os.environ["LOGS_TOKEN"],
+    title="API logs",
+))
+```
+
+**Flask / Django (WSGI):**
+
+```python
+app.wsgi_app = boxlog.WSGIRequestIdMiddleware(app.wsgi_app)            # Flask
+application = boxlog.WSGIRequestIdMiddleware(get_wsgi_application())    # Django
+```
+
+Then view logs with the standalone viewer (below).
+
+The middleware:
+- reuses an incoming `X-Request-ID` if it's well-formed, and otherwise generates one;
+- echoes the id back on the response;
+- logs one `http.request` record per request (method, path, status and duration);
+- logs any unhandled exception with its traceback.
+
+## The web viewer
+
+The viewer has:
+- a level filter (including "Failures only");
+- service and source filters, populated from your data;
+- an event-prefix filter and text search;
+- click-to-trace on any `request_id` or `job_id`;
+- live tail;
+- an expandable view of every record and its traceback.
+
+- **Mounted** inside an ASGI app: `create_viewer(backend, token=...)`, as above.
+- **Standalone**, for any app, including non-web workers and scripts:
+
+  ```bash
+  export BOXLOG_TOKEN="$(boxlog token)"
+  boxlog serve sqlite:///logs/billing.db          # http://127.0.0.1:8765/
+  boxlog serve "redis://localhost:6379/0?key=api:logs" --port 9000 --title "API logs"
+  ```
+
+**Security.** Logs contain whatever your users send you, so treat the viewer like an admin
+console:
+- It requires a bearer token of **at least 32 characters**. Generate one with `boxlog token`.
+- If the token is unset, the mounted viewer answers 404 everywhere.
+- The page renders log content only as text, never as HTML, and ships under a strict
+  Content-Security-Policy with no inline script.
+- Serve it over HTTPS. The standalone server binds to `127.0.0.1` unless you pass `--host`.
+
+`create_viewer` also takes callables for `backend` and `token`. That's useful when they're
+only known at startup (for example, inside a lifespan).
+
+## Storage backends
+
+| backend         | URL                                                  | good for                                                                   |
+|-----------------|------------------------------------------------------|----------------------------------------------------------------------------|
+| `MemoryBackend` | `memory://?max=5000`                                 | tests and scripts; lost on restart                                         |
+| `SQLiteBackend` | `sqlite:///logs/app.db?max=100000`                   | one machine, no server; indexed queries; processes on one host can share the file |
+| `RedisBackend`  | `redis://host:6379/0?key=app:logs&max=10000`         | several processes or machines; survives restarts                           |
+
+```python
+boxlog.setup(service="worker", backend=boxlog.SQLiteBackend("logs/worker.db"))
+# or attach later, once settings are known:
+boxlog.attach_backend("redis://cache:6379/0?key=worker:logs")
+```
+
+Records reach the backend from a background thread, in batches, so logging never blocks
+your code or an event loop. If the backend is down, records are dropped (with one warning
+on stderr) and your app carries on; stdout logging is unaffected. Several services can
+share one backend, and the viewer shows a service filter when it finds more than one.
+
+A custom backend needs three methods, `append(entries)`, `query(query)` and `close()`. See
+`boxlog.backends.base.LogBackend`.
+
+## Redaction
+
+Before any output, boxlog masks:
+- values of sensitive keys in `extra=` and bound fields: `password`, `token`, `api_key`,
+  `secret`, `authorization`, `cookie`, … (as whole names or `_` suffixes, so `access_token`
+  is masked but `total_tokens` isn't);
+- `Bearer …` and `Basic …` credentials in text;
+- `password=…` and `"token": "…"` pairs in text;
+- passwords inside URLs (`redis://user:secret@host`);
+- all of the above in exception messages and tracebacks.
+
+You can add your own keys and patterns:
+
+```python
+boxlog.setup(redact_keys=["national_id"], redact_patterns=[r"\b\d{13}\b"])
+```
+
+Redaction is a safety net. Don't log secrets or whole request bodies on purpose.
+
+## `setup()` reference
+
+```python
+boxlog.setup(
+    service=None,              # tagged on every record
+    level="INFO",
+    stdout="json",             # "json", "text" or None
+    backend=None,              # LogBackend or URL
+    redact_keys=(), redact_patterns=(),
+    promoted_fields=("request_id", "job_id", "source"),  # extra= keys lifted to top level
+    quiet_loggers=("httpx", "httpcore", "urllib3", "openai", "botocore", "redis", "asyncio"),
+    capture_uvicorn=True,      # route uvicorn's logs through boxlog, drop its access log
+)
+```
+
+To quiet more libraries while keeping the defaults, pass
+`quiet_loggers=(*boxlog.DEFAULT_QUIET_LOGGERS, "pinecone")`.
+
+You can call it again to change settings. It only replaces the handlers it installed
+itself. `boxlog.shutdown()` (also registered with `atexit`) flushes queued records.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/python -m pytest -q
+.venv/bin/python -m build && .venv/bin/python -m twine check dist/*
+```
+
+## License
+
+MIT

boxfusion_log-0.1.0/README.md

@@ -0,0 +1,214 @@
+# boxlog
+
+Structured JSON logging for Python, with request and job tracing, secret redaction,
+pluggable storage and a built-in web log viewer.
+
+```bash
+pip install boxfusion-log              # core: stdlib only, no dependencies
+pip install "boxfusion-log[redis]"     # + Redis storage
+pip install "boxfusion-log[web]"       # + the standalone `boxlog serve` viewer
+pip install "boxfusion-log[all]"
+```
+
+```python
+import boxlog   # the package installs as boxfusion-log but imports as boxlog
+```
+
+boxlog builds on the standard `logging` module, so it needs no new logger API. Your existing
+`logging.getLogger(__name__)` calls, and every third-party library's logs, flow through it
+unchanged.
+
+## Quick start
+
+```python
+import logging
+import boxlog
+
+boxlog.setup(service="billing", backend="sqlite:///logs/billing.db")
+log = logging.getLogger(__name__)
+
+log.info("Service started", extra={"event": "app.startup", "version": "1.4.2"})
+```
+
+Output on stdout, one JSON object per line:
+
+```json
+{"ts": "2026-09-29T09:16:21.180+00:00", "level": "INFO", "logger": "__main__",
+ "message": "Service started", "event": "app.startup", "service": "billing",
+ "extra": {"version": "1.4.2"}}
+```
+
+Use `stdout="text"` for readable lines during development.
+
+## Logging a unit of work: `log_step`
+
+One `with` block logs the start of the work, then either its success (with duration and
+any result fields) or its failure (with the traceback), and re-raises the error:
+
+```python
+with boxlog.log_step(log, "payment.charge", customer="c-42", amount=1999) as step:
+    receipt = gateway.charge(...)
+    step["receipt_id"] = receipt.id
+```
+
+| outcome | event                   | level | extras                                                  |
+|---------|-------------------------|-------|---------------------------------------------------------|
+| start   | `payment.charge.start`  | DEBUG | `customer`, `amount`                                    |
+| success | `payment.charge.ok`     | INFO  | `customer`, `amount`, `receipt_id`, `duration_ms`       |
+| failure | `payment.charge.failed` | ERROR | the fields, `duration_ms`, `error_type` and a traceback |
+
+It works around `await` too. Nested steps log each traceback only once, in the innermost
+step; outer steps still log `.failed`, so you see the chain of work that broke without
+reading the same traceback five times. In your own `except` blocks, check
+`boxlog.already_logged(exc)` for the same effect.
+
+## Tracing: `bind`
+
+Fields you bind are added to every record logged inside the block, including records
+from awaited code and from asyncio tasks started inside it:
+
+```python
+with boxlog.bind(job_id=job.id, tenant="acme"):
+    process(job)          # every record in here carries job_id and tenant
+```
+
+Field names must be lower_snake_case. The web middleware binds `request_id` for you.
+
+## Web frameworks
+
+**FastAPI / Starlette (ASGI):**
+
+```python
+import os
+from fastapi import FastAPI
+import boxlog
+
+boxlog.setup(service="api", backend="redis://localhost:6379/0?key=api:logs")
+
+app = FastAPI()
+app.add_middleware(boxlog.RequestIdMiddleware, quiet_paths=("/health", "/logs"))
+app.mount("/logs", boxlog.create_viewer(
+    boxlog.backend_from_url("redis://localhost:6379/0?key=api:logs"),
+    token=os.environ["LOGS_TOKEN"],
+    title="API logs",
+))
+```
+
+**Flask / Django (WSGI):**
+
+```python
+app.wsgi_app = boxlog.WSGIRequestIdMiddleware(app.wsgi_app)            # Flask
+application = boxlog.WSGIRequestIdMiddleware(get_wsgi_application())    # Django
+```
+
+Then view logs with the standalone viewer (below).
+
+The middleware:
+- reuses an incoming `X-Request-ID` if it's well-formed, and otherwise generates one;
+- echoes the id back on the response;
+- logs one `http.request` record per request (method, path, status and duration);
+- logs any unhandled exception with its traceback.
+
+## The web viewer
+
+The viewer has:
+- a level filter (including "Failures only");
+- service and source filters, populated from your data;
+- an event-prefix filter and text search;
+- click-to-trace on any `request_id` or `job_id`;
+- live tail;
+- an expandable view of every record and its traceback.
+
+- **Mounted** inside an ASGI app: `create_viewer(backend, token=...)`, as above.
+- **Standalone**, for any app, including non-web workers and scripts:
+
+  ```bash
+  export BOXLOG_TOKEN="$(boxlog token)"
+  boxlog serve sqlite:///logs/billing.db          # http://127.0.0.1:8765/
+  boxlog serve "redis://localhost:6379/0?key=api:logs" --port 9000 --title "API logs"
+  ```
+
+**Security.** Logs contain whatever your users send you, so treat the viewer like an admin
+console:
+- It requires a bearer token of **at least 32 characters**. Generate one with `boxlog token`.
+- If the token is unset, the mounted viewer answers 404 everywhere.
+- The page renders log content only as text, never as HTML, and ships under a strict
+  Content-Security-Policy with no inline script.
+- Serve it over HTTPS. The standalone server binds to `127.0.0.1` unless you pass `--host`.
+
+`create_viewer` also takes callables for `backend` and `token`. That's useful when they're
+only known at startup (for example, inside a lifespan).
+
+## Storage backends
+
+| backend         | URL                                                  | good for                                                                   |
+|-----------------|------------------------------------------------------|----------------------------------------------------------------------------|
+| `MemoryBackend` | `memory://?max=5000`                                 | tests and scripts; lost on restart                                         |
+| `SQLiteBackend` | `sqlite:///logs/app.db?max=100000`                   | one machine, no server; indexed queries; processes on one host can share the file |
+| `RedisBackend`  | `redis://host:6379/0?key=app:logs&max=10000`         | several processes or machines; survives restarts                           |
+
+```python
+boxlog.setup(service="worker", backend=boxlog.SQLiteBackend("logs/worker.db"))
+# or attach later, once settings are known:
+boxlog.attach_backend("redis://cache:6379/0?key=worker:logs")
+```
+
+Records reach the backend from a background thread, in batches, so logging never blocks
+your code or an event loop. If the backend is down, records are dropped (with one warning
+on stderr) and your app carries on; stdout logging is unaffected. Several services can
+share one backend, and the viewer shows a service filter when it finds more than one.
+
+A custom backend needs three methods, `append(entries)`, `query(query)` and `close()`. See
+`boxlog.backends.base.LogBackend`.
+
+## Redaction
+
+Before any output, boxlog masks:
+- values of sensitive keys in `extra=` and bound fields: `password`, `token`, `api_key`,
+  `secret`, `authorization`, `cookie`, … (as whole names or `_` suffixes, so `access_token`
+  is masked but `total_tokens` isn't);
+- `Bearer …` and `Basic …` credentials in text;
+- `password=…` and `"token": "…"` pairs in text;
+- passwords inside URLs (`redis://user:secret@host`);
+- all of the above in exception messages and tracebacks.
+
+You can add your own keys and patterns:
+
+```python
+boxlog.setup(redact_keys=["national_id"], redact_patterns=[r"\b\d{13}\b"])
+```
+
+Redaction is a safety net. Don't log secrets or whole request bodies on purpose.
+
+## `setup()` reference
+
+```python
+boxlog.setup(
+    service=None,              # tagged on every record
+    level="INFO",
+    stdout="json",             # "json", "text" or None
+    backend=None,              # LogBackend or URL
+    redact_keys=(), redact_patterns=(),
+    promoted_fields=("request_id", "job_id", "source"),  # extra= keys lifted to top level
+    quiet_loggers=("httpx", "httpcore", "urllib3", "openai", "botocore", "redis", "asyncio"),
+    capture_uvicorn=True,      # route uvicorn's logs through boxlog, drop its access log
+)
+```
+
+To quiet more libraries while keeping the defaults, pass
+`quiet_loggers=(*boxlog.DEFAULT_QUIET_LOGGERS, "pinecone")`.
+
+You can call it again to change settings. It only replaces the handlers it installed
+itself. `boxlog.shutdown()` (also registered with `atexit`) flushes queued records.
+
+## Development
+
+```bash
+python -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/python -m pytest -q
+.venv/bin/python -m build && .venv/bin/python -m twine check dist/*
+```
+
+## License
+
+MIT

boxfusion_log-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "boxfusion-log"
+version = "0.1.0"
+description = "Structured JSON logging with request tracing, secret redaction, pluggable storage and a built-in web log viewer."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Boxfusion" }]
+keywords = ["logging", "structured-logging", "json", "tracing", "log-viewer", "asgi", "fastapi"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Logging",
+    "Framework :: FastAPI",
+    "Typing :: Typed",
+]
+# The core is stdlib-only. Storage and the standalone viewer are opt-in.
+dependencies = []
+
+[project.optional-dependencies]
+redis = ["redis>=4.5"]
+web = ["uvicorn>=0.23"]
+all = ["redis>=4.5", "uvicorn>=0.23"]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+    "httpx>=0.27",
+    "redis>=4.5",
+    "uvicorn>=0.23",
+    "build>=1.2",
+    "twine>=5",
+]
+
+[project.scripts]
+boxlog = "boxlog.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/boxlog"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/boxlog", "tests", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+filterwarnings = ["error::DeprecationWarning:boxlog.*"]

boxfusion_log-0.1.0/src/boxlog/__init__.py

@@ -0,0 +1,69 @@
+"""boxlog - structured JSON logging with request tracing, secret redaction, pluggable
+storage and a built-in web log viewer.
+
+    import logging, boxlog
+
+    boxlog.setup(service="billing", backend="sqlite:///logs/billing.db")
+    log = logging.getLogger(__name__)
+
+    with boxlog.bind(request_id="abc"):
+        with boxlog.log_step(log, "invoice.create", customer="c-1") as step:
+            step["invoice_id"] = create_invoice()
+
+It builds on the standard `logging` module: existing `logging.getLogger(...)` calls,
+and third-party libraries' logs, all flow through it unchanged.
+"""
+
+from boxlog.backends import (
+    LogBackend,
+    MemoryBackend,
+    RedisBackend,
+    SQLiteBackend,
+    backend_from_url,
+)
+from boxlog.configure import (
+    DEFAULT_QUIET_LOGGERS,
+    attach_backend,
+    detach_backend,
+    set_level,
+    setup,
+    shutdown,
+)
+from boxlog.context import bind, current
+from boxlog.formatter import JsonFormatter, TextFormatter
+from boxlog.handler import BackendHandler
+from boxlog.middleware import RequestIdMiddleware, WSGIRequestIdMiddleware
+from boxlog.query import LogQuery
+from boxlog.redaction import Redactor
+from boxlog.timing import already_logged, log_step, mark_logged
+from boxlog.viewer import create_viewer
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_QUIET_LOGGERS",
+    "BackendHandler",
+    "JsonFormatter",
+    "LogBackend",
+    "LogQuery",
+    "MemoryBackend",
+    "Redactor",
+    "RedisBackend",
+    "RequestIdMiddleware",
+    "SQLiteBackend",
+    "TextFormatter",
+    "WSGIRequestIdMiddleware",
+    "__version__",
+    "already_logged",
+    "attach_backend",
+    "backend_from_url",
+    "bind",
+    "create_viewer",
+    "current",
+    "detach_backend",
+    "log_step",
+    "mark_logged",
+    "set_level",
+    "setup",
+    "shutdown",
+]

boxfusion_log-0.1.0/src/boxlog/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from boxlog.cli import main
+
+sys.exit(main())