Skip to Content

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

KeyStabilityTypeDescriptionExamples
rius.aggregated_usage.<key>DevelopmentintA whole agent run’s token usage, moved off gen_ai.usage.* so per-call usage is not counted twice; the suffix is the gen_ai.usage.* suffix. [1]115; 42
rius.command.classDevelopmentstringWhat kind of work a shell tool call ran, as one word, never the command itself. [2]test
rius.compaction.context_windowDevelopmentintThe size of the model’s context window, in tokens, when the compaction ran. [3]200000
rius.compaction.executorDevelopmentstringWho performed the compaction: the client that sent the request, or the provider. [4]client; provider
rius.compaction.idDevelopmentstringThe identifier the provider or the agent gave one compaction, when it has one. [5]cmp_9f3a2c
rius.compaction.kindDevelopmentstringWhat a compaction did to the context: summarize, clear_tool_results, clear_thinking or truncate. [6]summarize; clear_tool_results
rius.compaction.messages.compactedDevelopmentintHow many messages the compaction replaced or removed. [7]42
rius.compaction.messages.keptDevelopmentintHow many messages the compaction left in the context as they were. [8]6
rius.compaction.summary.bytesDevelopmentintThe size of the summary that replaced the compacted context, in bytes. [9]4096
rius.compaction.summary.textDevelopmentstringThe text of the summary that replaced the compacted context. [10]The user is migrating the billing service to the new queue. The consumer is done; the retry policy is still open.
rius.compaction.tokens.afterDevelopmentintTokens in the context just after the compaction. [11]31000
rius.compaction.tokens.beforeDevelopmentintTokens in the context just before the compaction. [12]168000
rius.compaction.tokens.droppedDevelopmentintHow many tokens the compaction removed from the context. [13]137000
rius.compaction.tool_results.clearedDevelopmentintHow many tool results the compaction emptied. [14]18
rius.compaction.triggerDevelopmentstringWhat started the compaction: the context filling up (auto) or a request to compact (manual). [15]auto; manual
rius.context.sizesDevelopmentanyByte sizes of each part of a generation’s context (tool definitions, input and output messages), as compact JSON. [16]{"version":1,"input_messages":[{"role":"system","parts":[{"type":"text","bytes":19}]},{"role":"user","parts":[{"type":"text","bytes":18}]}],"output_messages":[{"role":"assistant","parts":[{"type":"text","bytes":6}]}]}; {"version":1,"input_messages":[{"role":"user","parts":[{"type":"text","bytes":14},{"type":"blob","modality":"image","byte_size":48213}]}],"output_messages":[{"role":"assistant","parts":[{"type":"text","bytes":31}]}]}
rius.hint.channelDevelopmentstringHow the hint reached the agent: drain, callback or inject. [17]drain; inject
rius.hint.codeDevelopmentstringThe code of the detector that produced the hint. [18]CF-01
rius.hint.idDevelopmentstringThe identifier of the hint that was delivered: h_ followed by a ULID. [19]h_01JCX9Q4M8T6Y2S3K7B5N0RZ1A
rius.hint.template_versionDevelopmentintThe version of the wording template the hint’s text was rendered from. [20]1; 3
rius.main_agent.versionDevelopmentstringVersion of the agent definition (prompt, tools and policy) this process runs, independent of service.version. [24]7; 2026-10-01
rius.parent.foreignDevelopmentbooleanThe span’s parent is local to this process but was never received by Rius, so the trace arrives without it. [25]true
rius.request.<key>DevelopmentanyA request parameter the GenAI conventions do not define, keyed by the parameter’s name as the caller spelled it. [26]flex; true; {"type":"json_object"}
rius.request.tool_choiceDevelopmentstringHow the request constrained tool use: a mode string, or the provider’s forced-call object as compact JSON. [27]auto; required; {"type":"function","function":{"name":"get_weather"}}
rius.sdk.global_providerDevelopmentstringThe tracer provider that already held the OpenTelemetry global when Rius initialized, as foreign:<class>. [28]foreign:opentelemetry.sdk.trace.TracerProvider; foreign:NodeTracerProvider
rius.span.pendingDevelopmentbooleanMarks the content-free snapshot of a span that is exported when the span starts, before the real span ends. [29] Former spelling: glassflow.span.pending.true
rius.workspaceDevelopmentstringAlias of the workspace a span is exported to when one process sends to several; stripped before the span leaves the process. [30]acme; customer-eu

Events

NameStabilityDescription
rius.compactionDevelopmentThe context of this model call was compacted inside the request. [31]
rius.hint.deliveredDevelopmentThe SDK handed a hint from Rius to the agent. [32]

Deprecated

KeyTypeReplaced byDescription
rius.main_agent.descriptionstringgen_ai.main_agent.descriptionWhat 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.idstringgen_ai.main_agent.idStable 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.namestringgen_ai.main_agent.nameName 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.

Last updated on