Hi,
Here is a concrete example of how cool object logging can be. In the current
development version, Zinc HTTP Components announces a number of ZnLogEvent
objects while either ZnClient or ZnServer operates. One of those is
ZnServerTransactionEvent, which signals the completion of a single HTTP
transaction (request/response pair) by the server. By subscribing to this
specific event through Zinc's Announcer, we can simply count the number of
transactions. If we report and reset this counter every second, we get a
rudimentary live updating requests per second monitor, in about ten lines of
code in a workspace !
Here is the setup:
| transactionCount transactionsPerSecond |
transactionCount := 0.
transactionsPerSecond := 0 asValueHolder inspectWithLabel: 'HTTP req/s'.
ZnLogEvent announcer
when: ZnServerTransactionEvent
do: [ :each | transactionCount := transactionCount + 1 ]
for: #transactionCountDemo.
[ [
1 second asDelay wait.
transactionsPerSecond value: transactionCount.
transactionCount := 0 ] repeat ]
forkAt: Processor userBackgroundPriority
named: #transactionCountDemo.
Then we start the server:
ZnServer startDefaultOn: 8080.
In a terminal, we use ab (the Apache Benchmark tool) to generate some load on
the server (10K requests for 1K random data, using 4 concurrent threads):
$ ab -k -n 10240 -c 4 http://localhost:8080/random/1024
Here is a short 2 minute screencast showing this little demo in action (be sure
to select the HD version):
https://www.youtube.com/watch?v=gaUxPNq6_7c
It starts by showing how a AnnouncementSpy can be used to monitor the server
starting up and handling a single request - the logging from the client is
visible as well. The lines in the AnnouncementSpy are not just text, but full,
detailed objects. We inspect and explore the same transaction from both the
client and server perspective.
Next is the demo of the live updating requests per second monitor with the load
described above. You can see that both our counter and ab report approximately
the same number: about 800-900 req/s.
And finally, here is the cleanup code:
ZnLogEvent announcer unsubscribe: #transactionCountDemo.
ZnServer stopDefault.
Process allInstances select: [ :each | each name = #transactionCountDemo ]
thenDo: #terminate.
Note that by using other data elements in the ZnServerTransactionEvent we could
track bytes transferring in or out, rates of failure, slow requests and so.
There are lots of possibilities with object logging left to explore, as well as
lots to learn.
Sven
