Ok. I am back working on this again.

From the previous comments, I am not sure my efforts are going in the right direction. However, I have a working implementation that uses the standard logging mechanism now, while addressing some of the previous concerns.

I did a quick performance test, and it is true that the default mechanism is quite a bit faster than the standard JULI logger. For this test, I just modified the source code to write each log message 1000 times. The first set of timings (in millis) is from the current AccessLogValve, and the second set is using JULI.

AccessLogValve Elapsed Time: 8 AccessLogValve Elapsed Time: 19 AccessLogValve Elapsed Time: 63 AccessLogValve Elapsed Time: 6 AccessLogValve Elapsed Time: 7 AccessLogValve Elapsed Time: 8

INFO: AccessLogValve Elapsed Time: 830 INFO: AccessLogValve Elapsed Time: 1122 INFO: AccessLogValve Elapsed Time: 451 INFO: AccessLogValve Elapsed Time: 531 INFO: AccessLogValve Elapsed Time: 764 INFO: AccessLogValve Elapsed Time: 347

Granted, this certainly falls into the "Contrived micro-benchmark" realm. A real test would involve lots of threads each writing very little. Also, each thread would be doing a lot of other things, making the time spent in the access logger less significant. However, even in the worse case, it still only took a millis to write one message.

Honing my test case to test the speed of 1 single message (not just the write, but the whole process of creating and then writing the message), I got that it takes between 0 - 1 millis in the first case, and 0 - 2 millis with JULI. Most messages took 1 millis for each. (I have a pretty old machine I am testing on now.) I didn't test the speed of the file rolling and such. Also, I have no idea which would perform better under a heavy load.

I don't really have the facilities to do a realistic performance test. However, I think something can be gleaned from the above results. Does anyone have any advice or suggestions on what direction I should go? My main goal is to have automatic deletion of old log files. This is something I would imagine others would like as well, so I thought I would present here instead of just doing something myself. I certainly do not what to make anything more complicated to use / configure than it has to be.

I am considering 5 options: 1) I can add my "outputLoggerName" attribute, which will switch the valve to use the JULI logger 2) I can create some sort of AccessLogWriter that the AccessLogValves will delegate their writing to - With 2 implementations, one being the current method and one being a JULI implementation - Potentially removing one in the future if performance is not an issue. 3) I can just add an attribute to the AccessLogValves to automatically delete older files 4) I can just make my own private subclass to do what I want, and leave the tomcat code unaltered 5) Scrap the current file writing implementation in the AccessLogValve and go straight JULI

I would welcome any advice.

Thanks, Mark