langtrace-python-sdk 2.1.16__py3-none-any.whl → 2.1.19__py3-none-any.whl

examples/inspect_ai_example/basic_eval.py

@@ -0,0 +1,24 @@
+# langtrace.init(write_spans_to_console=True)
+import fsspec
+from inspect_ai import Task, task
+from inspect_ai.dataset import csv_dataset
+from inspect_ai.scorer import model_graded_qa
+from inspect_ai.solver import chain_of_thought, generate, self_critique
+
+from langtrace_python_sdk.extensions.langtrace_filesystem import LangTraceFileSystem
+
+# from langtrace_python_sdk import langtrace
+
+
+# Manually register the filesystem with fsspec
+# Note: This is only necessary because the filesystem is not registered.
+fsspec.register_implementation(LangTraceFileSystem.protocol, LangTraceFileSystem)
+
+
+@task
+def security_guide():
+    return Task(
+        dataset=csv_dataset("langtracefs://clxc2mxu6000lpc7ntsvcjvp9"),
+        plan=[chain_of_thought(), self_critique()],
+        scorer=model_graded_qa(),
+    )

examples/langchain_example/basic.py

@@ -8,14 +8,15 @@ from langchain_core.runnables import RunnablePassthrough
 from langchain_openai import ChatOpenAI, OpenAIEmbeddings
 
 from langtrace_python_sdk import langtrace
-from langtrace_python_sdk.utils.with_root_span import (
-    with_langtrace_root_span,
-    with_additional_attributes,
-)
+from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+from openai import OpenAI
 
 _ = load_dotenv(find_dotenv())
 
-langtrace.init()
+langtrace.init(
+    write_spans_to_console=False,
+    disable_tracing_for_functions={"langchain": ["RunnableSequence.invoke"]},
+)
 
 
 def api_call_1():
@@ -29,7 +30,8 @@ def api_call_1():
     output_parser = StrOutputParser()
     chain = prompt | llm | output_parser
     res = chain.invoke({"input": "how can langsmith help with testing?"})
-    print(res)
+    # print(res)
+    return res
 
 
 def api_call_2():
@@ -43,13 +45,26 @@ def api_call_2():
     output_parser = StrOutputParser()
     chain = prompt | llm | output_parser
     res = chain.invoke({"input": "how can langsmith help with testing?"})
-    print(res)
+    # print(res)
+    return res
 
 
 @with_langtrace_root_span()
 def basic_app():
     api_call_1()
-    api_call_2()
+    # api_call_2()
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[
+            {"role": "system", "content": "Talk like a pirate"},
+            {"role": "user", "content": "Tell me a story in 3 sentences or less."},
+        ],
+        # stream=True,
+        stream=False,
+    )
+
+    return response
 
 
 @with_langtrace_root_span()

examples/llamaindex_example/agent.py

@@ -12,7 +12,7 @@ import nest_asyncio
 
 nest_asyncio.apply()
 
-langtrace.init(write_spans_to_console=False)
+langtrace.init()
 
 
 def multiply(a: int, b: int) -> int:

examples/llamaindex_example/basic.py

@@ -7,7 +7,11 @@ from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
 _ = load_dotenv(find_dotenv())
 
 
-langtrace.init(write_spans_to_console=False)
+langtrace.init(
+    disable_tracing_for_functions={
+        "open_ai": ["openai.chat.completions.create"],
+    }
+)
 
 
 @with_langtrace_root_span()

examples/ollama_example/__init__.py

@@ -0,0 +1,14 @@
+from .basic import chat, async_chat, async_generate, generate, embed, async_embed
+from langtrace_python_sdk import with_langtrace_root_span
+import asyncio
+
+
+class OllamaRunner:
+    @with_langtrace_root_span("OllamaRunner")
+    def run(self):
+        chat()
+        generate()
+        embed()
+        asyncio.run(async_chat())
+        asyncio.run(async_generate())
+        asyncio.run(async_embed())

examples/ollama_example/basic.py

@@ -0,0 +1,50 @@
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+import ollama
+from ollama import AsyncClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+langtrace.init(write_spans_to_console=False)
+
+
+def chat():
+    response = ollama.chat(
+        model="llama3",
+        messages=[
+            {
+                "role": "user",
+                "content": "hi",
+            },
+        ],
+        stream=True,
+    )
+
+    return response
+
+
+async def async_chat():
+    message = {"role": "user", "content": "Why is the sky blue?"}
+    return await AsyncClient().chat(model="llama3", messages=[message])
+
+
+def generate():
+    return ollama.generate(model="llama3", prompt="Why is the sky blue?")
+
+
+def async_generate():
+    return AsyncClient().generate(model="llama3", prompt="Why is the sky blue?")
+
+
+def embed():
+    return ollama.embeddings(
+        model="llama3",
+        prompt="cat",
+    )
+
+
+async def async_embed():
+    return await AsyncClient().embeddings(
+        model="llama3",
+        prompt="cat",
+    )

examples/openai_example/chat_completion.py

@@ -40,5 +40,5 @@ def chat_completion():
             ]
             result.append(content[0] if len(content) > 0 else "")
 
-    print("".join(result))
+    # print("".join(result))
     return response

examples/pinecone_example/basic.py

@@ -13,6 +13,7 @@ from langtrace_python_sdk import (
     with_additional_attributes,
 )
 from langtrace_python_sdk.utils.with_root_span import SendUserFeedback
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter
 
 _ = load_dotenv(find_dotenv())
 langtrace.init()

langtrace_python_sdk/__init__.py

@@ -15,15 +15,13 @@ limitations under the License.
 """
 
 from langtrace_python_sdk import langtrace
-from langtrace_python_sdk.utils.with_root_span import (
-    with_langtrace_root_span,
-    with_additional_attributes,
-)
-
+from langtrace_python_sdk.extensions.langtrace_filesystem import LangTraceFileSystem
 from langtrace_python_sdk.utils.prompt_registry import get_prompt_from_registry
 from langtrace_python_sdk.utils.with_root_span import (
     SendUserFeedback,
     inject_additional_attributes,
+    with_additional_attributes,
+    with_langtrace_root_span,
 )
 
 __all__ = [
@@ -33,4 +31,5 @@ __all__ = [
     "inject_additional_attributes",
     "get_prompt_from_registry",
     "SendUserFeedback",
+    "LangTraceFileSystem",
 ]

langtrace_python_sdk/constants/instrumentation/common.py

@@ -23,6 +23,7 @@ SERVICE_PROVIDERS = {
     "PPLX": "Perplexity",
     "QDRANT": "Qdrant",
     "WEAVIATE": "Weaviate",
+    "OLLAMA": "Ollama",
 }
 
 LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY = "langtrace_additional_attributes"

langtrace_python_sdk/constants/instrumentation/ollama.py

@@ -0,0 +1,7 @@
+APIS = {
+    "GENERATE": {
+        "METHOD": "generate",
+    },
+    "CHAT": {"METHOD": "chat"},
+    "EMBEDDINGS": {"METHOD": "embeddings"},
+}

langtrace_python_sdk/constants/instrumentation/pinecone.py

@@ -12,7 +12,7 @@ APIS = {
         "OPERATION": "query",
     },
     "DELETE": {
-        "METHOD": PineconeMethods.DELETE,
+        "METHOD": PineconeMethods.DELETE.value,
         "ENDPOINT": "/vectors/delete",
         "OPERATION": "delete",
     },

langtrace_python_sdk/extensions/langtrace_filesystem.py

@@ -0,0 +1,194 @@
+import json
+import io
+import os
+import requests
+from typing import Iterator, Literal, Union
+from colorama import Fore
+from langtrace_python_sdk.constants.exporter.langtrace_exporter import (
+    LANGTRACE_REMOTE_URL,
+)
+from fsspec.spec import AbstractFileSystem
+
+OpenTextMode = Literal["r", "a", "w"]
+OpenBinaryMode = Literal["rb", "ab", "wb"]
+
+
+class OpenMode(str):
+    def __init_subclass__(cls, **kwargs):
+        allowed_values = Union[set(OpenTextMode.__args__), set(OpenBinaryMode.__args__)]
+        super().__init_subclass__(**kwargs)
+
+        def __new__(cls, value):
+            if value not in allowed_values:
+                raise ValueError(f"Invalid value for OpenMode: {value}")
+            return super().__new__(cls, value)
+
+        cls.__new__ = __new__
+
+
+class LangTraceFile(io.BytesIO):
+    def __init__(self, fs: "LangTraceFileSystem", path: str, mode: OpenMode):
+        super().__init__()
+        self.fs = fs
+        self.path = path
+        self.mode = mode
+
+    def close(self) -> None:
+        if not self.closed:
+            self.seek(0)
+            file_data = self.getvalue()
+            self.fs.files[self.path] = file_data
+
+            # Upload the file to the remote server
+            self.upload_to_server(file_data)
+
+        super().close()
+
+    def upload_to_server(self, file_data: bytes) -> None:
+        try:
+            # Parse the log file and upload it to the server
+            log = file_data.decode("utf-8")
+            eval_log = json.loads(log)
+            data = {
+                "runId": eval_log["eval"]["run_id"],
+                "taskId": eval_log["eval"]["task_id"],
+                "log": log,
+            }
+            if self.path is not None:
+                dataset_id = self.path.split("/")[0]
+                print(
+                    Fore.GREEN
+                    + f"Sending results to Langtrace for dataset: {dataset_id}"
+                    + Fore.RESET
+                )
+                data["datasetId"] = dataset_id
+            else:
+                print(Fore.GREEN + "Sending results to Langtrace" + Fore.RESET)
+            response = requests.post(
+                url=f"{LANGTRACE_REMOTE_URL}/api/run",
+                data=json.dumps(data),
+                headers={
+                    "Content-Type": "application/json",
+                    "x-api-key": os.environ.get("LANGTRACE_API_KEY"),
+                },
+                timeout=20,
+            )
+            response.raise_for_status()
+            print(Fore.GREEN + "Results sent to Langtrace successfully." + Fore.RESET)
+        except requests.exceptions.RequestException as error:
+            print(Fore.RED + f"Error reporting results: {error}" + Fore.RESET)
+
+
+class LangTraceFileSystem(AbstractFileSystem):
+    protocol = "langtracefs"
+    sep = "/"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.files = {}
+        self.dirs = set()
+
+    def open(
+        self,
+        path: str,
+        mode: Union[OpenTextMode, OpenBinaryMode] = "rb",
+        **kwargs,
+    ) -> Iterator[Union[LangTraceFile, io.BytesIO]]:
+        if "r" in mode:
+            dataset_id = path
+            # Fetch file from API and return a BytesIO object
+            file_data = self.fetch_file_from_api(dataset_id)
+            return io.BytesIO(file_data)
+        elif "w" in mode or "a" in mode:
+            return LangTraceFile(self, path, mode)
+        else:
+            raise ValueError(f"Unsupported mode: {mode}")
+
+    def fetch_file_from_api(self, dataset_id: str) -> bytes:
+        try:
+            print(
+                Fore.GREEN
+                + f"Fetching dataset with id: {dataset_id} from Langtrace"
+                + Fore.RESET
+            )
+            response = requests.get(
+                url=f"{LANGTRACE_REMOTE_URL}/api/dataset/download?id={dataset_id}",
+                headers={
+                    "Content-Type": "application/json",
+                    "x-api-key": os.environ.get("LANGTRACE_API_KEY"),
+                },
+                timeout=20,
+            )
+            print(
+                Fore.GREEN
+                + f"Successfully fetched dataset with id: {dataset_id} from Langtrace"
+                + Fore.RESET
+            )
+            response.raise_for_status()
+            file_data = response.content
+            return file_data
+        except requests.exceptions.RequestException as error:
+            print(
+                Fore.RED
+                + f"Error fetching dataset with id: {dataset_id} from Langtrace: {error}"
+                + Fore.RESET
+            )
+            return b""
+
+    def makedirs(self, path: str, exist_ok: bool = False) -> None:
+        if not exist_ok and path in self.dirs:
+            raise FileExistsError(f"Directory {path} already exists")
+        self.dirs.add(path)
+
+    def info(self, path: str, **kwargs):
+        if path in self.files:
+            return {"name": path, "size": len(self.files[path]), "type": "file"}
+        elif path in self.dirs:
+            return {"name": path, "type": "directory"}
+        else:
+            raise FileNotFoundError(f"No such file or directory: {path}")
+
+    def created(self, path: str) -> float:
+        # Return a dummy creation time
+        return 0.0
+
+    def exists(self, path: str) -> bool:
+        return path in self.files or path in self.dirs
+
+    def ls(self, path: str, detail: bool = False, **kwargs):
+        if path not in self.dirs:
+            raise FileNotFoundError(f"No such directory: {path}")
+        entries = []
+        for file_path in self.files:
+            if file_path.startswith(path + self.sep):
+                if detail:
+                    entries.append(self.info(file_path))
+                else:
+                    entries.append(file_path)
+        for dir_path in self.dirs:
+            if dir_path.startswith(path + self.sep):
+                if detail:
+                    entries.append(self.info(dir_path))
+                else:
+                    entries.append(dir_path)
+        return entries
+
+    def walk(self, path: str, maxdepth: int = None, **kwargs):
+        for root, dirs, files in self._walk(path):
+            yield root, dirs, [self.sep.join([root, f]) for f in files]
+
+    def _walk(self, path: str):
+        if path in self.dirs:
+            dirs = [d for d in self.dirs if d.startswith(path + self.sep)]
+            files = [f for f in self.files if f.startswith(path + self.sep)]
+            yield path, [d.split(self.sep)[-1] for d in dirs], [
+                f.split(self.sep)[-1] for f in files
+            ]
+            for d in dirs:
+                yield from self._walk(d)
+
+    def unstrip_protocol(self, path: str) -> str:
+        return path
+
+    def invalidate_cache(self, path: str = None) -> None:
+        pass

langtrace_python_sdk/instrumentation/__init__.py

@@ -11,6 +11,7 @@ from .openai import OpenAIInstrumentation
 from .pinecone import PineconeInstrumentation
 from .qdrant import QdrantInstrumentation
 from .weaviate import WeaviateInstrumentation
+from .ollama import OllamaInstrumentor
 
 __all__ = [
     "AnthropicInstrumentation",
@@ -26,4 +27,5 @@ __all__ = [
     "PineconeInstrumentation",
     "QdrantInstrumentation",
     "WeaviateInstrumentation",
+    "OllamaInstrumentor",
 ]

langtrace_python_sdk/instrumentation/chroma/patch.py

@@ -17,10 +17,10 @@ limitations under the License.
 from langtrace.trace_attributes import DatabaseSpanAttributes
 from langtrace_python_sdk.utils.llm import set_span_attributes
 from langtrace_python_sdk.utils.silently_fail import silently_fail
-from opentelemetry import baggage
+from opentelemetry import baggage, trace
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
-
+from opentelemetry.trace.propagation import set_span_in_context
 from langtrace_python_sdk.constants.instrumentation.chroma import APIS
 from langtrace_python_sdk.constants.instrumentation.common import (
     LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
@@ -59,7 +59,11 @@ def collection_patch(method, version, tracer):
 
         attributes = DatabaseSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(api["METHOD"], kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            api["METHOD"],
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

langtrace_python_sdk/instrumentation/groq/patch.py

@@ -17,7 +17,8 @@ limitations under the License.
 import json
 
 from langtrace.trace_attributes import Event, LLMSpanAttributes
-from opentelemetry import baggage
+from opentelemetry import baggage, trace
+from opentelemetry.trace.propagation import set_span_in_context
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
@@ -112,7 +113,9 @@ def chat_completions_create(original_method, version, tracer):
         # with tracer.start_as_current_span(APIS["CHAT_COMPLETION"]["METHOD"],
         #                                   kind=SpanKind.CLIENT) as span:
         span = tracer.start_span(
-            APIS["CHAT_COMPLETION"]["METHOD"], kind=SpanKind.CLIENT
+            APIS["CHAT_COMPLETION"]["METHOD"],
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
         )
         for field, value in attributes.model_dump(by_alias=True).items():
             if value is not None:

langtrace_python_sdk/instrumentation/langchain/patch.py

@@ -17,7 +17,9 @@ limitations under the License.
 import json
 
 from langtrace.trace_attributes import FrameworkSpanAttributes
-from opentelemetry import baggage
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from opentelemetry import baggage, trace
+from opentelemetry.trace.propagation import set_span_in_context
 from opentelemetry.trace import SpanKind, StatusCode
 from opentelemetry.trace.status import Status
 
@@ -54,7 +56,11 @@ def generic_patch(
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(method_name, kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            method_name,
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

langtrace_python_sdk/instrumentation/langchain_community/patch.py

@@ -17,7 +17,9 @@ limitations under the License.
 import json
 
 from langtrace.trace_attributes import FrameworkSpanAttributes
-from opentelemetry import baggage
+from opentelemetry import baggage, trace
+from opentelemetry.trace.propagation import set_span_in_context
+
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
@@ -52,7 +54,11 @@ def generic_patch(
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(method_name, kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            method_name,
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

langtrace_python_sdk/instrumentation/langchain_core/patch.py

@@ -17,9 +17,10 @@ limitations under the License.
 import json
 
 from langtrace.trace_attributes import FrameworkSpanAttributes
-from opentelemetry import baggage
+from opentelemetry import baggage, trace
 from opentelemetry.trace import SpanKind, StatusCode
 from opentelemetry.trace.status import Status
+from opentelemetry.trace.propagation import set_span_in_context
 
 from langtrace_python_sdk.constants.instrumentation.common import (
     LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
@@ -73,7 +74,12 @@ def generic_patch(
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(method_name, kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            method_name,
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
+
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)
@@ -147,7 +153,11 @@ def runnable_patch(
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(method_name, kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            method_name,
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

langtrace_python_sdk/instrumentation/langgraph/patch.py

@@ -15,9 +15,10 @@ limitations under the License.
 """
 
 import json
+from opentelemetry.trace.propagation import set_span_in_context
 
 from langtrace.trace_attributes import FrameworkSpanAttributes
-from opentelemetry import baggage
+from opentelemetry import baggage, trace
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
@@ -50,7 +51,11 @@ def patch_graph_methods(method_name, tracer, version):
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(method_name, kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            method_name,
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

langtrace_python_sdk/instrumentation/llamaindex/patch.py

@@ -15,10 +15,10 @@ limitations under the License.
 """
 
 from langtrace.trace_attributes import FrameworkSpanAttributes
-from opentelemetry import baggage
+from opentelemetry import baggage, trace
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
-
+from opentelemetry.trace.propagation import set_span_in_context
 from langtrace_python_sdk.constants.instrumentation.common import (
     LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
     SERVICE_PROVIDERS,
@@ -48,7 +48,11 @@ def generic_patch(method, task, tracer, version):
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(method, kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            method,
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

langtrace_python_sdk/instrumentation/ollama/__init__.py

@@ -0,0 +1,3 @@
+from .instrumentation import OllamaInstrumentor
+
+__all__ = ["OllamaInstrumentor"]