lmnr 0.4.53.dev0__py3-none-any.whl → 0.7.26__py3-none-any.whl

lmnr/opentelemetry_lib/opentelemetry/instrumentation/kernel/utils.py

@@ -0,0 +1,36 @@
+# import base64
+import base64
+from copy import deepcopy
+from typing import Any
+
+from lmnr.sdk.utils import json_dumps
+from pydantic import BaseModel
+
+
+def screenshot_tool_output_formatter(output: Any) -> str:
+    # output is of type BinaryAPIResponse, which implements
+    # the iter_bytes method from httpx.Response
+
+    return "<BINARY_BLOB_SCREENSHOT>"
+    # The below implementation works, but it may consume the entire iterator,
+    # making the response unusable after the formatter is called.
+    # This is UNLESS somewhere in code output.read() (httpx.Response.read())
+    # is called.
+    # We cannot rely on that now, so we return a placeholder.
+    # response_bytes = []
+    # for chunk in output.iter_bytes():
+    #     response_bytes.append(chunk)
+    # response_base64 = base64.b64encode(response_bytes).decode("utf-8")
+    # return f"data:image/png;base64,{response_base64}"
+
+
+def process_tool_output_formatter(output: Any) -> str:
+    if not isinstance(output, (dict, BaseModel)):
+        return json_dumps(output)
+
+    output = output.model_dump() if isinstance(output, BaseModel) else deepcopy(output)
+    if "stderr_b64" in output:
+        output["stderr"] = base64.b64decode(output["stderr_b64"]).decode("utf-8")
+    if "stdout_b64" in output:
+        output["stdout"] = base64.b64decode(output["stdout_b64"]).decode("utf-8")
+    return json_dumps(output)

lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/__init__.py

@@ -0,0 +1,121 @@
+"""OpenTelemetry Langgraph instrumentation"""
+
+import json
+import logging
+from typing import Collection
+
+from .utils import (
+    with_tracer_wrapper,
+)
+
+from langchain_core.runnables.graph import Graph
+from opentelemetry.trace import Tracer
+from wrapt import wrap_function_wrapper
+from opentelemetry.trace import get_tracer
+from opentelemetry.context import get_value, attach, set_value
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+
+
+logger = logging.getLogger(__name__)
+
+_instruments = ("langgraph >= 0.1.0",)
+
+
+@with_tracer_wrapper
+def wrap_pregel_stream(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
+    graph: Graph = instance.get_graph()
+    nodes = [
+        {
+            "id": node.id,
+            "name": node.name,
+            "metadata": node.metadata,
+        }
+        for node in graph.nodes.values()
+    ]
+    edges = [
+        {
+            "source": edge.source,
+            "target": edge.target,
+            "conditional": edge.conditional,
+        }
+        for edge in graph.edges
+    ]
+    d = {
+        "langgraph.edges": json.dumps(edges),
+        "langgraph.nodes": json.dumps(nodes),
+    }
+    association_properties = get_value("lmnr.langgraph.graph") or {}
+    association_properties.update(d)
+    attach(set_value("lmnr.langgraph.graph", association_properties))
+    return wrapped(*args, **kwargs)
+
+
+@with_tracer_wrapper
+async def async_wrap_pregel_stream(
+    tracer: Tracer, to_wrap, wrapped, instance, args, kwargs
+):
+    graph: Graph = await instance.aget_graph()
+    nodes = [
+        {
+            "id": node.id,
+            "name": node.name,
+            "metadata": node.metadata,
+        }
+        for node in graph.nodes.values()
+    ]
+    edges = [
+        {
+            "source": edge.source,
+            "target": edge.target,
+            "conditional": edge.conditional,
+        }
+        for edge in graph.edges
+    ]
+
+    d = {
+        "langgraph.edges": json.dumps(edges),
+        "langgraph.nodes": json.dumps(nodes),
+    }
+    association_properties = get_value("lmnr.langgraph.graph") or {}
+    association_properties.update(d)
+    attach(set_value("lmnr.langgraph.graph", association_properties))
+
+    async for item in wrapped(*args, **kwargs):
+        yield item
+
+
+class LanggraphInstrumentor(BaseInstrumentor):
+    """An instrumentor for Langgraph."""
+
+    def __init__(self):
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "0.0.1a0", tracer_provider)
+
+        wrap_function_wrapper(
+            module="langgraph.pregel",
+            name="Pregel.stream",
+            wrapper=wrap_pregel_stream(tracer, "Pregel.stream"),
+        )
+        wrap_function_wrapper(
+            module="langgraph.pregel",
+            name="Pregel.astream",
+            wrapper=async_wrap_pregel_stream(tracer, "Pregel.astream"),
+        )
+
+    def _uninstrument(self, **kwargs):
+        unwrap(
+            module="langgraph.pregel",
+            name="Pregel.stream",
+        )
+        unwrap(
+            module="langgraph.pregel",
+            name="Pregel.astream",
+        )

lmnr/opentelemetry_lib/opentelemetry/instrumentation/langgraph/utils.py

@@ -0,0 +1,60 @@
+import logging
+import traceback
+
+import pydantic
+from opentelemetry.trace import Span
+from typing import Any
+
+
+def set_span_attribute(span: Span, name: str, value: str):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            logger.debug(
+                "Laminar failed to trace in %s, error: %s",
+                func.__name__,
+                traceback.format_exc(),
+            )
+
+    return wrapper
+
+
+def to_dict(obj: pydantic.BaseModel | dict) -> dict[str, Any]:
+    try:
+        if isinstance(obj, pydantic.BaseModel):
+            return obj.model_dump()
+        elif isinstance(obj, dict):
+            return obj
+        else:
+            return dict(obj)
+    except Exception:
+        return dict(obj)
+
+
+def with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    def _with_tracer(tracer, to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer

lmnr/opentelemetry_lib/opentelemetry/instrumentation/openai/__init__.py

@@ -0,0 +1,61 @@
+"""
+Initially copied over from openllmetry, commit
+b3a18c9f7e6ff2368c8fb0bc35fd9123f11121c4
+"""
+
+from typing import Callable, Collection, Optional
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from .shared.config import Config
+from .utils import is_openai_v1
+from typing_extensions import Coroutine
+
+_instruments = ("openai >= 0.27.0",)
+
+
+class OpenAIInstrumentor(BaseInstrumentor):
+    """An instrumentor for OpenAI's client library."""
+
+    def __init__(
+        self,
+        enrich_assistant: bool = False,
+        enrich_token_usage: bool = False,
+        exception_logger=None,
+        get_common_metrics_attributes: Callable[[], dict] = lambda: {},
+        upload_base64_image: Optional[
+            Callable[[str, str, str, str], Coroutine[None, None, str]]
+        ] = lambda *args: "",
+        enable_trace_context_propagation: bool = True,
+        use_legacy_attributes: bool = True,
+    ):
+        super().__init__()
+        Config.enrich_assistant = enrich_assistant
+        Config.enrich_token_usage = enrich_token_usage
+        Config.exception_logger = exception_logger
+        Config.get_common_metrics_attributes = get_common_metrics_attributes
+        Config.upload_base64_image = upload_base64_image
+        Config.enable_trace_context_propagation = enable_trace_context_propagation
+        Config.use_legacy_attributes = use_legacy_attributes
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        if is_openai_v1():
+            from .v1 import OpenAIV1Instrumentor
+
+            OpenAIV1Instrumentor().instrument(**kwargs)
+        else:
+            from .v0 import OpenAIV0Instrumentor
+
+            OpenAIV0Instrumentor().instrument(**kwargs)
+
+    def _uninstrument(self, **kwargs):
+        if is_openai_v1():
+            from .v1 import OpenAIV1Instrumentor
+
+            OpenAIV1Instrumentor().uninstrument(**kwargs)
+        else:
+            from .v0 import OpenAIV0Instrumentor
+
+            OpenAIV0Instrumentor().uninstrument(**kwargs)