Transparency

What JOX knows about every run.

When a job fails — or when the auditor asks what actually ran in production two years ago — the depth of your persistence decides whether you have an answer in seconds or spend hours digging. JOX captures every run transactionally in the repository: status, resolved values, before/after states, parallel activity, and sent notifications. SQL statements are always captured; Persistence of OS-job output is configurable per template.

Captured per run

Seven dimensions, every run.

Status

Success or failure — binary and honest.

Every run is captured with precise timestamps, transactionally in the repository: start, end, duration, status. The return code is evaluated binary: 0 = OK, anything else = failure. That clarity makes template development fast and straightforward — no exit-code gymnastics, no mapping-table maintenance.

OS-job output

stdout / stderr on demand. Environment variables always.

stdout and stderr can be persisted in the JOX repository per job template via Load Output — unabridged, not just "last N lines". Default is off; the log file then stays on the server. Environment variables for every OS-job run, by contrast, are always captured — including the predefined variables that JOX sets, like JOX_JOB_ID, which give every run a unique, traceable identity.

SQL detail

Every statement. Data depending on statement type.

For SQL Actions, SQL Pipes and SQL Extracts, every executed statement is persisted — not the code from the template, but what actually went to the database after variable resolution. The data shows up directly in the JOX GUI:

  • SQL Actions with SELECT: results appear automatically.
  • SQL Pipes: per intermediate result configurable (Load Data).
  • SQL Extracts: configurable with row limit (Load Data + Record Number Limit).
Resolution

Which path, which account, which parameter was actually used.

System Functionalities are a template's abstract functionality bindings — things like bin_dir or billing_schema. They map per Location × Area to concrete directories or DB accounts. On top of that, classic JOX variables (e.g. order parameters) are resolved at runtime. In the run record you don't see the names — you see the concrete values: the path, the account, the parameter that was actually used.

Before / After

Which files changed. Which DB state was visible before and after.

Which files did the run create or touch? And what was the database state visible immediately before and immediately after execution? This before/after view turns pure output persistence into a complete impact ledger — the basis for follow-up audits and re-run decisions.

Activity context

What else was running in parallel.

From any run detail you jump straight into the Activity Report for the exact time window — and see all the jobs that ran in parallel (e.g. on the same Location or in the same Area). That is often the key piece of information when a job behaves differently under load than it does in isolation.

Notifications

Which emails went to which recipients.

Every email that JOX sent in response to the run is persisted — with the full recipient list and the complete body. For area-dependent distribution lists, you see the concrete resolution — who was actually notified.

With JOX we have an extremely reliable scheduler with deterministic results. The historization of processes and outcomes leaves our auditors more than satisfied.

In practice

What the persistence is really worth.

Forensics — a failed billing run and its rerun

Last night's billing run crashed at 02:17. Instead of digging for log files on the file system, you open the order in JOX. The failed job is immediately visible — flagged red. Output is complete. The last line reads "Segmentation fault", and there's a core file — a failure pattern that almost never happens. A glance at the JOX group "Server Configuration Checks", looking at last evening's order on the billing-relevant location, shows: yesterday an OS patch was applied that replaced a library used by the billing module. After the library is restored, the jobs of the billing order that ran from the upgrade point onward — including the billing run itself — are rerun recursively.

Compliance — external auditors with questions

"Which migration scripts ran against the production database in April 2024, and who was notified?" Activity Report including archived jobs surfaces the migration order. The order is brought back from the archive via Restore in a few seconds. All there: status, output, resolved values, number of rows changed by SQL, mail trail.

Replay — reproducing a historical run

A customer disputes an invoice from last quarter. You want to reproduce the run identically. Just copy the JOX order — same area, locations and parameters are already in place.

Talk

Want to see this in action?

A demo walks through the run detail using a concrete use case from your world. A short email with the use case is enough — then we show you the forensic depth on your own example.