sunholo 0.129.0__py3-none-any.whl → 0.129.2__py3-none-any.whl

sunholo/custom_logging.py

@@ -89,53 +89,109 @@ class GoogleCloudLogging:
                 }
         return None
 
+    def update_trace_id(self, trace_id):
+        """
+        Updates the trace ID to be included in all logs.
+        
+        Args:
+            trace_id (str): The trace ID to add to all logs.
+        """
+        self.trace_id = trace_id
+
+    def _append_trace_id(self, log_text):
+        """
+        Appends trace ID to log text if available.
+        
+        Args:
+            log_text (str): The log message.
+        
+        Returns:
+            str: Log message with trace ID prefixed if available.
+        """
+        if hasattr(self, 'trace_id') and self.trace_id:
+            return f"{self.logger_name}-{self.trace_id} {log_text}"
+        return log_text
+
+    def _add_trace_to_struct(self, log_struct):
+        """
+        Adds trace ID to structured log data if available.
+        
+        Args:
+            log_struct (dict): The structured log data.
+        
+        Returns:
+            dict: Log structure with trace ID added if available.
+        """
+        if not isinstance(log_struct, dict):
+            return log_struct
+            
+        if hasattr(self, 'trace_id') and self.trace_id:
+            return {**log_struct, "trace_id": self.trace_id}
+        return log_struct
+
     def structured_log(self, log_text=None, log_struct=None, logger_name=None, severity="INFO"):
         """
         Writes log entries to the specified logger as either text or structured data.
-
+        
         Args:
             log_text (str, optional): The log message as a text string. Defaults to None.
             log_struct (dict, optional): The log message as a dictionary for structured log. Defaults to None.
-            logger_name (str, optional): The name of the logger to which to write the log entries. e.g. 
-        logName="run.googleapis.com%2Fstderr"
+            logger_name (str, optional): The name of the logger to which to write the log entries.
+                e.g. logName="run.googleapis.com%2Fstderr"
             severity (str, optional): The severity level of the log entry. Defaults to "INFO".
         """
-
         from .utils.version import sunholo_version
-
-        log_text = f"[{sunholo_version()}] {log_text}"
-
+        
+        # Add version to log_text if it exists
+        if log_text is not None:
+            log_text = f"[{sunholo_version()}] {log_text}"
+            log_text = self._append_trace_id(log_text)
+        
+        # Always create or update log_struct with trace_id if available
+        if not log_struct:
+            log_struct = {}
+        
+        # Make sure log_struct is a dictionary
+        if not isinstance(log_struct, dict):
+            log_struct = {"original_non_dict_value": str(log_struct)}
+        
+        # Add trace ID to log_struct
+        if hasattr(self, 'trace_id') and self.trace_id:
+            log_struct["trace_id"] = self.trace_id
+        
+        # Add version to log_struct
+        log_struct["version"] = sunholo_version()
+        
         if not logger_name and not self.logger_name:
             raise ValueError("Must provide a logger name e.g. 'run.googleapis.com%2Fstderr'")
         
         from .utils.gcp import is_running_on_gcp, is_gcp_logged_in
         if not is_running_on_gcp() and not is_gcp_logged_in():
+            import logging as log
             log.basicConfig(level=log.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
             if log_text:
-                log.info(f"[{severity}][{logger_name or self.logger_name}][{self.version}] - {log_text}")
-            elif log_struct:
+                log.info(f"[{severity}][{logger_name or self.logger_name}][{self.version}] - {log_text} - {log_struct}")
+            else:
                 log.info(f"[{severity}][{logger_name or self.logger_name}][{self.version}] - {str(log_struct)}")
-
+            return
+        
         logger = self.client.logger(logger_name or self.logger_name)
-
         caller_info = self._get_caller_info()
-
+        
+        # Always log struct, and include message if provided
         if log_text:
-            if isinstance(log_struct, dict):
-                logger.log_struct(log_struct, severity=severity, source_location=caller_info)
-            elif isinstance(log_struct, str):
-                logger.log_text(log_text, severity=severity, source_location=caller_info)
-            else:
-                try:
-                    turn_to_text = str(log_text)
-                    logger.log_text(turn_to_text, severity=severity, source_location=caller_info)
-                except Exception as err:
-                    print(f"Could not log this: {log_text=} - {str(err)}")
-
-        elif log_struct:
-            if not isinstance(log_struct, dict):
-                raise ValueError("log_struct must be a dictionary.")
+            log_struct["message"] = log_text
+        
+        try:
             logger.log_struct(log_struct, severity=severity, source_location=caller_info)
+        except Exception as err:
+            print(f"Failed to log struct: {err}")
+            # Fallback to text logging
+            fallback_message = log_text if log_text else str(log_struct)
+            try:
+                logger.log_text(fallback_message, severity=severity, source_location=caller_info)
+            except Exception as text_err:
+                print(f"Even fallback text logging failed: {text_err}")
 
     def debug(self, log_text=None, log_struct=None):
 
@@ -217,6 +273,53 @@ def setup_logging(logger_name=None, log_level=logging.INFO, project_id=None):
         # Now you can use Python's logging module as usual
         import logging
         log.info('This is an info message that will be sent to Google Cloud log.')
+
+        # Basic structured logging
+        log.info(log_struct={"action": "user_login", "user_id": "12345"})
+
+        # Structured logging with trace ID
+        log.update_trace_id("abc-123")
+        log.info(log_struct={"action": "process_started", "file_count": 42})
+        # This will include trace_id: "abc-123" in the logged structure
+
+        # Logging with both text and structure
+        log.info(
+            log_text="Processing completed successfully", 
+            log_struct={"duration_ms": 1234, "items_processed": 100}
+        )
+
+        # Logging error with structured context
+        try:
+            # Some operation
+            process_data()
+        except Exception as e:
+            log.error(
+                log_text=f"Error processing data: {str(e)}",
+                log_struct={
+                    "error_type": type(e).__name__,
+                    "file_name": "example.csv",
+                    "line_number": 42
+                }
+            )
+
+        # More complex structured logging
+        log.info(log_struct={
+            "request": {
+                "method": "POST",
+                "path": "/api/data",
+                "user_agent": "Mozilla/5.0...",
+                "ip": "192.168.1.1"
+            },
+            "response": {
+                "status_code": 200,
+                "processing_time_ms": 345,
+                "bytes_sent": 1024
+            },
+            "metadata": {
+                "version": "1.2.3",
+                "environment": "production"
+            }
+        })
         
     Note:
         This function requires that the 'google-cloud-logging' library is installed and
@@ -252,9 +355,22 @@ def setup_logging(logger_name=None, log_level=logging.INFO, project_id=None):
 
         return log
     
-
-
-
+# for debugging
+def safe_log_struct(log, severity, message, struct):
+    try:
+        if severity == "INFO":
+            log.info(log_text=message, log_struct=struct)
+        elif severity == "ERROR":
+            log.error(log_text=message, log_struct=struct)
+        # Add other severity levels as needed
+    except Exception as e:
+        print(f"Logging error: {e}")
+        print(f"Failed to log structure: {struct}")
+        # Fallback to simple text logging
+        if severity == "INFO":
+            log.info(f"{message} (struct logging failed)")
+        elif severity == "ERROR":
+            log.error(f"{message} (struct logging failed)")
 
 def log_folder_location(folder_name):
     # Get the current working directory
@@ -277,4 +393,53 @@ def get_logger():
         _logger = setup_logging("sunholo")
     return _logger
 
-log = get_logger()
+log = get_logger()
+
+"""
+# Basic structured logging
+log.info(log_struct={"action": "user_login", "user_id": "12345"})
+
+# Structured logging with trace ID
+log.update_trace_id("abc-123")
+log.info(log_struct={"action": "process_started", "file_count": 42})
+# This will include trace_id: "abc-123" in the logged structure
+
+# Logging with both text and structure
+log.info(
+    log_text="Processing completed successfully", 
+    log_struct={"duration_ms": 1234, "items_processed": 100}
+)
+
+# Logging error with structured context
+try:
+    # Some operation
+    process_data()
+except Exception as e:
+    log.error(
+        log_text=f"Error processing data: {str(e)}",
+        log_struct={
+            "error_type": type(e).__name__,
+            "file_name": "example.csv",
+            "line_number": 42
+        }
+    )
+
+# More complex structured logging
+log.info(log_struct={
+    "request": {
+        "method": "POST",
+        "path": "/api/data",
+        "user_agent": "Mozilla/5.0...",
+        "ip": "192.168.1.1"
+    },
+    "response": {
+        "status_code": 200,
+        "processing_time_ms": 345,
+        "bytes_sent": 1024
+    },
+    "metadata": {
+        "version": "1.2.3",
+        "environment": "production"
+    }
+})
+"""

{sunholo-0.129.0.dist-info → sunholo-0.129.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.129.0
+Version: 0.129.2
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0

{sunholo-0.129.0.dist-info → sunholo-0.129.2.dist-info}/RECORD

@@ -1,7 +1,6 @@
 sunholo/__init__.py,sha256=InRbX4V0-qdNHo9zYH3GEye7ASLR6LX8-SMvPV4Jsaw,1212
-sunholo/custom_logging.py,sha256=YfIN1oP3dOEkkYkyRBU8BGS3uJFGwUDsFCl8mIVbwvE,12225
+sunholo/custom_logging.py,sha256=-n7YvgqWQ8nRjCKl1bfcbeZOMTV3m-rBdZGuVyXWDR8,17433
 sunholo/langchain_types.py,sha256=uZ4zvgej_f7pLqjtu4YP7qMC_eZD5ym_5x4pyvA1Ih4,1834
-sunholo/traced_logging.py,sha256=TaAK9gFQ63h700dXfCK-nLcyMvh00N-oZ-xlz4VAZ_4,2891
 sunholo/agents/__init__.py,sha256=X2I3pPkGeKWjc3d0QgSpkTyqD8J8JtrEWqwrumf1MMc,391
 sunholo/agents/chat_history.py,sha256=Gph_CdlP2otYnNdR1q1Umyyyvcad2F6K3LxU5yBQ9l0,5387
 sunholo/agents/dispatch_to_qa.py,sha256=NHihwAoCJ5_Lk11e_jZnucVUGQyZHCB-YpkfMHBCpQk,8882
@@ -169,9 +168,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.129.0.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.129.0.dist-info/METADATA,sha256=57vcuIcATCDaw7YigDz2bXfPqGp3PBSToaTLJLIiJRo,10084
-sunholo-0.129.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-sunholo-0.129.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.129.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.129.0.dist-info/RECORD,,
+sunholo-0.129.2.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.129.2.dist-info/METADATA,sha256=-G-cXG-Chu5B82pBh_4sww6YzAOkcF_6BIt1RDTJuMk,10084
+sunholo-0.129.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+sunholo-0.129.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.129.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.129.2.dist-info/RECORD,,

sunholo/traced_logging.py

@@ -1,70 +0,0 @@
-from .custom_logging import setup_logging, GoogleCloudLogging
-
-class TracedGoogleCloudLogging(GoogleCloudLogging):
-    """Extends GoogleCloudLogging with trace ID functionality."""
-    
-    def __init__(self, project_id=None, log_level=None, logger_name=None, trace_id=None):
-        super().__init__(project_id, log_level, logger_name)
-        self.trace_id = trace_id
-        
-    def update_trace_id(self, trace_id):
-        """Update the trace ID to be included in all logs."""
-        self.trace_id = trace_id
-        
-    def _get_trace_prefix(self):
-        """Get the trace prefix if a trace ID is set."""
-        return f"aitana-{self.trace_id} " if self.trace_id else ""
-        
-    def structured_log(self, log_text=None, log_struct=None, logger_name=None, severity="INFO"):
-        """Override to add trace ID to logs."""
-        if log_text and self.trace_id:
-            log_text = f"{self._get_trace_prefix()}{log_text}"
-            
-        if log_struct and self.trace_id:
-            if isinstance(log_struct, dict):
-                log_struct = {**log_struct, "trace_id": self.trace_id}
-                
-        # Call the parent method with the modified parameters
-        super().structured_log(log_text, log_struct, logger_name, severity)
-        
-def setup_traced_logging(logger_name=None, log_level=None, project_id=None, trace_id=None):
-    """Sets up traced logging that includes a trace ID in all logs."""
-    # First get the base logger from the original setup_logging
-    base_logger = setup_logging(logger_name, log_level, project_id)
-    
-    # If it's a GoogleCloudLogging instance, wrap it with our traced version
-    if isinstance(base_logger, GoogleCloudLogging):
-        traced_logger = TracedGoogleCloudLogging(
-            project_id=base_logger.project_id,
-            log_level=base_logger.log_level,
-            logger_name=base_logger.logger_name,
-            trace_id=trace_id
-        )
-        traced_logger.client = base_logger.client  # Reuse the client
-        return traced_logger
-    
-    # For standard Python logging, we can add a filter
-    import logging
-    class TraceFilter(logging.Filter):
-        def __init__(self, trace_id=None):
-            super().__init__()
-            self.trace_id = trace_id
-            
-        def update_trace_id(self, trace_id):
-            self.trace_id = trace_id
-            
-        def filter(self, record):
-            if self.trace_id:
-                prefix = f"aitana-{self.trace_id} "
-                if not record.msg.startswith(prefix):
-                    record.msg = f"{prefix}{record.msg}"
-            return True
-    
-    # Add the trace filter to the logger
-    trace_filter = TraceFilter(trace_id)
-    base_logger.addFilter(trace_filter)
-    
-    # Add the update method to the standard logger
-    base_logger.update_trace_id = trace_filter.update_trace_id
-    
-    return base_logger