sibi-dst 2025.8.8__py3-none-any.whl → 2025.8.9__py3-none-any.whl

sibi_dst/utils/log_utils.py

@@ -4,12 +4,12 @@ import logging
 import os
 import sys
 import time
-from contextlib import contextmanager, nullcontext
+from contextlib import contextmanager, nullcontext, suppress
 from logging import LoggerAdapter
 from logging.handlers import RotatingFileHandler
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Union
 
-# OpenTelemetry (optional)
+# --- OpenTelemetry (optional) ---
 try:
     from opentelemetry import trace
     from opentelemetry._logs import set_logger_provider, get_logger_provider
@@ -20,25 +20,15 @@ try:
     from opentelemetry.sdk.resources import Resource
     from opentelemetry.sdk.trace import TracerProvider
     from opentelemetry.sdk.trace.export import BatchSpanProcessor
-    from opentelemetry.trace import Tracer as OTelTracer
     _OTEL_AVAILABLE = True
 except Exception:
-    # OTel is optional; keep class working without it
-    LoggerProvider = TracerProvider = OTelTracer = object  # type: ignore
-    LoggingHandler = object  # type: ignore
     _OTEL_AVAILABLE = False
 
 
 class Logger:
     """
     Process-safe logger with optional OpenTelemetry integration.
-
-    Backward-compatible surface:
-      - Logger.default_logger(...)
-      - .debug/.info/.warning/.error/.critical
-      - .set_level(level), .shutdown()
-      - .bind(**extra) -> LoggerAdapter, .bound(**extra) ctx manager
-      - .start_span(name, attributes=None), .trace_function(span_name=None)
+    Idempotent handler setup. No propagation to root.
     """
 
     DEBUG = logging.DEBUG
@@ -47,8 +37,8 @@ class Logger:
     ERROR = logging.ERROR
     CRITICAL = logging.CRITICAL
 
-    # prevent attaching duplicate handlers per (logger_name, file_path) in process
-    _handler_keys_attached: set[tuple[str, str]] = set()
+    # idempotency guards per process
+    _attached_keys: set[tuple[str, str]] = set()  # (logger_name, sink_id)
     _otel_initialized_names: set[str] = set()
 
     def __init__(
@@ -56,7 +46,7 @@ class Logger:
         log_dir: str,
         logger_name: str,
         log_file: str,
-        log_level: int = logging.DEBUG,
+        log_level: int = logging.INFO,
         enable_otel: bool = False,
         otel_service_name: Optional[str] = None,
         otel_stream_name: Optional[str] = None,
@@ -69,38 +59,35 @@ class Logger:
         self.log_level = log_level
 
         self.enable_otel = bool(enable_otel and _OTEL_AVAILABLE)
-        self.otel_service_name = (otel_service_name or logger_name).strip() or "app"
+        self.otel_service_name = (otel_service_name or logger_name or "app").strip()
         self.otel_stream_name = (otel_stream_name or "").strip() or None
         self.otel_endpoint = otel_endpoint
         self.otel_insecure = otel_insecure
 
-        self.logger_provider: Optional[LoggerProvider] = None
-        self.tracer_provider: Optional[TracerProvider] = None
-        self.tracer: Optional[OTelTracer] = None
+        self.logger_provider = None
+        self.tracer_provider = None
+        self.tracer = None
 
-        self._core_logger: logging.Logger = logging.getLogger(self.logger_name)
-        self._core_logger.setLevel(self.log_level)
-        self._core_logger.propagate = False
+        self._core: logging.Logger = logging.getLogger(self.logger_name)
+        self._core.setLevel(self.log_level)
+        self._core.propagate = False
 
-        # public handle (may be adapter)
-        self.logger: logging.Logger | LoggerAdapter = self._core_logger
+        # public handle (may be LoggerAdapter)
+        self.logger: Union[logging.Logger, LoggerAdapter] = self._core
 
-        self._setup_standard_handlers()
+        self._setup_handlers()
         if self.enable_otel:
-            self._setup_otel_if_needed()
+            self._setup_otel()
 
-        # expose adapter with default extras if OTel stream requested
         if self.enable_otel and self.otel_stream_name:
-            attributes = {
+            attrs = {
                 "log_stream": self.otel_stream_name,
                 "log_service_name": self.otel_service_name,
                 "logger_name": self.logger_name,
             }
-            self.logger = LoggerAdapter(self._core_logger, extra=attributes)
+            self.logger = LoggerAdapter(self._core, extra=attrs)
 
-    # -------------------------
-    # Public API
-    # -------------------------
+    # ---------------- Public API ----------------
 
     @classmethod
     def default_logger(
@@ -116,14 +103,11 @@ class Logger:
         otel_insecure: bool = False,
     ) -> "Logger":
         try:
-            frame = sys._getframe(1)
-            caller_name = frame.f_globals.get("__name__", "default_logger")
+            caller_name = sys._getframe(1).f_globals.get("__name__", "default_logger")
         except Exception:
             caller_name = "default_logger"
-
         logger_name = logger_name or caller_name
         log_file = log_file or logger_name
-
         return cls(
             log_dir=log_dir,
             logger_name=logger_name,
@@ -136,55 +120,11 @@ class Logger:
             otel_insecure=otel_insecure,
         )
 
-    def shutdown(self):
-        """Flush/close OTel providers and Python logging handlers."""
-        try:
-            if self.enable_otel:
-                if isinstance(self.logger_provider, LoggerProvider):
-                    try:
-                        self._core_logger.info("Flushing OpenTelemetry logs...")
-                        self.logger_provider.force_flush()
-                    except Exception:
-                        pass
-                    try:
-                        self._core_logger.info("Shutting down OpenTelemetry logs...")
-                        self.logger_provider.shutdown()
-                    except Exception:
-                        pass
+    def set_level(self, level: int) -> None:
+        self._core.setLevel(level)
 
-                if isinstance(self.tracer_provider, TracerProvider):
-                    try:
-                        self._core_logger.info("Flushing OpenTelemetry traces...")
-                        self.tracer_provider.force_flush()
-                    except Exception:
-                        pass
-                    try:
-                        self._core_logger.info("Shutting down OpenTelemetry traces...")
-                        self.tracer_provider.shutdown()
-                    except Exception:
-                        pass
-        finally:
-            # Close our handlers explicitly to release file descriptors
-            for h in list(self._core_logger.handlers):
-                try:
-                    h.flush()
-                except Exception:
-                    pass
-                try:
-                    h.close()
-                except Exception:
-                    pass
-                try:
-                    self._core_logger.removeHandler(h)
-                except Exception:
-                    pass
-            logging.shutdown()
-
-    def set_level(self, level: int):
-        self._core_logger.setLevel(level)
-
-    # passthrough convenience
-    def _log(self, level: int, msg: str, *args, **kwargs):
+    # passthrough
+    def _log(self, level: int, msg: str, *args, **kwargs) -> None:
         extra = kwargs.pop("extra", None)
         if extra is not None:
             if isinstance(self.logger, LoggerAdapter):
@@ -195,171 +135,156 @@ class Logger:
         else:
             self.logger.log(level, msg, *args, **kwargs)
 
-    def debug(self, msg: str, *args, **kwargs): self._log(logging.DEBUG, msg, *args, **kwargs)
-    def info(self, msg: str, *args, **kwargs): self._log(logging.INFO, msg, *args, **kwargs)
-    def warning(self, msg: str, *args, **kwargs): self._log(logging.WARNING, msg, *args, **kwargs)
-    def error(self, msg: str, *args, **kwargs): self._log(logging.ERROR, msg, *args, **kwargs)
-    def critical(self, msg: str, *args, **kwargs): self._log(logging.CRITICAL, msg, *args, **kwargs)
+    def debug(self, msg: str, *a, **k): self._log(logging.DEBUG, msg, *a, **k)
+    def info(self, msg: str, *a, **k): self._log(logging.INFO, msg, *a, **k)
+    def warning(self, msg: str, *a, **k): self._log(logging.WARNING, msg, *a, **k)
+    def error(self, msg: str, *a, **k): self._log(logging.ERROR, msg, *a, **k)
+    def critical(self, msg: str, *a, **k): self._log(logging.CRITICAL, msg, *a, **k)
 
     def bind(self, **extra: Any) -> LoggerAdapter:
         if isinstance(self.logger, LoggerAdapter):
-            merged = {**self.logger.extra, **extra}
-            return LoggerAdapter(self.logger.logger, merged)
+            return LoggerAdapter(self.logger.logger, {**self.logger.extra, **extra})
         return LoggerAdapter(self.logger, extra)
 
     @contextmanager
     def bound(self, **extra: Any):
-        adapter = self.bind(**extra)
-        yield adapter
+        yield self.bind(**extra)
 
     def start_span(self, name: str, attributes: Optional[Dict[str, Any]] = None):
         if not (self.enable_otel and _OTEL_AVAILABLE and self.tracer):
-            # keep API but no-op cleanly
-            self.warning("Tracing is disabled or not initialized. Cannot start span.")
             return nullcontext()
-
         cm = self.tracer.start_as_current_span(name)
-
         class _SpanCtx:
             def __enter__(_self):
                 span = cm.__enter__()
                 if attributes:
                     for k, v in attributes.items():
-                        try:
+                        with suppress(Exception):
                             span.set_attribute(k, v)
-                        except Exception:
-                            pass
                 return span
-
-            def __exit__(_self, exc_type, exc, tb):
-                return cm.__exit__(exc_type, exc, tb)
-
+            def __exit__(_self, et, ev, tb):
+                return cm.__exit__(et, ev, tb)
         return _SpanCtx()
 
     def trace_function(self, span_name: Optional[str] = None):
-        def decorator(func):
-            def wrapper(*args, **kwargs):
+        def deco(func):
+            def wrapper(*a, **k):
                 name = span_name or func.__name__
                 with self.start_span(name):
-                    return func(*args, **kwargs)
+                    return func(*a, **k)
             return wrapper
-        return decorator
+        return deco
+
+    def shutdown(self) -> None:
+        try:
+            if self.enable_otel and _OTEL_AVAILABLE:
+                if self.logger_provider:
+                    with suppress(Exception):
+                        self._core.info("Flushing OpenTelemetry logs...")
+                        self.logger_provider.force_flush()
+                    with suppress(Exception):
+                        self._core.info("Shutting down OpenTelemetry logs...")
+                        self.logger_provider.shutdown()
+                if self.tracer_provider:
+                    with suppress(Exception):
+                        self._core.info("Flushing OpenTelemetry traces...")
+                        self.tracer_provider.force_flush()
+                    with suppress(Exception):
+                        self._core.info("Shutting down OpenTelemetry traces...")
+                        self.tracer_provider.shutdown()
+        finally:
+            for h in list(self._core.handlers):
+                with suppress(Exception): h.flush()
+                with suppress(Exception): h.close()
+                with suppress(Exception): self._core.removeHandler(h)
+            logging.shutdown()
 
-    # -------------------------
-    # Internal setup
-    # -------------------------
+    # ---------------- Internal ----------------
 
-    def _setup_standard_handlers(self):
+    def _setup_handlers(self) -> None:
         os.makedirs(self.log_dir, exist_ok=True)
         calling_script = os.path.splitext(os.path.basename(sys.argv[0]))[0]
         log_file_path = os.path.join(self.log_dir, f"{self.log_file}_{calling_script}.log")
-        key = (self.logger_name, os.path.abspath(log_file_path))
+        file_key = (self.logger_name, os.path.abspath(log_file_path))
+        console_key = (self.logger_name, "__console__")
 
-        formatter = logging.Formatter(
+        fmt = logging.Formatter(
             "[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s",
             datefmt="%Y-%m-%d %H:%M:%S",
         )
-        formatter.converter = time.gmtime  # UTC timestamps
-
-        # attach once per process for this logger/file combo
-        if key not in self._handler_keys_attached:
-            file_handler = RotatingFileHandler(
-                log_file_path, maxBytes=5 * 1024 * 1024, backupCount=5, delay=True
-            )
-            file_handler.setFormatter(formatter)
-            self._core_logger.addHandler(file_handler)
+        fmt.converter = time.gmtime  # UTC
 
-            console_handler = logging.StreamHandler(sys.stdout)
-            console_handler.setFormatter(formatter)
-            self._core_logger.addHandler(console_handler)
+        if file_key not in self._attached_keys:
+            fh = RotatingFileHandler(log_file_path, maxBytes=5 * 1024 * 1024, backupCount=5, delay=True)
+            fh.setFormatter(fmt)
+            self._core.addHandler(fh)
+            self._attached_keys.add(file_key)
 
-            self._handler_keys_attached.add(key)
+        if console_key not in self._attached_keys:
+            ch = logging.StreamHandler(sys.stdout)
+            ch.setFormatter(fmt)
+            self._core.addHandler(ch)
+            self._attached_keys.add(console_key)
 
     def _normalize_otlp_endpoint(self, ep: str) -> str:
         if "://" not in ep:
             ep = ("http://" if self.otel_insecure else "https://") + ep
         return ep
 
-    def _setup_otel_if_needed(self):
-        """
-        Initialize OTel once per logger_name within the process to avoid
-        clobbering providers (important under reloaders).
-        """
+    def _setup_otel(self) -> None:
         if not _OTEL_AVAILABLE:
-            self._core_logger.warning("OpenTelemetry not available — skipping OTel setup.")
+            self._core.warning("OpenTelemetry not available — skipping OTel setup.")
             return
         if self.logger_name in self._otel_initialized_names:
-            # already initialized for this logger name in this process
-            self.tracer = trace.get_tracer(self.logger_name)
+            with suppress(Exception):
+                self.tracer = trace.get_tracer(self.logger_name)
             return
 
-        # Create resources
-        resource_attrs = {
-            "service.name": self.otel_service_name,
-            "logger.name": self.logger_name,
-        }
+        # resources
+        attrs = {"service.name": self.otel_service_name, "logger.name": self.logger_name}
         if self.otel_stream_name:
-            resource_attrs["log.stream"] = self.otel_stream_name
-        resource = Resource.create(resource_attrs)
+            attrs["log.stream"] = self.otel_stream_name
+        resource = Resource.create(attrs)
 
-        # Respect any existing providers to avoid breaking apps that configured OTel elsewhere
+        # providers (reuse if already set globally)
         existing_lp = None
-        try:
+        with suppress(Exception):
             existing_lp = get_logger_provider()
-        except Exception:
-            pass
-
-        if not isinstance(existing_lp, LoggerProvider):
+        if getattr(existing_lp, "add_log_record_processor", None):
+            self.logger_provider = existing_lp
+        else:
             self.logger_provider = LoggerProvider(resource=resource)
             set_logger_provider(self.logger_provider)
-        else:
-            # reuse existing; don’t overwrite global provider
-            self.logger_provider = existing_lp  # type: ignore
 
         existing_tp = None
-        try:
+        with suppress(Exception):
             existing_tp = trace.get_tracer_provider()
-        except Exception:
-            pass
-
-        if not isinstance(existing_tp, TracerProvider):
+        if getattr(existing_tp, "add_span_processor", None):
+            self.tracer_provider = existing_tp
+        else:
             self.tracer_provider = TracerProvider(resource=resource)
             trace.set_tracer_provider(self.tracer_provider)
-        else:
-            self.tracer_provider = existing_tp  # type: ignore
 
         endpoint = self._normalize_otlp_endpoint(self.otel_endpoint)
 
-        # Logs exporter + processor (only if we created our own provider)
+        # exporters/processors (only if we own the providers we created above)
         if isinstance(self.logger_provider, LoggerProvider):
-            try:
+            with suppress(Exception):
                 log_exporter = OTLPLogExporter(endpoint=endpoint, insecure=self.otel_insecure)
                 self.logger_provider.add_log_record_processor(BatchLogRecordProcessor(log_exporter))
-            except Exception as e:
-                self._core_logger.warning(f"Failed to attach OTel log exporter: {e}")
 
-        # Traces exporter + processor (only if we created our own provider)
         if isinstance(self.tracer_provider, TracerProvider):
-            try:
+            with suppress(Exception):
                 span_exporter = OTLPSpanExporter(endpoint=endpoint, insecure=self.otel_insecure)
                 self.tracer_provider.add_span_processor(BatchSpanProcessor(span_exporter))
-            except Exception as e:
-                self._core_logger.warning(f"Failed to attach OTel span exporter: {e}")
-
-        # Attach OTel LoggingHandler once
-        if not any(type(h).__name__ == "LoggingHandler" for h in self._core_logger.handlers):
-            try:
-                otel_handler = LoggingHandler(level=logging.NOTSET, logger_provider=self.logger_provider)  # type: ignore
-                self._core_logger.addHandler(otel_handler)
-            except Exception as e:
-                self._core_logger.warning(f"Failed to attach OTel logging handler: {e}")
-
-        # Tracer handle
-        try:
+
+        # attach OTel log handler once
+        if not any(type(h).__name__ == "LoggingHandler" for h in self._core.handlers):
+            with suppress(Exception):
+                self._core.addHandler(LoggingHandler(level=logging.NOTSET, logger_provider=self.logger_provider))  # type: ignore
+
+        with suppress(Exception):
             self.tracer = trace.get_tracer(self.logger_name)
-        except Exception:
-            self.tracer = None
 
         self._otel_initialized_names.add(self.logger_name)
-        self._core_logger.info("OpenTelemetry logging/tracing initialized.")
-
+        self._core.info("OpenTelemetry logging/tracing initialized.")

{sibi_dst-2025.8.8.dist-info → sibi_dst-2025.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sibi-dst
-Version: 2025.8.8
+Version: 2025.8.9
 Summary: Data Science Toolkit
 Author: Luis Valverde
 Author-email: lvalverdeb@gmail.com

{sibi_dst-2025.8.8.dist-info → sibi_dst-2025.8.9.dist-info}/RECORD

@@ -54,7 +54,7 @@ sibi_dst/utils/file_age_checker.py,sha256=44B3lwH_PLwzMfiKkgvJKjKx-qSgITIXxKfNbd
 sibi_dst/utils/file_utils.py,sha256=cm__02IKCfEOzAKAZwdNIjnRL8H4XtPa6hKcj510pto,1310
 sibi_dst/utils/filepath_generator.py,sha256=Ke_OwBjLJkNMeOP0QjbLIZpSMkzhAIxKyf4hZ5P5re0,12916
 sibi_dst/utils/iceberg_saver.py,sha256=l1UWJWrLqe2OxCdP1mRyXlG9It1-F3MN_ZvHPmxqRJ4,5253
-sibi_dst/utils/log_utils.py,sha256=vhShRtCklQgVx9j7ustG6-r1bOyfgVTyHktOC_hmw5Y,14283
+sibi_dst/utils/log_utils.py,sha256=1xXTDfwMwWIdj37hjyXSpHx3ft2GMiXsAfxq9AArMTY,11588
 sibi_dst/utils/manifest_manager.py,sha256=9y4cV-Ig8O-ekhApp_UObTY-cTsl-bGnvKIThItEzg4,7394
 sibi_dst/utils/parquet_saver.py,sha256=XUDLpMRqkKvBTdUhckhRzQyyLSaI9q5iCqcmeyHc-0Q,9609
 sibi_dst/utils/periods.py,sha256=8eTGi-bToa6_a8Vwyg4fkBPryyzft9Nzy-3ToxjqC8c,1434
@@ -87,6 +87,6 @@ sibi_dst/v2/df_helper/core/_params_config.py,sha256=DYx2drDz3uF-lSPzizPkchhy-kxR
 sibi_dst/v2/df_helper/core/_query_config.py,sha256=Y8LVSyaKuVkrPluRDkQoOwuXHQxner1pFWG3HPfnDHM,441
 sibi_dst/v2/utils/__init__.py,sha256=6H4cvhqTiFufnFPETBF0f8beVVMpfJfvUs6Ne0TQZNY,58
 sibi_dst/v2/utils/log_utils.py,sha256=rfk5VsLAt-FKpv6aPTC1FToIPiyrnHAFFBAkHme24po,4123
-sibi_dst-2025.8.8.dist-info/METADATA,sha256=I6-rFEYpwCpVnxyplZCFR39982IX0FjQ_8GUusW1OqA,2671
-sibi_dst-2025.8.8.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-sibi_dst-2025.8.8.dist-info/RECORD,,
+sibi_dst-2025.8.9.dist-info/METADATA,sha256=euFCqxH_OCKd1_56ino8Dg9k9FfZszwrNf-8wnJSX4s,2671
+sibi_dst-2025.8.9.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+sibi_dst-2025.8.9.dist-info/RECORD,,