SignalControl reduces the volume of telemetry Dash0 stores. SignalControl Edge runs that same reduction inside your own network, before telemetry leaves it, so you cut egress cost on top of ingest and storage cost. You run Dash0's edge collector at the edge. It shares most of its processing with the Dash0 platform but connects back to Dash0 for configuration and, for tail sampling, for coordinated decisions.

There are two ways to run SignalControl Edge. Both run the same edge collector and the same optional edge proxy, and both support the same capabilities:

On Kubernetes: The Dash0 operator deploys and configures the edge collector and the edge proxy for you. See Dash0 SignalControl Edge.
Standalone: You run the edge collector and edge proxy container images yourself, for example with Docker, and write the collector configuration by hand. See Set Up SignalControl Edge Without Kubernetes.

This page covers what both deployments share: the capabilities, the architecture, the edge collector components, and the limits of each capability.

Capabilities

SignalControl Edge supports four capabilities:

Tail sampling: Content-aware trace sampling that keeps errors and slow requests while dropping routine traffic. Cuts trace egress by 90% or more. See Sample Traces.
RED metrics: Rate, Errors, Duration histograms generated from 100% of spans before sampling, so dashboards stay accurate despite the drop. See RED metrics on the edge below.
Signal to metrics: Custom metrics derived from spans and log records by configurable rules. See Convert Signals to Metrics.
Telemetry filtering: Per-dataset spam filter rules that drop noisy telemetry before egress. See Filter Out Spam.

Time series aggregation is the one SignalControl stage that does not run at the edge. It runs in Dash0 at ingestion, and applies to metrics whether they arrive from an edge collector or directly.

Architecture

A SignalControl Edge deployment has the following parts:

Edge collector(s): The Dash0 distribution of the OpenTelemetry Collector, running in your network. It receives your telemetry, applies the SignalControl capabilities, and exports to Dash0.
Edge proxy: Optional but recommended at scale. A stateless proxy in your network that holds one upstream connection per site for settings and sampling and fans the results out to the collectors, instead of each collector connecting to Dash0 directly. See Deploy the Edge Proxy.
Dash0 backend: The OTLP ingress that receives your telemetry, and the edge settings endpoint that serves each collector its rules.

Separately to SignalControl Edge deployments, **Decision maker is the Dash0-side service that coordinates tail-sampling decisions across collectors. Collectors reach it directly, or through the Edge proxy.

There are two ways a collector reaches Dash0 for settings and sampling:

Direct, no edge proxy: Each collector polls the edge settings endpoint over HTTPS and connects its sampler straight to Dash0. Simplest, fine for one or a few collectors.
Via edge proxy, recommended at scale: Collectors talk to a local edge proxy over gRPC. The proxy holds one upstream connection per site for both settings and sampling, and fans results out inside your network. This keeps per-collector egress to a single connection.

Telemetry export, meaning spans, logs, metrics, and the usage counters, always goes straight from each collector to the Dash0 OTLP ingress. The edge proxy carries settings and sampling only, never telemetry.

The Edge Collector Components

The edge collector is Dash0's distribution of the OpenTelemetry Collector. It bundles the full OpenTelemetry Collector Contrib component set, so all the standard receivers, processors, exporters, connectors, and extensions are available. On top of that, it adds Dash0's custom SignalControl components:

Component	Kind	What it does
`dash0settingsonedgeextension`	Extension	Marks the collector as running at the edge, and keeps the organization's settings (signal-to-metrics rules, filter rules, dataset settings) fresh from Dash0 or the edge proxy.
`dash0metricrecorderextension`	Extension	Holds the usage counters the metering processors record, in memory, until the paired receiver drains them.
`dash0metricrecorderreceiver`	Receiver	Pulls those counters out of the recorder into a metrics pipeline so they reach Dash0.
`dash0resource`	Processor (enrichment)	Computes each resource's identity, and on edge marks the resource as edge-originated so Dash0 does not process it a second time. Handles traces, logs, and metrics. Not a metered capability.
`dash0operation`	Processor (enrichment)	Derives the `dash0.operation.*` attributes that RED metrics and sampling rely on. Handles traces and metrics. Not a metered capability.
`dash0metering`	Processor	Counts the signals each capability processes and marks them so the capability acts on them.
`dash0sampling`	Processor	Tail sampling. Buffers spans and keeps or drops whole traces by your rules, coordinated through the edge proxy and Dash0's decision maker.
`dash0filter`	Processor	Telemetry filtering. Drops telemetry matching your per-dataset filter rules before it leaves your network. Handles traces, logs, and metrics.
`dash0redmetrics`	Connector	RED metrics. Generates Rate, Errors, Duration histograms from 100% of spans, before sampling.
`dash0signaltometrics`	Connector	Signal to metrics. Derives metrics from spans or log records matching your rules, before sampling.

Everything else in the reference configuration comes from the OpenTelemetry Collector Contrib distribution: the otlp receiver, the batch and memory_limiter processors, the forward connector, and the otlp exporter.

RED Metrics on the Edge

RED (Rate, Errors, Duration) metrics are generated from 100% of spans before sampling, so request, error, and latency views stay accurate even when traces are sampled down. Add dash0redmetrics in the pre-sampling pipeline, after dash0resource and dash0operation (it needs the attributes they add), on the exporter side alongside dash0signaltometrics.

For the RED visualization in Dash0, see Monitor Requests, Errors, and Duration.

Connector configuration (dash0redmetrics):

YAML key	Default	Description
`metrics_flush_interval`	`60s`	How often aggregated RED metrics are exported.
`max_time_series`	`5000`	Soft in-memory series cap.
`max_time_series_age`	`10m`	Age at which idle series are cleaned up.
`min_time_series_age`	`30s`	Minimum age before a series can be cleaned up.
`additional_span_attributes`	none	Extra span attributes to add as metric dimensions. Each is subject to `cardinality_threshold`.
`cardinality_threshold`	`3`	Max distinct values per additional attribute before it stops being added as a dimension. Must be 1–3 when `additional_span_attributes` is set.
`histogram.exponential.max_size`	`160`	Exponential-histogram bucket count. `histogram.explicit.buckets` is an alternative; the two are mutually exclusive.

Filter Operators

Signal-to-metrics match.filters and spam-filter filter criteria use the same operator set. Each criterion is { key, operator, value } (or values for the list operators):

Group	Operators
Equality	`is`, `is_not`
Existence	`is_set`, `is_not_set`
Multiple values (`values`)	`is_one_of`, `is_not_one_of`
Comparison	`gt`, `lt`, `gte`, `lte`
Regex	`matches`, `does_not_match`
String	`contains`, `does_not_contain`, `starts_with`, `does_not_start_with`, `ends_with`, `does_not_end_with`
Wildcard	`is_any` (matches any value, key present or not)

The keepResourceAttributes and keepSignalAttributes matchers use the same operators but match against attribute keys and so omit key. For example: { "operator": "starts_with", "value": "http.request." }.

Limits at a Glance

This is the canonical limits table for SignalControl Edge. Other edge pages link here rather than restating it.

Feature	Limit	Value	Hard or configurable
Tail sampling	Max `ottl` and `error` conditions per rule	32 (probabilistic conditions do not count)	Hard
Tail sampling	Condition kinds	`probabilistic`, `ottl`, `error`, `and`	Hard
Tail sampling	`and` nested conditions	at least 1	Hard
Tail sampling	Probabilistic rate	0.0–1.0	Hard
Tail sampling	Rate limit lower bound	16 or below not guaranteed	Soft
Tail sampling	Rules per dataset	no fixed limit	none
Reservoir	Buffer duration	60s default	Configurable
Reservoir	Memory / disk limit	100 MB (memory) / unlimited (disk)	Configurable
RED metrics	Max time series	5,000 (soft)	Configurable
RED metrics	`cardinality_threshold`	1–3	Hard
Signal to metrics	Max time series	30,000	Configurable
Signal to metrics	Bulk upsert items	1–500 per request	Hard
Edge settings	Snapshot compressed / raw	32 MiB / 100 MiB	Hard

About SignalControl Edge