opentelemetry-instrumentation-llamaindex 0.40.14__tar.gz → 0.42.0__tar.gz

{opentelemetry_instrumentation_llamaindex-0.40.14 → opentelemetry_instrumentation_llamaindex-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation-llamaindex
-Version: 0.40.14
+Version: 0.42.0
 Summary: OpenTelemetry LlamaIndex instrumentation
 License: Apache-2.0
 Author: Gal Kleinman
@@ -14,11 +14,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: instruments
+Provides-Extra: llamaparse
 Requires-Dist: inflection (>=0.5.1,<0.6.0)
 Requires-Dist: opentelemetry-api (>=1.28.0,<2.0.0)
 Requires-Dist: opentelemetry-instrumentation (>=0.50b0)
 Requires-Dist: opentelemetry-semantic-conventions (>=0.50b0)
-Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.9)
+Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.11)
 Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-llamaindex
 Description-Content-Type: text/markdown
 

{opentelemetry_instrumentation_llamaindex-0.40.14 → opentelemetry_instrumentation_llamaindex-0.42.0}/opentelemetry/instrumentation/llamaindex/__init__.py

@@ -4,16 +4,13 @@ import logging
 from importlib.metadata import version as import_version
 from typing import Collection
 
-from opentelemetry.instrumentation.llamaindex.config import Config
-from opentelemetry.trace import get_tracer
-
+from opentelemetry._events import get_event_logger
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-
 from opentelemetry.instrumentation.llamaindex.base_agent_instrumentor import (
     BaseAgentInstrumentor,
 )
-from opentelemetry.instrumentation.llamaindex.retriever_query_engine_instrumentor import (
-    RetrieverQueryEngineInstrumentor,
+from opentelemetry.instrumentation.llamaindex.base_embedding_instrumentor import (
+    BaseEmbeddingInstrumentor,
 )
 from opentelemetry.instrumentation.llamaindex.base_retriever_instrumentor import (
     BaseRetrieverInstrumentor,
@@ -24,30 +21,38 @@ from opentelemetry.instrumentation.llamaindex.base_synthesizer_instrumentor impo
 from opentelemetry.instrumentation.llamaindex.base_tool_instrumentor import (
     BaseToolInstrumentor,
 )
-from opentelemetry.instrumentation.llamaindex.base_embedding_instrumentor import (
-    BaseEmbeddingInstrumentor,
-)
+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.instrumentation.llamaindex.dispatcher_wrapper import instrument_with_dispatcher
+from opentelemetry.trace import get_tracer
 
 logger = logging.getLogger(__name__)
 
-_core_instruments = ("llama-index-core >= 0.7.0", )
+_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):
+    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 ()
@@ -70,6 +75,12 @@ class LlamaIndexInstrumentor(BaseInstrumentor):
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
 
+        if not Config.use_legacy_attributes:
+            event_logger_provider = kwargs.get("event_logger_provider")
+            Config.event_logger = get_event_logger(
+                __name__, __version__, event_logger_provider=event_logger_provider
+            )
+
         if import_version(name) >= "0.10.20":
             instrument_with_dispatcher(tracer)
         else:
@@ -82,6 +93,12 @@ class LlamaIndexInstrumentor(BaseInstrumentor):
             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."""

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

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

{opentelemetry_instrumentation_llamaindex-0.40.14 → opentelemetry_instrumentation_llamaindex-0.42.0}/opentelemetry/instrumentation/llamaindex/dispatcher_wrapper.py

@@ -1,20 +1,22 @@
-from functools import singledispatchmethod
 import inspect
 import json
 import re
-from typing import Any, AsyncGenerator, Dict, Generator, List, Optional
 from dataclasses import dataclass, field
+from functools import singledispatchmethod
+from typing import Any, AsyncGenerator, Dict, Generator, List, Optional
 
-from llama_index.core.bridge.pydantic import PrivateAttr
-from llama_index.core.base.llms.types import MessageRole
 from llama_index.core.base.response.schema import StreamingResponse
+from llama_index.core.bridge.pydantic import PrivateAttr
 from llama_index.core.instrumentation import get_dispatcher
+from llama_index.core.instrumentation.event_handlers import BaseEventHandler
 from llama_index.core.instrumentation.events import BaseEvent
 from llama_index.core.instrumentation.events.agent import AgentToolCallEvent
-from llama_index.core.instrumentation.events.embedding import EmbeddingStartEvent
 from llama_index.core.instrumentation.events.chat_engine import (
     StreamChatEndEvent,
 )
+from llama_index.core.instrumentation.events.embedding import (
+    EmbeddingStartEvent,
+)
 from llama_index.core.instrumentation.events.llm import (
     LLMChatEndEvent,
     LLMChatStartEvent,
@@ -22,24 +24,36 @@ from llama_index.core.instrumentation.events.llm import (
     LLMPredictEndEvent,
 )
 from llama_index.core.instrumentation.events.rerank import ReRankStartEvent
-from llama_index.core.instrumentation.event_handlers import BaseEventHandler
 from llama_index.core.instrumentation.span_handlers import BaseSpanHandler
 from llama_index.core.workflow import Workflow
 from opentelemetry import context as context_api
+from opentelemetry.instrumentation.llamaindex.event_emitter import (
+    emit_chat_message_events,
+    emit_chat_response_events,
+    emit_rerank_message_event,
+)
+from opentelemetry.instrumentation.llamaindex.span_utils import (
+    set_embedding,
+    set_llm_chat_request,
+    set_llm_chat_request_model_attributes,
+    set_llm_chat_response,
+    set_llm_chat_response_model_attributes,
+    set_llm_predict_response,
+    set_rerank,
+    set_rerank_model_attributes,
+    set_tool,
+)
 from opentelemetry.instrumentation.llamaindex.utils import (
     JSONEncoder,
-    dont_throw,
+    should_emit_events,
     should_send_prompts,
 )
 from opentelemetry.semconv_ai import (
     SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY,
-    LLMRequestTypeValues,
     SpanAttributes,
     TraceloopSpanKindValues,
 )
-from opentelemetry.trace import set_span_in_context, Tracer
-from opentelemetry.trace.span import Span
-
+from opentelemetry.trace import Span, Tracer, set_span_in_context
 
 # For these spans, instead of creating a span using data from LlamaIndex,
 # we use the regular OpenLLMetry instrumentations
@@ -60,109 +74,6 @@ def instrument_with_dispatcher(tracer: Tracer):
     dispatcher.add_event_handler(OpenLLMetryEventHandler(openllmetry_span_handler))
 
 
-@dont_throw
-def _set_llm_chat_request(event, span) -> None:
-    model_dict = event.model_dict
-    span.set_attribute(SpanAttributes.LLM_REQUEST_TYPE, LLMRequestTypeValues.CHAT.value)
-    span.set_attribute(SpanAttributes.LLM_REQUEST_MODEL, model_dict.get("model"))
-    span.set_attribute(
-        SpanAttributes.LLM_REQUEST_TEMPERATURE, model_dict.get("temperature")
-    )
-    if should_send_prompts():
-        for idx, message in enumerate(event.messages):
-            span.set_attribute(
-                f"{SpanAttributes.LLM_PROMPTS}.{idx}.role", message.role.value
-            )
-            span.set_attribute(
-                f"{SpanAttributes.LLM_PROMPTS}.{idx}.content", message.content
-            )
-
-
-@dont_throw
-def _set_llm_chat_response(event, span) -> None:
-    response = event.response
-    if should_send_prompts():
-        for idx, message in enumerate(event.messages):
-            span.set_attribute(
-                f"{SpanAttributes.LLM_PROMPTS}.{idx}.role", message.role.value
-            )
-            span.set_attribute(
-                f"{SpanAttributes.LLM_PROMPTS}.{idx}.content", message.content
-            )
-        span.set_attribute(
-            f"{SpanAttributes.LLM_COMPLETIONS}.0.role",
-            response.message.role.value,
-        )
-        span.set_attribute(
-            f"{SpanAttributes.LLM_COMPLETIONS}.0.content",
-            response.message.content,
-        )
-    if not (raw := response.raw):
-        return
-    span.set_attribute(
-        SpanAttributes.LLM_RESPONSE_MODEL,
-        (
-            raw.get("model") if "model" in raw else raw.model
-        ),  # raw can be Any, not just ChatCompletion
-    )
-    if usage := raw.get("usage") if "usage" in raw else raw.usage:
-        span.set_attribute(
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens
-        )
-        span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens)
-        span.set_attribute(SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens)
-    if choices := raw.choices:
-        span.set_attribute(
-            SpanAttributes.LLM_RESPONSE_FINISH_REASON, choices[0].finish_reason
-        )
-
-
-@dont_throw
-def _set_llm_predict_response(event, span) -> None:
-    if should_send_prompts():
-        span.set_attribute(
-            f"{SpanAttributes.LLM_COMPLETIONS}.role",
-            MessageRole.ASSISTANT.value,
-        )
-        span.set_attribute(
-            f"{SpanAttributes.LLM_COMPLETIONS}.content",
-            event.output,
-        )
-
-
-@dont_throw
-def _set_embedding(event, span) -> None:
-    model_dict = event.model_dict
-    span.set_attribute(
-        f"{LLMRequestTypeValues.EMBEDDING.value}.model_name",
-        model_dict.get("model_name"),
-    )
-
-
-@dont_throw
-def _set_rerank(event, span) -> None:
-    span.set_attribute(
-        f"{LLMRequestTypeValues.RERANK.value}.model_name",
-        event.model_name,
-    )
-    span.set_attribute(
-        f"{LLMRequestTypeValues.RERANK.value}.top_n",
-        event.top_n,
-    )
-    if should_send_prompts():
-        span.set_attribute(
-            f"{LLMRequestTypeValues.RERANK.value}.query",
-            event.query.query_str,
-        )
-
-
-@dont_throw
-def _set_tool(event, span) -> None:
-    span.set_attribute("tool.name", event.tool.name)
-    span.set_attribute("tool.description", event.tool.description)
-    span.set_attribute("tool.arguments", event.arguments)
-
-
 @dataclass
 class SpanHolder:
     span_id: str
@@ -205,27 +116,40 @@ class SpanHolder:
 
     @update_span_for_event.register
     def _(self, event: LLMChatStartEvent):
-        _set_llm_chat_request(event, self.otel_span)
+        set_llm_chat_request_model_attributes(event, self.otel_span)
+        if should_emit_events():
+            emit_chat_message_events(event)
+        else:
+            set_llm_chat_request(event, self.otel_span)
 
     @update_span_for_event.register
     def _(self, event: LLMChatEndEvent):
-        _set_llm_chat_response(event, self.otel_span)
+        set_llm_chat_response_model_attributes(event, self.otel_span)
+        if should_emit_events():
+            emit_chat_response_events(event)
+        else:
+            set_llm_chat_response(event, self.otel_span)  # noqa: F821
 
     @update_span_for_event.register
     def _(self, event: LLMPredictEndEvent):
-        _set_llm_predict_response(event, self.otel_span)
+        if not should_emit_events():
+            set_llm_predict_response(event, self.otel_span)
 
     @update_span_for_event.register
     def _(self, event: EmbeddingStartEvent):
-        _set_embedding(event, self.otel_span)
+        set_embedding(event, self.otel_span)
 
     @update_span_for_event.register
     def _(self, event: ReRankStartEvent):
-        _set_rerank(event, self.otel_span)
+        set_rerank_model_attributes(event, self.otel_span)
+        if should_emit_events():
+            emit_rerank_message_event(event)
+        else:
+            set_rerank(event, self.otel_span)
 
     @update_span_for_event.register
     def _(self, event: AgentToolCallEvent):
-        _set_tool(event, self.otel_span)
+        set_tool(event, self.otel_span)
 
 
 class OpenLLMetrySpanHandler(BaseSpanHandler[SpanHolder]):
@@ -269,7 +193,11 @@ class OpenLLMetrySpanHandler(BaseSpanHandler[SpanHolder]):
         )
 
         if isinstance(instance, Workflow):
-            span_name = f"{instance.__class__.__name__}.{kind}" if not parent_span_id else f"{method_name}.{kind}"
+            span_name = (
+                f"{instance.__class__.__name__}.{kind}"
+                if not parent_span_id
+                else f"{method_name}.{kind}"
+            )
         else:
             span_name = f"{class_name}.{kind}"
 

opentelemetry_instrumentation_llamaindex-0.42.0/opentelemetry/instrumentation/llamaindex/event_emitter.py

@@ -0,0 +1,152 @@
+from dataclasses import asdict
+from enum import Enum
+from typing import Union
+
+from llama_index.core.instrumentation.events.llm import (
+    LLMChatEndEvent,
+    LLMChatStartEvent,
+)
+from llama_index.core.instrumentation.events.rerank import ReRankStartEvent
+from opentelemetry._events import Event
+from opentelemetry.instrumentation.llamaindex.event_models import (
+    ChoiceEvent,
+    MessageEvent,
+)
+from opentelemetry.instrumentation.llamaindex.utils import (
+    should_emit_events,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+
+from .config import Config
+
+
+class Roles(Enum):
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+
+
+VALID_MESSAGE_ROLES = {role.value for role in Roles}
+"""The valid roles for naming the message event."""
+
+EVENT_ATTRIBUTES = {GenAIAttributes.GEN_AI_SYSTEM: "llamaindex"}
+"""The attributes to be used for the event."""
+
+
+def emit_chat_message_events(event: LLMChatStartEvent):
+    for message in event.messages:
+        emit_event(MessageEvent(content=message.content, role=message.role.value))
+
+
+def emit_chat_response_events(event: LLMChatEndEvent):
+    if event.response:
+        try:
+            finish_reason = event.response.raw.get("choices", [{}])[0].get(
+                "finish_reason", "unknown"
+            )
+        except (AttributeError, ValueError):
+            finish_reason = "unknown"
+        emit_choice_event(
+            index=0,
+            content=event.response.message.content,
+            role=event.response.message.role.value,
+            finish_reason=finish_reason,
+        )
+
+
+def emit_rerank_message_event(event: ReRankStartEvent):
+    if event.query:
+        if isinstance(event.query, str):
+            emit_message_event(content=event.query, role="user")
+        else:
+            emit_message_event(content=event.query.query_str, role="user")
+
+
+def emit_message_event(*, content, role: str):
+    emit_event(MessageEvent(content=content, role=role))
+
+
+def emit_choice_event(
+    *,
+    index: int = 0,
+    content,
+    role: str,
+    finish_reason: str,
+):
+    emit_event(
+        ChoiceEvent(
+            index=index,
+            message={"content": content, "role": role},
+            finish_reason=finish_reason,
+        )
+    )
+
+
+def emit_event(event: Union[MessageEvent, ChoiceEvent]) -> None:
+    """
+    Emit an event to the OpenTelemetry SDK.
+
+    Args:
+        event: The event to emit.
+    """
+    if not should_emit_events():
+        return
+
+    if isinstance(event, MessageEvent):
+        _emit_message_event(event)
+    elif isinstance(event, ChoiceEvent):
+        _emit_choice_event(event)
+    else:
+        raise TypeError("Unsupported event type")
+
+
+def _emit_message_event(event: MessageEvent) -> None:
+    body = asdict(event)
+
+    if event.role in VALID_MESSAGE_ROLES:
+        name = "gen_ai.{}.message".format(event.role)
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to the "role" in the message name. So, remove the role from the body if
+        # it is the same as the in the event name.
+        body.pop("role", None)
+    else:
+        name = "gen_ai.user.message"
+
+    # According to the semantic conventions, only the assistant role has tool call
+    if event.role != Roles.ASSISTANT.value and event.tool_calls is not None:
+        del body["tool_calls"]
+    elif event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        del body["content"]
+        if body.get("tool_calls") is not None:
+            for tool_call in body["tool_calls"]:
+                tool_call["function"].pop("arguments", None)
+
+    Config.event_logger.emit(Event(name=name, body=body, attributes=EVENT_ATTRIBUTES))
+
+
+def _emit_choice_event(event: ChoiceEvent) -> None:
+    body = asdict(event)
+    if event.message["role"] == Roles.ASSISTANT.value:
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to "assistant", so remove the role from the body if it is "assistant".
+        body["message"].pop("role", None)
+
+    if event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        body["message"].pop("content", None)
+        if body.get("tool_calls") is not None:
+            for tool_call in body["tool_calls"]:
+                tool_call["function"].pop("arguments", None)
+
+    Config.event_logger.emit(
+        Event(name="gen_ai.choice", body=body, attributes=EVENT_ATTRIBUTES)
+    )

opentelemetry_instrumentation_llamaindex-0.42.0/opentelemetry/instrumentation/llamaindex/event_models.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Any, List, Literal, Optional, TypedDict
+
+
+class _FunctionToolCall(TypedDict):
+    function_name: str
+    arguments: Optional[dict[str, Any]]
+
+
+class ToolCall(TypedDict):
+    """Represents a tool call in the AI model."""
+
+    id: str
+    function: _FunctionToolCall
+    type: Literal["function"]
+
+
+class CompletionMessage(TypedDict):
+    """Represents a message in the AI model."""
+
+    content: Any
+    role: str = "assistant"
+
+
+@dataclass
+class MessageEvent:
+    """Represents an input event for the AI model."""
+
+    content: Any
+    role: str = "user"
+    tool_calls: Optional[List[ToolCall]] = None
+
+
+@dataclass
+class ChoiceEvent:
+    """Represents a completion event for the AI model."""
+
+    index: int
+    message: CompletionMessage
+    finish_reason: str = "unknown"
+    tool_calls: Optional[List[ToolCall]] = None

opentelemetry_instrumentation_llamaindex-0.42.0/opentelemetry/instrumentation/llamaindex/llamaparse_instrumentor.py

@@ -0,0 +1,169 @@
+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
+
+MODULE_NAME = "llama_parse"
+CLASS_NAME = "LlamaParse"
+TASK_NAME = "llamaparse"
+
+
+class LlamaParseInstrumentor:
+    def __init__(self, tracer):
+        self._tracer = tracer
+
+    def instrument(self):
+        methods_to_wrap = [
+            ("load_data", load_data_wrapper),
+            ("aload_data", aload_data_wrapper),
+            ("get_json_result", get_json_wrapper),
+            ("aget_json", aget_json_wrapper),
+            ("get_images", get_images_wrapper),
+            ("aget_images", aget_images_wrapper),
+            ("get_charts", get_charts_wrapper),
+            ("aget_charts", aget_charts_wrapper),
+        ]
+
+        for method_name, wrapper_func in methods_to_wrap:
+            try:
+                wrap_function_wrapper(
+                    MODULE_NAME,
+                    f"{CLASS_NAME}.{method_name}",
+                    wrapper_func(self._tracer),
+                )
+            except AttributeError:
+                # Method doesn't exist, skip it
+                continue
+
+
+@_with_tracer_wrapper
+def get_json_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)
+        result = wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+async def aget_json_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)
+        result = await wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+def get_images_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)
+        result = wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+async def aget_images_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)
+        result = await wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+def get_charts_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)
+        result = wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+async def aget_charts_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)
+        result = await wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+def load_data_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)
+        result = wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result
+
+
+@_with_tracer_wrapper
+async def aload_data_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)
+        result = await wrapped(*args, **kwargs)
+        process_response(span, result)
+        return result

{opentelemetry_instrumentation_llamaindex-0.40.14 → opentelemetry_instrumentation_llamaindex-0.42.0}/opentelemetry/instrumentation/llamaindex/retriever_query_engine_instrumentor.py

@@ -1,8 +1,7 @@
-from importlib.metadata import version as package_version, PackageNotFoundError
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as package_version
 
-from wrapt import wrap_function_wrapper
 from opentelemetry.context import attach, set_value
-
 from opentelemetry.instrumentation.llamaindex.utils import (
     _with_tracer_wrapper,
     process_request,
@@ -10,6 +9,7 @@ from opentelemetry.instrumentation.llamaindex.utils import (
     start_as_current_span_async,
 )
 from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+from wrapt import wrap_function_wrapper
 
 V9_MODULE_NAME = "llama_index.query_engine.retriever_query_engine"
 V10_MODULE_NAME = "llama_index.core.query_engine.retriever_query_engine"

opentelemetry_instrumentation_llamaindex-0.42.0/opentelemetry/instrumentation/llamaindex/span_utils.py

@@ -0,0 +1,143 @@
+from llama_index.core.base.llms.types import MessageRole
+from opentelemetry.instrumentation.llamaindex.utils import (
+    dont_throw,
+    should_send_prompts,
+)
+from opentelemetry.semconv_ai import (
+    LLMRequestTypeValues,
+    SpanAttributes,
+)
+
+
+@dont_throw
+def set_llm_chat_request(event, span) -> None:
+    if not span.is_recording():
+        return
+
+    if should_send_prompts():
+        for idx, message in enumerate(event.messages):
+            span.set_attribute(
+                f"{SpanAttributes.LLM_PROMPTS}.{idx}.role", message.role.value
+            )
+            span.set_attribute(
+                f"{SpanAttributes.LLM_PROMPTS}.{idx}.content", message.content
+            )
+
+
+@dont_throw
+def set_llm_chat_request_model_attributes(event, span):
+    if span and not span.is_recording():
+        return
+
+    model_dict = event.model_dict
+    span.set_attribute(SpanAttributes.LLM_REQUEST_TYPE, LLMRequestTypeValues.CHAT.value)
+    span.set_attribute(SpanAttributes.LLM_REQUEST_MODEL, model_dict.get("model"))
+    span.set_attribute(
+        SpanAttributes.LLM_REQUEST_TEMPERATURE, model_dict.get("temperature")
+    )
+
+
+@dont_throw
+def set_llm_chat_response(event, span) -> None:
+    if not span.is_recording():
+        return
+
+    response = event.response
+    if should_send_prompts():
+        for idx, message in enumerate(event.messages):
+            span.set_attribute(
+                f"{SpanAttributes.LLM_PROMPTS}.{idx}.role", message.role.value
+            )
+            span.set_attribute(
+                f"{SpanAttributes.LLM_PROMPTS}.{idx}.content", message.content
+            )
+        span.set_attribute(
+            f"{SpanAttributes.LLM_COMPLETIONS}.0.role",
+            response.message.role.value,
+        )
+        span.set_attribute(
+            f"{SpanAttributes.LLM_COMPLETIONS}.0.content",
+            response.message.content,
+        )
+
+
+@dont_throw
+def set_llm_chat_response_model_attributes(event, span):
+    if not span.is_recording():
+        return
+
+    response = event.response
+
+    if not (raw := response.raw):
+        return
+
+    span.set_attribute(
+        SpanAttributes.LLM_RESPONSE_MODEL,
+        (
+            raw.get("model") if "model" in raw else raw.model
+        ),  # raw can be Any, not just ChatCompletion
+    )
+    if usage := raw.get("usage") if "usage" in raw else raw.usage:
+        span.set_attribute(
+            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens
+        )
+        span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens)
+        span.set_attribute(SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens)
+    if choices := raw.choices:
+        span.set_attribute(
+            SpanAttributes.LLM_RESPONSE_FINISH_REASON, choices[0].finish_reason
+        )
+
+
+@dont_throw
+def set_llm_predict_response(event, span) -> None:
+    if should_send_prompts():
+        span.set_attribute(
+            f"{SpanAttributes.LLM_COMPLETIONS}.role",
+            MessageRole.ASSISTANT.value,
+        )
+        span.set_attribute(
+            f"{SpanAttributes.LLM_COMPLETIONS}.content",
+            event.output,
+        )
+
+
+@dont_throw
+def set_embedding(event, span) -> None:
+    model_dict = event.model_dict
+    span.set_attribute(
+        f"{LLMRequestTypeValues.EMBEDDING.value}.model_name",
+        model_dict.get("model_name"),
+    )
+
+
+@dont_throw
+def set_rerank(event, span) -> None:
+    if not span.is_recording():
+        return
+    if should_send_prompts():
+        span.set_attribute(
+            f"{LLMRequestTypeValues.RERANK.value}.query",
+            event.query.query_str,
+        )
+
+
+@dont_throw
+def set_rerank_model_attributes(event, span):
+    if not span.is_recording():
+        return
+    span.set_attribute(
+        f"{LLMRequestTypeValues.RERANK.value}.model_name",
+        event.model_name,
+    )
+    span.set_attribute(
+        f"{LLMRequestTypeValues.RERANK.value}.top_n",
+        event.top_n,
+    )
+
+
+@dont_throw
+def set_tool(event, span) -> None:
+    span.set_attribute("tool.name", event.tool.name)
+    span.set_attribute("tool.description", event.tool.description)
+    span.set_attribute("tool.arguments", event.arguments)

{opentelemetry_instrumentation_llamaindex-0.40.14 → opentelemetry_instrumentation_llamaindex-0.42.0}/opentelemetry/instrumentation/llamaindex/utils.py

@@ -1,14 +1,17 @@
 import dataclasses
 import json
-import os
 import logging
+import os
 import traceback
 from contextlib import asynccontextmanager
 
 from opentelemetry import context as context_api
+from opentelemetry._events import EventLogger
 from opentelemetry.instrumentation.llamaindex.config import Config
 from opentelemetry.semconv_ai import SpanAttributes
 
+TRACELOOP_TRACE_CONTENT = "TRACELOOP_TRACE_CONTENT"
+
 
 def _with_tracer_wrapper(func):
     def _with_tracer(tracer):
@@ -28,7 +31,7 @@ async def start_as_current_span_async(tracer, *args, **kwargs):
 
 def should_send_prompts():
     return (
-        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
+        os.getenv(TRACELOOP_TRACE_CONTENT) or "true"
     ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
 
 
@@ -84,3 +87,18 @@ def process_response(span, res):
             SpanAttributes.TRACELOOP_ENTITY_OUTPUT,
             json.dumps(res, cls=JSONEncoder),
         )
+
+
+def is_role_valid(role: str) -> bool:
+    return role in ["user", "assistant", "system", "tool"]
+
+
+def should_emit_events() -> bool:
+    """
+    Checks if the instrumentation isn't using the legacy attributes
+    and if the event logger is not None.
+    """
+
+    return not Config.use_legacy_attributes and isinstance(
+        Config.event_logger, EventLogger
+    )

opentelemetry_instrumentation_llamaindex-0.42.0/opentelemetry/instrumentation/llamaindex/version.py

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

{opentelemetry_instrumentation_llamaindex-0.40.14 → opentelemetry_instrumentation_llamaindex-0.42.0}/pyproject.toml

@@ -8,7 +8,7 @@ show_missing = true
 
 [tool.poetry]
 name = "opentelemetry-instrumentation-llamaindex"
-version = "0.40.14"
+version = "0.42.0"
 description = "OpenTelemetry LlamaIndex instrumentation"
 authors = [
   "Gal Kleinman <gal@traceloop.com>",
@@ -27,7 +27,7 @@ python = ">=3.9,<4"
 opentelemetry-api = "^1.28.0"
 opentelemetry-instrumentation = ">=0.50b0"
 opentelemetry-semantic-conventions = ">=0.50b0"
-opentelemetry-semantic-conventions-ai = "0.4.9"
+opentelemetry-semantic-conventions-ai = "0.4.11"
 inflection = "^0.5.1"
 
 [tool.poetry.group.dev.dependencies]
@@ -43,15 +43,16 @@ openai = "^1.52.2"
 opentelemetry-sdk = "^1.27.0"
 llama-index = "^0.12.6"
 llama-index-postprocessor-cohere-rerank = "^0.3.0"
-opentelemetry-instrumentation-openai = "==0.40.14"
-opentelemetry-instrumentation-cohere = "==0.40.14"
-opentelemetry-instrumentation-chromadb = "==0.40.14"
+opentelemetry-instrumentation-openai = "==0.42.0"
+opentelemetry-instrumentation-cohere = "==0.42.0"
+opentelemetry-instrumentation-chromadb = "==0.42.0"
 sqlalchemy = "^2.0.31"
 llama-index-agent-openai = "^0.4.1"
 llama-index-vector-stores-chroma = "^0.4.1"
 llama-index-llms-cohere = "^0.4.0"
 llama-index-embeddings-openai = "^0.3.1"
 onnxruntime = "<1.20.0"
+llama-parse = "^0.5.20"
 
 [build-system]
 requires = ["poetry-core"]
@@ -59,6 +60,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.extras]
 instruments = ["llama-index"]
+llamaparse = ["llama-parse"]
 
 [tool.poetry.plugins."opentelemetry_instrumentor"]
 llama-index = "opentelemetry.instrumentation.llamaindex:LlamaIndexInstrumentor"

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

@@ -1,2 +0,0 @@
-class Config:
-    exception_logger = None

opentelemetry_instrumentation_llamaindex-0.40.14/opentelemetry/instrumentation/llamaindex/version.py

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