README.md

metadata

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.

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:

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.

Usage

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:

{"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

@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.