GenEvent for Event Handling
Learn to use GenEvent for creating decoupled event handling systems, allowing publishers and subscribers to interact asynchronously.
GenEvent for Event Handling is a free Erlang OTP: Distributed & Fault-Tolerant Systems Programming lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Erlang OTP: Distributed & Fault-Tolerant Systems Programming learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Why Event Handling?
Imagine you have many parts of your application that need to react to something happening, like a user logging in.
If each part directly calls every other part, your code becomes tightly coupled and hard to change. This is where event handling comes in!
Introducing GenEvent
Erlang's OTP (Open Telecom Platform) provides a powerful behavior called gen_event for building decoupled event handling systems.
- It implements the publisher-subscriber pattern.
- Publishers send events without knowing who will receive them.
- Subscribers (called handlers) register to receive specific events.
- This promotes loose coupling and makes systems more flexible.
The Event Manager
At the heart of gen_event is an event manager. This is a special Erlang process that acts as a central hub:
- It receives events from publishers.
- It dispatches these events to all registered handlers.
You start an event manager just like other OTP behaviors:
-module(event_manager_starter).
-export([start/0]).
start() ->
% Start a local event manager named 'my_app_events'
{ok, Pid} = gen_event:start_link({local, my_app_events}),
io:format("Event manager started with PID: ~p~n", [Pid]),
ok.Event Handlers: The Listeners
An event handler is an Erlang module that implements the gen_event behavior. It defines callback functions that the event manager will call when an event occurs.
Think of handlers as specialized listeners, each interested in certain types of events or performing a specific action when an event is received.
Creating a Simple Handler
Here's the basic structure for an event handler module. The key callback is handle_event/2, where you process the incoming event.
-module(my_event_handler).
-behaviour(gen_event).
-export([init/1, handle_event/2, terminate/2]).
init(Args) ->
io:format("Handler initialized with args: ~p~n", [Args]),
{ok, []}. % Returns initial state
handle_event(Event, State) ->
io:format("Handler received event: ~p~n", [Event]),
% Here you'd process the event
{ok, State}. % Return new state
terminate(_Args, _State) ->
io:format("Handler terminating.~n", []),
ok.Adding Handlers to the Manager
After starting your event manager and defining your handler, you need to tell the manager about your handler. This is done using gen_event:add_handler/3.
You can add multiple handlers to the same manager, and each will receive the events.
-module(handler_adder).
-export([add_to_manager/1]).
add_to_manager(ManagerName) ->
% The handler module name (my_event_handler)
% and any initial arguments for its init/1 function ([] in this case)
gen_event:add_handler(ManagerName, my_event_handler, []),
io:format("Handler 'my_event_handler' added to '~p'.~n", [ManagerName]),
ok.Notifying the Manager (Publishing Events)
Once handlers are registered, any part of your application can send an event to the manager using gen_event:notify/2. The manager will then forward this event to all active handlers.
The publisher doesn't know (or care) how many handlers there are, or what they do. This is the power of decoupling!
-module(event_publisher).
-export([send_alert/2]).
send_alert(ManagerName, Message) ->
Event = {alert, Message, os:timestamp()},
io:format("Publisher sending event: ~p to manager '~p'.~n", [Event, ManagerName]),
gen_event:notify(ManagerName, Event).Full GenEvent Demo
Let's put it all together! This runnable example starts a manager, adds a simple handler, and then sends a few events. Watch the handler react!
-module(gen_event_demo).
-export([start/0]).
% --- Inline Handler Module for Demo ---
% In a real app, this would be a separate .erl file.
my_demo_handler() ->
% Compile and load a temporary handler module
code:delete(demo_handler_impl),
code:purge(demo_handler_impl),
{ok, _} = compile:forms([
'-module(demo_handler_impl).',
'-behaviour(gen_event).',
'-export([init/1, handle_event/2, terminate/2]).',
'init(Args) -> {ok, Args}.',
'handle_event(Event, State) ->',
' io:format("*** Handler received: ~p~n", [Event]),',
' {ok, State}.',
'terminate(_Args, _State) -> ok.'
], []),
demo_handler_impl.
% --- Main Application Logic ---
start() ->
ManagerName = my_system_events,
HandlerModule = my_demo_handler(),
io:format("--- Starting GenEvent Demo ---~n"),
% 1. Start the event manager
{ok, _ManagerPid} = gen_event:start_link({local, ManagerName}),
io:format("Manager '~p' started.~n", [ManagerName]),
% 2. Add the handler to the manager
gen_event:add_handler(ManagerName, HandlerModule, []),
io:format("Handler '~p' added.~n", [HandlerModule]),
% 3. Publish some events
io:format("Sending first event...~n"),
gen_event:notify(ManagerName, {user_logged_in, "Alice"}),
timer:sleep(100), % Give time for event processing
io:format("Sending second event...~n"),
gen_event:notify(ManagerName, {sensor_reading, 25.5}),
timer:sleep(100),
io:format("Sending third event...~n"),
gen_event:notify(ManagerName, {error_alert, "Disk_full"}),
timer:sleep(100),
% 4. Stop the manager (optional, for clean exit)
gen_event:stop(ManagerName),
io:format("--- GenEvent Demo Finished ---~n"),
ok.Advanced GenEvent Usage
gen_event is quite flexible:
- Handler State: Handlers can maintain their own internal state, updated with each event.
- Multiple Handlers: A single event manager can have many handlers, each processing events independently.
- Removing Handlers: Handlers can be dynamically removed using
gen_event:delete_handler/3. - Synchronous Calls: While primarily asynchronous,
gen_event:call/2allows synchronous calls to handlers (though less common for pure eventing).
GenEvent Quick Check
You've learned about GenEvent's core components and how they interact. Let's test your understanding!
Recap: GenEvent Essentials
Great job! You've learned how gen_event helps build flexible, decoupled systems:
- Event Manager: The central hub that dispatches events.
- Event Handlers: Modules that subscribe to and process events.
- Publishers: Send events to the manager using
gen_event:notify/2. - Decoupling: Key benefit, allowing parts of your system to evolve independently.
Next, you'll explore even more advanced OTP behaviors!
Frequently asked questions
Is the “GenEvent for Event Handling” lesson free?
Yes — the full text of “GenEvent for Event Handling” is free to read here on the web, and the Erlang OTP: Distributed & Fault-Tolerant Systems Programming course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Erlang OTP: Distributed & Fault-Tolerant Systems Programming course, upgrade to CoddyKit PRO.
What will I learn in “GenEvent for Event Handling”?
Learn to use GenEvent for creating decoupled event handling systems, allowing publishers and subscribers to interact asynchronously. You practise Erlang OTP: Distributed & Fault-Tolerant Systems Programming with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Erlang OTP: Distributed & Fault-Tolerant Systems Programming?
No prior experience is required. Erlang OTP: Distributed & Fault-Tolerant Systems Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “GenEvent for Event Handling” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Erlang OTP: Distributed & Fault-Tolerant Systems Programming lesson?
Yes. Every Erlang OTP: Distributed & Fault-Tolerant Systems Programming lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- GenStatem for State Management
- GenEvent for Event Handling
- Custom OTP Behaviors
- Hot Code Swapping & Live Upgrades