Agent or proxy

Ship every decision to your SIEM

When your SOC works in a SIEM, send it Synapse's decisions in a format it already parses. Every layer emits one event model, so a single record says who enforced, what was done and what decided. Ship block events as CEF or JSON Lines, add IDS alerts, and decide about access logs deliberately, because they are billed by volume.

Overview

A block that only exists on the host is a block nobody can audit. Access rules, the smart firewall, the IDS, the WAF, threat intelligence, CAPTCHA and rate limits all emit the same structured event, so one query answers everything we blocked, and why.

Synapse emits; it does not store. Retention and search belong to your collector or SIEM.

When you see this

  1. The SOC asks why an address was blocked, and nobody can answer from the SIEM.
  2. Blocks happen on hosts that nobody logs into.
  3. You need to show which rule or feed drove enforcement.

Steps

  1. 01

    Read one decision

    layer is who enforced, action is what was done, and source is what decided. signals lists every family a fused rule used; source is only the first of them.

    One event
    {
      "ts": "2026-09-08T11:04:22.481Z",
      "layer": "smart_firewall",
      "action": "drop",
      "source": "fingerprint_rule",
      "signals": ["fingerprint_rule", "threat_intel"],
      "rule_id": "sf-scanner-ja4t-01",
      "rule_msg": "known scanner TCP fingerprint",
      "ban_secs": 3600,
      "src_ip": "203.0.113.42",
      "dst_ip": "10.0.0.5",
      "dst_port": 443
    }
  2. 02

    Answer why it was blocked

    The last query is the useful daily one: a sudden shift in which source dominates is usually a feed change or a misfiring rule, not an attack.

    From the event log
    # Everything dropped, newest first
    jq -c 'select(.action == "drop") | {ts, layer, source, src_ip, rule_msg}' \
      /var/log/synapse/events.log | tail -20
    
    # Which sources drive enforcement
    jq -r '.source // "unknown"' /var/log/synapse/events.log | sort | uniq -c | sort -rn
  3. 03

    Ship it as CEF

    CEF carries three streams, and only block events are on by default. dvchost is on every record, so the SIEM can attribute each event to an agent.

    /etc/synapse/config.yaml
    logging:
      cef:
        enabled: true
        file: "/var/log/synapse/cef.log"
        max_size: 104857600
        keep: 10
        streams:
          block_events: true
          ids_alerts: true
          access_logs: false
        device_host: ""
  4. 04

    Decide about access logs

    Block events fire per decision; access logs fire per proxied request, which on a busy proxy is orders of magnitude more records.

    DecisionIs your SIEM licensed by ingest volume?

    Yes Leave access_logs off. Block events and IDS alerts are the security picture.

    No Turn it on deliberately; it is one record per request.

  5. 05

    Or push over OTLP

    OTLP over HTTP carries the event stream as log records and a set of metrics, so one collector gets both what was blocked and how much is being blocked. JSON Lines suits a shipper you already run: Fluent Bit, Vector or an OpenTelemetry Collector.

Common mistakes

  1. Attributing a block by source alone when the rule fused several signals.
  2. Turning on access_logs without checking how the SIEM is priced.
  3. Reading ban_secs as a countdown. It is the duration declared at install.

Escalate when

  • A sudden shift in which source drives enforcement.
  • Blocks on addresses in your own ranges.

Where this stops working

  • Export is push or file, not a query API: Synapse keeps no searchable history.
  • OTLP batches, so there is a short delay between a decision and its record.
  • A shipper is your responsibility. The JSON Lines sink writes a file; something has to move it.
Run it here

Send the request. Watch where it stops.

Edit the request or any rule and the pipeline runs again. The rules are real wirefilter expressions, evaluated the way the agent evaluates them; the traffic and model scores are samples. It all runs in your browser.

Try this Switch the scan rule to drop and read the event panel: the record names the layer that enforced, the action, the source that decided, and every signal the rule used.

The request

ingress · agent mode

Every value is a rule field. Change one and the pipeline re-runs.

Connection
Source, resolved by the platform
Fingerprints, from Dendrite
Model scores, sample output from Cortex
Flow behaviour, per source
Payload, what Thalamus inspects
Result Delivered to the application
ResultDelivered to the applicationAllowed, with findings · Logged by Amygdala
  1. 01Capture and fingerprintDendrite · On the wireObserved

    Computed JA4T for this connection. Capture only: Dendrite never blocks.

  2. 02Access rulesHillock · XDP hook, before routingPassed

    198.51.100.66 (NL, AS64502) is on no access list.

    From the threat feed: known-bad sourcesNo match
    Country, resolved to IP ranges on the platform sideNo match
  3. 03Firewall rulesHillock · TC hook, in the kernelNot used

    No firewall rules in this policy.

  4. 04Intrusion detectionThalamus · On the hostNot used

    No signatures loaded for this scenario.

  5. 05Behavioural modelsCortex · On the host CPUObserved

    Sample scores, 0 to 100: C2 2, scan 62, malicious flow 4. Nothing leaves the machine to be scored.

  6. 06Service graphHippocampus · On the hostNot used

    No workload identity on this flow.

  7. 07Smart firewall rulesAmygdala · Decided on the host, enforced in nftablesFlagged

    Matched a log rule: recorded what it would have done, enforced nothing.

    No match
    Matched
  8. 08WAF rulesProxy · In the proxy, after decryptionNot used

    Agent mode does no HTTP proxying, so there is no request for the WAF to read.

  9. 09Content scanningProxy · ClamAV, before forwardingNot used

    No WAF rule selected this request for scanning, so nothing was scanned.

Field names and operators follow the docs: WAF and Smart Firewall. A rule that names an unknown field does not load; a field the request does not carry never matches.

What lands in the event log
{
  "ts": "2026-11-17T09:41:07.212Z",
  "layer": "smart_firewall",
  "action": "log",
  "source": "behavioral",
  "signals": [
    "behavioral"
  ],
  "rule_id": "s22",
  "src_ip": "198.51.100.66",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 3389,
  "src_country": "NL",
  "fingerprints": {
    "ja4t": "64240_2-4-8-1-3_1460_10"
  }
}

Shaped like the documented event schema; the timestamp, ports, rule ids and ban duration are illustrative.

Now on your own traffic.

A demo runs the same pipeline against real packets, with the engineers who built it.