RE: [nant-dev] Logging and Events

[Scott B. <sc...@sp...>]

To pick up this aging thread ...

I was wondering why the built-in Trace classes aren't used in Nant for
this?  I recently finished a project where we implemented logging in our
application using Trace.Writeline (etc.) with a set of custom
TraceListeners.  Trace.WriteLine accepts an object in one of the
overloads, so we created a custom TraceMessage class that stored extra
information about the message being written (so individual Listener
types could filter messages, for example).  Our custom TraceListeners
inherit from a base class (that in turn inherits from TraceListener, of
course) that knows how to deal with TraceMessages, and creates
TraceMessages if the string overloads were used instead.

Is there a reason that sort of system wouldn't work in Nant, rather than
creating something entirely from scratch?  Advantages also include the
ability then to add listeners via the .config file, and a Listener model
that future developers may already be familiar with.

Thanks,
Scott Boston

-----Original Message-----
From: nan...@li...
[mailto:nan...@li...] On Behalf Of
WEC...@th...
Sent: Monday, July 22, 2002 5:26 PM
To: sk...@eo...
Cc: 'Nant-Developers (E-mail)';
nan...@li...
Subject: Re: [nant-dev] Logging and Events



Hi Scott,

Sorry that this got a little long, but as you will see I have been
thinking about this a lot lately :-)

I have been chewing on this since last week when I asked about what it
would take to get an xml log. After trading emails with the list, I took
a look at Ant for inspiration and found that Ant 1.5 has an event system
very similar to what you've described, except that they include another
event for messages.

The code that Gerry posted seems to point that way as well -- but I
haven't dug into yet.

As I mentioned recently, we are working on a port/rewrite of
CruiseControl for the .NET platform. While implementing a class to drive
NAnt, we realized that we couldn't get an XML report of the results back
to merge with the rest of our workflow execution report.

So I had been considering implementing something similar to what you
describe in order to get us past our roadblock, and hopefully help NAnt
mature its logging.

Here are my thoughts so far:

I agree with both of these statements:
Events and logs serve a different purpose.
Something like Log4Net would be very nice instead of writing one.

The way I see it though, these two items are not completely unrelated.
For example, if one were to want to produce an XML result of an
execution, it would be very effective to create the log by using events
at the beginning and end of each target/task to create elements for each
of them in the resultant XML.

In order to facilitate this sort of log building an XML logger would
need be no more than just another event handler. Implementing this or
other types of logging classes using Log4Net would then be an
implementation detail of an event handling class, and not known
throughout NAnt's code. Another advantage of this is that if someone
wanted a simpler logger (or to use some other logging tool) they could
simply implement the Logger interface, and they'd be off and running (In
Ant 1.5 Loggers appear to be an extension of listeners, but I haven't
looked at it in detail).

What NAnt has now is explicit logging, possibly to multiple loggers but
with no way for the loggers to know the context of what is being logged.

What we seem to want to go is toward explicit event notification with
Logging being a valid listener and the ability to easily specify
additional/different listeners.

This isn't too huge of a difference from where NAnt is now. The problem
I see, is getting from here to there. There are a couple of things that
make this a non-trivial exercise:

1)Currently the Logger is explicitly mentioned in every target and task.
2)The formatting of the message for the console is expressed at each Log
invocation. 3)There is no non-programmatic way of specifying additional
Logger/Listeners 4)Messages being raised as events would require large
changes

And a couple of things in our favor:
1)Logger is already abstracted
2)The code is already structured for multiple LoggerListeners

So, as I scoped this out last week, I came up with the following tasks
for preparing the code to support an XML event handler/Logger:

1) factor all log statements that use LogPrefix, pushing this behavior
down to the specific LoggerListener (in this case ConsoleLogger) This
can be done by adding an Element parameter in an overload to the Write
and WriteLine methods in Log and LoggerListener.

2) Implement events at build start, build end, target start, target end
by changing Project.Execute, Target.Execute and Task.Execute

3) Modify LoggerListeners to implement EventHandling methods

4) add a command line argument for specifying additional listeners (e.g.
-listener xml)

5) modify Log class to allow adding listeners to the _listeners
collection

6) register event handlers for each listener for each event

7) in ListenerLogger event handlers emit appropriate text on event.

8) remove log calls for targets (it will be provided via handler) and in
ConsoleLogger implement onTargetStart to emit TargetName:

I actually implemented step one for a few tasks, and verified that it
works.

Once completing all 8 steps, the code would work as it does now, but
adding XML Logging would be a simple matter of adding an XML
LoggerListener and a line to the command line args to support it.

From there it would be a matter of removing all the calls to Log and
replacing them with a message event to complete the migration to
event-based notifications. Once that is complete it should be easy to
add a Log4NetListener that used Log4Net to accomplish logging.

-- Or at least it would be like that according to what i have learned so
far, those next 7 steps might change my mind a bit.

I was tentatively planning on doing the rest of that refactoring
starting tomorrow (because we need to demo CruiseControl in a couple of
weeks). My very next step was to look at Gerry's code in more detail,
and then start on steps 2 & 3 above.

Best,
Bill



 

                      "Scott Hernandez"

                      <sk...@eo...>                       To:
"'Nant-Developers \(E-mail\)'" <nan...@li...>

                      Sent by:                                cc:

                      nan...@li...        Subject:
[nant-dev] Logging and Events

                      ceforge.net

 

 

                      07/22/2002 02:46 PM

 

 





I've been giving some thought to logging and an event system for nant. I
don't think these two systems should be the same. They serve two
different purposes and don't need to overlap.

In my mind logging should be done via a mature logger, and it would be
great if we didn't have to write it. I'd like to suggest that we use
Log4Net.

As for events, it seems like the following are probably going to be
important:

Build Start/End
Target Start/End
Task Start/End

It would also be nice for the event system to allow for interception and
cancel-ability.

Thoughts?






-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf _______________________________________________
Nant-developers mailing list Nan...@li...
https://lists.sourceforge.net/lists/listinfo/nant-developers