Ensure lazy start span (#124)

* Ensure initialization during lazy init

* remove debug

Author: freddiev4

quotientai/client.py

@@ -469,7 +469,10 @@ class QuotientTracer:
     """
 
     def __init__(
-        self, tracing_resource: Optional[TracingResource], lazy_init: bool = False
+        self, 
+        tracing_resource: Optional[TracingResource], 
+        lazy_init: bool = False, 
+        ensure_init_callback=None,
     ):
         self.tracing_resource = tracing_resource
         self.app_name: Optional[str] = None
@@ -478,6 +481,7 @@ def __init__(
         self.instruments: Optional[List[Any]] = None
         self.detections: Optional[List[str]] = None
         self.lazy_init = lazy_init
+        self.ensure_init_callback = ensure_init_callback
 
         self._configured = False
 
@@ -548,22 +552,23 @@ def start_span(self, name: str):
         """
         Start a span.
         """
-        if self.lazy_init:
-            return self._create_lazy_decorator(name)
-        else:
-            # For non-lazy_init, use the original behavior
-            if not self.tracing_resource:
-                logger.error(
-                    "tracer is not configured. Please call init() before tracing."
-                )
-                return lambda func: func
-            # Warn if not configured but still allow tracing since resource is available
-            if not self._configured:
-                logger.warning(
-                    "tracer is not explicitly configured. Consider calling tracer.init() for full configuration."
-                )
-                
-            return self.tracing_resource.start_span(name)
+        if not self._configured:
+            logger.error(
+                "tracer is not configured. Please call init() before using start_span()."
+            )
+            return None
+        
+        # For lazy_init, ensure initialization if tracing_resource is not available
+        if self.lazy_init and not self.tracing_resource and self.ensure_init_callback:
+            self.ensure_init_callback()
+        
+        if not self.tracing_resource:
+            logger.error(
+                "tracer is configured but tracing resource is not available. This may indicate an initialization issue."
+            )
+            return None
+            
+        return self.tracing_resource.start_span(name)
 
     def _create_lazy_decorator(self, name: Optional[str] = None):
         """
@@ -645,7 +650,7 @@ def __init__(self, api_key: Optional[str] = None, lazy_init: bool = False):
         # Always create a tracer instance for lazy_init mode to avoid decorator errors
         if lazy_init:
             # Create a minimal tracer instance that can handle decorators
-            self.tracer = QuotientTracer(None, lazy_init=True)
+            self.tracer = QuotientTracer(None, lazy_init=True, ensure_init_callback=self._ensure_initialized)
         else:
             self.tracer = None
 
@@ -680,6 +685,10 @@ def _ensure_initialized(self):
         try:
             _client = _BaseQuotientClient(self.api_key)
             self.auth = resources.AuthResource(_client)
+            
+            # Authenticate FIRST to set the user ID
+            self.auth.authenticate()
+            
             self.logs = resources.LogsResource(_client)
             self.tracing = resources.TracingResource(_client)
             self.traces = resources.TracesResource(_client)
@@ -690,10 +699,16 @@ def _ensure_initialized(self):
             # Update tracer with the actual tracing resource if it was created in lazy mode
             if self.lazy_init and self.tracer:
                 self.tracer.tracing_resource = self.tracing
+                # Configure the tracing resource with the settings from the tracer
+                if self.tracer._configured:
+                    self.tracing.init(
+                        app_name=self.tracer.app_name,
+                        environment=self.tracer.environment,
+                        instruments=self.tracer.instruments,
+                    )
             else:
-                self.tracer = QuotientTracer(self.tracing, lazy_init=self.lazy_init)
+                self.tracer = QuotientTracer(self.tracing, lazy_init=self.lazy_init, ensure_init_callback=self._ensure_initialized)
 
-            self.auth.authenticate()
             self._initialized = True
         except Exception as e:
             error_msg = (
@@ -718,6 +733,7 @@ def configure(self, api_key: str):
         self._ensure_initialized()
         return self
 
+
     def log(
         self,
         *,

quotientai/resources/auth.py

@@ -14,6 +14,10 @@ def authenticate(self):
         # Set the user_id if successful
         if response and isinstance(response, dict) and "user_id" in response:
             self._client._user = response["user_id"]
+            print(f"✅ Authentication successful! User ID set to: {response['user_id']}")
+        else:
+            # Print what we got for debugging
+            print(f"❌ Authentication response missing user_id. Response: {response}")
 
         return response
 

quotientai/tracing/core.py

@@ -147,9 +147,9 @@ def _create_otlp_exporter(self, endpoint: str, headers: dict):
     def _get_user(self):
         """
         Get user_id from client.
-        Returns the user_id or None if not found.
+        Returns the user_id or "None" if not found.
         """
-        if hasattr(self._client, "_user"):
+        if hasattr(self._client, "_user") and self._client._user is not None:
             return self._client._user
         return "None"
 
@@ -344,15 +344,16 @@ def start_span(self, name: str):
         # Initialize tracer if not already done
         if self.tracer is None:
             self.tracer = get_tracer(
-                TRACER_NAME, tracer_provider=get_tracer_provider()
+                TRACER_NAME, 
+                tracer_provider=get_tracer_provider(),
             )
 
         # Use only configured values - no parameters accepted
         if not self._app_name or not self._environment:
             logger.error(
-                "tracer must be initialized with valid inputs before using trace(). Double check your inputs and try again."
+                "tracer must be initialized with valid inputs before using start_span(). Double check your inputs and try again."
             )
-            return lambda func: func
+            return None
 
         return self.tracer.start_span(name)