Set Up SignalControl Edge Without Kubernetes

extensions:
  # Tells every Dash0 component this collector runs at the edge, and supplies the settings
  # (signal-to-metrics rules, filter rules, dataset settings) the capabilities need.
  dash0settingsonedgeextension:
    # Direct HTTP: poll Dash0 directly. To use the edge proxy instead, remove these fields and set `proxy:` below.
    endpoint: "<dash0 api endpoint for your region>"
    auth_token: ${env:DASH0_AUTH_TOKEN}
    refresh_interval: 60s          # settings poll period; 10s–1h
    # proxy:                       # Edge proxy gRPC: subscribe to a local edge proxy instead of polling Dash0 directly
    #   address: "edge-proxy-host:8011"
    #   insecure: false            # true only for a plaintext local edge proxy

  # Holds the counters the Dash0 components record, until the paired receiver below drains
  # them into a metrics pipeline: the usage counters from the metering processors, and the
  # in/out volume counters from the capabilities that the SignalControl page in Dash0 shows.
  dash0metricrecorder/metering:
    flush_interval: 1m             # how often counters flush to the drain pipeline
    # queue_size: 1000             # in-memory queue of pending metric batches
    # max_stale: 5m                # drop a per-tenant recorder after this idle; must be > flush_interval

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

  # The drain side of the recorder. Its ID must name the extension instance above.
  dash0metricrecorder/metering:
    metric_recorder: dash0metricrecorder/metering

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 80
    spike_limit_percentage: 20

  batch: { }                       # optional: send_batch_size, timeout, send_batch_max_size

  # Enrichment. Not SignalControl capabilities, and never a reason to configure metering.
  # dash0resource handles traces, logs, and metrics. dash0operation handles traces and metrics.
  dash0resource: { }
  dash0operation: { }

  # Telemetry filtering. Drops telemetry matching your per-dataset filter rules. The same
  # processor instance serves the traces, logs, and metrics pipelines below.
  dash0filter:
    metric_recorder: dash0metricrecorder/metering   # records the filter's in/out volume; without it the SignalControl page shows no filter volume
    apply_positive_filters_only: true   # recommended on edge: skip negative-operator rules so an over-broad rule cannot drop everything
    # cache_expiration: 60s             # how long compiled filter rules are cached

  dash0sampling:
    metric_recorder: dash0metricrecorder/metering   # records sampling in/out volume; without it the SignalControl page shows no sampling volume
    decision_maker_endpoint: "<edge-proxy host:port>"   # edge proxy, or the Dash0 sampling upstream in direct mode
    # Required whenever organization_mode is single (the default): the headers authenticate the
    # organization for rule lookup, so the processor refuses to start without them.
    decision_maker_headers:
      Authorization: "Bearer ${env:DASH0_AUTH_TOKEN}"
      Dash0-Dataset: "${env:DASH0_DATASET}"
    decision_maker_insecure: false      # true only for a plaintext local edge proxy
    organization_mode: single           # single (one org, from the token) or multi
    default_dataset: "${env:DASH0_DATASET}"   # dataset used when a span carries none
    # enable_batching: false            # batch satisfaction reports to the upstream
    # max_batch_size: 500               # only when enable_batching is true
    # max_batch_wait: 200ms             # only when enable_batching is true
    # decision_channel_max_size: 10000  # buffer for incoming decisions
    # eviction_channel_size: 1000       # buffer for spans leaving the reservoir
    # fallback_sample_ratio: 0.01       # keep ratio when the upstream is unreachable / rules not yet delivered
    # fallback_min_connected_ratio: 1.0 # fall back when connected upstreams drop below this fraction
    # fallback_until_rules_received: true  # use the fallback ratio at startup until rules arrive
    # debug: false                      # verbose per-decision logging (high volume)
    reservoir:
      type: serialized_memory      # serialized_memory (recommended) | memory | disk (the default when unset)
      buffer_duration: 60s         # how long spans wait for a decision; must cover decision latency
      max_memory_bytes: 104857600  # 100 MB; used by memory and serialized_memory
      # shard_count: 16            # write parallelism; disk, serialized_memory, memory (memory defaults to CPU count)
      # ingest_channel_size: 100   # per-shard ingest buffer
      # eviction_scan_send_timeout: 1s
      # --- memory type only ---
      # estimated_bytes_per_span: 800   # size estimate used for the memory calculation
      # --- disk type only ---
      # data_dir: /var/lib/dash0/reservoir   # required for type: disk; use fast SSD/NVMe
      # max_disk_bytes: 0          # unlimited (age-based eviction only); set >0 to cap disk, e.g. 1073741824 (1 GiB)
      # rotation_interval: 5s      # how often active files are sealed
      # writer_buffer_size: 262144 # 256 KB per-shard write buffer

  # Metering. Exactly one count_and_mark instance per source and signal type. The otlp receiver
  # fans out per signal type, so traces, logs, and metrics each get their own counting instance
  # and every signal is counted exactly once.
  dash0metering/pre-sampling:
    metric_recorder: dash0metricrecorder/metering
    mode: count_and_mark           # count_and_mark | mark_only | count (count is invalid on edge)
    # old_data_threshold: 24h      # do not count signals older than this; 0 disables the check
    # web_spans_processing_enabled: false  # set true on a pipeline that processes web-event spans

  # Downstream of the traces counter in the same chain, so the mark keeps these spans from being
  # counted twice. It still marks, so dash0sampling below keeps acting once your organization is enforcing.
  dash0metering/sampling:
    metric_recorder: dash0metricrecorder/metering
    mode: mark_only

  dash0metering/logs:
    metric_recorder: dash0metricrecorder/metering
    mode: count_and_mark

  dash0metering/metrics:
    metric_recorder: dash0metricrecorder/metering
    mode: count_and_mark

connectors:
  forward/sampling: { }
  dash0signaltometrics:
    metric_recorder: dash0metricrecorder/metering   # records signal-to-metrics in/out volume for the SignalControl page
    # default_dataset: default
    # metrics_flush_interval: 60s  # how often generated metrics are exported
    # cache_expiration: 60s        # how long the compiled ruleset is cached
    # max_time_series: 30000       # in-memory series cap
    # histogram:
    #   exponential:
    #     max_size: 160            # exponential-histogram bucket count
  dash0redmetrics:
    # metrics_flush_interval: 60s
    # 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 cleanup
    # additional_span_attributes: []   # extra span attributes to add as metric dimensions
    # cardinality_threshold: 3     # max distinct values per additional attribute (1–3)
    # histogram:
    #   exponential:
    #     max_size: 160

exporters:
  otlp/dash0:
    endpoint: "<dash0 ingress>:4317"
    headers:
      Authorization: "Bearer ${env:DASH0_AUTH_TOKEN}"
      Dash0-Dataset: "${env:DASH0_DATASET}"

service:
  extensions:
    - dash0settingsonedgeextension
    - dash0metricrecorder/metering

  pipelines:
    # dash0metering/pre-sampling sits just before dash0filter, the first Dash0 capability here,
    # so it counts every span entering filtering, once. dash0signaltometrics and dash0redmetrics
    # then see the surviving spans on the exporter side, before sampling.
    traces/pre-sampling:
      receivers:
        - otlp
      processors:
        - memory_limiter
        - dash0resource
        - dash0operation
        - dash0metering/pre-sampling
        - dash0filter
      exporters:
        - dash0signaltometrics
        - dash0redmetrics
        - forward/sampling

    # Metering sits immediately before dash0sampling, the first Dash0 capability here.
    traces/sampling:
      receivers:
        - forward/sampling
      processors:
        - dash0metering/sampling
        - dash0sampling
        - batch
      exporters:
        - otlp/dash0

    # Logs: spam filtering, and signal-to-metrics rules that match logs. Metering sits just
    # before dash0filter, the first Dash0 capability in this pipeline.
    logs:
      receivers:
        - otlp
      processors:
        - memory_limiter
        - dash0resource
        - dash0metering/logs
        - dash0filter
        - batch
      exporters:
        - dash0signaltometrics
        - otlp/dash0

    # Metrics: spam filtering only. Time series aggregation runs in Dash0, not at the edge.
    metrics:
      receivers:
        - otlp
      processors:
        - memory_limiter
        - dash0resource
        - dash0operation
        - dash0metering/metrics
        - dash0filter
        - batch
      exporters:
        - otlp/dash0

    # Needs no metering: dash0signaltometrics and dash0redmetrics appear in receivers, and
    # their metrics were already counted upstream as the signals they were derived from. The
    # usage counters ride out here too, because a pipeline fed by a Dash0 connector reaches
    # Dash0 by construction.
    metrics/signal-control:
      receivers:
        - dash0signaltometrics
        - dash0redmetrics
        - dash0metricrecorder/metering
      exporters:
        - otlp/dash0

extensions:
  dash0settingsonedgeextension:
    endpoint: "https://api.<region>.aws.dash0.com"   # required
    auth_token: ${env:DASH0_AUTH_TOKEN}              # required; org is implicit in the token
    refresh_interval: 60s                            # 10s–1h

extensions:
  dash0settingsonedgeextension:
    proxy:
      address: "edge-proxy-host:8011"
      insecure: false            # true only for local and plaintext