Skip to main content

Log Events and Automated Reactions

Someone has to act on what appears in logs: route lines to ticketing, page on-call staff, open security investigations, trigger remediation playbooks. OLIVE runs like any other Kubernetes workload, so the pipeline and rule engine can be whatever fits the organization — a SIEM, Loki/Grafana alert rules, Falco, or custom workers that evaluate structured events.

This page is for both roles, and the split is the same as for metrics

The cluster operator owns the pipeline: log collection, storage, the retention and access controls the stream labels exist to support, the rule engine, and notification routing.

The platform administrator owns the rules written against the OLIVE event catalogue below, and first-line triage of what they fire. The codes are OLIVE-specific and so is the judgement — whether a burst of OLIAUTHZ2 is a misconfigured connector or someone probing, and what to do next, is not something a cluster operator can assess.

This is what the responsibility matrix means by "Owns tooling and platform alerts" on one side and "Owns OLIVE-level alert rules and first-line triage" on the other. The catalogue lives in the Cluster Operator guide because the cluster operator needs to know what the platform emits in order to size and route it — not because the rules are theirs to write.

Changed in 1.3

Earlier versions of this page said that OLIVE does not mark log events for automated processing. That is no longer true. From OLIVE 1.3 the platform emits a defined catalogue of security events with stable codes, in machine-readable form, specifically so that alert rules can be written against them.

Alert on codes, not on message text​

Each detection point has a stable code, for example OLIAUTHN4. The code does not change between releases; the message text may. Write your rules against the code.

The numbering has gaps — OLIAUTHN1, OLIAUTHN2 and OLIERROR5 are not in the catalogue below. Those are retired or unused codes: OLIVE does not emit them and will not reuse the numbers, so a rule written as a range over a family is safe.

The security event catalogue​

Authentication​

CodeEvent
OLIAUTHN3User logged out
OLIAUTHN4Cross-tenant access attempted
OLIAUTHN5JWT validation failed
OLIAUTHN6Bad authentication request
OLIAUTHN7Other authentication failure
Successful logins are Keycloak events, not OLIVE events

There is no OLIVE code for a successful login. The authentication flow completes in Keycloak and OAuth2 Proxy rather than in the OLIVE services, so a login is not observable from inside OLIVE — the first OLIVE event an authenticated session produces is whatever the user then does. Keycloak emits the login itself, so alert rules for logins, failed logins and brute-force lockouts are written against Keycloak's event log, not against this catalogue.

Capture and emission are two separate things, and both are needed.

Event classCaptured in a new realm?Carries
User eventsYes — eventsEnabled: true, 30-day expirationLogins, logouts, failed logins, token refreshes
Admin eventsYes — enforced on every syncConfiguration changes, including a user being disabled or deleted

Both are on in a newly onboarded realm. The realm OLIVE imports sets eventsEnabled: true with a 30-day eventsExpiration, and the onboarding job sets adminEventsEnabled and adminEventsDetailsEnabled and re-enforces them on every sync — the session-purge CronJob reads the admin log, and with admin events off that endpoint returns an empty list rather than an error, so the job would run green and terminate nothing.

Realm import only reaches new realms

eventsEnabled is set by the realm import, which applies when a realm is created. A tenant realm onboarded before this default changed still has user events off, and re-syncing keycloak-setup will not turn them on — only admin events are reconciled on every run. Check each existing realm and enable user events there by hand: Realm settings → Sessions/Events → User events config → Save events.

Capture puts events in Keycloak's own database. Emission is what gets them to stdout where a log pipeline can see them, and it is a separate setting: Keycloak writes successful events at DEBUG by default, so a correctly capturing realm emits nothing at the default root level of INFO. Set global.audit.successLevel: info and logFormat: json on the Keycloak chart.

Until both halves are in place, the authentication boundary — the single most security-relevant component in the stack — is invisible to monitoring.

Authorization​

CodeEvent
OLIAUTHZ1User performed an action requiring admin rights
OLIAUTHZ2User requested an admin action without the admin role
OLIAUTHZ3User requested an editor action without the editor role
OLIAUTHZ4CSRF token missing or invalid
OLIAUTHZ5Call from the frontend to a backend-only API

Outbound calls​

CodeEvent
OLIFETCH1Kubernetes-internal URL call blocked (the egress guard)
OLIFETCH2Called cloud function not found
OLIFETCH3A fetch authentication request failed

Errors​

CodeEvent
OLIERROR1Invalid parameter
OLIERROR2Invalid OLIVE type
OLIERROR3Resource not found
OLIERROR4Internal server error
OLIERROR6Not authenticated
OLIERROR7Missing authorization
OLIERROR8Forbidden
OLIERROR9Insufficient role
OLIERROR10Unauthorized
OLIERROR11Invalid token
OLIERROR12Unknown error

File handling​

CodeEvent
OLIFILE1Missing file requested
OLIFILE2Invalid file name, extension or MIME type uploaded
OLIFILE3Path traversal detected — prevention is in place; this detection point is not yet emitted

Orchestration​

CodeEvent
OLIORCH1Job of another user requested
OLIORCH2Response set from outside via setResponse

Secrets​

CodeEvent
OLISEC1Secret accessed
OLISEC2Secret changed
OLISEC3Non-existent secret requested
OLISEC4Invalid secret format

Configuration​

CodeEvent
OLIMISC1Log level changed
OLIMISC2Log truncation settings changed

Platform health​

CodeEvent
OLIALIVE1Liveness check result

OLIALIVE1 is emitted by data-orchestrator every time the olive-platform-liveness-check-scheduler task runs — every five minutes, once the foundational OLIVE Connectivity Bundle has been imported. The connector it runs uses CouchDB, a file write, a file read and data orchestration, so a successful result is evidence that the tenant works end to end rather than that its pods are up.

{"timestamp":"2026-09-15 09:00:14.566","level":"INFO","loglabel":"oli-security","messages":["event: OLIALIVE1","message: Liveness check result: ","service: data-orchestrator","userID: c6afca88-7c6a-49e1-a718-c0f8d545b8aa","ipAddress: ::ffff:172.31.19.193","remoteIpAddress: ::ffff:172.31.19.193","callingService: data-orchestrator","requestID: 2b2e2a52bb59","tenantID: multi","args: null","security","multi","b8669939"]}
Alert on its absence, not only on its result

This is the one event where silence is the signal. A failing result names what broke; no OLIALIVE1 at all for a tenant means the scheduler, the orchestrator, the data store or the log pipeline itself has stopped — and nothing else reports that. Build a dead-man's-switch rule per tenantID: alert when no OLIALIVE1 has arrived within roughly three intervals.

Because the rule keys on the tenant, it also catches a tenant that has quietly stopped working while the rest of the platform is healthy.

The bold entries correspond directly to attacks the platform prevents. That is the point of the catalogue: the same control that blocks cross-tenant access also reports the attempt, so you see the probe rather than only the eventual breach.

Fields on every security event​

FieldNotes
Event codeAlert on this
Source IPOne hop behind the proxy for external calls; the calling service name for internal ones. Both protected against forgery
User name
Tenant IDMandatory on every log record. Without it, logs from different tenants cannot be separated for investigation or for a data subject request
Service name
Service versionLets an event be attributed to a specific build
Description
Request IDA traceable identifier propagated across services, so one user action can be reconstructed across every service it touched
Verify client IP propagation after any ingress change

Several events depend on the source IP. If the ingress or gateway in front of OLIVE changes — a different controller, an added load balancer, a different TLS termination point — re-confirm that the client IP is propagated and not spoofable before relying on those events.

Log streams​

OLIVE ships no observability stack

OLIVE writes logs and labels them. Collecting, storing, retaining and controlling access to them is the job of whatever log platform you run — OLIVE neither provides one nor configures one.

The labels are the contract between the two: they are what lets you apply different retention and different access rights per kind of log, instead of one rule across everything OLIVE emits.

Logs carry a log_type label separating them into streams:

StreamWhat it carries
appOrdinary application logging
securityThe security event catalogue above
audit_aiActivity involving AI, marked separately so it can be treated differently from ordinary security logging

A separate developer stream exists for development environments only and is never enabled in a production deployment.

Retention and access are yours to set​

OLIVE does not prescribe a retention period. How long each stream may or must be kept depends on the compliance regime the operating organisation is subject to and on what the logs contain, so it is a decision for the people who own that obligation — not a platform default. Set it per stream rather than accepting one global value, and record why.

What is worth recommending regardless:

  • Restrict the security stream to the people who need it. It identifies users and their source addresses. Broad read access to it is itself a privacy exposure, and everyone who can debug an application should not automatically be able to see who logged in from where. Multi-factor authentication on those accounts is a reasonable additional requirement.
  • Encryption at rest for log storage.

The audit trail​

The security event stream doubles as the audit trail. Authentication outcomes, authorization failures, use of higher-risk functionality, configuration changes, secret access and modification, service start-up and shutdown, and application errors are all recorded with actor, tenant, target, outcome and time — which is what makes repository changes, file uploads and deletions, and job triggering attributable.

The logging mechanism protects itself​

A tenant able to reduce logging verbosity globally could suppress the evidence of its own activity. Log level changes no longer affect other tenants, and both log level and truncation changes are themselves logged (OLIMISC1, OLIMISC2). Verbosity also cannot be raised to a level that captures credentials, tokens or request and response bodies in production.

Suggested starting alerts​

These belong to the platform administrator to adopt and tune; the cluster operator's part is that rules can be loaded and that notifications route somewhere. If you are building a rule set from scratch, these are the ones worth having on day one:

AlertRule
Cross-tenant access attemptAny OLIAUTHN4 — should be zero; page on it
Blocked internal egressAny OLIFETCH1 — indicates a datapoint pointing at an internal address, deliberately or otherwise
Privilege probingRepeated OLIAUTHZ2 / OLIAUTHZ3 from one user
Another user's job requestedAny OLIORCH1
Authentication failure burstOLIAUTHN5–OLIAUTHN7 rate over baseline, grouped by source IP
Logging tamperingAny OLIMISC1 / OLIMISC2 outside a change window
Secret access anomalyOLISEC1 / OLISEC2 from an unexpected service or outside a change window

What OLIVE does not provide​

Detection logic — anomaly detection, per-tenant baselines, impossible-travel analysis — is deliberately not built into the product. Those are operational capabilities, and a partial version built into the platform would be worse than none. OLIVE provides the signal; the detection is built on top of it, by the platform administrator on the OLIVE events and by the cluster operator on the infrastructure.