ipulse-shared-core-ftredge 19.0.1__py3-none-any.whl → 20.0.1__py3-none-any.whl

ipulse_shared_core_ftredge/monitoring/__init__.py

@@ -1,5 +1,7 @@
 from .microservmon import Microservmon
+from .tracemon import TraceMon
 
 __all__ = [
     'Microservmon',
+    'TraceMon',
 ]

ipulse_shared_core_ftredge/monitoring/microservmon.py

@@ -125,6 +125,11 @@ class Microservmon:
         """Get the current context stack as a string."""
         return " >> ".join(self._context_stack) if self._context_stack else "root"
 
+    @property
+    def current_trace_id(self) -> Optional[str]:
+        """Get the current trace_id from context stack (first element if present)."""
+        return self._context_stack[0] if self._context_stack else None
+
     @contextmanager
     def context(self, context_name: str):
         """
@@ -140,6 +145,24 @@ class Microservmon:
         finally:
             self.pop_context()
 
+    @contextmanager
+    def trace(self, description: Optional[str] = None):
+        """
+        Context manager for trace lifecycle management.
+        Automatically starts and ends a trace, managing the context stack.
+
+        Args:
+            description: Optional description of the trace
+
+        Yields:
+            str: The trace_id for the current trace
+        """
+        trace_id = self.start_trace(description)
+        try:
+            yield trace_id
+        finally:
+            self.end_trace(trace_id)
+
     def push_context(self, context: str):
         """Add a context level to the stack."""
         self._context_stack.append(context)
@@ -182,6 +205,9 @@ class Microservmon:
         self._microservice_metrics["active_traces"] = len(self._active_traces)
         self._microservice_metrics["status_counts"].add_status(ProgressStatus.IN_PROGRESS)
 
+        # Push trace_id as first element in context stack
+        self._context_stack.insert(0, trace_id)
+
         # Log the trace start using StructLog
         msg = description if description else f"Starting trace {trace_id}"
         start_log = StructLog(
@@ -291,18 +317,26 @@ class Microservmon:
         del self._active_traces[trace_id]
         self._microservice_metrics["active_traces"] = len(self._active_traces)
 
+        # Remove trace_id from context stack if it's the first element
+        if self._context_stack and self._context_stack[0] == trace_id:
+            self._context_stack.pop(0)
+
     def log(self, log: StructLog, trace_id: Optional[str] = None) -> None:
         """
         Log a StructLog message with trace context.
 
         Args:
             log: StructLog instance to log
-            trace_id: Optional trace ID for trace-specific logging
+            trace_id: Optional trace ID for trace-specific logging. If not provided,
+                     will use current_trace_id from context stack
         """
+        # Use provided trace_id or infer from context stack
+        effective_trace_id = trace_id or self.current_trace_id
+
         # Calculate elapsed time
         elapsed_ms = None
-        if trace_id and trace_id in self._active_traces:
-            start_time = self._active_traces[trace_id]["start_time"]
+        if effective_trace_id and effective_trace_id in self._active_traces:
+            start_time = self._active_traces[effective_trace_id]["start_time"]
             elapsed_ms = int((time.time() - start_time) * 1000)
         else:
             # Use microservice start time if no trace
@@ -311,9 +345,18 @@ class Microservmon:
         # Set microservice-specific context on the log
         log.collector_id = self.id
         log.base_context = self.base_context
-        # Context includes trace_id automatically via StructLog
-        log.context = f"{self.current_context} >> {trace_id}" if trace_id else self.current_context
-        log.trace_id = trace_id
+
+        # Context with trace_id first, then other context elements
+        if effective_trace_id:
+            context_parts = [effective_trace_id]
+            # Add non-trace_id context elements (skip first element if it's trace_id)
+            other_contexts = [ctx for ctx in self._context_stack if ctx != effective_trace_id]
+            context_parts.extend(other_contexts)
+            log.context = " >> ".join(context_parts)
+        else:
+            log.context = self.current_context
+
+        log.trace_id = effective_trace_id
 
         # Append elapsed time to existing notes
         existing_note = log.note or ""
@@ -321,7 +364,7 @@ class Microservmon:
         log.note = f"{existing_note}; {elapsed_note}" if existing_note else elapsed_note
 
         # Update metrics for the trace or microservice
-        self._update_counts(log, trace_id)
+        self._update_counts(log, effective_trace_id)
 
         # Write to logger
         self._write_log_to_logger(log)

ipulse_shared_core_ftredge/monitoring/tracemon.py

@@ -0,0 +1,320 @@
+"""
+TraceMon - Per-trace monitoring and logging
+==========================================
+
+TraceMon is designed for complete trace isolation. Each request/operation gets
+its own TraceMon instance, eliminating race conditions and providing clean,
+per-trace context management.
+
+Key Design Principles:
+1. One TraceMon per trace (complete isolation)
+2. No shared state between traces
+3. Automatic trace_id inference (no parameter needed)
+4. Thread-safe by design
+5. Collector ID and trace_id are the same (one collector per trace)
+"""
+import uuid
+import time
+from datetime import datetime, timezone
+from typing import Dict, Any, Optional
+from contextlib import contextmanager
+from collections import defaultdict
+from ipulse_shared_base_ftredge import (LogLevel, AbstractResource,
+                                      ProgressStatus, Action,
+                                      Alert, StructLog)
+from ipulse_shared_base_ftredge.status import StatusCounts, map_progress_status_to_log_level, eval_statuses
+
+
+class TraceMon:
+    """
+    TraceMon handles monitoring and logging for a single trace/request.
+
+    Each trace gets its own TraceMon instance, providing complete isolation
+    and eliminating race conditions between concurrent requests.
+    """
+
+    def __init__(self, base_context: str, logger,
+                 max_log_field_len: Optional[int] = 8000,  # by default PipelineLog has 8000 per field length Limit
+                 max_log_dict_byte_size: Optional[float] = 256 * 1024 * 0.80,  # by default PipelineLog dict has 256 * 1024 * 0.80 -80% of 256Kb Limit
+                 exclude_none_from_logs: bool = True):
+        """
+        Initialize TraceMon for a single trace.
+
+        Args:
+            base_context: Base context containing all execution details
+            logger: Logger instance to use
+            max_log_field_len: Maximum length for log field values
+            max_log_dict_byte_size: Maximum byte size for log dictionary
+            exclude_none_from_logs: Whether to exclude None values from logs
+        """
+        # Create ID with timestamp prefix and UUID suffix (same pattern as pipelinemon)
+        timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+        uuid_suffix = str(uuid.uuid4())[:8]  # Take first 8 chars of UUID
+        self._id = f"{timestamp}_{uuid_suffix}"
+
+        # Core configuration
+        self._logger = logger
+        self._base_context = base_context
+
+        # Logging configuration
+        self._max_log_field_len = max_log_field_len
+        self._max_log_dict_byte_size = max_log_dict_byte_size
+        self._exclude_none_from_logs = exclude_none_from_logs
+
+        # Trace timing
+        self._start_time = time.time()
+        self._end_time: Optional[float] = None
+
+        # Context stack (isolated per trace)
+        self._context_stack = []
+
+        # Trace metrics
+        self._metrics = {
+            "trace_id": self._id,  # In TraceMon, collector_id and trace_id are the same
+            "start_time": self._start_time,
+            "status": ProgressStatus.IN_PROGRESS.name,
+            "by_event_count": defaultdict(int),
+            "by_level_code_count": defaultdict(int),
+            "status_counts": StatusCounts()
+        }
+
+        # Add initial status
+        self._metrics["status_counts"].add_status(ProgressStatus.STARTED)
+
+        # Log trace start
+        self._log_trace_start()
+
+    @property
+    def id(self) -> str:
+        """Get the unique ID for this TraceMon (both collector_id and trace_id)."""
+        return self._id
+
+    @property
+    def trace_id(self) -> str:
+        """Get the trace ID for this trace (same as collector_id)."""
+        return self._id
+
+    @property
+    def collector_id(self) -> str:
+        """Get the collector ID for this TraceMon (same as trace_id)."""
+        return self._id
+
+    @property
+    def base_context(self) -> str:
+        """Get the base context."""
+        return self._base_context
+
+    @property
+    def current_context(self) -> str:
+        """Get the current context stack as a string."""
+        if not self._context_stack:
+            return self._id
+        return f"{self._id} >> " + " >> ".join(self._context_stack)
+
+    @property
+    def elapsed_ms(self) -> int:
+        """Get elapsed time in milliseconds since trace start."""
+        return int((time.time() - self._start_time) * 1000)
+
+    @property
+    def duration_ms(self) -> Optional[int]:
+        """Get total duration in milliseconds (only available after end)."""
+        if self._end_time is None:
+            return None
+        return int((self._end_time - self._start_time) * 1000)
+
+    @property
+    def metrics(self) -> Dict[str, Any]:
+        """Get current trace metrics."""
+        metrics = self._metrics.copy()
+        metrics["by_event_count"] = dict(metrics["by_event_count"])
+        metrics["by_level_code_count"] = dict(metrics["by_level_code_count"])
+        metrics["elapsed_ms"] = self.elapsed_ms
+        if self.duration_ms is not None:
+            metrics["duration_ms"] = self.duration_ms
+        return metrics
+
+    @property
+    def is_active(self) -> bool:
+        """Check if trace is still active (not ended)."""
+        return self._end_time is None
+
+    def _log_trace_start(self):
+        """Log the trace start event."""
+        start_log = StructLog(
+            level=LogLevel.INFO,
+            description=f"Starting trace {self._id}",
+            resource=AbstractResource.MICROSERVICE_TRACE,
+            action=Action.EXECUTE,
+            progress_status=ProgressStatus.STARTED,
+        )
+        self.log(start_log)
+
+    @contextmanager
+    def context(self, context_name: str):
+        """
+        Context manager for tracking execution context within this trace.
+
+        Args:
+            context_name: The name of the execution context
+        """
+        self.push_context(context_name)
+        try:
+            yield
+        finally:
+            self.pop_context()
+
+    def push_context(self, context: str):
+        """Add a context level to the stack."""
+        self._context_stack.append(context)
+
+    def pop_context(self):
+        """Remove the most recent context from the stack."""
+        if self._context_stack:
+            return self._context_stack.pop()
+
+    def log(self, log: StructLog) -> None:
+        """
+        Log a StructLog message with this trace's context.
+
+        Args:
+            log: StructLog instance to log
+        """
+        if not self.is_active:
+            # Still allow logging but add a warning note
+            existing_note = log.note or ""
+            warning_note = "TRACE_ENDED"
+            log.note = f"{existing_note}; {warning_note}" if existing_note else warning_note
+
+        # Set trace-specific context
+        log.trace_id = self._id
+        log.collector_id = self._id
+        log.base_context = self._base_context
+        log.context = self.current_context
+
+        # Add elapsed time
+        existing_note = log.note or ""
+        elapsed_note = f"elapsed_ms: {self.elapsed_ms}"
+        log.note = f"{existing_note}; {elapsed_note}" if existing_note else elapsed_note
+
+        # Update trace metrics
+        self._update_counts(log)
+
+        # Write to logger
+        self._write_log_to_logger(log)
+
+    def _update_counts(self, log: StructLog):
+        """Update trace metrics based on the log event."""
+        event_tuple = log.getEvent()
+        level = log.level
+
+        self._metrics["by_event_count"][event_tuple] += 1
+        self._metrics["by_level_code_count"][level.value] += 1
+
+    def _get_error_count(self) -> int:
+        """Get total error count (ERROR + CRITICAL)."""
+        return (self._metrics["by_level_code_count"].get(LogLevel.ERROR.value, 0) +
+                self._metrics["by_level_code_count"].get(LogLevel.CRITICAL.value, 0))
+
+    def _get_warning_count(self) -> int:
+        """Get warning count."""
+        return self._metrics["by_level_code_count"].get(LogLevel.WARNING.value, 0)
+
+    def _get_notice_count(self) -> int:
+        """Get notice count."""
+        return self._metrics["by_level_code_count"].get(LogLevel.NOTICE.value, 0)
+
+    def end(self, force_status: Optional[ProgressStatus] = None, issues_allowed: bool = True) -> Dict[str, Any]:
+        """
+        End this trace and return final metrics.
+
+        Args:
+            force_status: Optional status to force, overriding automatic calculation
+            issues_allowed: Whether issues (errors) are allowed for this trace
+
+        Returns:
+            Dict containing final trace metrics
+        """
+        if not self.is_active:
+            # Already ended, return existing metrics
+            return self.metrics
+
+        self._end_time = time.time()
+
+        # Calculate final status
+        error_count = self._get_error_count()
+        warning_count = self._get_warning_count()
+        notice_count = self._get_notice_count()
+
+        if force_status is not None:
+            final_status = force_status
+            level = map_progress_status_to_log_level(final_status)
+        else:
+            # Simple status calculation based on error/warning/notice counts
+            if error_count > 0:
+                if issues_allowed:
+                    final_status = ProgressStatus.FINISHED_WITH_ISSUES
+                else:
+                    final_status = ProgressStatus.FAILED
+            elif warning_count > 0:
+                final_status = ProgressStatus.DONE_WITH_WARNINGS
+            elif notice_count > 0:
+                final_status = ProgressStatus.DONE_WITH_NOTICES
+            else:
+                final_status = ProgressStatus.DONE
+
+            level = map_progress_status_to_log_level(final_status)
+
+        # Update trace status
+        self._metrics["status"] = final_status.name
+        self._metrics["status_counts"].add_status(final_status)
+
+        # Log completion
+        status_source = "FORCED" if force_status is not None else "AUTO"
+        summary_msg = (
+            f"Trace {self._id} completed with status {final_status.name} ({status_source}). "
+            f"Duration: {self.duration_ms}ms. "
+            f"Errors: {error_count}, Warnings: {warning_count}, Notices: {notice_count}"
+        )
+
+        completion_log = StructLog(
+            level=level,
+            description=summary_msg,
+            resource=AbstractResource.MICROSERVICE_TRACE,
+            action=Action.EXECUTE,
+            progress_status=final_status
+        )
+        self.log(completion_log)
+
+        return self.metrics
+
+    def get_readable_level_counts(self) -> Dict[str, int]:
+        """Get readable level counts for this trace."""
+        readable_counts = {}
+
+        for level_code, count in self._metrics["by_level_code_count"].items():
+            if count > 0:
+                for level in LogLevel:
+                    if level.value == level_code:
+                        readable_counts[level.name] = count
+                        break
+
+        return readable_counts
+
+    def _write_log_to_logger(self, log: StructLog):
+        """Write structured log to the logger."""
+        log_dict = log.to_dict(
+            max_field_len=self._max_log_field_len,
+            byte_size_limit=self._max_log_dict_byte_size,
+            exclude_none=self._exclude_none_from_logs
+        )
+
+        # Write to logger based on level
+        if log.level.value >= LogLevel.ERROR.value:
+            self._logger.error(log_dict)
+        elif log.level.value >= LogLevel.WARNING.value:
+            self._logger.warning(log_dict)
+        elif log.level.value >= LogLevel.INFO.value:
+            self._logger.info(log_dict)
+        else:
+            self._logger.debug(log_dict)

{ipulse_shared_core_ftredge-19.0.1.dist-info → ipulse_shared_core_ftredge-20.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 19.0.1
+Version: 20.0.1
 Summary: Shared Core models and Logger util for the Pulse platform project. Using AI for financial advisory and investment management.
 Home-page: https://github.com/TheFutureEdge/ipulse_shared_core
 Author: Russlan Ramdowar

{ipulse_shared_core_ftredge-19.0.1.dist-info → ipulse_shared_core_ftredge-20.0.1.dist-info}/RECORD

@@ -16,8 +16,9 @@ ipulse_shared_core_ftredge/models/subscription.py,sha256=bu6BtyDQ4jDkK3PLY97dZ_A
 ipulse_shared_core_ftredge/models/user_auth.py,sha256=NLR3Fazj4ZKy-ym8utnfhwDbxHExsb4DVqFZ2xI4kLI,3140
 ipulse_shared_core_ftredge/models/user_profile.py,sha256=lqpuXfdXFm-yw5xnwk_BC6QLxpBKbxaED0q2_6-GBvw,5765
 ipulse_shared_core_ftredge/models/user_status.py,sha256=7t3aY4-FjC_Jm2NVIlV-88zcdOG9Bd_g3c5Vpt-amSw,21077
-ipulse_shared_core_ftredge/monitoring/__init__.py,sha256=ZfEHQi_28wFtW416wg2rLHOUUNcMgcovaHsgiKlWDTU,73
-ipulse_shared_core_ftredge/monitoring/microservmon.py,sha256=eAPu1hz0WmylXEcJArYjKrdZrGTfZoRYlODfPfiv1Kc,19416
+ipulse_shared_core_ftredge/monitoring/__init__.py,sha256=lH1zGVWMuWkqh6mmBWq0GU2pdbg7lfdBXHckGlf768k,120
+ipulse_shared_core_ftredge/monitoring/microservmon.py,sha256=hg713JDW-QGXvBlHIP--nBKF94XcWzcHCOjmkr87BrA,21031
+ipulse_shared_core_ftredge/monitoring/tracemon.py,sha256=92a6hWhMB1nAqfKG0pCW3sBqfEHLNitInNI9O-zyv-8,11616
 ipulse_shared_core_ftredge/services/__init__.py,sha256=HbPhpzeJjf0_B7IjfbqA1DcRb2b3ZEvdL_axx173Yh4,894
 ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py,sha256=QCDU8Xy3ztEMy9wLzoZmszQp6J7m5wEcNki2JPDWqyI,9140
 ipulse_shared_core_ftredge/services/charging_processors.py,sha256=8bozatlie8egZFA-IUc2Vh1zjhyTdDqoe5nNgsL_ebM,16170
@@ -34,8 +35,8 @@ ipulse_shared_core_ftredge/services/user/user_holistic_operations.py,sha256=oujC
 ipulse_shared_core_ftredge/utils/__init__.py,sha256=JnxUb8I2MRjJC7rBPXSrpwBIQDEOku5O9JsiTi3oun8,56
 ipulse_shared_core_ftredge/utils/custom_json_encoder.py,sha256=DblQLD0KOSNDyQ58wQRogBrShIXzPIZUw_oGOBATnJY,1366
 ipulse_shared_core_ftredge/utils/json_encoder.py,sha256=QkcaFneVv3-q-s__Dz4OiUWYnM6jgHDJrDMdPv09RCA,2093
-ipulse_shared_core_ftredge-19.0.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
-ipulse_shared_core_ftredge-19.0.1.dist-info/METADATA,sha256=nkDrQ-jtlE4xIFkkMf5pmsdWtN-aSNhDkJnS0UdT7n0,803
-ipulse_shared_core_ftredge-19.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ipulse_shared_core_ftredge-19.0.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
-ipulse_shared_core_ftredge-19.0.1.dist-info/RECORD,,
+ipulse_shared_core_ftredge-20.0.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
+ipulse_shared_core_ftredge-20.0.1.dist-info/METADATA,sha256=Yw11hvsKpLro4hxINzgUgcqzuBIwM-pThiAzkGsarbU,803
+ipulse_shared_core_ftredge-20.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ipulse_shared_core_ftredge-20.0.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
+ipulse_shared_core_ftredge-20.0.1.dist-info/RECORD,,