Traces Overview

pip install "arthur-observability-sdk"

# To add framework auto-instrumentation (e.g., OpenAI)
pip install "arthur-observability-sdk[openai]"

# Mastra users: install the Arthur exporter
npm install @mastra/arthur

from arthur_observability_sdk.arthur import Arthur
from opentelemetry import trace
from openinference.semconv.trace import SpanAttributes, OpenInferenceSpanKindValues

arthur = Arthur(
    task_name="my-llm-app",
    api_key="your-api-key",
    base_url="https://your-arthur-engine-url",
)

tracer = trace.get_tracer("my-llm-app")

// Mastra handles tracer setup automatically once ArthurExporter is wired in.
// No manual tracer initialization needed.
const agent = mastra.getAgent('my-agent');

import openai

client = openai.OpenAI()

with tracer.start_as_current_span("llm_call") as span:
    # Tag the span as an LLM span using OpenInference conventions
    span.set_attribute(
        SpanAttributes.OPENINFERENCE_SPAN_KIND,
        OpenInferenceSpanKindValues.LLM.value
    )
    span.set_attribute(SpanAttributes.INPUT_VALUE, "What is the capital of France?")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "What is the capital of France?"}],
    )

    output = response.choices[0].message.content
    span.set_attribute(SpanAttributes.OUTPUT_VALUE, output)
    span.set_attribute(SpanAttributes.LLM_MODEL_NAME, "gpt-4o")
    span.set_attribute(
        SpanAttributes.LLM_TOKEN_COUNT_TOTAL,
        response.usage.total_tokens
    )

print(output)
# Don't forget to flush on shutdown
arthur.shutdown()

// Mastra auto-instruments every agent/LLM call once ArthurExporter is wired in.
// No manual span creation needed — just invoke your agent.
const agent = mastra.getAgent('my-agent');
const response = await agent.generate('What is the capital of France?');
console.log(response.text);

from arthur_observability_sdk.arthur import Arthur

arthur = Arthur(
    task_name="my-llm-app",
    api_key="your-api-key",
    base_url="https://your-arthur-engine-url",
)

# Auto-instrument the OpenAI client — all calls are traced automatically
arthur.instrument_openai()

# Now use OpenAI normally
import openai
client = openai.OpenAI()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

// Mastra auto-instruments all supported frameworks via ArthurExporter.
// See the Quickstart (doc:quickstart-eval) for the full setup.
const agent = mastra.getAgent('my-agent');
const response = await agent.generate('What is the capital of France?');
console.log(response.text);

graph TD
    Root["CHAIN: answer_question (root)"]
    Root --> Embed["EMBEDDING: embed_query"]
    Root --> Retrieve["RETRIEVER: fetch_documents"]
    Root --> Generate["LLM: generate_answer"]

from arthur_observability_sdk.arthur import Arthur
from opentelemetry import trace
from openinference.semconv.trace import SpanAttributes, OpenInferenceSpanKindValues

arthur = Arthur(task_name="rag-app", api_key="your-api-key", base_url="https://your-arthur-engine-url")
tracer = trace.get_tracer("rag-app")

def answer_question(user_query: str) -> str:
    # Root span — represents the full request
    with tracer.start_as_current_span("answer_question") as root:
        root.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND, OpenInferenceSpanKindValues.CHAIN.value)
        root.set_attribute(SpanAttributes.INPUT_VALUE, user_query)
        # Optional: attach session and user context
        root.set_attribute("session.id", "session-abc-123")
        root.set_attribute("user.id", "user-42")

        # Step 1: Embed the query
        with tracer.start_as_current_span("embed_query") as embed_span:
            embed_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND, OpenInferenceSpanKindValues.EMBEDDING.value)
            embedding = embed_query(user_query)  # your embedding function
            embed_span.set_attribute(SpanAttributes.EMBEDDING_MODEL_NAME, "text-embedding-3-small")

        # Step 2: Retrieve documents
        with tracer.start_as_current_span("fetch_documents") as retriever_span:
            retriever_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND, OpenInferenceSpanKindValues.RETRIEVER.value)
            docs = retrieve_documents(embedding)  # your retrieval function
            retriever_span.set_attribute(SpanAttributes.INPUT_VALUE, user_query)
            retriever_span.set_attribute("retrieval.document_count", len(docs))

        # Step 3: Generate answer
        with tracer.start_as_current_span("generate_answer") as llm_span:
            llm_span.set_attribute(SpanAttributes.OPENINFERENCE_SPAN_KIND, OpenInferenceSpanKindValues.LLM.value)
            answer = generate_with_context(user_query, docs)  # your LLM call
            llm_span.set_attribute(SpanAttributes.OUTPUT_VALUE, answer)
            llm_span.set_attribute(SpanAttributes.LLM_MODEL_NAME, "gpt-4o")

        root.set_attribute(SpanAttributes.OUTPUT_VALUE, answer)
        return answer

// Mastra traces RAG pipelines automatically — each step (embed, retrieve,
// generate) is captured as a separate span with the correct OpenInference
// span kind. No manual span creation needed.
const agent = mastra.getAgent('rag-agent');
const response = await agent.generate(userQuery);
console.log(response.text);

# Submit all spans in a single OTLP payload.
# Each span references the root span's spanId as its parentSpanId.
# See the OTLP/HTTP spec for the full payload structure.

from openinference.semconv.trace import SpanAttributes, OpenInferenceSpanKindValues

with tracer.start_as_current_span("my_tool_call") as span:
    span.set_attribute(
        SpanAttributes.OPENINFERENCE_SPAN_KIND,
        OpenInferenceSpanKindValues.TOOL.value  # "TOOL"
    )
    span.set_attribute("tool.name", "search_web")
    span.set_attribute(SpanAttributes.INPUT_VALUE, '{"query": "Arthur AI pricing"}')
    result = search_web(query="Arthur AI pricing")
    span.set_attribute(SpanAttributes.OUTPUT_VALUE, str(result))

span.setAttribute("openinference.span.kind", "TOOL");
span.setAttribute("tool.name", "search_web");
span.setAttribute("input.value", JSON.stringify({ query: "Arthur AI pricing" }));