dlogify 0.1.0__py3-none-any.whl

dlogify/_record.py

@@ -0,0 +1,149 @@
+"""Records: attribute values, exceptions and size cuts (docs/12 §3)."""
+
+from __future__ import annotations
+
+import json
+import math
+import time
+import traceback
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+from types import TracebackType
+from typing import Optional, Union
+
+from ._levels import Level
+
+AttributeValue = Union[str, bool, int, float]
+
+# docs/12 §3 size cuts, in UTF-8 bytes.
+BODY_MAX_BYTES = 16 * 1024
+STACKTRACE_MAX_BYTES = 40 * 1024
+ATTRIBUTE_MAX_BYTES = 4 * 1024
+
+
+@dataclass(frozen=True)
+class LogRecord:
+    scope: str
+    time_unix_nano: str
+    observed_time_unix_nano: str
+    level: Optional[Level]
+    body: str
+    attributes: dict[str, object]
+
+
+def now_unix_nano() -> str:
+    return str(time.time_ns())
+
+
+def ms_to_unix_nano(ms: float) -> str:
+    return str(round(ms * 1000) * 1000)
+
+
+def seconds_to_unix_nano(seconds: float) -> str:
+    return str(round(seconds * 1_000_000) * 1000)
+
+
+def normalize_value(value: object) -> Optional[AttributeValue]:
+    """Strings, booleans, integers and finite floats keep their type; None is
+    skipped; anything else is its compact JSON, or str() when JSON cannot render it."""
+    if value is None:
+        return None
+    if isinstance(value, (str, bool, int)):
+        return value
+    if isinstance(value, float) and math.isfinite(value):
+        return value
+    try:
+        return json.dumps(value, separators=(",", ":"), ensure_ascii=False, default=str)
+    except Exception:
+        pass
+    try:
+        return str(value)
+    except Exception:
+        return object.__repr__(value)
+
+
+def normalize_attributes(source: object, into: Optional[dict] = None) -> dict:
+    out: dict = {} if into is None else into
+    if not isinstance(source, Mapping):
+        return out
+    for key, raw in source.items():
+        value = normalize_value(raw)
+        if value is not None:
+            out[str(key)] = value
+    return out
+
+
+def exception_type(exc: BaseException) -> str:
+    cls = type(exc)
+    name = getattr(cls, "__qualname__", None) or cls.__name__
+    module = getattr(cls, "__module__", None)
+    return name if module in (None, "builtins") else f"{module}.{name}"
+
+
+def exception_message(exc: BaseException) -> str:
+    try:
+        return str(exc)
+    except Exception:
+        return "<exception str() failed>"
+
+
+def exception_title(type_: str, message: str) -> str:
+    return f"{type_}: {message}" if message else type_
+
+
+def exception_attributes(exc: BaseException, tb: Optional[TracebackType] = None) -> dict[str, str]:
+    """docs/12 §3 Errors: format_exception already includes chained exceptions."""
+    type_ = exception_type(exc)
+    message = exception_message(exc)
+    try:
+        stack = "".join(traceback.format_exception(type(exc), exc, tb if tb is not None else exc.__traceback__))
+    except Exception:
+        stack = exception_title(type_, message)
+    return {"exception.type": type_, "exception.message": message, "exception.stacktrace": stack}
+
+
+def utf8_cut_index(data: bytes, max_bytes: int) -> int:
+    """The largest index <= max_bytes that does not split a UTF-8 sequence."""
+    if len(data) <= max_bytes:
+        return len(data)
+    end = max_bytes
+    while end > 0 and end > max_bytes - 3 and (data[end] & 0xC0) == 0x80:
+        end -= 1
+    return end
+
+
+def utf8_safe(text: str) -> str:
+    """Lone surrogates (from surrogateescape decoding) cannot be UTF-8 encoded: they become '?'."""
+    try:
+        text.encode("utf-8")
+        return text
+    except UnicodeEncodeError:
+        return text.encode("utf-8", "replace").decode("utf-8")
+
+
+def cut_utf8(text: str, max_bytes: int) -> tuple[str, bool]:
+    if text.isascii() and len(text) <= max_bytes:
+        return text, False
+    data = utf8_safe(text).encode("utf-8")
+    if len(data) <= max_bytes:
+        return data.decode("utf-8"), False
+    return data[: utf8_cut_index(data, max_bytes)].decode("utf-8"), True
+
+
+def finalize_record(record: LogRecord) -> LogRecord:
+    """Normalizes attribute values and applies the size cuts; a cut record
+    carries logify.truncated = true."""
+    body, truncated = cut_utf8(record.body, BODY_MAX_BYTES)
+    attributes: dict[str, object] = {}
+    for key, raw in record.attributes.items():
+        value = normalize_value(raw)
+        if value is None:
+            continue
+        name = utf8_safe(str(key))
+        if isinstance(value, str):
+            value, cut = cut_utf8(value, STACKTRACE_MAX_BYTES if name == "exception.stacktrace" else ATTRIBUTE_MAX_BYTES)
+            truncated = truncated or cut
+        attributes[name] = value
+    if truncated:
+        attributes["logify.truncated"] = True
+    return replace(record, body=body, attributes=attributes)

dlogify/_singleton.py

@@ -0,0 +1,12 @@
+"""The client created by init(); LogifyHandler without a client reads it too."""
+
+from __future__ import annotations
+
+import threading
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from ._client import Client
+
+lock = threading.Lock()
+current: Optional["Client"] = None

dlogify/_version.py

@@ -0,0 +1,4 @@
+VERSION = "0.1.0"
+USER_AGENT = f"logify-python/{VERSION}"
+SDK_NAME = "logify.python"
+SDK_LANGUAGE = "python"

dlogify/handler.py

@@ -0,0 +1,70 @@
+"""LogifyHandler: sends `logging` records to Logify (spec §3). init() installs
+one; applications that configure logging with dictConfig can name the class:
+{"class": "dlogify.LogifyHandler"}."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Optional, Union
+
+from . import _singleton
+from ._diagnostics import describe_error
+from ._guard import guarded, is_guarded
+from ._levels import level_from_levelno
+from ._record import exception_attributes, exception_title, seconds_to_unix_nano
+
+if TYPE_CHECKING:
+    from ._client import Client
+
+# The attributes every LogRecord has; anything else came from `extra=`.
+_STANDARD = frozenset(logging.LogRecord("", 0, "", 0, "", (), None).__dict__) | {"message", "asctime"}
+
+
+class LogifyHandler(logging.Handler):
+    def __init__(self, level: Union[int, str] = logging.NOTSET, *, client: Optional["Client"] = None) -> None:
+        super().__init__(level)
+        self._client = client
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if is_guarded() or record.name == "dlogify" or record.name.startswith("dlogify."):
+            return
+        client = self._client if self._client is not None else _singleton.current
+        if client is None:
+            return
+        # A handler named in dictConfig and init()'s capture both reach a
+        # record: each client sends it once. Ids, not clients: QueueHandler and
+        # SocketHandler pickle the record's attributes.
+        try:
+            sent_to = record.__dict__.setdefault("_dlogify_clients", [])
+            if id(client) in sent_to:
+                return
+            sent_to.append(id(client))
+            with guarded():
+                body, attributes = _parts(record)
+                client._emit(
+                    "logging", level_from_levelno(record.levelno), body, attributes, time_unix_nano=seconds_to_unix_nano(record.created)
+                )
+        except Exception as err:
+            client.diagnostics.debug(f"dropped a logging record: {describe_error(err)}")
+
+    def handleError(self, record: logging.LogRecord) -> None:
+        """Never print logging's error report: emit() reports through diagnostics."""
+
+
+def _parts(record: logging.LogRecord) -> tuple[str, dict[str, object]]:
+    try:
+        message = record.getMessage()
+    except Exception:
+        message = str(record.msg)
+    attributes: dict[str, object] = {}
+    exc_info = record.exc_info
+    if isinstance(exc_info, tuple) and len(exc_info) == 3 and isinstance(exc_info[1], BaseException):
+        exception = exception_attributes(exc_info[1], exc_info[2])
+        attributes.update(exception)
+        if not message:
+            message = exception_title(exception["exception.type"], exception["exception.message"])
+    attributes["logger.name"] = record.name
+    for key, value in record.__dict__.items():
+        if key not in _STANDARD and not key.startswith("_"):
+            attributes[key] = value
+    return message, attributes

dlogify/run/child.py

@@ -0,0 +1,215 @@
+"""docs/12 §5.7 and spec §5: run a command, pass its output through unchanged,
+send a parsed copy."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import threading
+import time
+from collections.abc import Sequence
+from typing import IO, Optional
+
+from .._client import Client, Internals
+from .._diagnostics import Diagnostics, describe_error
+from .._parse.stream_parser import StreamParser, StreamRecord
+from .._version import USER_AGENT
+
+USAGE = "usage: logify run -- <command> [args...]\n"
+EXIT_FLUSH_TIMEOUT = 5.0
+TICK = 0.1
+# After the child exits, how long its pipes may still deliver output. A
+# background grandchild can hold them open forever; we do not wait for it.
+PIPE_GRACE = 0.5
+_READ_SIZE = 65536
+
+
+def parse_run_args(argv: Sequence[str]) -> Optional[tuple[str, list[str]]]:
+    if len(argv) < 3 or argv[0] != "run" or argv[1] != "--":
+        return None
+    return argv[2], list(argv[3:])
+
+
+def _write_all(fd: int, data: bytes) -> None:
+    view = memoryview(data)
+    while view:
+        written = os.write(fd, view)
+        view = view[written:]
+
+
+class _Relay:
+    """Copies one child stream to ours first, unchanged, then parses a copy."""
+
+    def __init__(self, source: IO[bytes], target_fd: int, parser: StreamParser, diagnostics: Diagnostics) -> None:
+        self._source = source
+        self._target_fd = target_fd
+        self._parser = parser
+        self._diagnostics = diagnostics
+        self._lock = threading.Lock()
+        self._finished = False
+        self.reader_gone = False
+        self._thread = threading.Thread(target=self._run, name=f"logify-run-{parser.stream}", daemon=True)
+
+    def start(self) -> None:
+        self._thread.start()
+
+    def join(self, timeout: float) -> None:
+        self._thread.join(max(0.0, timeout))
+
+    def tick(self) -> None:
+        with self._lock:
+            if not self._finished:
+                self._safely(self._parser.tick)
+
+    def finish(self) -> None:
+        with self._lock:
+            if not self._finished:
+                self._finished = True
+                self._safely(self._parser.end)
+
+    def _run(self) -> None:
+        fd = self._source.fileno()
+        while True:
+            try:
+                chunk = os.read(fd, _READ_SIZE)
+            except OSError:
+                return
+            if not chunk:
+                return
+            try:
+                _write_all(self._target_fd, chunk)
+            except OSError:
+                # Our reader went away (as in `logify run -- cmd | head`): close
+                # the child's pipe too, so the child sees it as it would without us.
+                self.reader_gone = True
+                try:
+                    self._source.close()
+                except OSError:
+                    pass
+                return
+            with self._lock:
+                if not self._finished:
+                    self._safely(lambda: self._parser.push(chunk))
+
+    def _safely(self, action) -> None:
+        try:
+            action()
+        except Exception as err:
+            self._diagnostics.debug(f"parse failed: {describe_error(err)}")
+
+
+def _cannot_run(command: str, reason: str, code: int) -> int:
+    try:
+        os.write(2, f"logify: cannot run {command}: {reason}\n".encode("utf-8", "replace"))
+    except OSError:
+        pass
+    return code
+
+
+def _signal_name(signum: int) -> str:
+    try:
+        return signal.Signals(signum).name
+    except ValueError:
+        return f"signal {signum}"
+
+
+def _stdin_is_tty() -> bool:
+    try:
+        return os.isatty(0)
+    except OSError:
+        return False
+
+
+def _reraise(signum: int) -> None:
+    """Dies from the child's signal, like the child did."""
+    try:
+        signal.signal(signum, signal.SIG_DFL)
+    except (OSError, ValueError):
+        pass  # SIGKILL and SIGSTOP cannot be changed, and need not be
+    try:
+        os.kill(os.getpid(), signum)
+    except OSError:
+        return
+    time.sleep(1)  # delivery is asynchronous; still alive afterwards: the signal does not kill
+
+
+def run_command(command: str, args: list[str]) -> int:
+    # `logify run` is not the application: no logging or uncaught capture.
+    client = Client(capture_logging=False, capture_uncaught=False, _internals=Internals(user_agent=f"{USER_AGENT} run"))
+    env = dict(os.environ)
+    env.setdefault("PYTHONUNBUFFERED", "1")
+    try:
+        child = subprocess.Popen([command, *args], stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, bufsize=0)
+    except FileNotFoundError:
+        return _cannot_run(command, "command not found", 127)
+    except PermissionError:
+        return _cannot_run(command, "permission denied", 126)
+    except OSError as err:
+        return _cannot_run(command, err.strerror or describe_error(err), 126)
+
+    def emit(record: StreamRecord) -> None:
+        client._emit("logify.run", record.level, record.body, dict(record.attributes), time_unix_nano=record.time_unix_nano)
+
+    def now() -> float:
+        return time.time() * 1000
+
+    assert child.stdout is not None and child.stderr is not None
+    relays = [
+        _Relay(child.stdout, 1, StreamParser("stdout", now, emit), client.diagnostics),
+        _Relay(child.stderr, 2, StreamParser("stderr", now, emit), client.diagnostics),
+    ]
+    for relay in relays:
+        relay.start()
+    stop_ticker = threading.Event()
+
+    def tick_loop() -> None:
+        while not stop_ticker.wait(TICK):
+            for relay in relays:
+                relay.tick()
+
+    threading.Thread(target=tick_loop, name="logify-run-ticker", daemon=True).start()
+
+    # Signals logify run received, forwarded or not: a child they end is not reported.
+    received: set[int] = set()
+    from_terminal = _stdin_is_tty()
+    # A terminal sends Ctrl-C and hang-up to its whole foreground process group,
+    # child included: forwarding them again would deliver each one twice.
+    terminal_signals = {signal.SIGINT, signal.SIGHUP}
+
+    def on_signal(signum: int, frame: object) -> None:
+        received.add(signum)
+        if from_terminal and signum in terminal_signals:
+            return
+        try:
+            child.send_signal(signum)
+        except OSError:
+            pass
+
+    previous = {sig: signal.signal(sig, on_signal) for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP)}
+    returncode = 1
+    signum: Optional[int] = None
+    try:
+        returncode = child.wait()
+        deadline = time.monotonic() + PIPE_GRACE
+        for relay in relays:
+            relay.join(deadline - time.monotonic())
+        stop_ticker.set()
+        for relay in relays:
+            relay.finish()
+        signum = -returncode if returncode < 0 else None
+        # `logify run -- cmd | head`: the child died as it would have without us.
+        pipeline_ended = signum == signal.SIGPIPE and any(relay.reader_gone for relay in relays)
+        if signum is not None and signum not in received and not pipeline_ended:
+            name = _signal_name(signum)
+            client._emit("logify.run", "error", f"Process terminated by {name}", {"process.signal": name})
+        elif signum is None and returncode != 0:
+            client._emit("logify.run", "error", f"Process exited with code {returncode}", {"process.exit_code": returncode})
+        client.flush(EXIT_FLUSH_TIMEOUT)
+    finally:
+        for sig, handler in previous.items():
+            signal.signal(sig, handler)
+    if signum is not None:
+        _reraise(signum)
+        return 128 + signum
+    return returncode

dlogify/run/cli.py

@@ -0,0 +1,22 @@
+"""`logify run -- <cmd> [args…]` (also `pipx run dlogify run -- …` and `python -m dlogify run -- …`)."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import NoReturn, Optional
+
+from .child import USAGE, parse_run_args
+
+
+def main(argv: Optional[list[str]] = None) -> NoReturn:
+    parsed = parse_run_args(sys.argv[1:] if argv is None else argv)
+    if parsed is None:
+        sys.stderr.write(USAGE)
+        sys.exit(2)
+    if os.name == "nt":
+        sys.stderr.write("logify: logify run is not supported on Windows\n")
+        sys.exit(1)
+    from .child import run_command
+
+    sys.exit(run_command(*parsed))

dlogify-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,31 @@
+dlogify/__init__.py,sha256=Kv1MycTyEBAhha8Wg3UWrtcV3dp_gWoyLWwKm4kpQXU,4862
+dlogify/__main__.py,sha256=6RSh346QjO75J3d6h1QNgxzm46ZBogNQ2HpQHE1DiYM,34
+dlogify/_capture_logging.py,sha256=zo-NccwyUT9EU9YicE7WgUJ_QkyaOD22oTdB5Zuq3h0,2128
+dlogify/_client.py,sha256=gK4TD8oyY8IH9WU1V5SRNYRTcUH3K4T7wdAPLQXV6uc,10024
+dlogify/_config.py,sha256=yvH-uRFr6OyfzMKjT-u8osfYioibICgh05gTHUuUwKk,6718
+dlogify/_diagnostics.py,sha256=7eN0mtALexYNYJO6go8yB4ZcP-uVpArSRltFBqe483g,1438
+dlogify/_encode.py,sha256=ZORsngCxtxtf8TmsuSMtLhL9YMdzpujrv4t3O4uHzi8,3420
+dlogify/_exporter.py,sha256=AVM9CqNTFPygwWfTTafgnKeXgpSr7XZ8g8EoMKRgoL4,15791
+dlogify/_guard.py,sha256=Bu6mcxiC0uJL0oNLMD7iwxSfE2fxuS027T0RHaOzf_Q,716
+dlogify/_hooks.py,sha256=A_49x7G92vxCr7aunSciMWDWjoS6XyL6Lo2fPk738Tc,3220
+dlogify/_http.py,sha256=VJnn4Tlau3_KObT_VRsmgCi8P51KSYF4otPToZGZfKQ,1606
+dlogify/_levels.py,sha256=BuoqSBBNjfK9OLHaE215Aa1dxH1W2NpjG6CV-TzEXgw,2385
+dlogify/_record.py,sha256=VBFEhi-F9ETE0ptbevABug0R_c5moIuMqRRLgo_yWFo,4714
+dlogify/_singleton.py,sha256=Ox3CPZJXo3wBUKooL678Uxsn_f06zc2rx9ixzGP6U1E,289
+dlogify/_version.py,sha256=0jSTKJwvVJIrWp3INk0MyX5pUM58Yu17Cwzmngf9S34,109
+dlogify/handler.py,sha256=_TbzM-opDmhINBchoyTr-6SSD-YkjkswY-fXGaPeNSM,2985
+dlogify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dlogify/_parse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dlogify/_parse/compact_json.py,sha256=qm9ytdTJYhmqzaYXb9gYa3DPZBvCFLiYF81MtescrRs,1893
+dlogify/_parse/json_line.py,sha256=V_arqLnzyke_EsQHHtnzmZlV9-0WnGntF9F9_QeSloc,6072
+dlogify/_parse/lines.py,sha256=PJl-CMkpyXGkMfy8Qy6ZUjzWEyDSxezXxhV3UYBD3SE,1778
+dlogify/_parse/stream_parser.py,sha256=4xL3ibEJvkF9HN7av260lxo6PhoALXsn_vsgW9fTJ8s,3468
+dlogify/_parse/text_event.py,sha256=Q_FXrxwW78eYoVkl70EJzB8j-a7wmo-ruK3zZckS3_Q,5943
+dlogify/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dlogify/run/child.py,sha256=ExdgTc2A8qCH8rknle7cJTM5aociL_9SjuA9f74Eh8M,7485
+dlogify/run/cli.py,sha256=f1-FAhc-fviW8rRf2Ft4-CuGSjL9K4rXsl14bM2JZ58,642
+dlogify-0.1.0.dist-info/METADATA,sha256=Ad2tDWS_7hFMmyl99ObHecQOyQiF9X2lkySdeohQXgE,5955
+dlogify-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+dlogify-0.1.0.dist-info/entry_points.txt,sha256=P8nsnJ3WXqEYGaiQXf3R-BAfGxYtMMi4SqKYWc2rPlE,79
+dlogify-0.1.0.dist-info/licenses/LICENSE,sha256=lvxNg1CobdsJEl7Qr0NKRtS_8nDYnjBywS131kfk_lM,1063
+dlogify-0.1.0.dist-info/RECORD,,

dlogify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

dlogify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dlogify = dlogify.run.cli:main
+logify = dlogify.run.cli:main

dlogify-0.1.0.dist-info/licenses/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.