dlogify 0.1.0__tar.gz

dlogify-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+.venv-*/
+__pycache__/
+*.pyc
+dist/

dlogify-0.1.0/LICENSE

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

dlogify-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.5
+Name: dlogify
+Version: 0.1.0
+Summary: Send Python logs and uncaught exceptions to dlogify.
+Project-URL: Homepage, https://dlogify.com
+Project-URL: Documentation, https://docs.dlogify.com/send-logs/python
+Author: Logify
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dlogify,errors,exceptions,logging,opentelemetry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Logging
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# dlogify
+
+Send your Python logs and uncaught exceptions to [Logify](https://dlogify.com), which groups errors, classifies them with AI and delivers tickets with the full context.
+
+Requires Python 3.10 or later. No dependencies.
+
+## Install
+
+```bash
+pip install dlogify
+export LOGIFY_API_KEY=lgf_live_…
+```
+
+## With the SDK
+
+```python
+import logging
+
+import dlogify
+
+dlogify.init(service="billing")
+logging.basicConfig(level=logging.INFO)
+```
+
+`init()` sends every record that passes your `logging` configuration, and every uncaught exception (main thread and other threads). It changes no logger's level and adds no handler, so `logging.basicConfig()` works before or after it and your console output stays as it was. Python's root logger shows `WARNING` and above unless you configure it, as above.
+
+```python
+log = logging.getLogger("billing")
+
+try:
+    charge(order_id)
+except PaymentError:
+    log.exception("charge failed", extra={"order_id": order_id})
+```
+
+Keys passed with `extra=` become attributes; `log.exception()` (or `exc_info=True`) attaches the traceback.
+
+You can also log directly:
+
+```python
+dlogify.info("order placed", attributes={"order_id": order_id})
+dlogify.error("charge failed", exc=err, attributes={"order_id": order_id})
+dlogify.log("warning", "disk almost full")  # any level name, any case
+dlogify.capture_exception()  # inside an except block
+dlogify.flush()              # before os._exit()
+```
+
+`log()` takes `trace`, `debug`, `info`, `warn`, `error` and `fatal`, and also Python's `warning` and `critical`, in any case; an unknown name logs at `info`.
+
+- `init(capture_logging=False)` or `init(capture_uncaught=False)` turns a capture off.
+- Calls before `init()` are dropped, and a second `init()` is ignored.
+- `dlogify.Client(**options)` creates an independent client.
+- `dictConfig` users can name the handler instead: `{"class": "dlogify.LogifyHandler"}` with `init(capture_logging=False)`; it sends through the `init()` client. With the capture left on, each record is still sent once.
+- `structlog` and `loguru` can write to the standard `logging` module, which dlogify captures.
+
+## Any process: logify run
+
+```bash
+LOGIFY_API_KEY=lgf_live_… pipx run dlogify run -- python manage.py runserver
+```
+
+With the package installed, the command is `logify run -- <cmd>`. The output appears in your terminal exactly as without dlogify, and the exit code is the command's. Python tracebacks, stack traces from other languages and Go panics become single events; JSON lines are read as structured records. A non-zero exit or a death by signal is reported as one more error, except a `SIGPIPE` after the reader of the output went away, as in `| head`. Not available on Windows.
+
+## Configuration
+
+Options passed to `init()` win over environment variables, which win over the defaults.
+
+| Variable | Option | Default |
+|---|---|---|
+| `LOGIFY_API_KEY` | `api_key` | Required; without it the client is disabled. |
+| `LOGIFY_ENDPOINT` | `endpoint` | `https://api.dlogify.com` |
+| `LOGIFY_SERVICE` | `service` | `OTEL_SERVICE_NAME`, then the `[project] name` of the nearest `pyproject.toml` from the working directory, then `unknown_service` |
+| `LOGIFY_ENVIRONMENT` | `environment` | `default` |
+| `LOGIFY_RELEASE` | `release` | empty |
+| `LOGIFY_MIN_LEVEL` | `min_level` | `info` (`trace`, `debug`, `info`, `warn`, `error`, `fatal`) |
+| `LOGIFY_DISABLED` | `disabled` | off (`1` or `true` turns the client into a no-op) |
+| `LOGIFY_DEBUG` | `debug` | off (`1` or `true` prints the client's diagnostics to stderr) |
+
+Also `attributes` (added to every record) and `max_queue_size` (default 2000). `disabled`, `debug`, `capture_logging` and `capture_uncaught` take `True` or `False`; any other value is ignored with a warning.
+
+## Guarantees
+
+- No call raises, and logging never waits for the network: records are sent by a background daemon thread, in compressed batches, with retries for up to 5 minutes.
+- If the key is rejected, the client stops for the rest of the process with one warning. Redirects are not followed: one warning names the URL to put in `LOGIFY_ENDPOINT`.
+- If the endpoint's TLS certificate cannot be verified, one warning says how to fix it: with Python from python.org on macOS, run `Install Certificates.command`; behind a proxy that inspects TLS, set `SSL_CERT_FILE` to its CA bundle.
+- After an uncaught exception the client sends what is queued, then Python reports the exception as usual. At normal exit it flushes too. An exit spends at most 2 seconds on this in total. `os._exit()` skips both, so call `dlogify.flush()` first.
+- Works with pre-fork servers such as gunicorn, and with `multiprocessing` children, which flush when their target returns. `Pool.terminate()` (also run when a `with Pool()` block ends) stops workers before they flush: call `pool.close()` and `pool.join()` instead. Other worker pools that end with `os._exit()` should call `dlogify.flush()` first.
+- The client's own messages go to stderr, never through `logging`.
+
+## What is sent
+
+Only log records: message, level, time, logger name, the attributes you pass, the exception's type, message and traceback, and the service name, environment, release, host name and SDK version. The SDK makes no other network calls and opens no ports. Personal data is redacted by Logify on arrival.
+
+Documentation: https://docs.dlogify.com/send-logs/python

dlogify-0.1.0/README.md

@@ -0,0 +1,94 @@
+# dlogify
+
+Send your Python logs and uncaught exceptions to [Logify](https://dlogify.com), which groups errors, classifies them with AI and delivers tickets with the full context.
+
+Requires Python 3.10 or later. No dependencies.
+
+## Install
+
+```bash
+pip install dlogify
+export LOGIFY_API_KEY=lgf_live_…
+```
+
+## With the SDK
+
+```python
+import logging
+
+import dlogify
+
+dlogify.init(service="billing")
+logging.basicConfig(level=logging.INFO)
+```
+
+`init()` sends every record that passes your `logging` configuration, and every uncaught exception (main thread and other threads). It changes no logger's level and adds no handler, so `logging.basicConfig()` works before or after it and your console output stays as it was. Python's root logger shows `WARNING` and above unless you configure it, as above.
+
+```python
+log = logging.getLogger("billing")
+
+try:
+    charge(order_id)
+except PaymentError:
+    log.exception("charge failed", extra={"order_id": order_id})
+```
+
+Keys passed with `extra=` become attributes; `log.exception()` (or `exc_info=True`) attaches the traceback.
+
+You can also log directly:
+
+```python
+dlogify.info("order placed", attributes={"order_id": order_id})
+dlogify.error("charge failed", exc=err, attributes={"order_id": order_id})
+dlogify.log("warning", "disk almost full")  # any level name, any case
+dlogify.capture_exception()  # inside an except block
+dlogify.flush()              # before os._exit()
+```
+
+`log()` takes `trace`, `debug`, `info`, `warn`, `error` and `fatal`, and also Python's `warning` and `critical`, in any case; an unknown name logs at `info`.
+
+- `init(capture_logging=False)` or `init(capture_uncaught=False)` turns a capture off.
+- Calls before `init()` are dropped, and a second `init()` is ignored.
+- `dlogify.Client(**options)` creates an independent client.
+- `dictConfig` users can name the handler instead: `{"class": "dlogify.LogifyHandler"}` with `init(capture_logging=False)`; it sends through the `init()` client. With the capture left on, each record is still sent once.
+- `structlog` and `loguru` can write to the standard `logging` module, which dlogify captures.
+
+## Any process: logify run
+
+```bash
+LOGIFY_API_KEY=lgf_live_… pipx run dlogify run -- python manage.py runserver
+```
+
+With the package installed, the command is `logify run -- <cmd>`. The output appears in your terminal exactly as without dlogify, and the exit code is the command's. Python tracebacks, stack traces from other languages and Go panics become single events; JSON lines are read as structured records. A non-zero exit or a death by signal is reported as one more error, except a `SIGPIPE` after the reader of the output went away, as in `| head`. Not available on Windows.
+
+## Configuration
+
+Options passed to `init()` win over environment variables, which win over the defaults.
+
+| Variable | Option | Default |
+|---|---|---|
+| `LOGIFY_API_KEY` | `api_key` | Required; without it the client is disabled. |
+| `LOGIFY_ENDPOINT` | `endpoint` | `https://api.dlogify.com` |
+| `LOGIFY_SERVICE` | `service` | `OTEL_SERVICE_NAME`, then the `[project] name` of the nearest `pyproject.toml` from the working directory, then `unknown_service` |
+| `LOGIFY_ENVIRONMENT` | `environment` | `default` |
+| `LOGIFY_RELEASE` | `release` | empty |
+| `LOGIFY_MIN_LEVEL` | `min_level` | `info` (`trace`, `debug`, `info`, `warn`, `error`, `fatal`) |
+| `LOGIFY_DISABLED` | `disabled` | off (`1` or `true` turns the client into a no-op) |
+| `LOGIFY_DEBUG` | `debug` | off (`1` or `true` prints the client's diagnostics to stderr) |
+
+Also `attributes` (added to every record) and `max_queue_size` (default 2000). `disabled`, `debug`, `capture_logging` and `capture_uncaught` take `True` or `False`; any other value is ignored with a warning.
+
+## Guarantees
+
+- No call raises, and logging never waits for the network: records are sent by a background daemon thread, in compressed batches, with retries for up to 5 minutes.
+- If the key is rejected, the client stops for the rest of the process with one warning. Redirects are not followed: one warning names the URL to put in `LOGIFY_ENDPOINT`.
+- If the endpoint's TLS certificate cannot be verified, one warning says how to fix it: with Python from python.org on macOS, run `Install Certificates.command`; behind a proxy that inspects TLS, set `SSL_CERT_FILE` to its CA bundle.
+- After an uncaught exception the client sends what is queued, then Python reports the exception as usual. At normal exit it flushes too. An exit spends at most 2 seconds on this in total. `os._exit()` skips both, so call `dlogify.flush()` first.
+- Works with pre-fork servers such as gunicorn, and with `multiprocessing` children, which flush when their target returns. `Pool.terminate()` (also run when a `with Pool()` block ends) stops workers before they flush: call `pool.close()` and `pool.join()` instead. Other worker pools that end with `os._exit()` should call `dlogify.flush()` first.
+- The client's own messages go to stderr, never through `logging`.
+
+## What is sent
+
+Only log records: message, level, time, logger name, the attributes you pass, the exception's type, message and traceback, and the service name, environment, release, host name and SDK version. The SDK makes no other network calls and opens no ports. Personal data is redacted by Logify on arrival.
+
+Documentation: https://docs.dlogify.com/send-logs/python

dlogify-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "dlogify"
+version = "0.1.0"
+description = "Send Python logs and uncaught exceptions to dlogify."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Logify" }]
+keywords = ["logging", "errors", "exceptions", "opentelemetry", "dlogify"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: System :: Logging",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://dlogify.com"
+Documentation = "https://docs.dlogify.com/send-logs/python"
+
+[project.scripts]
+logify = "dlogify.run.cli:main"
+dlogify = "dlogify.run.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8.3"]
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dlogify"]
+
+[tool.hatch.build.targets.sdist]
+# Anchored: an unanchored "LICENSE" also matches the licenses inside .venv*/.
+include = ["/src/dlogify", "/README.md", "/LICENSE", "/pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-p no:cacheprovider"

dlogify-0.1.0/src/dlogify/__init__.py

@@ -0,0 +1,160 @@
+"""dlogify: send Python logs and uncaught exceptions to Logify.
+
+    import dlogify
+    dlogify.init()
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Optional
+
+from . import _singleton
+from ._client import Client
+from ._diagnostics import Diagnostics, is_flag
+from ._version import VERSION as __version__
+from .handler import LogifyHandler
+
+__all__ = [
+    "init",
+    "trace",
+    "debug",
+    "info",
+    "warn",
+    "warning",
+    "error",
+    "fatal",
+    "critical",
+    "log",
+    "capture_exception",
+    "flush",
+    "shutdown",
+    "Client",
+    "LogifyHandler",
+    "__version__",
+]
+
+_noted_before_init = False
+
+
+def _active() -> Optional[Client]:
+    global _noted_before_init
+    client = _singleton.current
+    if client is None and not _noted_before_init:
+        _noted_before_init = True
+        try:
+            Diagnostics(is_flag(os.environ.get("LOGIFY_DEBUG"))).debug("a log call before init() was dropped")
+        except Exception:
+            pass
+    return client
+
+
+def init(
+    *,
+    api_key: Optional[str] = None,
+    endpoint: Optional[str] = None,
+    service: Optional[str] = None,
+    environment: Optional[str] = None,
+    release: Optional[str] = None,
+    min_level: Optional[str] = None,
+    capture_logging: bool = True,
+    capture_uncaught: bool = True,
+    attributes: Optional[Mapping[str, object]] = None,
+    max_queue_size: Optional[int] = None,
+    disabled: Optional[bool] = None,
+    debug: Optional[bool] = None,
+) -> None:
+    """Starts the client: captures logging and uncaught exceptions unless turned off.
+    Safe to call from any thread; a second call is ignored."""
+    try:
+        with _singleton.lock:
+            existing = _singleton.current
+            if existing is not None:
+                existing.diagnostics.debug("init() was called again; ignored")
+                return
+            _singleton.current = Client(
+                api_key=api_key,
+                endpoint=endpoint,
+                service=service,
+                environment=environment,
+                release=release,
+                min_level=min_level,
+                capture_logging=capture_logging,
+                capture_uncaught=capture_uncaught,
+                attributes=attributes,
+                max_queue_size=max_queue_size,
+                disabled=disabled,
+                debug=debug,
+            )
+    except Exception:
+        pass  # init() never raises
+
+
+def trace(message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.trace(message, exc=exc, attributes=attributes)
+
+
+def debug(message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.debug(message, exc=exc, attributes=attributes)
+
+
+def info(message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.info(message, exc=exc, attributes=attributes)
+
+
+def warn(message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.warn(message, exc=exc, attributes=attributes)
+
+
+warning = warn
+
+
+def error(message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.error(message, exc=exc, attributes=attributes)
+
+
+def fatal(message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.fatal(message, exc=exc, attributes=attributes)
+
+
+critical = fatal
+
+
+def log(level: str, message: object, *, exc: Optional[BaseException] = None, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.log(level, message, exc=exc, attributes=attributes)
+
+
+def capture_exception(exc: Optional[BaseException] = None, *, attributes: Optional[Mapping[str, object]] = None) -> None:
+    client = _active()
+    if client is not None:
+        client.capture_exception(exc, attributes=attributes)
+
+
+def flush(timeout: float = 2.0) -> None:
+    client = _singleton.current
+    if client is not None:
+        client.flush(timeout)
+
+
+def shutdown(timeout: float = 2.0) -> None:
+    """Flushes, stops and restores what init() installed; init() may run again."""
+    with _singleton.lock:
+        client = _singleton.current
+        _singleton.current = None
+    if client is not None:
+        client.shutdown(timeout)

dlogify-0.1.0/src/dlogify/__main__.py

@@ -0,0 +1,3 @@
+from .run.cli import main
+
+main()

dlogify-0.1.0/src/dlogify/_capture_logging.py

@@ -0,0 +1,56 @@
+"""init() hands every logging record to its LogifyHandler by wrapping
+Logger.callHandlers instead of adding a handler to the root logger: a root
+logger without handlers keeps logging.basicConfig() and logging.lastResort
+working (spec D3)."""
+
+from __future__ import annotations
+
+import logging
+import threading
+from typing import Callable
+
+_lock = threading.Lock()
+_handlers: list[logging.Handler] = []
+# The wrapper we installed last, while Logger.callHandlers is still it.
+_installed: "Callable | None" = None
+
+
+def _wrap(previous: Callable) -> Callable:
+    def call_handlers(self: logging.Logger, record: logging.LogRecord) -> None:
+        try:
+            previous(self, record)
+        finally:
+            # Another library may have wrapped us and been wrapped again: each
+            # record reaches our handlers once.
+            if not getattr(record, "_dlogify_seen", False):
+                try:
+                    record._dlogify_seen = True
+                    for handler in tuple(_handlers):
+                        if record.levelno >= handler.level:
+                            handler.handle(record)
+                except Exception:
+                    pass  # never break the application's logging call
+
+    call_handlers._dlogify_previous = previous  # type: ignore[attr-defined]
+    return call_handlers
+
+
+def install_logging_capture(handler: logging.Handler) -> Callable[[], None]:
+    global _installed
+    with _lock:
+        current = logging.Logger.callHandlers
+        if not hasattr(current, "_dlogify_previous"):
+            _installed = _wrap(current)
+            logging.Logger.callHandlers = _installed  # type: ignore[method-assign]
+        _handlers.append(handler)
+
+    def undo() -> None:
+        global _installed
+        with _lock:
+            if handler in _handlers:
+                _handlers.remove(handler)
+            if not _handlers and _installed is not None and logging.Logger.callHandlers is _installed:
+                logging.Logger.callHandlers = _installed._dlogify_previous  # type: ignore[attr-defined,method-assign]
+                _installed = None
+
+    return undo