WebMelody project Homepage
WebMelody presents a novel technique to
monitor Web servers' behavior by sonification. Events are mapped to
sound tracks by configuring an Apache module. When events occur,
they are sent by the server to the Collector and then
sent for musical reproduction to the WebPlayer.
||Antonio De Santis
|Umberto Ferraro Petrillo
A brief description:
WebMelody system uses a three-level distributed architecture and
consists of the following components:
- mod_musical_log a module that analyzes the WWW server activity
by parsing HTTP requests/responses. Interesting events (as
configured by the Webmaster) are annotated and, then, proper playing
requests are sent to the Collector module. The module
mod_musical_log has been coded as a third-party Apache module.
- Collector, a Java application in charge of receiving playing
requests from the mod_musical_log, interpret them and then forward
them to one (or more) Web Players.
- WebPlayer, a Java based audio player that connects to a
(remote) Collector and plays audio tracks according to received
Documentation, papers and samples:
- At WWW 9 in Amsterdam (May 2000):
the short paper and
poster presentation (slides).
- Technical Documentation:
- an MP3 file of a brief sample log file. The style is rather abstract and
should avoid fatigue in the listener (i.e. since it does not appeal to
rythm and known musical patterns, it can be listened for a
long time without disturbing).
The events are mapped to GrandPiano
(critical errors, such as 500 HTTP errors and similar), Woodblock
(access by User-Agent Netscape), MusicBox (access by User-Agent MS
Internet Explorer), Trumpet (access to a directory).
Any suitable MP3
player like Windows Media Player (http://www.microsoft.com/windowsmedia),
WinAmp (http://www.winamp.com) for
Window-based machine or XAudio (http://www.xaudio.com) for several
Unix systems will play the MP3 file.
- The second sample is a more Jazz-like
example in the style of a Swing jam-session. Here load is mapped to
the rythm (drums and bass), while different events are mapped to Piano
and Organ, with the errors played by Timpani.
To start WebMelody, the three components must be run in this order:
Actually our prototype can support only one Apache server connection.
When you start/restart the Apache server the Collector must be running
otherwise no communication Collector-Apache can be made. So each time
you want to re-start Apache, you must stop the Collector, restart it
and restart the server and Collector will start to collect information
about this new server. After Collector-Apache server connection, you
can start WebPlayers when you want. Only authorized WebPlayers will
connect successfully to the Collector.
- Apache Web server
Before you launch WebPlayer, be sure to include also directory . in the
CLASSPATH, and that current directory is where you untarred the file.
and then change the name of the server (actually the server for the
webPlayer is the Collector so include the hostname where the Collector
is running!) and then click on the icon on the right. Then select the
channel required, wait 30-60 seconds and enjoy it!.
In the download, we also include jazz.mid and cool.mid (beware! this
is large!) MIDI tracks that must be placed on a Web server to be read
by webPlayers. The location of the midi file used to play must be
included into the Apache httpd.conf configuration file.
Apache module mod_musical_log:
- To add mod_musical_log module to the server Apache (version 1.3.6
for Unix or later versions) you can statically compile it or install it into
its own DSO mod_musical_log.so.
- Adding a Static Module.
Adding mod_musical_log to Apache statically:
The next step is to edit the server configuration file httpd.conf.
This consists of setting up various directives introduced by mod_musical_log
to define server profiles to monitor.
For more informations how to do it, see Compiling
and installing from Apache documentation.
- Adding mod_musical_log to Apache dinamically.
To simplify creation of DSO files for Apache modules outside of the Apache
source tree you can use apxs(APache eXtenSion) tool. When installing
Apache the configure's make install procedure installs the Apache C header
files and puts the platform-dependent compiler and linker flags for building
DSO files into the apxs program. This way the user can use apxs to compile
his Apache module sources without the Apache distribution source tree
and without having to fiddle with the platform-dependent compiler and
linker flags for DSO support. Once you have Apache compiled with dynamic
module support, you can use the support tool,apxs (in the src/support
directory) for adding additional modules normally without having to reconfigure
or recompile Apache itself (for more informations see dso.html
). This tool builds the module for dynamic loading, installs it into
the live Apache directory and adds the required LoadModule line to the
Apache configuration files.
$ cd /path/to/3rdparty
$ apxs -c mod_musical_log.c
$ apxs -i -a -n musical_log mod_musical_log.so
If no new line is added to the Apache configuration file (httpd.conf)
after running of this script, manually add :
LoadModule musical_log_module /path/to/install/libexec/mod_musical_log.so
These new lines must be last lines respectively in LoadModule directive
and AddModule directive lists in the configuration file. In this way mod_musical_log
will be the first module to be contacted during HTTP requests processing
loop in phases that it manages. This allows to obtain best valuation of
the server workload. The next step is to edit the configuration files
for the server. This consists of setting up various directives introduced
by mod_musical_log to define server profiles to monitor.
Now you can send a USR1 signal to Apache (typically with the apachectl
script) to get it to re-read the configuration and load in the new module
without affecting transfers in progress.
Collector is a module in charge of receiving information from the mod_musical_log
about HTTP events. Its goal is store the data to interpret them and then to
forward proper playing requests to Web Players that connected to it. The Collector
is a Java application containing a server to manage WebPlayers sonification
requests and a server to manage communications with Apache servers.
Multiple Apache servers could connect to the Collector and for each of
it multiple WebPlayers can contact the Collector. However actually only
a Web server can be sonified.
The Collector java application can be run using the Java Runtime Environment
(JRE) or the Java Development Kit (JDK) 1.3 virtual machines
both availables from http://java.sun.com .
The Collector is the first system component you must start up. Its default
port number is 7000 (to be contacted by Apache servers) but you can also
select another number specifing it on command line. To start the Collector
is made with:
java Collector [port]
It is preferible the Collector and server Apache be locate on the same
host to have best results (because of delays). Each time an Apache server
contacts the Collector a new port number is indicate on the screen. This
port number must be used by WebPlayers that want to sonify that HTTP server.
Actually port number is 4444. So WebPlayers can establish a connection with
the Collector after a Collector-Apache connection.
The Collector starts to collect Apache server information when receives
first HTTP request/response communication from the server.
When a new WebPlayer or Apache server connect/disconnect to Collector a
line is visualized on standard output.
For each Apache communication, information received by Collector are displayed
to help you to understand which bit strings are sent to WebPlayers. For
each Channel a batch of bit string are displayed according user-specified
The WebPlayer uses the Java Sound technology to is a Java application, to
be able to run . You need Java Runtime Environment 1.3 or the Java Developers
Kit 1.3 (available at http://www.javasoft.com/j2se/) and one
of the supported audio card installed on your computer. Untar the file distributed
in a directory, change the ClassPath so that it includes . (current directory)
The GUI of WebPlayer allows the user to perform the following tasks (in
Note that WebPlayer uses several internal buffers to store data sent from
a remote Collector. The bufferization of data allows to minimize problems
concerning the network degradation and allows a better audio playback. For
this reason, when switching to a new Channel the user must wait several seconds
before listening to the selected channel (typically the delay ranges from
30 to 60 seconds).
- select the location of a remote Collector from a list of pre-filled
standard addresses (where it says "server" it means Collector)
- connect to a remote Collector (by clicking on the icon on the right)
using the currently selected address for the Collector;
- switch among several sonification channels provided by the current
Collector (the first channel is the default).
For any info send an e-mail to: