OpenTelemetry gives you a vendor-neutral way to collect traces and metrics from your services. Where you send that data is a separate decision, and FusionReactor is one of the destinations you can wire up with a small amount of YAML.
According to a guide from FusionReactor, you can route OpenTelemetry data to the FusionReactor Cloud by configuring an OpenTelemetry Collector with the right exporters and your API key. The setup is a few minutes of work and gives you real-time visibility into your apps.
The short version
- OpenTelemetry is a vendor-neutral framework for collecting telemetry data.
- FusionReactor supports OpenTelemetry via its Cloud API.
- You ship data by configuring an OTel Collector with YAML.
- Two exporters are used: `otlphttp` for traces and `prometheusremotewrite` for metrics.
- You authenticate with an API key generated in FusionReactor Cloud.
Why route OpenTelemetry data anywhere
OpenTelemetry collects traces, metrics, and logs from your services using a standard format. The "OTel" pipeline is the same regardless of where the data ends up. That is the point. You are not locked into one vendor's agent or schema.
FusionReactor's pitch is that it gives you a place to send that pipeline output, then turns it into dashboards, alerts, and root-cause analysis. If you already run an OTel pipeline, the guide shows how to add FusionReactor as another destination without rewriting anything.
The YAML configuration
The setup is built around an OpenTelemetry Collector config file. The file declares receivers and exporters and wires them together through pipelines.
For traces, the collector receives over OTLP HTTP on port 4318 and ships them out via the `otlphttp` exporter to FusionReactor's API endpoint. For metrics, the same OTLP receiver feeds a `prometheusremotewrite` exporter pointed at FusionReactor's metrics endpoint. Both exporters carry an `Authorization` header containing your API key.
The example config in the guide uses an HTTP endpoint at `https://api.fusionreactor.io` for traces and `https://api.fusionreactor.io/v1/metrics` for metrics. You can swap HTTP for gRPC if your collector supports it.
Getting an API key
Authentication is a FusionReactor API key. You generate it inside FusionReactor Cloud under Account Settings, then paste it into the `Authorization` field of both exporter blocks. The guide shows placeholder values; you replace them with your real key.
Treat it like any other secret. Do not paste it into source control. Use environment variables or a secret manager and have the collector read from those at runtime.
Step-by-step at a glance
- Create `otel-config.yaml` with the receivers, exporters, and pipelines shown above.
- Set the trace exporter endpoint to `https://api.fusionreactor.io` and metrics to `https://api.fusionreactor.io/v1/metrics`.
- Generate an API key in FusionReactor Cloud under Account Settings, API Keys.
- Replace the placeholder `Authorization` values in your YAML with the real key.
- Start the collector and verify that data lands in your FusionReactor dashboard.
Our analysis
OpenTelemetry's value is exactly this kind of portability. You are not locked in. If FusionReactor stops being the right fit, you point the same collector at another backend and your services do not change.
Worth watching next: the cost model. Most observability vendors price by data volume, and shipping traces plus metrics to two destinations can roughly double your ingest cost. Before turning on a new exporter, check whether FusionReactor's billing makes the move worth it.
Worked example: adding FusionReactor to an existing pipeline
Say you already run an OTel Collector that ships data to your primary backend. Add FusionReactor as a second exporter by duplicating the exporter block, swapping in the FusionReactor endpoint and your API key, and adding the new exporter to the pipeline's `exporters` list. Restart the collector. From that point on, every span and metric that hits the collector also lands in FusionReactor, and your existing setup keeps running unchanged.
Bottom line
If you already use OpenTelemetry, adding FusionReactor as a destination is a small config change. Generate an API key, point the right exporters at FusionReactor's endpoints, and you have a second observability backend without touching your services.
Key takeaways
- Configure an OTel Collector with `otlphttp` and `prometheusremotewrite` exporters.
- Authenticate with an API key from FusionReactor Cloud.
- Use environment variables for secrets, not hardcoded values.
Frequently asked questions
What exporters does FusionReactor support?
The guide uses `otlphttp` for traces and `prometheusremotewrite` for metrics.
Where do I get an API key?
Inside FusionReactor Cloud under Account Settings, then API Keys, then Generate.
Can I use gRPC instead of HTTP?
Yes. The guide notes you can use gRPC if your collector supports it.
Do my services need to change?
No. Services emit OTLP to the collector as usual. The collector fans out to multiple exporters.
Does this work for logs too?
The example focuses on traces and metrics. OpenTelemetry supports logs through a similar exporter pipeline if you want to add them.