Event log
- Synopsis
- Full Details
In briefThe event log is the record of every event the platform processed: where it came from, what it changed, and whether it succeeded. Each event carries a correlation ID, so you can follow one action through everything it set off.
WhereOperations › Event Log. It shows the environment selected at the top of the Operations section of the navigation; switch environment there.
When
- An event — from a job, a self service button, the API, a webhook or an agent — did not do what you expected.
- You want to see what one action set off, through its correlation ID.
- You want to know what a property token resolved to on a particular attempt.
- A
FAILEDevent needs explaining before anyone raises it again.
Use something else when you need to know what a job did: its Output and Status History are on the Processes page.
How
- Open Operations › Event Log, and check the environment selected above it in the navigation.
- Narrow the list by Status, Event Type, Source, User or date.
- Select an event to read its Payload, State Changes, Attempts and Error.
- Select its Correlation ID to see every event from the same action.
For the full steps, see Use the event log.
- The payload is stored as it was authored. Property tokens are resolved each time the event is processed, and Attempts shows what each one resolved to.
- An event refused before it became an event — an agent's event line with the wrong field count, for instance — has no row here.
- A job or workflow event refused for a name that would add extra tags or entries is recorded as
FAILED, with the reason; nothing in it was applied. So is an event that would create a property whose name holds a token that did not resolve. - The list refreshes itself every 10 seconds by default; pause it while you read.
- Reading the log needs the Audit History View permission, which applies tenant-wide.
- There is no Retry in the event log. To run a failed event again, raise it again from where it came from.
- A
$JOB:ADDthat partly failed is not safe to raise again as it stands. Read its error first. - A not supported error is permanent. Remove or replace the event rather than raising it again.
Task walkthrough: Use the event log. This page is the full configuration and troubleshooting reference.
The event log is the record of everything the platform processed — every event, where it came from, what it did, and whether it succeeded. It's the primary tool for tracing what happened and why across a chain of related actions.
- Reading an Event
- Filtering and Correlation
- Agent Events
- Outcomes and Failures
- Permissions
Reading an Event
What an event shows
List view: the columns are Timestamp (when the event was received), Type,
Environment, Status, Source, User (who or what triggered it) and Duration (how
long it took to process). The type column shows the event's display name — the
same name the job editor and the other event forms use, for example Hold Job — with the raw
$JOB:HOLD beneath it, so you can read the list without translating codes and still have the exact
type to hand. For an action a person took, User shows a
human-readable name — the user's display name, or their email if there's no display name — falling
back to the user id only when neither is recorded. For a person's own actions that name comes from
their signed-in identity, so it can't be spoofed by the request. When a person's $MACHINE:STATUS,
$JOB or $SCHEDULE event changes an agent, a job or a workflow, that change is recorded under the
same person, not System — see
Who an event's change is recorded under.
Detail view adds: the Event ID, the Correlation ID (select it to see every event from the same action), the service it was Routed To, its Timestamps, the Payload, the State Changes it made (entity, field, previous → new value), Attempts (what each processing attempt resolved — see below), and the Error (code + message) if it failed.
Statuses and sources
| Field | Values |
|---|---|
| Status | RECEIVED, PROCESSING, COMPLETED, FAILED. The status filter also offers EXPIRED, but no event has that status in the current release |
| Source | API, CLI, AGENT, SCHEDULER, WEBHOOK, UI, JOB_EVENT |
A payload is stored as it was authored
An event's payload is kept as the author wrote it, [[…]] property tokens included. For an
event raised from outside a job — source UI, API, CLI, WEBHOOK or AGENT — those tokens are
resolved each time the event is processed, and the result is never written back. So the row you
read shows the intent, not an earlier resolution.
An event whose token could not be resolved shows as FAILED, and its error names the token as
authored and the field it sat in — never the value anything resolved to, since more people can
read this log than can read the properties behind it. See An event raised from outside a
job.
A job or workflow event is different: its tokens are filled in as it fires, and one that does not
resolve keeps its authored text while the event still goes ahead. The exception is a property
name the event would create: the property name of a $PROPERTY:ADD, or a name in the
Instance Properties or Schedule Properties list of $JOB:ADD, $JOB:ADDHLD,
$SCHEDULE:BUILD and $SCHEDULE:BUILDHLD. If a token in such a name did not resolve, the event
shows here as FAILED, with the reason, and no property is added. Before this, such an event
created a property named with the token's text.
The same holds for an error that came back from somewhere else. An event whose tokens resolved fine and was then refused downstream carries that refusal as its error — and the service that refused it may well quote the offending value back, which would be the resolved property's value. Any value a token resolved to on this event is removed from the error before it is stored, including where the value has been changed in case or percent-encoded on the way, and where one value happens to contain another. So an event's error names what went wrong without reprinting what a property held.
Attempts: what each one resolved
Because the payload holds the tokens and not their values, the payload alone cannot tell you what a
particular attempt actually used. A [[$DATE]] event that failed at 23:59 and was processed again
the next morning resolved two different dates, and neither appeared anywhere.
The detail view now carries an Attempts section: one entry per processing attempt, numbered, with
its outcome (SUCCESS, FAILED or TIMEOUT) and the time it started. Under each attempt is a line
per property token it resolved and what that token resolved to:
[[OI.$DATE]] → 9/25/2026
Tokens are listed in their full form, so a token authored as [[$DATE]] reads as
[[OI.$DATE]]. Identical token-and-value pairs are listed once.
Values are masked where you could not read them anyway. This section does not become a side channel onto a property you have no access to:
| The token resolved | What the attempt line shows |
|---|---|
| An encrypted property's value | ******** |
| A global property's plain value | The value, but only if you hold Properties View in that property's workspace. Masked for anyone else, and masked if the check cannot complete |
| A date or time value | Always shown — there is nothing to protect |
| Anything landing in a field the stored payload redacts | Masked, so the trail cannot reveal what the payload hides |
Two bounds are worth knowing: an attempt records at most 100 token-and-value pairs, and a value longer than 1024 characters is shown truncated.
Events processed before this shipped have no attempt entries at all, and numbering for one of them starts at 1 on its next attempt. An attempt whose process died part-way through also records no entry — the values it used were never known.
Filtering and Correlation
Filtering, correlation, and live view
The log shows events for the environment selected at the top of the Operations section of the navigation, so switch environment there rather than on the page — the page has no environment list of its own.
- Filters: status, event type, source, date range, and User (matches any part of the name the User column shows — the display name, or the email where there is none).
- Event type is a multi-select picker over the catalog of known types, matched exactly.
Selecting several matches events of any of them. It is no longer a free-text pattern, so a partial
string won't match. The picker lists each type by its display name with the raw
$TYPEas a hint, grouped by category in the same order the event forms use — so a type is in the same place here as it is where you authored it. Values sent to the server are still the raw types. - A type the platform will never support is still filterable. Those events are stored as
FAILEDrather than refused outright, so they appear in the log and the picker lists them. - The date range covers both the From and the To day, read in the scheduler's time zone — the zone the list's times are shown in — rather than your browser's.
- Correlation: every event carries a correlation ID. Select it in the event's detail to open a view of all events that share it — follow a single action through everything it caused.
- Live polling: refresh every 5/10/30/60 seconds (10s default), with play/pause and manual refresh; page size 25/50/100 (50 default).
- To trace an incident, start from a failed event and open its correlation view to see the full chain (the triggering action and everything it set off).
- A
FAILEDevent's detail includes the error — the fastest place to see why something didn't process. - There is no Retry in the event log. To run a failed event again, raise it again from where it came from: the workflow, the self service button, or the machine.
Agent Events
Events with source AGENT
AGENT means a legacy LSAM machine raised the event itself — a job or process on that machine
wrote a file of event syntax into the agent's MSGIN directory. Such an event shows the machine
name as its actor, plus the service account whose credential the line carried, as the identity
system confirmed it. The event is checked against that account's roles, except for a line that uses
the SYSTEM/MESSAGE compatibility pair. The payload holds the line as received, with its trailing
credential pair removed and the token masked.
Two things about these events differ from the rest of the log, and both matter when you are trying to find out why an event file did nothing:
- A line refused before it became an event never appears here. A wrong field count, an unknown
event type, or a machine with no Default event environment set is refused at the platform edge,
so there is no row to find. An event that was accepted and then failed does appear, as
FAILED. - A stored properties value can be a placeholder. For
$JOB:ADD,$JOB:ADDHLD,$SCHEDULE:BUILDand$SCHEDULE:BUILDHLDraised by an agent, a properties value is replaced with a placeholder before the event is stored, because event files are hand-written and can carry a password. The original value is not kept, so to run such an event again, raise it again from the machine.
Outcomes and Failures
Message-only events
$CONSOLE:DISPLAY exists to make a message visible in the log, and nothing else — there is no
downstream action for it to take. It now completes: the event is recorded with its message and shows
as COMPLETED. On earlier builds it was accepted and then logged as FAILED, so a message that had
in fact been received read as an error.
This is the only event type that completes without doing anything downstream. An event type the
platform can't act on still reports FAILED — a green row for $MACHINE:MAXJOBS, say, would claim
a per-machine job limit had been applied when nothing enforces one. $MACHINE:STATUS is not one of
those: it is carried out, and sets the agent's operator mark. See Events for which
types are applied.
An event type can fail for two different reasons
Both read as FAILED, and the error tells you which you are looking at:
| The error says | What it means | What to do |
|---|---|---|
| …is not yet supported / not yet implemented / …is not supported yet | The type is accepted, but the platform does not carry it out. Nine types are in this state: $JOB:RESCHEDULE, $JOB:RESCHEDHLD, $JOB:USER, $JOB:MACHGRP, $SCHEDULE:START, $SCHEDULE:DELETE, $SCHEDULE:CHECK, $SCHEDULE:CHECKALL and $MACHINE:MAXJOBS | Use another way to get the same result |
| …is not supported on this platform and will not be applied | The type will not arrive. Eight $NOTIFY types are refused permanently: $NOTIFY:COMMAND, $NOTIFY:LOG, $NOTIFY:NETSEND, $NOTIFY:SNMP, $NOTIFY:SPOAL, $NOTIFY:SPOCO, $NOTIFY:TASKS and $NOTIFY:TEXTMSG | Remove the event, or replace it — the message says so |
The difference is not cosmetic. A not supported refusal happens before the event resolves a token or reaches any service, so nothing was half-done and the producer is told to stop rather than retrying on a schedule. A Vision card refuses one of the eight when you save the card, and no event picker in the product offers them any more — though an event already saved with one still shows its stored type rather than reading as blank.
A third refusal is separate from both: $JOB:TRACK, $JOB:QUEUED and $JOB:QUESTATE are raised
only by an agent's LSAM. Raised from anywhere else, such an event is recorded as FAILED with an
error saying so, and Nothing was changed.
$NOTIFY:EMAIL is not in either list: it is carried out, and sends mail. See
Sending mail with $NOTIFY:EMAIL. Neither is $MACHINE:STATUS,
which is carried out. Every type and its status is listed in Events.
A job or workflow event refused before it was applied
A job or workflow event is resolved before it is sent, and some resolved values are refused: a job,
schedule, machine or frequency name that would split the Tags field into extra tags, or add
entries to properties or dates — see
A value that would break the field it lands in. Such an event is still recorded
here, as FAILED, with source SCHEDULER. Its error has the code EVENT_REFUSED_BY_SUBMITTER, and
the message names the event type, the reason and the field, and ends Nothing was applied.
Nothing in the event was carried out. If the job has other events, they still run. Earlier builds did not send a refused event at all, so it left no row here.
A $JOB:ADD event reports one outcome per instance
A $JOB:ADD or $JOB:ADDHLD that names a multi-instance
job adds several job instances at
once, so it records one state change per instance, each under the projected <job>.<instance>
name the rest of the run identifies it by. An instance that was refused because it is already
running is recorded as such and does not fail the event — the job it asked for is there.
The event FAILEDs when an instance did not land, or landed in a state from which it can never
start because its dependencies could not be recorded. A failed event keeps no state changes, so the
message carries the whole picture instead: how many of the instances were added, which were not and
why, which were added but will never start — those have to be removed and added again — and which
were already running. Added instances are named with their IDs, because this is the only record of
them the event leaves.
Some instances were added before the failure, so raising the same event again would add the rest and attempt the ones that landed. Read the message, deal with the instances it names, and only then decide whether anything still needs adding.
An add that had nothing to report — a single instance that conflicts, or a fan-out where every instance does — is refused outright, and fails the event with no partial state to reconcile.
Permissions
Who can read the event log
Reading the event log needs the Audit History View permission: the list, an event's detail, its correlation view and the event statistics, on the screen and through the API alike. The permission is global, so it applies tenant-wide and the list is not narrowed to particular workspaces. It is also what offers Event Log in the navigation.
Your own events need no permission. A request for only the events you raised yourself is answered without it, so the home dashboard's list of your events works for everyone. See The event history needs Audit History.
Contact support when
- An event is
FAILEDwith no actionable error, or its State Changes don't match what actually happened in the system.
Include the event ID, correlation ID, type, status, and the error from the detail view.