Security Data Works

OCSF in practice

What "OCSF-native" actually delivers

Pipeline products often sell "OCSF-native" or "normalizes to OCSF at ingest," and when I checked in June what four tool families ship for the same four sources, only Tenzir shipped a mapping that could run on the bench corpus, and for one source in four. The fidelity score that mapping produced on Zeek conn turned out to be measuring my own answer key as much as the tool, because the key marked Tenzir down for mapping choices I now think were better than mine.

Zeek is the source I know best, partly because I built and open-sourced its OCSF mapping myself, so that one score is what this piece reads most closely. The availability half is what a buyer reading "OCSF-native" on a slide needs, and the answer-key half is what anyone building an OCSF gold set to test vendors needs before trusting it.

Reading time: about 15 minutes. Evidence tier: A for the OCSF 1.8.0 and 1.9.0 schema text and changelog; B for the June bench (single host, synthetic corpus, pre-registered before any scored run) and for the November re-score (agent-run); B for vendor documentation of what a feature does.

Grid titled Of two tools that advertise OCSF, one shipped a mapping that ran on my bench corpus. In June 2026 Tenzir 6.0.0 ran on Zeek conn, highlighted in blue, shipped nothing for CloudTrail and handled Sysmon only as EVTX/XML rather than JSON; Cribl 4.18.1 had no public pack for Zeek conn or Sysmon JSON, and its CloudTrail path was not tested. Vector and Logstash ship none, and the generic auth source has no mapping by design.
SDW Lab pipeline-normalization bench, June 2026, one host, Tier B. Cribl's untested CloudTrail path is the account-gated Amazon Security Lake pack, and on Tenzir's November library JSON Sysmon maps once three collector constants are set, which would change the Sysmon cell if accepted on the same terms as Zeek's, a call the later section leaves open.

Method

The bench

The design was pre-registered on 2026-06-10, before any scored run (pipeline-normalization-fidelity, Tier B). Four sources, each about 100,000 deterministic synthetic records with realistic field names: Zeek conn.log (Network Activity 4001), AWS CloudTrail management events (API Activity 6003), Sysmon process creation as pre-parsed JSON (Process Activity 1007), and a generic authentication source (Authentication 3002). Each tool maps the corpus to OCSF 1.8.0 with its most official available mapping, shipped first and vendor-published second, and a tool with nothing shipped scores 0% coverage for that source, with any hand-written fill reported separately, since a hand-written mapping measures its author more than the tool. The input can still need shaping before a shipped mapping will read it, and the Zeek arm did: the synthetic corpus omits the _path = "conn" field that Zeek's own JSON logger writes on every record, and Tenzir's mapping dispatches on it, so the bench pipeline adds that one constant. The scorer checks three levels against a hand-built gold mapping: field fidelity (does the source field land on a typed OCSF attribute), value fidelity (does its value survive), and semantic fidelity (class, activity_id, type_uid, plus five recurring crosswalk failure classes from the earlier six-schemas work). It passes its own self-check at 100% on all three levels when fed the gold's own mapping.

The pre-registration named three tools, Tenzir, Cribl and Vector, and Logstash was added on 2026-06-16 under its own registration. It also committed a panel of SOC-shaped queries, which has no published output, so nothing below rests on it.

Availability

Availability is the first gate

Four tool families were checked between 2026-06-14 and 2026-06-16, with versions pinned, and only Tenzir shipped a mapping that could be scored on the bench corpus (all Tier B, single host). Tenzir was re-checked in November; the other three are as of June 2026 and haven't been re-checked.

Tool and versionWhat ships for OCSFBench sources with a usable shipped mapping
Tenzir 6.0.0, Community Library @ 671e049TQL mapping packages per source (zeek::ocsf::map, sysmon::ocsf::map, an amazon package)1 of 4 (Zeek conn)
Vector 0.56.0No OCSF component, VRL function or string in the binary0 of 4
Logstash OSS 7.10.2 (January 2021, the last Apache-2.0 OSS build) and Elastic 8.17.0 (December 2024)No ocsf codec or filter in either edition0 of 4
Cribl Stream 4.18.1 (free, on-prem, Docker)No OCSF in the base image; per-source and per-partner packs0 of 4 among public on-prem packs; the official Security Lake pack was out of scope

The generic auth source has no vendor mapping by design, so the ceiling for any tool on this corpus is three of four.

The Tenzir misses at the June library are worth a closer look because they were not the "no mapping exists" kind. The sysmon::ocsf::map operator called parse_winlog(), so it expected raw Windows EVTX/XML and did not consume the flat pre-parsed JSON that collectors such as NXLog emit; the amazon package covered Route 53, Security Lake and VPC Flow and had no CloudTrail management-events mapping; and no vendor ships a mapping for a generic auth source's field names, which is a fair miss by design. So "Tenzir maps Sysmon to OCSF" was true in June and also did not help a team whose Sysmon arrives as JSON, which is the input-shape trap I'd check first on any vendor's mapping list. On the current library (v6.22.0 with 9949f753, as of 2026-11-15) that changes: JSON Sysmon in NXLog's flat shape maps through the microsoft package to Process Activity on every record once three NXLog collector-metadata constants are present, and that is the same kind of shaping as the Zeek arm's _path constant, three constants instead of one (the November re-score, section d). Accepted on the same terms as Zeek's, it would make the current Tenzir count two of four. The re-score left that call open and I haven't made it, so the table stays as measured in June.

Cribl advertises packaged OCSF mappings, and on the three pack samples I ran, every conversion emitted OCSF of the class it targets, with a caveat that keeps it out of the same table as the others. With the community camrunr/cribl-ocsf-conversion pack v0.5.1 (self-labeled work in progress) run through cribl pipe on the pack's own bundled samples, all three conversions emitted structurally valid OCSF with the class_uid, category and type_uid each conversion names: Okta to Authentication 3002, AWS WAF to 4002 and Proofpoint TAP to 4009. Two of the three resolved to a specific activity; the Okta OAuth-authorize event fell back to activity_id: 99 (Other), and every conversion left a tail of 4 to 10 field groups in unmapped.extras (Tier B). Those are the pack's samples, assessed on their own terms and not against a gold, so I can say Cribl emits OCSF of the intended class where a pack exists for the source and cannot put a fidelity percentage next to Tenzir's. I also did not test the official Amazon Security Lake pack, which is account-gated and targets a SaaS lake outside the self-hostable scope this site's Capability Matrix is built around.

So of the two families that advertise OCSF, Tenzir shipped a runnable mapping for one of my four sources and Cribl's public on-prem packs for none of them, and the two general-purpose routers, Vector and Logstash, ship nothing and, as far as I can tell, don't claim to. Whether a usable mapping ships for your source, in the shape your shipper emits, binds before fidelity is even a question, and I'd read "OCSF-native" on a slide as a claim about a list of sources and ask for the list.

Fidelity

What the Zeek fidelity number measured

The one source that produced a fidelity score was Tenzir on Zeek conn, and the bench's published summary says: class 100%, field fidelity 80%, value fidelity 92%, and activity_id correct on 17% of records, with history, service and uid described as landing in unmapped and ts mangled on every record. The same summary also found that Tenzir reproduced neither of the two crosswalk failure classes it could test on Zeek, entity-role inversion and observables flattening, on any record. I published that summary, and it was repeated on Matrix pages and in two of my essays as evidence that a shipped mapping gets the class right and the activity wrong, but it misreads both the activity figure and the three fields it calls dropped.

Joining Tenzir's 100,000 emitted events to the gold on _id and cross-tabulating Zeek conn_state against the two activity_id values shows what the records actually say (Tier B; derived in the lab on 2026-11-09 and reproduced by the bench's own erratum script). Both files are gitignored, so reproducing this from the public repo means regenerating the corpus and re-running Tenzir's pipeline in Docker.

Zeek conn_stateRecordsGold activity_idTenzir activity_id
S0 (attempt, no reply)16,6976 Traffic1 Open
SF (normal establish and close)16,5796 Traffic2 Close
RSTO / RSTR (reset by either side)33,3456 Traffic3 Reset
REJ (rejected)16,6776 Traffic5 Refuse
OTH (no SYN seen, midstream)16,7026 Traffic6 Traffic

The gold pins every connection to Traffic (6), a choice written into the generator as "6 = Traffic (the conn.log grain)", and Tenzir derives the activity from conn_state. The 17% is the OTH share, the one state where the two readings agree, and since the generator draws its six states uniformly, it is one sixth by construction and says nothing about a production traffic mix. The summary's sentence "the mapping does not derive the OCSF activity from Zeek's conn_state" has the mechanism backwards, because Tenzir derives it and my gold does not.

Which reading is right is an ontology call more than a fact, and I'll state mine as an opinion. Network Activity's activity enum has 1 Open, 2 Close, 3 Reset, 4 Fail, 5 Refuse, 6 Traffic and 7 Listen, plus 0 Unknown and 99 Other (Tier A, OCSF schema), and I read it as existing so that a consumer can filter for refused or reset connections without parsing vendor strings, which Tenzir's mapping supports and the gold, by collapsing five distinguishable outcomes into one, does not. I'd argue about S0 (a connection attempt with no reply reads to me more like Fail than Open), though Tenzir documents its choice in a comment in the mapping. On Reset, the enum text says a connection "abnormally terminated or closed by a middle device like firewalls" (OCSF 1.8.0 schema export, Tier A); one reading limits that to middle-device closure, which would exclude Zeek's endpoint resets, but I don't think that's the natural reading, and a passive sensor can't always tell an endpoint RST from an injected one anyway. So on SF, REJ and the reset states I think Tenzir's reading is the more useful one and the gold is lazy.

The three "dropped" fields follow the same pattern. Tenzir did not park them in unmapped; the only thing in unmapped on the emitted records is the bench's own _id join key. It put Zeek's uid at connection_info.uid (and metadata.original_event_uid and metadata.correlation_uid), service at app_protocol_name, and history at connection_info.flag_history, all of which resolve as valid paths in the same OCSF 1.8.0 subset the scorer validates against, with the source value intact on every record. The gold wanted metadata.uid, app_name and connection_info.tcp_flags, and the last one is hard to defend, since tcp_flags is an integer bitmask and Zeek's history is a string of letters that flag_history exists to hold. The pre-registration defined field fidelity as a field landing on a typed OCSF attribute, as against being dropped or stuffed into unmapped, and by that wording all three landings count; the scorer as built was narrower, counting any landing other than the gold's chosen path as a drop, so the 80% measures agreement with my choices and says little about what Tenzir lost.

The ts finding is real but smaller than "mangled", and on a closer read it isn't a mapping finding at all. In the JSON the bench pipeline wrote, time is an RFC 3339 string with nanosecond digits (2026-01-06T14:33:05.181363968Z), where OCSF types time as timestamp_t, an integer count of milliseconds since the epoch. No information is lost, but a strict JSON consumer that expects the OCSF integer will reject or mis-parse every record. The string is Tenzir's default rendering, and Tenzir documents a cast option, timestamp_to_ms, for consumers that need the integer; its guide says which post-mapping functions run "is a decision of each pipeline, not part of the mapping", and its own Security Lake package sets that option (Tenzir docs and library, read 2026-11-16, Tier B for what the feature does). The bench pipeline didn't call it, and I haven't checked what it emits on this corpus, so I'd treat the string as a default to know about before you point a strict consumer at the output, not as something to hold against the mapping. A further 53 duration values differed from the gold's millisecond figure by 1 ms; the corpus holds 104 durations that fall on a half millisecond at its microsecond precision, the other 51 agree, and the 53 are consistent with my gold rounding half to even where Tenzir rounds up, so both are faithful conversions (bench erratum, point 5).

The June bench carries an erratum stating those mechanisms (appended 2026-11-15, pre-registration untouched), and the corrected percentages come from a separate re-score whose alternates-accepting gold and activity rule were frozen before scoring but written with Tenzir 6.0.0's output already in view, so its 6.0.0 numbers confirm a reading rather than test one (ocsf-1.9-rescore; Tier B, single host). The re-score was run by an agent session, which also wrote and froze its gold and pre-registration, neither of which I have reviewed, and a second agent re-derived the field and activity figures with its own scripts, re-ran the bench's scorer for the value figures and made one Gemini call as a cross-provider check, without re-running the Tenzir pipelines and with no verdict change. With no cast step in the bench pipeline, the numbers are:

Scored asFieldValue, strictValue, information-preservingActivity
Tenzir 6.0.0 / 671e049, June scorer and gold80%91.66%n/a16.7%
Tenzir 6.0.0 / 671e049, alternates gold100%93.24%100%83.30%
Tenzir v6.22.0 / 9949f753, alternates gold93.24%92.75%100%83.30%

The strict value failures are ts on every record, the string time above, and the v6.22.0 field figure is the duration question in the 1.9.0 section below. The activity figure needs its caveat attached, because the one disagreement left on this corpus is S0, which Tenzir maps to Open, with a comment in its own mapping noting that S0 means only a SYN was seen, while the frozen rule accepts Fail or Traffic. The 83.30% rests entirely on rejecting Open for S0, which was as much a judgement made with the output in view as accepting it would have been, since accepting it would make the figure 100%, and the figure is five sixths of a corpus that draws its six states uniformly, as the 17% was one sixth of it, so it says nothing about a production mix. So the June 17% was my gold pinning every connection to activity 6, which says nothing against Tenzir, and the June 80% was agreement with my path choices, which leaves Tenzir's shipped Zeek mapping close to faithful on this source and, I'd argue, more useful than my gold on activity_id and history.

Testing

What the gold-key problem says about testing "OCSF-native"

A gold key for OCSF mapping records its author's choice at every place where OCSF admits more than one reasonable home for a field, and an exact-match scorer then measures how often a tool agreed with those choices, which is a different thing from how much the tool lost. Zeek conn produced four places where my June gold and Tenzir parted ways over where a value belongs, the activity and three of the fifteen fields (the connection uid, service and history), and at each of the three fields the re-score's gold, written against the OCSF 1.8.0 text, rejects my June choice (bench erratum, points 1 and 3). I don't think this is a mistake peculiar to my bench, because anyone building a gold set by hand makes the same kind of choice field by field, and nothing in an exact-match score tells the reader which misses are real losses and which are disagreements about where a value should go.

Testing · what a gold key measures

The same mapped field scored two ways: a single-answer gold calls it a miss, an alternates gold accepts itAt the top, Zeek conn field uid, which Tenzir maps to connection_info.uid with the source value intact. On the left, a single-answer gold row expects metadata.uid, so an exact-match scorer marks the field wrong, highlighted in red, although nothing was lost. On the right, an alternates gold names connection_info.uid as primary and accepts metadata.original_event_uid and metadata.correlation_uid, and rejects metadata.uid with a written reason, the OCSF 1.8.0 text calling it distinct from the original event identifier; the same output scores as a match. Mechanism, not a measurement.A miss that measured the answer keyOne Zeek field, one tool output, two ways to score itZeek uidmapped by Tenzir toconnection_info.uidSingle-answer goldexpects onlymetadata.uidexact-match scorerscored wrongvalue intact, path valid:it disagreed with the key,it did not lose anythingAlternates goldprimary, then acceptedconnection_info.uidmetadata.original_event_uidmetadata.correlation_uidexact match on any accepted pathscored a matchrejects metadata.uid, withthe reason from the OCSFtext written next to it
The tool output is identical in both panels; only the answer key changes. An exact-match score against one gold row reports how often a tool agreed with the author's choices, which is why the alternates design lists every accepted path and writes down the reason for each rejection. Field paths are from the table below. Mechanism, not a measurement.

The re-score's frozen gold (alternates-gold-zeek_conn.json, sha256 recorded in the pre-registration) is the fix I'd offer, and it works as a worked example of what the extra discipline costs. Each of the fifteen Zeek fields carries one primary OCSF path and zero or more accepted alternates, an alternate is accepted only when the OCSF 1.8.0 dictionary or object text describes the source field's meaning, and the same test was applied to the June gold's choices, with every rejected path listed alongside its reason. The four fields where it matters:

Zeek fieldRe-score primary (alternates)June gold pathWhy the June path is rejected
tstime (start_time)timeNot rejected; the June gold and the re-score agree on the path
uidconnection_info.uid (metadata.original_event_uid, metadata.correlation_uid)metadata.uidThe 1.8.0 text calls it "distinct from the original event identifier in the source system"
serviceapp_protocol_nameapp_nameOCSF describes app_name as an application identified by tools such as NBAR or App ID, YouTube or Webex for instance, and Zeek's service is a detected protocol
historyconnection_info.flag_historyconnection_info.tcp_flagstcp_flags is typed as an integer bitmask, and flag_history holds flag strings

Of the three rejections, metadata.uid and tcp_flags are the ones the bench erratum also questions on the schema text, and app_name is the re-score gold's call alone and the most arguable of the three. The activity is scored against a written rule instead of a gold row: each Zeek conn_state gets an accepted set and one derived primary value, Traffic is accepted for every state because conn.log is a per-connection traffic summary, and Unknown and Other are never accepted. Value checks sit apart from path checks, with a strict rule that wants the OCSF epoch-millisecond integer for ts and an information-preserving rule that also accepts an RFC 3339 string that parses back to the source value, and duration is accepted within 1 ms so that both rounding conventions behind the half-millisecond ties count as faithful. The 20,166 records whose service is Zeek's unset marker - are dropped from that field's denominator instead of being scored as an obligation.

Three caveats travel with that design:

  • The 6.0.0 result is confirmatory by construction, as above, and reproducing the numbers shows they were computed correctly from the design without showing that the design is right (Tier B).
  • The activity rule covers thirteen Zeek connection states, but the corpus exercises only six of them (S0, SF, RSTO, RSTR, REJ and OTH), so the other seven entries are untested text, and on three of them (S2, S3 and SHR) the rule as written would also reject the Fail that Tenzir's mapping emits.
  • The frozen gold carries two of its author's misses: its service rule scores the June gold itself, run as a mapper, at 81.09% where 80% was expected, and it accepts only a top-level duration, which is how Tenzir's current release, following the OCSF 1.9.0 text, comes to score 93.24% on fields.

An alternates gold is only as complete as its author's foresight, and freezing it means reporting that kind of miss at full strength until the next version of the gold. The same adjudication problem, a mapping that is schema-valid but not the one the key expected, turned up in my mapping bench as well, where a mapper that could only emit real OCSF paths still put many fields on a valid path the gold didn't pick, which the companion piece on the harness and the model covers.

A spec that pinned how a source's states map onto the activity enum would make both a tool and a gold answerable to the same text. The Network Activity class in the 1.8.0 export describes what each activity means, Fail as "a connection timeout or no route to host" for instance, without saying how Zeek's connection states, or any other source's, map onto it (Tier A), so that rule lives in each vendor's mapping and each tester's gold, and I'd like to see it move upstream, though that is my opinion and I haven't checked whether the maintainers have discussed it. For a buyer running their own bake-off, the re-score suggests a short list:

  • Score class and activity against a written rule per source state, frozen before you look at any tool's output, and not against a single gold row.
  • Give each field a primary path plus the alternates OCSF's own text supports, and write down the reason for every rejection, including the rejections of your own first choices.
  • Check value types against the OCSF type dictionary separately from paths, and run that check on the output as your consumer will receive it, with whatever cast step the vendor documents included, because a path check passes Tenzir's default string time on every record while a strict type check on the uncast output fails all 100,000.
  • Validate paths against the full schema export with profiles applied, since the hand-transcribed 1.8.0 subset the June scorer used carries no attribute types, which is why an integer field holding a string of letters went unflagged (bench erratum, point 3), and since a validator that ignores profiles reported 20 false defects on the re-score's six-source corpus.
  • Publish the gold's own misses next to the tool's, because the next reader's bake-off will inherit your choices along with your numbers.

Currency

The 1.9.0 question

OCSF 1.9.0 shipped on 2026-08-03 with no breaking changes listed in its changelog and with deprecations as the compatibility surface (OCSF changelog, read 2026-11-16, Tier A), so the question for a pipeline tool is whether its mappings followed. The same re-score ran Tenzir's current release as of 2026-11-15, v6.22.0 with library HEAD 9949f753, on the same Zeek corpus; the library's README at that commit says its packages need Tenzir 7, which was still a release candidate, so this is a pairing that loads and maps, not one Tenzir documents. It emits OCSF 1.9.0 on every record and derives activity from conn_state with the same values as 6.0.0, so activity stays at 83.30% under the same caveats. The field figure needs reading against a schema change: OCSF 1.9.0 rewrote Network Activity's duration to say it should only be populated for aggregate events (count greater than 1), where 1.8.0 described it as the time the event covers, and Tenzir's current mapping is consistent with the new text, leaving the top-level duration off single-connection records and carrying the span as traffic.start_time and traffic.end_time, which reproduce the source duration within a millisecond on every record (a post-hoc check). The re-score's gold was written against the 1.8.0 text and accepts only the top-level field, so it records 93.24% on fields, and I'd read that as the gold being a version behind, not as lost fidelity; every leaf path either version emits is valid and not deprecated in its declared OCSF version. On the other sources, the current library has no CloudTrail mapping, and nothing for a generic auth shape; it does ship Okta System Log and sshd mappings to Authentication 3002, but neither matches the bench's synthetic auth fields, which leaves the availability picture where June left it apart from the Sysmon shaping question above. The six-source mapping corpus and the identity-class cost of the 1.9.0 move are in the companion piece on version drift, which uses the same re-score.

Bottom line

What I'd ask a vendor selling "OCSF-native"

These come from the availability results and the re-score together:

  • Which of my sources have a shipped mapping, by name and version, and does each one consume the shape my shipper emits (JSON Sysmon versus EVTX/XML is the case I hit)?
  • Which OCSF version does each mapping emit, which of your releases supports it, and what is the upgrade path when OCSF releases?
  • How is activity_id derived for each source, and is the rule written down where I can check it?
  • What lands in unmapped, and can I see a sample before I buy?
  • Does the emitted JSON honor OCSF's types (epoch-millisecond time, integer enums) by default, and if not, which documented step turns that on?

Bottom line: "OCSF-native" is first a claim about which sources have a mapping, and on the bench corpus that list ran from one source in four to none, depending on the tool. Where a mapping did exist, Tenzir's Zeek conn mapping comes out close to faithful once the scorer accepts documented alternates, under a gold that was written knowing what Tenzir emitted, and what the re-score left against the mapping itself is a defensible disagreement over one of the six connection states the corpus exercises, with the string time belonging to a pipeline setting the bench didn't use. The June numbers that said otherwise were measuring my answer key, which is the part I'd want anyone building an OCSF bake-off to take from this before they trust their own gold.