langtrace-python-sdk 2.3.0__tar.gz → 2.3.2__tar.gz

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.3.0
+Version: 2.3.2
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/examples/crewai_example/simple_agent/main.py

@@ -18,12 +18,12 @@ class PoetryCrew:
         tasks = PoetryTasks()
 
         poetry_agent = agents.create_poet_agent()
-        poetry_agent_2 = agents.poet_agent_2()
-        poetry_agent_3 = agents.poet_agent_3()
+        # poetry_agent_2 = agents.poet_agent_2()
+        # poetry_agent_3 = agents.poet_agent_3()
 
         create_poem = tasks.create_poem(poetry_agent, self.topic)
-        create_poem_2 = tasks.create_poem(poetry_agent_2, self.topic)
-        create_poem_3 = tasks.create_poem(poetry_agent_3, self.topic)
+        # create_poem_2 = tasks.create_poem(poetry_agent_2, self.topic)
+        # create_poem_3 = tasks.create_poem(poetry_agent_3, self.topic)
 
         crew = Crew(agents=[poetry_agent], tasks=[create_poem], verbose=True, memory=True)
         res = crew.kickoff()

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/extensions/langtrace_exporter.py

@@ -76,7 +76,29 @@ class LangTraceExporter(SpanExporter):
         Returns:
             The result of the export SUCCESS or FAILURE
         """
-        if not self.api_key and not self.disable_logging:
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": self.api_key,
+            "User-Agent": "LangtraceExporter",
+        }
+
+        # Check if the OTEL_EXPORTER_OTLP_HEADERS environment variable is set
+        otel_headers = os.getenv("OTEL_EXPORTER_OTLP_HEADERS", None)
+        if otel_headers:
+            # Parse and add to headers
+            for header in otel_headers.split(","):
+                key, value = header.split("=")
+                headers[key.strip()] = value.strip()
+
+        # Check if the OTEL_EXPORTER_OTLP_TRACES_HEADERS environment variable is set
+        otel_traces_headers = os.getenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS", None)
+        if otel_traces_headers:
+            # Parse and add to headers
+            for header in otel_traces_headers.split(","):
+                key, value = header.split("=")
+                headers[key.strip()] = value.strip()
+
+        if not headers["x-api-key"] and not self.disable_logging:
             print(Fore.RED)
             print(
                 "Missing Langtrace API key, proceed to https://langtrace.ai to create one"
@@ -101,11 +123,7 @@ class LangTraceExporter(SpanExporter):
             response = requests.post(
                 url=f"{self.api_host}",
                 data=json.dumps(data),
-                headers={
-                    "Content-Type": "application/json",
-                    "x-api-key": self.api_key,
-                    "User-Agent": "LangtraceExporter",
-                },
+                headers=headers,
                 timeout=20,
             )
 
@@ -113,14 +131,34 @@ class LangTraceExporter(SpanExporter):
                 raise RequestException(response.text)
             if not self.disable_logging:
                 print(
-                    Fore.GREEN + f"Exported {len(spans)} spans successfully." + Fore.RESET
+                    Fore.GREEN
+                    + f"Exported {len(spans)} spans successfully."
+                    + Fore.RESET
                 )
             return SpanExportResult.SUCCESS
         except RequestException as err:
             if not self.disable_logging:
                 print(Fore.RED + "Failed to export spans.")
-                print(Fore.RED + f"Error: {err}" + Fore.RESET)
+                print(Fore.RED + f"Error: {err}\r\n" + Fore.RESET)
+                if (
+                    "invalid api key" in str(err).lower()
+                    and self.api_host == f"{LANGTRACE_REMOTE_URL}/api/trace"
+                ):
+                    print(
+                        Fore.YELLOW
+                        + "If you're self-hosting Langtrace, make sure to do one of the following to configure your trace endpoint (e.g., http://localhost:3000/api/trace):"
+                        + Fore.YELLOW
+                    )
+                    print(
+                        Fore.YELLOW
+                        + "1. Set the `LANGTRACE_API_HOST` environment variable, or\r\n2. Pass the `api_host` parameter to the `langtrace.init()` method.\r\n"
+                        + Fore.YELLOW
+                    )
             return SpanExportResult.FAILURE
 
     def shutdown(self) -> None:
-        print(Fore.WHITE + "⭐ Leave our github a star to stay on top of our updates - https://github.com/Scale3-Labs/langtrace" + Fore.RESET)
+        print(
+            Fore.WHITE
+            + "⭐ Leave our github a star to stay on top of our updates - https://github.com/Scale3-Labs/langtrace"
+            + Fore.RESET
+        )

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/instrumentation/crewai/instrumentation.py

@@ -19,7 +19,7 @@ from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper as _W
 from typing import Collection
 from importlib_metadata import version as v
-from .patch import patch_crew
+from .patch import patch_crew, patch_memory
 
 
 class CrewAIInstrumentation(BaseInstrumentor):
@@ -49,7 +49,23 @@ class CrewAIInstrumentation(BaseInstrumentor):
                 "Task.execute_sync",
                 patch_crew("Task.execute", version, tracer),
             )
-        except Exception as e:
+            _W(
+                "crewai.memory.storage.rag_storage",
+                "RAGStorage.save",
+                patch_memory("RAGStorage.save", version, tracer),
+            )
+            _W(
+                "crewai.memory.storage.rag_storage",
+                "RAGStorage.search",
+                patch_memory("RAGStorage.search", version, tracer),
+            )
+            _W(
+                "crewai.memory.storage.rag_storage",
+                "RAGStorage.reset",
+                patch_memory("RAGStorage.reset", version, tracer),
+            )
+        # pylint: disable=broad-except
+        except Exception:
             pass
 
     def _uninstrument(self, **kwargs):

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/instrumentation/crewai/patch.py

@@ -11,82 +11,56 @@ from opentelemetry import baggage
 from langtrace.trace_attributes import FrameworkSpanAttributes
 from opentelemetry.trace import SpanKind, Span, Tracer
 from opentelemetry.trace.status import Status, StatusCode
+from langtrace_python_sdk.utils.misc import serialize_args, serialize_kwargs
 
 
-crew_properties = {
-    "tasks": "object",
-    "agents": "object",
-    "cache": "bool",
-    "process": "object",
-    "verbose": "bool",
-    "memory": "bool",
-    "embedder": "json",
-    "full_output": "bool",
-    "manager_llm": "object",
-    "manager_agent": "object",
-    "manager_callbacks": "object",
-    "function_calling_llm": "object",
-    "config": "json",
-    "id": "object",
-    "max_rpm": "int",
-    "share_crew": "bool",
-    "step_callback": "object",
-    "task_callback": "object",
-    "prompt_file": "str",
-    "output_log_file": "bool",
-}
-
-task_properties = {
-    "id": "object",
-    "used_tools": "int",
-    "tools_errors": "int",
-    "delegations": "int",
-    "i18n": "object",
-    "thread": "object",
-    "prompt_context": "object",
-    "description": "str",
-    "expected_output": "str",
-    "config": "object",
-    "callback": "str",
-    "agent": "object",
-    "context": "object",
-    "async_execution": "bool",
-    "output_json": "object",
-    "output_pydantic": "object",
-    "output_file": "object",
-    "output": "object",
-    "tools": "object",
-    "human_input": "bool",
-}
-
-agent_properties = {
-    "formatting_errors": "int",
-    "id": "object",
-    "role": "str",
-    "goal": "str",
-    "backstory": "str",
-    "cache": "bool",
-    "config": "object",
-    "max_rpm": "int",
-    "verbose": "bool",
-    "allow_delegation": "bool",
-    "tools": "object",
-    "max_iter": "int",
-    "max_execution_time": "object",
-    "agent_executor": "object",
-    "tools_handler": "object",
-    "force_answer_max_iterations": "int",
-    "crew": "object",
-    "cache_handler": "object",
-    "step_callback": "object",
-    "i18n": "object",
-    "llm": "object",
-    "function_calling_llm": "object",
-    "callbacks": "object",
-    "system_template": "object",
-    "prompt_template": "object",
-    "response_template": "object",
-}
+def patch_memory(operation_name, version, tracer: Tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["CREWAI"]
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        inputs = {}
+        if len(args) > 0:
+            inputs["args"] = serialize_args(*args)
+        if len(kwargs) > 0:
+            inputs["kwargs"] = serialize_kwargs(**kwargs)
+        span_attributes["crewai.memory.storage.rag_storage.inputs"] = json.dumps(inputs)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            get_span_name(operation_name), kind=SpanKind.CLIENT
+        ) as span:
+
+            try:
+                set_span_attributes(span, attributes)
+                result = wrapped(*args, **kwargs)
+                if result is not None and len(result) > 0:
+                    set_span_attribute(span, "crewai.memory.storage.rag_storage.outputs", str(result))
+                if result:
+                    span.set_status(Status(StatusCode.OK))
+                span.end()
+                return result
+
+            except Exception as err:
+                # Record the exception in the span
+                span.record_exception(err)
+
+                # Set the span status to indicate an error
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
 
 
 def patch_crew(operation_name, version, tracer: Tracer):
@@ -161,25 +135,26 @@ class CrewAISpanAttributes:
         instance_name = self.instance.__class__.__name__
         if instance_name == "Crew":
             self.set_crew_attributes()
-            set_span_attribute(self.span, "crewai.crew.config", json.dumps(self.crew))
+            for key, value in self.crew.items():
+                key = f"crewai.crew.{key}"
+                set_span_attribute(self.span, key, value)
 
         elif instance_name == "Agent":
             agent = self.set_agent_attributes()
-            # for key, value in agent.items():
-            #     set_span_attribute(self.span, key, value)
-            set_span_attribute(self.span, "crewai.agent.config", json.dumps(agent))
+            for key, value in agent.items():
+                key = f"crewai.agent.{key}"
+                set_span_attribute(self.span, key, value)
+
         elif instance_name == "Task":
             task = self.set_task_attributes()
-            # uncomment if you want to spread attributes for the UI instead of dumping the whole object
-            # for key, value in task.items():
-            #     set_span_attribute(self.span, key, value)
-            set_span_attribute(self.span, "crewai.task.config", json.dumps(task))
+            for key, value in task.items():
+                key = f"crewai.task.{key}"
+                set_span_attribute(self.span, key, value)
 
     def set_crew_attributes(self):
         for key, value in self.instance.__dict__.items():
             if key == "tasks":
                 self._parse_tasks(value)
-
             elif key == "agents":
                 self._parse_agents(value)
             else:

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/instrumentation/embedchain/patch.py

@@ -52,6 +52,11 @@ def generic_patch(method, version, tracer):
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
+        if hasattr(instance, 'config') and isinstance(instance.config, object):
+            config_dict = instance.config.__dict__
+            if isinstance(config_dict, dict):
+                span_attributes["embedchain.config"] = json.dumps(config_dict)
+
         if len(args) > 0:
             span_attributes["embedchain.inputs"] = json.dumps(args)
 

langtrace_python_sdk-2.3.2/src/langtrace_python_sdk/instrumentation/langchain/instrumentation.py

@@ -0,0 +1,109 @@
+"""
+Copyright (c) 2024 Scale3 Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import importlib.metadata
+import logging
+from typing import Collection
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
+
+from langtrace_python_sdk.instrumentation.langchain.patch import generic_patch
+
+logging.basicConfig(level=logging.FATAL)
+
+
+# def patch_module_classes(
+#     module_name, tracer, version, task, trace_output=True, trace_input=True
+# ):
+#     """
+#     Generic function to patch all public methods of all classes in a given module.
+
+#     Parameters:
+#     - module: The module object containing the classes to patch.
+#     - module_name: The name of the module, used in the prefix for `wrap_function_wrapper`.
+#     - tracer: The tracer object used in `generic_patch`.
+#     - version: The version parameter used in `generic_patch`.
+#     - task: The name used to identify the type of task in `generic_patch`.
+#     - exclude_private: Whether to exclude private methods (those starting with '_').
+#     - trace_output: Whether to trace the output of the patched methods.
+#     - trace_input: Whether to trace the input of the patched methods.
+#     """
+#     # import the module
+#     module = importlib.import_module(module_name)
+#     # loop through all public classes in the module
+#     for name, obj in inspect.getmembers(
+#         module,
+#         lambda member: inspect.isclass(member) and member.__module__ == module.__name__,
+#     ):
+#         # loop through all public methods of the class
+#         for method_name, _ in inspect.getmembers(obj, predicate=inspect.isfunction):
+#             # Skip private methods
+#             if method_name.startswith("_"):
+#                 continue
+#             try:
+#                 method_path = f"{name}.{method_name}"
+#                 wrap_function_wrapper(
+#                     module_name,
+#                     method_path,
+#                     generic_patch(
+#                         method_path, task, tracer, version, trace_output, trace_input
+#                     ),
+#                 )
+#             # pylint: disable=broad-except
+#             except Exception:
+#                 pass
+
+
+class LangchainInstrumentation(BaseInstrumentor):
+    """
+    Instrumentor for langchain.
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["langchain >= 0.1.9"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version("langchain")
+
+        wrap_function_wrapper(
+            "langchain.agents.agent",
+            "RunnableAgent.plan",
+            generic_patch(
+                "RunnableAgent.plan", "plan", tracer, version, True, True
+            ),
+        )
+
+        wrap_function_wrapper(
+            "langchain.agents.agent",
+            "RunnableAgent.aplan",
+            generic_patch(
+                "RunnableAgent.aplan", "plan", tracer, version, True, True
+            ),
+        )
+
+        # modules_to_patch = []
+
+        # for module_name, task, trace_output, trace_input in modules_to_patch:
+        #     patch_module_classes(
+        #         module_name, tracer, version, task, trace_output, trace_input
+        #     )
+
+    def _uninstrument(self, **kwargs):
+        pass

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/instrumentation/langchain/patch.py

@@ -29,6 +29,7 @@ from langtrace_python_sdk.constants.instrumentation.common import (
     SERVICE_PROVIDERS,
 )
 from importlib_metadata import version as v
+from langtrace_python_sdk.utils.misc import serialize_args, serialize_kwargs
 
 
 def generic_patch(
@@ -52,8 +53,12 @@ def generic_patch(
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
+        inputs = {}
         if len(args) > 0 and trace_input:
-            span_attributes["langchain.inputs"] = to_json_string(args)
+            inputs["args"] = serialize_args(*args)
+        if len(kwargs) > 0 and trace_input:
+            inputs["kwargs"] = serialize_kwargs(**kwargs)
+        span_attributes["langchain.inputs"] = json.dumps(inputs)
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/instrumentation/langchain_core/instrumentation.py

@@ -114,6 +114,8 @@ class LangchainCoreInstrumentation(BaseInstrumentor):
             "format",
             "format_messages",
             "format_prompt",
+            "transform",
+            "stream",
             "__or__",
             "__init__",
             "__repr__",

{langtrace_python_sdk-2.3.0 → langtrace_python_sdk-2.3.2}/src/langtrace_python_sdk/langtrace.py

@@ -80,11 +80,19 @@ def init(
         sys.stdout = open(os.devnull, "w")
 
     host = (
-        os.environ.get("LANGTRACE_API_HOST", None) or api_host or LANGTRACE_REMOTE_URL
+        os.environ.get("LANGTRACE_API_HOST", None)
+        or os.environ.get("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", None)
+        or os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT", None)
+        or api_host
+        or LANGTRACE_REMOTE_URL
     )
     check_if_sdk_is_outdated()
     print(Fore.GREEN + "Initializing Langtrace SDK.." + Fore.RESET)
-    print(Fore.WHITE + "⭐ Leave our github a star to stay on top of our updates - https://github.com/Scale3-Labs/langtrace" + Fore.RESET)
+    print(
+        Fore.WHITE
+        + "⭐ Leave our github a star to stay on top of our updates - https://github.com/Scale3-Labs/langtrace"
+        + Fore.RESET
+    )
     sampler = LangtraceSampler(disabled_methods=disable_tracing_for_functions)
     resource = Resource.create(
         attributes={

langtrace_python_sdk-2.3.2/src/langtrace_python_sdk/utils/misc.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+import json
+
+
+def extract_input_params(args, kwargs):
+    extracted_params = {}
+    for key, value in kwargs.items():
+        if hasattr(value, "__dict__"):
+            extracted_params[key] = json.dumps(vars(value))
+        else:
+            extracted_params[key] = value
+    for i, value in enumerate(args):
+        if hasattr(value, "__dict__"):
+            extracted_params[f"arg{i}"] = json.dumps(vars(value))
+        else:
+            extracted_params[f"arg{i}"] = value
+    # Remove None values
+    return {k: v for k, v in extracted_params.items() if v is not None}
+
+
+def to_iso_format(value):
+    return (
+        None
+        if value is None
+        else (
+            value.isoformat(timespec="microseconds") + "Z"
+            if isinstance(value, datetime)
+            else None
+        )
+    )
+
+
+def serialize_kwargs(**kwargs):
+    # Function to check if a value is serializable
+    def is_serializable(value):
+        try:
+            json.dumps(value)
+            return True
+        except (TypeError, ValueError):
+            return False
+
+    # Filter out non-serializable items
+    serializable_kwargs = {k: v for k, v in kwargs.items() if is_serializable(v)}
+
+    # Convert to string representation
+    return json.dumps(serializable_kwargs)
+
+
+def serialize_args(*args):
+    # Function to check if a value is serializable
+    def is_serializable(value):
+        try:
+            json.dumps(value)
+            return True
+        except (TypeError, ValueError):
+            return False
+
+    # Filter out non-serializable items
+    serializable_args = [arg for arg in args if is_serializable(arg)]
+
+    # Convert to string representation
+    return json.dumps(serializable_args)

langtrace_python_sdk-2.3.2/src/langtrace_python_sdk/version.py

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

langtrace_python_sdk-2.3.0/src/langtrace_python_sdk/instrumentation/langchain/instrumentation.py

@@ -1,96 +0,0 @@
-"""
-Copyright (c) 2024 Scale3 Labs
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-import importlib.metadata
-import inspect
-import logging
-from typing import Collection
-
-from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-from opentelemetry.trace import get_tracer
-from wrapt import wrap_function_wrapper
-
-from langtrace_python_sdk.instrumentation.langchain.patch import generic_patch
-
-logging.basicConfig(level=logging.FATAL)
-
-
-def patch_module_classes(
-    module_name, tracer, version, task, trace_output=True, trace_input=True
-):
-    """
-    Generic function to patch all public methods of all classes in a given module.
-
-    Parameters:
-    - module: The module object containing the classes to patch.
-    - module_name: The name of the module, used in the prefix for `wrap_function_wrapper`.
-    - tracer: The tracer object used in `generic_patch`.
-    - version: The version parameter used in `generic_patch`.
-    - task: The name used to identify the type of task in `generic_patch`.
-    - exclude_private: Whether to exclude private methods (those starting with '_').
-    - trace_output: Whether to trace the output of the patched methods.
-    - trace_input: Whether to trace the input of the patched methods.
-    """
-    # import the module
-    module = importlib.import_module(module_name)
-    # loop through all public classes in the module
-    for name, obj in inspect.getmembers(
-        module,
-        lambda member: inspect.isclass(member) and member.__module__ == module.__name__,
-    ):
-        # loop through all public methods of the class
-        for method_name, _ in inspect.getmembers(obj, predicate=inspect.isfunction):
-            # Skip private methods
-            if method_name.startswith("_"):
-                continue
-            try:
-                method_path = f"{name}.{method_name}"
-                wrap_function_wrapper(
-                    module_name,
-                    method_path,
-                    generic_patch(
-                        method_path, task, tracer, version, trace_output, trace_input
-                    ),
-                )
-            # pylint: disable=broad-except
-            except Exception:
-                pass
-
-
-class LangchainInstrumentation(BaseInstrumentor):
-    """
-    Instrumentor for langchain.
-    """
-
-    def instrumentation_dependencies(self) -> Collection[str]:
-        return ["langchain >= 0.1.9"]
-
-    def _instrument(self, **kwargs):
-        tracer_provider = kwargs.get("tracer_provider")
-        tracer = get_tracer(__name__, "", tracer_provider)
-        version = importlib.metadata.version("langchain")
-
-        modules_to_patch = [
-            ("langchain.text_splitter", "split_text", True, True),
-        ]
-
-        for module_name, task, trace_output, trace_input in modules_to_patch:
-            patch_module_classes(
-                module_name, tracer, version, task, trace_output, trace_input
-            )
-
-    def _uninstrument(self, **kwargs):
-        pass