---
license: cc0-1.0
task_categories:
- text-generation
size_categories:
- 1K<n<10K
pretty_name: IFParse v2.0
configs:
- config_name: default
  data_files:
  - split: test
    path: test.parquet
tags:
- structured-output
- json
- observability
- telemetry
- log-parsing
- benchmark
---

# IFParse v2.0

**Hostile telemetry in. Exact JSON out.**

IFParse v2.0 is a benchmark for the part of observability that demos usually skip: turning real production record shapes into a strict, normalized JSON contract with no repairs, no guessing, and no partial credit.

Every task contains a raw record, a frozen JSON Schema contract, and a reference object. The model must emit exactly that object. A single wrong type, wrong null, wrong timestamp, extra key, code fence, or explanatory sentence fails the task.

## At a glance

| | |
|---|---|
| Tasks | **1,800** |
| Families | **9** × 200 |
| Difficulty | **360 hard**, **1,080 brutal**, **360 nightmare** |
| Trap types | **117** machine-declared transformations |
| Native formats | nginx, RFC 5424 syslog, AWS CloudTrail, Kubernetes audit, Zeek conn, ArcSight CEF, Windows Sysmon XML, PostgreSQL csvlog, raw HTTP/1.1 |
| Primary metric | **perfect** — binary exact semantic match |
| Diagnostics | valid JSON, no fences, no filler, schema match, exact match, field accuracy, per-trap attribution |

## Why it exists

Most telemetry-parsing evaluations stop at "did the model produce valid JSON?" That question is too easy. A parser can emit valid JSON with the wrong null semantics, an offset timestamp that was never normalized, a status/reason pair that cannot coexist, or a policy action attached to the wrong resource type.

IFParse v2.0 measures whether a model can produce the **one exact object** that a careful parser would produce from a hostile native record.

Three properties define the difficulty:

1. **Semantic exactness, not schema compliance.** A response can validate against the schema and still be wrong. The reference must be exactly equal, including null-vs-empty, integer types, array order, timestamp precision, and nested field semantics.
2. **Causal difficulty tiers.** Every task declares a `traps` list — the specific transformations it exercises, each with a weight. The tier is derived from the trap weight, not chosen independently: `hard` carries 3–5 weight points, `brutal` 6–9, `nightmare` 10–15.
3. **Real record grammar.** Records preserve native quoting, escaping, timezone offsets, NILVALUE, XML entities, CSV quoting, CEF escaping, chunked HTTP bodies, and JSON policy documents. The model has to decode each format exactly once.

## Task structure

Each row is a JSON object:

| Field | Type | Meaning |
|---|---|---|
| `task_id` | string | Stable id, e.g. `ifparse-v2.0-edge-0000` |
| `family` | string | One of the nine family names |
| `contract_id` | string | Contract version, e.g. `edge.v1` |
| `difficulty` | string | `hard`, `brutal`, or `nightmare` |
| `traps` | array | Machine ids of the transformations the task exercises |
| `raw_format` | string | Native format label |
| `system_prompt` | string | Frozen system message |
| `prompt` | string | Frozen user prompt containing the record and contract |
| `raw_record` | string | Native record |
| `schema` | string | JSON Schema serialized as a string |
| `reference` | string | Exact reference object serialized as a string |

`schema` and `reference` are strings containing JSON. The prompt is already frozen — no templating is required to evaluate.

## Task families

| Family | Native record | Contract | What makes it hostile |
|---|---|---|---|
| `edge` | nginx extended access log | `edge.v1` | offset timestamps, percent-decoded targets, absolute-form request lines with a decoy vhost, trusted-proxy X-Forwarded-For resolution, multi-hop upstream retries, NILVALUE cache |
| `syslog` | RFC 5424 | `syslog.v1` | PRI decomposition, NILVALUE, escaped structured data, multiple SD elements, variable timestamp precision, UTF-8 messages |
| `cloud` | AWS CloudTrail JSON | `cloud.v1` | nested identity, string booleans, double-encoded policy, ARN/resource coherence, decoy `additionalEventData`, `AssumeRole` role ARN |
| `k8s` | Kubernetes audit event | `k8s.v1` | RFC3339Nano latency floor, URI/apiVersion coherence, identity-linked RBAC reasons, stage-dependent semantics, service-account groups |
| `net` | Zeek `conn` TSV | `net.v1` | unset `-` vs `(empty)`, T/F booleans, sorted sets, epoch timestamps, interval-to-ms, failed-state packet semantics |
| `sec` | ArcSight CEF | `sec.v1` | header pipe escaping, extension escaping, full 0–10 severity bands, shuffled extensions, decoy fields, `cs1..csN` label pairs |
| `win` | Sysmon event XML | `win.v1` | four event types (1/3/11/22) in one contract, subtype-driven nullability, XML entities, hash order and case, 100 ns wire timestamps |
| `db` | PostgreSQL csvlog | `db.v1` | CSV quoting, embedded newlines and quotes, IPv6 clients, duration in milliseconds, SQLSTATE/message pairing |
| `http` | raw HTTP/1.1 request | `http.v1` | chunked bodies with byte-accurate sizes and chunk extensions, obs-fold continuations, duplicate and case-variant headers, header/body promotion rules |

Field-level contracts and the full trap list with weights: [`TAXONOMY.md`](TAXONOMY.md).

## Difficulty tiers

| Tier | Per family | Global | Trap weight |
|---|---:|---:|---|
| `hard` | 40 | 360 | 3–5 |
| `brutal` | 120 | 1,080 | 6–9 |
| `nightmare` | 40 | 360 | 10–15 |

Tier is a property of the task, derived from its declared traps. The gold object is always exact.

## Scoring

`perfect` is binary:

```text
perfect = valid_json ∧ no_fences ∧ no_filler ∧ schema_match ∧ exact_match
```

Diagnostics are reported separately:

- `valid_json` — the raw response parses as JSON
- `no_fences` — no Markdown code fence
- `no_filler` — no prose before or after the JSON value
- `schema_match` — the parsed value validates against the task schema
- `exact_match` — strict semantic equality with the reference
- `field_accuracy` — path-level agreement, for error analysis only
- `by_trap` — per-trap perfect rate and field accuracy

There is no normalization of numeric strings, no coercion of `null` to `""`, and no array sorting at scoring time. The contract is the contract.

## Independent community results

An independent evaluation by a community member (John6666) ran nine model conditions on a 72-task stratified subset of this dataset with GGUF models, greedy decoding, and a local strict-proxy scorer built from the published contract. Direct quote of the reported table:

| Model / GGUF quantization | Valid JSON / 72 | Schema pass / 72 | Strict perfect / 72 |
|---|---:|---:|---:|
| Qwen2.5-14B-Instruct Q4_K_M | 71 | 53 | 16 |
| Qwen2.5-7B-Instruct Q4_K_M | 69 | 47 | 5 |
| Qwen2.5-3B-Instruct Q6_K | 64 | 37 | 4 |
| Qwen2.5-1.5B-Instruct Q6_K | 62 | 17 | 0 |
| Qwen3-4B-Instruct-2507 Q6_K | 69 | 51 | 6 |
| Phi-4-mini-instruct Q6_K | 35 | 18 | 0 |
| LFM2.5-1.2B-Instruct Q6_K | 61 | 3 | 0 |
| Qwen2.5-0.5B-Instruct Q8_0 | 17 | 3 | 0 |
| Ministral-3-8B-Instruct-2512 Q4_K_M | 0 | 0 | 0 |

These numbers are **not** comparable to the published 270-task baselines above: different slice, different inference stack (GGUF/llama-cpp vs transformers), different quantization, and a proxy scorer rather than the executable one. They are reported here because they independently reproduce the benchmark's central finding  **format discipline is solved, exactness is not**: the 14B model emitted parseable JSON in 71/72 cases and schema-valid objects in 53, yet matched the full reference in only 16.

The Ministral-3 row is a pure wrapper failure: all 72 responses were fenced, so strict perfect is 0; as a diagnostic-only counterfactual, removing the outer fence (nothing else) yields 72 parseable, 61 schema-valid, 9 exact. The benchmark's answer: a downstream consumer that requires the object as-is cannot accept fenced output, but the fence/content split is exactly the kind of failure-stage view the diagnostics already support  report `no_fences` and `exact_match` separately and both stories are visible.

## Usage

```python
import json

rows = [json.loads(line) for line in open("test.jsonl", encoding="utf-8")]
row = rows[0]

print(row["task_id"], row["family"], row["difficulty"], row["traps"])
print(row["raw_record"])
print(json.loads(row["reference"]))
```

Predictions are JSONL records with `task_id` and `response`:

```json
{"task_id":"ifparse-v2.0-edge-0000","response":"{\"bytes\":3157}"}
```

## Splits

There is one `test` split (1,800 tasks). There is no train split.

## Data characteristics

All telemetry is synthetic.

- Domains use `example.com`, `example.net`, `example.org`, or `.invalid`.
- IPv4 and IPv6 addresses use documentation, private, loopback, or otherwise reserved ranges.
- Identities, accounts, ARNs, hostnames, process ids, session ids, and hashes are fabricated.
- No real customer data, credentials, access keys, or production telemetry are included.

The release verifier scans raw records and references for non-reserved emails and public IP addresses; the current release has zero findings.

## Limitations

- The references define one defensible normalization per task. Other production systems may choose different conventions for nulls, duplicate query keys, or array ordering.
- The benchmark covers nine common telemetry grammars. It does not cover every vendor or version of those grammars.
- The tasks are synthetic and seeded from a generator. They are not sampled from a production corpus.
- Exact match is intentionally unforgiving. Field accuracy and per-trap attribution are provided for diagnosis.
- Exact match is a hard ceiling: a model that answers 95% of individual fields correctly still fails most tasks. Report field accuracy alongside the primary metric.

## Contamination policy

The public test split is frozen. A held-out split with identical contracts, families, and tier
balance exists under a private seed and is never published; it exists so that results on the
public split can be checked against unseen rows of the same distribution. Note the standard
caveat: a held-out split prevents answer memorization, not style overfitting to the generator.

## Usage policy

- Do not train on the test split and report the result as held-out performance. If you use the data for training, disclose it.
- Do not use the benchmark as evidence that a model is safe for production ingestion.

## Citation

```bibtex
@dataset{Muse2026ifparsev2,
  title  = {IFParse v2.0: Hostile Telemetry Normalization with Exact JSON Contracts},
  author = {Muse-Research},
  year   = {2026},
  version = {2.0.0}
}
```

## License

Code is MIT. Data is CC0 1.0. See [`LICENSE`](https://huggingface.co/datasets/Muse-research/Ifparse-v2.0/blob/main/LICENSE).