rius namespace
The rius namespace is the one this registry owns: a fact no OpenTelemetry
convention names gets a key here.
Generated from rius-semconv 1.12.0, the Rius attribute registry, and updated on each of its releases.
Attributes
Events
| Name | Stability | Description |
|---|---|---|
rius.compaction | Development | The context of this model call was compacted inside the request. [31] |
rius.hint.delivered | Development | The SDK handed a hint from Rius to the agent. [32] |
Deprecated
| Key | Type | Replaced by | Description |
|---|---|---|---|
rius.main_agent.description | string | gen_ai.main_agent.description | What the agent this process is does, in free text. [21] Moved to gen_ai.main_agent.description, which the OpenTelemetry GenAI conventions now define for the same fact. The SDKs stamp both through the deprecation window; readers take gen_ai.main_agent.description first. |
rius.main_agent.id | string | gen_ai.main_agent.id | Stable identifier of the agent this process is, unchanged across restarts and deployments. [22] Moved to gen_ai.main_agent.id, which the OpenTelemetry GenAI conventions now define for the same fact. The SDKs stamp both through the deprecation window; readers take gen_ai.main_agent.id first. This key only ever carried a configured id, while gen_ai.main_agent.id falls back to the agent name when none is configured. |
rius.main_agent.name | string | gen_ai.main_agent.name | Name of the agent this process is, stamped once on the resource. [23] Moved to gen_ai.main_agent.name, which the OpenTelemetry GenAI conventions now define for the same fact. The SDKs stamp both through the deprecation window; readers take gen_ai.main_agent.name first. |
Notes
[1] rius.aggregated_usage.<key>: Where a whole agent run’s token usage goes when the same producer also
reports each model call’s usage on that call’s own span:
gen_ai.usage.<suffix> becomes rius.aggregated_usage.<suffix>, on the
in-process (INTERNAL) invoke_agent span only. Left under gen_ai.usage.*,
the run’s tokens are counted once per call span and once more on the
agent span by any backend that sums usage across spans.
Applied only to producers KNOWN to repeat the usage on per-call spans, because a span on its own cannot say whether its usage is an aggregate or the only record. CLIENT invoke_agent spans keep their usage: a remote agent’s model calls are not in the trace.
The same move covers a wrapper span that repeats ONE call’s usage: a LiteLLM completion span whose child, the openai instrumentor’s ChatCompletion span, records the call. The child keeps gen_ai.usage.*, since it is the call itself. Decided from end order (a child ends before its parent), so a LiteLLM span with no such child keeps its usage.
Our namespace, not pydantic-ai’s gen_ai.aggregated_usage.*: the GenAI conventions define no aggregate yet (semantic-conventions-genai#19), and one could be defined later with different semantics (sub-agents included or not). A backend reads both spellings, for display only; totals read gen_ai.usage.* alone.
[2] rius.command.class: Classified on the user’s machine from the command line, which is never
sent: test, build, lint, package, git, or other. Lets a trace show what a
running or failed shell call was doing without exporting the command.
Claude Code’s own telemetry has a similar bash_command_class; no
convention defines the fact.
[3] rius.compaction.context_window: The limit the context was measured against, so tokens.before reads as how
full the window was. Shared form of what Cursor’s preCompact hook reports
as cursor.context.context_window_size.
[4] rius.compaction.executor: client when the application or agent did the work (it summarized the
history itself, or cut it before sending), provider when the model
provider did it on its side (context editing, a server-side compaction
call). It tells a reader whose behaviour to look at when context
shrinks: the agent’s own policy, or a provider setting. Required where
rius.compaction.kind is, for the same reason.
[5] rius.compaction.id: Lets a reader join a compaction to the record the provider or the agent
keeps for it. Set only when one exists: an id is never made up, as with
gen_ai.conversation.id.
[6] rius.compaction.kind: How the context was shrunk: summarize (a summary replaces older turns),
clear_tool_results (old tool results are emptied), clear_thinking (old
thinking blocks are dropped) or truncate (old turns are cut with nothing
in their place). A reader needs it because the four lose different
things, and a drop in context between two calls means something else
after each.
Required on a compaction span and a rius.compaction event, which is why
it is conditionally required rather than required: only those carry it,
and a CHAIN or LLM span that is no compaction has nothing to say here.
The span form is keyed by gen_ai.operation.name, not by the span name:
the registry’s conventions already key spans by the operation, and
taxonomy.yaml maps “compaction” to the CHAIN kind from it, so a reader
that finds compaction spans by operation needs no name parsing.
A Rius key under rius.*, never gen_ai.*: no convention defines a
compaction span or event, and the GenAI registry is free to define one
later and mean something else.
[7] rius.compaction.messages.compacted: The number of messages that were summarized, cut or emptied, whichever
the kind says.
[8] rius.compaction.messages.kept: The messages the next call still sees unchanged, usually the most recent
turns. The summary, when there is one, is not counted here.
[9] rius.compaction.summary.bytes: A size, not content, like rius.context.sizes: deliberately absent from
CONTENT_ATTRIBUTES, so it survives masking and capture_content=False and
a reader can see how big the summary was when its text is withheld.
[10] rius.compaction.summary.text: What the summary said, for a summarize compaction. Content in the same
sense messages are: a summary restates the conversation, so it is on
CONTENT_ATTRIBUTES and is masked or stripped at export. Never on a
pending snapshot, since it exists only once the compaction ran.
A leaf under rius.compaction.summary rather than the key itself, so the
name is not also the namespace of rius.compaction.summary.bytes, which
the OpenTelemetry naming rules do not allow for an attribute.
[11] rius.compaction.tokens.after: The size of the context the compaction left behind, measured the same
way as rius.compaction.tokens.before.
[12] rius.compaction.tokens.before: The size of the context the compaction started from, in the model’s
tokens. Not gen_ai.usage.input_tokens: that bills one request, while this
measures the context window’s contents at a point in time.
[13] rius.compaction.tokens.dropped: What the compaction removed: tokens.before minus tokens.after when both
are known. Its own key because a provider that clears tool results often
reports only how much it cleared and never the two sizes, and a reader
should not have to subtract to answer “how much was lost”.
[14] rius.compaction.tool_results.cleared: Set for a clear_tool_results compaction, where the messages stay but
their tool results are replaced by a placeholder, so
rius.compaction.messages.compacted does not describe the loss.
[15] rius.compaction.trigger: auto when the producer or provider compacted because the context neared
its limit, manual when a person or the calling code asked for it (a
/compact command, an explicit call). Absent when the producer cannot
tell. It separates a compaction that was a cost of the run from one
somebody chose.
[16] rius.context.sizes: Per-part byte sizes of a generation’s context, as compact JSON with
readable keys: tool_definitions (name, bytes), input_messages and
output_messages (literal role, parts typed text / tool_call /
tool_call_response with bytes and tool name), cache_marker, and a folded
summary of older input.
A media part (blob / uri / file) carries its modality (image, video,
audio or document) and, when known, byte_size, never bytes: the size of
the media itself, not of any content, which a blob does not carry.
A Rius vendor attribute, NOT a convention:
the backend reads it to attribute gen_ai.usage.input_tokens across the
context, and no convention describes context composition. Deliberately
absent from CONTENT_ATTRIBUTES (it is sizes, not content, and must survive
masking and capture_content=False; that is its whole point when the
messages are truncated or stripped) and from PENDING_IDENTITY_ATTRIBUTES
(content is unknown at span start, so a pending snapshot never has it).
[17] rius.hint.channel: drain when the agent’s own code pulled the hint (drain_hints()),
callback when the SDK passed it to an on_hint callback, inject when a
framework hook added it to a model call just before the call. Only
inject guarantees the model saw the hint; with drain and callback the
agent’s code decides what to do with it. Measuring whether hints help
needs to tell the two apart.
[18] rius.hint.code: Which problem the hint is about, as Rius named it. Copied from the hint
so that measuring whether hints help can group deliveries by detector
straight from the trace. The SDK copies it and never interprets it.
Not gen_ai.prompt.name: a hint is not a managed prompt, and the model
call a hint is injected into may carry the agent’s own
gen_ai.prompt.name and gen_ai.prompt.version, naming that call’s prompt.
[19] rius.hint.id: The hint’s id exactly as Rius sent it, the same on every redelivery. It
is the join key to the record Rius keeps for each hint it writes, which
holds the run the hint is about, its code, the text the agent received
and when it was written, so a reader finds what the hint said and how
long it took to arrive without the event repeating any of it.
The SDK de-duplicates on the id, so a hint Rius sends again gives no
second event on the same channel. A hint can reach the agent through
more than one channel and gives one event for each: at most one per
(rius.hint.id, rius.hint.channel). A count of hints delivered must
deduplicate on rius.hint.id.
[20] rius.hint.template_version: Each code’s wording is versioned, and a change of wording bumps the
version, so two wordings of the same hint can be compared. An int, as
Rius sends it. Not gen_ai.prompt.version, for the reason given on
rius.hint.code.
[21] rius.main_agent.description: Deprecated: moved to gen_ai.main_agent.description.
[22] rius.main_agent.id: Deprecated: moved to gen_ai.main_agent.id.
Took the same stability constraint the conventions put on gen_ai.agent.id:
a transient in-memory or process-local id here would mint a new “agent”
every restart and make the key useless for grouping.
[23] rius.main_agent.name: Deprecated: moved to gen_ai.main_agent.name.
Named the agent this process is before the conventions had a key for it.
[24] rius.main_agent.version: The version of the agent DEFINITION (its prompt, tools and policy), which is
deliberately NOT service.version. A service can sit at 2.3.1 while its
agent definition is at 7, and the two move independently; deriving either
from the other produces confidently wrong data on every deployment where
they disagree, which is most of them.
[25] rius.parent.foreign: On a span: its parent is local to this process, yet rius never received
it, so the trace arrives without that parent. Remote parents are never
flagged.
[26] rius.request.<key>: Where a request parameter the GenAI registry does NOT define goes. Our own
namespace rather than gen_ai.request.<key>, per OTel’s naming guidance: an
existing semantic-convention namespace must not be used as a prefix for
application-specific attributes, because the convention is free to define
that exact key later and mean something else. The GenAI conventions offer
no catch-all of their own, so we own one.
Masking: rius.request.* follows gen_ai.request.* exactly. Today neither is in CONTENT_ATTRIBUTES, so both export in clear. The TIE is the rule, not the current value: if request parameters ever become maskable, both namespaces change together, and neither may join the content allowlist alone.
[27] rius.request.tool_choice: How the request constrained tool use: a mode string (“auto”, “required”)
or, for a forced call, the provider’s object as compact JSON. The GenAI
conventions define no tool_choice, so it lives in our namespace. Context
attribution reads it to price the tool-use preamble, which is why the
normalizer lifts it out of the OpenInference request bag (content) into
here (not content).
[28] rius.sdk.global_provider: On the resource: foreign:<module.Class> when another provider already
held the OpenTelemetry global at init(). Absent when rius registered the
global.
[29] rius.span.pending: Marks the content-free snapshot exported at span START; the backend maps it
to Finished=0 and the real span replaces it at end. This key knowingly bends
the convention-native rule (no vendor namespace): OpenTelemetry has NO
pending-span mechanism to align with (spec #3732/#4646, semconv #2133, all
open, none planned), and the only shipping precedent (Logfire’s
logfire.span_type) is equally vendor-namespaced. Spelled glassflow.span.pending
before the vendor keys moved under rius.*; the backend reads both spellings
for as long as pre-rename SDK versions are in the field.
[30] rius.workspace: Process-local routing marker for multi-workspace export. Stamped at span
start so pending snapshots route too, and ALWAYS stripped by the routing
exporter before spans leave the process: the destination’s API key is what
tells the backend which workspace a span belongs to.
[31] rius.compaction: A compaction that happens inside one request, with no step of its own:
the provider edits the context as part of the call, or the agent’s hook
reports it while the call is open. It is an event on that LLM span and
carries the rius.compaction.* attributes. A compaction that is a step of
its own is a CHAIN span with gen_ai.operation.name “compaction” instead,
never both for the same compaction. Every LLM call that runs on the
compacted context sets gen_ai.conversation.compacted.
[32] rius.hint.delivered: Recorded when the SDK hands a hint to the agent: drain_hints() returns
it, an on_hint callback receives it, or a framework hook adds it to a
model call. For every channel, the event goes on the root span of the
run the hint is about (the hint’s trace_id). The SDK keeps each run’s
root span while the run is open, and Rius delivers a hint only while
its run is open. A hint with no trace_id is about the instance as a
whole: its event goes on the current span if one is recording, and
otherwise no event is recorded.
One run can get several hints, so its root span can carry several of
these events, one per hint and channel: at most one per
(rius.hint.id, rius.hint.channel). A count of hints delivered must
deduplicate on rius.hint.id.
It carries the rius.hint.* attributes and never the hint’s text, which
the record Rius keeps for each hint it writes holds under the id.
It records delivery, not the acknowledgement on the heartbeat: an ack
only tells Rius to stop sending the hint, and the SDK acks hints it
drops as well.
For inject, nothing else is needed to measure whether a hint helped. The
hint’s run is the trace the event sits in, and the model calls after the
hint are the LLM spans of that trace that start after the event’s
timestamp. The hint’s id joins the event to the record Rius keeps for each
hint it writes (its code, its run, when it was written). A key on each
later model call naming the hints it carried would repeat what that join
gives. With drain or callback, this event only says the agent’s code
received the hint: the SDK cannot know whether the code passed it to the
model, acted on it itself, or ignored it, so measuring those needs a
record from the agent’s code.