How do I move my production and staging environments from Langfuse to Rius?

In Rius, you move production and staging by giving each environment its own workspace and API key, then pointing each environment at its own key. Your instrumentation can stay as it is, because Rius takes OpenTelemetry traces. Start with staging, compare it with Langfuse, then repeat for production. The full concept map is in Migrate from Langfuse, and the wider process is in Migrate to Rius.

How it works

Each trace in Rius belongs to one workspace, and the API key it is sent with decides which one. That makes the key your environment switch.

• Environments: create one Rius workspace for production and one for staging, and mint an API key in each. Production traces and staging traces never mix, because each key writes to only one workspace.
• Projects: a Langfuse project maps to an agent in Rius, named by service.name. Inside each workspace, traces are grouped by agent.
• Traces, sessions and users: these map directly. A Langfuse user_id becomes user.id in Rius, and sessions stay sessions.
• What does not carry over: scores, annotation queues, evals, datasets and prompt management have no Rius equivalent. Existing traces stay in Langfuse, and Rius starts from the first span you send it. Langfuse can be self-hosted, but Rius is a managed service only.

If you depend on scores, evals or prompt management for an environment, keep Langfuse for those and send traces to both tools.

Set it up

1. Create the workspaces and keys. Sign up, then create a staging workspace and a production workspace, each with its own API key. The quickstart shows how to mint a key. Keys start with ri_.

2. Pick your path per service. If you send OTLP to Langfuse (OpenLLMetry, OpenInference, a plain OpenTelemetry SDK or a Collector), keep your instrumentation and change only the exporter settings. If you use the Langfuse SDK, swap it for the Rius SDK.

3. Path A: re-point the exporter. Set the staging key in staging deployments and the production key in production deployments. Nothing else differs between the two:

# Before: pointing at Langfuse
export OTEL_EXPORTER_OTLP_ENDPOINT="https://cloud.langfuse.com/api/public/otel"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Basic <base64 public:secret>"
 
# After: pointing at Rius
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingest.eu.console.rius-glassflow.com"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_HEADERS="authorization=Bearer <your API key>"

Rius takes OTLP over HTTP, not gRPC. Set OTEL_SERVICE_NAME if your setup does not already set a service.name, since that name becomes the agent.

4. Path B: swap the SDK. Replace the Langfuse client with rius.init, and set RIUS_API_KEY in each environment to that environment’s key. The key pair of Langfuse becomes one key:

import rius
 
client = rius.init(service_name="my-agent")  # reads RIUS_API_KEY

Then map @observe() to @rius.observe, propagate_attributes(session_id=...) to with rius.session(session_id): and propagate_attributes(user_id=...) to with rius.user(user_id):. The migration guide has the full table of calls.

5. Move staging first. Keep sending to Langfuse as well, either by running the swapped SDK in one service or by adding Rius as a second exporter in your Collector. Check that the trace tree, model, token counts and cost look right.

6. Repeat for production. Use the production key, compare both backends on real traffic for a few days, then move any dashboards or alerts that read from Langfuse. Remove the Langfuse exporter or SDK, and revoke the Langfuse keys once nothing sends to them.

What you get

• Separate production and staging workspaces, so staging experiments never show up in production traces, cost or users.
• In each workspace, traces grouped by agent, with sessions, users, token counts and server-side cost. Cost is a list-price estimate in US dollars.
• A reversible migration. Both backends can receive the same spans until you revoke the Langfuse keys.
• A staging environment that works as a dress rehearsal, so you confirm attributes and cost before touching production.
• New organizations start on a trial of 30 days or 500,000 spans, whichever comes first, with no card needed.

When something else fits

• If scores, annotation queues, evals, datasets or prompt management are central to how you run an environment, keep Langfuse for those workflows, because Rius does not offer them.
• If you must self-host your observability backend or import historical traces, Rius does not cover that, since it is a managed service and starts from the first span you send.

Related