Making a log4net appender conditionally choose between properties for a particular field

Question

I have a common logging project that uses log4net to record logging events. Since it's a common project, it's configured in a non-standard way: almost everything is set via C# code.

Now, I have an AdoNet appender configured in this manner, which includes logging the method that triggered the log event. It is created as part of logging initialization and it's defined as follows:

appender.AddParameter(new AdoNetAppenderParameter()
{
    ParameterName = "@Method",
    DbType = DbType.String,
    Size = 255,
    Layout = new RawLayoutConverter().ConvertFrom(new PatternLayout("%method")) as IRawLayout
});

Since I'm tying into the log4net %method property, this will automatically pull the method name that triggered the logging event and send it to the database in a parameter called @Method which will eventually be inserted into a database table that has a column called Method.

However, I'm adding some new functionality to globally handle exceptions and log them. When an exception bubbles up to the top of the call stack from anywhere, it will be passed to this new global method so it can be logged. I have access to the exception, so I can see the controller and method that caused this exception. I could easily add this as a log4net custom property (mapped to something like %property{ExceptionMethod}). My problem is overriding (or overwriting) log4net's %method property with my own custom property.

So, how can I have log4net conditionally choose between %method and %property{ExceptionMethod} when sending the data through the AdoNet appender to log this information under the Method column of my logging database table? Is this even feasible?

Answer 1

Without knowing exactly how you're confuguring and using log4net, it's hard to write code which will fit into your existing framework: this example though creates two appenders, one that uses %method and one that uses %property{ExceptionMethod}, and assigns them to different loggers:

public abstract class BaseAppender : AdoNetAppender
{
    protected BaseAppender()
    {
        // Add common parameters, set connection strings etc

        // e.g.
        this.AddParameter(new AdoNetAppenderParameter
        {
            ParameterName = "@log_level",
            DbType = DbType.String,
            Size = 50,
            Layout = new RawLayoutConverter().ConvertFrom(new PatternLayout("%level")) as IRawLayout
        });

        // Then ask each subclass to add the extra parameters
        this.AddExtraParameters();
    }

    protected abstract void AddExtraParameters();
}

public class RuntimeAppender : BaseAppender
{
    protected override void AddExtraParameters()
    {
        this.AddParameter(new AdoNetAppenderParameter
        {
            ParameterName = "@Method",
            DbType = DbType.String,
            Size = 255,
            Layout = new RawLayoutConverter().ConvertFrom(new PatternLayout("%method")) as IRawLayout
        });
    }
}

public class UnhandledExceptionAppender : BaseAppender
{
    protected override void AddExtraParameters()
    {
        this.AddParameter(new AdoNetAppenderParameter
        {
            ParameterName = "@Method",
            DbType = DbType.String,
            Size = 255,
            Layout =
                new RawLayoutConverter().ConvertFrom(new PatternLayout("%property{ExceptionMethod}")) as IRawLayout
        });
    }
}

public sealed class RuntimeLogger : Logger
{
    public RuntimeLogger(string name)
        : base(name)
    {
        this.Appenders.Add(new RuntimeAppender());
        this.Level = Level.Error; // etc
    }
}

public sealed class UnhandledExceptionLogger : Logger
{
    public UnhandledExceptionLogger(string name)
        : base(name)
    {
        this.Appenders.Add(new UnhandledExceptionAppender());
        this.Level = Level.Error; // etc
    }
}

Then, at runtime, you choose which to use:

public class ExceptionHandler
{
    public void HandleException(Exception ex)
    {
        string exceptionMethod = "set exception method here" ; 
        GlobalContext.Properties["ExceptionMethod"] = exceptionMethod;

        var logger = new UnhandledExceptionLogger("Logger Name Goes Here");
        logger.Log(Level.Error, "Message", ex);
    }
}

public class RuntimeLogging
{
    public void LogSomething(Exception ex)
    {
        var logger = new RuntimeLogger("Logger Name Goes Here");
        logger.Log(Level.Error, "Message", ex);
    }
}   

Answer 2

Depending on your needs, you might find it easier to implement your AdoNetAppender entirely in code.

There's at least one way to do that, found in my earlier answer here.