Log Intelligence
How Auditty distinguishes signal from noise — searchable ids in summaries, full originals in the Vault
Key Principle
Your rules always win. If you say "suppress this", we suppress it. No exceptions.
The Three Layers
1. Your Rules (Always Respected)
Explicit rules you define are always followed:
rules:
# Suppress known noisy patterns
- name: suppress_healthchecks
action: suppress
match:
entryIncludes: "GET /health"
# Preserve audit logs (never summarize)
- name: preserve_audit
action: preserve
match:
entryIncludes: "audit_event"If you have a rule, Auditty follows it. Period.
Bootstrap preserve rules from your existing alerts (all platforms, 1.7.1+):
Go to Integrations in the Auditty dashboard, connect your platform, then click Sync Monitors on its card: Auditty fetches your log-alerting objects — Datadog log monitors, Splunk saved-search alerts, Kibana alert rules, Coralogix log alerts, Grafana Loki ruler rules, New Relic NRQL conditions, Sumo Logic log monitors — and translates each alert’s query into a preserve rule, so enabling suppression can never silence an existing alert. Translation errs broad by design (a preserve rule can only add forwarding); queries it can’t translate faithfully are listed for manual review instead of silently skipped. Review the generated rules, copy the YAML into your Edge config’s rules: list, and re-sync when alerts change. Edge itself stays vendor-agnostic — the integrations live entirely in Auditty, and the output is plain Auditty rules YAML.
2. Smart Defaults (When No Rule Matches)
For logs without explicit rules, Auditty applies intelligent defaults:
| Log Type | Default Behavior |
|---|---|
| First occurrence (new pattern) | Forward |
| Rate spike (5x+ above baseline) | Forward |
| Repetitive INFO/DEBUG | Summarize |
| Errors (without rule) | Forward |
High-Severity Logs Are Preserved by Default
Auditty automatically preserves high-severity logs (ERROR, CRITICAL, FATAL, PANIC) — they are never suppressed unless you explicitly create a suppress rule for them. This fail-safe default ensures that important signals are never lost.
Severity is auto-detected from all major log formats: JSON ("level": "error"), logfmt (level=error), bracketed ([ERROR]), and more.
3. The Identity Ledger
When logs are summarized, Auditty indexes the varying correlation keys under a single ids object — one entry per searchable id. An id is a declared identity key, a shape-detected key (uuid, hex trace/RayID, prefixed id, long token, ip, MAC, JWT), or a value under an id-ish key name. Bare magnitudes and dimensions (bytes_sent, duration_ms, status, method) are context — kept losslessly in the Vault, not listed in ids. Every id maps directly to an array of its complete distinct values — a window holds up to 50 distinct identity groups, then rolls to a new summary, so ids are enumerated in full rather than sampled. Every id is searchable, and the exact originals — including the excluded fields — stay one click away via backfill_url:
JSON:
{
"message": "DNS query",
"auditty": {
"suppressed": 100,
"window": { "start": "2026-01-15T09:00:00Z", "end": "2026-01-15T09:05:00Z" },
"duration": "5m0s",
"fingerprint": "a1b2c3d4",
"class": "network",
"namespace": "prod",
"workload": "dns-proxy",
"ids": {
"dest_ip": ["10.0.10.1"],
"src_ip": ["10.0.1.5", "10.0.1.12", "10.0.1.20", "10.0.1.33", "10.0.1.41"]
},
"backfill_url": "https://<your-hivemind-url>/backfill/replay?token=<TOKEN>&sig=<SIG>"
}
}Reading the summary: 100 DNS queries collapsed into one line. Every suppressed query went to dest_ip: 10.0.10.1 (a single-element array) and originated from five distinct sources — src_ip lists all of them. Each id maps directly to an array of its complete distinct values; nothing is sampled away. Non-id context (query names, byte counts) is not indexed here but is preserved in full — replay the exact originals via the backfill_url.
Plain text:
DNS query for <str> took <decimal> ms [auditty: suppressed 100 over 5m (09:00:00-09:05:00) | namespace:prod | workload:dns-proxy | fingerprint:a1b2c3d4 | dest_ip=10.0.10.1 | src_ip=10.0.1.5,10.0.1.12,10.0.1.20,10.0.1.33,10.0.1.41 | backfill_url:https://…]What Gets Preserved in Summaries
When multiple logs are compressed into one summary, Auditty keeps:
| Key | What It Means |
|---|---|
| message | Readable headline: the masked template with <decimal>/<str>/<int> placeholders for free-text/logfmt, or an HTTP subject / natural message field for JSON. Never mentions suppression |
| suppressed | How many logs were compressed |
| window.start / window.end | Exact time range the compressed logs spanned |
| duration | Time span of the compressed logs |
| fingerprint | Pattern ID (use for backfill) |
| class | Semantic classification (http, db, lifecycle, network, etc.) |
| ids | One entry per identifier, each mapping directly to an array of its complete distinct values. A window holds up to 50 distinct identity groups, then rolls to a new summary — so ids are fully enumerated across summaries, never sampled. Searchable via auditty.ids.<name> |
| backfill_url | One-click signed link to retrieve original logs from vault |
How the ids object reads:
Each id appears once — declared identity keys, shape-detected ids, and values under id-ish key names; magnitudes and dimensions are kept in the Vault, not indexed here. Every id maps directly to an array of its complete distinct values. No occurrence count is attached to a value, so a unique identifier never looks like it recurred:
"ids": {
"user_id": ["user_17", "user_42", "user_88"],
"trace_id": ["abc123", "def456", "ghi789"],
"src_ip": ["10.0.0.1", "10.0.0.2", "10.0.0.3"]
}Every id is searchable: auditty.ids.user_id:user_42, auditty.ids.src_ip:10.0.0.3. Summaries stay bounded because a window holds at most 50 distinct identity groups before it rolls to a new summary — so even a unique-per-event id (e.g. a per-request trace id) is enumerated in full across summaries rather than sampled. The complete set for any window is also one click away via the backfill URL.
Anomaly Detection
Auditty detects two types of anomalies:
| Anomaly | What It Means |
|---|---|
| first_occurrence | Pattern never seen before |
| rate_spike | Rate is 5x+ above baseline |
Important:
Anomaly detection informs the default behavior. It does NOT override your rules.
- If you have a suppress rule --> Log is suppressed (even if anomaly detected)
- If you have no rule --> Anomaly causes log to forward
Pattern Correlation (Precursor → Outcome)
Auditty does not just emit anomaly signals — it remembers which patterns historically precede incidents. Every observed (precursor → outcome) pair is recorded in the signal_correlations table so the next time a known precursor fires, the Insights page surfaces it as an early warning.
How a correlation is recorded
- A precursor signal fires (a
first_occurrence,content_change, ordormant_resurrectionin some workload). - Within the correlation window, an outcome signal fires in the same
(tenant, cluster, namespace, workload)scope (typically arate_spike). - A row is written:
(precursor_fp, outcome_fp, precursor_at, outcome_at, lead_time_sec, novelty_scores). - After 3+ confirmations, the pair is treated as reliable and surfaces in the Insights feed.
Where you see this
On the Insights page, look for cards titled Reliable precursor in <workload>: N× → rate spike. Each card tells you the precursor pattern, how many times it has preceded a rate spike, and the average lead time. Treat the next firing of that pattern as an early warning — the spike usually follows within seconds to minutes.
Example surface
Reliable precursor in payments-api: 7× → rate spike
Pattern a1b2c3d4 (first occurrence) preceded a rate spike 7 times in
the last 30 days, average lead time 47s. Treat its next firing as an
early warning.| Field | What It Means |
|---|---|
| precursor_fp | Fingerprint that fires first (the early-warning pattern) |
| outcome_fp | Fingerprint that follows (typically the rate-spike pattern) |
| lead_time_sec | Seconds between precursor and outcome — your reaction window |
| confirmations | How many times this precursor → outcome pair has been observed |
| precursor_type / outcome_type | Anomaly type on each side (first_occurrence, content_change, dormant_resurrection, rate_spike) |
Privacy & retention
Correlations store fingerprints (opaque hashes), not log content. Raw correlation rows are kept for 180 days; the daily summary used by the Insights query is kept for 365 days. Both are tenant-isolated.
Tunable knobs (deployment-level)
- Correlation window — how long after a precursor an outcome can be attributed (default 60s).
- Min confirmations — how many observations before a pair is shown as reliable (default 3).
- Max lead time — pairs slower than this are filtered from the insight surface (default 300s).
Overriding Defaults Per Workload
While high-severity logs are preserved by default, you can override this for specific workloads using rules. This is useful when certain workloads produce known, noisy errors that are safe to suppress.
ConfigMap: Suppress known noisy errors cluster-wide
rules:
- name: "suppress-noisy-db-errors"
action: suppress
scope:
workloadIncludes: "health-checker"
match:
severity: "error"
description: "Suppress known noisy errors from health-checker"Annotation: Override per workload
Application teams can use annotations to preserve their logs even when a platform-wide suppress rule exists — because preserve has higher precedence than suppress.
annotations:
auditty.ai/rule.keep-errors: |-
action: preserve
match:
severity: "error"Precedence reminder: preserve > skip > intercept > suppress. A workload annotation with preserve always wins over a ConfigMap suppress rule.
Example Scenarios
| Scenario | Your Rule | Anomaly? | Result |
|---|---|---|---|
| Health check spam | suppress | No | Suppressed |
| Health check spam | suppress | Yes (spike) | Suppressed (your rule wins) |
| New error pattern | none | Yes (first) | Forwarded (smart default) |
| Known noisy error | suppress | No | Suppressed |
| Audit log | preserve | N/A | Always forwarded |
| ERROR (no rule) | none | No | Forwarded (high-severity default) |
| ERROR (suppress rule) | suppress | No | Suppressed (your rule wins) |
| ERROR (suppress + annotation preserve) | both | No | Forwarded (preserve > suppress) |
Recovering Suppressed Logs
Every summary includes a backfill_url — a signed link (signed locally by Edge API) that opens the Replay Viewer with all the original suppressed logs for that fingerprint and time window. Just click the URL.
How backfill works:
- Edge archives suppressed logs to your cloud storage (S3/GCS/Azure)
- Every suppression summary contains a
backfill_urlsigned locally by Edge API - Open the URL — Auditty validates the token, fetches the archived data, and shows the original logs
- No extra tooling or credentials needed
Summary
- Your rules always win — Auditty never overrides explicit rules
- Smart defaults — First occurrences and spikes forward when no rule matches
- Identity ledger — Every searchable correlation key indexed under
idsin summaries; full originals in the Vault - Nothing silently dropped — Suppressed logs archived to your own cloud storage (bounded, documented durability), recoverable via backfill URL or fingerprint