diff --git a/example/event_manager_example.dart b/example/event_manager_example.dart
deleted file mode 100644
index 46d050b..0000000
--- a/example/event_manager_example.dart
+++ /dev/null
@@ -1,56 +0,0 @@
-import 'dart:async';
-
-import 'package:dart_mediator/mediator.dart';
-import 'package:test/test.dart';
-
-class Event implements DomainEvent {
-  final int data;
-  const Event(this.data);
-}
-
-class RequestEvent implements Query<String> {
-  final int data;
-  const RequestEvent(this.data);
-}
-
-class RequestEventHandler implements RequestHandler<String, RequestEvent> {
-  @override
-  FutureOr<String> handle(RequestEvent request) {
-    return request.data.toString();
-  }
-}
-
-class LoggingBehavior implements PipelineBehavior {
-  @override
-  FutureOr handle(request, RequestHandlerDelegate next) async {
-    try {
-      print('[$LoggingBehavior] [${request.runtimeType}] Before');
-      return await next();
-    } finally {
-      print('[$LoggingBehavior] [${request.runtimeType}] After');
-    }
-  }
-}
-
-Future<void> main() async {
-  final Mediator mediator = Mediator();
-
-  mediator.requests.pipeline.registerGeneric(LoggingBehavior());
-
-  mediator.requests.register(RequestEventHandler());
-
-  mediator.events
-      .on<Event>()
-      .map((event) => event.data)
-      .distinct()
-      .subscribeFunction((event) => prints('[$Event handler] received $event'));
-
-  final resp =
-      await mediator.requests.send<String, RequestEvent>(RequestEvent(123));
-
-  print('Got ${resp.runtimeType} -> $resp');
-
-  await mediator.events.dispatch(Event(123));
-
-  print('done');
-}
diff --git a/example/mediator_example.dart b/example/mediator_example.dart
new file mode 100644
index 0000000..0a07123
--- /dev/null
+++ b/example/mediator_example.dart
@@ -0,0 +1,152 @@
+import 'dart:async';
+
+import 'package:dart_mediator/mediator.dart';
+
+Future<void> main() async {
+  final mediator = Mediator(
+    eventObservers: [LoggingEventObserver()],
+  );
+
+  // Add a request logging behavior.
+  mediator.requests.pipeline.registerGeneric(LoggingBehavior());
+
+  // Register a request handlers.
+  mediator.requests.register(GetUserByIdQueryHandler());
+  mediator.requests.register(MyCommandHandler());
+
+  // Subscribe to the count event.
+  mediator.events
+      .on<CountEvent>()
+      .map((event) => event.count)
+      .distinct()
+      .subscribeFunction(
+        (count) => print('[$CountEvent handler] received count: $count'),
+      );
+
+  const getUserQuery = GetUserByIdQuery(123);
+
+  print('Sending $getUserQuery request');
+
+  final resp =
+      await mediator.requests.send<User, GetUserByIdQuery>(getUserQuery);
+
+  print('Got $GetUserByIdQuery response: $resp');
+
+  print('---');
+
+  const order66Command = MyCommand('Order 66');
+
+  print('Sending command $order66Command');
+
+  await mediator.requests.send<void, MyCommand>(order66Command);
+
+  print('Command $order66Command completed');
+
+  print('---');
+
+  const countEvent = CountEvent(123);
+
+  await mediator.events.dispatch(countEvent);
+
+  await mediator.events.dispatch(countEvent);
+
+  print('done');
+}
+
+class CountEvent implements DomainEvent {
+  final int count;
+  const CountEvent(this.count);
+
+  @override
+  String toString() => '$CountEvent(count: $count)';
+}
+
+class MyCommand implements Command {
+  final String command;
+  const MyCommand(this.command);
+
+  @override
+  String toString() => '$MyCommand(command: $command)';
+}
+
+class MyCommandHandler implements CommandHandler<MyCommand> {
+  @override
+  Future<void> handle(MyCommand request) async {
+    print('[$MyCommandHandler] Executing "$request"');
+    await Future.delayed(const Duration(milliseconds: 500));
+    print('[$MyCommandHandler] "$request" completed');
+  }
+}
+
+class GetUserByIdQuery implements Query<User> {
+  final int userId;
+  const GetUserByIdQuery(this.userId);
+
+  @override
+  String toString() => '$GetUserByIdQuery(userId: $userId)';
+}
+
+class GetUserByIdQueryHandler implements QueryHandler<User, GetUserByIdQuery> {
+  @override
+  Future<User> handle(GetUserByIdQuery request) async {
+    print('[$GetUserByIdQueryHandler] handeling $request');
+    final user = await getUserByIdAsync(request.userId);
+    print('[$GetUserByIdQueryHandler] got $user');
+    return user;
+  }
+}
+
+class LoggingBehavior implements PipelineBehavior {
+  @override
+  Future handle(request, RequestHandlerDelegate next) async {
+    try {
+      print('[$LoggingBehavior] [${request.runtimeType}] Before');
+      return await next();
+    } finally {
+      print('[$LoggingBehavior] [${request.runtimeType}] After');
+    }
+  }
+}
+
+class LoggingEventObserver implements EventObserver {
+  @override
+  void onDispatch<TEvent extends DomainEvent>(
+    TEvent event,
+    Set<EventHandler<TEvent>> handlers,
+  ) {
+    print(
+      '[$LoggingEventObserver] onDispatch "$event" with ${handlers.length} handlers',
+    );
+  }
+
+  @override
+  void onError<TEvent extends DomainEvent>(
+    TEvent event,
+    EventHandler<TEvent> handler,
+    Object error,
+    StackTrace stackTrace,
+  ) {
+    print('[$LoggingEventObserver] onError $event -> $handler ($error)');
+  }
+
+  @override
+  void onHandled<TEvent extends DomainEvent>(
+    TEvent event,
+    EventHandler<TEvent> handler,
+  ) {}
+}
+
+class User {
+  final int id;
+  final String name;
+
+  const User(this.id, this.name);
+
+  @override
+  String toString() => '$User(id: $id, name: $name)';
+}
+
+Future<User> getUserByIdAsync(int id) async {
+  await Future.delayed(const Duration(seconds: 1));
+  return User(id, 'John Doe');
+}