langtrace-python-sdk 1.0.9__py3-none-any.whl → 1.0.11__py3-none-any.whl

examples/chroma_example/basic.py

@@ -0,0 +1,27 @@
+import chromadb
+from chromadb.utils import embedding_functions
+from dotenv import find_dotenv, load_dotenv
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+
+@with_langtrace_root_span()
+def basic():
+    chroma_client = chromadb.Client()
+    embedder = embedding_functions.DefaultEmbeddingFunction()
+    collection = chroma_client.create_collection(
+        name="my6_collection", embedding_function=embedder)
+    collection.add(
+        documents=["This is a document", "This is another document"],
+        metadatas=[{"source": "my_source"}, {"source": "my_source"}],
+        ids=["id1", "id2"]
+    )
+    results = collection.query(
+        query_texts=["This is a query document"],
+        n_results=2
+    )

examples/langchain_example/basic.py

@@ -0,0 +1,65 @@
+from dotenv import find_dotenv, load_dotenv
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.vectorstores.faiss import FAISS
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts.chat import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+
+@with_langtrace_root_span()
+def basic():
+    llm = ChatOpenAI()
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are world class technical documentation writer."),
+        ("user", "{input}")
+    ])
+    output_parser = StrOutputParser()
+    chain = prompt | llm | output_parser
+    res = chain.invoke({"input": "how can langsmith help with testing?"})
+    print(res)
+
+
+@with_langtrace_root_span()
+def rag():
+    vectorstore = FAISS.from_texts(
+        ["harrison worked at kensho"], embedding=OpenAIEmbeddings()
+    )
+    retriever = vectorstore.as_retriever()
+
+    template = """Answer the question based only on the following context:{context}
+
+        Question: {question}
+    """
+    prompt = ChatPromptTemplate.from_template(template)
+
+    model = ChatOpenAI()
+
+    chain = (
+        {"context": retriever, "question": RunnablePassthrough()}
+        | prompt
+        | model
+        | StrOutputParser()
+    )
+
+    res = chain.invoke("where did harrison work?")
+    # print(res)
+
+
+@with_langtrace_root_span()
+def load_and_split():
+    url = 'https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf'
+    loader = PyPDFLoader(url)
+    data = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500, chunk_overlap=0)
+    docs = text_splitter.split_documents(data)
+    # print(docs)

examples/langchain_example/tool.py

@@ -0,0 +1,85 @@
+from dotenv import find_dotenv, load_dotenv
+from langchain import hub
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain.chains import LLMMathChain
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.tools import Tool
+from langchain_openai import ChatOpenAI
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+
+llm = ChatOpenAI(temperature=0, model="gpt-4")
+llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
+
+primes = {998: 7901, 999: 7907, 1000: 7919}
+
+
+class CalculatorInput(BaseModel):
+    question: str = Field()
+
+
+class PrimeInput(BaseModel):
+    n: int = Field()
+
+
+def is_prime(n: int) -> bool:
+    if n <= 1 or (n % 2 == 0 and n > 2):
+        return False
+    for i in range(3, int(n**0.5) + 1, 2):
+        if n % i == 0:
+            return False
+    return True
+
+
+def get_prime(n: int, primes: dict = primes) -> str:
+    return str(primes.get(int(n)))
+
+
+async def aget_prime(n: int, primes: dict = primes) -> str:
+    return str(primes.get(int(n)))
+
+
+@with_langtrace_root_span()
+def tool_example():
+
+    tools = [
+        Tool(
+            name="GetPrime",
+            func=get_prime,
+            description="A tool that returns the `n`th prime number",
+            args_schema=PrimeInput,
+            coroutine=aget_prime,
+        ),
+        Tool.from_function(
+            func=llm_math_chain.run,
+            name="Calculator",
+            description="Useful for when you need to compute mathematical expressions",
+            args_schema=CalculatorInput,
+            coroutine=llm_math_chain.arun,
+        ),
+    ]
+
+    prompt = hub.pull("hwchase17/openai-functions-agent")
+
+    agent = create_openai_functions_agent(llm, tools, prompt)
+
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+    question = "What is the product of the 998th, 999th and 1000th prime numbers?"
+
+    for step in agent_executor.iter({"input": question}):
+        if output := step.get("intermediate_step"):
+            action, value = output[0]
+            if action.tool == "GetPrime":
+                print(f"Checking whether {value} is prime...")
+                assert is_prime(int(value))
+            # Ask user if they want to continue
+            _continue = input("Should the agent continue (Y/n)?:\n") or "Y"
+            if _continue.lower() != "y":
+                break

examples/llamaindex_example/basic.py

@@ -0,0 +1,19 @@
+from dotenv import find_dotenv, load_dotenv
+from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+
+@with_langtrace_root_span()
+def basic():
+    documents = SimpleDirectoryReader(
+        "src/examples/llamaindex_example/data").load_data()
+    index = VectorStoreIndex.from_documents(documents)
+    query_engine = index.as_query_engine()
+    response = query_engine.query("What did the author do in college?")
+    print(response)

examples/openai/chat_completion.py

@@ -0,0 +1,39 @@
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+client = OpenAI()
+
+
+@with_langtrace_root_span()
+def chat_completion():
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Say this is a test three times"}],
+        stream=True,
+    )
+    # print(stream)
+    # stream = client.chat.completions.create(
+    #     model="gpt-4",
+    #     messages=[{"role": "user", "content": "Say this is a test three times"}, {"role": "assistant", "content": "This is a test. This is a test. This is a test"},
+    #               {"role": "user", "content": "Say this is a mock 4 times"}],
+    #     stream=False,
+    # )
+
+    result = []
+    for chunk in response:
+        if chunk.choices[0].delta.function_call is not None:
+            content = [
+                choice.delta.function_call.arguments if choice.delta.function_call and
+                choice.delta.function_call.arguments else ""
+                for choice in chunk.choices]
+            result.append(
+                content[0] if len(content) > 0 else "")
+
+    print("".join(result))

examples/openai/embeddings_create.py

@@ -0,0 +1,19 @@
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+client = OpenAI()
+
+
+@with_langtrace_root_span()
+def embeddings_create():
+    result = client.embeddings.create(
+        model="text-embedding-ada-002",
+        input="Once upon a time, there was a frog.",
+    )

examples/openai/function_calling.py

@@ -0,0 +1,75 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+client = OpenAI()
+
+
+student_custom_functions = [
+    {
+        'name': 'extract_student_info',
+        'description': 'Get the student information from the body of the input text',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'name': {
+                    'type': 'string',
+                    'description': 'Name of the person'
+                },
+                'major': {
+                    'type': 'string',
+                    'description': 'Major subject.'
+                },
+                'school': {
+                    'type': 'string',
+                    'description': 'The university name.'
+                },
+                'grades': {
+                    'type': 'integer',
+                    'description': 'GPA of the student.'
+                },
+                'club': {
+                    'type': 'string',
+                    'description': 'School club for extracurricular activities. '
+                }
+
+            }
+        }
+    }
+]
+
+
+@with_langtrace_root_span()
+def function_calling():
+    response = client.chat.completions.create(
+        model='gpt-3.5-turbo',
+        messages=[{'role': 'user', 'content': "David Nguyen is a sophomore majoring in computer science at Stanford University. He is Asian American and has a 3.8 GPA. David is known for his programming skills and is an active member of the university's Robotics Club. He hopes to pursue a career in artificial intelligence after graduating."}],
+        functions=student_custom_functions,
+        function_call='auto',
+        stream=False
+    )
+
+    # result = []
+    # for chunk in response:
+    #     if chunk.choices[0].delta.function_call is not None:
+    #         content = [
+    #             choice.delta.function_call.arguments if choice.delta.function_call and
+    #             choice.delta.function_call.arguments else ""
+    #             for choice in chunk.choices]
+    #         result.append(
+    #             content[0] if len(content) > 0 else "")
+
+    # print("".join(result))
+
+    # Loading the response as a JSON object
+    json_response = json.loads(
+        response.choices[0].message.function_call.arguments)
+    print(json_response)

examples/openai/images_generate.py

@@ -0,0 +1,20 @@
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+client = OpenAI()
+
+
+@with_langtrace_root_span()
+def images_generate():
+    result = client.images.generate(
+        model="dall-e-3",
+        prompt="A cute baby sea otter",
+    )
+    print(result)

examples/pinecone_example/basic.py

@@ -0,0 +1,32 @@
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+from pinecone import Pinecone
+
+from examples.setup import setup_instrumentation
+from instrumentation.with_root_span import with_langtrace_root_span
+
+_ = load_dotenv(find_dotenv())
+
+setup_instrumentation()
+
+client = OpenAI()
+pinecone = Pinecone()
+
+
+@with_langtrace_root_span()
+def basic():
+    result = client.embeddings.create(
+        model="text-embedding-ada-002",
+        input="Some random text string goes here",
+        encoding_format="float"
+    )
+
+    embedding = result.data[0].embedding
+
+    unique_id = "randomid"
+    data_to_upsert = {"id": unique_id, "values": embedding}
+
+    index = pinecone.Index("test-index")
+    index.upsert(vectors=[data_to_upsert])
+
+    resp = index.query(vector=embedding, top_k=1)

instrumentation/chroma/instrumentation.py

@@ -1,3 +1,6 @@
+"""
+Instrumentation for ChromaDB
+"""
 import importlib.metadata
 from typing import Collection
 
@@ -5,11 +8,14 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 
-from instrumentation.chroma.lib.apis import APIS
+from instrumentation.chroma.apis import APIS
 from instrumentation.chroma.patch import collection_patch
 
 
 class ChromaInstrumentation(BaseInstrumentor):
+    """
+    The ChromaInstrumentation class represents the ChromaDB instrumentation
+    """
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return ["chromadb >= 0.4.23"]
@@ -19,7 +25,7 @@ class ChromaInstrumentation(BaseInstrumentor):
         tracer = get_tracer(__name__, "", tracer_provider)
         version = importlib.metadata.version('chromadb')
 
-        for operation, details in APIS.items():
+        for operation, _ in APIS.items():
             wrap_function_wrapper(
                 'chromadb.api.models.Collection',
                 f'Collection.{operation.lower()}',
@@ -27,7 +33,7 @@ class ChromaInstrumentation(BaseInstrumentor):
             )
 
     def _instrument_module(self, module_name):
-        print(module_name)
+        pass
 
     def _uninstrument(self, **kwargs):
-        print(kwargs)
+        pass

instrumentation/chroma/patch.py

@@ -1,12 +1,18 @@
+"""
+This module contains the patching logic for the Chroma client.
+"""
 from langtrace.trace_attributes import DatabaseSpanAttributes
-from opentelemetry.trace import SpanKind, StatusCode
+from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
+from instrumentation.chroma.apis import APIS
 from instrumentation.constants import SERVICE_PROVIDERS
-from instrumentation.chroma.lib.apis import APIS
 
 
 def collection_patch(method, version, tracer):
+    """
+    A generic patch method that wraps a function with a span
+    """
     def traced_method(wrapped, instance, args, kwargs):
         api = APIS[method]
         service_provider = SERVICE_PROVIDERS['CHROMA']

instrumentation/constants.py

@@ -1,16 +1,11 @@
-
-TRACE_NAMESPACES = {
-    "OPENAI": "Langtrace OpenAI SDK",
-    "LANGCHAIN": "Langtrace Langchain SDK",
-    "PINECONE": "Langtrace Pinecone SDK",
-    "LLAMAINDEX": "Langtrace LlamaIndex SDK",
-    "CHROMA": "Langtrace Chroma SDK",
-}
-
+"""
+This file contains the constants used in the project.
+"""
 SERVICE_PROVIDERS = {
     "OPENAI": "OpenAI",
     "AZURE": "Azure",
     "LANGCHAIN": "Langchain",
+    "LANGCHAIN_CORE": "Langchain Core",
     "LANGCHAIN_COMMUNITY": "Langchain Community",
     "PINECONE": "Pinecone",
     "LLAMAINDEX": "LlamaIndex",

instrumentation/langchain_core/instrumentation.py

@@ -71,15 +71,21 @@ class LangchainCoreInstrumentation(BaseInstrumentor):
         version = importlib.metadata.version('langchain-core')
 
         exclude_methods = ['get_name', 'get_output_schema',
-                           'get_input_schema', 'get_graph', 'to_json']
-        exclude_classes = ['BaseChatPromptTemplate']
+                           'get_input_schema', 'get_graph', 'to_json',
+                           'to_json_not_implemented', 'bind',  'dict',
+                           'format', 'format_messages', 'format_prompt']
+        exclude_classes = ['BaseChatPromptTemplate', 'Runnable', 'RunnableBinding',
+                           'RunnableBindingBase', 'RunnableEach', 'RunnableEachBase',
+                           'RunnableGenerator', 'RunnablePick', 'RunnableMap',
+                           'RunnableSerializable']
+
         modules_to_patch = [
             ('langchain_core.retrievers', 'retriever',
              generic_patch, True, True),
-            ('langchain_core.prompts.chat', 'chatprompt',
-             generic_patch, True, False),
+            ('langchain_core.prompts.chat', 'prompt',
+             generic_patch, True, True),
             ('langchain_core.runnables.base',
-             'runnableparallel', runnable_patch, True, True),
+             'runnable', runnable_patch, True, True),
             ('langchain_core.runnables.passthrough',
              'runnablepassthrough', runnable_patch, True, True),
             ('langchain_core.output_parsers.string',

instrumentation/langchain_core/patch.py

@@ -22,7 +22,7 @@ def generic_patch(method_name, task, tracer, version, trace_output=True, trace_i
     """
 
     def traced_method(wrapped, instance, args, kwargs):
-        service_provider = SERVICE_PROVIDERS['LANGCHAIN']
+        service_provider = SERVICE_PROVIDERS['LANGCHAIN_CORE']
         span_attributes = {
             'langtrace.service.name': service_provider,
             'langtrace.service.type': 'framework',
@@ -32,7 +32,18 @@ def generic_patch(method_name, task, tracer, version, trace_output=True, trace_i
         }
 
         if len(args) > 0 and trace_input:
-            span_attributes['langchain.inputs'] = to_json_string(args)
+            inputs = {}
+            for arg in args:
+                if isinstance(arg, dict):
+                    for key, value in arg.items():
+                        if isinstance(value, list):
+                            for item in value:
+                                inputs[key] = item.__class__.__name__
+                        elif isinstance(value, str):
+                            inputs[key] = value
+                elif isinstance(arg, str):
+                    inputs['input'] = arg
+            span_attributes['langchain.inputs'] = to_json_string(inputs)
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 
@@ -73,7 +84,7 @@ def runnable_patch(method_name, task, tracer, version, trace_output=True, trace_
     trace_input: Whether to trace the input of the patched methods.
     """
     def traced_method(wrapped, instance, args, kwargs):
-        service_provider = SERVICE_PROVIDERS['LANGCHAIN']
+        service_provider = SERVICE_PROVIDERS['LANGCHAIN_CORE']
         span_attributes = {
             'langtrace.service.name': service_provider,
             'langtrace.service.type': 'framework',
@@ -84,12 +95,17 @@ def runnable_patch(method_name, task, tracer, version, trace_output=True, trace_
 
         if trace_input:
             inputs = {}
-            args_list = []
             if len(args) > 0:
-                for value in args:
-                    if isinstance(value, str):
-                        args_list.append(value)
-            inputs['args'] = args_list
+                for arg in args:
+                    if isinstance(arg, dict):
+                        for key, value in arg.items():
+                            if isinstance(value, list):
+                                for item in value:
+                                    inputs[key] = item.__class__.__name__
+                            elif isinstance(value, str):
+                                inputs[key] = value
+                    elif isinstance(arg, str):
+                        inputs['input'] = arg
 
             for field, value in instance.steps.items() if hasattr(instance, "steps") and \
                     isinstance(instance.steps, dict) else {}:

instrumentation/llamaindex/instrumentation.py

@@ -1,3 +1,6 @@
+"""
+The LlamaindexInstrumentation class represents the LlamaIndex instrumentation
+"""
 import importlib.metadata
 from typing import Collection
 
@@ -8,12 +11,11 @@ from wrapt import wrap_function_wrapper
 
 from instrumentation.llamaindex.patch import generic_patch
 
-MODULES = [
-    "llama_index.core.query_pipeline.query",
-]
-
 
 class LlamaindexInstrumentation(BaseInstrumentor):
+    """
+    The LlamaindexInstrumentation class represents the LlamaIndex instrumentation
+    """
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return ["llama-index >= 0.10.0"]

instrumentation/llamaindex/patch.py

@@ -1,11 +1,16 @@
+"""
+This module contains a generic patch method that wraps a function with a span.
+"""
 from langtrace.trace_attributes import FrameworkSpanAttributes
-from opentelemetry.trace import SpanKind, StatusCode
+from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from instrumentation.constants import SERVICE_PROVIDERS
 
 
 def generic_patch(method, task, tracer, version):
+    """
+    A generic patch method that wraps a function with a span"""
     def traced_method(wrapped, instance, args, kwargs):
         service_provider = SERVICE_PROVIDERS['LLAMAINDEX']
         span_attributes = {

instrumentation/openai/{lib/apis.py → apis.py}

@@ -1,3 +1,6 @@
+"""
+APIs to instrument OpenAI.
+"""
 from langtrace.trace_attributes import OpenAIMethods
 
 APIS = {

instrumentation/openai/{lib/constants.py → constants.py}

@@ -1,3 +1,6 @@
+"""
+Constants for OpenAI API"""
+
 OPENAI_COST_TABLE = {
     "gpt-4-0125-preview": {
         "input": 0.01,
@@ -28,3 +31,13 @@ OPENAI_COST_TABLE = {
         "output": 0.002,
     },
 }
+
+# TODO: Add more models
+# https://github.com/dqbd/tiktoken/blob/74c147e19584a3a1acea0c8e0da4d39415cd33e0/wasm/src/lib.rs#L328
+TIKTOKEN_MODEL_MAPPING = {
+    "gpt-4": "cl100k_base",
+    "gpt-4-32k": "cl100k_base",
+    "gpt-4-0125-preview": "cl100k_base",
+    "gpt-4-1106-preview": "cl100k_base",
+    "gpt-4-1106-vision-preview": "cl100k_base",
+}

instrumentation/openai/patch.py

@@ -1,14 +1,21 @@
+"""
+This module contains the patching logic for the OpenAI library."""
 import json
 
 from langtrace.trace_attributes import Event, LLMSpanAttributes
-from opentelemetry.trace import SpanKind, StatusCode
+from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from instrumentation.constants import SERVICE_PROVIDERS
-from instrumentation.openai.lib.apis import APIS
+from instrumentation.openai.apis import APIS
+from instrumentation.openai.token_estimation import (calculate_prompt_tokens,
+                                                     estimate_tokens)
 
 
 def images_generate(original_method, version, tracer):
+    """
+    Wrap the `generate` method of the `Images` class to trace it.
+    """
     def traced_method(wrapped, instance, args, kwargs):
         base_url = str(instance._client._base_url) if hasattr(
             instance, '_client') and hasattr(instance._client, '_base_url') else ""
@@ -27,7 +34,8 @@ def images_generate(original_method, version, tracer):
 
         attributes = LLMSpanAttributes(**span_attributes)
 
-        with tracer.start_as_current_span(APIS["IMAGES_GENERATION"]["METHOD"], kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(APIS["IMAGES_GENERATION"]["METHOD"],
+                                          kind=SpanKind.CLIENT) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)
@@ -39,7 +47,8 @@ def images_generate(original_method, version, tracer):
                         result, 'data') and len(result.data) > 0 else {}
                     response = [{
                         "url": data.url if hasattr(data, 'url') else "",
-                        "revised_prompt": data.revised_prompt if hasattr(data, 'revised_prompt') else "",
+                        "revised_prompt": data.revised_prompt if
+                        hasattr(data, 'revised_prompt') else "",
                     }]
                     span.set_attribute(
                         "llm.responses", json.dumps(response))
@@ -60,6 +69,7 @@ def images_generate(original_method, version, tracer):
 
 
 def chat_completions_create(original_method, version, tracer):
+    """Wrap the `create` method of the `ChatCompletion` class to trace it."""
     def traced_method(wrapped, instance, args, kwargs):
         base_url = str(instance._client._base_url) if hasattr(
             instance, '_client') and hasattr(instance._client, '_base_url') else ""
@@ -84,83 +94,131 @@ def chat_completions_create(original_method, version, tracer):
             attributes.llm_top_p = kwargs.get('top_p')
         if kwargs.get('user') is not None:
             attributes.llm_user = kwargs.get('user')
-
-        with tracer.start_as_current_span(APIS["CHAT_COMPLETION"]["METHOD"], kind=SpanKind.CLIENT) as span:
-            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(*args, **kwargs)
-                if kwargs.get('stream') is False:
-                    if hasattr(result, 'choices') and result.choices is not None:
-                        responses = [
-                            {
-                                "message": choice.message.content if choice.message and choice.message.content else "",
-                                **({"content_filter_results": choice["content_filter_results"]} if "content_filter_results" in choice else {})
-                            }
-                            for choice in result.choices
-                        ]
-                    else:
-                        responses = []
-                    span.set_attribute("llm.responses", json.dumps(responses))
-
-                    if hasattr(result, 'system_fingerprint') and result.system_fingerprint is not None:
+        if kwargs.get('functions') is not None:
+            attributes.llm_function_prompts = json.dumps(
+                kwargs.get('functions'))
+
+        # TODO(Karthik): Gotta figure out how to handle streaming with context
+        # 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)
+        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(*args, **kwargs)
+            if kwargs.get('stream') is False:
+                if hasattr(result, 'choices') and result.choices is not None:
+                    responses = [
+                        {
+                            "message": choice.message.content if choice.message and
+                            choice.message.content else choice.message.function_call.arguments
+                            if choice.message and
+                            choice.message.function_call.arguments else "",
+                            **({"content_filter_results": choice["content_filter_results"]}
+                               if "content_filter_results" in choice else {})
+                        }
+                        for choice in result.choices
+                    ]
+                    span.set_attribute(
+                        "llm.responses", json.dumps(responses))
+                else:
+                    responses = []
+                    span.set_attribute(
+                        "llm.responses", json.dumps(responses))
+                if hasattr(result, 'system_fingerprint') and \
+                        result.system_fingerprint is not None:
+                    span.set_attribute(
+                        "llm.system.fingerprint", result.system_fingerprint)
+                # Get the usage
+                if hasattr(result, 'usage') and result.usage is not None:
+                    usage = result.usage
+                    if usage is not None:
+                        usage_dict = {
+                            "prompt_tokens": result.usage.prompt_tokens,
+                            "completion_tokens": usage.completion_tokens,
+                            "total_tokens": usage.total_tokens
+                        }
                         span.set_attribute(
-                            "llm.system.fingerprint", result.system_fingerprint)
-
-                    # Get the usage
-                    if hasattr(result, 'usage') and result.usage is not None:
-                        usage = result.usage
-                        if usage is not None:
-                            usage_dict = {
-                                "prompt_tokens": result.usage.prompt_tokens,
-                                "completion_tokens": usage.completion_tokens,
-                                "total_tokens": usage.total_tokens
-                            }
-                            span.set_attribute(
-                                "llm.token.counts", json.dumps(usage_dict))
-
-                    span.set_status(StatusCode.OK)
-                    return result
+                            "llm.token.counts", json.dumps(usage_dict))
+                span.set_status(StatusCode.OK)
+                span.end()
+                return result
+            else:
+                prompt_tokens = calculate_prompt_tokens(json.dumps(
+                    kwargs.get('messages', {})[0]), kwargs.get('model'))
+                return handle_streaming_response(result, span, prompt_tokens,
+                                                 function_call=kwargs.get(
+                                                     'functions')
+                                                 is not None)
+        except Exception as e:
+            # Record the exception in the span
+            span.record_exception(e)
+            # Set the span status to indicate an error
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            # Reraise the exception to ensure it's not swallowed
+            span.end()
+            raise
+
+    def handle_streaming_response(result, span, prompt_tokens, function_call=False):
+        """Process and yield streaming response chunks."""
+        result_content = []
+        span.add_event(Event.STREAM_START.value)
+        completion_tokens = 0
+        try:
+            for chunk in result:
+                if hasattr(chunk, 'choices') and chunk.choices is not None:
+                    token_counts = [
+                        estimate_tokens(choice.delta.content) if choice.delta
+                        and choice.delta.content
+                        else estimate_tokens(choice.delta.function_call.arguments)
+                        if choice.delta.function_call and
+                        choice.delta.function_call.arguments else 0
+                        for choice in chunk.choices
+                    ]
+                    completion_tokens += sum(token_counts)
+                    content = [
+                        choice.delta.content if choice.delta and choice.delta.content
+                        else choice.delta.function_call.arguments if choice.delta.function_call and
+                        choice.delta.function_call.arguments else ""
+                        for choice in chunk.choices
+                    ]
                 else:
-                    result_content = []
-                    span.add_event(Event.STREAM_START.value)
-
-                    for chunk in result:
-                        # Assuming `chunk` has a structure similar to what OpenAI might return,
-                        # adjust the access accordingly based on actual response structure.
-                        if hasattr(chunk, 'choices') and chunk.choices is not None:
-                            content = [
-                                choice.delta.content if choice.delta and choice.delta.content else ""
-                                for choice in chunk.choices
-                            ]
-                        else:
-                            content = []
-                        span.add_event(Event.STREAM_OUTPUT.value, {
-                            "response": "".join(content)
-                        })
-                        result_content.append(
-                            content[0] if len(content) > 0 else "")
-                    span.add_event(Event.STREAM_END.value)
-                    span.set_attribute("llm.responses", json.dumps(
-                        {"message": {"role": "assistant", "content": "".join(result_content)}}))
-
-            except Exception as e:
-                # Record the exception in the span
-                span.record_exception(e)
-
-                # Set the span status to indicate an error
-                span.set_status(Status(StatusCode.ERROR, str(e)))
-
-                # Reraise the exception to ensure it's not swallowed
-                raise
+                    content = []
+                span.add_event(Event.STREAM_OUTPUT.value, {
+                    "response": "".join(content)
+                })
+                result_content.append(
+                    content[0] if len(content) > 0 else "")
+                yield chunk
+        finally:
+
+            # Finalize span after processing all chunks
+            span.add_event(Event.STREAM_END.value)
+            span.set_attribute("llm.token.counts", json.dumps({
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": prompt_tokens + completion_tokens
+            }))
+            if function_call is False:
+                span.set_attribute("llm.responses", json.dumps(
+                    {"message": {"role": "assistant", "content": "".join(result_content)}}))
+            else:
+                span.set_attribute("llm.responses", json.dumps(
+                    {"message": {"role": "assistant", "function_call": "".join(result_content)}}))
+            span.set_status(StatusCode.OK)
+            span.end()
 
     # return the wrapped method
     return traced_method
 
 
 def embeddings_create(original_method, version, tracer):
+    """
+    Wrap the `create` method of the `Embeddings` class to trace it.
+    """
     def traced_method(wrapped, instance, args, kwargs):
         base_url = str(instance._client._base_url) if hasattr(
             instance, '_client') and hasattr(instance._client, '_base_url') else ""
@@ -187,7 +245,8 @@ def embeddings_create(original_method, version, tracer):
         if kwargs.get('user') is not None:
             attributes["llm.user"] = kwargs.get('user')
 
-        with tracer.start_as_current_span(APIS["EMBEDDINGS_CREATE"]["METHOD"], kind=SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(APIS["EMBEDDINGS_CREATE"]["METHOD"],
+                                          kind=SpanKind.CLIENT) as span:
             for field, value in attributes.model_dump(by_alias=True).items():
                 if value is not None:
                     span.set_attribute(field, value)

instrumentation/openai/token_estimation.py

@@ -0,0 +1,48 @@
+"""
+This module contains functions to estimate the number of tokens in a prompt and 
+to calculate the price of a model based on its usage.
+"""
+
+from tiktoken import get_encoding
+
+from instrumentation.openai.constants import (OPENAI_COST_TABLE,
+                                              TIKTOKEN_MODEL_MAPPING)
+
+
+def estimate_tokens(prompt):
+    """
+    Estimate the number of tokens in a prompt."""
+    if prompt and len(prompt) > 0:
+        # Simplified token estimation: count the words.
+        return len([word for word in prompt.split() if word])
+    return 0
+
+
+def estimate_tokens_using_tiktoken(prompt, model):
+    """
+    Estimate the number of tokens in a prompt using tiktoken."""
+    encoding = get_encoding(model)
+    tokens = encoding.encode(prompt)
+    return len(tokens)
+
+
+def calculate_prompt_tokens(prompt_content, model):
+    """
+    Calculate the number of tokens in a prompt. If the model is supported by tiktoken, use it for the estimation."""
+    try:
+        tiktoken_model = TIKTOKEN_MODEL_MAPPING[model]
+        return estimate_tokens_using_tiktoken(prompt_content, tiktoken_model)
+    except Exception:
+        return estimate_tokens(prompt_content)  # Fallback method
+
+
+def calculate_price_from_usage(model, usage):
+    """
+    Calculate the price of a model based on its usage."""
+    cost_table = OPENAI_COST_TABLE.get(model)
+    if cost_table:
+        return (
+            (cost_table['input'] * usage['prompt_tokens'] +
+             cost_table['output'] * usage['completion_tokens']) / 1000
+        )
+    return 0

instrumentation/pinecone/instrumentation.py

@@ -1,3 +1,7 @@
+"""
+Pinecone instrumentation
+"""
+
 import importlib.metadata
 from typing import Collection
 
@@ -7,11 +11,13 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 
-from instrumentation.pinecone.lib.apis import APIS
+from instrumentation.pinecone.apis import APIS
 from instrumentation.pinecone.patch import generic_patch
 
 
 class PineconeInstrumentation(BaseInstrumentor):
+    """
+    The PineconeInstrumentation class represents the Pinecone instrumentation"""
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return ["pinecone-client >= 3.1.0"]
@@ -40,4 +46,4 @@ class PineconeInstrumentation(BaseInstrumentor):
             )
 
     def _uninstrument(self, **kwargs):
-        print(kwargs)
+        pass

instrumentation/pinecone/patch.py

@@ -1,14 +1,16 @@
-import json
-
+"""
+This module contains the patching logic for the Pinecone client."""
 from langtrace.trace_attributes import DatabaseSpanAttributes
-from opentelemetry.trace import SpanKind, StatusCode
+from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
 from instrumentation.constants import SERVICE_PROVIDERS
-from instrumentation.pinecone.lib.apis import APIS
+from instrumentation.pinecone.apis import APIS
 
 
 def generic_patch(original_method, method, version, tracer):
+    """
+    A generic patch method that wraps a function with a span"""
     def traced_method(wrapped, instance, args, kwargs):
         api = APIS[method]
         service_provider = SERVICE_PROVIDERS['PINECONE']

{langtrace_python_sdk-1.0.9.dist-info → langtrace_python_sdk-1.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langtrace-python-sdk
-Version: 1.0.9
+Version: 1.0.11
 Summary: LangTrace - Python SDK
 Home-page: https://github.com/Scale3-Labs/langtrace-python-sdk
 Author: Ali Waleed

langtrace_python_sdk-1.0.11.dist-info/RECORD

@@ -0,0 +1,53 @@
+examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/setup.py,sha256=07Sy36lUuNuPU5QPAs2BEMm-YKSosruzKJPl0QKc_rc,2105
+examples/chroma_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/chroma_example/basic.py,sha256=HD8vGSsvcXN21AuWyUx09CePphXrIp9PSNllueMqvEI,836
+examples/langchain_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/langchain_example/basic.py,sha256=PBYotFDJlkH9y17U8WRbH3FxqgfBPHra2k_C7hHPiMc,1993
+examples/langchain_example/tool.py,sha256=g7mFuXal6TtCvo-KTYqWeSEpuyQMR2LuHF6WQdKRwbw,2494
+examples/llamaindex_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/llamaindex_example/basic.py,sha256=b1y1VnYE7eaeSXLk9rJ4EZApCj-tMPPMTY-fc_M7X7c,620
+examples/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/openai/chat_completion.py,sha256=3ojkccgntJp_IXnNb7f7w9sXPtj_mDNOE7IyLB6SsS0,1300
+examples/openai/embeddings_create.py,sha256=01ApMJ2F_8-IWanDAD8SWlrcjg8b3mJzaddsGhRvrck,457
+examples/openai/function_calling.py,sha256=MzxNNvPNdUWOw8Ugs_gMGuwyQN4yPJnja46rE_8W_ZY,2475
+examples/openai/images_generate.py,sha256=GD2Bj902xqS0pfZr0pZtPXCGHEHWZM_CjGJ0DdoP_pY,444
+examples/pinecone_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/pinecone_example/basic.py,sha256=lF8TcDvW1v6j-QKvl3B9r1t0ShnvCcOgJ5F74qy6VO8,793
+instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/constants.py,sha256=YdC62dsYpbbBdMHhfUbaK-cbDM4w4eau0ClUdWVmjmU,336
+instrumentation/with_root_span.py,sha256=CRie2ljHhnHN8bUGDwBM-F18-c6xyoI_238KP8BEO-U,969
+instrumentation/chroma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/chroma/apis.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
+instrumentation/chroma/instrumentation.py,sha256=ySEyLnXcjL7D3sgMHTkxwdpxDpsRVbRJvFOgTxYRHvs,1174
+instrumentation/chroma/patch.py,sha256=2ERORLV4_F1UU2Is8Y4H7aEXNnAPI5XKvW9DnLeEndM,1943
+instrumentation/chroma/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain/instrumentation.py,sha256=LXtx5edfHPLRZ9yP0yKbDHlvE7LOJumJMGTqQX5RhhM,2850
+instrumentation/langchain/patch.py,sha256=f-lq0wdk7doop-Dak2VcGueDsESA_5RKyuGtJQIm4DQ,2979
+instrumentation/langchain_community/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain_community/instrumentation.py,sha256=XWzaHl4FPPlZEhnUlxRB0iO5kPkNVI9siRXZgxF_Yb4,4316
+instrumentation/langchain_community/patch.py,sha256=w6R_lHTDg2GzWRH8BZNocQowedeaNUE-pLfCoRETnTk,2872
+instrumentation/langchain_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain_core/instrumentation.py,sha256=AYHqyuOwunuMqrTCxzXCbkIDmJbHA6Q40moHntdL4tw,4739
+instrumentation/langchain_core/patch.py,sha256=a314C0IaF0gSa2eh-yO8jHqtZwnWIczQsF3FgCgoiiU,7536
+instrumentation/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/llamaindex/instrumentation.py,sha256=WwETor8jLwaDQwnwgbtKZHQ3MwtNIfZSp1aaUn-uLIk,2759
+instrumentation/llamaindex/patch.py,sha256=hSSoOij70kIhAleHLOfTW-zNc-N9boQz1iyhoBdVRsQ,1709
+instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/openai/apis.py,sha256=lMUa6rCkT-fKltngOUxcXd0aNpTb5L8xlqjrdseLIZM,488
+instrumentation/openai/constants.py,sha256=3_xaFfAhh2dpH0072Cijzb5iZazUpmj4SF0iWiMFm1A,973
+instrumentation/openai/instrumentation.py,sha256=Mkk6fwvQ8kS9ykFFc8OffIGbNMYVi6rrBVjVVhjuTjo,1408
+instrumentation/openai/patch.py,sha256=Syktbjz9R-XjGj9QEGojZ4fsxZdQ7Gq4nPOW49J4fLA,12234
+instrumentation/openai/token_estimation.py,sha256=nwTR0yyZs2OB0S3bBviBgd_xMb6oh7nCPMt-HlIlCRU,1549
+instrumentation/openai/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/pinecone/apis.py,sha256=XpKNUfyzEE3HkBN10Qv1w_t1PT-J39pHlotrdU-wvec,477
+instrumentation/pinecone/instrumentation.py,sha256=yfOxKkMtW6GEUQ0E9AWSBdaa07MHzV3o6Q09cAvoWIU,1708
+instrumentation/pinecone/patch.py,sha256=fr07o97CqGc8sUEyMtSiT6watZiTPStRPOrxOzhJGLo,1840
+instrumentation/pinecone/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langtrace_python_sdk-1.0.11.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+langtrace_python_sdk-1.0.11.dist-info/METADATA,sha256=Zgg1c6Ykg62bBICe3rPmogg4GWjTe-WwtnGWQyVJ_mA,6149
+langtrace_python_sdk-1.0.11.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+langtrace_python_sdk-1.0.11.dist-info/top_level.txt,sha256=FJhLokAk3p9qB-lzJKTfQ1CtAXoxvyL8zkfffVrFSdI,25
+langtrace_python_sdk-1.0.11.dist-info/RECORD,,

{langtrace_python_sdk-1.0.9.dist-info → langtrace_python_sdk-1.0.11.dist-info}/top_level.txt

@@ -1 +1,2 @@
+examples
 instrumentation

instrumentation/utils.py

@@ -1,27 +0,0 @@
-from tiktoken import TiktokenEncoding, get_encoding
-from .constants import TIKTOKEN_MODEL_MAPPING, OPENAI_COST_TABLE
-
-def estimate_tokens(prompt: str) -> int:
-    if prompt and len(prompt) > 0:
-        # Simplified token estimation: count the words.
-        return len(prompt.split())
-    return 0
-
-def estimate_tokens_using_tiktoken(prompt: str, model: TiktokenEncoding) -> int:
-    encoding = get_encoding(model)
-    tokens = encoding.encode(prompt)
-    return len(tokens)
-
-def calculate_prompt_tokens(prompt_content: str, model: str) -> int:
-    try:
-        tiktoken_model = TIKTOKEN_MODEL_MAPPING[model]
-        return estimate_tokens_using_tiktoken(prompt_content, tiktoken_model)
-    except KeyError:
-        return estimate_tokens(prompt_content)  # Fallback method
-
-def calculate_price_from_usage(model: str, usage: dict) -> float:
-    cost_table = OPENAI_COST_TABLE.get(model)
-    if cost_table:
-        return ((cost_table['input'] * usage['prompt_tokens'] +
-                 cost_table['output'] * usage['completion_tokens']) / 1000)
-    return 0

langtrace_python_sdk-1.0.9.dist-info/RECORD

@@ -1,38 +0,0 @@
-instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/constants.py,sha256=1wth9_em4_h4UgmcADcPmDHvKCJLqOqBbTw7jmcga6A,467
-instrumentation/setup.py,sha256=07Sy36lUuNuPU5QPAs2BEMm-YKSosruzKJPl0QKc_rc,2105
-instrumentation/utils.py,sha256=2kQHQgeuk8kSGoQSBQByQYEXGLkSMDkw7riYVag_cv8,1059
-instrumentation/with_root_span.py,sha256=CRie2ljHhnHN8bUGDwBM-F18-c6xyoI_238KP8BEO-U,969
-instrumentation/chroma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/chroma/instrumentation.py,sha256=Gc0nNAMoBR-WPRbgPw5AYZBDSQUY56i_rAEbhX8h4A4,1078
-instrumentation/chroma/patch.py,sha256=smzSItC53-tuaMuGbiMhgB2luNJOHz3ttyL7uOqyYII,1811
-instrumentation/chroma/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/chroma/lib/apis.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
-instrumentation/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain/instrumentation.py,sha256=LXtx5edfHPLRZ9yP0yKbDHlvE7LOJumJMGTqQX5RhhM,2850
-instrumentation/langchain/patch.py,sha256=f-lq0wdk7doop-Dak2VcGueDsESA_5RKyuGtJQIm4DQ,2979
-instrumentation/langchain_community/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain_community/instrumentation.py,sha256=XWzaHl4FPPlZEhnUlxRB0iO5kPkNVI9siRXZgxF_Yb4,4316
-instrumentation/langchain_community/patch.py,sha256=w6R_lHTDg2GzWRH8BZNocQowedeaNUE-pLfCoRETnTk,2872
-instrumentation/langchain_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain_core/instrumentation.py,sha256=uq9F0R0AVM-mlqcrtl2cKxFjHjMTqTZb8741AVhzjAA,4360
-instrumentation/langchain_core/patch.py,sha256=PRAi64V02TSY3uX3403dmQ0CDPHSf9ZF9fvw4Tfaf3Y,6702
-instrumentation/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/llamaindex/instrumentation.py,sha256=igUTU0lXOVGXOF_4fvFrRa0Y8dmwdGpk6AqWmrQhDaE,2635
-instrumentation/llamaindex/patch.py,sha256=-vsnJBXBBUwNJckHfmH8BRuVM0_dHGOqH6d22NBY4_E,1562
-instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/openai/instrumentation.py,sha256=Mkk6fwvQ8kS9ykFFc8OffIGbNMYVi6rrBVjVVhjuTjo,1408
-instrumentation/openai/patch.py,sha256=hA71WogWtbP3gIGAE9cVMF3UyBOQPV-KyLrg50ctfoM,9467
-instrumentation/openai/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/openai/lib/apis.py,sha256=9rVa-9nKkKWuIFKGmyrFK_fHe7XVe07SlfRfB3Bxl8Q,453
-instrumentation/openai/lib/constants.py,sha256=jbxBAXlyauJQFQhM5I01005y0qLr_IRRWjKDkzsltDA,594
-instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/pinecone/instrumentation.py,sha256=asVu7d7slGOwv0ZTv9W_oIOe9gSDI7dFgxLhh-JMUt0,1598
-instrumentation/pinecone/patch.py,sha256=KCiNToy2hAq0eQHyR-Jw5aEyyn1XoQubGrzew-_sK04,1725
-instrumentation/pinecone/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/pinecone/lib/apis.py,sha256=XpKNUfyzEE3HkBN10Qv1w_t1PT-J39pHlotrdU-wvec,477
-langtrace_python_sdk-1.0.9.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-langtrace_python_sdk-1.0.9.dist-info/METADATA,sha256=ZDDY0OWZ-TMVH3SF8198BOOuTAZfdaN7qLQD9iYNAbU,6148
-langtrace_python_sdk-1.0.9.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-langtrace_python_sdk-1.0.9.dist-info/top_level.txt,sha256=mdFAULSZuqUiDveRElCIPMvwAkRAYXP4bm_dEI4A96Q,16
-langtrace_python_sdk-1.0.9.dist-info/RECORD,,