nano SIEM
Case Management

Auto-Grouping Configuration

Supported in:Self-hosted

How grouping rules turn a burst of related alerts into one case, and how to tune them.

Configure auto-grouping to collect related alerts in one case. You can turn a burst of signals about a host or user into a single investigation.

How auto-grouping works

When a detection rule creates an alert:

  1. Rule evaluation. nano walks the enabled grouping rules in priority order (highest number first).
  2. Key computation. For each rule, it reads the rule's entity (host, user, IP or detection rule) from the alert's matched events and computes a grouping key.
  3. Attach to an open case. If a case that is not resolved or closed has the same key, its last activity is within the rule's time window, and it holds fewer than the rule's maximum alerts, the alert is added to it. The first rule that finds such a case wins.
  4. Create a case. Otherwise, the highest-priority rule that can produce a key creates a new case. If no rule can classify the alert, it gets a standalone case.
Alert created
  → for each enabled rule (priority order): compute key → open case with this key, in window, under max? → add alert
  → no match: highest-priority rule that produced a key → create case keyed by it
  → no rule produced a key: create a standalone case

Grouping keys are case-insensitive: WORKSTATION-1 and workstation-1 group together.

Permissions

To read grouping rules, you need settings:view. To change them, you need settings:system.

Grouping rules

Manage grouping rules in Settings → Case Management → Grouping Rules.

FieldAPI keyDescription
NamenameRule name
Match typematch_typeWhat to group by: host, user, ip or rule
Time windowtime_window_minutesHow long after a case's last activity it keeps accepting alerts
PrioritypriorityEvaluation order. A higher number is evaluated first
Title templatecase_title_templateTitle for cases this rule creates
Severity rulecase_severity_ruleHow case severity follows its alerts. Use highest (see Severity)
Auto-assignauto_assign_toAssign new cases to this user
Max alertsmax_alertsAlerts per case before a new case is started (default 100)
Auto-create caseauto_create_caseWhen off, this rule only attaches alerts to existing cases and never opens a new one
EnabledenabledTurn the rule on or off

Match types

For host, user and ip, nano reads the first non-empty value from the alert's matched events, trying the source side before the destination side. The fields are OCSF 1.9 paths:

TypeFields tried (in order)Use case
Hostsrc_endpoint.hostname, device.hostname, then dst_endpoint.hostnameAll activity on one compromised host
Useruser.name, actor.user.name, user.uidOne compromised account across systems
IPsrc_endpoint.ip, then dst_endpoint.ipScanning or attack activity from one address
RuleThe detection rule's IDAll firings of one detection

Default rules

Each deployment starts with these rules:

RulePriorityTime windowEnabledTitle template
Group by Host10060 minYesAlerts on host: {{host}}
Group by User9060 minYesAlerts for user: {{user}}
Group by Source IP8030 minNoAlerts from IP: {{ip}}
Group by Detection Rule70120 minNo{{rule_name}}

All four use a maximum of 100 alerts and the highest severity rule.

Title templates

A title template can use:

TokenValue
{{rule_name}}Name of the detection rule that fired
{{severity}}Alert severity
{{entity}}The value the rule grouped on (host name, user name or IP)
{{host}}, {{user}}, {{ip}}, {{hash}}, {{domain}}Aliases of {{entity}}

Unknown tokens are left as written. Titles are cut at 120 characters. A rule without a template titles the case <rule name> - <context>, where the context is taken from the events (for example admin@WS-001).

For rule grouping there's no entity value, so use {{rule_name}}.

Configuration examples

{
  "name": "Group by Host",
  "match_type": "host",
  "time_window_minutes": 60,
  "priority": 100,
  "case_title_template": "Alerts on host: {{host}}",
  "case_severity_rule": "highest",
  "enabled": true
}

Five alerts about SRV-PROD-01 within an hour go into one case.

Group by user

{
  "name": "Group by User Account",
  "match_type": "user",
  "time_window_minutes": 60,
  "priority": 90,
  "case_title_template": "Suspicious activity by {{user}}",
  "case_severity_rule": "highest",
  "enabled": true
}

Group by source IP

{
  "name": "Group by Source IP",
  "match_type": "ip",
  "time_window_minutes": 30,
  "priority": 80,
  "case_title_template": "Activity from {{ip}}",
  "case_severity_rule": "highest",
  "enabled": true
}

Group by detection rule

{
  "name": "Group by Rule",
  "match_type": "rule",
  "time_window_minutes": 120,
  "priority": 70,
  "case_title_template": "{{rule_name}}",
  "case_severity_rule": "highest",
  "enabled": true
}

Severity

With case_severity_rule set to highest (the default), a case's severity rises to match the most severe alert added to it. It never goes down.

Time windows and caps

The time window is measured from the case's last activity, not from its creation.

Time window: 60 minutes

Alert 1 @ 10:00 → creates CASE-1234
Alert 2 @ 10:15 → added to CASE-1234 (within window)
Alert 3 @ 10:45 → added to CASE-1234 (within window)
Alert 4 @ 12:00 → creates CASE-1235 (more than 60 min after Alert 3)

The case settings (Settings → Case Management → General, GET/PUT /api/settings/cases) set deployment-wide caps:

SettingAPI keyDefaultEffect
Auto-groupingauto_grouping_enabledonWhen off, every alert opens its own case
Max alerts per casemax_alerts_per_case100Upper bound on every rule's max_alerts
Default time windowdefault_time_window_minutes60Upper bound on every rule's time_window_minutes

A rule's window and maximum are each capped by these settings, so the effective value is the smaller one. With the default 60-minute cap, the Group by Detection Rule default (120 minutes) behaves as 60 minutes until you raise the cap.

When a case stops accepting alerts (window expired or full), it stays open for analysts, and the next matching alert starts a new case.

Time window guidelines

ScenarioSuggested windowRationale
Brute force15–30 minutesAttacks are short bursts
Lateral movement60–120 minutesAttackers pause between moves
Data exfiltration60–240 minutesCan happen in stages
General monitoring60 minutesBalances grouping against fragmentation

Priority order

Rules are evaluated from the highest priority number down:

Priority 100: Group by Host   ← evaluated first (default)
Priority 90:  Group by User
Priority 80:  Group by IP
Priority 70:  Group by Rule   ← evaluated last (default)
Enabled rulesAlert hasNew case keyed by
Host + User + Rulehost, userHost
Host + User + Ruleuser onlyUser (no host value)
User + Rulehost, userUser (host rule disabled)
Rule onlyanythingRule

Why "Group by Rule" may not group

With both "Group by Host" and "Group by Rule" enabled:

Alert 1: Rule X on WS-001 → creates a case keyed by host WS-001
Alert 2: Rule X on WS-002 → host lookup: no open case for WS-002
                          → rule lookup: no case keyed by rule X
                          → creates a new case keyed by host WS-002

To group all alerts of one detection regardless of host or user, either disable the Host, User and IP rules, or give "Group by Rule" the highest priority (for example 200).

API reference

Grouping rules are read with settings:view and changed with settings:system.

# List grouping rules
GET /api/settings/case-grouping

# Create a grouping rule
POST /api/settings/case-grouping
{
  "name": "Group by Host",
  "match_type": "host",
  "time_window_minutes": 60,
  "priority": 100,
  "case_title_template": "Alerts on host: {{host}}",
  "case_severity_rule": "highest",
  "max_alerts": 100,
  "enabled": true
}

# Update a grouping rule
PUT /api/settings/case-grouping/{id}
{
  "time_window_minutes": 120,
  "enabled": false
}

# Delete a grouping rule
DELETE /api/settings/case-grouping/{id}

Best practices

  1. Start with the defaults and tune from there.
  2. Pick windows deliberately. Too short fragments cases; too long merges unrelated alerts.
  3. Keep max_alerts workable. 100 is the default; 50 suits high-volume environments.
  4. Disable rules that never match. Only the highest-priority rule that produces a key creates cases.

Troubleshoot

Need help with these checks? Contact support with the request ID and time with timezone.

Alerts are not grouping

  1. Check that auto-grouping is on and the rule is enabled.
  2. Remember that the window runs from the case's last activity.
  3. Check that the matched events carry the rule's entity fields (see below).
  4. Check whether a higher-priority rule is keying the cases.

Host grouping creates separate cases

Check which host fields your detection's events populate. Run the rule's query (or a sample like this one) and look at the candidate fields:

class_uid=3002 status_id=2 // replace with your detection's query
| table time, src_endpoint.hostname, device.hostname, dst_endpoint.hostname, user.name, actor.user.name, src_endpoint.ip

If only dst_endpoint.hostname is populated, every destination becomes its own case. Lower the Host rule's priority (for example to 85, below User), disable host grouping, or rely on IP grouping if src_endpoint.ip is consistent.

"Group by Rule" is not working

Host, User and IP rules have higher default priorities, and most alerts have a host or user, so those rules key the cases. Disable them or raise the Rule priority above 100.

Too many cases

  1. Increase the time window (and the deployment-wide cap if needed).
  2. Check that the entity fields the rule uses are populated for your sources.
  3. Try a different match type.

Cases are too large

  1. Reduce the time window.
  2. Lower max_alerts.
  3. Add more specific rules for high-volume detections.

What's next

On this page