Can I keep my OpenTelemetry instrumentation when I leave Langfuse?

Yes, Rius accepts your existing OpenTelemetry instrumentation, so you keep it and change only where the OTLP exporter sends traces. OpenLLMetry, OpenInference, plain OpenTelemetry SDKs and an OpenTelemetry Collector all stay as they are. Rius reads the models, token counts and session and user attributes on those spans and computes cost itself. Only code written against the Langfuse SDK itself needs a swap.

How it works

Spans from OpenTelemetry instrumentation are standard OTLP, so they are not tied to Langfuse. Only the exporter settings point at Langfuse.

What can stay

• OpenLLMetry (the Traceloop SDK).
• OpenInference instrumentors.
• A vanilla OpenTelemetry SDK in any language.
• An OpenTelemetry Collector that forwards to Langfuse’s OTLP endpoint.

What does not stay

Code that calls the Langfuse SDK directly, such as @observe or start_as_current_observation, uses Langfuse’s own exporter and auth, so you cannot point it at Rius. Swap it for the Rius SDK, which has the same shape: a decorator, context managers for spans and generations, and session and user scopes. The Langfuse migration guide maps each call.

What Rius reads from your spans

• The OpenTelemetry GenAI attributes (gen_ai.*), the OpenInference attributes and OpenLLMetry’s attributes. Rius normalizes these at ingest, so model, token and cost analytics work with any of them.
• The model (gen_ai.request.model) and the token counts, including gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, and cache and reasoning tokens when present. Rius computes cost per call from these, as a list-price estimate in US dollars. You never send a cost attribute. A model Rius cannot price gets an empty cost, not zero.
• service.name, which names the agent your traces are grouped under.
• session.id and user.id, which drive sessions and the Users page. Set both on every span, the root included. Without session.id a trace is its own session, and without user.id it counts as anonymous.

Rius takes OTLP over HTTP, with http/protobuf recommended. It does not accept gRPC, and it ingests traces only, not OTLP metrics or logs.

Set it up

1. Create a Rius workspace and an API key. Keys start with ri_. The Migrate to Rius guide covers the overall path.

2. Change the exporter settings. Traces post to the base address https://ingest.eu.console.rius-glassflow.com plus /v1/traces, and the key goes in a Bearer header:

# 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>"

3. Set OTEL_SERVICE_NAME if your setup does not already set a service name, so the agent has a name in Rius.

4. To compare both backends first, keep Langfuse and add Rius as a second exporter in your Collector. Use the otlphttp exporter:

exporters:
  otlphttp/langfuse:
    endpoint: https://cloud.langfuse.com/api/public/otel
    headers:
      authorization: Basic ${env:LANGFUSE_BASIC_AUTH}
  otlphttp/rius:
    endpoint: https://ingest.eu.console.rius-glassflow.com
    encoding: proto
    compression: gzip
    headers:
      authorization: Bearer ${env:RIUS_API_KEY}
 
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/langfuse, otlphttp/rius]

5. Send one request and open its trace. Check that the tree looks right, the model call shows a model and token counts, and cost appears. If those fields are empty, compare your attribute names with the supported conventions in Interoperability.

6. Once the numbers match on real traffic, remove the Langfuse exporter and revoke the Langfuse keys.

What you get

• Your existing spans arrive unchanged, with no re-instrumentation.
• Traces grouped by agent, with models, token counts and server-side cost estimates on each call.
• Sessions and users, as long as session.id and user.id are on your spans.
• A reversible move: while both exporters run, you can compare trace trees, token totals and cost on identical traffic before you cut over.

When something else fits

• Rius has no scores, evals, datasets or prompt management. If you rely on them, keep Langfuse for those and send traces to both.
• Rius is a managed service only, so it cannot replace a self-hosted Langfuse deployment. Existing Langfuse traces stay there, and Rius starts from the first span you send.
• If your code uses the Langfuse SDK directly, plan the SDK swap in the Langfuse migration guide instead of an exporter change.

Related