langwatch 0.2.14__tar.gz → 0.2.15__tar.gz

{langwatch-0.2.14 → langwatch-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langwatch
-Version: 0.2.14
+Version: 0.2.15
 Summary: LangWatch Python SDK, for monitoring your LLMs
 Author-email: Langwatch Engineers <engineering@langwatch.ai>
 License: MIT

langwatch-0.2.15/examples/openinference/google_adk.py

@@ -0,0 +1,117 @@
+"""
+Google ADK Agent with LangWatch Observability
+
+This example demonstrates how to use Google ADK (Agent Development Kit) with LangWatch
+for comprehensive observability, monitoring, and evaluation of your AI agents.
+
+Features demonstrated:
+- Automatic tracing of all agent interactions
+- Tool usage with weather information
+- Custom metadata and context
+- Error handling and debugging
+- Session management
+- Streaming responses
+
+Requirements:
+- pip install langwatch google-adk openinference-instrumentation-google-adk
+- Set LANGWATCH_API_KEY and GOOGLE_API_KEY environment variables
+"""
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+import chainlit as cl
+import langwatch
+from openinference.instrumentation.google_adk import GoogleADKInstrumentor
+from google.adk.agents import Agent
+from google.adk.runners import InMemoryRunner
+from google.genai import types
+import nest_asyncio
+
+nest_asyncio.apply()
+
+# Initialize LangWatch once at module level
+langwatch.setup(instrumentors=[GoogleADKInstrumentor()])
+
+
+def get_weather(city: str):
+    """Get weather for a city."""
+    weather_data = {
+        "new york": "Sunny, 25°C (77°F), Humidity: 65%",
+        "london": "Cloudy, 18°C (64°F), Humidity: 80%",
+        "tokyo": "Rainy, 22°C (72°F), Humidity: 85%",
+    }
+
+    city_lower = city.lower()
+    if city_lower in weather_data:
+        return {"status": "success", "report": weather_data[city_lower]}
+    else:
+        return {"status": "error", "message": f"Weather for '{city}' not available."}
+
+
+def get_stock_price(symbol: str):
+    """Get stock price for a symbol."""
+    stock_data = {
+        "AAPL": {"price": 175.50, "change": 2.30},
+        "GOOGL": {"price": 142.80, "change": -1.20},
+        "MSFT": {"price": 380.25, "change": 5.75},
+    }
+
+    symbol_upper = symbol.upper()
+    if symbol_upper in stock_data:
+        data = stock_data[symbol_upper]
+        return {
+            "status": "success",
+            "price": f"${data['price']:.2f}",
+            "change": f"${data['change']:+.2f}",
+        }
+    else:
+        return {"status": "error", "message": f"Stock '{symbol}' not available."}
+
+
+@cl.on_chat_start
+async def on_chat_start():
+    agent = Agent(
+        name="multi_tool_agent",
+        model="gemini-2.0-flash-exp",
+        description="Agent with weather and stock tools.",
+        instruction="Use available tools to answer questions.",
+        tools=[get_weather, get_stock_price],
+    )
+
+    cl.user_session.set("agent", agent)
+    cl.user_session.set("runner", InMemoryRunner(agent=agent, app_name="demo"))
+
+
+@cl.on_message
+@langwatch.trace()
+async def main(message: cl.Message):
+    agent = cl.user_session.get("agent")
+    runner = cl.user_session.get("runner")
+
+    msg = cl.Message(content="")
+
+    langwatch.get_current_trace().update(
+        metadata={"labels": ["google_adk"], "agent_name": agent.name}
+    )
+
+    # Create session for this interaction
+    session_service = runner.session_service
+    await session_service.create_session(
+        app_name="demo", user_id="user", session_id="session"
+    )
+
+    async for event in runner.run_async(
+        user_id="user",
+        session_id="session",
+        new_message=types.Content(
+            role="user", parts=[types.Part(text=message.content)]
+        ),
+    ):
+        if event.is_final_response():
+            response = event.content.parts[0].text.strip()
+            await msg.stream_token(response)
+            break
+
+    await msg.update()

{langwatch-0.2.14 → langwatch-0.2.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langwatch"
-version = "0.2.14" # remember to also update it in src/langwatch/__version__.py
+version = "0.2.15" # remember to also update it in src/langwatch/__version__.py
 description = "LangWatch Python SDK, for monitoring your LLMs"
 authors = [{ name = "Langwatch Engineers", email = "engineering@langwatch.ai" }]
 requires-python = ">=3.10,<3.14"

{langwatch-0.2.14 → langwatch-0.2.15}/src/langwatch/__version__.py

@@ -1,3 +1,3 @@
 """Version information for LangWatch."""
 
-__version__ = "0.2.14"
+__version__ = "0.2.15"

{langwatch-0.2.14 → langwatch-0.2.15}/src/langwatch/client.py

@@ -42,6 +42,7 @@ class Client(LangWatchClientProtocol):
     _flush_on_exit: bool = True
     _span_exclude_rules: List[SpanProcessingExcludeRule] = []
     _ignore_global_tracer_provider_override_warning: bool = False
+    _skip_open_telemetry_setup: bool = False
     _rest_api_client: LangWatchApiClient
 
     def __init__(
@@ -56,6 +57,7 @@ class Client(LangWatchClientProtocol):
         flush_on_exit: bool = True,
         span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
         ignore_global_tracer_provider_override_warning: bool = False,
+        skip_open_telemetry_setup: bool = False,
     ):
         """
         Initialize the LangWatch tracing client.
@@ -70,6 +72,7 @@ class Client(LangWatchClientProtocol):
                 flush_on_exit: Optional. If True, the tracer provider will flush all spans when the program exits.
                 span_exclude_rules: Optional. The rules to exclude from the span exporter.
                 ignore_global_tracer_provider_override_warning: Optional. If True, the warning about the global tracer provider being overridden will be ignored.
+                skip_open_telemetry_setup: Optional. If True, OpenTelemetry setup will be skipped entirely. This is useful when you want to handle OpenTelemetry setup yourself.
         """
 
         self._api_key = api_key or os.getenv("LANGWATCH_API_KEY", "")
@@ -85,6 +88,7 @@ class Client(LangWatchClientProtocol):
         self._ignore_global_tracer_provider_override_warning = (
             ignore_global_tracer_provider_override_warning
         )
+        self._skip_open_telemetry_setup = skip_open_telemetry_setup
         self.base_attributes = base_attributes or {}
         self.base_attributes[AttributeKey.LangWatchSDKName] = (
             "langwatch-observability-sdk"
@@ -92,11 +96,17 @@ class Client(LangWatchClientProtocol):
         self.base_attributes[AttributeKey.LangWatchSDKVersion] = str(__version__)
         self.base_attributes[AttributeKey.LangWatchSDKLanguage] = "python"
 
-        self.tracer_provider = self.__ensure_otel_setup(tracer_provider)
+        if not self._skip_open_telemetry_setup:
+            self.tracer_provider = self.__ensure_otel_setup(tracer_provider)
 
-        self.instrumentors = instrumentors or []
-        for instrumentor in self.instrumentors:
-            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors = instrumentors or []
+            for instrumentor in self.instrumentors:
+                instrumentor.instrument(tracer_provider=self.tracer_provider)
+        else:
+            self.tracer_provider = tracer_provider
+            self.instrumentors = instrumentors or []
+            if self._debug:
+                logger.debug("Skipping OpenTelemetry setup as requested")
 
         self._setup_rest_api_client()
 
@@ -135,7 +145,7 @@ class Client(LangWatchClientProtocol):
 
         self._api_key = value
 
-        if api_key_has_changed:
+        if api_key_has_changed and not self._skip_open_telemetry_setup:
             # Shut down any existing tracer provider, as API key change requires re-initialization.
             self.__shutdown_tracer_provider()
 
@@ -160,6 +170,11 @@ class Client(LangWatchClientProtocol):
         """Get the REST API client for the client."""
         return self._rest_api_client
 
+    @property
+    def skip_open_telemetry_setup(self) -> bool:
+        """Get whether OpenTelemetry setup is skipped."""
+        return self._skip_open_telemetry_setup
+
     @disable_sending.setter
     def disable_sending(self, value: bool) -> None:
         """Set whether sending is disabled. If enabling, this will create a new global tracer provider."""
@@ -167,7 +182,7 @@ class Client(LangWatchClientProtocol):
             return
 
         # force flush the tracer provider before changing the disable_sending flag
-        if self.tracer_provider:
+        if self.tracer_provider and not self._skip_open_telemetry_setup:
             self.tracer_provider.force_flush()
 
         self._disable_sending = value
@@ -196,6 +211,11 @@ class Client(LangWatchClientProtocol):
 
     def __setup_tracer_provider(self) -> None:
         """Sets up the tracer provider if not already active."""
+        if self._skip_open_telemetry_setup:
+            if self._debug:
+                logger.debug("Skipping tracer provider setup as requested.")
+            return
+
         if not self.tracer_provider:
             if self._debug:
                 logger.debug("Setting up new tracer provider.")

{langwatch-0.2.14 → langwatch-0.2.15}/src/langwatch/dataset/__init__.py

@@ -1,5 +1,6 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 from opentelemetry import trace
+from opentelemetry.trace import NoOpTracer
 from langwatch.generated.langwatch_rest_api_client.api.default import (
     get_api_dataset_by_slug_or_id,
 )
@@ -14,6 +15,7 @@ from langwatch.generated.langwatch_rest_api_client.models import (
 )
 from langwatch.state import get_instance
 import pandas as pd
+from pydantic import BaseModel
 
 from langwatch.utils.initialization import ensure_setup
 
@@ -37,10 +39,20 @@ class Dataset:
         return pd.DataFrame([entry.entry for entry in self.entries])
 
 
-def get_dataset(slug_or_id: str) -> Dataset:
+class GetDatasetOptions(BaseModel):
+    ignore_tracing: Optional[bool] = False
+
+
+def get_dataset(
+    slug_or_id: str, options: Optional[GetDatasetOptions] = None
+) -> Dataset:
     ensure_setup()
 
-    with _tracer.start_as_current_span("get_dataset") as span:
+    tracer = NoOpTracer() if options and options.ignore_tracing is True else _tracer
+
+    with tracer.start_as_current_span(
+        "get_dataset",
+    ) as span:
         span.set_attribute("inputs.slug_or_id", slug_or_id)
 
         try:

{langwatch-0.2.14 → langwatch-0.2.15}/tests/test_client.py

@@ -4,8 +4,16 @@ from typing import Optional
 import pytest
 
 
-def make_client(api_key: Optional[str] = None, disable_sending: bool = False) -> Client:
-    return Client(api_key=api_key, disable_sending=disable_sending)
+def make_client(
+    api_key: Optional[str] = None,
+    disable_sending: bool = False,
+    skip_open_telemetry_setup: bool = False,
+) -> Client:
+    return Client(
+        api_key=api_key,
+        disable_sending=disable_sending,
+        skip_open_telemetry_setup=skip_open_telemetry_setup,
+    )
 
 
 def test_api_key_setter_same_key():
@@ -144,3 +152,32 @@ def test_tracer_provider_reinitialized_on_api_key_change():
         client.api_key = "second-key"
         shutdown2.assert_not_called()
         setup_tracer2.assert_not_called()
+
+
+def test_skip_open_telemetry_setup_property():
+    """Test that skip_open_telemetry_setup property returns the correct value."""
+    client = make_client(api_key="test-key", skip_open_telemetry_setup=True)
+    assert client.skip_open_telemetry_setup is True
+
+    client2 = make_client(api_key="test-key", skip_open_telemetry_setup=False)
+    assert client2.skip_open_telemetry_setup is False
+
+    client3 = make_client(api_key="test-key")  # Default should be False
+    assert client3.skip_open_telemetry_setup is False
+
+
+def test_skip_open_telemetry_setup_api_key_setter():
+    """Test that skip_open_telemetry_setup prevents OpenTelemetry reinitialization when API key changes."""
+    client = make_client(api_key="first-key", skip_open_telemetry_setup=True)
+
+    with (
+        patch.object(client, "_Client__shutdown_tracer_provider") as shutdown,
+        patch.object(client, "_Client__setup_tracer_provider") as setup_tracer,
+        patch.object(client, "_setup_rest_api_client") as setup_rest,
+    ):
+        client.api_key = "second-key"
+        # Should not call shutdown or setup_tracer when skip_open_telemetry_setup is True
+        shutdown.assert_not_called()
+        setup_tracer.assert_not_called()
+        # Should still call setup_rest for the API client
+        setup_rest.assert_called_once()