langtrace-python-sdk 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

langtrace_python_sdk/instrumentation/openai/patch.py

@@ -121,7 +121,8 @@ def async_images_generate(original_method, version, tracer):
         with tracer.start_as_current_span(
             APIS["IMAGES_GENERATION"]["METHOD"], kind=SpanKind.CLIENT
         ) as span:
-            async for field, value in attributes.model_dump(by_alias=True).items():
+            items = attributes.model_dump(by_alias=True).items()
+            for field, value in items:
                 if value is not None:
                     span.set_attribute(field, value)
             try:
@@ -325,7 +326,9 @@ def chat_completions_create(original_method, version, tracer):
             span.end()
             raise
 
-    def handle_streaming_response(result, span, prompt_tokens, function_call=False, tool_calls=False):
+    def handle_streaming_response(
+        result, span, prompt_tokens, function_call=False, tool_calls=False
+    ):
         """Process and yield streaming response chunks."""
         result_content = []
         span.add_event(Event.STREAM_START.value)
@@ -343,12 +346,16 @@ def chat_completions_create(original_method, version, tracer):
                                 content = [choice.delta.content]
                     elif function_call:
                         for choice in chunk.choices:
-                            if choice.delta and choice.delta.function_call and choice.delta.function_call.arguments is not None:
-                                token_counts = estimate_tokens(choice.delta.function_call.arguments)
-                                completion_tokens += token_counts
-                                content = [
+                            if (
+                                choice.delta
+                                and choice.delta.function_call
+                                and choice.delta.function_call.arguments is not None
+                            ):
+                                token_counts = estimate_tokens(
                                     choice.delta.function_call.arguments
-                                ]
+                                )
+                                completion_tokens += token_counts
+                                content = [choice.delta.function_call.arguments]
                     elif tool_calls:
                         # TODO(Karthik): Tool calls streaming is tricky. The chunks after the
                         # first one are missing the function name and id though the arguments
@@ -357,7 +364,14 @@ def chat_completions_create(original_method, version, tracer):
                 else:
                     content = []
                 span.add_event(
-                    Event.STREAM_OUTPUT.value, {"response": "".join(content) if len(content) > 0 and content[0] is not None else ""}
+                    Event.STREAM_OUTPUT.value,
+                    {
+                        "response": (
+                            "".join(content)
+                            if len(content) > 0 and content[0] is not None
+                            else ""
+                        )
+                    },
                 )
                 result_content.append(content[0] if len(content) > 0 else "")
                 yield chunk
@@ -559,7 +573,9 @@ def async_chat_completions_create(original_method, version, tracer):
             span.end()
             raise
 
-    async def ahandle_streaming_response(result, span, prompt_tokens, function_call=False, tool_calls=False):
+    async def ahandle_streaming_response(
+        result, span, prompt_tokens, function_call=False, tool_calls=False
+    ):
         """Process and yield streaming response chunks."""
         result_content = []
         span.add_event(Event.STREAM_START.value)
@@ -577,12 +593,16 @@ def async_chat_completions_create(original_method, version, tracer):
                                 content = [choice.delta.content]
                     elif function_call:
                         for choice in chunk.choices:
-                            if choice.delta and choice.delta.function_call and choice.delta.function_call.arguments is not None:
-                                token_counts = estimate_tokens(choice.delta.function_call.arguments)
-                                completion_tokens += token_counts
-                                content = [
+                            if (
+                                choice.delta
+                                and choice.delta.function_call
+                                and choice.delta.function_call.arguments is not None
+                            ):
+                                token_counts = estimate_tokens(
                                     choice.delta.function_call.arguments
-                                ]
+                                )
+                                completion_tokens += token_counts
+                                content = [choice.delta.function_call.arguments]
                     elif tool_calls:
                         # TODO(Karthik): Tool calls streaming is tricky. The chunks after the
                         # first one are missing the function name and id though the arguments
@@ -591,7 +611,14 @@ def async_chat_completions_create(original_method, version, tracer):
                 else:
                     content = []
                 span.add_event(
-                    Event.STREAM_OUTPUT.value, {"response": "".join(content) if len(content) > 0 and content[0] is not None else ""}
+                    Event.STREAM_OUTPUT.value,
+                    {
+                        "response": (
+                            "".join(content)
+                            if len(content) > 0 and content[0] is not None
+                            else ""
+                        )
+                    },
                 )
                 result_content.append(content[0] if len(content) > 0 else "")
                 yield chunk
@@ -756,11 +783,19 @@ def async_embeddings_create(original_method, version, tracer):
 
 def extract_content(choice):
     # Check if choice.message exists and has a content attribute
-    if hasattr(choice, 'message') and hasattr(choice.message, 'content') and choice.message.content is not None:
+    if (
+        hasattr(choice, "message")
+        and hasattr(choice.message, "content")
+        and choice.message.content is not None
+    ):
         return choice.message.content
 
     # Check if choice.message has tool_calls and extract information accordingly
-    elif hasattr(choice, 'message') and hasattr(choice.message, 'tool_calls') and choice.message.tool_calls is not None:
+    elif (
+        hasattr(choice, "message")
+        and hasattr(choice.message, "tool_calls")
+        and choice.message.tool_calls is not None
+    ):
         result = [
             {
                 "id": tool_call.id,
@@ -768,13 +803,18 @@ def extract_content(choice):
                 "function": {
                     "name": tool_call.function.name,
                     "arguments": tool_call.function.arguments,
-                }
-            } for tool_call in choice.message.tool_calls
+                },
+            }
+            for tool_call in choice.message.tool_calls
         ]
         return result
 
     # Check if choice.message has a function_call and extract information accordingly
-    elif hasattr(choice, 'message') and hasattr(choice.message, 'function_call') and choice.message.function_call is not None:
+    elif (
+        hasattr(choice, "message")
+        and hasattr(choice.message, "function_call")
+        and choice.message.function_call is not None
+    ):
         return {
             "name": choice.message.function_call.name,
             "arguments": choice.message.function_call.arguments,

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "1.3.5"
+__version__ = "1.3.7"

{langtrace_python_sdk-1.3.5.dist-info → langtrace_python_sdk-1.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 1.3.5
+Version: 1.3.7
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -25,6 +25,10 @@ Requires-Dist: langchain-openai; extra == 'dev'
 Requires-Dist: llama-index; extra == 'dev'
 Requires-Dist: openai; extra == 'dev'
 Requires-Dist: python-dotenv; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: pytest-vcr; extra == 'test'
 Description-Content-Type: text/markdown
 
 # [Langtrace](https://www.langtrace.ai)

{langtrace_python_sdk-1.3.5.dist-info → langtrace_python_sdk-1.3.7.dist-info}/RECORD

@@ -30,7 +30,7 @@ examples/pinecone_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 examples/pinecone_example/basic.py,sha256=OkYjN3J5kxw-kloOV3Q-iyI6opkbarWsMom-_AMP2ZA,893
 langtrace_python_sdk/__init__.py,sha256=SlHg447-nQBbw8exRNJP_OyHUZ39Sldb7aaQ35hIRm8,262
 langtrace_python_sdk/langtrace.py,sha256=83-AkdASO7UF9FHR9BDZUSeYv9GFZkJJQD2YLKbqzo8,3562
-langtrace_python_sdk/version.py,sha256=tdqvkGH0OryRjjXzO3HS5DyYol-VTO9fC8m43nB2PgI,22
+langtrace_python_sdk/version.py,sha256=9peaXOar2qezOPJEKG6cD_A0aaXrzdVN8h-v6fBoBEk,22
 langtrace_python_sdk/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=5MNjnAOg-4am78J3gVMH6FSwq5N8TOj72ugkhsw4vi0,46
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -66,14 +66,31 @@ langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py,sha256=D7_HPv
 langtrace_python_sdk/instrumentation/llamaindex/patch.py,sha256=8IM2dedF81w8_vVyA56JptyvlQl_bQO4UcB56sptuGs,3700
 langtrace_python_sdk/instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=Pv4n4z_kSxvZGVxrj3AopBoWQSxIOtMKolkxHrchRdM,2162
-langtrace_python_sdk/instrumentation/openai/patch.py,sha256=ZxR6hLXbf05rw7tccNsEQv-uB8Zb8QvOzTJk1coJbkY,33819
+langtrace_python_sdk/instrumentation/openai/patch.py,sha256=ou8_48lmHmtI9UTU--QVl7KaAIeBnNtqOuHtnUQqjpU,34590
 langtrace_python_sdk/instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/instrumentation/pinecone/instrumentation.py,sha256=o0EUd5jvHaDKOUTj4NjnL5UfDHDHxyXkWGlTW4oeRDk,1784
 langtrace_python_sdk/instrumentation/pinecone/patch.py,sha256=5lF7hQmg2-U2EWtOC0w8_peRaNMysBomb0fjiNoS6eQ,2200
 langtrace_python_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/utils/llm.py,sha256=4z2e-md_ELXCEuOIRVWracR6qH2pmsOxCqpkuF9_3Nw,1589
 langtrace_python_sdk/utils/with_root_span.py,sha256=N7ONrcF0myZbHBy5gpQffDbX-Kf63Crsz9szG0i3m08,1889
-langtrace_python_sdk-1.3.5.dist-info/METADATA,sha256=yUAeoRPdsjv_i4VUE0lwzH10O1uNWt9-S-qj8yMhRAI,9094
-langtrace_python_sdk-1.3.5.dist-info/WHEEL,sha256=osohxoshIHTFJFVPhsi1UkZuLRGMHRXZzwEBW2ezjrc,87
-langtrace_python_sdk-1.3.5.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-1.3.5.dist-info/RECORD,,
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/utils.py,sha256=wdbR00LjYfDXzTBFvkksQYEz1hZjGTNKEiw5KPE_bqI,625
+tests/anthropic/test_anthropic.py,sha256=vvrDJCg9KCws72NEuvPklq8RqQBgGwmV-fSkxGSvUFw,2632
+tests/chroma/test_chroma.py,sha256=5zeInDcP5VplrM9ex2iuVKcpVKMDfEf_ZDK9D6Tc700,2392
+tests/langchain/test_langchain.py,sha256=GGGRcxz0isNmegeum37XFrlJqI6jB6_iUvv8AJ5iG24,2481
+tests/langchain/test_langchain_community.py,sha256=m9lBmMZIeUouKSq1JfdBupV0-0ef39GD6BKsA0Cf_08,2515
+tests/langchain/test_langchain_core.py,sha256=hCuKkIUvDQOUBM2oEgMG3Iq_KNTwC2sH7_Y_IR5FIno,4238
+tests/openai/conftest.py,sha256=r-Scvq1pP62gkvI4CC13nR19twlRQFUx8WuMe9qcesM,1138
+tests/openai/test_chat_completion.py,sha256=iXz8RTU5oCfP2CWOhKJXlWwK-IfLubI8SW396sPxnV0,5310
+tests/openai/test_embeddings.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/openai/test_image_generation.py,sha256=tUyLTELi-nBOlp6yZ0hyPbLp04S_-qo-EtqAIJZeXuQ,3889
+tests/openai/cassettes/test_async_chat_completion_streaming.yaml,sha256=0aZHFy9NvXegEDjGWyoG-_ItLr7JYAKbaBLIPSl-pfM,6844
+tests/openai/cassettes/test_async_image_generation.yaml,sha256=_LYZcrqxrnSqcWVQn2Y0XMVGxF-wBrSAd-v3LTAIAeo,3597
+tests/openai/cassettes/test_chat_completion.yaml,sha256=YkNFgK9VHAzNqGWuxFcTiE194GdEie8eDf1FSsffjd8,2944
+tests/openai/cassettes/test_chat_completion_streaming.yaml,sha256=nkx_TemQMYSZxUF_b-LCEFwCRDm0AkQHLf4sdJVuZBw,2592394
+tests/openai/cassettes/test_image_generation.yaml,sha256=gn5aSVp6V6_hb_rt2NnkAWd_idzDxo-7VzhZII0Wslw,3562
+tests/pinecone/test_pinecone.py,sha256=_wlJbSKnY7gyzVcwxIWKft1P_t8dWwcIKNfGCrRLiHs,2633
+langtrace_python_sdk-1.3.7.dist-info/METADATA,sha256=3GGehwdTtmz8Hs-UPF8CLs4P3PLz_nek1e9FOSnlPxs,9244
+langtrace_python_sdk-1.3.7.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+langtrace_python_sdk-1.3.7.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-1.3.7.dist-info/RECORD,,

{langtrace_python_sdk-1.3.5.dist-info → langtrace_python_sdk-1.3.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.1
+Generator: hatchling 1.24.2
 Root-Is-Purelib: true
 Tag: py3-none-any

tests/anthropic/test_anthropic.py

@@ -0,0 +1,73 @@
+import unittest
+from unittest.mock import MagicMock, call
+from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create
+from opentelemetry.trace import SpanKind
+import importlib.metadata
+from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
+from opentelemetry.trace.status import Status, StatusCode
+import json
+from langtrace.trace_attributes import Event, LLMSpanAttributes
+
+from tests.utils import common_setup
+
+class TestAnthropic(unittest.TestCase):
+
+    data = {
+        "content" : [MagicMock(text="Some text", type="text")],
+        "system_fingerprint" : "None",
+        "usage" : MagicMock(input_tokens=23, output_tokens=44),
+        "chunks" : [MagicMock(delta="Some text", message="text")]}
+
+
+    def setUp(self):
+        
+        # Mock the original method
+        self.anthropic_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        pass
+
+    def test_anthropic(self):
+        # Arrange
+        version = importlib.metadata.version('anthropic')        
+        kwargs = {
+            "model": "claude-3-opus-20240229",
+            "messages" : [{"role": "user", "content": "How are you today?"}],
+            "stream": False
+        }   
+
+        # Act
+        wrapped_function = messages_create("anthropic.messages.create", version, self.tracer)
+        result = wrapped_function(self.anthropic_mock, MagicMock(), (), kwargs)
+        
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with("anthropic.messages.create", kind=SpanKind.CLIENT))
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+        
+        expected_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": "Anthropic",
+            "langtrace.service.type": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": "/v1/messages",
+            "llm.api": APIS["MESSAGES_CREATE"]["ENDPOINT"],
+            "llm.model": kwargs.get("model"),
+            "llm.prompts": json.dumps(kwargs.get("messages", [])),
+            "llm.stream": kwargs.get("stream"),
+        }
+
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+       
+        expected_result_data = {"system_fingerprint": "None"  }   
+
+        self.assertEqual(result.system_fingerprint, expected_result_data["system_fingerprint"])
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/chroma/test_chroma.py

@@ -0,0 +1,64 @@
+from unittest.mock import MagicMock, patch, call
+from langtrace_python_sdk.constants.instrumentation.common import \
+    SERVICE_PROVIDERS
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import StatusCode,Status
+from langtrace_python_sdk.instrumentation.chroma.patch import collection_patch
+from opentelemetry.trace import SpanKind
+from tests.utils import common_setup
+import unittest
+import json
+
+
+class TestChromaPatch(unittest.TestCase):
+    data = {
+        "status": "success",
+    }
+    def setUp(self):
+            self.chroma_mock, self.tracer, self.span = common_setup(self.data, 'chromadb.Collection.add')
+            self.wrapped_method = MagicMock(return_value="mocked method result")
+            self.instance = MagicMock()
+            self.instance.name = "aa" 
+
+    def tearDown(self):
+        self.chroma_mock.stop()
+
+    def test_collection_patch_success(self):
+        # Arrange
+        traced_method = collection_patch("ADD", "1.2.3", self.tracer)
+
+        # Act
+        result = traced_method(self.wrapped_method, self.instance, (), {})
+
+        # Assert
+        # Assert the result of the original method is returned
+        self.assertEqual(result, "mocked method result")
+
+        # Assert the span is started with the correct parameters
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with("chromadb.Collection.add", kind=SpanKind.CLIENT))
+
+        # Verify span attributes are set as expected
+        expected_attributes = {
+            'langtrace.sdk.name': 'langtrace-python-sdk',
+            'langtrace.service.name': 'Chroma',
+            'langtrace.service.type': 'vectordb',
+            'langtrace.service.version': '1.2.3',
+            'langtrace.version': '1.0.0',
+            'db.system': 'chromadb',
+            'db.operation': 'add',
+            'db.collection.name': 'aa',
+        }
+        for key, value in expected_attributes.items():
+            self.span.set_attribute.assert_has_calls([call(key, value)], any_order=True)
+
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+        
+        # Assert the span status is set to OK
+        self.span.set_status.assert_called_with(StatusCode.OK)
+        
+
+if __name__ == '__main__':
+    unittest.main()

tests/langchain/test_langchain.py

@@ -0,0 +1,69 @@
+
+import unittest
+from unittest.mock import MagicMock, call
+from langtrace_python_sdk.instrumentation.langchain.patch import generic_patch
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace import get_tracer
+import importlib.metadata
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import Status, StatusCode
+from tests.utils import common_setup
+import json
+
+class TestGenericPatch(unittest.TestCase):
+    data = {"key": "value"}
+    def setUp(self):
+        self.langchain_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        # Clean up after each test case
+        pass
+      
+    def test_generic_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = False  # Change as per your requirement
+        args = (1, 2, 3)
+        task = "split_text"
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version('langchain')
+
+        # Act
+        wrapped_function = generic_patch("langchain.text_splitter", task, self.tracer, version, trace_output, trace_input)
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain"
+        expected_attributes = {
+            'langtrace.sdk.name': 'langtrace-python-sdk',
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": task,
+        }
+        
+        
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+                
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+        
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"key": "value"  }   
+
+        self.assertEqual(result.key, expected_result_data["key"])
+
+if __name__ == '__main__':
+    unittest.main()

tests/langchain/test_langchain_community.py

@@ -0,0 +1,69 @@
+
+import unittest
+from unittest.mock import MagicMock, Mock, patch, call
+from langtrace_python_sdk.instrumentation.langchain_community.patch import generic_patch
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace import get_tracer
+import importlib.metadata
+import openai
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import Status, StatusCode
+import json
+from tests.utils import common_setup
+class TestGenericPatch(unittest.TestCase):
+    data = {"key": "value"}
+    def setUp(self):
+        self.langchain_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        # Clean up after each test case
+        pass
+
+    def test_generic_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = False 
+        args = (1, 2, 3)
+        task = "vector_store"
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version("langchain-community")
+
+        # Act
+        wrapped_function = generic_patch("langchain_community.vectorstores.faiss", task, self.tracer, version, trace_output, trace_input)
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain Community"
+        expected_attributes = {
+            'langtrace.sdk.name': 'langtrace-python-sdk',
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": task,
+        }
+        
+        
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+                
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+        
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"key": "value"  }   
+        self.assertEqual(result.key, expected_result_data["key"])
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/langchain/test_langchain_core.py

@@ -0,0 +1,115 @@
+
+import unittest
+from unittest.mock import MagicMock, Mock, patch, call
+from langtrace_python_sdk.instrumentation.langchain_core.patch import generic_patch, runnable_patch
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace import get_tracer
+import importlib.metadata
+import openai
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import Status, StatusCode
+import json
+from tests.utils import common_setup
+class TestGenericPatch(unittest.TestCase):
+    data = {"items": "value"}
+    def setUp(self):
+        self.langchain_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        # Clean up after each test case
+        pass
+
+    def test_generic_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = True 
+        task = "retriever"
+        args = (1, 2, 3)
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version("langchain-core")
+
+        # Act
+        wrapped_function = generic_patch("langchain_core.retrievers", task , self.tracer, version, trace_output, trace_input)
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain Core"
+        expected_attributes = {
+            'langtrace.sdk.name': 'langtrace-python-sdk',
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": task,
+        }
+        
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+             
+        actual_calls = self.span.set_attribute.call_args_list
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+
+        
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"items": "value"  }   
+        self.assertEqual(result.items, expected_result_data["items"])
+
+    def test_runnable_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = True 
+        args = (1, 2, 3)
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version("langchain-core")
+
+        # Act
+        wrapped_function = runnable_patch("langchain_core.runnables.passthrough",
+                "runnablepassthrough", self.tracer, version, trace_output, trace_input)
+
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain Core"
+        expected_attributes = {
+            'langtrace.sdk.name': 'langtrace-python-sdk',
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": "runnablepassthrough",
+        }
+
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+        
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+
+       
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"items": "value"  }   
+
+        self.assertEqual(result.items, expected_result_data["items"])
+
+
+if __name__ == '__main__':
+    unittest.main()