paid-python 0.0.5a40__py3-none-any.whl → 0.1.1__py3-none-any.whl

paid/tracing/wrappers/anthropic/anthropicWrapper.py

@@ -1,14 +1,9 @@
 import typing
 
-from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
 
 from paid.tracing.tracing import (
     get_paid_tracer,
-    logger,
-    paid_external_agent_id_var,
-    paid_external_customer_id_var,
-    paid_token_var,
 )
 
 try:
@@ -23,54 +18,28 @@ except ImportError:
 
 
 class PaidAnthropic:
-    def __init__(self, anthropic_client: Anthropic, optional_tracing: bool = False):
+    def __init__(self, anthropic_client: Anthropic):
         self.anthropic = anthropic_client
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
 
     @property
     def messages(self):
-        return MessagesWrapper(self.anthropic, self.tracer, self.optional_tracing)
+        return MessagesWrapper(self.anthropic)
 
 
 class MessagesWrapper:
-    def __init__(self, anthropic_client: Anthropic, tracer: trace.Tracer, optional_tracing: bool):
+    def __init__(self, anthropic_client: Anthropic):
         self.anthropic = anthropic_client
-        self.tracer = tracer
-        self.optional_tracing = optional_tracing
 
     def create(
         self, *, model: ModelParam, messages: typing.Iterable[MessageParam], max_tokens: int, **kwargs
     ) -> typing.Any:
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, calling Anthropic directly.")
-                return self.anthropic.messages.create(model=model, messages=messages, max_tokens=max_tokens, **kwargs)
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
-
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No external_customer_id or token, calling Anthropic directly")
-                return self.anthropic.messages.create(model=model, messages=messages, max_tokens=max_tokens, **kwargs)
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
-
-        with self.tracer.start_as_current_span("anthropic.messages.create") as span:
+        tracer = get_paid_tracer()
+
+        with tracer.start_as_current_span("anthropic.messages.create") as span:
             attributes = {
                 "gen_ai.system": "anthropic",
                 "gen_ai.operation.name": "messages",
-                "external_customer_id": external_customer_id,
-                "token": token,
             }
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
 
             try:
                 response = self.anthropic.messages.create(
@@ -104,58 +73,28 @@ class MessagesWrapper:
 
 
 class PaidAsyncAnthropic:
-    def __init__(self, anthropic_client: AsyncAnthropic, optional_tracing: bool = False):
+    def __init__(self, anthropic_client: AsyncAnthropic):
         self.anthropic = anthropic_client
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
 
     @property
     def messages(self):
-        return AsyncMessagesWrapper(self.anthropic, self.tracer, self.optional_tracing)
+        return AsyncMessagesWrapper(self.anthropic)
 
 
 class AsyncMessagesWrapper:
-    def __init__(self, anthropic_client: AsyncAnthropic, tracer: trace.Tracer, optional_tracing: bool):
+    def __init__(self, anthropic_client: AsyncAnthropic):
         self.anthropic = anthropic_client
-        self.tracer = tracer
-        self.optional_tracing = optional_tracing
 
     async def create(
         self, *, model: ModelParam, messages: typing.Iterable[MessageParam], max_tokens: int, **kwargs
     ) -> typing.Any:
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, calling Anthropic directly.")
-                return await self.anthropic.messages.create(
-                    model=model, messages=messages, max_tokens=max_tokens, **kwargs
-                )
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
-
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No external_customer_id or token, calling Anthropic directly")
-                return await self.anthropic.messages.create(
-                    model=model, messages=messages, max_tokens=max_tokens, **kwargs
-                )
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
+        tracer = get_paid_tracer()
 
-        with self.tracer.start_as_current_span("anthropic.messages.create") as span:
+        with tracer.start_as_current_span("anthropic.messages.create") as span:
             attributes = {
                 "gen_ai.system": "anthropic",
                 "gen_ai.operation.name": "messages",
-                "external_customer_id": external_customer_id,
-                "token": token,
             }
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
 
             try:
                 response = await self.anthropic.messages.create(

paid/tracing/wrappers/bedrock/bedrockWrapper.py

@@ -1,53 +1,24 @@
 from typing import Any, Dict, List
 
-from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
 
 from paid.tracing.tracing import (
     get_paid_tracer,
-    logger,
-    paid_external_agent_id_var,
-    paid_external_customer_id_var,
-    paid_token_var,
 )
 
 
 class PaidBedrock:
-    def __init__(self, bedrock_client: Any, optional_tracing: bool = False):
+    def __init__(self, bedrock_client: Any):
         self.bedrock_client = bedrock_client
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
 
     def converse(self, *, modelId: str, messages: List[Dict[str, Any]], **kwargs) -> Dict[str, Any]:
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, calling Bedrock directly.")
-                return self.bedrock_client.converse(modelId=modelId, messages=messages, **kwargs)
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
+        tracer = get_paid_tracer()
 
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No external_customer_id or token, calling Bedrock directly")
-                return self.bedrock_client.converse(modelId=modelId, messages=messages, **kwargs)
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
-
-        with self.tracer.start_as_current_span("bedrock.converse") as span:
+        with tracer.start_as_current_span("bedrock.converse") as span:
             attributes = {
                 "gen_ai.system": "bedrock",
                 "gen_ai.operation.name": "converse",
-                "external_customer_id": external_customer_id,
-                "token": token,
             }
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
 
             try:
                 response = self.bedrock_client.converse(modelId=modelId, messages=messages, **kwargs)

paid/tracing/wrappers/gemini/geminiWrapper.py

@@ -6,16 +6,10 @@ https://github.com/paid-ai/sdk-wrapper-codegen
 
 from typing import Union
 
-from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
 
-from paid.tracing.tracing import (
-    get_paid_tracer,
-    logger,
-    paid_external_agent_id_var,
-    paid_external_customer_id_var,
-    paid_token_var,
-)
+from paid.logger import logger
+from paid.tracing.tracing import get_paid_tracer
 
 try:
     from google import genai
@@ -30,65 +24,35 @@ except ImportError:
 class PaidGemini:
     """OpenTelemetry instrumented wrapper for Gemini Python SDK SDK."""
 
-    def __init__(self, original_client: genai.Client, optional_tracing: bool = False):
+    def __init__(self, original_client: genai.Client):
         self._client = original_client
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
 
     @property
     def models(self):
         """Access models with OTEL instrumentation."""
-        return ModelsWrapper(self._client, self.tracer, self.optional_tracing)
+        return ModelsWrapper(self._client)
 
 
 class ModelsWrapper:
     """Wrapper for models with OTEL instrumentation."""
 
-    def __init__(self, original_client: genai.Client, tracer: trace.Tracer, optional_tracing: bool):
+    def __init__(self, original_client: genai.Client):
         self._client = original_client
-        self.tracer = tracer
-        self.optional_tracing = optional_tracing
 
     def generate_content(self, **kwargs) -> GenerateContentResponse:
         """GenerateContentResponse method with OTEL instrumentation."""
-        # Check if tracing is active (optional tracing mode)
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing wasn't enabled, only calling the client.")
-                return self._client.models.generate_content(**kwargs)
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
-
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(
-                    f"{self.__class__.__name__} No external_customer_id or token, so no tracing, only calling the client."
-                )
-                return self._client.models.generate_content(**kwargs)
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
-
-        with self.tracer.start_as_current_span("gemini.models.generate_content") as span:
+        tracer = get_paid_tracer()
+
+        with tracer.start_as_current_span("gemini.models.generate_content") as span:
             try:
                 # Execute the original method
                 response = self._client.models.generate_content(**kwargs)
                 if response.usage_metadata is None:
-                    # unnecessary but need this for type checker
-                    raise ValueError("Response usage metadata is None. Ensure the response contains usage metadata.")
+                    logger.error("should be unreachable: response.usage_metadata is None, cannot extract usage data")
+                    return response
 
                 # Set OTEL attributes (best-effort)
                 attributes: dict[str, Union[str, int]] = {}
-                attributes["external_customer_id"] = external_customer_id
-                attributes["token"] = token
-                if external_agent_id:
-                    attributes["external_agent_id"] = external_agent_id
-
                 attributes["gen_ai.system"] = "gemini"
                 attributes["gen_ai.operation.name"] = "generate_content"
                 try:

paid/tracing/wrappers/langchain/paidLangChainCallback.py

@@ -2,10 +2,9 @@ import time
 from typing import Any, Dict, List, Optional, Sequence
 from uuid import UUID
 
-from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
 
-from paid.tracing.tracing import get_paid_tracer, logger, paid_external_customer_id_var, paid_token_var
+from paid.tracing.tracing import get_paid_tracer
 
 try:
     from langchain_core.callbacks import BaseCallbackHandler  # type: ignore
@@ -44,7 +43,6 @@ class PaidLangChainCallback(BaseCallbackHandler):
     def __init__(self):
         """Initialize the callback handler."""
         super().__init__()
-        self.tracer = get_paid_tracer()
         self._spans: Dict[str, Any] = {}  # Track active spans by run_id
         self._start_times: Dict[str, float] = {}  # Track start times
 
@@ -56,27 +54,10 @@ class PaidLangChainCallback(BaseCallbackHandler):
 
     def _start_span(self, run_id: UUID, span_name: str, **attributes: Any) -> Optional[Any]:
         """Start a new span and store it."""
-        # Check if there's an active span (from capture())
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            logger.info(f"{self.__class__.__name__} No active span found - LangChain operations will not be traced")
-            return None
-
-        # Get context variables
-        external_customer_id = paid_external_customer_id_var.get()
-        token = paid_token_var.get()
-
-        # Check if required context is available
-        if not (external_customer_id and token):
-            logger.info(
-                f"{self.__class__.__name__} Missing required tracing information "
-                f"(external_customer_id={bool(external_customer_id)}, token={bool(token)}) - "
-                f"LangChain operation '{span_name}' will not be traced"
-            )
-            return None
+        tracer = get_paid_tracer()
 
         # Create child span
-        span = self.tracer.start_span(span_name)
+        span = tracer.start_span(span_name)
 
         # Set common attributes
         base_attributes = {
@@ -84,11 +65,6 @@ class PaidLangChainCallback(BaseCallbackHandler):
             "langchain.run_id": str(run_id),
         }
 
-        if external_customer_id:
-            base_attributes["external_customer_id"] = external_customer_id
-        if token:
-            base_attributes["token"] = token
-
         # Add custom attributes
         base_attributes.update(attributes)
         span.set_attributes(base_attributes)
@@ -97,8 +73,6 @@ class PaidLangChainCallback(BaseCallbackHandler):
         self._spans[str(run_id)] = span
         self._start_times[str(run_id)] = time.time()
 
-        logger.info(f"{self.__class__.__name__} Started span '{span_name}' for run_id={run_id}")
-
         return span
 
     def _end_span(self, run_id: UUID, error: Optional[BaseException] = None, **attributes):
@@ -107,9 +81,6 @@ class PaidLangChainCallback(BaseCallbackHandler):
         span = self._spans.get(span_key)
 
         if not span:
-            logger.info(
-                f"{self.__class__.__name__} No span found for run_id={run_id} - span was not created or already ended"
-            )
             return
 
         try:
@@ -126,10 +97,8 @@ class PaidLangChainCallback(BaseCallbackHandler):
             if error:
                 span.set_status(Status(StatusCode.ERROR, str(error)))
                 span.record_exception(error)
-                logger.info(f"{self.__class__.__name__} Ended span with error for run_id={run_id}: {error}")
             else:
                 span.set_status(Status(StatusCode.OK))
-                logger.info(f"{self.__class__.__name__} Successfully ended span for run_id={run_id}")
 
         finally:
             span.end()
@@ -149,14 +118,10 @@ class PaidLangChainCallback(BaseCallbackHandler):
     ) -> Any:
         """Called when LLM starts running."""
         if not metadata:
-            logger.info(f"{self.__class__.__name__} No metadata provided for LLM start (run_id={run_id})")
             return None
 
         model_type = metadata.get("ls_model_type", "unknown")
         model_name = metadata.get("ls_model_name", "unknown")
-        logger.info(
-            f"{self.__class__.__name__} LLM start - model_type={model_type}, model_name={model_name}, run_id={run_id}"
-        )
         span_name = self._get_span_name(f"trace.{model_type}", model_name)
 
         attributes = {

paid/tracing/wrappers/llamaindex/llamaIndexWrapper.py

@@ -1,15 +1,8 @@
 from typing import Any, Sequence, cast
 
-from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
 
-from paid.tracing.tracing import (
-    get_paid_tracer,
-    logger,
-    paid_external_agent_id_var,
-    paid_external_customer_id_var,
-    paid_token_var,
-)
+from paid.tracing.tracing import get_paid_tracer
 
 try:
     from llama_index.core.llms import ChatMessage, ChatResponse
@@ -23,44 +16,17 @@ except ImportError:
 
 
 class PaidLlamaIndexOpenAI:
-    def __init__(self, openai_client: OpenAI, optional_tracing: bool = False):
+    def __init__(self, openai_client: OpenAI):
         self.openai = openai_client
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
 
     def chat(self, messages: Sequence[ChatMessage], **kwargs: Any) -> ChatResponse:
-        # Check if there's an active span (from trace())
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, calling LlamaIndex OpenAI directly.")
-                return self.openai.chat(messages=messages, **kwargs)
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
+        tracer = get_paid_tracer()
 
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(
-                    f"{self.__class__.__name__} No external_customer_id or token, calling LlamaIndex OpenAI directly"
-                )
-                return self.openai.chat(messages=messages, **kwargs)
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
-
-        with self.tracer.start_as_current_span("openai.chat") as span:
+        with tracer.start_as_current_span("openai.chat") as span:
             attributes = {
                 "gen_ai.system": "openai",
                 "gen_ai.operation.name": "chat",
-                "external_customer_id": external_customer_id,
-                "token": token,
             }
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
             span.set_attributes(attributes)
 
             try:

paid/tracing/wrappers/mistral/mistralWrapper.py

@@ -1,14 +1,9 @@
 from typing import Any, Dict, List, Optional, Union
 
-from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
 
 from paid.tracing.tracing import (
     get_paid_tracer,
-    logger,
-    paid_external_agent_id_var,
-    paid_external_customer_id_var,
-    paid_token_var,
 )
 
 try:
@@ -22,21 +17,17 @@ except ImportError:
 
 
 class PaidMistral:
-    def __init__(self, mistral_client: Mistral, optional_tracing: bool = False):
+    def __init__(self, mistral_client: Mistral):
         self.mistral = mistral_client
-        self.tracer = get_paid_tracer()
-        self.optional_tracing = optional_tracing
 
     @property
     def ocr(self):
-        return OCRWrapper(self.mistral, self.tracer, self.optional_tracing)
+        return OCRWrapper(self.mistral)
 
 
 class OCRWrapper:
-    def __init__(self, mistral_client: Mistral, tracer: trace.Tracer, optional_tracing: bool):
+    def __init__(self, mistral_client: Mistral):
         self.mistral = mistral_client
-        self.tracer = tracer
-        self.optional_tracing = optional_tracing
 
     def process(
         self,
@@ -75,56 +66,9 @@ class OCRWrapper:
             timeout_ms: Override default request timeout in milliseconds
             http_headers: Additional headers to set or replace on requests
         """
-        # Check if there's an active span (from capture())
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, calling Mistral directly.")
-                return self.mistral.ocr.process(
-                    model=model,
-                    document=document,
-                    id=id,
-                    pages=pages,
-                    include_image_base64=include_image_base64,
-                    image_limit=image_limit,
-                    image_min_size=image_min_size,
-                    bbox_annotation_format=bbox_annotation_format,
-                    document_annotation_format=document_annotation_format,
-                    retries=retries,
-                    server_url=server_url,
-                    timeout_ms=timeout_ms,
-                    http_headers=http_headers,
-                )
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
-
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No external_customer_id or token, calling Mistral directly")
-                return self.mistral.ocr.process(
-                    model=model,
-                    document=document,
-                    id=id,
-                    pages=pages,
-                    include_image_base64=include_image_base64,
-                    image_limit=image_limit,
-                    image_min_size=image_min_size,
-                    bbox_annotation_format=bbox_annotation_format,
-                    document_annotation_format=document_annotation_format,
-                    retries=retries,
-                    server_url=server_url,
-                    timeout_ms=timeout_ms,
-                    http_headers=http_headers,
-                )
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
+        tracer = get_paid_tracer()
 
-        with self.tracer.start_as_current_span("mistral.ocr.process") as span:
+        with tracer.start_as_current_span("mistral.ocr.process") as span:
             attributes = {
                 "gen_ai.system": "mistral",
                 "gen_ai.operation.name": "ocr",
@@ -132,10 +76,6 @@ class OCRWrapper:
             if bbox_annotation_format or document_annotation_format:
                 attributes["gen_ai.ocr.annotated"] = "true"
 
-            attributes["external_customer_id"] = external_customer_id
-            attributes["token"] = token
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
             span.set_attributes(attributes)
 
             try:
@@ -212,56 +152,9 @@ class OCRWrapper:
             timeout_ms: Override default request timeout in milliseconds
             http_headers: Additional headers to set or replace on requests
         """
-        # Check if there's an active span (from capture())
-        current_span = trace.get_current_span()
-        if current_span == trace.INVALID_SPAN:
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No tracing, calling Mistral directly.")
-                return await self.mistral.ocr.process_async(
-                    model=model,
-                    document=document,
-                    id=id,
-                    pages=pages,
-                    include_image_base64=include_image_base64,
-                    image_limit=image_limit,
-                    image_min_size=image_min_size,
-                    bbox_annotation_format=bbox_annotation_format,
-                    document_annotation_format=document_annotation_format,
-                    retries=retries,
-                    server_url=server_url,
-                    timeout_ms=timeout_ms,
-                    http_headers=http_headers,
-                )
-            raise RuntimeError("No OTEL span found. Make sure to call this method from Paid.trace().")
-
-        external_customer_id = paid_external_customer_id_var.get()
-        external_agent_id = paid_external_agent_id_var.get()
-        token = paid_token_var.get()
-
-        if not (external_customer_id and token):
-            if self.optional_tracing:
-                logger.info(f"{self.__class__.__name__} No external_customer_id or token, calling Mistral directly")
-                return await self.mistral.ocr.process_async(
-                    model=model,
-                    document=document,
-                    id=id,
-                    pages=pages,
-                    include_image_base64=include_image_base64,
-                    image_limit=image_limit,
-                    image_min_size=image_min_size,
-                    bbox_annotation_format=bbox_annotation_format,
-                    document_annotation_format=document_annotation_format,
-                    retries=retries,
-                    server_url=server_url,
-                    timeout_ms=timeout_ms,
-                    http_headers=http_headers,
-                )
-            raise RuntimeError(
-                "Missing required tracing information: external_customer_id or token."
-                " Make sure to call this method from Paid.trace()."
-            )
+        tracer = get_paid_tracer()
 
-        with self.tracer.start_as_current_span("mistral.ocr.process_async") as span:
+        with tracer.start_as_current_span("mistral.ocr.process_async") as span:
             attributes = {
                 "gen_ai.system": "mistral",
                 "gen_ai.operation.name": "ocr",
@@ -269,10 +162,6 @@ class OCRWrapper:
             if bbox_annotation_format or document_annotation_format:
                 attributes["gen_ai.ocr.annotated"] = "true"
 
-            attributes["external_customer_id"] = external_customer_id
-            attributes["token"] = token
-            if external_agent_id:
-                attributes["external_agent_id"] = external_agent_id
             span.set_attributes(attributes)
 
             try: