Add start_span() on quotient.tracer (#123)

* Add start_span() method for tracer

* Make sure tracer has the method not just resource

* Make sure we initialize the resource

Author: freddiev4

quotientai/client.py

@@ -500,7 +500,7 @@ def init(
 
         # Configure the underlying tracing resource (if available)
         if self.tracing_resource:
-            self.tracing_resource.configure(
+            self.tracing_resource.init(
                 app_name=app_name,
                 environment=environment,
                 instruments=instruments,
@@ -544,6 +544,27 @@ async def my_async_function():
             # Call the tracing resource without parameters since it's now configured
             return self.tracing_resource.trace(name)
 
+    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)
+
     def _create_lazy_decorator(self, name: Optional[str] = None):
         """
         Create a lazy decorator that defers the tracing decision until function execution.

quotientai/tracing/core.py

@@ -100,7 +100,12 @@ def init(
         """
         self.configure(app_name, environment, instruments, detections)
         detections_str = ",".join(detections) if detections else None
-        self._setup_auto_collector(app_name, environment, instruments, detections_str)
+        self._setup_auto_collector(
+            app_name=app_name,
+            environment=environment,
+            instruments=tuple(instruments),
+            detections=detections_str,
+        )
 
     def get_vector_db_instrumentors(self):
         """
@@ -228,6 +233,7 @@ def _setup_auto_collector(
                 if instruments:
                     for instrument in instruments:
                         instrument.instrument()
+                        
 
             # Initialize tracer if not already done
             if self.tracer is None:
@@ -272,20 +278,19 @@ def my_other_function():
         def decorator(func):
             span_name = name if name is not None else func.__qualname__
 
+            self._setup_auto_collector(
+                app_name=self._app_name,
+                environment=self._environment,
+                instruments=(
+                    tuple(self._instruments)
+                    if self._instruments is not None
+                    else None
+                ),
+                detections=self._detections,
+            )
+
             @functools.wraps(func)
             def sync_func_wrapper(*args, **kwargs):
-
-                self._setup_auto_collector(
-                    app_name=self._app_name,
-                    environment=self._environment,
-                    instruments=(
-                        tuple(self._instruments)
-                        if self._instruments is not None
-                        else None
-                    ),
-                    detections=self._detections,
-                )
-
                 # if there is no tracer, just run the function normally
                 if self.tracer is None:
                     return func(*args, **kwargs)
@@ -307,17 +312,6 @@ def sync_func_wrapper(*args, **kwargs):
 
             @functools.wraps(func)
             async def async_func_wrapper(*args, **kwargs):
-                self._setup_auto_collector(
-                    app_name=self._app_name,
-                    environment=self._environment,
-                    instruments=(
-                        tuple(self._instruments)
-                        if self._instruments is not None
-                        else None
-                    ),
-                    detections=self._detections,
-                )
-
                 if self.tracer is None:
                     return await func(*args, **kwargs)
 
@@ -343,6 +337,25 @@ async def async_func_wrapper(*args, **kwargs):
 
         return decorator
 
+    def start_span(self, name: str):
+        """
+        Start a span.
+        """
+        # Initialize tracer if not already done
+        if self.tracer is None:
+            self.tracer = get_tracer(
+                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."
+            )
+            return lambda func: func
+
+        return self.tracer.start_span(name)
+
     def _cleanup(self):
         """
         Internal cleanup method registered with atexit.