diff --git a/.gitignore b/.gitignore
index 5b85ade..9d62ca3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,227 @@
-/_ReSharper.uhttpsharp/
-/*.6.0.ReSharper.user
-/*.suo
-/packages/*
-*/bin/*
-*/obj/*
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio) 
+*.userprefs 
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# Visual Studio 2015 cache/options directory
+*.vs/
+
+# Roslyn cache directories
+*.ide/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+*_i.c
+*_p.c
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.log
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+
+# Visual Studio profiler
 *.psess
 *.vsp
-*.nupkg
\ No newline at end of file
+*.vspx
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding addin-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+*.ncrunch*
+.*crunch*.local.xml
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+## TODO: Comment the next line if you want to checkin your
+## web deploy settings but do note that will include unencrypted
+## passwords
+*.pubxml
+*.publishproj
+
+# NuGet Packages Directory
+packages/*
+*.nupkg
+
+## TODO: If the tool you use requires repositories.config
+## uncomment the next line
+#!packages/repositories.config
+
+# Enable "build/" folder in the NuGet Packages folder since
+# NuGet packages use it for MSBuild targets.
+# This line needs to be after the ignore of the build folder
+# (and the packages folder if the line above has been uncommented)
+!packages/build/
+
+# PVC Build packages (https://github.com/pvcbuild/pvc)
+pvc-packages/*
+
+# Windows Azure Build Output
+csx
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Others
+sql/
+*.Cache
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.[Pp]ublish.xml
+*.pfx
+*.publishsettings
+node_modules/
+bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file to a newer
+# Visual Studio version. Backup files are not needed, because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+App_Data/*.mdf
+App_Data/*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# Node.js Tools for Visual Studio 
+.ntvs_analysis.dat 
+ 
+# Visual Studio 6 build log 
+*.plg 
+ 
+# Visual Studio 6 workspace options file 
+*.opt 
+
+# Paket Package Manager Main exe
+.paket/paket.exe
+
+# =========================
+# Windows detritus
+# =========================
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Mac crap
+.DS_Store
diff --git a/README.md b/README.md
index 369e655..e1655a8 100644
--- a/README.md
+++ b/README.md
@@ -2,29 +2,8 @@
 
 A very lightweight & simple embedded http server for c# 
 
-Master | Provider
------- | --------
-[![Build Status][TeamCityImgMaster]][TeamCityLinkMaster] | Windows CI Provided By [JetBrains][] and [CodeBetter][]
-[![Build status](https://ci.appveyor.com/api/projects/status/1schhjbpx7oomrx7)](https://ci.appveyor.com/project/shanielh/uHttpSharp) | Windows CI Provided By [AppVeyor][]
-[![Build Status][MonoImgMaster]][MonoLinkMaster] | Mono CI Provided by [travis-ci][] 
-
-[TeamCityImgMaster]:http://teamcity.codebetter.com/app/rest/builds/buildType:\(id:bt1191\)/statusIcon
-[TeamCityLinkMaster]:http://teamcity.codebetter.com/viewLog.html?buildTypeId=bt1191&buildId=lastFinished&guest=1
-
-[MonoImgMaster]:https://travis-ci.org/Code-Sharp/uHttpSharp.png?branch=master
-[MonoLinkMaster]:https://travis-ci.org/Code-Sharp/uHttpSharp
-
-[travis-ci]:https://travis-ci.org/
-[AppVeyor]:http://www.appveyor.com/
-[JetBrains]:http://www.jetbrains.com/
-[CodeBetter]:http://codebetter.com/
-
 ## Usage
 
-A [NuGet Package](https://www.nuget.org/packages/uHttpSharp/ "Go to µHttpSharp NuGet Package page")  is available, Install via NuGet Package Manager :
-
-	install-package uHttpSharp
-
 A sample for usage : 
 
 	using (var httpServer = new HttpServer(new HttpRequestProvider()))
diff --git a/uhttpsharp-demo/Handlers/TimingHandler.cs b/uhttpsharp-demo/Handlers/TimingHandler.cs
index 91ab79e..f37504e 100644
--- a/uhttpsharp-demo/Handlers/TimingHandler.cs
+++ b/uhttpsharp-demo/Handlers/TimingHandler.cs
@@ -2,14 +2,14 @@
 using System.Diagnostics;
 using System.Reflection;
 using System.Threading.Tasks;
-using log4net;
 using uhttpsharp;
+using uhttpsharp.Logging;
 
 namespace uhttpsharpdemo.Handlers
 {
     public class TimingHandler : IHttpRequestHandler
     {
-        private static readonly ILog Logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog Logger = LogProvider.GetCurrentClassLogger();
 
         public async Task Handle(IHttpContext context, Func<Task> next)
         {
diff --git a/uhttpsharp-demo/Program.cs b/uhttpsharp-demo/Program.cs
index 177737e..4d07921 100644
--- a/uhttpsharp-demo/Program.cs
+++ b/uhttpsharp-demo/Program.cs
@@ -37,8 +37,6 @@ internal static class Program
     {
         private static void Main()
         {
-            log4net.Config.XmlConfigurator.Configure();
-
             //var serverCertificate = X509Certificate.CreateFromCertFile(@"TempCert.cer");
 
             using (var httpServer = new HttpServer(new HttpRequestProvider()))
diff --git a/uhttpsharp-demo/packages.config b/uhttpsharp-demo/packages.config
index a8e7b37..747efc5 100644
--- a/uhttpsharp-demo/packages.config
+++ b/uhttpsharp-demo/packages.config
@@ -1,5 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="log4net" version="2.0.3" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="6.0.3" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/uhttpsharp-demo/uhttpsharp.Demo.csproj b/uhttpsharp-demo/uhttpsharp.Demo.csproj
index 7563180..62d1a20 100644
--- a/uhttpsharp-demo/uhttpsharp.Demo.csproj
+++ b/uhttpsharp-demo/uhttpsharp.Demo.csproj
@@ -39,12 +39,9 @@
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="log4net">
-      <HintPath>..\packages\log4net.2.0.3\lib\net40-full\log4net.dll</HintPath>
-    </Reference>
     <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\Newtonsoft.Json.6.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
diff --git a/uhttpsharp.Tests/HttpMethodProviderCacheTests.cs b/uhttpsharp.Tests/HttpMethodProviderCacheTests.cs
index 85a8f53..9f42c2d 100644
--- a/uhttpsharp.Tests/HttpMethodProviderCacheTests.cs
+++ b/uhttpsharp.Tests/HttpMethodProviderCacheTests.cs
@@ -1,9 +1,9 @@
-using Moq;
-using NUnit.Framework;
+using NSubstitute;
+using Shouldly;
+using Xunit;
 
 namespace uhttpsharp.Tests
 {
-    [TestFixture]
     public class HttpMethodProviderCacheTests
     {
         private const string MethodName = "Hello World";
@@ -13,44 +13,44 @@ private static IHttpMethodProvider GetTarget(IHttpMethodProvider child)
             return new HttpMethodProviderCache(child);
         }
 
-        [Test]
+        [Fact]
         public void Should_Call_Child_With_Right_Parameters()
         {
             // Arrange
-            var mock = new Mock<IHttpMethodProvider>();
-            var target = GetTarget(mock.Object);
+            var mock = Substitute.For<IHttpMethodProvider>();
+            var target = GetTarget(mock);
 
             // Act
             target.Provide(MethodName);
 
             // Assert
-            mock.Verify(m => m.Provide(MethodName), Times.Once);
+            mock.Received(1).Provide(MethodName);
         }
 
-        [Test]
+        [Fact]
         public void Should_Return_Same_Child_Value()
         {
             // Arrange
             const HttpMethods expectedMethod = HttpMethods.Post;
 
-            var mock = new Mock<IHttpMethodProvider>();
-            var target = GetTarget(mock.Object);
+            var mock = Substitute.For<IHttpMethodProvider>();
+            mock.Provide(MethodName).Returns(expectedMethod);
+            var target = GetTarget(mock);
 
-            mock.Setup(m => m.Provide(MethodName)).Returns(expectedMethod);
 
             // Act
             var actual = target.Provide(MethodName);
 
             // Assert
-            Assert.That(actual, Is.EqualTo(expectedMethod));
+            actual.ShouldBe(expectedMethod);
         }
 
-        [Test]
+        [Fact]
         public void Should_Cache_The_Value()
         {
             // Arrange
-            var mock = new Mock<IHttpMethodProvider>();
-            var target = GetTarget(mock.Object);
+            var mock = Substitute.For<IHttpMethodProvider>();
+            var target = GetTarget(mock);
 
             // Act
             target.Provide(MethodName);
@@ -58,7 +58,7 @@ public void Should_Cache_The_Value()
             target.Provide(MethodName);
 
             // Assert
-            mock.Verify(m => m.Provide(MethodName), Times.Once);
+            mock.Received(1).Provide(MethodName);
         }
 
     }
diff --git a/uhttpsharp.Tests/HttpMethodProviderTests.cs b/uhttpsharp.Tests/HttpMethodProviderTests.cs
index 4589c3a..be12a8d 100644
--- a/uhttpsharp.Tests/HttpMethodProviderTests.cs
+++ b/uhttpsharp.Tests/HttpMethodProviderTests.cs
@@ -1,10 +1,10 @@
 using System;
 using System.Collections.Generic;
-using NUnit.Framework;
+using Shouldly;
+using Xunit;
 
 namespace uhttpsharp.Tests
 {
-    [TestFixture]
     public class HttpMethodProviderTests
     {
 
@@ -14,25 +14,35 @@ private static IHttpMethodProvider GetTarget()
         }
 
 
-        private IEnumerable<string> Methods
+        public static IEnumerable<object> Methods
         {
             get
             {
                 return Enum.GetNames(typeof(HttpMethods));
             }
         }
-            
-        [TestCaseSource("Methods")]
-        public void Should_Get_Right_Method(string methodName)
+        
+        [Theory]
+        [InlineData(HttpMethods.Connect)]
+        [InlineData(HttpMethods.Delete)]
+        [InlineData(HttpMethods.Get)]
+        [InlineData(HttpMethods.Head)]
+        [InlineData(HttpMethods.Options)]
+        [InlineData(HttpMethods.Patch)]
+        [InlineData(HttpMethods.Post)]
+        [InlineData(HttpMethods.Put)]
+        [InlineData(HttpMethods.Trace)]
+        public void Should_Get_Right_Method(HttpMethods method)
         {
             // Arrange
+            var methodName = Enum.GetName(typeof(HttpMethods), method);
             var target = GetTarget();
 
             // Act
             var actual = target.Provide(methodName);
 
             // Assert
-            Assert.IsTrue(StringComparer.InvariantCultureIgnoreCase.Equals(actual.ToString(), methodName));
+            actual.ToString().ShouldBe(methodName);
         }
 
     }
diff --git a/uhttpsharp.Tests/packages.config b/uhttpsharp.Tests/packages.config
index c90677c..b31a20b 100644
--- a/uhttpsharp.Tests/packages.config
+++ b/uhttpsharp.Tests/packages.config
@@ -1,5 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Moq" version="4.2.1312.1622" targetFramework="net45" />
-  <package id="NUnit" version="2.6.3" targetFramework="net45" />
+  <package id="NSubstitute" version="1.8.1.0" targetFramework="net45" />
+  <package id="Shouldly" version="2.4.0" targetFramework="net45" />
+  <package id="xunit" version="2.0.0" targetFramework="net45" />
+  <package id="xunit.abstractions" version="2.0.0" targetFramework="net45" />
+  <package id="xunit.assert" version="2.0.0" targetFramework="net45" />
+  <package id="xunit.core" version="2.0.0" targetFramework="net45" />
+  <package id="xunit.extensibility.core" version="2.0.0" targetFramework="net45" />
+  <package id="xunit.runner.visualstudio" version="2.0.0" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/uhttpsharp.Tests/uhttpsharp.Tests.csproj b/uhttpsharp.Tests/uhttpsharp.Tests.csproj
index 331fb8e..0d11c68 100644
--- a/uhttpsharp.Tests/uhttpsharp.Tests.csproj
+++ b/uhttpsharp.Tests/uhttpsharp.Tests.csproj
@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" />
+  <Import Project="..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props" Condition="Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" />
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -13,6 +15,7 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <NuGetPackageImportStamp>84fe69d3</NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -32,11 +35,11 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Moq">
-      <HintPath>..\packages\Moq.4.2.1312.1622\lib\net40\Moq.dll</HintPath>
+    <Reference Include="NSubstitute">
+      <HintPath>..\packages\NSubstitute.1.8.1.0\lib\net45\NSubstitute.dll</HintPath>
     </Reference>
-    <Reference Include="nunit.framework">
-      <HintPath>..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
+    <Reference Include="Shouldly">
+      <HintPath>..\packages\Shouldly.2.4.0\lib\net40\Shouldly.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -45,6 +48,15 @@
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
+    <Reference Include="xunit.abstractions">
+      <HintPath>..\packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="xunit.assert">
+      <HintPath>..\packages\xunit.assert.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.assert.dll</HintPath>
+    </Reference>
+    <Reference Include="xunit.core">
+      <HintPath>..\packages\xunit.extensibility.core.2.0.0\lib\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="HttpMethodProviderCacheTests.cs" />
@@ -60,8 +72,18 @@
       <Name>uhttpsharp</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.0.0\build\portable-net45+win+wpa81+wp80+monotouch+monoandroid+Xamarin.iOS\xunit.core.props'))" />
+    <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.0.0\build\net20\xunit.runner.visualstudio.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/uhttpsharp.dll.nuspec b/uhttpsharp.dll.nuspec
index df95c7c..433069d 100644
--- a/uhttpsharp.dll.nuspec
+++ b/uhttpsharp.dll.nuspec
@@ -14,8 +14,7 @@
 		<copyright>Copyright 2014</copyright>
 		<tags>http server microframeworks</tags>
 		<dependencies>
-			<dependency id="Newtonsoft.Json" version="5.0.8" />
-			<dependency id="log4net" version="2.0.3" />
+			<dependency id="Newtonsoft.Json" version="6.0.8" />
 		</dependencies>
 	</metadata>
 	<files>
diff --git a/uhttpsharp/App_Packages/LibLog.3.1/LibLog.cs b/uhttpsharp/App_Packages/LibLog.3.1/LibLog.cs
new file mode 100644
index 0000000..1d711c7
--- /dev/null
+++ b/uhttpsharp/App_Packages/LibLog.3.1/LibLog.cs
@@ -0,0 +1,1941 @@
+//===============================================================================
+// LibLog
+//
+// https://github.com/damianh/LibLog
+//===============================================================================
+// Copyright © 2011-2015 Damian Hickey.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//===============================================================================
+
+// ReSharper disable PossibleNullReferenceException
+
+// Define LIBLOG_PORTABLE conditional compilation symbol for PCL compatibility
+
+#pragma warning disable 1591
+
+namespace uhttpsharp.Logging
+{
+    using System.Collections.Generic;
+    using uhttpsharp.Logging.LogProviders;
+    using System;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// Simple interface that represent a logger.
+    /// </summary>
+    public interface ILog
+    {
+        /// <summary>
+        /// Log a message the specified log level.
+        /// </summary>
+        /// <param name="logLevel">The log level.</param>
+        /// <param name="messageFunc">The message function.</param>
+        /// <param name="exception">An optional exception.</param>
+        /// <param name="formatParameters">Optional format parameters for the message generated by the messagefunc. </param>
+        /// <returns>true if the message was logged. Otherwise false.</returns>
+        /// <remarks>
+        /// Note to implementers: the message func should not be called if the loglevel is not enabled
+        /// so as not to incur performance penalties.
+        /// 
+        /// To check IsEnabled call Log with only LogLevel and check the return value, no event will be written.
+        /// </remarks>
+        bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, params object[] formatParameters );
+    }
+
+    /// <summary>
+    /// The log level.
+    /// </summary>
+    public enum LogLevel
+    {
+        Trace,
+        Debug,
+        Info,
+        Warn,
+        Error,
+        Fatal
+    }
+
+    public static class LogExtensions
+    {
+        public static bool IsDebugEnabled(this ILog logger)
+        {
+            GuardAgainstNullLogger(logger);
+            return logger.Log(LogLevel.Debug, null);
+        }
+
+        public static bool IsErrorEnabled(this ILog logger)
+        {
+            GuardAgainstNullLogger(logger);
+            return logger.Log(LogLevel.Error, null);
+        }
+
+        public static bool IsFatalEnabled(this ILog logger)
+        {
+            GuardAgainstNullLogger(logger);
+            return logger.Log(LogLevel.Fatal, null);
+        }
+
+        public static bool IsInfoEnabled(this ILog logger)
+        {
+            GuardAgainstNullLogger(logger);
+            return logger.Log(LogLevel.Info, null);
+        }
+
+        public static bool IsTraceEnabled(this ILog logger)
+        {
+            GuardAgainstNullLogger(logger);
+            return logger.Log(LogLevel.Trace, null);
+        }
+
+        public static bool IsWarnEnabled(this ILog logger)
+        {
+            GuardAgainstNullLogger(logger);
+            return logger.Log(LogLevel.Warn, null);
+        }
+
+        public static void Debug(this ILog logger, Func<string> messageFunc)
+        {
+            GuardAgainstNullLogger(logger);
+            logger.Log(LogLevel.Debug, messageFunc);
+        }
+
+        public static void Debug(this ILog logger, string message)
+        {
+            if (logger.IsDebugEnabled())
+            {
+                logger.Log(LogLevel.Debug, message.AsFunc());
+            }
+        }
+
+        public static void DebugFormat(this ILog logger, string message, params object[] args)
+        {
+            if (logger.IsDebugEnabled())
+            {
+                logger.LogFormat(LogLevel.Debug, message, args);
+            }
+        }
+
+        public static void DebugException(this ILog logger, string message, Exception exception)
+        {
+            if (logger.IsDebugEnabled())
+            {
+                logger.Log(LogLevel.Debug, message.AsFunc(), exception);
+            }
+        }
+
+
+        public static void DebugException(this ILog logger, string message, Exception exception, params object[] formatParams)
+        {
+            if (logger.IsDebugEnabled())
+            {
+                logger.Log(LogLevel.Debug, message.AsFunc(), exception, formatParams);
+            }
+        }
+
+        public static void Error(this ILog logger, Func<string> messageFunc)
+        {
+            logger.Log(LogLevel.Error, messageFunc);
+        }
+
+        public static void Error(this ILog logger, string message)
+        {
+            if (logger.IsErrorEnabled())
+            {
+                logger.Log(LogLevel.Error, message.AsFunc());
+            }
+        }
+
+        public static void ErrorFormat(this ILog logger, string message, params object[] args)
+        {
+            if (logger.IsErrorEnabled())
+            {
+                logger.LogFormat(LogLevel.Error, message, args);
+            }
+        }
+
+        public static void ErrorException(this ILog logger, string message, Exception exception, params object[] formatParams)
+        {
+            if (logger.IsErrorEnabled())
+            {
+                logger.Log(LogLevel.Error, message.AsFunc(), exception, formatParams);
+            }
+        }
+
+        public static void Fatal(this ILog logger, Func<string> messageFunc)
+        {
+            logger.Log(LogLevel.Fatal, messageFunc);
+        }
+
+        public static void Fatal(this ILog logger, string message)
+        {
+            if (logger.IsFatalEnabled())
+            {
+                logger.Log(LogLevel.Fatal, message.AsFunc());
+            }
+        }
+
+        public static void FatalFormat(this ILog logger, string message, params object[] args)
+        {
+            if (logger.IsFatalEnabled())
+            {
+                logger.LogFormat(LogLevel.Fatal, message, args);
+            }
+        }
+
+        public static void FatalException(this ILog logger, string message, Exception exception, params object[] formatParams)
+        {
+            if (logger.IsFatalEnabled())
+            {
+                logger.Log(LogLevel.Fatal, message.AsFunc(), exception, formatParams);
+            }
+        }
+
+        public static void Info(this ILog logger, Func<string> messageFunc)
+        {
+            GuardAgainstNullLogger(logger);
+            logger.Log(LogLevel.Info, messageFunc);
+        }
+
+        public static void Info(this ILog logger, string message)
+        {
+            if (logger.IsInfoEnabled())
+            {
+                logger.Log(LogLevel.Info, message.AsFunc());
+            }
+        }
+
+        public static void InfoFormat(this ILog logger, string message, params object[] args)
+        {
+            if (logger.IsInfoEnabled())
+            {
+                logger.LogFormat(LogLevel.Info, message, args);
+            }
+        }
+
+        public static void InfoException(this ILog logger, string message, Exception exception, params object[] formatParams)
+        {
+            if (logger.IsInfoEnabled())
+            {
+                logger.Log(LogLevel.Info, message.AsFunc(), exception, formatParams);
+            }
+        }
+
+        public static void Trace(this ILog logger, Func<string> messageFunc)
+        {
+            GuardAgainstNullLogger(logger);
+            logger.Log(LogLevel.Trace, messageFunc);
+        }
+
+        public static void Trace(this ILog logger, string message)
+        {
+            if (logger.IsTraceEnabled())
+            {
+                logger.Log(LogLevel.Trace, message.AsFunc());
+            }
+        }
+
+        public static void TraceFormat(this ILog logger, string message, params object[] args)
+        {
+            if (logger.IsTraceEnabled())
+            {
+                logger.LogFormat(LogLevel.Trace, message, args);
+            }
+        }
+
+        public static void TraceException(this ILog logger, string message, Exception exception, params object[] formatParams)
+        {
+            if (logger.IsTraceEnabled())
+            {
+                logger.Log(LogLevel.Trace, message.AsFunc(), exception, formatParams);
+            }
+        }
+
+        public static void Warn(this ILog logger, Func<string> messageFunc)
+        {
+            GuardAgainstNullLogger(logger);
+            logger.Log(LogLevel.Warn, messageFunc);
+        }
+
+        public static void Warn(this ILog logger, string message)
+        {
+            if (logger.IsWarnEnabled())
+            {
+                logger.Log(LogLevel.Warn, message.AsFunc());
+            }
+        }
+
+        public static void WarnFormat(this ILog logger, string message, params object[] args)
+        {
+            if (logger.IsWarnEnabled())
+            {
+                logger.LogFormat(LogLevel.Warn, message, args);
+            }
+        }
+
+        public static void WarnException(this ILog logger, string message, Exception exception, params object[] formatParams)
+        {
+            if (logger.IsWarnEnabled())
+            {
+                logger.Log(LogLevel.Warn, message.AsFunc(), exception, formatParams);
+            }
+        }
+
+        private static void GuardAgainstNullLogger(ILog logger)
+        {
+            if (logger == null)
+            {
+                throw new ArgumentNullException("logger");
+            }
+        }
+
+        private static void LogFormat(this ILog logger, LogLevel logLevel, string message, params object[] args)
+        {
+            logger.Log(logLevel, message.AsFunc(), null, args);
+        }
+
+        // Avoid the closure allocation, see https://gist.github.com/AArnott/d285feef75c18f6ecd2b
+        private static Func<T> AsFunc<T>(this T value) where T : class
+        {
+            return value.Return;
+        }
+
+        private static T Return<T>(this T value)
+        {
+            return value;
+        }
+    }
+
+    /// <summary>
+    /// Represents a way to get a <see cref="ILog"/>
+    /// </summary>
+    public interface ILogProvider
+    {
+        /// <summary>
+        /// Gets the specified named logger.
+        /// </summary>
+        /// <param name="name">Name of the logger.</param>
+        /// <returns>The logger reference.</returns>
+        ILog GetLogger(string name);
+
+        /// <summary>
+        /// Opens a nested diagnostics context. Not supported in EntLib logging.
+        /// </summary>
+        /// <param name="message">The message to add to the diagnostics context.</param>
+        /// <returns>A disposable that when disposed removes the message from the context.</returns>
+        IDisposable OpenNestedContext(string message);
+
+        /// <summary>
+        /// Opens a mapped diagnostics context. Not supported in EntLib logging.
+        /// </summary>
+        /// <param name="key">A key.</param>
+        /// <param name="value">A value.</param>
+        /// <returns>A disposable that when disposed removes the map from the context.</returns>
+        IDisposable OpenMappedContext(string key, string value);
+    }
+
+    /// <summary>
+    /// Provides a mechanism to create instances of <see cref="ILog" /> objects.
+    /// </summary>
+    public static class LogProvider
+    {
+        private static ILogProvider _currentLogProvider;
+        private const string NullLogProvider = "Current Log Provider is not set. Call SetCurrentLogProvider " +
+                                               "with a non-null value first.";
+
+        /// <summary>
+        /// Gets a logger for the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type whose name will be used for the logger.</typeparam>
+        /// <returns>An instance of <see cref="ILog"/></returns>
+        public static ILog For<T>()
+        {
+            return GetLogger(typeof(T));
+        }
+
+#if !LIBLOG_PORTABLE
+        /// <summary>
+        /// Gets a logger for the current class.
+        /// </summary>
+        /// <returns>An instance of <see cref="ILog"/></returns>
+        public static ILog GetCurrentClassLogger()
+        {
+            var stackFrame = new StackFrame(1, false);
+            return GetLogger(stackFrame.GetMethod().DeclaringType);
+        }
+#endif
+
+        /// <summary>
+        /// Gets a logger for the specified type.
+        /// </summary>
+        /// <param name="type">The type whose name will be used for the logger.</param>
+        /// <returns>An instance of <see cref="ILog"/></returns>
+        public static ILog GetLogger(Type type)
+        {
+            return GetLogger(type.FullName);
+        }
+
+        /// <summary>
+        /// Gets a logger with the specified name.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <returns>An instance of <see cref="ILog"/></returns>
+        public static ILog GetLogger(string name)
+        {
+            ILogProvider logProvider = _currentLogProvider ?? ResolveLogProvider();
+            return logProvider == null ? new NoOpLogger() : (ILog)new LoggerExecutionWrapper(logProvider.GetLogger(name));
+        }
+
+        /// <summary>
+        /// Sets the current log provider.
+        /// </summary>
+        /// <param name="logProvider">The log provider.</param>
+        public static void SetCurrentLogProvider(ILogProvider logProvider)
+        {
+            _currentLogProvider = logProvider;
+        }
+
+        public static IDisposable OpenNestedConext(string message)
+        {
+            if(_currentLogProvider == null)
+            {
+                throw new InvalidOperationException(NullLogProvider);
+            }
+            return _currentLogProvider.OpenNestedContext(message);
+        }
+
+        public static IDisposable OpenMappedContext(string key, string value)
+        {
+            if (_currentLogProvider == null)
+            {
+                throw new InvalidOperationException(NullLogProvider);
+            }
+            return _currentLogProvider.OpenMappedContext(key, value);
+        }
+
+        public delegate bool IsLoggerAvailable();
+
+        public delegate ILogProvider CreateLogProvider();
+
+        public static readonly List<Tuple<IsLoggerAvailable, CreateLogProvider>> LogProviderResolvers =
+            new List<Tuple<IsLoggerAvailable, CreateLogProvider>>
+        {
+            new Tuple<IsLoggerAvailable, CreateLogProvider>(SerilogLogProvider.IsLoggerAvailable, () => new SerilogLogProvider()),
+            new Tuple<IsLoggerAvailable, CreateLogProvider>(NLogLogProvider.IsLoggerAvailable, () => new NLogLogProvider()),
+            new Tuple<IsLoggerAvailable, CreateLogProvider>(Log4NetLogProvider.IsLoggerAvailable, () => new Log4NetLogProvider()),
+            new Tuple<IsLoggerAvailable, CreateLogProvider>(EntLibLogProvider.IsLoggerAvailable, () => new EntLibLogProvider()),
+            new Tuple<IsLoggerAvailable, CreateLogProvider>(LoupeLogProvider.IsLoggerAvailable, () => new LoupeLogProvider()),
+            new Tuple<IsLoggerAvailable, CreateLogProvider>(ColouredConsoleLogProvider.IsLoggerAvailable, () => new ColouredConsoleLogProvider()),
+        };
+
+        private static ILogProvider ResolveLogProvider()
+        {
+            try
+            {
+                foreach (var providerResolver in LogProviderResolvers)
+                {
+                    if (providerResolver.Item1())
+                    {
+                        return providerResolver.Item2();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+#if LIBLOG_PORTABLE
+                Debug.WriteLine(
+#else
+                Console.WriteLine(
+#endif
+                    "Exception occured resolving a log provider. Logging for this assembly {0} is disabled. {1}",
+                    typeof(LogProvider).GetAssemblyPortable().FullName,
+                    ex);
+            }
+            return null;
+        }
+
+        internal class NoOpLogger : ILog
+        {
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
+            {
+                return false;
+            }
+        }
+    }
+
+    internal class LoggerExecutionWrapper : ILog
+    {
+        private readonly ILog _logger;
+        internal const string FailedToGenerateLogMessage = "Failed to generate log message";
+
+        internal LoggerExecutionWrapper(ILog logger)
+        {
+            _logger = logger;
+        }
+
+        public ILog WrappedLogger
+        {
+            get { return _logger; }
+        }
+
+        public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null, params object[] formatParameters)
+        {
+            if (messageFunc == null)
+            {
+                return _logger.Log(logLevel, null);
+            }
+
+            Func<string> wrappedMessageFunc = () =>
+            {
+                try
+                {
+                    return messageFunc();
+                }
+                catch (Exception ex)
+                {
+                    Log(LogLevel.Error, () => FailedToGenerateLogMessage, ex);
+                }
+                return null;
+            };
+            return _logger.Log(logLevel, wrappedMessageFunc, exception, formatParameters);
+        }
+    }
+}
+
+namespace uhttpsharp.Logging.LogProviders
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq.Expressions;
+    using System.Reflection;
+    using System.Text;
+    using System.Text.RegularExpressions;
+
+    internal abstract class LogProviderBase : ILogProvider
+    {
+        protected delegate IDisposable OpenNdc(string message);
+        protected delegate IDisposable OpenMdc(string key, string value);
+
+        private readonly Lazy<OpenNdc> _lazyOpenNdcMethod;
+        private readonly Lazy<OpenMdc> _lazyOpenMdcMethod;
+        private static readonly IDisposable NoopDisposableInstance = new DisposableAction();
+
+        protected LogProviderBase()
+        {
+            _lazyOpenNdcMethod 
+                = new Lazy<OpenNdc>(GetOpenNdcMethod);
+            _lazyOpenMdcMethod
+               = new Lazy<OpenMdc>(GetOpenMdcMethod);
+        }
+
+        public abstract ILog GetLogger(string name);
+        
+        public IDisposable OpenNestedContext(string message)
+        {
+            return _lazyOpenNdcMethod.Value(message);
+        }
+
+        public IDisposable OpenMappedContext(string key, string value)
+        {
+            return _lazyOpenMdcMethod.Value(key, value);
+        }
+
+        protected virtual OpenNdc GetOpenNdcMethod()
+        {
+            return _ => NoopDisposableInstance;
+        }
+
+        protected virtual OpenMdc GetOpenMdcMethod()
+        {
+            return (_, __) => NoopDisposableInstance;
+        }
+    }
+
+    internal class NLogLogProvider : LogProviderBase
+    {
+        private readonly Func<string, object> _getLoggerByNameDelegate;
+        private static bool _providerIsAvailableOverride = true;
+
+        public NLogLogProvider()
+        {
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("NLog.LogManager not found");
+            }
+            _getLoggerByNameDelegate = GetGetLoggerMethodCall();
+        }
+
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        public override ILog GetLogger(string name)
+        {
+            return new NLogLogger(_getLoggerByNameDelegate(name));
+        }
+
+        public static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride && GetLogManagerType() != null;
+        }
+
+        protected override OpenNdc GetOpenNdcMethod()
+        {
+            Type ndcContextType = Type.GetType("NLog.NestedDiagnosticsContext, NLog");
+            MethodInfo pushMethod = ndcContextType.GetMethodPortable("Push", new[] { typeof(string) });
+            ParameterExpression messageParam = Expression.Parameter(typeof(string), "message");
+            MethodCallExpression pushMethodCall = Expression.Call(null, pushMethod, messageParam);
+            return Expression.Lambda<OpenNdc>(pushMethodCall, messageParam).Compile();
+        }
+
+        protected override OpenMdc GetOpenMdcMethod()
+        {
+            Type mdcContextType = Type.GetType("NLog.MappedDiagnosticsContext, NLog");
+
+            MethodInfo setMethod = mdcContextType.GetMethodPortable("Set", new[] { typeof(string), typeof(string) });
+            MethodInfo removeMethod = mdcContextType.GetMethodPortable("Remove", new[] { typeof(string) });
+            ParameterExpression keyParam = Expression.Parameter(typeof(string), "key");
+            ParameterExpression valueParam = Expression.Parameter(typeof(string), "value");
+
+            MethodCallExpression setMethodCall = Expression.Call(null, setMethod, keyParam, valueParam);
+            MethodCallExpression removeMethodCall = Expression.Call(null, removeMethod, keyParam);
+
+            Action<string, string> set = Expression
+                .Lambda<Action<string, string>>(setMethodCall, keyParam, valueParam)
+                .Compile();
+            Action<string> remove = Expression
+                .Lambda<Action<string>>(removeMethodCall, keyParam)
+                .Compile();
+
+            return (key, value) =>
+            {
+                set(key, value);
+                return new DisposableAction(() => remove(key));
+            };
+        }
+
+        private static Type GetLogManagerType()
+        {
+            return Type.GetType("NLog.LogManager, NLog");
+        }
+
+        private static Func<string, object> GetGetLoggerMethodCall()
+        {
+            Type logManagerType = GetLogManagerType();
+            MethodInfo method = logManagerType.GetMethodPortable("GetLogger", new[] { typeof(string) });
+            ParameterExpression nameParam = Expression.Parameter(typeof(string), "name");
+            MethodCallExpression methodCall = Expression.Call(null, method, nameParam);
+            return Expression.Lambda<Func<string, object>>(methodCall, nameParam).Compile();
+        }
+
+        public class NLogLogger : ILog
+        {
+            private readonly dynamic _logger;
+
+            internal NLogLogger(dynamic logger)
+            {
+                _logger = logger;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
+            {
+                if (messageFunc == null)
+                {
+                    return IsLogLevelEnable(logLevel);
+                }
+                messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
+
+                if(exception != null)
+                {
+                    return LogException(logLevel, messageFunc, exception);
+                }
+                switch (logLevel)
+                {
+                    case LogLevel.Debug:
+                        if (_logger.IsDebugEnabled)
+                        {
+                            _logger.Debug(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Info:
+                        if (_logger.IsInfoEnabled)
+                        {
+                            _logger.Info(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Warn:
+                        if (_logger.IsWarnEnabled)
+                        {
+                            _logger.Warn(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Error:
+                        if (_logger.IsErrorEnabled)
+                        {
+                            _logger.Error(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Fatal:
+                        if (_logger.IsFatalEnabled)
+                        {
+                            _logger.Fatal(messageFunc());
+                            return true;
+                        }
+                        break;
+                    default:
+                        if (_logger.IsTraceEnabled)
+                        {
+                            _logger.Trace(messageFunc());
+                            return true;
+                        }
+                        break;
+                }
+                return false;
+            }
+
+            private bool LogException(LogLevel logLevel, Func<string> messageFunc, Exception exception)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Debug:
+                        if (_logger.IsDebugEnabled)
+                        {
+                            _logger.DebugException(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Info:
+                        if (_logger.IsInfoEnabled)
+                        {
+                            _logger.InfoException(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Warn:
+                        if (_logger.IsWarnEnabled)
+                        {
+                            _logger.WarnException(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Error:
+                        if (_logger.IsErrorEnabled)
+                        {
+                            _logger.ErrorException(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Fatal:
+                        if (_logger.IsFatalEnabled)
+                        {
+                            _logger.FatalException(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    default:
+                        if (_logger.IsTraceEnabled)
+                        {
+                            _logger.TraceException(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                }
+                return false;
+            }
+
+            private bool IsLogLevelEnable(LogLevel logLevel)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Debug:
+                        return _logger.IsDebugEnabled;
+                    case LogLevel.Info:
+                        return _logger.IsInfoEnabled;
+                    case LogLevel.Warn:
+                        return _logger.IsWarnEnabled;
+                    case LogLevel.Error:
+                        return _logger.IsErrorEnabled;
+                    case LogLevel.Fatal:
+                        return _logger.IsFatalEnabled;
+                    default:
+                        return _logger.IsTraceEnabled;
+                }
+            }
+        }
+    }
+
+    internal class Log4NetLogProvider : LogProviderBase
+    {
+        private readonly Func<string, object> _getLoggerByNameDelegate;
+        private static bool _providerIsAvailableOverride = true;
+
+        public Log4NetLogProvider()
+        {
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("log4net.LogManager not found");
+            }
+            _getLoggerByNameDelegate = GetGetLoggerMethodCall();
+        }
+
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        public override ILog GetLogger(string name)
+        {
+            return new Log4NetLogger(_getLoggerByNameDelegate(name));
+        }
+
+        internal static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride && GetLogManagerType() != null;
+        }
+
+        protected override OpenNdc GetOpenNdcMethod()
+        {
+            Type ndcContextType = Type.GetType("log4net.NDC, log4net");
+            MethodInfo pushMethod = ndcContextType.GetMethodPortable("Push", new[] { typeof(string) });
+            ParameterExpression messageParam = Expression.Parameter(typeof(string), "message");
+            MethodCallExpression pushMethodCall = Expression.Call(null, pushMethod, messageParam);
+            return Expression.Lambda<OpenNdc>(pushMethodCall, messageParam).Compile();
+        }
+
+        protected override OpenMdc GetOpenMdcMethod()
+        {
+            Type mdcContextType = Type.GetType("log4net.MDC, log4net");
+
+            MethodInfo setMethod = mdcContextType.GetMethodPortable("Set", new[] { typeof(string), typeof(string) });
+            MethodInfo removeMethod = mdcContextType.GetMethodPortable("Remove", new[] { typeof(string) });
+            ParameterExpression keyParam = Expression.Parameter(typeof(string), "key");
+            ParameterExpression valueParam = Expression.Parameter(typeof(string), "value");
+
+            MethodCallExpression setMethodCall = Expression.Call(null, setMethod, keyParam, valueParam);
+            MethodCallExpression removeMethodCall = Expression.Call(null, removeMethod, keyParam);
+
+            Action<string, string> set = Expression
+                .Lambda<Action<string, string>>(setMethodCall, keyParam, valueParam)
+                .Compile();
+            Action<string> remove = Expression
+                .Lambda<Action<string>>(removeMethodCall, keyParam)
+                .Compile();
+
+            return (key, value) =>
+            {
+                set(key, value);
+                return new DisposableAction(() => remove(key));
+            };
+        }
+
+        private static Type GetLogManagerType()
+        {
+            return Type.GetType("log4net.LogManager, log4net");
+        }
+
+        private static Func<string, object> GetGetLoggerMethodCall()
+        {
+            Type logManagerType = GetLogManagerType();
+            MethodInfo method = logManagerType.GetMethodPortable("GetLogger", new[] { typeof(string) });
+            ParameterExpression nameParam = Expression.Parameter(typeof(string), "name");
+            MethodCallExpression methodCall = Expression.Call(null, method, nameParam);
+            return Expression.Lambda<Func<string, object>>(methodCall, nameParam).Compile();
+        }
+
+        public class Log4NetLogger : ILog
+        {
+            private readonly dynamic _logger;
+
+            internal Log4NetLogger(dynamic logger)
+            {
+                _logger = logger;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
+            {
+                if (messageFunc == null)
+                {
+                    return IsLogLevelEnable(logLevel);
+                }
+
+                messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
+
+                if (exception != null)
+                {
+                    return LogException(logLevel, messageFunc, exception);
+                }
+                switch (logLevel)
+                {
+                    case LogLevel.Info:
+                        if (_logger.IsInfoEnabled)
+                        {
+                            _logger.Info(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Warn:
+                        if (_logger.IsWarnEnabled)
+                        {
+                            _logger.Warn(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Error:
+                        if (_logger.IsErrorEnabled)
+                        {
+                            _logger.Error(messageFunc());
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Fatal:
+                        if (_logger.IsFatalEnabled)
+                        {
+                            _logger.Fatal(messageFunc());
+                            return true;
+                        }
+                        break;
+                    default:
+                        if (_logger.IsDebugEnabled)
+                        {
+                            _logger.Debug(messageFunc()); // Log4Net doesn't have a 'Trace' level, so all Trace messages are written as 'Debug'
+                            return true;
+                        }
+                        break;
+                }
+                return false;
+            }
+
+            private bool LogException(LogLevel logLevel, Func<string> messageFunc, Exception exception)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Info:
+                        if (_logger.IsDebugEnabled)
+                        {
+                            _logger.Info(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Warn:
+                        if (_logger.IsWarnEnabled)
+                        {
+                            _logger.Warn(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Error:
+                        if (_logger.IsErrorEnabled)
+                        {
+                            _logger.Error(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Fatal:
+                        if (_logger.IsFatalEnabled)
+                        {
+                            _logger.Fatal(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                    default:
+                        if (_logger.IsDebugEnabled)
+                        {
+                            _logger.Debug(messageFunc(), exception);
+                            return true;
+                        }
+                        break;
+                }
+                return false;
+            }
+
+            private bool IsLogLevelEnable(LogLevel logLevel)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Debug:
+                        return _logger.IsDebugEnabled;
+                    case LogLevel.Info:
+                        return _logger.IsInfoEnabled;
+                    case LogLevel.Warn:
+                        return _logger.IsWarnEnabled;
+                    case LogLevel.Error:
+                        return _logger.IsErrorEnabled;
+                    case LogLevel.Fatal:
+                        return _logger.IsFatalEnabled;
+                    default:
+                        return _logger.IsDebugEnabled;
+                }
+            }
+        }
+    }
+
+    internal class EntLibLogProvider : LogProviderBase
+    {
+        private const string TypeTemplate = "Microsoft.Practices.EnterpriseLibrary.Logging.{0}, Microsoft.Practices.EnterpriseLibrary.Logging";
+        private static bool _providerIsAvailableOverride = true;
+        private static readonly Type LogEntryType;
+        private static readonly Type LoggerType;
+        private static readonly Type TraceEventTypeType;
+        private static readonly Action<string, string, int> WriteLogEntry;
+        private static readonly Func<string, int, bool> ShouldLogEntry;
+
+        static EntLibLogProvider()
+        {
+            LogEntryType = Type.GetType(string.Format(TypeTemplate, "LogEntry"));
+            LoggerType = Type.GetType(string.Format(TypeTemplate, "Logger"));
+            TraceEventTypeType = TraceEventTypeValues.Type;
+            if (LogEntryType == null
+                 || TraceEventTypeType == null
+                 || LoggerType == null)
+            {
+                return;
+            }
+            WriteLogEntry = GetWriteLogEntry();
+            ShouldLogEntry = GetShouldLogEntry();
+        }
+
+        public EntLibLogProvider()
+        {
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("Microsoft.Practices.EnterpriseLibrary.Logging.Logger not found");
+            }
+        }
+
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        public override ILog GetLogger(string name)
+        {
+            return new EntLibLogger(name, WriteLogEntry, ShouldLogEntry);
+        }
+
+        internal static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride
+                 && TraceEventTypeType != null
+                 && LogEntryType != null;
+        }
+
+        private static Action<string, string, int> GetWriteLogEntry()
+        {
+            // new LogEntry(...)
+            var logNameParameter = Expression.Parameter(typeof(string), "logName");
+            var messageParameter = Expression.Parameter(typeof(string), "message");
+            var severityParameter = Expression.Parameter(typeof(int), "severity");
+
+            MemberInitExpression memberInit = GetWriteLogExpression(
+                messageParameter,
+                Expression.Convert(severityParameter, TraceEventTypeType),
+                logNameParameter);
+
+            //Logger.Write(new LogEntry(....));
+            MethodInfo writeLogEntryMethod = LoggerType.GetMethodPortable("Write", new[] { LogEntryType });
+            var writeLogEntryExpression = Expression.Call(writeLogEntryMethod, memberInit);
+
+            return Expression.Lambda<Action<string, string, int>>(
+                writeLogEntryExpression,
+                logNameParameter,
+                messageParameter,
+                severityParameter).Compile();
+        }
+
+        private static Func<string, int, bool> GetShouldLogEntry()
+        {
+            // new LogEntry(...)
+            var logNameParameter = Expression.Parameter(typeof(string), "logName");
+            var severityParameter = Expression.Parameter(typeof(int), "severity");
+
+            MemberInitExpression memberInit = GetWriteLogExpression(
+                Expression.Constant("***dummy***"),
+                Expression.Convert(severityParameter, TraceEventTypeType),
+                logNameParameter);
+
+            //Logger.Write(new LogEntry(....));
+            MethodInfo writeLogEntryMethod = LoggerType.GetMethodPortable("ShouldLog", new[] { LogEntryType });
+            var writeLogEntryExpression = Expression.Call(writeLogEntryMethod, memberInit);
+
+            return Expression.Lambda<Func<string, int, bool>>(
+                writeLogEntryExpression,
+                logNameParameter,
+                severityParameter).Compile();
+        }
+
+        private static MemberInitExpression GetWriteLogExpression(Expression message,
+            Expression severityParameter, ParameterExpression logNameParameter)
+        {
+            var entryType = LogEntryType;
+            MemberInitExpression memberInit = Expression.MemberInit(Expression.New(entryType), new []
+            {
+                Expression.Bind(entryType.GetPropertyPortable("Message"), message),
+                Expression.Bind(entryType.GetPropertyPortable("Severity"), severityParameter),
+                Expression.Bind(entryType.GetPropertyPortable("TimeStamp"),
+                    Expression.Property(null, typeof (DateTime).GetPropertyPortable("UtcNow"))),
+                Expression.Bind(entryType.GetPropertyPortable("Categories"),
+                    Expression.ListInit(
+                        Expression.New(typeof (List<string>)),
+                        typeof (List<string>).GetMethodPortable("Add", new[] {typeof (string)}),
+                        logNameParameter))
+            });
+            return memberInit;
+        }
+
+        public class EntLibLogger : ILog
+        {
+            private readonly string _loggerName;
+            private readonly Action<string, string, int> _writeLog;
+            private readonly Func<string, int, bool> _shouldLog;
+
+            internal EntLibLogger(string loggerName, Action<string, string, int> writeLog, Func<string, int, bool> shouldLog)
+            {
+                _loggerName = loggerName;
+                _writeLog = writeLog;
+                _shouldLog = shouldLog;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
+            {
+                var severity = MapSeverity(logLevel);
+                if (messageFunc == null)
+                {
+                    return _shouldLog(_loggerName, severity);
+                }
+
+
+                messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
+                if (exception != null)
+                {
+                    return LogException(logLevel, messageFunc, exception);
+                }
+                _writeLog(_loggerName, messageFunc(), severity);
+                return true;
+            }
+
+            public bool LogException(LogLevel logLevel, Func<string> messageFunc, Exception exception)
+            {
+                var severity = MapSeverity(logLevel);
+                var message = messageFunc() + Environment.NewLine + exception;
+                _writeLog(_loggerName, message, severity);
+                return true;
+            }
+
+            private static int MapSeverity(LogLevel logLevel)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Fatal:
+                        return TraceEventTypeValues.Critical;
+                    case LogLevel.Error:
+                        return TraceEventTypeValues.Error;
+                    case LogLevel.Warn:
+                        return TraceEventTypeValues.Warning;
+                    case LogLevel.Info:
+                        return TraceEventTypeValues.Information;
+                    default:
+                        return TraceEventTypeValues.Verbose;
+                }
+            }
+        }
+    }
+
+    internal class SerilogLogProvider : LogProviderBase
+    {
+        private readonly Func<string, object> _getLoggerByNameDelegate;
+        private static bool _providerIsAvailableOverride = true;
+
+        public SerilogLogProvider()
+        {
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("Serilog.Log not found");
+            }
+            _getLoggerByNameDelegate = GetForContextMethodCall();
+        }
+
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        public override ILog GetLogger(string name)
+        {
+            return new SerilogLogger(_getLoggerByNameDelegate(name));
+        }
+
+        internal static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride && GetLogManagerType() != null;
+        }
+
+        protected override OpenNdc GetOpenNdcMethod()
+        {
+            return message => GetPushProperty()("NDC", message);
+        }
+
+        protected override OpenMdc GetOpenMdcMethod()
+        {
+            return (key, value) => GetPushProperty()(key, value);
+        }
+
+        private static Func<string, string, IDisposable> GetPushProperty()
+        {
+            Type ndcContextType = Type.GetType("Serilog.Context.LogContext, Serilog.FullNetFx");
+            MethodInfo pushPropertyMethod = ndcContextType.GetMethodPortable(
+                "PushProperty",
+                new[]
+                {
+                    typeof(string),
+                    typeof(object),
+                    typeof(bool)
+                });
+            ParameterExpression nameParam = Expression.Parameter(typeof(string), "name");
+            ParameterExpression valueParam = Expression.Parameter(typeof(object), "value");
+            ParameterExpression destructureObjectParam = Expression.Parameter(typeof(bool), "destructureObjects");
+            MethodCallExpression pushPropertyMethodCall = Expression
+                .Call(null, pushPropertyMethod, nameParam, valueParam, destructureObjectParam);
+            var pushProperty = Expression
+                .Lambda<Func<string, object, bool, IDisposable>>(
+                    pushPropertyMethodCall,
+                    nameParam,
+                    valueParam,
+                    destructureObjectParam)
+                .Compile();
+            
+            return (key, value) => pushProperty(key, value, false);
+        }
+
+        private static Type GetLogManagerType()
+        {
+            return Type.GetType("Serilog.Log, Serilog");
+        }
+
+        private static Func<string, object> GetForContextMethodCall()
+        {
+            Type logManagerType = GetLogManagerType();
+            MethodInfo method = logManagerType.GetMethodPortable("ForContext", new[] { typeof(string), typeof(object), typeof(bool) });
+            ParameterExpression propertyNameParam = Expression.Parameter(typeof(string), "propertyName");
+            ParameterExpression valueParam = Expression.Parameter(typeof(object), "value");
+            ParameterExpression destructureObjectsParam = Expression.Parameter(typeof(bool), "destructureObjects");
+            MethodCallExpression methodCall = Expression.Call(null, method, new Expression[]
+            {
+                propertyNameParam, 
+                valueParam,
+                destructureObjectsParam
+            });
+            var func = Expression.Lambda<Func<string, object, bool, object>>(
+                methodCall,
+                propertyNameParam,
+                valueParam,
+                destructureObjectsParam)
+                .Compile();
+            return name => func("Name", name, false);
+        }
+
+        public class SerilogLogger : ILog
+        {
+            private readonly object _logger;
+            private static readonly object DebugLevel;
+            private static readonly object ErrorLevel;
+            private static readonly object FatalLevel;
+            private static readonly object InformationLevel;
+            private static readonly object VerboseLevel;
+            private static readonly object WarningLevel;
+            private static readonly Func<object, object, bool> IsEnabled;
+            private static readonly Action<object, object, string, object[]> Write;
+            private static readonly Action<object, object, Exception, string, object[]> WriteException;
+
+            static SerilogLogger()
+            {
+                var logEventTypeType = Type.GetType("Serilog.Events.LogEventLevel, Serilog");
+                DebugLevel = Enum.Parse(logEventTypeType, "Debug", false);
+                ErrorLevel = Enum.Parse(logEventTypeType, "Error", false);
+                FatalLevel = Enum.Parse(logEventTypeType, "Fatal", false);
+                InformationLevel = Enum.Parse(logEventTypeType, "Information", false);
+                VerboseLevel = Enum.Parse(logEventTypeType, "Verbose", false);
+                WarningLevel = Enum.Parse(logEventTypeType, "Warning", false);
+
+                // Func<object, object, bool> isEnabled = (logger, level) => { return ((SeriLog.ILogger)logger).IsEnabled(level); }
+                var loggerType = Type.GetType("Serilog.ILogger, Serilog");
+                var logEventLevelType = Type.GetType("Serilog.Events.LogEventLevel, Serilog");
+                MethodInfo isEnabledMethodInfo = loggerType.GetMethodPortable("IsEnabled", logEventLevelType);
+                ParameterExpression instanceParam = Expression.Parameter(typeof(object));
+                UnaryExpression instanceCast = Expression.Convert(instanceParam, loggerType);
+                ParameterExpression levelParam = Expression.Parameter(typeof(object));
+                UnaryExpression levelCast = Expression.Convert(levelParam, logEventTypeType);
+                MethodCallExpression isEnabledMethodCall = Expression.Call(instanceCast, isEnabledMethodInfo, levelCast);
+                IsEnabled = Expression.Lambda<Func<object, object, bool>>(isEnabledMethodCall, instanceParam, levelParam).Compile();
+
+                // Action<object, object, string> Write =
+                // (logger, level, message, params) => { ((SeriLog.ILoggerILogger)logger).Write(level, message, params); }
+                MethodInfo writeMethodInfo = loggerType.GetMethodPortable("Write", new[] { logEventTypeType, typeof(string), typeof(object[]) });
+                ParameterExpression messageParam = Expression.Parameter(typeof(string));
+                ParameterExpression propertyValuesParam = Expression.Parameter(typeof(object[]));
+                MethodCallExpression writeMethodExp = Expression.Call(instanceCast, writeMethodInfo, levelCast, messageParam, propertyValuesParam);
+                var expression = Expression.Lambda<Action<object, object, string, object[]>>(
+                    writeMethodExp, 
+                    instanceParam,
+                    levelParam,
+                    messageParam,
+                    propertyValuesParam);
+                Write = expression.Compile();
+
+                // Action<object, object, string, Exception> WriteException =
+                // (logger, level, exception, message) => { ((ILogger)logger).Write(level, exception, message, new object[]); }
+                MethodInfo writeExceptionMethodInfo = loggerType.GetMethodPortable("Write", new[]
+                {
+                    logEventTypeType,
+                    typeof(Exception), 
+                    typeof(string),
+                    typeof(object[])
+                });
+                ParameterExpression exceptionParam = Expression.Parameter(typeof(Exception));
+                writeMethodExp = Expression.Call(
+                    instanceCast,
+                    writeExceptionMethodInfo,
+                    levelCast,
+                    exceptionParam,
+                    messageParam,
+                    propertyValuesParam);
+                WriteException = Expression.Lambda<Action<object, object, Exception, string, object[]>>(
+                    writeMethodExp, 
+                    instanceParam,
+                    levelParam,
+                    exceptionParam,
+                    messageParam,
+                    propertyValuesParam).Compile();
+            }
+
+            internal SerilogLogger(object logger)
+            {
+                _logger = logger;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
+            {
+                if (messageFunc == null)
+                {
+                    return IsEnabled(_logger, logLevel);
+                }
+                if (exception != null)
+                {
+                    return LogException(logLevel, messageFunc, exception, formatParameters);
+                }
+
+                switch (logLevel)
+                {
+                    case LogLevel.Debug:
+                        if (IsEnabled(_logger, DebugLevel))
+                        {
+                            Write(_logger, DebugLevel, messageFunc(), formatParameters);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Info:
+                        if (IsEnabled(_logger, InformationLevel))
+                        {
+                            Write(_logger, InformationLevel, messageFunc(), formatParameters);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Warn:
+                        if (IsEnabled(_logger, WarningLevel))
+                        {
+                            Write(_logger, WarningLevel, messageFunc(), formatParameters);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Error:
+                        if (IsEnabled(_logger, ErrorLevel))
+                        {
+                            Write(_logger, ErrorLevel, messageFunc(), formatParameters);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Fatal:
+                        if (IsEnabled(_logger, FatalLevel))
+                        {
+                            Write(_logger, FatalLevel, messageFunc(), formatParameters);
+                            return true;
+                        }
+                        break;
+                    default:
+                        if (IsEnabled(_logger, VerboseLevel))
+                        {
+                            Write(_logger, VerboseLevel, messageFunc(), formatParameters);
+                            return true;
+                        }
+                        break;
+                }
+                return false;
+            }
+
+            private bool LogException(LogLevel logLevel, Func<string> messageFunc, Exception exception, object[] formatParams)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Debug:
+                        if (IsEnabled(_logger, DebugLevel))
+                        {
+                            WriteException(_logger, DebugLevel, exception, messageFunc(), formatParams);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Info:
+                        if (IsEnabled(_logger, InformationLevel))
+                        {
+                            WriteException(_logger, InformationLevel, exception, messageFunc(), formatParams);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Warn:
+                        if (IsEnabled(_logger, WarningLevel))
+                        {
+                            WriteException(_logger, WarningLevel, exception, messageFunc(), formatParams);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Error:
+                        if (IsEnabled(_logger, ErrorLevel))
+                        {
+                            WriteException(_logger, ErrorLevel, exception, messageFunc(), formatParams);
+                            return true;
+                        }
+                        break;
+                    case LogLevel.Fatal:
+                        if (IsEnabled(_logger, FatalLevel))
+                        {
+                            WriteException(_logger, FatalLevel, exception, messageFunc(), formatParams);
+                            return true;
+                        }
+                        break;
+                    default:
+                        if (IsEnabled(_logger, VerboseLevel))
+                        {
+                            WriteException(_logger, VerboseLevel, exception, messageFunc(), formatParams);
+                            return true;
+                        }
+                        break;
+                }
+                return false;
+            }
+        }
+    }
+
+    internal class LoupeLogProvider : LogProviderBase
+    {
+        /// <summary>
+        /// The form of the Loupe Log.Write method we're using
+        /// </summary>
+        internal delegate void WriteDelegate(
+            int severity,
+            string logSystem,
+            int skipFrames,
+            Exception exception,
+            bool attributeToException,
+            int writeMode,
+            string detailsXml,
+            string category,
+            string caption,
+            string description,
+            params object[] args
+            );
+
+        private static bool _providerIsAvailableOverride = true;
+        private readonly WriteDelegate _logWriteDelegate;
+
+        public LoupeLogProvider()
+        {
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("Gibraltar.Agent.Log (Loupe) not found");
+            }
+
+            _logWriteDelegate = GetLogWriteDelegate();
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether [provider is available override]. Used in tests.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if [provider is available override]; otherwise, <c>false</c>.
+        /// </value>
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        public override ILog GetLogger(string name)
+        {
+            return new LoupeLogger(name, _logWriteDelegate);
+        }
+
+        public static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride && GetLogManagerType() != null;
+        }
+
+        private static Type GetLogManagerType()
+        {
+            return Type.GetType("Gibraltar.Agent.Log, Gibraltar.Agent");
+        }
+
+        private static WriteDelegate GetLogWriteDelegate()
+        {
+            Type logManagerType = GetLogManagerType();
+            Type logMessageSeverityType = Type.GetType("Gibraltar.Agent.LogMessageSeverity, Gibraltar.Agent");
+            Type logWriteModeType = Type.GetType("Gibraltar.Agent.LogWriteMode, Gibraltar.Agent");
+
+            MethodInfo method = logManagerType.GetMethodPortable(
+                "Write",
+                new[]
+                {
+                    logMessageSeverityType, typeof(string), typeof(int), typeof(Exception), typeof(bool), 
+                    logWriteModeType, typeof(string), typeof(string), typeof(string), typeof(string), typeof(object[])
+                });
+
+            var callDelegate = (WriteDelegate)method.CreateDelegate(typeof(WriteDelegate));
+            return callDelegate;
+        }
+
+        public class LoupeLogger : ILog
+        {
+            private const string LogSystem = "LibLog";
+
+            private readonly string _category;
+            private readonly WriteDelegate _logWriteDelegate;
+            private readonly int _skipLevel;
+
+            internal LoupeLogger(string category, WriteDelegate logWriteDelegate)
+            {
+                _category = category;
+                _logWriteDelegate = logWriteDelegate;
+                _skipLevel = 1;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
+            {
+                if (messageFunc == null)
+                {
+                    //nothing to log..
+                    return true;
+                }
+
+                messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
+
+                _logWriteDelegate(ToLogMessageSeverity(logLevel), LogSystem, _skipLevel, exception, true, 0, null,
+                    _category, null, messageFunc.Invoke());
+
+                return true;
+            }
+
+            private int ToLogMessageSeverity(LogLevel logLevel)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Trace:
+                        return TraceEventTypeValues.Verbose;
+                    case LogLevel.Debug:
+                        return TraceEventTypeValues.Verbose;
+                    case LogLevel.Info:
+                        return TraceEventTypeValues.Information;
+                    case LogLevel.Warn:
+                        return TraceEventTypeValues.Warning;
+                    case LogLevel.Error:
+                        return TraceEventTypeValues.Error;
+                    case LogLevel.Fatal:
+                        return TraceEventTypeValues.Critical;
+                    default:
+                        throw new ArgumentOutOfRangeException("logLevel");
+                }
+            }
+        }
+    }
+
+    internal static class TraceEventTypeValues
+    {
+        internal static readonly Type Type;
+        internal static readonly int Verbose;
+        internal static readonly int Information;
+        internal static readonly int Warning;
+        internal static readonly int Error;
+        internal static readonly int Critical;
+
+        static TraceEventTypeValues()
+        {
+            var assembly = typeof(Uri).GetAssemblyPortable(); // This is to get to the System.dll assembly in a PCL compatible way.
+            if (assembly == null)
+            {
+                return;
+            }
+            Type = assembly.GetType("System.Diagnostics.TraceEventType");
+            if (Type == null) return;
+            Verbose = (int)Enum.Parse(Type, "Verbose", false);
+            Information = (int)Enum.Parse(Type, "Information", false);
+            Warning = (int)Enum.Parse(Type, "Warning", false);
+            Error = (int)Enum.Parse(Type, "Error", false);
+            Critical = (int)Enum.Parse(Type, "Critical", false);
+        }
+    }
+
+    internal class ColouredConsoleLogProvider : LogProviderBase
+    {
+        private static readonly Type ConsoleType;
+        private static readonly Type ConsoleColorType;
+        private static readonly Action<string> ConsoleWriteLine;
+        private static readonly Func<int> GetConsoleForeground;
+        private static readonly Action<int> SetConsoleForeground;
+        private static bool _providerIsAvailableOverride = true;
+        private static readonly IDictionary<LogLevel, int> Colors;
+ 
+        static ColouredConsoleLogProvider()
+        {
+            ConsoleType = Type.GetType("System.Console");
+            ConsoleColorType = ConsoleColorValues.Type;
+
+            if (!IsLoggerAvailable())
+            {
+                throw new InvalidOperationException("System.Console or System.ConsoleColor type not found");
+            }
+
+            MessageFormatter = DefaultMessageFormatter;
+            Colors = new Dictionary<LogLevel, int>
+                {
+                    {LogLevel.Fatal, ConsoleColorValues.Red},
+                    {LogLevel.Error, ConsoleColorValues.Yellow},
+                    {LogLevel.Warn, ConsoleColorValues.Magenta},
+                    {LogLevel.Info, ConsoleColorValues.White},
+                    {LogLevel.Debug, ConsoleColorValues.Gray},
+                    {LogLevel.Trace, ConsoleColorValues.DarkGray},
+                };
+            ConsoleWriteLine = GetConsoleWrite();
+            GetConsoleForeground = GetGetConsoleForeground();
+            SetConsoleForeground = GetSetConsoleForeground();
+        }
+
+        internal static bool IsLoggerAvailable()
+        {
+            return ProviderIsAvailableOverride && ConsoleType != null && ConsoleColorType != null;
+        }
+
+        public override ILog GetLogger(string name)
+        {
+            return new ColouredConsoleLogger(name, ConsoleWriteLine, GetConsoleForeground, SetConsoleForeground);
+        }
+
+        /// <summary>
+        /// A delegate returning a formatted log message
+        /// </summary>
+        /// <param name="loggerName">The name of the Logger</param>
+        /// <param name="level">The Log Level</param>
+        /// <param name="message">The Log Message</param>
+        /// <param name="e">The Exception, if there is one</param>
+        /// <returns>A formatted Log Message string.</returns>
+        internal delegate string MessageFormatterDelegate(
+            string loggerName,
+            LogLevel level,
+            object message,
+            Exception e);
+
+        internal static MessageFormatterDelegate MessageFormatter { get; set; }
+
+        public static bool ProviderIsAvailableOverride
+        {
+            get { return _providerIsAvailableOverride; }
+            set { _providerIsAvailableOverride = value; }
+        }
+
+        protected static string DefaultMessageFormatter(string loggerName, LogLevel level, object message, Exception e)
+        {
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
+            stringBuilder.Append(" ");
+            
+            // Append a readable representation of the log level
+            stringBuilder.Append(("[" + level.ToString().ToUpper() + "]").PadRight(8));
+            stringBuilder.Append("(" + loggerName + ") ");
+
+            // Append the message
+            stringBuilder.Append(message);
+
+            // Append stack trace if there is an exception
+            if (e != null)
+            {
+                stringBuilder.Append(Environment.NewLine).Append(e.GetType());
+                stringBuilder.Append(Environment.NewLine).Append(e.Message);
+                stringBuilder.Append(Environment.NewLine).Append(e.StackTrace);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        private static Action<string> GetConsoleWrite()
+        {
+            var messageParameter = Expression.Parameter(typeof(string), "message");
+
+            MethodInfo writeMethod = ConsoleType.GetMethodPortable("WriteLine", new[] { typeof(string) });
+            var writeExpression = Expression.Call(writeMethod, messageParameter);
+
+            return Expression.Lambda<Action<string>>(
+                writeExpression, messageParameter).Compile();
+        }
+
+        private static Func<int> GetGetConsoleForeground()
+        {
+            MethodInfo getForeground = ConsoleType.GetPropertyPortable("ForegroundColor").GetGetMethod();
+            var getForegroundExpression = Expression.Convert(Expression.Call(getForeground), typeof(int));
+
+            return Expression.Lambda<Func<int>>(getForegroundExpression).Compile();
+        }
+
+        private static Action<int> GetSetConsoleForeground()
+        {
+            var colorParameter = Expression.Parameter(typeof(int), "color");
+
+            MethodInfo setForeground = ConsoleType.GetPropertyPortable("ForegroundColor").GetSetMethod();
+            var setForegroundExpression = Expression.Call(setForeground,
+                Expression.Convert(colorParameter, ConsoleColorType));
+
+            return Expression.Lambda<Action<int>>(
+                setForegroundExpression, colorParameter).Compile();
+        }
+
+        public class ColouredConsoleLogger : ILog
+        {
+            private readonly string _name;
+            private readonly Action<string> _write;
+            private readonly Func<int> _getForeground;
+            private readonly Action<int> _setForeground;
+
+            public ColouredConsoleLogger(string name, Action<string> write,
+                Func<int> getForeground, Action<int> setForeground)
+            {
+                _name = name;
+                _write = write;
+                _getForeground = getForeground;
+                _setForeground = setForeground;
+            }
+
+            public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception,
+                params object[] formatParameters)
+            {
+                if (messageFunc == null)
+                {
+                    return true;
+                }
+
+                messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
+
+                Write(logLevel, messageFunc(), exception);
+                return true;
+            }
+
+            protected void Write(LogLevel logLevel, string message, Exception e = null)
+            {
+                var formattedMessage = MessageFormatter(this._name, logLevel, message, e);
+                int color;
+
+                if (Colors.TryGetValue(logLevel, out color))
+                {
+                    var originalColor = _getForeground();
+                    try
+                    {
+                        _setForeground(color);
+                        _write(formattedMessage);
+                    }
+                    finally
+                    {
+                        _setForeground(originalColor);
+                    }
+                }
+                else
+                {
+                    _write(formattedMessage);
+                }
+            }
+        }
+
+        private static class ConsoleColorValues
+        {
+            internal static readonly Type Type;
+            internal static readonly int Red;
+            internal static readonly int Yellow;
+            internal static readonly int Magenta;
+            internal static readonly int White;
+            internal static readonly int Gray;
+            internal static readonly int DarkGray;
+
+            static ConsoleColorValues()
+            {
+                Type = Type.GetType("System.ConsoleColor");
+                if (Type == null) return;
+                Red = (int)Enum.Parse(Type, "Red", false);
+                Yellow = (int)Enum.Parse(Type, "Yellow", false);
+                Magenta = (int)Enum.Parse(Type, "Magenta", false);
+                White = (int)Enum.Parse(Type, "White", false);
+                Gray = (int)Enum.Parse(Type, "Gray", false);
+                DarkGray = (int)Enum.Parse(Type, "DarkGray", false);
+            }
+        }
+    }
+
+    internal static class LogMessageFormatter
+    {
+        private static readonly Regex Pattern = new Regex(@"\{\w{1,}\}");
+
+        /// <summary>
+        /// Some logging frameworks support structured logging, such as serilog. This will allow you to add names to structured data in a format string:
+        /// For example: Log("Log message to {user}", user). This only works with serilog, but as the user of LibLog, you don't know if serilog is actually 
+        /// used. So, this class simulates that. it will replace any text in {curlybraces} with an index number. 
+        /// 
+        /// "Log {message} to {user}" would turn into => "Log {0} to {1}". Then the format parameters are handled using regular .net string.Format.
+        /// </summary>
+        /// <param name="messageBuilder">The message builder.</param>
+        /// <param name="formatParameters">The format parameters.</param>
+        /// <returns></returns>
+        public static Func<string> SimulateStructuredLogging(Func<string> messageBuilder, object[] formatParameters)
+        {
+            if(formatParameters == null)
+            {
+                return messageBuilder;
+            }
+
+            return () =>
+            {
+                string targetMessage = messageBuilder();
+                int argumentIndex = 0;
+                foreach (Match match in Pattern.Matches(targetMessage))
+                {
+                    int notUsed;
+                    if (!int.TryParse(match.Value.Substring(1, match.Value.Length -2), out notUsed))
+                    {
+                        targetMessage = ReplaceFirst(targetMessage, match.Value,
+                            "{" + argumentIndex++ + "}");
+                    }
+                }
+                try
+                {
+                    return String.Format(CultureInfo.InvariantCulture, targetMessage, formatParameters);
+                }
+                catch (FormatException ex)
+                {
+                    throw new FormatException("The input string '" + targetMessage + "' could not be formatted using string.Format", ex);
+                }
+            };
+        }
+
+        private static string ReplaceFirst(string text, string search, string replace)
+        {
+            int pos = text.IndexOf(search, StringComparison.Ordinal);
+            if (pos < 0)
+            {
+                return text;
+            }
+            return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
+        }
+    }
+
+    internal static class TypeExtensions
+    {
+        internal static MethodInfo GetMethodPortable(this Type type, string name)
+        {
+#if LIBLOG_PORTABLE
+            return type.GetRuntimeMethod(name, new Type[]{});
+#else
+            return type.GetMethod(name);
+#endif
+        }
+
+        internal static MethodInfo GetMethodPortable(this Type type, string name, params Type[] types)
+        {
+#if LIBLOG_PORTABLE
+            return type.GetRuntimeMethod(name, types);
+#else
+            return type.GetMethod(name, types);
+#endif
+        }
+
+        internal static PropertyInfo GetPropertyPortable(this Type type, string name)
+        {
+#if LIBLOG_PORTABLE
+            return type.GetRuntimeProperty(name);
+#else
+            return type.GetProperty(name);
+#endif
+        }
+
+#if LIBLOG_PORTABLE
+        internal static MethodInfo GetGetMethod(this PropertyInfo propertyInfo)
+        {
+            return propertyInfo.GetMethod;
+        }
+
+        internal static MethodInfo GetSetMethod(this PropertyInfo propertyInfo)
+        {
+            return propertyInfo.SetMethod;
+        }
+#endif
+
+#if !LIBLOG_PORTABLE
+        internal static object CreateDelegate(this MethodInfo methodInfo, Type delegateType)
+        {
+            return Delegate.CreateDelegate(delegateType, methodInfo);
+        }
+#endif
+
+        internal static Assembly GetAssemblyPortable(this Type type)
+        {
+#if LIBLOG_PORTABLE
+            return type.GetTypeInfo().Assembly;
+#else
+            return type.Assembly;
+#endif
+        }
+    }
+
+    internal class DisposableAction : IDisposable
+    {
+        private readonly Action _onDispose;
+
+        public DisposableAction(Action onDispose = null)
+        {
+            _onDispose = onDispose;
+        }
+
+        public void Dispose()
+        {
+            if(_onDispose != null)
+            {
+                _onDispose();
+            }
+        }
+    }
+}
diff --git a/uhttpsharp/Headers/HttpHeaders.cs b/uhttpsharp/Headers/HttpHeaders.cs
index 66d708d..9b57910 100644
--- a/uhttpsharp/Headers/HttpHeaders.cs
+++ b/uhttpsharp/Headers/HttpHeaders.cs
@@ -6,8 +6,8 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using log4net;
 using uhttpsharp.RequestProviders;
+using uhttpsharp.Logging;
 
 namespace uhttpsharp.Headers
 {
diff --git a/uhttpsharp/HttpClient.cs b/uhttpsharp/HttpClient.cs
index 8366f00..4749d11 100644
--- a/uhttpsharp/HttpClient.cs
+++ b/uhttpsharp/HttpClient.cs
@@ -17,7 +17,6 @@
  */
 
 using System.Text;
-using log4net;
 using System.Net;
 using System.Reflection;
 using System;
@@ -29,6 +28,7 @@
 using uhttpsharp.Clients;
 using uhttpsharp.Headers;
 using uhttpsharp.RequestProviders;
+using uhttpsharp.Logging;
 
 namespace uhttpsharp
 {
@@ -37,7 +37,7 @@ internal sealed class HttpClientHandler
         private const string CrLf = "\r\n";
         private static readonly byte[] CrLfBuffer = Encoding.UTF8.GetBytes(CrLf);
 
-        private static readonly ILog Logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog Logger = LogProvider.GetCurrentClassLogger();
         
         private readonly IClient _client;
         private readonly Func<IHttpContext, Task> _requestHandler;
@@ -108,7 +108,7 @@ private async void Process()
             catch (Exception e)
             {
                 // Hate people who make bad calls.
-                Logger.Warn(string.Format("Error while serving : {0}", _remoteEndPoint), e);
+                Logger.WarnException(string.Format("Error while serving : {0}", _remoteEndPoint), e);
                 _client.Close();
             }
 
diff --git a/uhttpsharp/HttpServer.cs b/uhttpsharp/HttpServer.cs
index 5c13387..e30d070 100644
--- a/uhttpsharp/HttpServer.cs
+++ b/uhttpsharp/HttpServer.cs
@@ -16,19 +16,19 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-using log4net;
 using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Threading.Tasks;
 using uhttpsharp.Listeners;
 using uhttpsharp.RequestProviders;
+using uhttpsharp.Logging;
 
 namespace uhttpsharp
 {
     public sealed class HttpServer : IDisposable
     {
-        private static readonly ILog Logger = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog Logger = LogProvider.GetCurrentClassLogger();
 
         private bool _isActive;
 
@@ -78,7 +78,7 @@ private async void Listen(IHttpListener listener)
                 }
                 catch (Exception e)
                 {
-                    Logger.Warn("Error while getting client", e);
+                    Logger.WarnException("Error while getting client", e);
                 }
             }
 
diff --git a/uhttpsharp/RequestProviders/HttpRequestProvider.cs b/uhttpsharp/RequestProviders/HttpRequestProvider.cs
index 8edb5df..d33270d 100644
--- a/uhttpsharp/RequestProviders/HttpRequestProvider.cs
+++ b/uhttpsharp/RequestProviders/HttpRequestProvider.cs
@@ -5,8 +5,8 @@
 using System.Net.Sockets;
 using System.Text;
 using System.Threading.Tasks;
-using log4net;
 using uhttpsharp.Headers;
+using uhttpsharp.Logging;
 
 namespace uhttpsharp.RequestProviders
 {
@@ -14,9 +14,8 @@ public class HttpRequestProvider : IHttpRequestProvider
     {
         private static readonly char[] Separators = { '/' };
 
-        private static readonly ILog Logger = LogManager.GetLogger(typeof(HttpRequestProvider));
-
-
+        private static readonly ILog Logger = LogProvider.GetCurrentClassLogger();
+        
         public async Task<IHttpRequest> Provide(IStreamReader reader)
         {
             // parse the http request
diff --git a/uhttpsharp/packages.config b/uhttpsharp/packages.config
index a8e7b37..b7ba33b 100644
--- a/uhttpsharp/packages.config
+++ b/uhttpsharp/packages.config
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="log4net" version="2.0.3" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="6.0.3" targetFramework="net45" />
+  <package id="LibLog" version="3.1.0" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="6.0.8" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/uhttpsharp/uhttpsharp.csproj b/uhttpsharp/uhttpsharp.csproj
index 4cf5d80..aa5dfe1 100644
--- a/uhttpsharp/uhttpsharp.csproj
+++ b/uhttpsharp/uhttpsharp.csproj
@@ -36,11 +36,9 @@
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="log4net">
-      <HintPath>..\packages\log4net.2.0.3\lib\net40-full\log4net.dll</HintPath>
-    </Reference>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\packages\Newtonsoft.Json.6.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Newtonsoft.Json.6.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -55,6 +53,7 @@
     <Compile Include="..\AssemblyCommon.cs">
       <Link>Properties\AssemblyCommon.cs</Link>
     </Compile>
+    <Compile Include="App_Packages\LibLog.3.1\LibLog.cs" />
     <Compile Include="Attributes\IModelBinding.cs" />
     <Compile Include="Attributes\HttpMethodAttribute.cs" />
     <Compile Include="Clients\ClientSslDecoerator.cs" />