Skip to content

Tail Sampling with EdgeFlow

EdgeFlow runs between DataKit and Dataway. It collects spans by trace_id and decides whether to keep or drop each trace using local EdgeFlow DSL rules. DataKit Aggregator groups, packages, and sends the data. The rules applied on EdgeFlow determine the actual sampling conditions, rate, and timing.

This guide configures tracing tail sampling. The example prioritizes error retention, drops heartbeat and 404 traces, and samples the remaining traces at 10%. Spans already discarded by the SDK or collector cannot be recovered.

Prerequisites and Installation Resources

Version requirements: DataKit 2.11 or later and EdgeFlow 1.0.1. The host package supports Linux AMD64. This guide manages sampling rules with the local EdgeFlow rules validate, rules test, and rules apply commands.

Installation resource Download URL
EdgeFlow host package (Linux AMD64) Download package
EdgeFlow container image pubrepo.guance.com/guance/edgeflow:1.0.1

Prepare the original Dataway address, workspace token, a separate administration token, and writable state storage. Ensure DataKit can reach the EdgeFlow data port and EdgeFlow can reach the original Dataway. The examples use internal HTTP addresses. The host example uses Linux/systemd. Docker installation requires a working Docker Engine and persistent data storage. Back up DataKit settings and existing rules first.

Follow this order: choose an integration mode, install EdgeFlow, apply local DSL rules, configure DataKit, and verify sampling. Choose either host or Docker installation.

Choose an Integration Mode

Comparison Full proxy Sampling only
[dataway].urls Points to EdgeFlow Keeps the original Dataway
[aggregator].endpoints Empty; reuses the ordinary output Points to individual EdgeFlow nodes
tracing Sampled by EdgeFlow, then sent to Dataway Sent by Aggregator to EdgeFlow, then forwarded to Dataway after sampling
Ordinary logs, metrics, and other data Forwarded through EdgeFlow Sent directly to the original Dataway
Deployment One instance per integration path Multiple independent instances can be selected by trace
Failure impact Affects all data using this ordinary output Primarily affects trace sampling; other data keeps its original output

This guide adds tracing tail rules only. Check the scope of existing aggregation, routing rules, or dedicated Sinks separately.

Full proxy:    DataKit → single EdgeFlow → original Dataway

Sampling only: DataKit ── ordinary logs and metrics ──→ original Dataway
                  └── Aggregator → EdgeFlow A/B ─────→ original Dataway

Use a single instance for full proxy mode. An ordinary request can contain multiple traces. Do not distribute these requests randomly across multiple EdgeFlow instances.

Multiple sampling-only nodes require every DataKit to use an endpoint list with identical length and order. Each address must resolve to one fixed instance. Each EdgeFlow instance needs separate state storage or a data volume and the same locally applied DSL rules. Do not replace trace-based distribution with random load balancing or share a state directory across nodes.

Changing the endpoint count or order changes trace ownership. Coordinate the switch and allow in-flight data to drain. Nodes do not automatically synchronize rules or take over another node's existing trace state.

Host Installation

Replace these placeholders: <DATAWAY_HOST> is the original Dataway host, <EDGEFLOW_HOST> is the EdgeFlow host, <WORKSPACE_TOKEN> is the workspace token, and <ADMIN_TOKEN> is the administration credential. The example workspace is demo. The data port is 9529, and the administration port 9530 is accessible only locally.

Install the Binary and Directories

Download and extract the Linux AMD64 package, then check its version:

curl -fL 'https://static.guance.com/edgeflow/edgeflow-linux-amd64.tar.gz' -o edgeflow-linux-amd64.tar.gz
mkdir -p edgeflow-package
tar -xzf edgeflow-linux-amd64.tar.gz -C edgeflow-package
cd edgeflow-package
./edgeflow --version

The download URL is not versioned. Before installing, confirm that the binary matches version 1.0.1 used in this guide. Then run:

sudo useradd --system --user-group --home-dir /var/lib/edgeflow --shell /usr/sbin/nologin edgeflow
sudo install -m 0755 ./edgeflow /usr/local/bin/edgeflow
sudo install -d -m 0755 /etc/edgeflow /etc/edgeflow/rules
sudo install -d -o edgeflow -g edgeflow -m 0750 /var/lib/edgeflow

Skip useradd if the account already exists. Preserve existing configuration and state when upgrading.

Runtime Configuration and Credentials

Create the runtime configuration with sudoedit /etc/edgeflow/edgeflow.toml:

listen = "0.0.0.0:9529"
admin_listen = "127.0.0.1:9530"
upstream_url = "http://<DATAWAY_HOST>:9528"
admin_token_env = "EDGEFLOW_ADMIN_TOKEN"

[state]
mode = "memory_spill"
path = "/var/lib/edgeflow/edgeflow.state"
max_bytes = 10737418240

[workspaces.demo]
token_env = "EDGEFLOW_DEMO_TOKEN"

Keep the original Dataway scheme and port in upstream_url. Do not append a write API path or ?token=..., or point it back to EdgeFlow. Supply workspace tokens through environment variables; each must be valid for the original Dataway. Use a randomly generated administration token, separate from the workspace token, to manage local rules.

demo is the workspace identifier within EdgeFlow and must match --workspace demo in the commands. For each additional workspace, add a [workspaces.<name>] section, a separate token_env, and the corresponding environment variable. Each token can belong to only one workspace. Apply rules separately for each workspace; use the same identifier and token for that workspace on every node.

Save credentials with sudoedit /etc/edgeflow/edgeflow.env. Quote special characters according to systemd environment-file syntax:

EDGEFLOW_ADMIN_TOKEN=<ADMIN_TOKEN>
EDGEFLOW_DEMO_TOKEN=<WORKSPACE_TOKEN>
sudo chmod 0644 /etc/edgeflow/edgeflow.toml
sudo chmod 0600 /etc/edgeflow/edgeflow.env

Start the Service

Create /etc/systemd/system/edgeflow.service:

[Unit]
Description=EdgeFlow tail sampling
Wants=network-online.target
After=network-online.target

[Service]
User=edgeflow
Group=edgeflow
StateDirectory=edgeflow
WorkingDirectory=/var/lib/edgeflow
EnvironmentFile=/etc/edgeflow/edgeflow.env
ExecStart=/usr/local/bin/edgeflow --config /etc/edgeflow/edgeflow.toml run
Restart=on-failure
TimeoutStopSec=180

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now edgeflow
sudo systemctl status edgeflow --no-pager
sudo journalctl -u edgeflow -n 100 --no-pager
curl -fsS http://127.0.0.1:9529/healthz

After the service starts, continue with local rules. A successful health check does not mean sampling is configured.

Docker Installation

Prepare a separate directory on the Docker host:

mkdir -p edgeflow-docker/rules
cd edgeflow-docker

Create edgeflow.toml and edgeflow.env using Runtime Configuration and Credentials, changing state.path to /app/data/edgeflow.state. The upstream_url must be reachable from the container network. Keep the administration address as 127.0.0.1:9530. Store rule files under rules/ in the current directory. Use KEY=value entries in the Docker environment file without surrounding shell quotes.

chmod 0644 edgeflow.toml
chmod 0600 edgeflow.env
chmod 0755 rules
docker volume create edgeflow-state
docker pull pubrepo.guance.com/guance/edgeflow:1.0.1
docker run -d --name edgeflow --restart unless-stopped --stop-timeout 180 \
  --env-file ./edgeflow.env \
  -p 9529:9529 \
  -v "$PWD/edgeflow.toml:/app/edgeflow.toml:ro" \
  -v "$PWD/rules:/app/local-rules:ro" \
  -v edgeflow-state:/app/data \
  pubrepo.guance.com/guance/edgeflow:1.0.1 run
docker logs --tail 100 edgeflow
curl -fsS http://127.0.0.1:9529/healthz

The image runs as a non-root user. A new named volume is initialized from the image's data directory. When reusing a volume, ensure the container user can read and write it. Expose only data port 9529 and run the local rule CLI inside the container.

Choose either host or Docker installation; do not let two processes share a port or state directory. For multiple sampling-only nodes, use a separate container, data volume, and fixed reachable address per node, and apply the same DSL file on each. Continue with local rules.

Prepare and Apply Local Rules

edgeflow.toml contains runtime settings. The following tracing.dsl contains the actual sampling rules. Run rules apply after editing the DSL file. Saving the file alone does not update the running rules.

Each rules apply replaces the entire DSL for the selected workspace; it does not append a rule. The example below is intended for a workspace without existing business rules. If aggregation, routing, or sampling rules already exist, back up the complete current DSL, merge all rules you need to retain into one file, then validate and apply it. Do not overwrite existing rules with this example.

Rule Example

On a host, save this as /etc/edgeflow/rules/tracing.dsl. For Docker installation, save it as rules/tracing.dsl under the installation directory:

version 1;

schema tracing {
  field.trace_id: string;
  field.resource: string;
  field.duration: number;
  tag.status: string;
  tag.http_status_code: string;
}

tail "trace_sampling" on tracing {
  group by field.trace_id;
  idle 10s max_wait 1m decision_ttl 5m;

  keep when any(tag.status == "error");
  drop when any(field.resource in ["/health", "/healthz", "/ready", "/readyz", "/heartbeat"]);
  drop when any(tag.http_status_code == "404");
  sample 0.1 otherwise seed "edgeflow-tracing-v1";
}

Actions are evaluated in order. The first match decides whether to keep or drop the entire collected trace. An error trace is therefore retained even if it also matches a heartbeat or 404 condition. To drop heartbeats or 404s unconditionally, move the corresponding drop action before error retention.

any(...) matches any span, not only the entry span. The example uses common DataKit field locations. Before deployment, verify the actual tag. / field. locations, types, and values. A resource may be GET /health or a route template; adjust the list accordingly. If HTTP status is a numeric field, update both the schema and condition.

Optionally insert slow-trace retention after error retention and before the drop actions:

keep when any(field.duration > 1000000);

Here, duration is a number compared against standard DataKit tracing values in microseconds: 1000000 is one second. This detects a span longer than one second, not the total wall-clock extent of the trace. Adjust the comparison if a Pipeline changes the unit.

Validate and Apply on a Host

Validate and preview offline first. Built-in samples are only a quick check; verify business rules separately with representative sanitized samples:

sudo chmod 0644 /etc/edgeflow/rules/tracing.dsl
edgeflow rules validate /etc/edgeflow/rules/tracing.dsl
edgeflow rules test /etc/edgeflow/rules/tracing.dsl --workspace demo --format json

The following command loads the existing credential file through a transient systemd unit and applies the rules locally on the EdgeFlow host, without putting tokens on the command line. For the first application, use --if-match 0:

sudo systemd-run --quiet --wait --pipe --collect \
  --property=EnvironmentFile=/etc/edgeflow/edgeflow.env \
  /usr/local/bin/edgeflow --config /etc/edgeflow/edgeflow.toml \
  rules apply /etc/edgeflow/rules/tracing.dsl --workspace demo --if-match 0 --format json

Confirm ok: true and record the revision and hash. Do not keep using 0 when updating existing rules; see Updates and Rollback.

Validate and Apply Inside the Container

Save the DSL as rules/tracing.dsl in the Docker installation directory. This directory is already mounted read-only in the container. After editing the host file, validate and apply it inside the container:

chmod 0644 rules/tracing.dsl
docker exec edgeflow edgeflow rules validate /app/local-rules/tracing.dsl
docker exec edgeflow edgeflow rules test /app/local-rules/tracing.dsl --workspace demo --format json
docker exec edgeflow edgeflow --config /app/edgeflow.toml \
  rules apply /app/local-rules/tracing.dsl --workspace demo --if-match 0 --format json

The container already receives the credentials through --env-file. After the first application, use the current revision or omit --if-match for updates. Repeat these steps on every node, confirming that all instances apply the same file and return the same hash. Revisions are independent per instance and need not have identical numbers.

Apply EdgeFlow rules before switching DataKit's output. Keep the original DSL file and its history; the container's data volume should not be the only backup.

Configure DataKit Aggregator

See DataKit Aggregator for the full parameter reference. This section configures data ingestion; EdgeFlow's actual business sampling policy is maintained locally on EdgeFlow.

Choose the Connection Settings

The default host configuration is /usr/local/datakit/conf.d/datakit.conf. Update fields in the existing sections rather than adding duplicate sections or replacing the entire file.

Sampling-only mode keeps the original [dataway].urls:

[dataway]
urls = ["http://<DATAWAY_HOST>:9528?token=<WORKSPACE_TOKEN>"]

[aggregator]
endpoints = [
  "http://edgeflow-a:9529?token=<WORKSPACE_TOKEN>",
  "http://edgeflow-b:9529?token=<WORKSPACE_TOKEN>"
]
timeout = "30s"
max_raw_body_size = 1048576
use_local_config = true
local_config_dir = "/usr/local/datakit/conf.d/aggr"
local_metric_config_file = "aggr.toml"
local_tail_sampling_config_file = "tail-sampling.toml"

Keep one endpoint for a single node and replace hostnames with reachable addresses. DataKit running in Kubernetes must also use EdgeFlow host addresses or DNS names reachable from the Pod network. Use service root addresses with tokens, without API paths. All endpoints in one DataKit instance must use the same workspace token and target the same workspace as the original [dataway].urls. Do not mix workspaces in this endpoint list.

Full proxy mode uses the same Aggregator parameters but changes these two settings:

[dataway]
urls = ["http://<EDGEFLOW_HOST>:9529?token=<WORKSPACE_TOKEN>"]

[aggregator]
endpoints = []

This snippet shows only the differences. Keep the other Aggregator fields from the complete example. An empty endpoint list reuses the ordinary Dataway output; configure only one EdgeFlow address in this mode.

Create the Ingestion Configuration Files

On a host, create /usr/local/datakit/conf.d/aggr/. For Kubernetes, prepare the following two files on the operator's machine.

Keep an empty aggregation rule set in aggr.toml:

default_window = "15s"
action = ""
delete_rules_point = false
aggregate_rules = []

Do not overwrite an existing aggregation setup: aggregation tasks also use the Aggregator endpoints.

Use tail-sampling.toml to enable grouped tracing delivery:

version = 1

[trace]
data_ttl = "1m"
group_key = "trace_id"

[[trace.sampling_pipeline]]
name = "send-traces-to-edgeflow"
type = "condition"
condition = '{ 1 = 1 }'
action = "keep"

Here, keep does not tell EdgeFlow to retain every trace. The applied tracing.dsl decides retention. This TOML file's version and data_ttl are separate from EdgeFlow's rule revision and timing. Do not add [logging] or [rum]; this integration processes tracing only.

Configure DataKit in Kubernetes

The following assumes a DaemonSet named datakit in the datakit namespace. Back up the existing configuration first. When using deployment tools or GitOps, edit and deploy from the original configuration source. This section configures an existing DataKit deployment; it does not install EdgeFlow.

Create a ConfigMap:

kubectl -n datakit get daemonset datakit -o yaml > datakit-daemonset-backup.yaml
kubectl -n datakit create configmap edgeflow-tail-ingestion \
  --from-file=aggr.toml=./aggr.toml \
  --from-file=tail-sampling.toml=./tail-sampling.toml \
  --dry-run=client -o yaml | kubectl apply -f -

Create a Secret for connection addresses. This example uses two sampling-only nodes. Save it as datakit-edgeflow-endpoints.yaml and run kubectl apply -f datakit-edgeflow-endpoints.yaml:

apiVersion: v1
kind: Secret
metadata:
  name: datakit-edgeflow-endpoints
  namespace: datakit
type: Opaque
stringData:
  endpoints: "http://<EDGEFLOW_A_HOST>:9529?token=<WORKSPACE_TOKEN>,http://<EDGEFLOW_B_HOST>:9529?token=<WORKSPACE_TOKEN>"

Merge the following into the DataKit container's existing env and volumeMounts. Keep the original ENV_DATAWAY and avoid duplicate environment-variable names:

env:
  - name: ENV_AGGREGATOR_ENDPOINTS
    valueFrom:
      secretKeyRef:
        name: datakit-edgeflow-endpoints
        key: endpoints
  - name: ENV_AGGREGATOR_TIMEOUT
    value: "30s"
  - name: ENV_AGGREGATOR_MAX_RAW_BODY_SIZE
    value: "1048576"
  - name: ENV_AGGREGATOR_USE_LOCAL_CONFIG
    value: "true"
  - name: ENV_AGGREGATOR_LOCAL_CONFIG_DIR
    value: "/usr/local/datakit/conf.d/aggr"
  - name: ENV_AGGREGATOR_LOCAL_METRIC_CONFIG_FILE
    value: "aggr.toml"
  - name: ENV_AGGREGATOR_LOCAL_TAIL_SAMPLING_CONFIG_FILE
    value: "tail-sampling.toml"
volumeMounts:
  - name: edgeflow-tail-ingestion
    mountPath: /usr/local/datakit/conf.d/aggr/aggr.toml
    subPath: aggr.toml
    readOnly: true
  - name: edgeflow-tail-ingestion
    mountPath: /usr/local/datakit/conf.d/aggr/tail-sampling.toml
    subPath: tail-sampling.toml
    readOnly: true

Merge the following into spec.template.spec.volumes:

volumes:
  - name: edgeflow-tail-ingestion
    configMap:
      name: edgeflow-tail-ingestion

For full proxy mode, change the Secret address to the single endpoint http://<EDGEFLOW_HOST>:9529?token=<WORKSPACE_TOKEN> and rename the first environment variable to ENV_DATAWAY. Remove duplicate ENV_DATAWAY entries and the previous ENV_AGGREGATOR_ENDPOINTS. Also ensure aggregator.endpoints = [] in the main configuration; an empty environment variable does not clear an existing list in the file.

Activate DataKit Settings

On a host, run:

sudo systemctl restart datakit
sudo systemctl status datakit --no-pager

In Kubernetes, update the configuration source, then run:

kubectl -n datakit rollout restart daemonset/datakit
kubectl -n datakit rollout status daemonset/datakit

Restart DataKit after changing its local ingestion settings. Recreate Pods to load changes to subPath mounts. To change only the EdgeFlow sampling policy, apply the DSL on each EdgeFlow node; no corresponding DataKit configuration change is required.

Rule Parameters and Sampling Interpretation

Parameter Example Meaning
version 1 DSL syntax version, not a rule version incremented on each edit
group by field.trace_id Groups a complete trace; adding service splits traces across services
idle 10s Inactivity since the last data received for the group; must be greater than zero
max_wait 1m Maximum collection time since the first data received for the group; must exceed idle
decision_ttl 5m Decision retention period; must be greater than zero. Late data in the same group reuses that decision
sample 0.1 Sampling rate for ordinary traces, in [0,1]
seed edgeflow-tracing-v1 Seed for stable probabilistic sampling; keep it consistent for the same policy
revision Returned by apply Rule revision on the current instance, used to check concurrent updates

These timers use the time EdgeFlow receives the data. Collection can end when either idle or max_wait is reached; not every trace waits a full minute. Adjust them for span reporting intervals and trace duration to avoid deciding too early.

decision_ttl does not extend collection. After a drop decision, even a late error span is dropped during the retention period. Once that period expires, later data for the same trace may form a new group and receive a different decision.

Error retention takes priority. The 10% rate applies only to traces that do not match earlier actions. For example, out of 10,000 traces, 500 may be retained by the error action and 1,500 dropped by subsequent actions. Sampling the remaining 8,000 retains about 800, yielding roughly 13% overall retention. Count distinct trace_id values, not spans or bytes.

To sample all traces uniformly at 10%, remove the three conditional actions inside the tail and keep only sample ... otherwise. Errors then participate in sampling too. Do not add a second tail rule for the same category.

Verify Sampling Results

Use unique, searchable trace IDs to verify deterministic actions first, then use many distinct traces to check the sampling rate.

Scenario Expected result for the main example
Contains an error span Retain the entire collected trace
No errors; matches a heartbeat resource Drop
No errors; contains a 404 Drop
Matches both error and 404 conditions Retain because the error action comes first
Many ordinary traces Retain approximately 10% when counted by trace
One trace arrives from different DataKit instances Collected on the same instance in multi-node sampling-only mode
Ordinary logs and metrics Forwarded through EdgeFlow or directly to Dataway according to the selected mode

Allow for collection time and delivery latency before checking platform results. HTTP success and health checks do not replace rule acceptance checks. Before production, also test late spans and downstream outages and recovery, including whether fallback changes the retention rate.

Updates, Rollback, and Operations

Update and Roll Back Local Rules

  1. Save the complete current DSL for the workspace, applied revision, and hash.
  2. Edit the local file and run validate and test.
  3. Use the same rules apply command, replacing the initial --if-match 0 with the current revision of that instance. Alternatively, omit it to let the CLI read the active revision and check for concurrent changes.
  4. Confirm success, apply the same file on every node, compare the hashes, and verify business results.

Applying identical content does not increment the revision. On a revision conflict, inspect the current rules before replacing someone else's changes. To roll back, reapply the saved DSL. Keep the syntax version as version 1;.

Existing groups may finish under their original rules; observe in-flight data after an update. Editing the DSL file alone or restarting DataKit alone does not update EdgeFlow rules.

Change Runtime Configuration or Credentials

Runtime settings, credentials, and sampling rules take effect differently:

Change Required action
EdgeFlow DSL Run rules apply for the workspace on each node; no DataKit restart is required
Host edgeflow.toml or edgeflow.env Save and run sudo systemctl restart edgeflow; run sudo systemctl daemon-reload first if the service unit changed
Docker edgeflow.toml or edgeflow.env Stop and remove the old container, then recreate it from the original installation directory using the docker run command in Docker Installation; preserve and reuse the data volume
DataKit main configuration or local ingestion files Restart the service or recreate Pods as described in Activate DataKit Configuration

To recreate a Docker container, first run docker stop edgeflow and docker rm edgeflow. Do not delete the edgeflow-state volume. docker restart alone does not reload a modified --env-file; recreation also ensures that a replaced bind-mounted configuration file is read again. Check service health and sampling after restarting. For a new workspace, apply its rules after startup succeeds and before routing its data to EdgeFlow.

Restore the Original Data Path

For full proxy mode, restore the original [dataway].urls. For sampling-only mode, clear the custom Aggregator endpoints. In both cases, remove the tracing ingestion configuration introduced by this setup, restore the original configuration, restart DataKit, and verify ordinary tracing writes. Do not merely set use_local_config = false: that changes the configuration source.

Allow EdgeFlow to drain before stopping it and preserve its state directory. Old nodes may still deliver accepted data, so account for duplicates and delays.

Storage and Failure Monitoring

memory_spill uses memory first and temporarily stores data on disk as needed. It saves state during normal shutdown. A crash can lose data already received but not yet delivered, even with a persistent volume. Both the host and Docker examples use this mode. If your business requires received data to survive a crash, confirm a separate durable deployment plan.

state.max_bytes is a logical state quota, not a hard limit on actual disk usage. Capacity must include backlog, trace state, snapshots, indexes, and headroom. For example, raw bodies accumulating at 2 MiB/s for 30 minutes already require about 3.52 GiB.

The following limits can be set under [limits] in edgeflow.toml; omitted values use the defaults. Sizes are in bytes and do not cap total process memory:

Parameter Default Effect at the limit
max_compressed_body 16777216 (16 MiB) Requests exceeding the limit are rejected
max_decompressed_body 67108864 (64 MiB) Requests exceeding the limit after decompression are rejected
max_active_groups 200000 When the active group limit is reached, data for new groups is retained and forwarded directly
max_group_bytes 8388608 (8 MiB) When accumulated trace data exceeds the limit, existing and incoming data is retained; later data is also retained during the decision retention period

DataKit's max_raw_body_size = 1048576 controls individual packet size, not accumulated trace size. Do not size storage solely around a 10% sampling rate: data awaiting a decision still consumes space, and the direct retention described above increases the retention rate.

Monitor process logs, disk, memory, /readyz, and /metrics. Use edgeflow_engine_fail_open_total with reason="active_groups" or reason="group_bytes" to observe direct retention caused by capacity limits. DataKit's aggr_tail_sampling_fallback_package_total and aggr_tail_sampling_fallback_point_total help quantify fallback after delivery failures.

In sampling-only mode, fallback to the ordinary output can send unsampled data directly and increase retention. Partially successful requests can also cause duplicates. In full proxy mode, the ordinary output is still EdgeFlow, so fallback cannot bypass that node's failure.

Troubleshooting

Symptom What to check
An edit has no effect Local rules apply execution, correct workspace, identical files applied on all nodes, and groups still using old rules
Applying rules fails DSL syntax, administration token in the CLI process environment, a running EdgeFlow instance, and the current --if-match revision
Heartbeat or 404 traces are retained Earlier error or slow-trace retention, field location and type, and the actual resource value
Retention is not 10% Preferential error retention, sample size, trace versus span counts, delivery fallback, and direct retention at capacity limits
Incomplete traces SDK head sampling, collection filters, trace ID propagation, node assignment, and late spans
Data-port authentication fails Endpoint token matches the EdgeFlow workspace token
413 or persistent 5xx Packet size limits, network, disk quota, memory, and downstream status

Related documentation: Data Aggregation and Tail Sampling, DataKit Aggregator, and Dataway Tail Sampling.

Feedback

Is this page helpful?