Span attribute reference

The wire format Rius reads. If you emit spans from anything other than the SDKs (a vanilla OpenTelemetry SDK, a collector pipeline, another language), this page tells you which attributes to set so your traces get the same analytics as SDK-emitted ones.

For the full list of keys, with each one’s type, stability, and examples, see the attribute registry. It is generated from each release of rius-semconv , the registry the SDKs and the platform share. This page covers which of those keys to set and what the platform does with them.

Where to send spans

OTLP/HTTP with protobuf encoding:

POST https://ingest.eu.console.rius-glassflow.com/v1/traces
Authorization: Bearer <your API key>
Content-Type: application/x-protobuf

The contract in full:

• Host: region-qualified. All Rius endpoints carry the region in the subdomain (ingest.eu.console.rius-glassflow.com, eu.console.rius-glassflow.com); use your workspace’s region. Examples throughout these docs use eu.
• Protocol: OTLP/HTTP, either protobuf (http/protobuf, recommended) or JSON (http/json); there is no gRPC endpoint. JSON requests get JSON replies. Protobuf is the default of the Python, Go, and Java OTLP/HTTP exporters and of the collector’s otlphttp exporter. In Node it is not: @opentelemetry/exporter-trace-otlp-http sends JSON, which works, but @opentelemetry/exporter-trace-otlp-proto is the better choice (the Rius TypeScript SDK already uses it).
• Compression: Content-Encoding: gzip is accepted (and worth enabling; span batches compress well).
• Body limit: 16 MiB per request. Exporters’ default batch sizes sit far below this.
• Auth: Authorization: Bearer with an API key from the console.

The receiver answers a rejected request with one of these status codes. JSON requests get the error as a JSON google.rpc.Status body.

The ingest rate is per workspace, in spans per minute, with one minute’s worth of burst: 25,000 on Core and during the trial, 50,000 on Growth, and 100,000 on Pro.

Setup for each common sender is one page away: a vanilla OpenTelemetry SDK, OpenLLMetry, OpenInference, or an OpenTelemetry Collector.

Span taxonomy

Set either one and the platform derives the other: chat, text_completion, and generate_content are LLM, invoke_agent and create_agent are AGENT, execute_tool is TOOL, embeddings is EMBEDDING, retrieval is RETRIEVER, and invoke_workflow and plan are CHAIN. A CHAIN span gets no operation in return, because the conventions define none for a generic step. The SDKs set both.

The SDKs also emit OpenInference’s RERANKER kind with the rerank operation for reranking steps (Python 1.1.0, TypeScript 1.2.0). Rius has no reranker category yet: in trace views and kind filters, a reranking span shows as LLM when it carries gen_ai.request.model, and as Other when it does not.

An LLM call, as the console and alerts count it, is an inference call: a span whose kind is LLM, set directly or derived from a chat, text_completion, or generate_content operation. A span with neither a kind nor an operation counts when it carries gen_ai.request.model. Agent, tool, and retrieval spans are not LLM calls even when they carry a model, and embedding calls are not either; their cost still appears in the per-model breakdown and the cost totals.

Name spans the way the GenAI conventions ask, the operation followed by what it acted on: chat gpt-4o, execute_tool get_weather, invoke_agent planner, retrieval product-kb. The platform does not require it, but it is what the SDKs emit, so mixed fleets read alike.

Agents, tools, and retrieval

MCP tool calls

A tool called over the Model Context Protocol (MCP) is an execute_tool span like any other, plus the OpenTelemetry MCP attributes:

A trace’s context attribution reports how many context tokens MCP tools took, and their share of the total, only when at least one span in the trace carries mcp.method.name. Without it, MCP and local tools cannot be told apart, so the MCP share is unknown, not zero. The SDKs’ MCP integration sets both attributes; set them yourself when you instrument MCP calls by hand.

LLM analytics

These drive model analytics and cost computation:

Content

Content attributes are stored for trace inspection and are the ones covered by the SDK’s privacy controls when you export through it.

The GenAI message shape

gen_ai.input.messages and gen_ai.output.messages carry a JSON array of messages, each {"role", "parts": [...]}. Text parts are {"type": "text", "content": ...}; tool interactions have dedicated part types:

[
  {"role": "user", "parts": [{"type": "text", "content": "What is 2+2?"}]},
  {
    "role": "assistant",
    "parts": [
      {"type": "tool_call", "id": "call_1", "name": "calculator", "arguments": "{\"expr\": \"2+2\"}"}
    ]
  },
  {
    "role": "tool",
    "parts": [{"type": "tool_call_response", "id": "call_1", "response": "4"}]
  }
]

This is the OpenTelemetry GenAI message schema; the SDK’s set_input() / set_output() normalize OpenAI-style dicts into it (message formats). When emitting directly, produce this shape yourself so message rendering in the console works. Spans carrying it render their prompt and completion on the span’s Input / Output tab:

Spans without these attributes show “Content not captured” there; the rest of the span (timings, tokens, cost) is unaffected.

List-valued attributes

An attribute sent as an OTLP array or key-value list, such as gen_ai.response.finish_reasons, is stored as plain JSON: ["stop"], or an object for a key-value list. A saved search or alert that matches the stored text should match that form. Spans ingested before this storage change keep the older OTLP envelope form ({"arrayValue":{"values":[...]}}), and those rows are not rewritten.

Context sizes

The SDKs also send rius.context.sizes on spans from their generation API: a compact JSON record of the byte size of each tool definition and each message part. LLM spans from auto-instrumentation, such as the OpenAI or LangChain integrations, do not carry it. Rius uses it to divide a call’s input tokens across the parts of its context, and it survives content stripping because it holds no content. It is optional: without it, the platform estimates the same breakdown from the captured messages, gen_ai.system_instructions, and tool definitions.

Span events

When a span carries a producer’s own first-chunk event, OpenInference’s First Token Stream Event or the Vercel AI SDK’s ai.stream.firstChunk, that event’s time is the first chunk and gen_ai.response.time_to_first_chunk is not used for it. Otherwise time to first token comes from gen_ai.response.time_to_first_chunk: the platform places the first chunk at the span start plus that duration, never later than the span’s end. For streaming LLM calls, set gen_ai.response.time_to_first_chunk once, in seconds from the span start, when the first content chunk arrives, together with gen_ai.request.stream: true. The SDK’s record_first_token() does exactly this, and when you export through the SDKs they also derive the duration from a producer’s first-chunk event. No event is needed.

Sessions and users

The SDK’s session and user scopes stamp these attributes for you; third-party senders set them directly.

Resource attributes

Attribute count limit

OpenTelemetry SDKs keep at most 128 attributes per span unless configured otherwise, and drop the rest without an error. Instrumentations that flatten messages and tools into one attribute per field, OpenInference among them, pass that within a few turns of an agent loop, and the span then loses its model, tools, usage, or messages. The Rius SDKs raise the limit to 4096. When you export without them, set it yourself:

export OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT=4096

Supported conventions

What each attribute family gets today. “Analytics” means the promoted columns above (taxonomy, model, tokens, cost, time to first token). “Stored” says which key the value is kept under on the span, and so which key to search and filter on in trace inspection.

“Normalized at ingest” means the platform moves the values onto their canonical keys before storage and removes the source keys it mapped. Native gen_ai.* keys always win; normalization fills gaps, never overwrites. Search and filter on the canonical key: a filter on llm.token_count.prompt or gen_ai.usage.prompt_tokens matches nothing, while gen_ai.usage.input_tokens matches. A few source keys stay on the span on purpose: for OpenInference, llm.system and the members of llm.invocation_parameters that no canonical key takes; for OpenLLMetry, traceloop.entity.name; for the Vercel AI SDK, ai.operationId. For OpenInference:

• The request model comes from llm.request.model_name, else the model member of llm.invocation_parameters, else llm.model_name. The response model comes from llm.response.model_name, else llm.model_name, but only when the span’s status is OK. An ERROR or UNSET span gets no response model from llm.model_name, because on those spans it may still hold the requested model rather than the one the provider served.
• llm.token_count.prompt / completion and their cache and reasoning details fill the token counts, which is what makes cost computation work.
• The recognized members of llm.invocation_parameters (model, model_name, temperature, top_p, top_k, max_tokens, max_completion_tokens, num_output, frequency_penalty, presence_penalty, seed, n, stop, stop_sequences, and stream) become gen_ai.request.*, and tool_choice becomes rius.request.tool_choice. model_name is a fallback for model, num_output for the maximum tokens, and stop and stop_sequences both become gen_ai.request.stop_sequences. Other members stay in the bag. Its tools become gen_ai.tool.definitions, as do the indexed llm.tools.* schemas, and Anthropic’s system parameter becomes the leading system message.
• The flattened llm.input_messages.* / llm.output_messages.* are reassembled into the GenAI message shape, and at ingest the first-token span event is renamed to gen_ai.first_token.

For OpenLLMetry, the Traceloop decorator kinds (workflow, task, agent, tool) and the provider span’s llm.request.type become the span taxonomy; the decorated entity’s name becomes the tool or invoked agent name; traceloop.entity.input / output become input.value / output.value; the older usage and streaming spellings move to their current keys; and the flattened gen_ai.prompt.* / gen_ai.completion.* messages are reassembled into the GenAI message shape. Keys with no canonical equivalent, such as llm.usage.total_tokens, ride through under their own names.

The Rius SDKs apply the same OpenInference mapping in your process before export, with one difference: they skip the llm.model_name fallback, which only the platform applies. See what the SDK normalizes.

Unknown attributes are stored as sent and are never an error, with three exceptions that apply to every span:

• Credential header attributes, such as http.request.header.authorization or ai.request.headers.x-api-key, are never stored, on the span, its events, or its resource.
• Inline media bytes in messages and raw payloads are replaced by a placeholder recording the media type and size.
• Embedding vectors (OpenInference’s embedding.embeddings.N.embedding.vector, the Vercel AI SDK’s ai.embedding / ai.embeddings) are dropped. The embedded texts are kept.

Next steps

• Vanilla OpenTelemetry SDKs: emitting these attributes from any language.
• OpenTelemetry Collector: routing them through a collector pipeline.