Skip to main content
Evaluator downsampling lets an Evaluator Rule run on a fraction of the spans it matches instead of every one. It is designed for high-volume GenAI applications where running an LLM-as-a-Judge evaluator on 100% of traffic is more costly than the monitoring signal requires. You control downsampling with a single per-rule field, sampling_rate, a number in the range (0.0, 1.0] that defaults to 1.0 (evaluate every matching span).
Traces are always persisted even with evaluator downsampling enabled. Downsampling only controls whether an evaluator runs on a matching span — it never affects ingestion or storage. Sampled-out traces stay fully queryable in the Explorer. To score traces a rule skipped, raise the rule’s sampling_rate and run a backfill — a backfill at the same rate re-applies the same deterministic decision and skips the same traces again.
Availability. Evaluator downsampling is gated by a feature flag and may not be enabled for your deployment yet. To turn it on, contact your Fiddler account team or Fiddler support; on self-hosted deployments, an administrator enables it through deployment configuration. Until it’s enabled, the Sampling rate field is unavailable in the UI and the API rejects requests that include a sampling_rate.

How it works

When evaluator downsampling is active, each matching span is checked against the rule’s sampling_rate before the evaluator runs:
  • The decision is deterministic and trace-atomic — every span within the same trace receives the same evaluate-or-skip outcome, so multi-step and agentic traces are always scored as a unit.
  • A rule left at the default sampling_rate = 1.0 behaves exactly as it does today, with no change in coverage.
For example, a rule with sampling_rate = 0.1 evaluates roughly 10% of the traces it matches, cutting the evaluator’s LLM-as-a-Judge calls for that rule by about 90% — while every trace is still ingested and stored.

When to use evaluator downsampling

Use downsampling when evaluation cost or latency, not coverage, is your constraint:
  • Cost reduction at scale. LLM-as-a-Judge evaluators are expensive at production volumes. A representative sample typically preserves drift and quality signal at a fraction of the cost — a 5–20% sample is often equivalent to full coverage for trend monitoring. See Recommended minimum trace volume for choosing a rate.
  • High-throughput applications. Reducing evaluation volume relieves backpressure on the enrichment pipeline during traffic spikes.
  • Multiple evaluators on the same traffic. When several rules score the same high-volume application, downsampling each one keeps total evaluation cost manageable. (Each application supports up to 100 evaluator rules.)
Sampling is correlated across rules. Two rules with the same sampling_rate evaluate the same subset of traces — the decision is hashed on the trace, not the rule, so multiple judges agree on which traces to score. If you want two evaluators to cover different traces, downsampling them at the same rate will not spread them apart.

When not to use evaluator downsampling

Avoid downsampling (keep sampling_rate = 1.0) when:
  • Your application is low-volume. On low-traffic applications, sampling removes too many data points and produces noisy, unreliable drift and quality signals.
  • You need a very low rate (below ~1%). Rates under roughly 1% introduce statistical noise that can swamp the signal you are trying to measure. If cost is still a concern at 1%, your application volume is probably too low to downsample at all.
  • You need every trace scored — for example, for compliance, exhaustive evaluation, or guardrail-style use cases. In those cases, leave the rule at 1.0.
  • You want to pause evaluation. Do not use a tiny sampling_rate to “almost turn off” a rule. Deactivate the rule instead (see below).
Choose a rate that keeps the evaluated volume statistically meaningful, not just the matched volume. As a rule of thumb:
  • Aim for at least ~1,000 evaluated traces per monitoring window (the period over which you read drift or quality metrics).
  • Avoid downsampling applications that match fewer than a few thousand traces per day for a given rule.
  • Keep sampling_rate at or above 0.01 (1%).
In other words, pair lower rates with higher volume. A sampling_rate of 0.1 is reasonable at 100,000 daily traces (~10,000 evaluated); the same 0.1 on an application with only a few hundred daily traces will not produce a reliable signal. These thresholds are recommendations, not enforced limits. The API accepts any sampling_rate in (0.0, 1.0] (to a resolution of 0.0001), so a rate like 0.01 is permitted — values below ~1% are simply unlikely to yield a usable monitoring signal, so treat 1% as a practical floor rather than a hard minimum.

sampling_rate vs. deactivating a rule

A rule’s sampling_rate and its enabled state are independent controls. Use the one that matches your intent:
GoalUseEffect
Reduce evaluation volume and costLower sampling_rate (e.g. 0.1)The evaluator runs on a fraction of matching traces
Pause evaluation entirelyDeactivate the rule (enabled = false)The evaluator runs on no spans; the rule is skipped completely
Key behaviors:
  • sampling_rate = 0.0 is rejected — to stop evaluation entirely, deactivate the rule instead of using a near-zero rate.
  • A rule is created enabled; the create request does not accept an enabled field. To pause a rule, deactivate it afterward — toggle it off in the UI or send a PATCH with {"enabled": false}.
  • Deactivating a rule preserves its configured sampling_rate, so reactivating it restores your previous setting.
  • Changing sampling_rate never reactivates a deactivated rule.
Changes take effect within about 60 seconds. When you update a rule’s sampling_rate, evaluation already in flight may use the previous rate until the evaluator-rule cache refreshes (roughly a 60-second window). Plan rate changes with this short delay in mind.

Configure downsampling

Using the REST API

Set sampling_rate when you create a rule, or update it later with a PATCH. Create a rule that evaluates 10% of matching spans:
Map the input keys your evaluator declares — a custom LLM-as-a-Judge takes the keys named in its prompt, while built-in evaluators require specific inputs (for example, the Coherence evaluator needs both prompt and response). Change the sampling rate on an existing rule:
A sampling_rate outside (0.0, 1.0] (including 0.0 or any value above 1.0) returns 400 Bad Request.

Using the UI

When evaluator downsampling is enabled for your deployment, you set a rule’s sampling rate from the Evaluator Rules tab. When creating a rule, the Add Evaluator Rule dialog includes a Sampling rate field:
  1. Open your application’s Evaluator Rules tab and click Add Rule.
  2. Configure the evaluator, input mappings, and application rules as usual (see Evaluator Rules).
  3. Set the Sampling rate to the percentage of matching traces you want evaluated — for example, enter 10 for 10%. Leave it at the default (100) to evaluate everything.
  4. Save the rule.
For an existing rule, edit its Sampling rate (also a percentage) directly in the Evaluator Rules table — update the value in the rule’s Sampling rate cell. (The row menu offers only Pause and Delete; there is no separate edit dialog.)
The UI uses a percentage; the REST API uses a fraction. In the UI, enter 10 for 10%. The same rate over the API is sampling_rate: 0.1.
The Sampling rate control is rolling out behind a feature flag and may not yet be visible in your environment. If evaluator downsampling is enabled for your deployment but the control has not yet rolled out, configure downsampling through the REST API in the meantime.

Python SDK

SDK support for configuring sampling_rate on Evaluator Rules is forthcoming. For now, configure downsampling through the REST API or the UI.