Log4netTraceListener simplified and adapted from Cavity (http://code.google.com/p/cavity/source/browse/trunk/src/ClassLibraries/Diagnostics.Log4Net/Diagnostics/Log4NetTraceListener.cs?spec=svn265&r=265)

Log4netTraceListener.cs

    public class Log4netTraceListener : TraceListener
    {
        public override void Write(object o)
        {
            base.Write(o);
        }

        public override void WriteLine(string message)
        {
            this.Write(message);
        }

        public override void Write(string message)
        {
            StackTrace st = new StackTrace();
            var stack = this.GetTracingStackFrame(st);
            var loggerName = stack.GetMethod().DeclaringType.FullName;
            this.Write(message, loggerName);
        }

        public override void WriteLine(string message, string category)
        {
            this.Write(message, category);
        }

        public override void Write(string message, string category)
        {
            var logger = LogManager.GetLogger(category ?? this.GetType().FullName);
            logger.Debug(message);
        }


        public override void Fail(string message)
        {
            this.Fail(message, string.Empty);
        }

        public override void Fail(string message, string detailMessage)
        {
            var stack = new StackTrace();
            var frame = this.GetTracingStackFrame(stack);
            var log = LogManager.GetLogger(frame.GetMethod().DeclaringType);

            message = string.IsNullOrEmpty(detailMessage)
                              ? message
                              : string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", message, Environment.NewLine, detailMessage);
            log.WarnFormat("[Fail] {0}", message);
        }

        public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId)
        {
            var array = new object[] { message, relatedActivityId };
            this.TraceEvent(eventCache, source, TraceEventType.Transfer, id, "{0}", array);
        }

        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
        {
            var array = new[] { data };
            this.TraceData(eventCache, source, eventType, id,array);
        }

        public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data)
        {
            if (null == data || 0 == data.Length)
            {
                base.TraceData(eventCache, source, eventType, id, data);
                return;
            }

            foreach (var datum in data.Where(x => !this.TraceException(eventType, source, x)))
            {
                var array = new[] { datum };
                TraceEvent(eventCache, source, eventType, id, "{0}", array);
            }
        }

        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
        {
            if (0 == args.Length)
            {
                base.TraceEvent(eventCache, source, eventType, id, format, args);
            }


            if (string.IsNullOrWhiteSpace(source))
            {
                var frame = GetTracingStackFrame(new StackTrace());
                source = frame.GetMethod().DeclaringType.FullName;

                if (source == null)
                    source = this.GetType().FullName;
            }

            var logger = LogManager.GetLogger(source);
            switch (eventType)
            {
                case TraceEventType.Critical:
                    logger.FatalFormat(format, args);
                    break;

                case TraceEventType.Error:
                    logger.ErrorFormat(format, args);
                    break;

                case TraceEventType.Information:
                    logger.InfoFormat(format, args);
                    break;

                case TraceEventType.Resume:
                case TraceEventType.Start:
                case TraceEventType.Stop:
                case TraceEventType.Suspend:
                case TraceEventType.Transfer:
                case TraceEventType.Verbose:
                    logger.DebugFormat(format, args);
                    break;

                case TraceEventType.Warning:
                    logger.WarnFormat(format, args);
                    break;
            }
        }

        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
        {
            var array = new[] { message };
            this.TraceEvent(eventCache, source, eventType, id, "{0}", array);
        }

        private bool TraceException(TraceEventType eventType, string source, object data)
        {
            if (TraceEventType.Critical != eventType && TraceEventType.Error != eventType)
                return false;

            var exception = data as Exception;
            if (null == exception)
                return false;

            if (string.IsNullOrWhiteSpace(source))
            {
                var frame = GetTracingStackFrame(new StackTrace());
                source = frame.GetMethod().DeclaringType.FullName;

                if (source == null)
                    source = this.GetType().FullName;
            }

            var logger = LogManager.GetLogger(source);
            switch (eventType)
            {
                case TraceEventType.Critical:
                    logger.Fatal(exception.Message, exception);
                    break;

                case TraceEventType.Error:
                    logger.Error(exception.Message, exception);
                    break;
            }

            return true;
        }


        private StackFrame GetTracingStackFrame(StackTrace stack)
        {
            for (var i = 0; i < stack.FrameCount; i++)
            {
                var frame = stack.GetFrame(i);
                var method = frame.GetMethod();
                if (null == method)
                {
                    continue;
                }

                if ("System.Diagnostics" == method.DeclaringType.Namespace)
                {
                    continue;
                }

                if ("System.Threading" == method.DeclaringType.Namespace)
                {
                    continue;
                }

                if (this.GetType() == method.DeclaringType)
                {
                    continue;
                }

                return stack.GetFrame(i);
            }

            return null;
        }
    }