splunk-otel-util-genai-translator-traceloop 0.1.3__tar.gz

splunk_otel_util_genai_translator_traceloop-0.1.3/.gitignore

@@ -0,0 +1,8 @@
+.env
+
+__pycache__/
+.vscode/
+*.pyc
+.DS_Store
+
+# Ignore example output files

splunk_otel_util_genai_translator_traceloop-0.1.3/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: splunk-otel-util-genai-translator-traceloop
+Version: 0.1.3
+Summary: Traceloop -> GenAI translator emitter for OpenTelemetry GenAI
+Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib
+Project-URL: Repository, https://github.com/open-telemetry/opentelemetry-python-contrib
+Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+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
+Requires-Python: >=3.9
+Requires-Dist: opentelemetry-api>=1.31.0
+Requires-Dist: opentelemetry-instrumentation~=0.52b1
+Requires-Dist: opentelemetry-sdk>=1.31.0
+Requires-Dist: opentelemetry-semantic-conventions~=0.52b1
+Requires-Dist: splunk-otel-util-genai>=0.1.3
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/x-rst
+
+OpenTelemetry GenAI Traceloop Translator
+=========================================
+
+This package automatically translates Traceloop-instrumented spans into OpenTelemetry GenAI semantic conventions.
+It intercepts spans with ``traceloop.*`` attributes and creates corresponding spans with ``gen_ai.*`` attributes,
+enabling seamless integration between Traceloop instrumentation and GenAI observability tools.
+
+Mapping Table
+-------------
+
+============================== ================================ 
+Traceloop Key                  Added Key                        
+============================== ================================
+``traceloop.workflow.name``    ``gen_ai.workflow.name``
+``traceloop.entity.name``      ``gen_ai.agent.name``
+``traceloop.entity.path``      ``gen_ai.workflow.path``
+``traceloop.correlation.id``   ``gen_ai.conversation.id``
+``traceloop.entity.input``     ``gen_ai.input.messages``
+``traceloop.entity.output``    ``gen_ai.output.messages``
+============================== ================================
+
+
+Installation
+------------
+.. code-block:: bash
+
+   pip install opentelemetry-util-genai-traceloop-translator
+
+Quick Start (Automatic Registration)
+-------------------------------------
+The easiest way to use the translator is to simply import it - no manual setup required!
+
+.. code-block:: python
+
+   import os
+   from openai import OpenAI
+
+
+   from traceloop.sdk import Traceloop
+   from traceloop.sdk.decorators import workflow
+
+   client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+   Traceloop.init(app_name="story_service")
+
+
+   @workflow(name="streaming_story")
+   def joke_workflow():
+      stream = client.chat.completions.create(
+         model="gpt-4o-2024-05-13",
+         messages=[{"role": "user", "content": "Tell me a story about opentelemetry"}],
+         stream=True,
+      )
+
+      for part in stream:
+         print(part.choices[0].delta.content or "", end="")
+      print()
+
+
+   joke_workflow()
+   # The translator automatically creates new gen_ai.* attributes based on the mapping.
+
+Tests
+-----
+.. code-block:: bash
+
+   pytest util/opentelemetry-util-genai-traceloop-translator/tests
+

splunk_otel_util_genai_translator_traceloop-0.1.3/README.rst

@@ -0,0 +1,68 @@
+OpenTelemetry GenAI Traceloop Translator
+=========================================
+
+This package automatically translates Traceloop-instrumented spans into OpenTelemetry GenAI semantic conventions.
+It intercepts spans with ``traceloop.*`` attributes and creates corresponding spans with ``gen_ai.*`` attributes,
+enabling seamless integration between Traceloop instrumentation and GenAI observability tools.
+
+Mapping Table
+-------------
+
+============================== ================================ 
+Traceloop Key                  Added Key                        
+============================== ================================
+``traceloop.workflow.name``    ``gen_ai.workflow.name``
+``traceloop.entity.name``      ``gen_ai.agent.name``
+``traceloop.entity.path``      ``gen_ai.workflow.path``
+``traceloop.correlation.id``   ``gen_ai.conversation.id``
+``traceloop.entity.input``     ``gen_ai.input.messages``
+``traceloop.entity.output``    ``gen_ai.output.messages``
+============================== ================================
+
+
+Installation
+------------
+.. code-block:: bash
+
+   pip install opentelemetry-util-genai-traceloop-translator
+
+Quick Start (Automatic Registration)
+-------------------------------------
+The easiest way to use the translator is to simply import it - no manual setup required!
+
+.. code-block:: python
+
+   import os
+   from openai import OpenAI
+
+
+   from traceloop.sdk import Traceloop
+   from traceloop.sdk.decorators import workflow
+
+   client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+   Traceloop.init(app_name="story_service")
+
+
+   @workflow(name="streaming_story")
+   def joke_workflow():
+      stream = client.chat.completions.create(
+         model="gpt-4o-2024-05-13",
+         messages=[{"role": "user", "content": "Tell me a story about opentelemetry"}],
+         stream=True,
+      )
+
+      for part in stream:
+         print(part.choices[0].delta.content or "", end="")
+      print()
+
+
+   joke_workflow()
+   # The translator automatically creates new gen_ai.* attributes based on the mapping.
+
+Tests
+-----
+.. code-block:: bash
+
+   pytest util/opentelemetry-util-genai-traceloop-translator/tests
+

splunk_otel_util_genai_translator_traceloop-0.1.3/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "splunk-otel-util-genai-translator-traceloop"
+dynamic = ["version"]
+description = "Traceloop -> GenAI translator emitter for OpenTelemetry GenAI"
+readme = "README.rst"
+license = "Apache-2.0"
+requires-python = ">=3.9"
+authors = [
+  { name = "OpenTelemetry Authors", email = "cncf-opentelemetry-contributors@lists.cncf.io" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+  "opentelemetry-instrumentation ~= 0.52b1",
+  "opentelemetry-semantic-conventions ~= 0.52b1",
+  "opentelemetry-api>=1.31.0",
+  "opentelemetry-sdk>=1.31.0",
+  "splunk-otel-util-genai>=0.1.3",
+]
+
+[project.entry-points.opentelemetry_configurator]
+
+[project.optional-dependencies]
+test = ["pytest>=7.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/open-telemetry/opentelemetry-python-contrib"
+Repository = "https://github.com/open-telemetry/opentelemetry-python-contrib"
+
+[tool.hatch.version]
+path = "src/opentelemetry/util/genai/version.py"
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src",
+  "/tests",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/opentelemetry"]
+include = [
+  "src/opentelemetry_util_genai_traceloop_translator.pth",
+]
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/opentelemetry_util_genai_traceloop_translator.pth" = "opentelemetry_util_genai_traceloop_translator.pth"

splunk_otel_util_genai_translator_traceloop-0.1.3/src/opentelemetry/util/genai/processor/__init__.py

@@ -0,0 +1,20 @@
+# Copyright The OpenTelemetry Authors
+#
+# 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.
+
+"""Traceloop span processor and transformation utilities."""
+
+from .filtering_span_processor import FilteringSpanProcessor
+from .traceloop_span_processor import TraceloopSpanProcessor
+
+__all__ = ["TraceloopSpanProcessor", "FilteringSpanProcessor"]

splunk_otel_util_genai_translator_traceloop-0.1.3/src/opentelemetry/util/genai/processor/content_normalizer.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List
+
+# Internal sizing caps (kept private to module, not exposed via env)
+INPUT_MAX = 100
+OUTPUT_MAX = 100
+MSG_CONTENT_MAX = 16000
+PROMPT_TEMPLATE_MAX = 4096
+
+
+def maybe_truncate_template(value: Any) -> Any:
+    if not isinstance(value, str) or len(value) <= PROMPT_TEMPLATE_MAX:
+        return value
+    return value[:PROMPT_TEMPLATE_MAX] + "…(truncated)"
+
+
+def _coerce_text_part(content: Any) -> Dict[str, Any]:
+    if not isinstance(content, str):
+        try:
+            content = json.dumps(content)[:MSG_CONTENT_MAX]
+        except Exception:
+            content = str(content)[:MSG_CONTENT_MAX]
+    else:
+        content = content[:MSG_CONTENT_MAX]
+    return {"type": "text", "content": content}
+
+
+def _extract_langchain_messages(content_val: Any) -> List[Dict[str, Any]]:
+    """
+    Extract actual message content from nested LangChain message objects.
+    
+    Handles formats like:
+    - {"messages": [{"lc": 1, "kwargs": {"content": "text", "type": "human"}}]}
+    - {"outputs": {"messages": [{"lc": 1, "kwargs": {"content": "text"}}]}}
+    
+    Returns list of extracted messages with their content and role.
+    """
+    extracted = []
+    
+    try:
+        # Parse if it's a JSON string
+        if isinstance(content_val, str):
+            try:
+                content_val = json.loads(content_val)
+            except Exception:
+                return []  # Not JSON, let caller handle it
+        
+        if not isinstance(content_val, dict):
+            return []
+        
+        # Check for "outputs" wrapper (common in workflow outputs)
+        if "outputs" in content_val and isinstance(content_val["outputs"], dict):
+            content_val = content_val["outputs"]
+        
+        # Look for "messages" array
+        messages = content_val.get("messages", [])
+        if not isinstance(messages, list):
+            return []
+        
+        # Extract content from each LangChain message
+        for msg in messages:
+            if not isinstance(msg, dict):
+                continue
+            
+            # Check if this is a LangChain message (has "lc": 1 and "kwargs")
+            if msg.get("lc") == 1 and "kwargs" in msg:
+                kwargs = msg["kwargs"]
+                if isinstance(kwargs, dict):
+                    msg_content = kwargs.get("content")
+                    msg_type = kwargs.get("type", "unknown")
+                    
+                    if msg_content:
+                        # Map LangChain types to roles
+                        if msg_type == "human":
+                            role = "user"
+                        elif msg_type == "ai":
+                            role = "assistant"
+                        elif msg_type == "system":
+                            role = "system"
+                        else:
+                            # Infer from message position
+                            role = "user" if not extracted else "assistant"
+                        
+                        extracted.append({
+                            "content": msg_content,
+                            "role": role
+                        })
+        
+        return extracted
+    
+    except Exception:
+        return []
+
+
+def normalize_traceloop_content(
+    raw: Any, direction: str
+) -> List[Dict[str, Any]]:
+    """Normalize traceloop entity input/output blob into GenAI message schema.
+
+    direction: 'input' | 'output'
+    Returns list of messages: {role, parts, finish_reason?}
+    """
+    # List[dict] messages already
+    if isinstance(raw, list) and all(isinstance(m, dict) for m in raw):
+        normalized: List[Dict[str, Any]] = []
+        limit = INPUT_MAX if direction == "input" else OUTPUT_MAX
+        for m in raw[:limit]:
+            role = m.get(
+                "role", "user" if direction == "input" else "assistant"
+            )
+            content_val = m.get("content")
+            if content_val is None:
+                temp = {
+                    k: v
+                    for k, v in m.items()
+                    if k not in ("role", "finish_reason", "finishReason")
+                }
+                content_val = temp or ""
+            
+            # CRITICAL FIX: Check if content contains nested LangChain messages
+            # This handles the format where Traceloop serializes workflow inputs/outputs
+            # with LangChain message objects embedded in JSON
+            langchain_messages = _extract_langchain_messages(content_val)
+            
+            if langchain_messages:
+                # We found nested LangChain messages - extract their content
+                for lc_msg in langchain_messages:
+                    parts = [_coerce_text_part(lc_msg["content"])]
+                    msg: Dict[str, Any] = {"role": lc_msg["role"], "parts": parts}
+                    if direction == "output":
+                        fr = m.get("finish_reason") or m.get("finishReason") or "stop"
+                        msg["finish_reason"] = fr
+                    normalized.append(msg)
+            else:
+                # No nested LangChain messages - use content as-is
+                parts = [_coerce_text_part(content_val)]
+                msg: Dict[str, Any] = {"role": role, "parts": parts}
+                if direction == "output":
+                    fr = m.get("finish_reason") or m.get("finishReason") or "stop"
+                    msg["finish_reason"] = fr
+                normalized.append(msg)
+        
+        return normalized
+
+    # Dict variants
+    if isinstance(raw, dict):
+        # OpenAI choices
+        if (
+            direction == "output"
+            and "choices" in raw
+            and isinstance(raw["choices"], list)
+        ):
+            out_msgs: List[Dict[str, Any]] = []
+            for choice in raw["choices"][:OUTPUT_MAX]:
+                message = (
+                    choice.get("message") if isinstance(choice, dict) else None
+                )
+                if message and isinstance(message, dict):
+                    role = message.get("role", "assistant")
+                    content_val = (
+                        message.get("content") or message.get("text") or ""
+                    )
+                else:
+                    role = "assistant"
+                    content_val = (
+                        choice.get("text")
+                        or choice.get("content")
+                        or json.dumps(choice)
+                    )
+                parts = [_coerce_text_part(content_val)]
+                finish_reason = (
+                    choice.get("finish_reason")
+                    or choice.get("finishReason")
+                    or "stop"
+                )
+                out_msgs.append(
+                    {
+                        "role": role,
+                        "parts": parts,
+                        "finish_reason": finish_reason,
+                    }
+                )
+            return out_msgs
+        # Gemini candidates
+        if (
+            direction == "output"
+            and "candidates" in raw
+            and isinstance(raw["candidates"], list)
+        ):
+            out_msgs: List[Dict[str, Any]] = []
+            for cand in raw["candidates"][:OUTPUT_MAX]:
+                role = cand.get("role", "assistant")
+                cand_content = cand.get("content")
+                if isinstance(cand_content, list):
+                    joined = "\n".join(
+                        [
+                            str(p.get("text", p.get("content", p)))
+                            for p in cand_content
+                        ]
+                    )
+                    content_val = joined
+                else:
+                    content_val = cand_content or json.dumps(cand)
+                parts = [_coerce_text_part(content_val)]
+                finish_reason = (
+                    cand.get("finish_reason")
+                    or cand.get("finishReason")
+                    or "stop"
+                )
+                out_msgs.append(
+                    {
+                        "role": role,
+                        "parts": parts,
+                        "finish_reason": finish_reason,
+                    }
+                )
+            return out_msgs
+        # messages array
+        if "messages" in raw and isinstance(raw["messages"], list):
+            return normalize_traceloop_content(raw["messages"], direction)
+        # wrapper args (LangGraph/Traceloop format with function call args)
+        if "args" in raw and isinstance(raw["args"], list) and len(raw["args"]) > 0:
+            # Extract first arg (usually contains messages and other params)
+            first_arg = raw["args"][0]
+            if isinstance(first_arg, dict):
+                # Recursively process - will find "messages" array
+                return normalize_traceloop_content(first_arg, direction)
+        # wrapper inputs
+        if "inputs" in raw:
+            inner = raw["inputs"]
+            if isinstance(inner, list):
+                return normalize_traceloop_content(inner, direction)
+            if isinstance(inner, dict):
+                # Recursively process - might contain "messages" array
+                return normalize_traceloop_content(inner, direction)
+        # tool calls
+        if (
+            direction == "output"
+            and "tool_calls" in raw
+            and isinstance(raw["tool_calls"], list)
+        ):
+            out_msgs: List[Dict[str, Any]] = []
+            for tc in raw["tool_calls"][:OUTPUT_MAX]:
+                part = {
+                    "type": "tool_call",
+                    "name": tc.get("name", "tool"),
+                    "arguments": tc.get("arguments"),
+                    "id": tc.get("id"),
+                }
+                finish_reason = (
+                    tc.get("finish_reason")
+                    or tc.get("finishReason")
+                    or "tool_call"
+                )
+                out_msgs.append(
+                    {
+                        "role": "assistant",
+                        "parts": [part],
+                        "finish_reason": finish_reason,
+                    }
+                )
+            return out_msgs
+        body = {k: v for k, v in raw.items() if k != "role"}
+        if direction == "output":
+            return [
+                {
+                    "role": "assistant",
+                    "parts": [_coerce_text_part(body)],
+                    "finish_reason": "stop",
+                }
+            ]
+        return [{"role": "user", "parts": [_coerce_text_part(body)]}]
+
+    # JSON string
+    if isinstance(raw, str):
+        try:
+            parsed = json.loads(raw)
+            return normalize_traceloop_content(parsed, direction)
+        except Exception:
+            if direction == "output":
+                return [
+                    {
+                        "role": "assistant",
+                        "parts": [_coerce_text_part(raw)],
+                        "finish_reason": "stop",
+                    }
+                ]
+            return [{"role": "user", "parts": [_coerce_text_part(raw)]}]
+
+    # List of raw strings
+    if isinstance(raw, list) and all(isinstance(s, str) for s in raw):
+        msgs: List[Dict[str, Any]] = []
+        limit = INPUT_MAX if direction == "input" else OUTPUT_MAX
+        for s in raw[:limit]:
+            msgs.append(
+                {
+                    "role": "user" if direction == "input" else "assistant",
+                    "parts": [_coerce_text_part(s)],
+                }
+            )
+        return msgs
+
+    # Generic fallback
+    if direction == "output":
+        return [
+            {
+                "role": "assistant",
+                "parts": [_coerce_text_part(raw)],
+                "finish_reason": "stop",
+            }
+        ]
+    return [{"role": "user", "parts": [_coerce_text_part(raw)]}]
+
+
+__all__ = [
+    "normalize_traceloop_content",
+    "maybe_truncate_template",
+    "INPUT_MAX",
+    "OUTPUT_MAX",
+    "MSG_CONTENT_MAX",
+    "PROMPT_TEMPLATE_MAX",
+]