Skip to content

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 TypeDefault Behavior
First occurrence (new pattern)Forward
Rate spike (5x+ above baseline)Forward
Repetitive INFO/DEBUGSummarize
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:

KeyWhat It Means
messageReadable 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
suppressedHow many logs were compressed
window.start / window.endExact time range the compressed logs spanned
durationTime span of the compressed logs
fingerprintPattern ID (use for backfill)
classSemantic classification (http, db, lifecycle, network, etc.)
idsOne 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_urlOne-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:

AnomalyWhat It Means
first_occurrencePattern never seen before
rate_spikeRate 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

  1. A precursor signal fires (a first_occurrence, content_change, or dormant_resurrection in some workload).
  2. Within the correlation window, an outcome signal fires in the same (tenant, cluster, namespace, workload) scope (typically a rate_spike).
  3. A row is written: (precursor_fp, outcome_fp, precursor_at, outcome_at, lead_time_sec, novelty_scores).
  4. 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.
FieldWhat It Means
precursor_fpFingerprint that fires first (the early-warning pattern)
outcome_fpFingerprint that follows (typically the rate-spike pattern)
lead_time_secSeconds between precursor and outcome — your reaction window
confirmationsHow many times this precursor → outcome pair has been observed
precursor_type / outcome_typeAnomaly 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

ScenarioYour RuleAnomaly?Result
Health check spamsuppressNoSuppressed
Health check spamsuppressYes (spike)Suppressed (your rule wins)
New error patternnoneYes (first)Forwarded (smart default)
Known noisy errorsuppressNoSuppressed
Audit logpreserveN/AAlways forwarded
ERROR (no rule)noneNoForwarded (high-severity default)
ERROR (suppress rule)suppressNoSuppressed (your rule wins)
ERROR (suppress + annotation preserve)bothNoForwarded (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:

  1. Edge archives suppressed logs to your cloud storage (S3/GCS/Azure)
  2. Every suppression summary contains a backfill_url signed locally by Edge API
  3. Open the URL — Auditty validates the token, fetches the archived data, and shows the original logs
  4. No extra tooling or credentials needed

Summary

  1. Your rules always win — Auditty never overrides explicit rules
  2. Smart defaults — First occurrences and spikes forward when no rule matches
  3. Identity ledger — Every searchable correlation key indexed under ids in summaries; full originals in the Vault
  4. Nothing silently dropped — Suppressed logs archived to your own cloud storage (bounded, documented durability), recoverable via backfill URL or fingerprint