Using structuremap with log4net wrapper

Question

I have the following interface:

public interface ILogger
{
    void Debug(string message, params object[] values);
    void Info(string message, params object[] values);
    void Warn(string message, params object[] values);
    void Error(string message, params object[] values);
    void Fatal(string message, params object[] values);
}

and the following implementation:

public class Log4netLogger : ILogger
{
    private ILog _log;

    public Log4netLogger(Type type)
    {
        _log = LogManager.GetLogger(type);
    }

    public void Debug(string message, params object[] values)
    {
        _log.DebugFormat(message, values);
    }

    // other logging methods here...

}

My idea was to use structuremap to instantiate the Log4netLogger class with using the Type of the class that did the logging. However, I can't for the life of me figure out how to pass the type of the calling class to structuremap so that it can be passed to the constructor of the logging implementation. Any advice on how to do that (or a better way) would be most appreciated.

Answer 1

If the type parameter is context-specific, I don't think this is going to work as shown. If you need to pass something context specific in the constructor, you are likely going to have to create a factory interface and implementation that returns an instance of the ILogger:

public interface ILoggerFactory
{
    ILogger Create(Type type);   
}

public class LoggerFactory : ILoggerFactory
{
    public ILogger Create(Type type)
    {
        return new Log4netLogger(type);
    }
}

It might be possible to bootstrap StructureMap to supply the instance you want based on the type, but that assumes a limited number of types that you know in advance.

Answer 2

I really need to get out of the habit of answering my own question, but for those who run across it, here's the answer.

return ObjectFactory.With(type).GetInstance<T>();

I actually have a wrapper to structuremap (to avoid exposing the structuremap dependency to my app) that looks like the following:

public static class ServiceManager
{
    public static T Get<T>()
    {
        return ObjectFactory.GetInstance<T>();
    }

    public static T Get<T>(Type type)
    {
        return ObjectFactory.With(type).GetInstance<T>();
    }
}

Any time in the code I need a logger, I call the following:

ServiceManager.Get<ILogger>(GetType()).Info("Logging page view...");

Answer 3

We use a similar ILogger wrapper around log4net and typically use constructor injection. We use an interceptor as a factory method responsible for creating the Logger. Here is our typical registry for logging setup.

public class CommonsRegistry : Registry
{
    public CommonsRegistry()
    {
        For<ILogger>()
            .AlwaysUnique()
            .TheDefault.Is.ConstructedBy(s =>
            {
                if (s.ParentType == null)
                    return new Log4NetLogger(s.BuildStack.Current.ConcreteType);

                return new Log4NetLogger(s.ParentType);
            });

        var applicationPath = Path.GetDirectoryName(Assembly.GetAssembly(GetType()).Location);
        var configFile = new FileInfo(Path.Combine(applicationPath, "log4net.config"));
        XmlConfigurator.ConfigureAndWatch(configFile);
    }
}

The parent type null check is necessary when there are dependencies on concrete types.

The rest is optional log4net setup stuff.

One thing I do like about this setup is the ability to use a null loggers for unit testing.

Answer 4

This is what i've done to get the correct type getting passed into Log4Net, without having to manually create each logger, in each class. Thank dependency injection :)

Note: IoC == StructureMap.

namespace Insert.Your.Funky.Called.Medina.Name.Ass.Space.Here
{
    public class ServicesRegistry : Registry
    {
        public ServicesRegistry()
        {
            // Because we're using Log4Net .. which requires some configuration information ... lets load that now.
            // This trick with AppDomain was stollen from NLog :)
            string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "log4net.config");
            if (!File.Exists(path))
            {
                throw new FileNotFoundException("The log4net.config file was not found -> ru-roh!!! Please make sure it exists. Maybe check the path? Current file we tried to load is: " + path);
            }

            log4net.Config.XmlConfigurator.Configure(new FileInfo(path));

            Scan(x =>
                {
                    x.TheCallingAssembly();
                }
            );

            // First, grab the current stackTrace.
            var stackTrace = new System.Diagnostics.StackTrace().GetFrames();

            // Now, inject a logging service whenever requested. Pass in the type
            // which is the calling method's class. The first slot (ie. [0]) is usually
            // the ctor of the logging service class. so we jump up one frame
            // and use the class type, of that method.
            For<ILoggingService>().Use<Log4NetLogging>()
                .Ctor<Type>("type").Is(stackTrace.Length >= 2 ? 
                    stackTrace[1].GetMethod().DeclaringType : 
                    stackTrace[0].GetMethod().DeclaringType);            

             // Add any other specific injection rules here.
        }
    }
}

namespace Insert.Another.Funky.Called.Medina.Name.Ass.Space.Here
{
    public class Log4NetLogging : ILoggingService
    {
        private static ILog Log4Net { get; set; }

        public Log4NetLogging(Type type)
        {
            Log4Net = log4net.LogManager.GetLogger(type);
        }

        // blah blah .. all the logging interfaces, coded against Log4Net.
    }
}