langtrace-python-sdk 2.0.7__tar.gz → 2.0.9__tar.gz

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/.gitignore

@@ -152,6 +152,9 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
+# Test artifcats
+chroma.sqlite3
+
 # PyCharm
 #  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.0.7
+Version: 2.0.9
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -21,11 +21,14 @@ Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: chromadb; extra == 'dev'
 Requires-Dist: cohere; extra == 'dev'
 Requires-Dist: langchain; extra == 'dev'
+Requires-Dist: langchain-community; extra == 'dev'
 Requires-Dist: langchain-openai; extra == 'dev'
 Requires-Dist: llama-index; extra == 'dev'
 Requires-Dist: openai; extra == 'dev'
 Requires-Dist: python-dotenv; extra == 'dev'
+Requires-Dist: qdrant-client; extra == 'dev'
 Provides-Extra: test
+Requires-Dist: protobuf==3.20.0; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-asyncio; extra == 'test'
 Requires-Dist: pytest-vcr; extra == 'test'
@@ -217,6 +220,15 @@ def chat_completion():
    api_call2()
 ```
 
+- `get_prompt_from_registry` - this function is designed to fetch the desired prompt from the `Prompt Registry`. You can pass two options for filtering `prompt_version` & `variables`.
+
+
+```python
+from langtrace_python_sdk import get_prompt_from_registry
+
+prompt = get_prompt_from_registry(<Registry ID>, options={"prompt_version": 1, "variables": {"foo": "bar"} })
+```
+
 ## Supported integrations
 
 Langtrace automatically captures traces from the following vendors:

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/README.md

@@ -184,6 +184,15 @@ def chat_completion():
    api_call2()
 ```
 
+- `get_prompt_from_registry` - this function is designed to fetch the desired prompt from the `Prompt Registry`. You can pass two options for filtering `prompt_version` & `variables`.
+
+
+```python
+from langtrace_python_sdk import get_prompt_from_registry
+
+prompt = get_prompt_from_registry(<Registry ID>, options={"prompt_version": 1, "variables": {"foo": "bar"} })
+```
+
 ## Supported integrations
 
 Langtrace automatically captures traces from the following vendors:

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/pyproject.toml

@@ -34,17 +34,20 @@ dev = [
     "anthropic",
     "python-dotenv",
     "langchain",
+    'langchain-community',
     "langchain-openai",
     "llama-index",
     "langchain-openai",
     "chromadb",
-    "cohere"
+    "cohere",
+    "qdrant_client"
 ]
 
 test = [
     "pytest",
     "pytest-vcr",
-    "pytest-asyncio"
+    "pytest-asyncio",
+    "protobuf==3.20.0",
 ]
 
 

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/examples/pinecone_example/basic.py

@@ -2,19 +2,16 @@
 This example demonstrates how to use Pinecone with Langtrace.
 """
 
+from langtrace_python_sdk import langtrace
 from dotenv import find_dotenv, load_dotenv
 from openai import OpenAI
 from pinecone import Pinecone
 
-from langtrace_python_sdk import langtrace
 from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
 
 _ = load_dotenv(find_dotenv())
 
-langtrace.init(
-    write_spans_to_console=True,
-    disable_instrumentations={"all_except": ["pinecone", "openai"]},
-)
+langtrace.init()
 
 client = OpenAI()
 pinecone = Pinecone()
@@ -30,10 +27,14 @@ def basic():
 
     embedding = result.data[0].embedding
 
-    unique_id = "randomid"
+    unique_id = "unique_random_id"
     data_to_upsert = {"id": unique_id, "values": embedding}
 
     index = pinecone.Index("test-index")
-    index.upsert(vectors=[data_to_upsert])
+    res = index.upsert(vectors=[data_to_upsert], namespace="test-namespace")
+    print("res", res)
 
-    resp = index.query(vector=embedding, top_k=1)
+    resp = index.query(
+        vector=embedding, top_k=1, include_values=False, namespace="test-namespace"
+    )
+    print(resp)

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/langtrace_python_sdk/__init__.py

@@ -16,5 +16,6 @@ limitations under the License.
 
 from langtrace_python_sdk import langtrace
 from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+from langtrace_python_sdk.utils.prompt_registry import get_prompt_from_registry
 
-__all__ = ["langtrace", "with_langtrace_root_span"]
+__all__ = ["langtrace", "with_langtrace_root_span", "get_prompt_from_registry"]

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/langtrace_python_sdk/constants/instrumentation/common.py

@@ -4,6 +4,7 @@ TIKTOKEN_MODEL_MAPPING = {
     "gpt-4-0125-preview": "cl100k_base",
     "gpt-4-1106-preview": "cl100k_base",
     "gpt-4-1106-vision-preview": "cl100k_base",
+    "gpt-4o": "0200k_base",
 }
 
 SERVICE_PROVIDERS = {

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/langtrace_python_sdk/instrumentation/pinecone/patch.py

@@ -15,6 +15,8 @@ limitations under the License.
 """
 
 from langtrace.trace_attributes import DatabaseSpanAttributes
+from langtrace_python_sdk.utils import set_span_attribute
+from langtrace_python_sdk.utils.silently_fail import silently_fail
 from opentelemetry import baggage
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
@@ -24,6 +26,7 @@ from langtrace_python_sdk.constants.instrumentation.common import (
     SERVICE_PROVIDERS,
 )
 from langtrace_python_sdk.constants.instrumentation.pinecone import APIS
+import json
 
 
 def generic_patch(original_method, method, version, tracer):
@@ -49,12 +52,21 @@ def generic_patch(original_method, method, version, tracer):
         attributes = DatabaseSpanAttributes(**span_attributes)
 
         with tracer.start_as_current_span(api["METHOD"], kind=SpanKind.CLIENT) as span:
+
+            if span.is_recording():
+                set_span_attribute(span, "server.address", instance._config.host)
+                if method == "QUERY":
+                    set_query_input_attributes(span, kwargs)
+
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)
             try:
                 # Attempt to call the original method
                 result = original_method(instance, *args, **kwargs)
+                if result:
+                    if span.is_recording():
+                        set_query_response_attributes(span, result)
                 span.set_status(StatusCode.OK)
                 return result
             except Exception as err:
@@ -67,4 +79,48 @@ def generic_patch(original_method, method, version, tracer):
                 # Reraise the exception to ensure it's not swallowed
                 raise
 
+    @silently_fail
+    def set_query_input_attributes(span, kwargs):
+        set_span_attribute(span, "db.query.top_k", kwargs.get("top_k"))
+        set_span_attribute(span, "db.query.namespace", kwargs.get("namespace"))
+        set_span_attribute(span, "db.query.id", kwargs.get("id"))
+        filter = (
+            json.dumps(kwargs.get("filter"))
+            if isinstance(kwargs.get("filter"), dict)
+            else kwargs.get("filter")
+        )
+        set_span_attribute(span, "db.query.filter", filter)
+        set_span_attribute(
+            span, "db.query.include_values", kwargs.get("include_values")
+        )
+        set_span_attribute(
+            span, "db.query.include_metadata", kwargs.get("include_metadata")
+        )
+
+    @silently_fail
+    def set_query_response_attributes(span, response):
+        matches = response.get("matches")
+
+        usage = response.get("usage")
+        for match in matches:
+            span.add_event(
+                name="db.query.match",
+                attributes={
+                    "db.query.match.id": match.get("id"),
+                    "db.query.match.score": match.get("score"),
+                    "db.query.match.metadata": match.get("metadata"),
+                    # "db.query.match.values": match.get("values"),
+                },
+            )
+
+        if "read_units" in usage:
+            set_span_attribute(
+                span, "db.query.usage.read_units", usage.get("read_units")
+            )
+
+        if "write_units" in usage:
+            set_span_attribute(
+                span, "db.query.usage.write_units", usage.get("write_units")
+            )
+
     return traced_method

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/langtrace_python_sdk/instrumentation/qdrant/patch.py

@@ -15,6 +15,8 @@ limitations under the License.
 """
 
 from langtrace.trace_attributes import DatabaseSpanAttributes
+from langtrace_python_sdk.utils.silently_fail import silently_fail
+from langtrace_python_sdk.utils.llm import set_span_attributes
 from opentelemetry import baggage
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
@@ -47,12 +49,19 @@ def collection_patch(method, version, tracer):
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
-        if hasattr(instance, "name") and instance.name is not None:
-            span_attributes["db.collection.name"] = instance.name
-
         attributes = DatabaseSpanAttributes(**span_attributes)
 
         with tracer.start_as_current_span(api["METHOD"], kind=SpanKind.CLIENT) as span:
+            collection_name = kwargs.get("collection_name") or args[0]
+            operation = api["OPERATION"]
+            set_span_attributes(span, "db.collection.name", collection_name)
+            if operation == "upsert":
+                _set_upsert_attributes(span, args, kwargs)
+            elif operation == "add":
+                _set_upload_attributes(span, args, kwargs, "documents")
+
+            # Todo: Add support for other operations here.
+
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)
@@ -72,3 +81,26 @@ def collection_patch(method, version, tracer):
                 raise
 
     return traced_method
+
+
+@silently_fail
+def _set_upsert_attributes(span, args, kwargs):
+    points = kwargs.get("points") or args[1]
+    if isinstance(points, list):
+        length = len(points)
+    else:
+        # In case of using Batch.
+        length = len(points.ids)
+    set_span_attributes(span, "db.upsert.points_count", length)
+
+
+@silently_fail
+def _set_upload_attributes(span, args, kwargs, field):
+    docs = kwargs.get(field) or args[0]
+    if isinstance(docs, list):
+        length = len(docs)
+    else:
+        # In case of using Batch.
+        length = len(docs.ids)
+
+    set_span_attributes(span, f"db.upload.{field}_count", length)

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/langtrace_python_sdk/langtrace.py

@@ -24,6 +24,8 @@ from opentelemetry.sdk.trace.export import (
     ConsoleSpanExporter,
     SimpleSpanProcessor,
 )
+import sys
+from opentelemetry.sdk.resources import Resource
 
 from langtrace_python_sdk.extensions.langtrace_exporter import LangTraceExporter
 from langtrace_python_sdk.instrumentation.anthropic.instrumentation import (
@@ -72,7 +74,7 @@ def init(
     api_host: Optional[str] = None,
     disable_instrumentations: Optional[DisableInstrumentations] = None,
 ):
-    provider = TracerProvider()
+    provider = TracerProvider(resource=Resource.create({"service.name": sys.argv[0]}))
 
     remote_write_exporter = (
         LangTraceExporter(api_key=api_key, api_host=api_host)

langtrace_python_sdk-2.0.9/src/langtrace_python_sdk/utils/__init__.py

@@ -0,0 +1,7 @@
+def set_span_attribute(span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+

{langtrace_python_sdk-2.0.7 → langtrace_python_sdk-2.0.9}/src/langtrace_python_sdk/utils/llm.py

@@ -58,3 +58,11 @@ def calculate_price_from_usage(model, usage):
             + cost_table["output"] * usage["completion_tokens"]
         ) / 1000
     return 0
+
+
+def set_span_attributes(span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+

langtrace_python_sdk-2.0.9/src/langtrace_python_sdk/utils/prompt_registry.py

@@ -0,0 +1,82 @@
+import os
+from langtrace_python_sdk.constants.exporter.langtrace_exporter import (
+    LANGTRACE_REMOTE_URL,
+)
+import requests
+from urllib.parse import urlencode
+from typing import Optional, TypedDict, Dict, List
+
+
+class LangtracePrompt(TypedDict):
+    id: str
+    value: str
+    variables: List[str]
+    model: str
+    modelSettings: Dict[str, object]
+    version: int
+    live: bool
+    tags: List[str]
+    note: str
+    promptsetId: str
+    createdAt: str
+    updatedAt: str
+
+
+class FetchOptions(TypedDict, total=False):
+    prompt_version: int
+    variables: Dict[str, str]
+
+
+def get_prompt_from_registry(
+    prompt_registry_id: str,
+    options: Optional[FetchOptions] = None,
+) -> LangtracePrompt:
+    """Fetches a prompt from the registry.
+
+    Args:
+        prompt_registry_id (str): The ID of the prompt registry.
+        options (dict, optional): Configuration options for fetching the prompt:
+            - prompt_version (int): Fetches the prompt with the specified version.
+            - variables (dict): Replaces variables in the prompt with provided values.
+
+    Returns:
+        dict: The fetched prompt with variables replaced as specified.
+
+    Raises:
+        Exception: If the fetch operation fails or returns an error.
+    """
+    try:
+        query_params = {"promptset_id": prompt_registry_id}
+        if options:
+            if "prompt_version" in options:
+                query_params["version"] = options["prompt_version"]
+            if "variables" in options:
+                for key, value in options["variables"].items():
+                    query_params[f"variables.{key}"] = value
+        # Encode the query parameters
+        query_string = urlencode(query_params, doseq=True)
+        headers = {"x-api-key": os.environ["LANGTRACE_API_KEY"]}
+        print(query_params)
+        # Make the GET request to the API
+        response = requests.get(
+            f"{LANGTRACE_REMOTE_URL}/api/promptset?{query_string}",
+            headers=headers,
+            timeout=None,
+        )
+        response.raise_for_status()
+
+        # Extract the prompt data from the response
+        prompt_data = response.json()["prompts"][0]
+        return prompt_data
+
+    except requests.RequestException as err:
+        # Handle specific HTTP errors or general request exceptions
+        error_msg = str(err)
+        if err.response:
+            try:
+                # Try to extract server-provided error message
+                error_msg = err.response.json().get("error", error_msg)
+            except ValueError:
+                # Fallback if response is not JSON
+                error_msg = err.response.text
+        raise Exception(f"API error: {error_msg}") from err

langtrace_python_sdk-2.0.9/src/langtrace_python_sdk/utils/silently_fail.py

@@ -0,0 +1,19 @@
+import logging
+
+
+def silently_fail(func):
+    """
+    A decorator that catches exceptions thrown by the decorated function and logs them as warnings.
+    """
+
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as exception:
+            logger.warning(
+                "Failed to execute %s, error: %s", func.__name__, str(exception)
+            )
+
+    return wrapper

langtrace_python_sdk-2.0.9/src/langtrace_python_sdk/version.py

@@ -0,0 +1 @@
+__version__ = "2.0.9"

langtrace_python_sdk-2.0.9/src/tests/chroma/conftest.py

@@ -0,0 +1,15 @@
+import chromadb
+import pytest
+from langtrace_python_sdk.instrumentation.chroma.instrumentation import (
+    ChromaInstrumentation,
+)
+
+
+@pytest.fixture
+def chroma_client():
+    return chromadb.Client()
+
+
+@pytest.fixture(scope="session", autouse=True)
+def instrument():
+    ChromaInstrumentation().instrument()

langtrace_python_sdk-2.0.9/src/tests/chroma/test_chroma.py

@@ -0,0 +1,31 @@
+import importlib
+from chromadb.utils import embedding_functions
+from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
+
+COLLECTION_NAME = "test_collection"
+
+
+def test_chroma_add(chroma_client, exporter):
+    embedder = embedding_functions.DefaultEmbeddingFunction()
+    collection = chroma_client.create_collection(
+        name=COLLECTION_NAME, embedding_function=embedder
+    )
+    collection.add(
+        documents=["This is a document", "This is another document"],
+        metadatas=[{"source": "my_source"}, {"source": "my_source"}],
+        ids=["id1", "id2"],
+    )
+    spans = exporter.get_finished_spans()
+    chroma_span = spans[-1]
+
+    attributes = chroma_span.attributes
+
+    assert attributes.get("db.collection.name") == COLLECTION_NAME
+    assert attributes.get("db.operation") == "add"
+    assert attributes.get("db.system") == "chromadb"
+    assert attributes.get("langtrace.sdk.name") == "langtrace-python-sdk"
+    assert attributes.get("langtrace.service.name") == SERVICE_PROVIDERS["CHROMA"]
+    assert attributes.get("langtrace.service.type") == "vectordb"
+    assert attributes.get("langtrace.service.version") == importlib.metadata.version(
+        "chromadb"
+    )