Telemetry sources

Connect your services to ilert by pushing OpenTelemetry traces to a telemetry source. ilert extracts the service dependencies from your traces and builds your live service topology.

A telemetry source is an OpenTelemetry (OTLP) ingestion endpoint that your services push traces to. ilert samples those traces, extracts the service-to-service dependencies, and continuously builds your service topology — no manual wiring required.

Beta

Telemetry sources and service topology are currently in beta. Details of the UI and behavior may change.

How it works

ilert uses a push model — you never share credentials with ilert. Your services (or an OpenTelemetry Collector) send OTLP traces to the endpoint, authenticated with an ingestion token:

1. Your services export OTLP traces to the telemetry source endpoint.
2. ilert inspects outbound client and producer spans to derive edges — the caller's service.name becomes the source, and the target is taken from span attributes such as peer.service, server.address, or db.system.
3. The discovered edges are merged into a single per-account topology graph, and any previously unseen service is created in your service catalog.
4. The Service Health map updates live as traces continue to arrive.

Multiple telemetry sources all merge into the same topology graph, so you can, for example, use one source per team or per environment.

Create a telemetry source

The create wizard has two steps: Configure and Connect & verify.

1. Open Telemetry sources under Catalog in the sidebar and click Create telemetry source.
2. Give the source a name. This is a human label shown in the sources list.
3. Optionally add labels (free-form key: value pairs) and assign the source to one or more teams.
4. Click Create source.

Step 1 of the wizard — name, labels and teams

Telemetry sources use a push model, so ilert collects no credentials from you. The ingest endpoint accepts OTLP over HTTP or gRPC, encoded as either protobuf (the exporter default) or JSON.

Connect your services

In the Connect & verify step ilert provisions the endpoint and an ingestion token. Copy the token now — you configure your OpenTelemetry exporter to send traces to the endpoint with the token as a bearer credential.

Step 2 of the wizard — endpoints, ingestion token and ready-to-copy exporter configuration

Endpoints

Protocol	Base endpoint
OTLP / HTTP	https://otlp.ilert.com:4318
OTLP / gRPC	otlp.ilert.com:4317

These are base endpoints — configure them as your exporter's OTLP endpoint and the exporter appends the signal path (/v1/traces) automatically. If you are posting to the HTTP endpoint directly (not through an OTLP exporter), the full traces URL is https://otlp.ilert.com:4318/v1/traces.

Authenticate every request with the ingestion token:

Authorization: Bearer <ingestion-token>

The wizard provides ready-to-copy configuration for common setups:

OTEL Collector

# otel-collector.yaml
exporters:
  otlphttp:
    endpoint: https://otlp.ilert.com:4318   # base endpoint — /v1/traces is appended automatically
    encoding: proto                          # proto (default) or json — both accepted
    headers:
      Authorization: "Bearer <ingestion-token>"

service:
  pipelines:
    traces:
      exporters: [otlphttp]

SDK (env vars)

export OTEL_EXPORTER_OTLP_ENDPOINT="https://otlp.ilert.com:4318"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <ingestion-token>"

Kubernetes · OBI

# OBI DaemonSet env
env:
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: "https://otlp.ilert.com:4318"
  - name: OTEL_EXPORTER_OTLP_HEADERS
    value: "Authorization=Bearer <ingestion-token>"

The ingest endpoint accepts both protobuf and JSON OTLP payloads. Most exporters default to protobuf, which is recommended; JSON works too if your exporter is configured for it.

Once traces start flowing, the topology updates automatically — there is nothing else to configure.

Endpoint and ingestion token

You can view the endpoints and the token — shown as Integration Key — again at any time from the telemetry source's detail page. The key is masked by default and visible only to users with write permission.

The telemetry source detail page, with endpoints, status and the masked integration key

If a key is ever exposed, rotate it: open the source and choose Rotate integration key to issue a new key, then roll it out to your exporters. Treat the exposed key as compromised and rotate as soon as possible.

Ingestion status

The sources list shows each source with its labels, teams and ingestion status, so you can confirm data is arriving:

Status	Meaning
Receiving	Traces are being received.
Stopped	The source was receiving traces but none have arrived lately.
Error	Ingestion is failing.
Pending	The source is provisioned but no traces have been seen yet.

The Telemetry sources list, scoped to the currently selected team

Labels on discovered services

When ilert creates a service for the first time from your traces, it enriches it with labels derived from the OpenTelemetry resource attributes your services report. This makes it easy to filter the topology and service catalog by environment, namespace, cloud, and more.

Labels are applied only when a service is first created — an existing service's labels are never overwritten, so manual edits are safe. A service that only appears as a dependency target (for example a database that doesn't emit its own spans) carries no labels until it starts reporting.

A selection of the mapping:

ilert label	OpenTelemetry resource attribute(s)
env	deployment.environment.name, deployment.environment
namespace	service.namespace
version	service.version
language	telemetry.sdk.language
runtime	process.runtime.name
k8s-namespace, k8s-cluster, k8s-deployment, …	the matching k8s.*.name
cloud, region, zone, cloud-account	cloud.provider, cloud.region, cloud.availability_zone, cloud.account.id

High-cardinality attributes (such as pod name, host name, and instance id) are deliberately excluded.

Next steps

• Explore your service topology on the Service Health map.
• Review the auto-created services in your service catalog.