Skip to Content

How do I move my projects from Traceloop to Rius?

Rius maps each Traceloop project to an agent named by service.name, so you move a project by re-pointing OpenLLMetry’s exporter at Rius and keeping the same app name. Your decorators and auto-instrumentation keep working, and each environment such as production or staging gets its own Rius workspace and API key. Traceloop platform features such as monitors, evaluators, prompt registry, datasets and experiments have no Rius counterpart. The full walkthrough is in Migrate from Traceloop to Rius, and the general approach is in Migrate to Rius.

How it works

Traceloop’s SDK is OpenLLMetry, which exports plain OpenTelemetry traces to whatever endpoint you give it. Rius takes OTLP over HTTP with a Bearer API key, so a project moves through configuration, not re-instrumentation.

The concept mapping for a project looks like this:

  • Project: becomes an agent. Rius groups traces by agent, and the agent name is the service.name, which comes from your app_name (Python) or appName (TypeScript).
  • Environment: becomes a workspace. Create one workspace and one API key for each environment, for example production and staging.
  • Conversation: becomes a session. @conversation, set_conversation_id and withConversation write gen_ai.conversation.id, which Rius reads as the session. Set the conversation id before the root span starts, because Rius lists a trace under the session of its root span.
  • Association properties: stay span attributes. Values such as user_id and chat_id are stored under traceloop.association.properties.* and you can filter on them, but Rius does not treat them as users or sessions.
  • Workflow, task, agent and tool spans: workflows and tasks appear as generic steps, agents as agent spans and tools as tool spans, each named after the decorated function.
  • LLM calls: appear as generations with model, token counts and cost computed by Rius.

Set it up

  1. Create a Rius workspace and API key for each environment you run today, so a Traceloop project with production and staging becomes two workspaces.

  2. Point OpenLLMetry at Rius. Set the base URL to https://ingest.eu.console.rius-glassflow.com and send your Rius API key as a Bearer token. Keep app_name as the name you want the agent to have in Rius:

    import os from traceloop.sdk import Traceloop Traceloop.init( app_name="my-agent", api_endpoint="https://ingest.eu.console.rius-glassflow.com", headers={"Authorization": f"Bearer {os.environ['RIUS_API_KEY']}"}, )

    In TypeScript, call initialize() from @traceloop/node-server-sdk with appName, baseUrl and headers set the same way.

  3. Clean up leftover settings. In Python, TRACELOOP_BASE_URL and TRACELOOP_HEADERS override the arguments to Traceloop.init(), so remove old values from your deployment. Remove TRACELOOP_API_KEY too, because the Rius header replaces it. Use an http or https URL, since Rius accepts OTLP over HTTP only.

  4. In Python, set TRACELOOP_METRICS_ENABLED to false. The Python SDK also exports metrics to the same base URL, Rius ingests traces only, and those requests would fail with a 404 on every export. Traces are unaffected either way.

  5. Set user.id if you want Rius users. OpenLLMetry does not set it, so add it with the OpenTelemetry API inside your outermost decorated function, which is the span that starts the trace:

    from opentelemetry import trace trace.get_current_span().set_attribute("user.id", user_id)
  6. Verify one traced request. The trace tree should show your workflow, agent and tool spans, the generation should show model and tokens with a cost, and traces that share a conversation id should share a session.

  7. Optionally, move to the Rius SDK later. Decorators map one to one onto observe with a span kind, rius.session replaces conversation ids and rius.user sets user.id. Remove OpenLLMetry in that process, because running both produces duplicate LLM spans.

What you get

  • Each Traceloop project shows up as an agent in Rius, with its traces, models, token counts and cost. Cost is a list-price estimate in US dollars, computed by Rius, so you never send a cost value.
  • Each environment is isolated in its own workspace with its own API key.
  • Conversations become sessions, and users appear once you set user.id.
  • Your existing decorators and auto-instrumentation keep working, with no re-instrumentation.
  • You can run both backends in parallel through an OpenTelemetry Collector, then cut over when Rius shows what you need. The Traceloop guide has the Collector configuration.

Some things have no counterpart in Rius:

  • Monitors, evaluators, guardrails, the prompt registry, playgrounds, datasets, experiments, user feedback and annotation tasks.
  • Traceloop Hub, since Rius has no LLM gateway or proxy.
  • Self-hosting. Rius is a managed service only.
  • Historical data. Existing traces stay in Traceloop, and Rius starts from the first span you send.
  • OpenLLMetry metrics. Rius ingests traces only and computes token, cost and latency analytics from the spans.

In Python, re-pointing OpenLLMetry at Rius also switches off Traceloop’s platform client, so get_prompt(), guardrails, feedback, datasets and experiments stop working in that process.

When something else fits

  • If your code calls get_prompt(), guardrails, datasets or experiments, keep OpenLLMetry pointed at Traceloop and add Rius through a Collector fan-out instead of re-pointing.
  • If evaluators or a prompt registry are central to your workflow, keep Traceloop for those pieces and use Rius for tracing, cost and alerts.
  • If you need to bring old traces over or host the platform yourself, Rius does not offer either, so plan to keep that data where it is.

Still stuck? Get help

Last updated on