LinkMesh

Search docs, blog and changelog

ENDE

OpenTelemetry routing

Route telemetry to the right backend — by label, environment, or tenant

One pipeline can’t serve every team, and wiring each collector to a single backend is lock-in. LinkMesh manages routes that fan telemetry from your OpenTelemetry Collectors to multiple destinations — Splunk, Grafana, object storage, any OTLP backend — with a different processing chain per route. Self-hosted, vendor-neutral, and priced per collector, not per gigabyte.

Start free →

25 Collectors free after a no-card registration · 5 without one How the free tier works

One destination for everything doesn’t scale

Teams need different telemetry in different places, at different price points. Hard-wire it to a single backend and you get sprawl, lock-in, and duplicated data. These are the failure modes a routing layer exists to fix.

One pipeline can’t serve every team

Security wants logs in one place, SRE wants metrics somewhere else, finance wants slow queries in a third. A single hard-wired pipeline forces everyone onto the same destination.

Per-team collector sprawl

Give each team its own collector to reach its own backend and you get a fleet of near-duplicate agents, each configured by hand and drifting from the rest.

One backend is lock-in

Couple every collector directly to a single vendor and switching — or even adding — a backend becomes a fleet-wide rewrite you keep postponing.

Dual-shipping duplicates data

Sending the same telemetry to two destinations the naive way doubles what you store and pay for, and leaves you reconciling two copies that quietly diverge.

Everything pays premium prices

When there’s no layer deciding what belongs where, low-value debug output lands in the same expensive backend as your security-critical logs.

No visibility into where data goes

Ask which telemetry flows to which destination, at what rate, and the honest answer is buried in per-host config files nobody has read in months.

One collector layer, many destinations

Sources feed your collectors; LinkMesh manages the routing policy that decides where each stream goes; the collectors fan telemetry out to every destination — Splunk, Grafana or Loki, object storage, any OTLP backend. LinkMesh pushes the route config and reads health, and the telemetry never passes through it.

CONTROL PLANE · route config, health (never telemetry)LinkMesh — self-hosted control planemanages the routing policy on every collectorroute config · healthSourceshosts · K8sapps · syslogCollector Fleetrouting policy · per-route chainotelcol-contrib · Grafana Alloymanaged by LinkMeshSplunk · security logsGrafana · LokiObject storage · archiveAny OTLP backendtelemetryrouted
Routing runs on the collectors, which fan telemetry out to every destination. LinkMesh manages the routes and stays out of the data path.

01

Route by label, environment, or tenant

Problem

Different telemetry belongs in different places, but a hard-wired pipeline sends everything to one destination regardless of what it is or who owns it.

LinkMesh

Define routes that match on labels, environment, source, or tenant, and send each stream to the destination that fits. One collector reads the rules LinkMesh renders and fans telemetry out accordingly — no per-team agent required.

The right telemetry reaches the right backend, decided by rule instead of by wiring.

How routes fan telemetry to backends →

02

A different processing chain per route

Problem

A single processing pipeline treats every destination the same, even though what Splunk should receive and what object storage should receive are rarely identical.

LinkMesh

Each route carries its own chain of processors — filter, sample, mask, transform — so you can trim and redact for one destination while sending fuller records to another, all from the same collector.

Tailor what each backend receives without standing up a separate collector for it.

How processors transform telemetry →

03

Dual-ship without duplicates

Problem

Sending the same telemetry to two backends the naive way doubles storage and cost, and leaves two copies that drift apart over time.

LinkMesh

Fan a stream to more than one destination from a single route, with per-route filtering so each copy carries only what that backend needs — the security index gets the security fields, the archive gets the rest. One source, deliberate copies.

Send telemetry to two places on purpose, without paying twice for the same records.

How-to: filter records on a route →

04

Tier to cheaper storage

Problem

When one pipeline sends everything to a premium backend, low-value telemetry pays the same per-gigabyte price as the data you query every day.

LinkMesh

Route high-value logs to your primary backend and fan the rest to object storage or a cheaper OTLP destination — Grafana Loki, an archive bucket, anywhere. The split is a route rule, not a second collector.

Keep premium storage for what earns it; everything else stops paying premium prices.

How-to: route telemetry to Grafana Loki →

05

Vendor-neutral — swap a backend without touching collectors

Problem

Collectors coupled directly to one vendor make every backend change a fleet-wide rewrite, which is exactly how a cost or migration project stalls.

LinkMesh

Routes point at destinations you define centrally, built on standard OpenTelemetry Collectors and Grafana Alloy. Add, remove, or swap a backend by changing a route — the collectors keep running the open configuration they already have.

Change where telemetry goes without re-touching a single host.

How a collector is modelled in LinkMesh →

06

Live throughput per route and edge

Problem

Without visibility into what flows where, a route change is a guess and a misrouted stream can go unnoticed until a backend bill or a missing dashboard surfaces it.

LinkMesh

The topology view shows every collector, route, and destination with live records-per-second measured on each connecting edge. You see which telemetry reaches which backend, at what rate, as it happens.

Routing you can watch, not routing you have to infer from config files.

How collector groups and topology work →
The LinkMesh topology view — a collector group routing telemetry to multiple destinations, with live records-per-second measured on each connecting edge.
The topology: collectors routed to destinations, with live throughput on every edge.

07

Git-versioned route changes with rollback

Problem

"Who changed where the payments logs go, when, and can we undo it?" should be a one-click answer, not an archaeology project across host configs.

LinkMesh

Every route, processor, and destination edit lands as a commit in the GitOps config repo — full diff, author, and timestamp. Roll back to any previous revision and re-push it to the fleet.

Git-grade change history and one-click rollback for your whole routing configuration.

How config is versioned in Git →

What LinkMesh is — and what it isn’t

What it is

A self-hosted control plane that manages the routing policy running in your OpenTelemetry Collectors — standard otelcol-contrib and Grafana Alloy — so one collector layer fans telemetry to many backends, each with its own processing chain.

What it isn’t

It is not a telemetry backend or data store, and it is not a broker your data flows through. LinkMesh does not ingest, index, or retain your logs, metrics, or traces — the collectors do the routing and send it straight to your own backends. Telemetry never transits LinkMesh.

If nothing changes

Left alone, none of this gets cheaper: the volume grows on its own, the data that already left cannot be recalled, and each agent added is one more to remove later.

Once it is running

  • A per-collector bill that a volume spike does not move.
  • Sensitive fields masked on the host, before anything leaves the network.
  • Every config change a diff you can review and roll back.
  • Backends you can swap, because nothing proprietary sits in the path.

Common questions

Can one collector send telemetry to multiple backends?

Yes. LinkMesh manages routes that fan telemetry from a single collector to multiple destinations — Splunk, Grafana or Loki, object storage, or any OTLP backend — each with its own processing chain. You do not need a separate collector per backend.

Can I dual-ship the same telemetry without duplicating it?

Yes. A single route can fan a stream to more than one destination, with per-route filtering so each copy carries only what that backend needs. You send telemetry to two places deliberately instead of paying to store two full copies.

Does my telemetry pass through LinkMesh to be routed?

No. LinkMesh is self-hosted and carries only configuration and health. Routing runs in your own collectors, and your telemetry flows straight from them to your backends — it never transits LinkMesh.

Does routing through LinkMesh create vendor lock-in?

No. Routes are built on standard OpenTelemetry Collectors and Grafana Alloy, and you can add, remove, or swap a backend by changing a route rather than re-touching hosts. If you ever move off LinkMesh, your collectors keep running the open configuration they already have.

Can I see where telemetry is actually going?

Yes. The topology view shows every collector, route, and destination with live records-per-second on each connecting edge, so you can watch which telemetry reaches which backend and at what rate.

How is LinkMesh priced?

By managed collector, never by data volume. The first 25 collectors are free after a no-card registration in the OpenSight Customer Portal (5 without one); beyond that it is a flat USD 12.50 · CHF 12.00 · EUR 12.50 per collector per month, billed annually, and the bill stops growing at 200 collectors.

Send every stream to the backend that fits

Self-hosted, vendor-neutral, priced per collector. Route by label, environment, or tenant; fan out without duplicating; and swap a backend without touching a host. The first 25 Collectors are free after a no-card registration in the OpenSight Customer Portal (5 without one).

Install the control plane on any Linux VM — Ubuntu / Debian

curl -fsSL https://artifacts.saas.opensight.ch/binaries/linkmesh-server/latest/linkmesh-server_latest_amd64.deb -o linkmesh-server.deb && sudo apt install -y ./linkmesh-server.deb

RHEL / Rocky / AlmaLinux, collector enrollment, and the full walkthrough: Install guide →

Test this in your own environment

Use these maintained guides to move from product evaluation to a working configuration.

Check versions and limitations first