opentelemetry-instrumentation-llamaindex 0.9.3__tar.gz → 0.49.1__tar.gz

{opentelemetry_instrumentation_llamaindex-0.9.3 → opentelemetry_instrumentation_llamaindex-0.49.1}/PKG-INFO

@@ -1,21 +1,27 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-llamaindex
-Version: 0.9.3
+Version: 0.49.1
 Summary: OpenTelemetry LlamaIndex instrumentation
 License: Apache-2.0
 Author: Gal Kleinman
 Author-email: gal@traceloop.com
-Requires-Python: >=3.8.1,<4
+Requires-Python: >=3.9,<4
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: instruments
+Provides-Extra: llamaparse
 Requires-Dist: inflection (>=0.5.1,<0.6.0)
-Requires-Dist: opentelemetry-api (>=1.22.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (==0.43b0)
-Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.0.14,<0.0.15)
+Requires-Dist: opentelemetry-api (>=1.38.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.13,<0.5.0)
+Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-llamaindex
 Description-Content-Type: text/markdown
 
 # OpenTelemetry LlamaIndex Instrumentation
@@ -32,6 +38,14 @@ This library allows tracing complete LLM applications built with [LlamaIndex](ht
 pip install opentelemetry-instrumentation-llamaindex
 ```
 
+## Example usage
+
+```python
+from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor
+
+LlamaIndexInstrumentor().instrument()
+```
+
 ## Privacy
 
 **By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

{opentelemetry_instrumentation_llamaindex-0.9.3 → opentelemetry_instrumentation_llamaindex-0.49.1}/README.md

@@ -12,6 +12,14 @@ This library allows tracing complete LLM applications built with [LlamaIndex](ht
 pip install opentelemetry-instrumentation-llamaindex
 ```
 
+## Example usage
+
+```python
+from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor
+
+LlamaIndexInstrumentor().instrument()
+```
+
 ## Privacy
 
 **By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/__init__.py

@@ -0,0 +1,134 @@
+"""OpenTelemetry LlamaIndex instrumentation"""
+
+import logging
+from importlib.metadata import version as import_version
+from typing import Collection
+
+from opentelemetry._logs import get_logger
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.llamaindex.base_agent_instrumentor import (
+    BaseAgentInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.base_embedding_instrumentor import (
+    BaseEmbeddingInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.base_retriever_instrumentor import (
+    BaseRetrieverInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.base_synthesizer_instrumentor import (
+    BaseSynthesizerInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.base_tool_instrumentor import (
+    BaseToolInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.config import Config
+from opentelemetry.instrumentation.llamaindex.custom_llm_instrumentor import (
+    CustomLLMInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.dispatcher_wrapper import (
+    instrument_with_dispatcher,
+)
+from opentelemetry.instrumentation.llamaindex.llamaparse_instrumentor import (
+    LlamaParseInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.query_pipeline_instrumentor import (
+    QueryPipelineInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.retriever_query_engine_instrumentor import (
+    RetrieverQueryEngineInstrumentor,
+)
+from opentelemetry.instrumentation.llamaindex.version import __version__
+from opentelemetry.trace import get_tracer
+
+logger = logging.getLogger(__name__)
+
+_core_instruments = ("llama-index-core >= 0.7.0",)
+_full_instruments = ("llama-index >= 0.7.0",)
+
+
+class LlamaIndexInstrumentor(BaseInstrumentor):
+    """An instrumentor for both: core and legacy LlamaIndex SDK."""
+
+    def __init__(self, exception_logger=None, use_legacy_attributes=True):
+        self.legacy = LlamaIndexInstrumentorFull(exception_logger)
+        self.core = LlamaIndexInstrumentorCore(exception_logger)
+        Config.use_legacy_attributes = use_legacy_attributes
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ()
+
+    def _instrument(self, **kwargs):
+        # Try to use the legacy entry point for instrumentation
+        if self.legacy._check_dependency_conflicts() is None:
+            self.legacy.instrument(**kwargs)
+        if not self.legacy._is_instrumented_by_opentelemetry:
+            # it didn't work -> try the new package
+            if self.core._check_dependency_conflicts() is None:
+                self.core.instrument(**kwargs)
+
+    def _uninstrument(self, **kwargs):
+        self.legacy.uninstrument(**kwargs)
+        self.core.uninstrument(**kwargs)
+
+    @staticmethod
+    def apply_instrumentation(name, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        if not Config.use_legacy_attributes:
+            logger_provider = kwargs.get("logger_provider")
+            Config.event_logger = get_logger(
+                __name__, __version__, logger_provider=logger_provider
+            )
+
+        if import_version(name) >= "0.10.20":
+            instrument_with_dispatcher(tracer)
+        else:
+            RetrieverQueryEngineInstrumentor(tracer).instrument()
+            BaseRetrieverInstrumentor(tracer).instrument()
+            BaseSynthesizerInstrumentor(tracer).instrument()
+            BaseEmbeddingInstrumentor(tracer).instrument()
+            CustomLLMInstrumentor(tracer).instrument()
+            QueryPipelineInstrumentor(tracer).instrument()
+            BaseAgentInstrumentor(tracer).instrument()
+            BaseToolInstrumentor(tracer).instrument()
+
+        # LlamaParse instrumentation doesn't work for all versions
+        try:
+            LlamaParseInstrumentor(tracer).instrument()
+        except Exception:
+            pass
+
+
+class LlamaIndexInstrumentorCore(BaseInstrumentor):
+    """An instrumentor for core LlamaIndex SDK."""
+
+    def __init__(self, exception_logger=None):
+        super().__init__()
+        Config.exception_logger = exception_logger
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _core_instruments
+
+    def _instrument(self, **kwargs):
+        LlamaIndexInstrumentor.apply_instrumentation("llama-index-core", **kwargs)
+
+    def _uninstrument(self, **kwargs):
+        pass
+
+
+class LlamaIndexInstrumentorFull(BaseInstrumentor):
+    """An instrumentor for legacy LlamaIndex SDK."""
+
+    def __init__(self, exception_logger=None):
+        super().__init__()
+        Config.exception_logger = exception_logger
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _full_instruments
+
+    def _instrument(self, **kwargs):
+        LlamaIndexInstrumentor.apply_instrumentation("llama-index", **kwargs)
+
+    def _uninstrument(self, **kwargs):
+        pass

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/base_agent_instrumentor.py

@@ -0,0 +1,80 @@
+from importlib.metadata import version as package_version, PackageNotFoundError
+
+from wrapt import wrap_function_wrapper
+
+from opentelemetry.instrumentation.llamaindex.utils import (
+    _with_tracer_wrapper,
+    process_request,
+    process_response,
+    start_as_current_span_async,
+)
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+
+
+TO_INSTRUMENT = [
+    {
+        "class": "AgentRunner",
+        "v10_module": "llama_index.core.agent.runner.base",
+        "v10_legacy_module": "llama_index.legacy.agent.runner.base",
+    },
+    {
+        "class": "OpenAIAssistantAgent",
+        "v10_module": "llama_index.agent.openai.openai_assistant_agent",
+        "v10_legacy_module": "llama_index.legacy.agent.openai_assistant_agent",
+    },
+]
+
+
+class BaseAgentInstrumentor:
+    def __init__(self, tracer):
+        self._tracer = tracer
+
+    def instrument(self):
+        for module in TO_INSTRUMENT:
+            try:
+                package_version("llama-index-core")
+                self._instrument_module(module["v10_module"], module["class"])
+                self._instrument_module(module["v10_legacy_module"], module["class"])
+
+            except PackageNotFoundError:
+                pass  # not supported before v10
+
+    def _instrument_module(self, module_name, class_name):
+        wrap_function_wrapper(
+            module_name, f"{class_name}.chat", query_wrapper(self._tracer)
+        )
+        wrap_function_wrapper(
+            module_name, f"{class_name}.achat", aquery_wrapper(self._tracer)
+        )
+
+
+@_with_tracer_wrapper
+def query_wrapper(tracer, wrapped, instance, args, kwargs):
+    name = instance.__class__.__name__
+    with tracer.start_as_current_span(f"{name}.agent") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.AGENT.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
+
+        process_request(span, args, kwargs)
+        res = wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res
+
+
+@_with_tracer_wrapper
+async def aquery_wrapper(tracer, wrapped, instance, args, kwargs):
+    name = instance.__class__.__name__
+    async with start_as_current_span_async(tracer=tracer, name=f"{name}.agent") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.AGENT.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
+
+        process_request(span, args, kwargs)
+        res = await wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/base_embedding_instrumentor.py

@@ -0,0 +1,68 @@
+from importlib.metadata import version as package_version, PackageNotFoundError
+
+from wrapt import wrap_function_wrapper
+
+from opentelemetry.instrumentation.llamaindex.utils import (
+    _with_tracer_wrapper,
+    start_as_current_span_async,
+)
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+
+V9_MODULE_NAME = "llama_index.embeddings.base"
+V10_MODULE_NAME = "llama_index.core.embeddings"
+V10_LEGACY_MODULE_NAME = "llama_index.legacy.embeddings.base"
+
+CLASS_NAME = "BaseEmbedding"
+TASK_NAME = "get_query_embedding"
+
+
+class BaseEmbeddingInstrumentor:
+    def __init__(self, tracer):
+        self._tracer = tracer
+
+    def instrument(self):
+        try:
+            package_version("llama-index-core")
+            self._instrument_module(V10_MODULE_NAME)
+            self._instrument_module(V10_LEGACY_MODULE_NAME)
+
+        except PackageNotFoundError:
+            self._instrument_module(V9_MODULE_NAME)
+
+    def _instrument_module(self, module_name):
+        wrap_function_wrapper(
+            module_name,
+            f"{CLASS_NAME}.get_query_embedding",
+            get_query_embedding_wrapper(self._tracer),
+        )
+        wrap_function_wrapper(
+            module_name,
+            f"{CLASS_NAME}.aget_query_embedding",
+            aget_query_embedding_wrapper(self._tracer),
+        )
+
+
+@_with_tracer_wrapper
+def get_query_embedding_wrapper(tracer, wrapped, instance, args, kwargs):
+    with tracer.start_as_current_span(f"{TASK_NAME}.task") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TASK.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, TASK_NAME)
+
+        return wrapped(*args, **kwargs)
+
+
+@_with_tracer_wrapper
+async def aget_query_embedding_wrapper(tracer, wrapped, instance, args, kwargs):
+    async with start_as_current_span_async(
+        tracer=tracer, name=f"{TASK_NAME}.task"
+    ) as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TASK.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, TASK_NAME)
+
+        return await wrapped(*args, **kwargs)

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/base_retriever_instrumentor.py

@@ -0,0 +1,73 @@
+from importlib.metadata import version as package_version, PackageNotFoundError
+
+from wrapt import wrap_function_wrapper
+
+from opentelemetry.instrumentation.llamaindex.utils import (
+    _with_tracer_wrapper,
+    process_request,
+    process_response,
+    start_as_current_span_async,
+)
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+
+
+V9_MODULE_NAME = "llama_index.indices.base_retriever"
+V10_MODULE_NAME = "llama_index.core.indices.base_retriever"
+V10_LEGACY_MODULE_NAME = "llama_index.legacy.indices.base_retriever"
+
+CLASS_NAME = "BaseRetriever"
+TASK_NAME = "retrieve"
+
+
+class BaseRetrieverInstrumentor:
+    def __init__(self, tracer):
+        self._tracer = tracer
+
+    def instrument(self):
+        try:
+            package_version("llama-index-core")
+            self._instrument_module(V10_MODULE_NAME)
+            self._instrument_module(V10_LEGACY_MODULE_NAME)
+
+        except PackageNotFoundError:
+            self._instrument_module(V9_MODULE_NAME)
+
+    def _instrument_module(self, module_name):
+        wrap_function_wrapper(
+            module_name, f"{CLASS_NAME}.retrieve", retrieve_wrapper(self._tracer)
+        )
+        wrap_function_wrapper(
+            module_name, f"{CLASS_NAME}.aretrieve", aretrieve_wrapper(self._tracer)
+        )
+
+
+@_with_tracer_wrapper
+def retrieve_wrapper(tracer, wrapped, instance, args, kwargs):
+    with tracer.start_as_current_span(f"{TASK_NAME}.task") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TASK.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, TASK_NAME)
+
+        process_request(span, args, kwargs)
+        res = wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res
+
+
+@_with_tracer_wrapper
+async def aretrieve_wrapper(tracer, wrapped, instance, args, kwargs):
+    async with start_as_current_span_async(
+        tracer=tracer, name=f"{TASK_NAME}.task"
+    ) as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TASK.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, TASK_NAME)
+
+        process_request(span, args, kwargs)
+        res = await wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/base_synthesizer_instrumentor.py

@@ -0,0 +1,72 @@
+from importlib.metadata import version as package_version, PackageNotFoundError
+
+from wrapt import wrap_function_wrapper
+
+from opentelemetry.instrumentation.llamaindex.utils import (
+    _with_tracer_wrapper,
+    process_request,
+    process_response,
+    start_as_current_span_async,
+)
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+
+V9_MODULE_NAME = "llama_index.response_synthesizers"
+V10_MODULE_NAME = "llama_index.core.response_synthesizers"
+V10_LEGACY_MODULE_NAME = "llama_index.legacy.response_synthesizers.base"
+
+CLASS_NAME = "BaseSynthesizer"
+TASK_NAME = "synthesize"
+
+
+class BaseSynthesizerInstrumentor:
+    def __init__(self, tracer):
+        self._tracer = tracer
+
+    def instrument(self):
+        try:
+            package_version("llama-index-core")
+            self._instrument_module(V10_MODULE_NAME)
+            self._instrument_module(V10_LEGACY_MODULE_NAME)
+
+        except PackageNotFoundError:
+            self._instrument_module(V9_MODULE_NAME)
+
+    def _instrument_module(self, module_name):
+        wrap_function_wrapper(
+            module_name, f"{CLASS_NAME}.synthesize", synthesize_wrapper(self._tracer)
+        )
+        wrap_function_wrapper(
+            module_name, f"{CLASS_NAME}.asynthesize", asynthesize_wrapper(self._tracer)
+        )
+
+
+@_with_tracer_wrapper
+def synthesize_wrapper(tracer, wrapped, instance, args, kwargs):
+    with tracer.start_as_current_span(f"{TASK_NAME}.task") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TASK.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, TASK_NAME)
+
+        process_request(span, args, kwargs)
+        res = wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res
+
+
+@_with_tracer_wrapper
+async def asynthesize_wrapper(tracer, wrapped, instance, args, kwargs):
+    async with start_as_current_span_async(
+        tracer=tracer, name=f"{TASK_NAME}.task"
+    ) as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TASK.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, TASK_NAME)
+
+        process_request(span, args, kwargs)
+        res = await wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/base_tool_instrumentor.py

@@ -0,0 +1,82 @@
+from importlib.metadata import version as package_version, PackageNotFoundError
+
+from wrapt import wrap_function_wrapper
+
+from opentelemetry.instrumentation.llamaindex.utils import (
+    _with_tracer_wrapper,
+    process_request,
+    process_response,
+    start_as_current_span_async,
+)
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+
+
+TO_INSTRUMENT = [
+    {
+        "class": "FunctionTool",
+        "v9_module": "llama_index.tools.function_tool",
+        "v10_module": "llama_index.core.tools.function_tool",
+        "v10_legacy_module": "llama_index.legacy.tools.function_tool",
+    },
+    {
+        "class": "QueryEngineTool",
+        "v9_module": "llama_index.tools.query_engine",
+        "v10_module": "llama_index.core.tools.query_engine",
+        "v10_legacy_module": "llama_index.legacy.tools.query_engine",
+    },
+]
+
+
+class BaseToolInstrumentor:
+    def __init__(self, tracer):
+        self._tracer = tracer
+
+    def instrument(self):
+        for module in TO_INSTRUMENT:
+            try:
+                package_version("llama-index-core")
+                self._instrument_module(module["v10_module"], module["class"])
+                self._instrument_module(module["v10_legacy_module"], module["class"])
+
+            except PackageNotFoundError:
+                self._instrument_module(module["v9_module"], module["class"])
+
+    def _instrument_module(self, module_name, class_name):
+        wrap_function_wrapper(
+            module_name, f"{class_name}.call", query_wrapper(self._tracer)
+        )
+        wrap_function_wrapper(
+            module_name, f"{class_name}.acall", aquery_wrapper(self._tracer)
+        )
+
+
+@_with_tracer_wrapper
+def query_wrapper(tracer, wrapped, instance, args, kwargs):
+    name = instance.__class__.__name__
+    with tracer.start_as_current_span(f"{name}.tool") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TOOL.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
+
+        process_request(span, args, kwargs)
+        res = wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res
+
+
+@_with_tracer_wrapper
+async def aquery_wrapper(tracer, wrapped, instance, args, kwargs):
+    name = instance.__class__.__name__
+    async with start_as_current_span_async(tracer=tracer, name=f"{name}.tool") as span:
+        span.set_attribute(
+            SpanAttributes.TRACELOOP_SPAN_KIND,
+            TraceloopSpanKindValues.TOOL.value,
+        )
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, name)
+
+        process_request(span, args, kwargs)
+        res = await wrapped(*args, **kwargs)
+        process_response(span, res)
+        return res

opentelemetry_instrumentation_llamaindex-0.49.1/opentelemetry/instrumentation/llamaindex/config.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+from opentelemetry._logs import Logger
+
+
+class Config:
+    exception_logger = None
+    use_legacy_attributes = True
+    event_logger: Optional[Logger] = None