metricallize 0.1.0__tar.gz

metricallize-0.1.0/LICENSE

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

metricallize-0.1.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: metricallize
+Version: 0.1.0
+Summary: TinyDB-based document storage for simple telemetry/logging with sync, cached and serialized async modes.
+Author: migue
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/metricallize/
+Keywords: tinydb,telemetry,logging,metrics,document-store
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tinydb>=4.0.0
+Provides-Extra: serialized-async
+Requires-Dist: orjson>=3.9.0; extra == "serialized-async"
+Requires-Dist: blosc2>=2.0.0; extra == "serialized-async"
+Dynamic: license-file
+
+# metricallize
+
+Uma forma simples de armazenar telemetria/logs em “banco de documentos” usando TinyDB, com 3 modos de persistência:
+
+- `readable_sync`: JSON legível (escreve no disco de forma direta)
+- `in_memory_async`: JSON legível com cache em memória (escreve em batch, no flush/close)
+- `serialized_async`: arquivo binário/comprimido (mais rápido/menor, escreve em background; exige flush/close)
+
+## Instalação
+
+```bash
+pip install metricallize
+```
+
+Para usar o modo `serialized_async` (serialização/compressão):
+
+```bash
+pip install "metricallize[serialized_async]"
+```
+
+## Conceitos
+
+- Você cria um `DocumentStorage`
+- Você acessa qualquer table com `storage.db.table("nome")`
+- O decorator `storage.capture(table="...")` registra uma “execução” (status/duração/erro) nessa table
+
+Campos automáticos gravados pelo `capture`:
+
+- `ts`: `YYYY-MM-DD HH:MM:SS.xxx` (UTC)
+- `name`: `module.qualname` da função
+- `status`: `ok` ou `error`
+- `duration`: `HH:MM:SS`
+- Em caso de erro: `exc_type`, `exc_msg`
+
+## Path e versionamento (por mês)
+
+Se você passar `path` como diretório (sem extensão), o arquivo é criado automaticamente em:
+
+`<path>/storage/YYYY_MM/day_DD.json` (modos legíveis)  
+`<path>/storage/YYYY_MM/day_DD.db` (modo serialized)
+
+Você pode controlar o nome base com `name="..."`.
+
+## Uso: readable_sync (JSON legível)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(path=storage_dir, mode="readable_sync", name="logger")
+
+logger = storage.db.table("loggers")
+logger.insert({"event": "startup"})
+```
+
+## Uso: in_memory_async (cache em memória, JSON legível)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(
+    path=storage_dir,
+    mode="in_memory_async",
+    name="trace",
+    write_cache_size=100_000,
+)
+
+trace = storage.db.table("trace")
+trace.insert({"event": "step"})
+
+storage.flush()
+storage.close()
+```
+
+## Uso: serialized_async (binário, assíncrono)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(path=storage_dir, mode="serialized_async", name="trace")
+
+trace = storage.db.table("trace")
+trace.insert({"event": "step"})
+
+storage.flush()
+storage.close()
+```
+
+## Decorator: capture
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage = DocumentStorage(path=Path.cwd() / "data", mode="readable_sync")
+table_name = "trace"
+
+@storage.capture(table=table_name)
+def soma(a: int, b: int) -> int:
+    return a + b
+
+@storage.capture(table=table_name)
+def falha() -> None:
+    raise RuntimeError("boom")
+
+soma(1, 2)
+try:
+    falha()
+except RuntimeError:
+    pass
+```
+
+## Publicação (TestPyPI e PyPI)
+
+Build:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+```
+
+TestPyPI:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+```
+
+PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+

metricallize-0.1.0/README.md

@@ -0,0 +1,138 @@
+# metricallize
+
+Uma forma simples de armazenar telemetria/logs em “banco de documentos” usando TinyDB, com 3 modos de persistência:
+
+- `readable_sync`: JSON legível (escreve no disco de forma direta)
+- `in_memory_async`: JSON legível com cache em memória (escreve em batch, no flush/close)
+- `serialized_async`: arquivo binário/comprimido (mais rápido/menor, escreve em background; exige flush/close)
+
+## Instalação
+
+```bash
+pip install metricallize
+```
+
+Para usar o modo `serialized_async` (serialização/compressão):
+
+```bash
+pip install "metricallize[serialized_async]"
+```
+
+## Conceitos
+
+- Você cria um `DocumentStorage`
+- Você acessa qualquer table com `storage.db.table("nome")`
+- O decorator `storage.capture(table="...")` registra uma “execução” (status/duração/erro) nessa table
+
+Campos automáticos gravados pelo `capture`:
+
+- `ts`: `YYYY-MM-DD HH:MM:SS.xxx` (UTC)
+- `name`: `module.qualname` da função
+- `status`: `ok` ou `error`
+- `duration`: `HH:MM:SS`
+- Em caso de erro: `exc_type`, `exc_msg`
+
+## Path e versionamento (por mês)
+
+Se você passar `path` como diretório (sem extensão), o arquivo é criado automaticamente em:
+
+`<path>/storage/YYYY_MM/day_DD.json` (modos legíveis)  
+`<path>/storage/YYYY_MM/day_DD.db` (modo serialized)
+
+Você pode controlar o nome base com `name="..."`.
+
+## Uso: readable_sync (JSON legível)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(path=storage_dir, mode="readable_sync", name="logger")
+
+logger = storage.db.table("loggers")
+logger.insert({"event": "startup"})
+```
+
+## Uso: in_memory_async (cache em memória, JSON legível)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(
+    path=storage_dir,
+    mode="in_memory_async",
+    name="trace",
+    write_cache_size=100_000,
+)
+
+trace = storage.db.table("trace")
+trace.insert({"event": "step"})
+
+storage.flush()
+storage.close()
+```
+
+## Uso: serialized_async (binário, assíncrono)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(path=storage_dir, mode="serialized_async", name="trace")
+
+trace = storage.db.table("trace")
+trace.insert({"event": "step"})
+
+storage.flush()
+storage.close()
+```
+
+## Decorator: capture
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage = DocumentStorage(path=Path.cwd() / "data", mode="readable_sync")
+table_name = "trace"
+
+@storage.capture(table=table_name)
+def soma(a: int, b: int) -> int:
+    return a + b
+
+@storage.capture(table=table_name)
+def falha() -> None:
+    raise RuntimeError("boom")
+
+soma(1, 2)
+try:
+    falha()
+except RuntimeError:
+    pass
+```
+
+## Publicação (TestPyPI e PyPI)
+
+Build:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+```
+
+TestPyPI:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+```
+
+PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+

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

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: metricallize
+Version: 0.1.0
+Summary: TinyDB-based document storage for simple telemetry/logging with sync, cached and serialized async modes.
+Author: migue
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/metricallize/
+Keywords: tinydb,telemetry,logging,metrics,document-store
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tinydb>=4.0.0
+Provides-Extra: serialized-async
+Requires-Dist: orjson>=3.9.0; extra == "serialized-async"
+Requires-Dist: blosc2>=2.0.0; extra == "serialized-async"
+Dynamic: license-file
+
+# metricallize
+
+Uma forma simples de armazenar telemetria/logs em “banco de documentos” usando TinyDB, com 3 modos de persistência:
+
+- `readable_sync`: JSON legível (escreve no disco de forma direta)
+- `in_memory_async`: JSON legível com cache em memória (escreve em batch, no flush/close)
+- `serialized_async`: arquivo binário/comprimido (mais rápido/menor, escreve em background; exige flush/close)
+
+## Instalação
+
+```bash
+pip install metricallize
+```
+
+Para usar o modo `serialized_async` (serialização/compressão):
+
+```bash
+pip install "metricallize[serialized_async]"
+```
+
+## Conceitos
+
+- Você cria um `DocumentStorage`
+- Você acessa qualquer table com `storage.db.table("nome")`
+- O decorator `storage.capture(table="...")` registra uma “execução” (status/duração/erro) nessa table
+
+Campos automáticos gravados pelo `capture`:
+
+- `ts`: `YYYY-MM-DD HH:MM:SS.xxx` (UTC)
+- `name`: `module.qualname` da função
+- `status`: `ok` ou `error`
+- `duration`: `HH:MM:SS`
+- Em caso de erro: `exc_type`, `exc_msg`
+
+## Path e versionamento (por mês)
+
+Se você passar `path` como diretório (sem extensão), o arquivo é criado automaticamente em:
+
+`<path>/storage/YYYY_MM/day_DD.json` (modos legíveis)  
+`<path>/storage/YYYY_MM/day_DD.db` (modo serialized)
+
+Você pode controlar o nome base com `name="..."`.
+
+## Uso: readable_sync (JSON legível)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(path=storage_dir, mode="readable_sync", name="logger")
+
+logger = storage.db.table("loggers")
+logger.insert({"event": "startup"})
+```
+
+## Uso: in_memory_async (cache em memória, JSON legível)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(
+    path=storage_dir,
+    mode="in_memory_async",
+    name="trace",
+    write_cache_size=100_000,
+)
+
+trace = storage.db.table("trace")
+trace.insert({"event": "step"})
+
+storage.flush()
+storage.close()
+```
+
+## Uso: serialized_async (binário, assíncrono)
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage_dir = Path.cwd() / "data"
+storage = DocumentStorage(path=storage_dir, mode="serialized_async", name="trace")
+
+trace = storage.db.table("trace")
+trace.insert({"event": "step"})
+
+storage.flush()
+storage.close()
+```
+
+## Decorator: capture
+
+```python
+from pathlib import Path
+from metricallize import DocumentStorage
+
+storage = DocumentStorage(path=Path.cwd() / "data", mode="readable_sync")
+table_name = "trace"
+
+@storage.capture(table=table_name)
+def soma(a: int, b: int) -> int:
+    return a + b
+
+@storage.capture(table=table_name)
+def falha() -> None:
+    raise RuntimeError("boom")
+
+soma(1, 2)
+try:
+    falha()
+except RuntimeError:
+    pass
+```
+
+## Publicação (TestPyPI e PyPI)
+
+Build:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+```
+
+TestPyPI:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+```
+
+PyPI:
+
+```bash
+python -m twine upload dist/*
+```
+

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

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

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

@@ -0,0 +1 @@
+

metricallize-0.1.0/metricallize.egg-info/requires.txt

@@ -0,0 +1,5 @@
+tinydb>=4.0.0
+
+[serialized_async]
+orjson>=3.9.0
+blosc2>=2.0.0

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

@@ -0,0 +1 @@
+metricallize

metricallize-0.1.0/metricallize.py

@@ -0,0 +1,357 @@
+import _thread as Thread
+import atexit
+from collections.abc import Callable
+from datetime import datetime, timezone
+from io import BufferedRandom, BufferedWriter
+from pathlib import Path
+from time import sleep
+from typing import Any, Literal, Mapping, Optional, Set, TypeVar, Union, cast
+
+from tinydb import TinyDB
+from tinydb.middlewares import CachingMiddleware
+from tinydb.storages import JSONStorage
+
+__all__ = ["BetterJSONStoragePatched", "DocumentStorage"]
+__version__ = "0.1.0"
+
+JsonDict = dict[str, Any]
+PathLike = str | Path
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def _utc_now_iso() -> str:
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+
+try:
+    from blosc2 import compress as _blosc_compress
+    from blosc2 import decompress as _blosc_decompress
+except Exception:
+    _blosc_compress = None
+    _blosc_decompress = None
+
+try:
+    from orjson import dumps as _orjson_dumps
+    from orjson import loads as _orjson_loads
+except Exception:
+    _orjson_dumps = None
+    _orjson_loads = None
+
+try:
+    from BetterJSONStorage import BetterJSONStorage as BetterJSONStorage
+except Exception:
+    BetterJSONStorage = None
+
+
+class BetterJSONStoragePatched:
+    __slots__ = (
+        "_hash",
+        "_access_mode",
+        "_path",
+        "_data",
+        "_dump_kwargs",
+        "_changed",
+        "_running",
+        "_shutdown_lock",
+        "_handle",
+    )
+
+    _paths: Set[int] = set()
+
+    def __new__(cls, path: Path, *args: Any, **kwargs: Any):
+        h = hash(path)
+        if h in cls._paths:
+            raise AttributeError(
+                f'A BetterJSONStorage object already exists with path < "{path}" >'
+            )
+        cls._paths.add(h)
+        return object.__new__(cls)
+
+    def __init__(self, path: Path = Path(), access_mode: Literal["r", "r+"] = "r", **kwargs: Any):
+        if (
+            _orjson_dumps is None
+            or _orjson_loads is None
+            or _blosc_compress is None
+            or _blosc_decompress is None
+        ):
+            raise ModuleNotFoundError("BetterJSONStoragePatched requer orjson e blosc2 instalados")
+
+        self._shutdown_lock = Thread.allocate_lock()
+        self._running = True
+        self._changed = False
+
+        self._hash = hash(path)
+        self._handle: Optional[Union[BufferedWriter, BufferedRandom]] = None
+
+        if access_mode not in {"r", "r+"}:
+            self.close()
+            raise AttributeError(f'access_mode is not one of ("r", "r+"), :{access_mode}')
+
+        if not isinstance(path, Path):
+            self.close()
+            raise TypeError("path is not an instance of pathlib.Path")
+
+        if not path.exists():
+            if access_mode == "r":
+                self.close()
+                raise FileNotFoundError(
+                    f"File can't be found, use access_mode='r+' if you want to create it. Path: <{path.absolute()}>"
+                )
+            path.parent.mkdir(parents=True, exist_ok=True)
+            self._handle = path.open("wb+")
+
+        if not path.is_file():
+            self.close()
+            raise FileNotFoundError(f"path does not lead to a file: <{path.absolute()}>.")
+        else:
+            self._handle = path.open("rb+")
+
+        self._access_mode = access_mode
+        self._path = path
+        self._dump_kwargs = {k: v for k, v in kwargs.items() if k in {"default", "option"}}
+        self._data: Mapping[str, Any]
+
+        self.load()
+
+        if access_mode == "r+":
+            Thread.start_new_thread(self.__file_writer, ())
+
+    def read(self) -> Mapping[str, Any]:
+        return self._data
+
+    def __file_writer(self) -> None:
+        self._shutdown_lock.acquire()
+        while self._running:
+            if self._changed:
+                self._changed = False
+                self._handle.seek(0)
+                payload = _orjson_dumps(self._data, **self._dump_kwargs)
+                compressed = _blosc_compress(payload, typesize=1)
+                self._handle.write(compressed)
+                self._handle.truncate()
+                self._handle.flush()
+            else:
+                sleep(0.001)
+        self._shutdown_lock.release()
+
+    def write(self, data: Mapping[str, Any]) -> None:
+        if self._access_mode != "r+":
+            raise PermissionError("Storage is openend as read only")
+        self._data = data
+        self._changed = True
+
+    def load(self) -> None:
+        db_bytes = self._path.read_bytes()
+        if len(db_bytes):
+            self._data = cast(Mapping[str, Any], _orjson_loads(_blosc_decompress(db_bytes)))
+        else:
+            self._data = {}
+
+    def close(self) -> None:
+        while self._changed:
+            sleep(0.001)
+        self._running = False
+        self._shutdown_lock.acquire()
+        if self._handle is not None:
+            self._handle.flush()
+            self._handle.close()
+        self.__class__._paths.discard(self._hash)
+
+    def flush(self) -> None:
+        while self._changed:
+            sleep(0.001)
+
+
+StorageMode = Literal[
+    "readable_sync",
+    "in_memory_async",
+    "serialized_async",
+]
+
+
+class DocumentStorage:
+    """Example:
+    import os
+    from datetime import datetime
+    from pathlib import Path
+
+    from metricallize import DocumentStorage
+
+    storage_dir = Path(os.getcwd()) / "data"
+    process_id = datetime.now().strftime("%H%M%S")
+    storage = DocumentStorage(
+        path=storage_dir,
+        mode="readable_sync",
+    )
+
+    metrics = storage.db.table(process_id)
+    """
+
+    def __init__(
+        self,
+        path: PathLike,
+        *,
+        mode: StorageMode = "readable_sync",
+        access_mode: str = "r+",
+        storage: Any | None = None,
+        storage_kwargs: Mapping[str, Any] | None = None,
+        write_cache_size: int = 10000,
+        name: str = "storage",
+        auto_close: bool = True,
+    ) -> None:
+        self._closed = False
+        self._mode = mode
+
+        raw_path = Path(path)
+        if raw_path.suffix:
+            final_path = raw_path
+        else:
+            base_dir = raw_path
+            now = datetime.now()
+            month_dir = base_dir / "storage" / now.strftime("%Y_%m")
+            month_dir.mkdir(parents=True, exist_ok=True)
+            final_path = (
+                month_dir / f"day_{now.strftime('%d')}{self._default_extension(self._mode)}"
+            )
+
+        self._path = final_path
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+
+        if storage is None:
+            merged_storage_kwargs: dict[str, Any] = dict(storage_kwargs) if storage_kwargs else {}
+            if self._mode in {"readable_sync", "in_memory_async"}:
+                merged_storage_kwargs.setdefault("indent", 4)
+                merged_storage_kwargs.setdefault("ensure_ascii", False)
+
+            if self._mode == "in_memory_async":
+                caching = CachingMiddleware(JSONStorage)
+                caching.WRITE_CACHE_SIZE = int(write_cache_size)
+                storage = caching
+            elif self._mode == "serialized_async":
+                if _orjson_dumps is not None and _blosc_compress is not None:
+                    storage = BetterJSONStoragePatched
+                elif BetterJSONStorage is not None:
+                    storage = BetterJSONStorage
+                else:
+                    raise ModuleNotFoundError(
+                        "Modo serialized_async requer BetterJSONStorage (ou orjson+blosc2 para BetterJSONStoragePatched)"
+                    )
+            else:
+                storage = JSONStorage
+            storage_kwargs = merged_storage_kwargs
+        self._db = TinyDB(
+            self._path,
+            storage=storage,
+            access_mode=access_mode,
+            **(dict(storage_kwargs) if storage_kwargs else {}),
+        )
+
+        if auto_close:
+            atexit.register(self.close)
+
+    @staticmethod
+    def _default_extension(mode: str) -> str:
+        if mode == "serialized_async":
+            return ".db"
+        return ".json"
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    @property
+    def db(self) -> TinyDB:
+        return self._db
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._db.close()
+
+    def flush(self) -> None:
+        storage = getattr(self._db, "_storage", None)
+        if storage is None:
+            return
+        flush = getattr(storage, "flush", None)
+        if flush is None:
+            return
+        flush()
+
+    def __enter__(self) -> "DocumentStorage":
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        self.close()
+
+    def __span(
+        self,
+        name: str,
+        *,
+        fields: Mapping[str, Any] | None = None,
+        status: str = "ok",
+        duration_s: float | None = None,
+        duration_ms: float | None = None,
+        table: str = "spans",
+    ) -> int:
+        if duration_s is not None and duration_ms is not None:
+            raise ValueError("Use apenas um: duration_s ou duration_ms")
+
+        doc: JsonDict = {
+            "ts": _utc_now_iso(),
+            "name": name,
+            "status": status,
+            **(dict(fields) if fields else {}),
+        }
+
+        total_s: float | None
+        if duration_s is not None:
+            total_s = float(duration_s)
+        elif duration_ms is not None:
+            total_s = float(duration_ms) / 1000.0
+        else:
+            total_s = None
+
+        if total_s is not None:
+            total_s = max(0.0, total_s)
+            h = int(total_s // 3600)
+            m = int((total_s % 3600) // 60)
+            s = int(total_s % 60)
+            doc["duration"] = f"{h:02d}:{m:02d}:{s:02d}"
+        return int(self._db.table(table).insert(doc))
+
+    def capture(self, table: str = "traces") -> Callable[[F], F]:
+        def decorator(func: F) -> F:
+            span_name = f"{func.__module__}.{getattr(func, '__qualname__', func.__name__)}"
+
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
+                start = datetime.now(timezone.utc)
+                try:
+                    result = func(*args, **kwargs)
+                except Exception as exc:
+                    end = datetime.now(timezone.utc)
+                    self.__span(
+                        span_name,
+                        status="error",
+                        duration_s=(end - start).total_seconds(),
+                        table=table,
+                        fields={
+                            "exc_type": type(exc).__name__,
+                            "exc_msg": str(exc),
+                        },
+                    )
+                    raise
+                else:
+                    end = datetime.now(timezone.utc)
+                    self.__span(
+                        span_name,
+                        status="ok",
+                        duration_s=(end - start).total_seconds(),
+                        table=table,
+                    )
+                    return result
+
+            return cast(F, wrapper)
+
+        return decorator

metricallize-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "metricallize"
+version = "0.1.0"
+description = "TinyDB-based document storage for simple telemetry/logging with sync, cached and serialized async modes."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "migue" }]
+license = { text = "MIT" }
+dependencies = ["tinydb>=4.0.0"]
+keywords = ["tinydb", "telemetry", "logging", "metrics", "document-store"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+serialized_async = ["orjson>=3.9.0", "blosc2>=2.0.0"]
+
+[project.urls]
+Homepage = "https://pypi.org/project/metricallize/"
+
+[tool.setuptools]
+py-modules = ["metricallize"]
+

metricallize-0.1.0/setup.cfg

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