Explore and process multiple event types with Schema-aware Fabric Eventstreams (Preview)

Real-time streams rarely contain just one kind of event.

A building operations stream, for example, might carry thermostat readings, occupancy updates, air-quality measurements, and badge-reader activity through the same source. These events may share a payload format, but they don't describe the same thing. A temperature field matters to a thermostat event. An employee identifier belongs to an access event. An occupancy count describes something else entirely.

Traditionally, processing a mixed stream like this often meant treating it as one wide, sparse schema or reconstructing the meaning of each event downstream. Developers identify the event type, guard against fields that don't apply, and often repeat that logic wherever the stream branches.

With Schema-aware Fabric Eventstreams (Preview), Eventstreams can preserve and use the shape of an event while the data is still in motion.

You can explore individual event shapes, distinguish multiple event types within the same stream, and build processing logic against the event type you need. This works with events that reference registered schemas, events organized through classification, and untyped events whose structure is not yet defined. For developers working with mixed streams, this means building logic around each event type instead of repeatedly reconstructing its identity downstream.

The event’s identity and shape become part of the streaming workflow, not just something to interpret after the data lands.

Explore the events arriving in your stream

When several event types share a feed, looking at the union of every field only tells part of the story.

The schema-aware data preview feature organizes streaming data by event type, so you can focus on the shape you want to understand. For a thermostat event, you can inspect the fields describing temperature, humidity, location, and device state. Switch to an occupancy event, and the preview reflects fields for counts, zones, and observation time.

To understand an unfamiliar event before configuring processing logic, inspect its payload, headers, and metadata, expand nested JSON, and open its individual details. Export selected data when you need to examine representative events further.

More importantly, you can understand those differences while the stream is live, before building processing logic or waiting for the data to land somewhere else.

Figure: Schema-aware data preview groups events with registered schemas (schematized events), classified events, and untyped events.

Work with schemas at different levels of maturity

Not every event producer is at the same point in its schema journey.

Some applications publish against established, versioned contracts (schemas). Others already carry useful type information such as deviceType or eventType, but don’t have registered schemas. Still others produce events that are new, evolving, or not yet fully documented.

Schema-aware Eventstreams lets those different events coexist in the same Eventstream through registered, classified, and untyped events.

Schematized events: reuse established contracts

For producers with defined contracts, schema-aware Eventstreams (Preview) can use schemas managed through Event SchemaSet, which is generally available, and Fabric’s Schema Registry. Events that reference these registered schemas are called schematized events. They use the CloudEvents format, with the ce_type header identifying the registered event type so Eventstreams can use the corresponding schema for exploration and processing.

This gives producers and consumers an explicit, reusable definition of the event rather than deriving its meaning from whichever fields happen to appear in a sample.  See how registered schemas work in Eventstreams.

Classified events: find structure in existing streams

Many useful streams don't start with registered contracts.

A mixed JSON feed may already contain fields such as deviceType, eventType, or entityType that identify what each event represents. In the new Classifier workflow, select that field to organize the stream into distinct event types.

In our building example, deviceType can separate thermostat, occupancy, air-quality, and badge-reader events even though they continue through the same Eventstream. Classification doesn't turn those events into registered contracts. It makes their existing structure usable for exploration and processing.

Figure: The deviceType classifier separates a mixed stream into four event types with distinct detected fields.

Untyped events: keep the unknown visible

An event can still be inspected even when it has neither a registered schema nor a user-selected classifier. Untyped events keep that traffic visible without requiring you to define its structure first.

Events from sources that aren’t associated with an Event SchemaSet can remain untyped or be organized through classification. In classified streams, events with a missing or null classifier value remain untyped. Events from schema-associated sources that fail validation are dropped and reported in runtime logs, not routed as untyped.

This gives you room to inspect new or unmatched traffic and decide later whether it should be classified, registered, or continue as untyped.

Build against each event, not the entire stream

Seeing the different shapes is useful. Using those shapes while processing the stream is where schema awareness becomes especially powerful.

Supported operators and destinations can select a registered, classified, or untyped event as their input. The fields available for configuration then correspond to that event shape rather than every field observed across the source.

Suppose you want to identify high-temperature readings. That logic belongs to thermostat events. It shouldn't need to account for occupancy counts, badge identifiers, or air-quality attributes just because those events happen to travel through the same stream.

For example, select the thermostat event as the input to the Filter operator and use its temperature field to identify high-temperature readings. That branch can focus on thermostat data, while occupancy, air-quality, and badge-reader events continue through the same Eventstream and follow their own processing paths.

The same model extends to supported destinations such as Eventhouse, Lakehouse, custom endpoints, and derived streams. A destination can consume the selected event shape instead of treating a heterogeneous source as one undifferentiated feed.

Figure: The Input schema list makes individual shapes available to the Filter operator.

This shifts an important responsibility upstream. Instead of repeatedly reconstructing event type in downstream queries, applications, or transformations, the Eventstream itself can carry that processing context while the data is moving.

Start where your data is today

Adopting schemas doesn’t have to be the mandatory first step.

Different producers have different owners, technologies, release schedules, and contract maturity. Requiring every producer to register a schema before you can distinguish event shapes can delay the value you expect from stream processing.

Schema-aware Eventstreams lets you take a progressive approach:

• Register stable contracts that teams want to discover and reuse.
• Classify existing mixed feeds that already contain a meaningful type signal.
• Keep untyped traffic visible when its shape isn't known yet.
• Move toward registered contracts where stronger schema governance provides value.

One Eventstream can therefore work with several event types and levels of schema maturity without forcing every producer to change at the same time.

Start with the data you have today and introduce stronger contracts where they make sense.

Schema-aware Eventstreams brings the meaning of an event into the streaming workflow itself. Whether your events have established contracts, carry enough information to identify their shape, or are still evolving, you can start working with them as the events they represent, without first forcing everything into the same structural model. Create a new schema-aware Eventstream, send in a mixed feed, explore and classify the different event types, identify the valuable signals and build processing logic around it.

See schema-aware Eventstreams in action. Check out the demo video here and follow along to explore and process multiple event types in your own schema-aware Eventstream.

Resources

Schema-aware Eventstreams is available in Preview for newly created Eventstreams. Existing Eventstreams continue to operate unchanged.

• Schema-Aware Eventstreams overview
• Explore and classify mixed events in a schema-aware Eventstream
• Preview data in a schema-aware Eventstream
• Classify unschematized events
• Use registered schemas in Eventstreams
• Learn about Schema Registry

Have an idea for a capability or scenario these features don’t cover? Share it through Fabric Ideas or directly with us on the [email protected]. Your feedback helps shape what comes next.