Mini Drop-in Replacement for log4net

using System;
using System.Collections;
using System.IO;
using System.Text;
using System.Threading;
using System.Globalization;
 
namespace MyLogger
{
    public interface ILog
    {
        void Debug(object msg, params object[] objs);
        void Error(object msg, params object[] objs);
        void Info(object msg, params object[] objs);
        void Warn(object msg, params object[] objs);
        void Fatal(object msg, params object[] objs);
    }
 
    public enum LogVerbosity
    {
        FATAL = 0,
        ERROR,
        WARNING,
        INFO,
        DEBUG
    }
 
    internal class FileLogger
    {
        public static readonly FileLogger Instance = new FileLogger();
 
        private FileLogger()
        {
            AppDomain.CurrentDomain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);
            AppDomain.CurrentDomain.DomainUnload += new EventHandler(CurrentDomain_ProcessExit);
 
            _worker = new Thread(new ThreadStart(Writer));
            _worker.IsBackground = true;
            _worker.Start();
        }
 
        private Thread _worker;
        private bool _working = true;
        private Queue _que = new Queue();
        private StreamWriter _output;
        private string _baseFilename;
        private string _filename;
        private int _sizeLimit = 0;
        private long _lastSize = 0;
        private DateTime _lastFileDate;
        private bool _showMethodName = false;
        private string _FilePath = "";
 
        private const string dateTimeFormat = "yyyy-MM-dd";
 
        private LogVerbosity _verbosity = LogVerbosity.DEBUG;
 
        public bool ShowMethodNames
        {
            get { return _showMethodName; }
        }
 
        public LogVerbosity Verbosity
        {
            get { return _verbosity; }
            set { _verbosity = value; }
        }
 
        public void Init(string filename, int sizelimitKB, bool showmethodnames, LogVerbosity verbosity)
        {
            _showMethodName = showmethodnames;
            _sizeLimit = sizelimitKB;
            _baseFilename = filename;
            _filename = buildFilename();
            _verbosity = verbosity;
            // handle folder names as well -> create dir etc.
            _FilePath = Path.GetDirectoryName(filename);
            if (_FilePath != "")
            {
                _FilePath = Directory.CreateDirectory(_FilePath).FullName;
                if (_FilePath.EndsWith("\\") == false)
                    _FilePath += "\\";
            }
            _output = new StreamWriter(_filename, true);
            FileInfo fi = new FileInfo(_filename);
            _lastSize = fi.Length;
            _lastFileDate = fi.LastWriteTime;
        }
 
        private string buildFilename()
        {
            return Path.Combine(Path.GetDirectoryName(_baseFilename), string.Format("{0}_{1}{2}", Path.GetFileNameWithoutExtension(_baseFilename), DateTime.Today.ToString(dateTimeFormat), Path.GetExtension(_baseFilename)));
        }
 
        private void shutdown()
        {
            _working = false;
            _worker.Abort();
        }
 
        void CurrentDomain_ProcessExit(object sender, EventArgs e)
        {
            shutdown();
        }
 
        private void Writer()
        {
            while (_working)
            {
                while (_que.Count > 0)
                {
                    object o = _que.Dequeue();
                    if (_output != null && o != null)
                    {
                        if (_sizeLimit > 0)
                        {
                            // implement size limited logs
                            // implement rolling logs
                            #region [  rolling size limit ]
                            _lastSize += ("" + o).Length;
                            if (_lastSize > _sizeLimit * 1000)
                            {
                                _output.Flush();
                                _output.Close();
                                int count = 1;
                                while (File.Exists(_FilePath + Path.GetFileNameWithoutExtension(_filename) + "." + count.ToString("0000")))
                                    count++;
 
                                File.Move(_filename,
                                    _FilePath +
                                    Path.GetFileNameWithoutExtension(_filename) +
                                    "." + count.ToString("0000"));
                                _output = new StreamWriter(_filename, true);
                                _lastSize = 0;
                            }
                            #endregion
                        }
 
                        string fileDate = _filename.Substring(_filename.LastIndexOf('_') + 1, dateTimeFormat.Length);
                        DateTime fileDateFromName = DateTime.ParseExact(fileDate, dateTimeFormat, CultureInfo.InvariantCulture);
 
                        if (DateTime.Now.Subtract(_lastFileDate).Days > 0 || DateTime.Now.Subtract(fileDateFromName).Days > 0)
                        {
                            // implement date logs
                            #region [  rolling dates  ]
                            _output.Flush();
                            _output.Close();
                            
                            _filename = buildFilename();
                            
                            _output = new StreamWriter(_filename, true);
                            _lastFileDate = DateTime.Now;
                            _lastSize = 0;
                            #endregion
                        }
 
                        _output.Write(o);
                    }
                }
                if (_output != null)
                    _output.Flush();
                Thread.Sleep(500);
            }
            _output.Flush();
            _output.Close();
        }
 
        private string FormatLog(string log, string type, string meth, string msg, object[] objs)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.AppendLine(
                "" + DateTime.Now.ToString("dd'/'MM'/'yyyy HH:mm:ss.fff") +
                "|" + log +
                "|" + Thread.CurrentThread.ManagedThreadId +
                "|" + type +
                "|" + meth +
                "| " + string.Format(msg, objs));
 
            return sb.ToString();
        }
 
        public void Log(string logtype, string type, string meth, string msg, params object[] objs)
        {
            _que.Enqueue(FormatLog(logtype, type, meth, msg, objs));
        }
    }
 

    internal class logger : ILog
    {
        public logger(Type type)
        {
            typename = type.Namespace + "." + type.Name;
        }
 
        private string typename = "";
 
        private void log(string logtype, string msg, params object[] objs)
        {
            string meth = "";
            if (FileLogger.Instance.ShowMethodNames)
            {
                System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(2);
                System.Diagnostics.StackFrame sf = st.GetFrame(0);
                meth = sf.GetMethod().Name;
            }
            FileLogger.Instance.Log(logtype, typename, meth, msg, objs);
        }
 
        #region ILog Members
 
        public void Debug(object msg, params object[] objs)
        {
            if(FileLogger.Instance.Verbosity >= LogVerbosity.DEBUG)
                log("DEBUG", "" + msg, objs);
        }
 
        public void Error(object msg, params object[] objs)
        {
            if (FileLogger.Instance.Verbosity >= LogVerbosity.ERROR)
                log("ERROR", "" + msg, objs);
        }
 
        public void Info(object msg, params object[] objs)
        {
            if (FileLogger.Instance.Verbosity >= LogVerbosity.INFO)
                log("INFO", "" + msg, objs);
        }
 
        public void Warn(object msg, params object[] objs)
        {
            if (FileLogger.Instance.Verbosity >= LogVerbosity.WARNING)
                log("WARN", "" + msg, objs);
        }
 
        public void Fatal(object msg, params object[] objs)
        {
            if (FileLogger.Instance.Verbosity >= LogVerbosity.FATAL)
                log("FATAL", "" + msg, objs);
        }
        #endregion
    }
 
    public static class LogManager
    {
        public static ILog GetLogger(Type obj)
        {
            return new logger(obj);
        }
 
        public static void Configure(string filename, int sizelimitKB, bool showmethodnames, LogVerbosity verbosity)
        {
            FileLogger.Instance.Init(filename, sizelimitKB, showmethodnames, verbosity);
        }
    }
 
}