br-logging-and-profiling 0.1.0__tar.gz

br_logging_and_profiling-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: br-logging-and-profiling
+Version: 0.1.0
+Summary: Loguru-based logging facade, correlation IDs, and profiling decorator extracted from Forecasting-sidecar3.
+Author: Brais Diaz
+License: MIT
+Project-URL: Homepage, https://github.com/brais/br-logging-and-profiling
+Project-URL: Repository, https://github.com/brais/br-logging-and-profiling
+Keywords: logging,profiling,loguru,colorama,ray-id
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy<2.2,>=1.24
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: gitpython; extra == "dev"
+
+# br_logging_and_profiling
+
+Reusable logging/profiling/tracing package extracted from Forecasting-sidecar3.
+
+## Current state
+
+- Logging: Loguru + colorama via `br_py_log_n_profile.do_log.log_it`
+- Profiling: `profile_it` decorator (wall-clock timing, colored console output)
+- Correlation IDs: `ray_id` via `contextvars.ContextVar`
+
+## Planned
+
+- `tracing/` module: `init_tracing()`, `traced` decorator (OTel span replacement for `profile_it`), `@counted`/`@timed_metric` for hot-loop metrics
+- Backend: Prometheus + Jaeger + Grafana + OTel Collector
+- Migration phases: Phase 0 (deps/config) → Phase 1 (core tracing) → Phase 2 (migrate by layer) → Phase 3 (metrics) → Phase 4 (backend stack)
+
+## Install
+
+```bash
+pip install br-logging-and-profiling
+```
+
+## Development
+
+```bash
+pip install -r requirements-dev.txt
+pre-commit install
+pytest -m unit
+```

br_logging_and_profiling-0.1.0/README.md

@@ -0,0 +1,29 @@
+# br_logging_and_profiling
+
+Reusable logging/profiling/tracing package extracted from Forecasting-sidecar3.
+
+## Current state
+
+- Logging: Loguru + colorama via `br_py_log_n_profile.do_log.log_it`
+- Profiling: `profile_it` decorator (wall-clock timing, colored console output)
+- Correlation IDs: `ray_id` via `contextvars.ContextVar`
+
+## Planned
+
+- `tracing/` module: `init_tracing()`, `traced` decorator (OTel span replacement for `profile_it`), `@counted`/`@timed_metric` for hot-loop metrics
+- Backend: Prometheus + Jaeger + Grafana + OTel Collector
+- Migration phases: Phase 0 (deps/config) → Phase 1 (core tracing) → Phase 2 (migrate by layer) → Phase 3 (metrics) → Phase 4 (backend stack)
+
+## Install
+
+```bash
+pip install br-logging-and-profiling
+```
+
+## Development
+
+```bash
+pip install -r requirements-dev.txt
+pre-commit install
+pytest -m unit
+```

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

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: br-logging-and-profiling
+Version: 0.1.0
+Summary: Loguru-based logging facade, correlation IDs, and profiling decorator extracted from Forecasting-sidecar3.
+Author: Brais Diaz
+License: MIT
+Project-URL: Homepage, https://github.com/brais/br-logging-and-profiling
+Project-URL: Repository, https://github.com/brais/br-logging-and-profiling
+Keywords: logging,profiling,loguru,colorama,ray-id
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy<2.2,>=1.24
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: gitpython; extra == "dev"
+
+# br_logging_and_profiling
+
+Reusable logging/profiling/tracing package extracted from Forecasting-sidecar3.
+
+## Current state
+
+- Logging: Loguru + colorama via `br_py_log_n_profile.do_log.log_it`
+- Profiling: `profile_it` decorator (wall-clock timing, colored console output)
+- Correlation IDs: `ray_id` via `contextvars.ContextVar`
+
+## Planned
+
+- `tracing/` module: `init_tracing()`, `traced` decorator (OTel span replacement for `profile_it`), `@counted`/`@timed_metric` for hot-loop metrics
+- Backend: Prometheus + Jaeger + Grafana + OTel Collector
+- Migration phases: Phase 0 (deps/config) → Phase 1 (core tracing) → Phase 2 (migrate by layer) → Phase 3 (metrics) → Phase 4 (backend stack)
+
+## Install
+
+```bash
+pip install br-logging-and-profiling
+```
+
+## Development
+
+```bash
+pip install -r requirements-dev.txt
+pre-commit install
+pytest -m unit
+```

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

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+br_logging_and_profiling.egg-info/PKG-INFO
+br_logging_and_profiling.egg-info/SOURCES.txt
+br_logging_and_profiling.egg-info/dependency_links.txt
+br_logging_and_profiling.egg-info/requires.txt
+br_logging_and_profiling.egg-info/top_level.txt
+br_py_log_n_profile/__init__.py
+br_py_log_n_profile/do_log/__init__.py
+br_py_log_n_profile/do_log/log_it.py
+br_py_log_n_profile/do_log/ray_id.py
+br_py_log_n_profile/profiling/__init__.py
+br_py_log_n_profile/profiling/base.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,11 @@
+loguru>=0.7.0
+colorama>=0.4.6
+pandas>=2.0
+numpy<2.2,>=1.24
+
+[dev]
+pre-commit
+pytest>=7.0
+mypy>=1.0
+ruff>=0.6
+gitpython

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

@@ -0,0 +1 @@
+br_py_log_n_profile

br_logging_and_profiling-0.1.0/br_py_log_n_profile/__init__.py

@@ -0,0 +1,15 @@
+"""Reusable logging/profiling/tracing package extracted from Forecasting-sidecar3."""
+
+from br_py_log_n_profile.do_log import get_ray_id, log, log_d, log_e, log_i, log_w, set_ray_id
+from br_py_log_n_profile.profiling import profile_it
+
+__all__ = [
+    "get_ray_id",
+    "log",
+    "log_d",
+    "log_e",
+    "log_i",
+    "log_w",
+    "profile_it",
+    "set_ray_id",
+]

br_logging_and_profiling-0.1.0/br_py_log_n_profile/do_log/__init__.py

@@ -0,0 +1,4 @@
+from .log_it import log, log_d, log_e, log_i, log_w
+from .ray_id import get_ray_id, set_ray_id
+
+__all__ = ["get_ray_id", "log", "log_d", "log_e", "log_i", "log_w", "set_ray_id"]

br_logging_and_profiling-0.1.0/br_py_log_n_profile/do_log/log_it.py

@@ -0,0 +1,145 @@
+import logging
+import sys
+import traceback
+from pathlib import Path
+from types import FrameType
+
+from colorama import Fore, Style
+from loguru import logger
+
+from .ray_id import get_ray_id
+
+__severity_color_map = {
+    logging.INFO: Fore.GREEN,
+    logging.WARNING: Fore.YELLOW,
+    logging.ERROR: Fore.RED,
+    logging.DEBUG: Fore.CYAN,
+}
+__root_path: Path | None = None
+__log_format = "{time:YYYY-MM-DD HH:mm:ss.SS} | {level} | {name}:{function}:{line} - {message}"
+__log_to_std_out_level = logging.DEBUG
+__log_to_file_level = 0
+__min_log_level = __log_to_std_out_level
+
+__all__ = ["log_d", "log_e", "log_i", "log_w"]
+
+_NAMED_LEVEL_THRESHOLDS = (
+    (logging.CRITICAL, "CRITICAL"),
+    (logging.ERROR, "ERROR"),
+    (logging.WARNING, "WARNING"),
+    (logging.INFO, "INFO"),
+    (logging.DEBUG, "DEBUG"),
+)
+
+_STANDARD_LEVEL_NAMES = {
+    logging.CRITICAL: "CRITICAL",
+    logging.ERROR: "ERROR",
+    logging.WARNING: "WARNING",
+    logging.INFO: "INFO",
+    logging.DEBUG: "DEBUG",
+}
+
+
+def _nearest_level_name(severity: int) -> str:
+    name = _STANDARD_LEVEL_NAMES.get(severity)
+    if name is not None:
+        return name
+    for threshold, name in _NAMED_LEVEL_THRESHOLDS:
+        if severity >= threshold:
+            return name
+    return "DEBUG"
+
+
+class InterceptHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = _nearest_level_name(record.levelno)
+
+        frame: FrameType | None
+        frame, depth = sys._getframe(6), 6
+        while frame and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
+def _intercept_stdlib_logging() -> None:
+    logging.basicConfig(handlers=[InterceptHandler()], force=True)
+
+
+def root_path(root_distance: int = 5) -> Path:
+    global __root_path
+    if __root_path is None:
+        __root_path = Path(__file__)
+        try:
+            for _i in range(root_distance):
+                __root_path = __root_path.parent
+        except (NameError, FileNotFoundError):
+            logger.warning(
+                f"Unable to find parent for {__root_path}. "
+                f"Calling init_logger will enable extended "
+                f"features and resolve this warning."
+            )
+    return __root_path
+
+
+def _init_default_logger() -> None:
+    log_dir = root_path() / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    runtime_log_dir = log_dir / "runtime"
+    runtime_log_dir.mkdir(parents=True, exist_ok=True)
+    logger.remove()
+    logger.add(
+        sys.stdout,
+        format=__log_format,
+        colorize=True,
+        level=__log_to_std_out_level,
+    )
+    logger.add(
+        runtime_log_dir / "runtime.log",
+        format=__log_format,
+        level=__log_to_file_level,
+        rotation="00:00",
+        retention="30 days",
+        enqueue=True,
+    )
+    _intercept_stdlib_logging()
+
+
+_init_default_logger()
+
+
+def log_d(message: str, stack_limit: int = 0, stack_offset: int = 0) -> None:
+    log(message, logging.DEBUG, stack_limit, stack_offset + 1)
+
+
+def log_w(message: str, stack_limit: int = 0, stack_offset: int = 0) -> None:
+    log(message, logging.WARNING, stack_limit, stack_offset + 1)
+
+
+def log_i(message: str, stack_limit: int = 0, stack_offset: int = 0) -> None:
+    log(message, logging.INFO, stack_limit, stack_offset + 1)
+
+
+def log_e(message: str, stack_limit: int = 0, stack_offset: int = 0) -> None:
+    log(message, logging.ERROR, stack_limit, stack_offset + 1)
+
+
+def log(message: str, severity: int, stack_limit: int = 0, stack_offset: int = 0) -> None:
+    if __min_log_level > severity:
+        return
+    try:
+        stack_trace = ""
+        if stack_limit > 0:
+            stack = traceback.format_stack(limit=stack_offset + stack_limit + 1)[: -(stack_offset + 1)][-(stack_limit):]
+            stack_trace = "\n" + "".join(stack)
+        color = __severity_color_map.get(severity, Fore.WHITE)
+        id_of_ray = get_ray_id()
+        logger.opt(depth=stack_offset + 1).log(
+            _nearest_level_name(severity), f"{color}{message}{stack_trace} (ray:{id_of_ray}){Style.RESET_ALL}"
+        )
+    except Exception as e:
+        logger.exception(f"Failed to log message: {message} | Error: {e!s}")

br_logging_and_profiling-0.1.0/br_py_log_n_profile/do_log/ray_id.py

@@ -0,0 +1,23 @@
+import uuid
+from contextvars import ContextVar
+
+ray_id_var: ContextVar[uuid.UUID | None] = ContextVar("ray_id")
+
+
+def set_ray_id(id: uuid.UUID) -> None:
+    ray_id_var.set(id)
+
+
+def get_ray_id(generate: bool = True) -> uuid.UUID | None:
+    id_of_ray = ray_id_var.get(None)
+    if generate and id_of_ray is None:
+        id_of_ray = ray_id(source_type=0)
+        set_ray_id(id_of_ray)
+    return id_of_ray
+
+
+def ray_id(source_type: int, id_of_ray: uuid.UUID | None = None) -> uuid.UUID:
+    if id_of_ray is not None:
+        return id_of_ray
+    id_of_ray = uuid.uuid1(node=source_type)
+    return id_of_ray

br_logging_and_profiling-0.1.0/br_py_log_n_profile/profiling/__init__.py

@@ -0,0 +1 @@
+from .base import profile_it as profile_it

br_logging_and_profiling-0.1.0/br_py_log_n_profile/profiling/base.py

@@ -0,0 +1,80 @@
+import time
+from collections.abc import Callable
+from functools import wraps
+
+import numpy as np
+import pandas as pd
+from colorama import Fore
+
+from ..do_log.log_it import log_d
+
+
+def profile_it[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    @wraps(func)
+    def _measure_time(*args: P.args, **kwargs: P.kwargs) -> R:
+        start_time = time.time()
+        function_parameters = parameters_to_str(args, kwargs)
+        log_d(f"{func.__name__}({function_parameters}) started", stack_offset=1)
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        execution_time = end_time - start_time
+        execution_time_color = (
+            Fore.BLUE
+            if execution_time < 0.01
+            else Fore.GREEN
+            if execution_time < 0.1
+            else Fore.YELLOW
+            if execution_time < 1
+            else Fore.RED
+        )
+        log_d(
+            f"{func.__name__}({function_parameters}) executed in {execution_time_color}{execution_time:.3f} seconds",
+            stack_offset=1,
+        )
+        return result
+
+    return _measure_time
+
+
+def parameters_to_str(args: tuple[object, ...], kwargs: dict[str, object]) -> str:
+    def process_item(item: object) -> str:
+        if isinstance(item, pd.DataFrame):
+            return f"{len(item)}*{item.columns}"
+        elif isinstance(item, list):
+            try:
+                return f"list{np.array(item).shape}"
+            except ValueError as e:
+                raise e
+            except Exception as e:
+                raise e
+        elif isinstance(item, np.ndarray):
+            return f"ndarray{item.shape}"
+        elif isinstance(item, dict):
+            return process_dict(item)
+        else:
+            return str(item)
+
+    def process_dict(d: dict[object, object]) -> str:
+        t_parameters: list[str] = []
+        for key, value in d.items():
+            if isinstance(value, list):
+                try:
+                    t_parameters.append(f"{key}: list{np.array(value).shape}")
+                except ValueError as e:
+                    raise e
+                except Exception as e:
+                    raise e
+            elif isinstance(value, pd.DataFrame):
+                t_parameters.append(f"{key}: {len(value)}*{value.columns}")
+            elif isinstance(value, np.ndarray):
+                t_parameters.append(f"{key}: ndarray{value.shape}")
+            elif isinstance(value, dict):
+                t_parameters.append(f"{key}: {{ {process_dict(value)} }}")
+            else:
+                t_parameters.append(f"{key}: {value}")
+        return ", ".join(t_parameters)
+
+    parameters = [process_item(arg) for arg in args]
+    parameters += [f"{k}: {process_item(kwargs[k])}" for k in kwargs]
+
+    return ", ".join(parameters)

br_logging_and_profiling-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "br-logging-and-profiling"
+version = "0.1.0"
+description = "Loguru-based logging facade, correlation IDs, and profiling decorator extracted from Forecasting-sidecar3."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.12"
+authors = [{ name = "Brais Diaz" }]
+keywords = ["logging", "profiling", "loguru", "colorama", "ray-id"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "loguru>=0.7.0",
+    "colorama>=0.4.6",
+    "pandas>=2.0",
+    "numpy>=1.24,<2.2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pre-commit",
+    "pytest>=7.0",
+    "mypy>=1.0",
+    "ruff>=0.6",
+    "gitpython",
+]
+
+[project.urls]
+Homepage = "https://github.com/brais/br-logging-and-profiling"
+Repository = "https://github.com/brais/br-logging-and-profiling"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["br_py_log_n_profile*"]
+
+[tool.setuptools.package-data]
+br_py_log_n_profile = ["py.typed"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+extend-exclude = ["*.ipynb", ".testvenv"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "C4", "SIM", "W"]
+
+[tool.mypy]
+python_version = "3.12"
+explicit_package_bases = true
+strict = true
+disallow_any_explicit = true
+no_implicit_optional = true
+warn_return_any = true
+ignore_missing_imports = true
+follow_imports = "silent"
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+testpaths = ["tests"]
+pythonpath = ["."]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-ra --strict-markers --import-mode=importlib"
+markers = [
+    "unit: fast, isolated, no I/O",
+    "integration: multiple modules/stages wired together",
+    "contract: validates public API contract against installed package",
+]

br_logging_and_profiling-0.1.0/setup.cfg

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