diff --git a/README.md b/README.md
index e8b2e06de..4d671b5d4 100644
--- a/README.md
+++ b/README.md
@@ -12,35 +12,36 @@ The primary repo for the project is [on GitHub](https://github.com/opencover/ope
 ### Team communication
 [![Join the chat at https://gitter.im/OpenCover/opencover](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/OpenCover/opencover?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Team communications can also be done via [slack](http://slack.com), raise an issue to request access (include your email - obfuscated if you wish) and we will send you an invite then just visit the [team page](https://opencover.slack.com/) to sign up and join the conversation.
+### WIKI
+Please review the [wiki pages](https://github.com/opencover/opencover/wiki/_pages) on how to use OpenCover and take particular interest in the [Usage guide](https://github.com/opencover/opencover/wiki/Usage).
+
+### Issues
+Please raise issues on GitHub, if you can repeat the issue then please provide a sample to make it easier for us to also repeat it and then implement a fix. Please do not hijack unrelated issues, I would rather you create a new issue than add noise to an unrelated issue.
+
+[Dropbox](http://db.tt/VanqFDn) is very useful for sharing files alternatively you could create a [gist](https://gist.github.com/).
 
 ### Licence
 All Original Software is licensed under the [MIT Licence](https://github.com/opencover/opencover/blob/master/License.md) and does not apply to any other 3rd party tools, utilities or code which may be used to develop this application.
 
 If anyone is aware of any licence violations that this code may be making please inform the developers so that the issue can be investigated and rectified.
 
-### WIKI
-Please review the [wiki pages](https://github.com/opencover/opencover/wiki/_pages) on how to use OpenCover and take particular interest in the [Usage guide](https://github.com/opencover/opencover/wiki/Usage).
+### Integration Test support
+OpenCover was initially created to support unit testing techniques such as TDD and tools like NUnit and MSTest. Over time others have found ways to use OpenCover for integration testing especially in tricky scenarios such as IIS and Windows Services. I'll put links here as to how people have achieved this however as they say YMMV (You Mileage May Vary).
 
-### Service support
-Note that .zip and .nuget packages (at least) will not ACL files so that a low-privilege service can execute them -- manually add the service principal with read/execute privilege to the OpenCover.Profiler.dll ACLs, either through explorer properties or by a `Get-Acl`/`Set-Acl` PowerShell script.
+#### IIS support
+Please refer to the wiki - [IIS Support](https://github.com/OpenCover/opencover/wiki/IIS-Support)
 
-Launching the profiling operation must be done with Administrator privilege -- this is required to even start the service, and is also needed to create the global objects and set the per-service environment that registers the COM object.  Assuming that the COM objects have been pre-registered, the command line to use is like
+#### DNX support
+Please refer to the wiki - [DNX Support](https://github.com/OpenCover/opencover/wiki/DNX-Support)
 
-    OpenCover.console.exe -service:byname -target:<service name> -output:coverage.xml
-    
-As this is a blocking operation, launching the coverage gathering a separate process as 
+#### Win8/Win10 Application Support
+Note yet [implemented](https://github.com/OpenCover/opencover/issues/144). Sorry no call for it I assume the WPF way of separating model and UI has led to people getting all they need from unit-tests; I know how that is how it works for me. 
 
-    start-process OpenCover.console.exe @("-target:<service name>", "-service:byName", "-output:<service name>coverage.xml")
-    
-or equivalent in your test scripts.
+#### Service support
+please refer to the wiki - [Service Support](https://github.com/OpenCover/opencover/wiki/Service-Support)
 
-The `byname` qualifier is used to prevent races if multiple services are being started concurrently by injecting the OpenCover profiling information to the service specific environment.
-
-### Issues
-Please raise issues on GitHub, if you can repeat the issue then please provide a sample to make it easier for us to also repeat it and then implement a fix. Please do not hijack unrelated issues, I would rather you create a new issue than add noise to an unrelated issue.
-
-[Dropbox](http://db.tt/VanqFDn) is very useful for sharing files alternatively you could create a [gist](https://gist.github.com/).
+#### Silverlight support
+Please refer to wiki - [Silverlight support](https://github.com/OpenCover/opencover/wiki/Silverlight-Support)
 
 ### Building
 You will need:
@@ -85,7 +86,7 @@ I would like to thank
 * JetBrains for my Open Source [ReSharper licence](http://www.jetbrains.com/resharper/),
 * [AppVeyor](https://ci.appveyor.com/project/sawilde/opencover) for allowing free build CI services for Open Source projects,
 * [Coveralls](https://coveralls.io/r/OpenCover/opencover) for allowing free services for Open Source projects,
-* NDepend for my [NDepend licence](http://www.ndepend.com/).
+* NDepend for my [NDepend licence](http://www.ndepend.com/),
 * the guys at [CodeBetter](http://codebetter.com/), [Devlicious](http://devlicio.us/) and [Los Techies](http://lostechies.com/) who orignally arranged my MSDN licence all those years ago without which I doubt I'd have been able to start OpenCover (now no longer needed as we can build OpenCover using the VS2013 Community Edition), 
 * the [NextGenUG](http://www.nxtgenug.net/) and their free swag from where I got lots of useful tools,
 
diff --git a/ReleaseNotes.tmp b/ReleaseNotes.tmp
index 3cc108b09..b32197fc1 100644
--- a/ReleaseNotes.tmp
+++ b/ReleaseNotes.tmp
@@ -1,4 +1,6 @@
 Version [[version]]
+#282 exclude by process (feature)
+#246 auto crash reports (feature)
 #329 address ArgumentOutOfRangeException (potentially related to #274) (fix for VS2015)
 #335 error on unrecognized arguments/prefixes (fix)
 #328 exclude types when declaredtype is excluded (fix-feature)
diff --git a/build/Version/opencover.gendarme.snk b/build/Version/opencover.3rdparty.snk
similarity index 100%
rename from build/Version/opencover.gendarme.snk
rename to build/Version/opencover.3rdparty.snk
diff --git a/main/.nuget/packages.config b/main/.nuget/packages.config
index 6a2daf408..0d36bd4f6 100644
--- a/main/.nuget/packages.config
+++ b/main/.nuget/packages.config
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="CrashReporterdotNet" version="1.5" />
   <package id="coveralls.io" version="1.3.4" />
   <package id="curl" version="7.30.0.2" />
   <package id="Mono.Gendarme" version="2.11.0.20121120" />
diff --git a/main/OpenCover.Gendarme.Signer/App.config b/main/OpenCover.3rdParty.Signer/App.config
similarity index 100%
rename from main/OpenCover.Gendarme.Signer/App.config
rename to main/OpenCover.3rdParty.Signer/App.config
diff --git a/main/OpenCover.3rdParty.Signer/CrashReporterSigner.cs b/main/OpenCover.3rdParty.Signer/CrashReporterSigner.cs
new file mode 100644
index 000000000..e4e2f4bbc
--- /dev/null
+++ b/main/OpenCover.3rdParty.Signer/CrashReporterSigner.cs
@@ -0,0 +1,52 @@
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Mono.Cecil;
+
+namespace OpenCover.ThirdParty.Signer
+{
+    internal static class CrashReporterSigner
+    {
+
+        private const string Version = "1.5";
+
+        private static readonly string GendarmeAssemblyName = string.Format("CrashReporterdotNet.{0}", Version);
+
+        public static readonly string TargetFolder = Path.Combine("..", "tools", "CrashReporterSigned");
+        private static readonly string SourceFolder = Path.Combine("packages", GendarmeAssemblyName, "lib", "net20");
+        private static readonly string StrongNameKey = Path.Combine("..", "build", "Version", "opencover.3rdparty.snk");
+
+
+        public static bool AlreadySigned(string baseFolder)
+        {
+            var frameworkAssembly = Path.Combine(baseFolder, TargetFolder, "CrashReporter.NET.dll");
+            if (File.Exists(frameworkAssembly))
+            {
+                try
+                {
+                    var frameworkDefinition = AssemblyDefinition.ReadAssembly(frameworkAssembly);
+                    return frameworkDefinition.Name.HasPublicKey;
+                }
+                catch
+                {
+                }
+            }
+            return false;
+        }
+
+        public static void SignAssembly(string baseFolder)
+        {
+            var key = Path.Combine(baseFolder, StrongNameKey);
+            var assembly = Path.Combine(baseFolder, SourceFolder, "CrashReporter.NET.dll");
+            var newAssembly = Path.Combine(baseFolder, TargetFolder, "CrashReporter.NET.dll");
+
+            assembly = Path.GetFullPath(assembly);
+            newAssembly = Path.GetFullPath(newAssembly);
+
+            File.Copy(assembly, newAssembly, true);
+            var definition = AssemblyDefinition.ReadAssembly(newAssembly);
+            var keyPair = new StrongNameKeyPair(new FileStream(key, FileMode.Open, FileAccess.Read));
+            definition.Write(newAssembly, new WriterParameters() { StrongNameKeyPair = keyPair });
+        }
+    }
+}
\ No newline at end of file
diff --git a/main/OpenCover.Gendarme.Signer/Program.cs b/main/OpenCover.3rdParty.Signer/GendarmeSigner.cs
similarity index 67%
rename from main/OpenCover.Gendarme.Signer/Program.cs
rename to main/OpenCover.3rdParty.Signer/GendarmeSigner.cs
index 8ae24e077..cc88103d8 100644
--- a/main/OpenCover.Gendarme.Signer/Program.cs
+++ b/main/OpenCover.3rdParty.Signer/GendarmeSigner.cs
@@ -1,48 +1,23 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
+using System.IO;
 using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 using Mono.Cecil;
 
-namespace OpenCover.Gendarme.Signer
+namespace OpenCover.ThirdParty.Signer
 {
-    class Program
+    internal static class GendarmeSigner
     {
-		private const string GendarmeVersion = "2.11.0.20121120";
 
-		private static readonly string GendarmeAssemblyName = string.Format("Mono.Gendarme.{0}", GendarmeVersion);
+        private const string GendarmeVersion = "2.11.0.20121120";
 
-        private static readonly string TargetFolder = Path.Combine("..", "tools", "GendarmeSigned");
-        private static readonly string SourceFolder = Path.Combine("packages", GendarmeAssemblyName, "tools");
-        private static readonly string StrongNameKey = Path.Combine("..", "build", "Version", "opencover.gendarme.snk");
-
-        static void Main(string[] args)
-        {
-			var assemblyLocation = Assembly.GetAssembly (typeof(Program)).Location;
-			var assemblyFolder = Path.GetDirectoryName(assemblyLocation);
-            var baseFolder = Path.Combine(assemblyFolder, "..", "..", "..");
+        private static readonly string GendarmeAssemblyName = string.Format("Mono.Gendarme.{0}", GendarmeVersion);
 
-			var targetDirectory = Path.Combine (baseFolder, TargetFolder);
-            if (!Directory.Exists(targetDirectory)) 
-				Directory.CreateDirectory (targetDirectory);
-
-            if (AlreadySigned(baseFolder))
-            {
-                Console.WriteLine("Gendarme Framework is already Signed");
-                return;
-            }
-
-            Console.WriteLine("Signing Gendarme Framework");
-            SignGendarmeFramework(baseFolder);
+        public static readonly string TargetFolder = Path.Combine("..", "tools", "GendarmeSigned");
+        private static readonly string SourceFolder = Path.Combine("packages", GendarmeAssemblyName, "tools");
+        private static readonly string StrongNameKey = Path.Combine("..", "build", "Version", "opencover.3rdparty.snk");
 
-            Console.WriteLine("Signing Gendarme Rules Maintainability");
-            SignGendarmeRulesMaintainability(baseFolder);
-        }
 
-        private static bool AlreadySigned(string baseFolder)
+        public static bool AlreadySigned(string baseFolder)
         {
             var frameworkAssembly = Path.Combine(baseFolder, TargetFolder, "Gendarme.Framework.dll");
             if (File.Exists(frameworkAssembly))
@@ -59,7 +34,7 @@ private static bool AlreadySigned(string baseFolder)
             return false;
         }
 
-        private static void SignGendarmeRulesMaintainability(string baseFolder)
+        public static void SignGendarmeRulesMaintainability(string baseFolder)
         {
             var frameworkAssembly = Path.Combine(baseFolder, TargetFolder, "Gendarme.Framework.dll");
             var frameworkDefinition = AssemblyDefinition.ReadAssembly(frameworkAssembly);
@@ -97,7 +72,7 @@ private static void SignGendarmeRulesMaintainability(string baseFolder)
 
         }
 
-        private static void SignGendarmeFramework(string baseFolder)
+        public static void SignGendarmeFramework(string baseFolder)
         {
             var key = Path.Combine(baseFolder, StrongNameKey);
             var assembly = Path.Combine(baseFolder, SourceFolder, "Gendarme.Framework.dll");
@@ -112,4 +87,4 @@ private static void SignGendarmeFramework(string baseFolder)
             definition.Write(newAssembly, new WriterParameters() { StrongNameKeyPair = keyPair });
         }
     }
-}
+}
\ No newline at end of file
diff --git a/main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj b/main/OpenCover.3rdParty.Signer/OpenCover.3rdParty.Signer.csproj
similarity index 90%
rename from main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj
rename to main/OpenCover.3rdParty.Signer/OpenCover.3rdParty.Signer.csproj
index 7582c303e..484dbfabb 100644
--- a/main/OpenCover.Gendarme.Signer/OpenCover.Gendarme.Signer.csproj
+++ b/main/OpenCover.3rdParty.Signer/OpenCover.3rdParty.Signer.csproj
@@ -7,8 +7,8 @@
     <ProjectGuid>{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}</ProjectGuid>
     <OutputType>Exe</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>OpenCover.Gendarme.Signer</RootNamespace>
-    <AssemblyName>OpenCover.Gendarme.Signer</AssemblyName>
+    <RootNamespace>OpenCover.ThirdParty.Signer</RootNamespace>
+    <AssemblyName>OpenCover.3rdParty.Signer</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
@@ -65,6 +65,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CrashReporterSigner.cs" />
+    <Compile Include="GendarmeSigner.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
@@ -79,6 +81,10 @@
 $(SolutionDir)OpenCover.Gendarme.Signer\bin\$(ConfigurationName)\OpenCover.Gendarme.Signer.exe</PostBuildEvent>
     <PostBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">mono OpenCover.Gendarme.Signer.exe</PostBuildEvent>
   </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent>cd $(SolutionDir)OpenCover.3rdParty.Signer\bin\$(ConfigurationName)
+$(SolutionDir)OpenCover.3rdParty.Signer\bin\$(ConfigurationName)\OpenCover.3rdParty.Signer.exe</PostBuildEvent>
+  </PropertyGroup>
   <!-- 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/main/OpenCover.3rdParty.Signer/Program.cs b/main/OpenCover.3rdParty.Signer/Program.cs
new file mode 100644
index 000000000..0c8f61de4
--- /dev/null
+++ b/main/OpenCover.3rdParty.Signer/Program.cs
@@ -0,0 +1,56 @@
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace OpenCover.ThirdParty.Signer
+{
+    class Program
+    {
+
+        static void Main(string[] args)
+        {
+			var assemblyLocation = Assembly.GetAssembly (typeof(Program)).Location;
+			var assemblyFolder = Path.GetDirectoryName(assemblyLocation) ?? string.Empty;
+            var baseFolder = Path.Combine(assemblyFolder, "..", "..", "..");
+
+            SignGendarme(baseFolder);
+            SignCrashReporter(baseFolder);
+        }
+
+        private static void SignGendarme(string baseFolder)
+        {
+            var targetDirectory = Path.Combine(baseFolder, GendarmeSigner.TargetFolder);
+            if (!Directory.Exists(targetDirectory))
+                Directory.CreateDirectory(targetDirectory);
+
+            if (GendarmeSigner.AlreadySigned(baseFolder))
+            {
+                Console.WriteLine("Gendarme Framework is already Signed");
+                return;
+            }
+
+            Console.WriteLine("Signing Gendarme Framework");
+            GendarmeSigner.SignGendarmeFramework(baseFolder);
+
+            Console.WriteLine("Signing Gendarme Rules Maintainability");
+            GendarmeSigner.SignGendarmeRulesMaintainability(baseFolder);
+        }
+
+        private static void SignCrashReporter(string baseFolder)
+        {
+            var targetDirectory = Path.Combine(baseFolder, CrashReporterSigner.TargetFolder);
+            if (!Directory.Exists(targetDirectory))
+                Directory.CreateDirectory(targetDirectory);
+
+            if (CrashReporterSigner.AlreadySigned(baseFolder))
+            {
+                Console.WriteLine("CrashReporter is already Signed");
+                return;
+            }
+
+            Console.WriteLine("Signing CrashReporter");
+            CrashReporterSigner.SignAssembly(baseFolder);
+
+        }
+    }
+}
diff --git a/main/OpenCover.Gendarme.Signer/Properties/AssemblyInfo.cs b/main/OpenCover.3rdParty.Signer/Properties/AssemblyInfo.cs
similarity index 100%
rename from main/OpenCover.Gendarme.Signer/Properties/AssemblyInfo.cs
rename to main/OpenCover.3rdParty.Signer/Properties/AssemblyInfo.cs
diff --git a/main/OpenCover.Gendarme.Signer/packages.config b/main/OpenCover.3rdParty.Signer/packages.config
similarity index 100%
rename from main/OpenCover.Gendarme.Signer/packages.config
rename to main/OpenCover.3rdParty.Signer/packages.config
diff --git a/main/OpenCover.Console/CrashReporter/AnonymousData.cs b/main/OpenCover.Console/CrashReporter/AnonymousData.cs
new file mode 100644
index 000000000..6e9bcb74b
--- /dev/null
+++ b/main/OpenCover.Console/CrashReporter/AnonymousData.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace OpenCover.Console.CrashReporter
+{
+    /// <summary>
+    /// http://crashreporterdotnet.codeplex.com/SourceControl/latest#CrashReporter.NET/trunk/CrashReporter.NET/DrDump/AnonymousData.cs
+    /// </summary>
+    internal class AnonymousData
+    {
+        public Exception Exception { get; set; }
+        public string ToEmail { get; set; }
+        public Guid? ApplicationGuid { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/main/OpenCover.Console/CrashReporter/SendRequestState.cs b/main/OpenCover.Console/CrashReporter/SendRequestState.cs
new file mode 100644
index 000000000..60aec9990
--- /dev/null
+++ b/main/OpenCover.Console/CrashReporter/SendRequestState.cs
@@ -0,0 +1,129 @@
+using System;
+using System.Globalization;
+using System.Net;
+using CrashReporterDotNET;
+using CrashReporterDotNET.com.drdump;
+
+namespace OpenCover.Console.CrashReporter
+{
+    /// <summary>
+    /// http://crashreporterdotnet.codeplex.com/SourceControl/latest#CrashReporter.NET/trunk/CrashReporter.NET/DrDump/SendRequestState.cs
+    /// </summary>
+    internal class SendRequestState
+    {
+        public AnonymousData AnonymousData { get; set; }
+
+        public SendAnonymousReportCompletedEventArgs SendAnonymousReportResult { get; set; }
+
+        static private ExceptionInfo ConvertToExceptionInfo(Exception e, bool anonymous)
+        {
+            if (e == null)
+                return null;
+            return new ExceptionInfo
+            {
+                Type = e.GetType().ToString(),
+                HResult = System.Runtime.InteropServices.Marshal.GetHRForException(e),
+                StackTrace = e.StackTrace,
+                Source = e.Source,
+                Message = anonymous ? null : e.Message,
+                InnerException = ConvertToExceptionInfo(e.InnerException, anonymous)
+            };
+        }
+
+        static private System.Net.NetworkInformation.PhysicalAddress GetMacAddress()
+        {
+            var googleDns = new System.Net.Sockets.UdpClient("8.8.8.8", 53);
+            var localAddress = ((IPEndPoint)googleDns.Client.LocalEndPoint).Address;
+
+            foreach (var netInterface in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces())
+            {
+                foreach (var addr in netInterface.GetIPProperties().UnicastAddresses)
+                {
+                    if (addr.Address.Equals(localAddress))
+                        return netInterface.GetPhysicalAddress();
+                }
+            }
+            return null;
+        }
+
+        private static int GetAnonymousMachineId()
+        {
+            var mac = GetMacAddress();
+            return mac != null ? BitConverter.ToInt32(System.Security.Cryptography.MD5.Create().ComputeHash(mac.GetAddressBytes()), 0) : 0;
+        }
+
+        internal DetailedExceptionDescription GetDetailedExceptionDescription()
+        {
+            return new DetailedExceptionDescription
+            {
+                Exception = GetExceptionDescription(false),
+            };
+        }
+
+        internal ExceptionDescription GetExceptionDescription(bool anonymous)
+        {
+            var oldCulture = System.Threading.Thread.CurrentThread.CurrentCulture;
+            var oldUiCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
+            System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
+            System.Threading.Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
+
+            var osVersion = Environment.OSVersion;
+            var os = string.Format("os={0};v={1};spname={2}", osVersion.Platform, osVersion.Version, osVersion.ServicePack);
+
+            var exceptionDescription = new ExceptionDescription
+            {
+                ClrVersion = Environment.Version.ToString(),
+                OS = os,
+                CrashDate = DateTime.UtcNow,
+                PCID = GetAnonymousMachineId(),
+                Exception = ConvertToExceptionInfo(AnonymousData.Exception, anonymous),
+                ExceptionString = anonymous ? null : AnonymousData.Exception.ToString(),
+            };
+
+            System.Threading.Thread.CurrentThread.CurrentCulture = oldCulture;
+            System.Threading.Thread.CurrentThread.CurrentUICulture = oldUiCulture;
+
+            return exceptionDescription;
+        }
+
+        internal Application GetApplication()
+        {
+            var mainAssembly = System.Reflection.Assembly.GetEntryAssembly();
+
+            var moduleName = mainAssembly.GetName().Name;
+
+            var attributes = mainAssembly.GetCustomAttributes(typeof(System.Reflection.AssemblyCompanyAttribute), true);
+            string appCompany = (attributes.Length > 0) ? ((System.Reflection.AssemblyCompanyAttribute)attributes[0]).Company : AnonymousData.ToEmail;
+
+            var attributes2 = mainAssembly.GetCustomAttributes(typeof(System.Reflection.AssemblyTitleAttribute), true);
+            var appTitle = (attributes2.Length > 0) ? ((System.Reflection.AssemblyTitleAttribute)attributes2[0]).Title : moduleName;
+
+            var appVersion = mainAssembly.GetName().Version;
+
+            return new Application
+            {
+                ApplicationGUID = AnonymousData.ApplicationGuid.HasValue ? AnonymousData.ApplicationGuid.Value.ToString("D") : null,
+                AppName = appTitle,
+                CompanyName = appCompany,
+                Email = AnonymousData.ToEmail,
+                V1 = (ushort)appVersion.Major,
+                V2 = (ushort)appVersion.Minor,
+                V3 = (ushort)appVersion.Build,
+                V4 = (ushort)appVersion.Revision,
+                MainModule = moduleName
+            };
+        }
+
+        static internal ClientLib GetClientLib()
+        {
+            var clientVersion = typeof(ReportCrash).Assembly.GetName().Version;
+            return new ClientLib
+            {
+                V1 = (ushort)clientVersion.Major,
+                V2 = (ushort)clientVersion.Minor,
+                V3 = (ushort)clientVersion.Build,
+                V4 = (ushort)clientVersion.Revision
+            };
+        }
+    }
+}
diff --git a/main/OpenCover.Console/OpenCover.Console.csproj b/main/OpenCover.Console/OpenCover.Console.csproj
index c62fc381b..7077aa3f0 100644
--- a/main/OpenCover.Console/OpenCover.Console.csproj
+++ b/main/OpenCover.Console/OpenCover.Console.csproj
@@ -78,6 +78,9 @@
     <ApplicationIcon>..\Icons\Icon.ico</ApplicationIcon>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="CrashReporter.NET">
+      <HintPath>..\..\tools\CrashReporterSigned\CrashReporter.NET.dll</HintPath>
+    </Reference>
     <Reference Include="Gendarme.Framework">
       <HintPath>..\..\tools\GendarmeSigned\Gendarme.Framework.dll</HintPath>
     </Reference>
@@ -88,6 +91,8 @@
     <Reference Include="System" />
     <Reference Include="System.Management" />
     <Reference Include="System.ServiceProcess" />
+    <Reference Include="System.Web.Services" />
+    <Reference Include="System.Windows.Forms" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\build\Version\GlobalAssemblyInfo.cs">
@@ -96,6 +101,8 @@
     <Compile Include="..\..\build\Version\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="CrashReporter\AnonymousData.cs" />
+    <Compile Include="CrashReporter\SendRequestState.cs" />
     <Compile Include="ServiceEnvironmentManagement.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -138,6 +145,7 @@
       <Link>Icon.ico</Link>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/main/OpenCover.Console/Program.cs b/main/OpenCover.Console/Program.cs
index 7a83e77ec..e87483d16 100644
--- a/main/OpenCover.Console/Program.cs
+++ b/main/OpenCover.Console/Program.cs
@@ -12,6 +12,8 @@
 using System.Security.Authentication;
 using System.Security.Principal;
 using System.ServiceProcess;
+using CrashReporterDotNET.com.drdump;
+using OpenCover.Console.CrashReporter;
 using OpenCover.Framework;
 using OpenCover.Framework.Manager;
 using OpenCover.Framework.Persistance;
@@ -21,6 +23,8 @@
 
 namespace OpenCover.Console
 {
+
+
     class Program
     {
         private static readonly ILog Logger = LogManager.GetLogger("OpenCover");
@@ -34,12 +38,17 @@ static int Main(string[] args)
         {
             int returnCode;
             var returnCodeOffset = 0;
-            
+
+            AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
+
             try
             {
+                //throw new NullReferenceException();
+
                 CommandLineParser parser;
                 if (!ParseCommandLine(args, out parser)) return parser.ReturnCodeOffset + 1;
 
+
                 LogManager.GetRepository().Threshold = parser.LogLevel;
 
                 returnCodeOffset = parser.ReturnCodeOffset;
@@ -65,14 +74,48 @@ static int Main(string[] args)
                 {
                     Logger.FatalFormat("An exception occured: {0}", ex.Message);
                     Logger.FatalFormat("stack: {0}", ex.StackTrace);
+                    Logger.FatalFormat("A report has been sent to the OenCover development team...");
                 }
 
+                ReportCrash(ex);
+
                 returnCode = returnCodeOffset + 1;
             }
 
             return returnCode;
         }
 
+        private static void CurrentDomainOnUnhandledException(object sender, UnhandledExceptionEventArgs unhandledExceptionEventArgs)
+        {
+            ReportCrash((Exception)unhandledExceptionEventArgs.ExceptionObject);
+            Environment.Exit(0);
+        }
+
+        private static void ReportCrash(Exception exception)
+        {
+            try
+            {
+                var uploader = new HttpsCrashReporterReportUploader();
+
+                var state = new SendRequestState
+                {
+                    AnonymousData = new AnonymousData
+                    {
+                        ApplicationGuid = new Guid("e3933a4b-368b-4256-ad42-777bc60a9558"),
+                        Exception = exception,
+                        ToEmail = ""
+                    }
+                };
+
+                uploader.SendAnonymousReport(SendRequestState.GetClientLib(), state.GetApplication(), state.GetExceptionDescription(true));
+            }
+            catch (Exception ex)
+            {
+                System.Console.WriteLine("Failed to send crash report :(");
+            }
+
+        }
+
         private static int RunWithContainer(CommandLineParser parser, Bootstrapper container, IPersistance persistance)
         {
             var returnCode = 0;
diff --git a/main/OpenCover.Framework/CommandLineParser.cs b/main/OpenCover.Framework/CommandLineParser.cs
index 07220b3d2..a6d01570f 100644
--- a/main/OpenCover.Framework/CommandLineParser.cs
+++ b/main/OpenCover.Framework/CommandLineParser.cs
@@ -277,7 +277,7 @@ private T ExtractValue<T>(string argumentName, Action onError)
 
         private static List<string> ExtractFilters(string rawFilters)
         {
-            const string strRegex = @"([+-][\[].*?[\]].+?\s)|([+-][\[].*?[\]].*)";
+            const string strRegex = @"([+-](\{.*?\})?[\[].*?[\]].+?\s)|([+-](\{.*\})?[\[].*?[\]].*)";
             const RegexOptions myRegexOptions = RegexOptions.None;
             var myRegex = new Regex(strRegex, myRegexOptions);
             
diff --git a/main/OpenCover.Framework/CommandLineParserBase.cs b/main/OpenCover.Framework/CommandLineParserBase.cs
index 57b968efd..dc03f7b86 100644
--- a/main/OpenCover.Framework/CommandLineParserBase.cs
+++ b/main/OpenCover.Framework/CommandLineParserBase.cs
@@ -5,7 +5,6 @@
 //
 using System;
 using System.Collections.Generic;
-using System.Text;
 
 namespace OpenCover.Framework
 {
@@ -17,12 +16,19 @@ public abstract class CommandLineParserBase
     {
         private readonly string[] _arguments;
 
+        /// <summary>
+        /// Instantiate the base command line parser
+        /// </summary>
+        /// <param name="arguments"></param>
         protected CommandLineParserBase(string[] arguments)
         {
             _arguments = arguments;
             ParsedArguments = new Dictionary<string, string>();
         }
 
+        /// <summary>
+        /// Get the parsed arguments
+        /// </summary>
         protected IDictionary<string, string> ParsedArguments { get; private set; }
         
         /// <summary>
diff --git a/main/OpenCover.Framework/Communication/MarshalWapper.cs b/main/OpenCover.Framework/Communication/MarshalWapper.cs
index db1222451..1f4f71d33 100644
--- a/main/OpenCover.Framework/Communication/MarshalWapper.cs
+++ b/main/OpenCover.Framework/Communication/MarshalWapper.cs
@@ -11,12 +11,32 @@
 
 namespace OpenCover.Framework.Communication
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public interface IMarshalWrapper
     {
+        /// <summary>
+        /// Map pinned memory to a structure
+        /// </summary>
+        /// <typeparam name="T">The type of the structure</typeparam>
+        /// <param name="pinnedMemory"></param>
+        /// <returns></returns>
         T PtrToStructure<T>(IntPtr pinnedMemory);
+
+        /// <summary>
+        /// Map a structure to pinned memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="structure"></param>
+        /// <param name="pinnedMemory"></param>
+        /// <param name="fDeleteOld"></param>
         void StructureToPtr<T>(T structure, IntPtr pinnedMemory, bool fDeleteOld);
     }
 
+    /// <summary>
+    /// Implementation of <see cref="IMarshalWrapper"/>
+    /// </summary>
     public class MarshalWrapper : IMarshalWrapper
     {
         public T PtrToStructure<T>(IntPtr pinnedMemory)
diff --git a/main/OpenCover.Framework/Communication/MessageHandler.cs b/main/OpenCover.Framework/Communication/MessageHandler.cs
index e3ed9c854..99f246257 100644
--- a/main/OpenCover.Framework/Communication/MessageHandler.cs
+++ b/main/OpenCover.Framework/Communication/MessageHandler.cs
@@ -52,7 +52,7 @@ public class MessageHandler : IMessageHandler
         private readonly IMarshalWrapper _marshalWrapper;
         private readonly IMemoryManager _memoryManager;
 
-        private static readonly ILog Logger = LogManager.GetLogger("OpenCover");
+        private static readonly ILog DebugLogger = LogManager.GetLogger("DebugLogger");
 
         /// <summary>
         /// Construct a Message Handler
@@ -86,16 +86,21 @@ public int StandardMessage(MSG_Type msgType, IManagedCommunicationBlock mcb, Act
                     break;
 
                 case MSG_Type.MSG_TrackMethod:
-                        writeSize = HandleTrackMethodMessage(pinnedMemory);
+                    writeSize = HandleTrackMethodMessage(pinnedMemory);
                     break;
 
                 case MSG_Type.MSG_AllocateMemoryBuffer:
-                    writeSize = HandlerAllocateBufferMessage(offloadHandling, pinnedMemory);
+                    writeSize = HandleAllocateBufferMessage(offloadHandling, pinnedMemory);
                     break;
 
                 case MSG_Type.MSG_CloseChannel:
                     writeSize = HandleCloseChannelMessage(pinnedMemory);
                     break;
+
+                case MSG_Type.MSG_TrackProcess:
+                    writeSize = HandleTrackProcessMessage(pinnedMemory);
+                    break;
+
             }
             return writeSize;                
         }
@@ -108,7 +113,7 @@ private int HandleGetSequencePointsMessage(IntPtr pinnedMemory, IManagedCommunic
             {
                 var request = _marshalWrapper.PtrToStructure<MSG_GetSequencePoints_Request>(pinnedMemory);
                 InstrumentationPoint[] origPoints;
-                _profilerCommunication.GetSequencePoints(request.modulePath, request.assemblyName,
+                _profilerCommunication.GetSequencePoints(request.processName, request.modulePath, request.assemblyName,
                     request.functionToken, out origPoints);
                 var num = origPoints.Maybe(o => o.Length);
 
@@ -140,7 +145,7 @@ private int HandleGetSequencePointsMessage(IntPtr pinnedMemory, IManagedCommunic
             }
             catch (Exception ex)
             {
-                Logger.DebugFormat("{0}:{1}", ex.GetType(), ex.Message);
+                DebugLogger.ErrorFormat("HandleGetSequencePointsMessage => {0}:{1}", ex.GetType(), ex.Message);
                 response.more = false;
                 response.count = 0;
                 _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
@@ -156,7 +161,7 @@ private int HandleGetBranchPointsMessage(IntPtr pinnedMemory, IManagedCommunicat
             {
                 var request = _marshalWrapper.PtrToStructure<MSG_GetBranchPoints_Request>(pinnedMemory);
                 BranchPoint[] origPoints;
-                _profilerCommunication.GetBranchPoints(request.modulePath, request.assemblyName,
+                _profilerCommunication.GetBranchPoints(request.processName, request.modulePath, request.assemblyName,
                     request.functionToken, out origPoints);
                 var num = origPoints.Maybe(o => o.Length);
 
@@ -189,7 +194,7 @@ private int HandleGetBranchPointsMessage(IntPtr pinnedMemory, IManagedCommunicat
             }
             catch (Exception ex)
             {
-                Logger.DebugFormat("{0}:{1}", ex.GetType(), ex.Message);
+                DebugLogger.ErrorFormat("HandleGetBranchPointsMessage => {0}:{1}", ex.GetType(), ex.Message);
                 response.more = false;
                 response.count = 0;
                 _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
@@ -197,49 +202,118 @@ private int HandleGetBranchPointsMessage(IntPtr pinnedMemory, IManagedCommunicat
             return writeSize;
         }
 
-        private int HandlerAllocateBufferMessage(Action<ManagedBufferBlock> offloadHandling, IntPtr pinnedMemory)
+        private int HandleAllocateBufferMessage(Action<ManagedBufferBlock> offloadHandling, IntPtr pinnedMemory)
         {
-            var request = _marshalWrapper.PtrToStructure<MSG_AllocateBuffer_Request>(pinnedMemory);
-            uint bufferId;
-            var block = _memoryManager.AllocateMemoryBuffer(request.bufferSize, out bufferId);
-            var response = new MSG_AllocateBuffer_Response { allocated = true, bufferId = bufferId };
-            _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
             var writeSize = Marshal.SizeOf(typeof(MSG_AllocateBuffer_Response));
-            offloadHandling(block);
+            var response = new MSG_AllocateBuffer_Response { allocated = false, bufferId = 0 };
+            try
+            {
+                var request = _marshalWrapper.PtrToStructure<MSG_AllocateBuffer_Request>(pinnedMemory);
+                uint bufferId;
+                var block = _memoryManager.AllocateMemoryBuffer(request.bufferSize, out bufferId);
+                response.allocated=true;
+                response.bufferId = bufferId;
+                offloadHandling(block);
+            }
+            catch (Exception ex)
+            {
+                DebugLogger.ErrorFormat("HandlerAllocateBufferMessage => {0}:{1}", ex.GetType(), ex.Message);
+                response.allocated = false;
+                response.bufferId = 0;
+            }
+            finally
+            {
+                _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
+            }
             return writeSize;
         }
 
         private int HandleCloseChannelMessage(IntPtr pinnedMemory)
         {
-            var request = _marshalWrapper.PtrToStructure<MSG_CloseChannel_Request>(pinnedMemory);
-            var bufferId = request.bufferId;
-            var response = new MSG_CloseChannel_Response {done = true};
-            _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
-            var writeSize = Marshal.SizeOf(typeof (MSG_CloseChannel_Response));
-            _memoryManager.DeactivateMemoryBuffer(bufferId);
+            var writeSize = Marshal.SizeOf(typeof(MSG_CloseChannel_Response));
+            var response = new MSG_CloseChannel_Response { done = true };
+            try
+            {
+                var request = _marshalWrapper.PtrToStructure<MSG_CloseChannel_Request>(pinnedMemory);
+                var bufferId = request.bufferId;
+                _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
+                _memoryManager.DeactivateMemoryBuffer(bufferId);
+            }
+            catch (Exception ex)
+            {
+                DebugLogger.ErrorFormat("HandleCloseChannelMessage => {0}:{1}", ex.GetType(), ex.Message);
+            }
+            finally
+            {
+                _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
+            }
             return writeSize;
         }
 
         private int HandleTrackMethodMessage(IntPtr pinnedMemory)
         {
-            var request = _marshalWrapper.PtrToStructure<MSG_TrackMethod_Request>(pinnedMemory);
+            var writeSize = Marshal.SizeOf(typeof(MSG_TrackMethod_Response));
             var response = new MSG_TrackMethod_Response();
-            uint uniqueId;
-            response.track = _profilerCommunication.TrackMethod(request.modulePath,
-                request.assemblyName, request.functionToken, out uniqueId);
-            response.uniqueId = uniqueId;
-            _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
-            var writeSize = Marshal.SizeOf(typeof (MSG_TrackMethod_Response));
+            try
+            {
+                var request = _marshalWrapper.PtrToStructure<MSG_TrackMethod_Request>(pinnedMemory);
+                uint uniqueId;
+                response.track = _profilerCommunication.TrackMethod(request.modulePath,
+                    request.assemblyName, request.functionToken, out uniqueId);
+                response.uniqueId = uniqueId;
+            }
+            catch (Exception ex)
+            {
+                DebugLogger.ErrorFormat("HandleTrackMethodMessage => {0}:{1}", ex.GetType(), ex.Message);
+                response.track = false;
+                response.uniqueId = 0;
+            }
+            finally
+            {
+                _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
+            }
             return writeSize;
         }
 
         private int HandleTrackAssemblyMessage(IntPtr pinnedMemory)
         {
-            var request = _marshalWrapper.PtrToStructure<MSG_TrackAssembly_Request>(pinnedMemory);
             var response = new MSG_TrackAssembly_Response();
-            response.track = _profilerCommunication.TrackAssembly(request.modulePath, request.assemblyName);
-            _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
-            var writeSize = Marshal.SizeOf(typeof (MSG_TrackAssembly_Response));
+            var writeSize = Marshal.SizeOf(typeof(MSG_TrackAssembly_Response));
+            try
+            {
+                var request = _marshalWrapper.PtrToStructure<MSG_TrackAssembly_Request>(pinnedMemory);
+                response.track = _profilerCommunication.TrackAssembly(request.processName, request.modulePath, request.assemblyName);
+            }
+            catch (Exception ex)
+            {
+                DebugLogger.ErrorFormat("HandleTrackAssemblyMessage => {0}:{1}", ex.GetType(), ex.Message);
+                response.track = false;
+            }
+            finally
+            {
+                _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
+            }
+            return writeSize;
+        }
+
+        private int HandleTrackProcessMessage(IntPtr pinnedMemory)
+        {
+            var response = new MSG_TrackProcess_Response();
+            var writeSize = Marshal.SizeOf(typeof(MSG_TrackProcess_Response));
+            try
+            {
+                var request = _marshalWrapper.PtrToStructure<MSG_TrackProcess_Request>(pinnedMemory);
+                response.track = _profilerCommunication.TrackProcess(request.processName);
+            }
+            catch (Exception ex)
+            {
+                DebugLogger.ErrorFormat("HandleTrackProcessMessage => {0}:{1}", ex.GetType(), ex.Message);
+                response.track = false;
+            }
+            finally
+            {
+                _marshalWrapper.StructureToPtr(response, pinnedMemory, false);
+            }
             return writeSize;
         }
 
diff --git a/main/OpenCover.Framework/Communication/Messages.cs b/main/OpenCover.Framework/Communication/Messages.cs
index 6bdfccfef..ba1e40846 100644
--- a/main/OpenCover.Framework/Communication/Messages.cs
+++ b/main/OpenCover.Framework/Communication/Messages.cs
@@ -7,124 +7,334 @@
 
 namespace OpenCover.Framework.Communication
 {
+    /// <summary>
+    /// The command supportd by the host
+    /// </summary>
+// ReSharper disable InconsistentNaming
     public enum MSG_Type : int
     {
+        /// <summary>
+        /// Does this assembly have any code that can be covered
+        /// </summary>
         MSG_TrackAssembly = 1,
+
+        /// <summary>
+        /// Get the sequence point for a method
+        /// </summary>
         MSG_GetSequencePoints = 2,
+
+        /// <summary>
+        /// Get the branch points for a method
+        /// </summary>
         MSG_GetBranchPoints = 3,
+
+        /// <summary>
+        /// Do we track this method (test methods only)
+        /// </summary>
         MSG_TrackMethod = 4,
+
+        /// <summary>
+        /// allocate a provate memory buffer for profiler/host communications
+        /// </summary>
         MSG_AllocateMemoryBuffer = 5,
+
+        /// <summary>
+        /// Close a channel between host and profiler
+        /// </summary>
         MSG_CloseChannel = 6,
+
+        /// <summary>
+        /// Do we track this process
+        /// </summary>
+        MSG_TrackProcess = 7,
     }
 
+    /// <summary>
+    /// The type of results
+    /// </summary>
     public enum MSG_IdType : uint
     {
+        /// <summary>
+        /// a basic coverage vist point
+        /// </summary>
         IT_VisitPoint = 0x00000000,
+
+        /// <summary>
+        /// A test method enter
+        /// </summary>
         IT_MethodEnter = 0x40000000,
+
+        /// <summary>
+        /// A test method exit
+        /// </summary>
         IT_MethodLeave = 0x80000000,
+
+        /// <summary>
+        /// A test method tail call
+        /// </summary>
         IT_MethodTailcall = 0xC0000000,
 
+        /// <summary>
+        /// A mask of the above
+        /// </summary>
         IT_Mask = 0x3FFFFFFF,
     }
 
+    /// <summary>
+    /// Track an assembly
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
     public struct MSG_TrackAssembly_Request
     {
+        /// <summary>
+        /// The message type
+        /// </summary>
         public MSG_Type type;
+
+        /// <summary>
+        /// The path to the process
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
+        public string processName;
+
+        /// <summary>
+        /// The path to the module/assembly
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string modulePath;
+
+        /// <summary>
+        /// The name of the module/assembly
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string assemblyName;
     }
 
+    /// <summary>
+    /// The response to a <see cref="MSG_TrackAssembly_Request"/>
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_TrackAssembly_Response
     {
+        /// <summary>
+        /// True - if the assembly has instrumentable code
+        /// </summary>
         [MarshalAs(UnmanagedType.Bool)]
         public bool track;
     }
 
+    /// <summary>
+    /// Get the sequence points for a method
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
     public struct MSG_GetSequencePoints_Request
     {
+        /// <summary>
+        /// The type of message
+        /// </summary>
         public MSG_Type type;
+
+        /// <summary>
+        /// The token of the method
+        /// </summary>
         public int functionToken;
+
+        /// <summary>
+        /// The path to the process
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
+        public string processName;
+
+        /// <summary>
+        /// The path to the module hosting the emthod
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string modulePath;
+
+        /// <summary>
+        /// The name of the module/assembly hosting the method
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string assemblyName;
     }
 
+    /// <summary>
+    /// Defines a seqence point
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_SequencePoint
     {
+        /// <summary>
+        /// The identifier of the sequence point
+        /// </summary>
         public uint uniqueId;
+
+        /// <summary>
+        /// The original IL offset of where the sequence pont should be placed
+        /// </summary>
         public int offset;
     }
 
+    /// <summary>
+    /// The response to a <see cref="MSG_GetSequencePoints_Request"/>
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_GetSequencePoints_Response
     {
+        /// <summary>
+        /// Do we have more data
+        /// </summary>
         [MarshalAs(UnmanagedType.Bool)]
         public bool more;
 
+        /// <summary>
+        /// The number of sequence points that follow
+        /// </summary>
         public int count;
     }
 
+    /// <summary>
+    /// Get the branch points of a method
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
     public struct MSG_GetBranchPoints_Request
     {
+        /// <summary>
+        /// The type of message
+        /// </summary>
         public MSG_Type type;
+
+        /// <summary>
+        /// The token of the method
+        /// </summary>
         public int functionToken;
+
+        /// <summary>
+        /// The path to the process
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
+        public string processName;
+
+        /// <summary>
+        /// The path to the module hosting the emthod
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string modulePath;
+
+        /// <summary>
+        /// The name of the module/assembly hosting the method
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string assemblyName;
     }
 
+    /// <summary>
+    /// Defines a branch point
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_BranchPoint
     {
+        /// <summary>
+        /// The uniqueid of the branch point
+        /// </summary>
         public uint uniqueId;
+
+        /// <summary>
+        /// The original IL offset of the branch instruction to be instrumented
+        /// </summary>
         public int offset;
+
+        /// <summary>
+        /// Which of the paths T/F or switch that the point is intending to cover.
+        /// </summary>
         public int path;
     }
 
+    /// <summary>
+    /// The response to a <see cref="MSG_GetBranchPoints_Request"/>
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_GetBranchPoints_Response
     {
+        /// <summary>
+        /// Do we have more data
+        /// </summary>
         [MarshalAs(UnmanagedType.Bool)]
         public bool more;
 
+        /// <summary>
+        /// The number of branch points that follow
+        /// </summary>
         public int count;
     }
 
+    /// <summary>
+    /// Should we track this method
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
     public struct MSG_TrackMethod_Request
     {
+        /// <summary>
+        /// The type of message
+        /// </summary>
         public MSG_Type type;
+
+        /// <summary>
+        /// The token of the method under test
+        /// </summary>
         public int functionToken;
+
+        /// <summary>
+        /// Te path to the module
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string modulePath;
+
+        /// <summary>
+        /// The name of the assemby/module
+        /// </summary>
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
         public string assemblyName;
     }
 
+    /// <summary>
+    /// the response to a <see cref="MSG_TrackMethod_Request"/>
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_TrackMethod_Response
     {
+        /// <summary>
+        /// True - the method should be tracked
+        /// </summary>
         [MarshalAs(UnmanagedType.Bool)]
         public bool track;
+
+        /// <summary>
+        /// The uniqueid assigned to the method
+        /// </summary>
         public uint uniqueId;
     }
 
+    /// <summary>
+    /// Request to allocate a buffer
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
     public struct MSG_AllocateBuffer_Request
     {
+        /// <summary>
+        /// The type of message
+        /// </summary>
         public MSG_Type type;
+
+        /// <summary>
+        /// The buffer size
+        /// </summary>
         public int bufferSize;
     }
 
+    /// <summary>
+    /// The response to a <see cref="MSG_AllocateBuffer_Request"/>
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_AllocateBuffer_Response
     {
@@ -133,18 +343,66 @@ public struct MSG_AllocateBuffer_Response
         public uint bufferId;
     }
 
+    /// <summary>
+    /// A close channel request
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
     public struct MSG_CloseChannel_Request
     {
+        /// <summary>
+        /// The type of message
+        /// </summary>
         public MSG_Type type;
+
+        /// <summary>
+        /// The id of the buffer to close
+        /// </summary>
         public uint bufferId;
     }
 
+    /// <summary>
+    /// The response to a <see cref="MSG_CloseChannel_Request"/>
+    /// </summary>
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct MSG_CloseChannel_Response
     {
+        /// <summary>
+        /// The buffer should be cleared.
+        /// </summary>
         [MarshalAs(UnmanagedType.Bool)]
         public bool done;
     }
 
+    /// <summary>
+    /// Track an assembly
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
+    public struct MSG_TrackProcess_Request
+    {
+        /// <summary>
+        /// The message type
+        /// </summary>
+        public MSG_Type type;
+
+        /// <summary>
+        /// The path to the process
+        /// </summary>
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
+        public string processName;
+    }
+
+    /// <summary>
+    /// The response to a <see cref="MSG_TrackProcess_Request"/>
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct MSG_TrackProcess_Response
+    {
+        /// <summary>
+        /// True - if the assembly has instrumentable code
+        /// </summary>
+        [MarshalAs(UnmanagedType.Bool)]
+        public bool track;
+    }
+    // ReSharper restore InconsistentNaming
+
 }
diff --git a/main/OpenCover.Framework/Filter.cs b/main/OpenCover.Framework/Filter.cs
index e15e47d78..1501cb276 100644
--- a/main/OpenCover.Framework/Filter.cs
+++ b/main/OpenCover.Framework/Filter.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
@@ -25,6 +26,7 @@ public class Filter : IFilter
         internal IList<RegexFilter> ExcludedFiles { get; private set; }
         internal IList<RegexFilter> TestFiles { get; private set; }
         public bool RegExFilters { get; private set; }
+        
 
         /// <summary>
         /// Standard constructor
@@ -40,10 +42,11 @@ public Filter(bool useRegexFilters = false)
             RegExFilters = useRegexFilters;
         }
 
-        public bool UseAssembly(string assemblyName)
+        public bool UseAssembly(string processName, string assemblyName)
         {
+            processName = Path.GetFileNameWithoutExtension(processName);
             var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
-            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*"))
+            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*" && exclusionFilter.IsMatchingProcessName(processName)))
             {
                 return false;
             }
@@ -62,15 +65,16 @@ public bool UseAssembly(string assemblyName)
             return false;
         }
 
-        public bool InstrumentClass(string assemblyName, string className)
+        public bool InstrumentClass(string processName, string assemblyName, string className)
         {
-            if (string.IsNullOrEmpty(assemblyName) || string.IsNullOrEmpty(className))
+            if (string.IsNullOrEmpty(processName) || string.IsNullOrEmpty(assemblyName) || string.IsNullOrEmpty(className))
             {
                 return false;
             }
 
+            processName = Path.GetFileNameWithoutExtension(processName);
             var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForAssemblyName(assemblyName);
-            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*"))
+            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.ClassName == ".*" && exclusionFilter.IsMatchingProcessName(processName)))
             {
                 return false;
             }
@@ -91,20 +95,28 @@ public bool InstrumentClass(string assemblyName, string className)
             return false;
         }
 
+
+        public bool InstrumentClass(string assemblyName, string className)
+        {
+            return InstrumentClass(Guid.NewGuid().ToString(), assemblyName, className);
+        }
+
         public void AddFilter(string assemblyClassName)
         {
             string assemblyName;
             string className;
+            string processName;
             FilterType filterType;
-            GetAssemblyClassName(assemblyClassName, RegExFilters, out filterType, out assemblyName, out className);
+            GetAssemblyClassName(assemblyClassName, RegExFilters, out filterType, out assemblyName, out className, out processName);
 
             if (!RegExFilters)
             {
+                processName = (string.IsNullOrEmpty(processName) ? "*" : processName).ValidateAndEscape();
                 assemblyName = assemblyName.ValidateAndEscape();
                 className = className.ValidateAndEscape();
             }
 
-            var filter = new AssemblyAndClassFilter(assemblyName, className);
+            var filter = new AssemblyAndClassFilter(processName, assemblyName, className);
             if (filterType == FilterType.Inclusion)
                 InclusionFilters.Add(filter);
 
@@ -112,13 +124,13 @@ public void AddFilter(string assemblyClassName)
                 ExclusionFilters.Add(filter);
         }
 
-        private static void GetAssemblyClassName(string assemblyClassName, bool useRegEx, out FilterType filterType, out string assemblyName, out string className)
+        private static void GetAssemblyClassName(string assemblyClassName, bool useRegEx, out FilterType filterType, out string assemblyName, out string className, out string processName)
         {
             className = string.Empty;
             assemblyName = string.Empty;
-            var regEx = new Regex(@"^(?<type>([+-]))(\[(?<assembly>(.+))\])(?<class>(.*))?$");
+            var regEx = new Regex(@"^(?<type>([+-]))(\{(?<process>(.+))\})?(\[(?<assembly>(.+))\])(?<class>(.+))$");
             if (useRegEx)
-                regEx = new Regex(@"^(?<type>([+-]))(\[\((?<assembly>(.+))\)\])(\((?<class>(.*))\))?$");
+                regEx = new Regex(@"^(?<type>([+-]))(\{\((?<process>(.+))\)\})?(\[\((?<assembly>(.+))\)\])(\((?<class>(.+))\))$");
 
             var match = regEx.Match(assemblyClassName);
             if (match.Success)
@@ -126,6 +138,7 @@ private static void GetAssemblyClassName(string assemblyClassName, bool useRegEx
                 filterType = match.Groups["type"].Value.ParseFilterType();
                 assemblyName = match.Groups["assembly"].Value;
                 className = match.Groups["class"].Value;
+                processName = match.Groups["process"].Value;
 
                 if (string.IsNullOrWhiteSpace(assemblyName))
                     throw InvalidFilterFormatException(assemblyClassName);
@@ -237,6 +250,24 @@ public bool IsAutoImplementedProperty(MethodDefinition method)
             return false;
         }
 
+        public bool InstrumentProcess(string processName)
+        {
+            if (string.IsNullOrEmpty(processName))
+            {
+                return false;
+            }
+
+            processName = Path.GetFileNameWithoutExtension(processName);
+            var matchingExclusionFilters = ExclusionFilters.GetMatchingFiltersForProcessName(processName);
+            if (matchingExclusionFilters.Any(exclusionFilter => exclusionFilter.AssemblyName == ".*" && exclusionFilter.ClassName == ".*"))
+            {
+                return false;
+            }
+
+            var matchingInclusionFilters = InclusionFilters.GetMatchingFiltersForProcessName(processName);
+            return matchingInclusionFilters.Any(inclusionFilter => inclusionFilter.AssemblyName == ".*" || inclusionFilter.ClassName == ".*");
+        }
+
         /// <summary>
         /// Create a filter entity from parser parameters
         /// </summary>
diff --git a/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs b/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs
index f4e6dbf85..78101c217 100644
--- a/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs
+++ b/main/OpenCover.Framework/Filtering/AssemblyAndClassFilter.cs
@@ -7,28 +7,38 @@ namespace OpenCover.Framework.Filtering
 {
     internal class AssemblyAndClassFilter
     {
-        private readonly RegexFilter assemblyNameFilter;
+        private readonly RegexFilter _processNameFilter;
 
-        private readonly RegexFilter classNameFilter;
+        private readonly RegexFilter _assemblyNameFilter;
 
-        internal string AssemblyName { get { return assemblyNameFilter.FilterExpression; } }
+        private readonly RegexFilter _classNameFilter;
 
-        internal string ClassName { get { return classNameFilter.FilterExpression; } }
+        internal string ProcessName { get { return _processNameFilter.FilterExpression; } }
 
-        internal AssemblyAndClassFilter(string assemblyName, string className)
+        internal string AssemblyName { get { return _assemblyNameFilter.FilterExpression; } }
+
+        internal string ClassName { get { return _classNameFilter.FilterExpression; } }
+
+        internal AssemblyAndClassFilter(string processName, string assemblyName, string className)
+        {
+            _processNameFilter = new RegexFilter(processName);
+            _assemblyNameFilter = new RegexFilter(assemblyName);
+            _classNameFilter = new RegexFilter(className);
+        }
+
+        internal bool IsMatchingProcessName(string processName)
         {
-            assemblyNameFilter = new RegexFilter(assemblyName);
-            classNameFilter = new RegexFilter(className);
+            return _processNameFilter.IsMatchingExpression(processName);
         }
 
         internal bool IsMatchingAssemblyName(string assemblyName)
         {
-            return assemblyNameFilter.IsMatchingExpression(assemblyName);
+            return _assemblyNameFilter.IsMatchingExpression(assemblyName);
         }
 
         internal bool IsMatchingClassName(string className)
         {
-            return classNameFilter.IsMatchingExpression(className);
+            return _classNameFilter.IsMatchingExpression(className);
         }
     }
 
diff --git a/main/OpenCover.Framework/Filtering/FilterHelper.cs b/main/OpenCover.Framework/Filtering/FilterHelper.cs
index b2ad0b24a..a00ff084c 100644
--- a/main/OpenCover.Framework/Filtering/FilterHelper.cs
+++ b/main/OpenCover.Framework/Filtering/FilterHelper.cs
@@ -22,8 +22,24 @@ internal static string ValidateAndEscape(this string match, string notAllowed =
 
         internal static IList<AssemblyAndClassFilter> GetMatchingFiltersForAssemblyName(this IEnumerable<AssemblyAndClassFilter> filters, string assemblyName)
         {
-            var matchingFilters =
-                filters.Where(filter => filter.IsMatchingAssemblyName(assemblyName)).ToList();
+            var matchingFilters = filters
+                .Where(filter => filter.IsMatchingAssemblyName(assemblyName)).ToList();
+            return matchingFilters;
+        }
+
+        internal static IList<AssemblyAndClassFilter> GetMatchingFiltersForProcessName(this IEnumerable<AssemblyAndClassFilter> filters, string processName)
+        {
+            var matchingFilters = filters
+                .Where(filter => filter.IsMatchingProcessName(processName)).ToList();
+            return matchingFilters;
+        }
+
+        internal static IList<AssemblyAndClassFilter> GetMatchingFiltersForProcessAssemblyName(this IEnumerable<AssemblyAndClassFilter> filters, string processName, string assemblyName)
+        {
+            var matchingFilters = filters
+                .Where(filter => filter.IsMatchingProcessName(processName))
+                .Where(filter => filter.IsMatchingAssemblyName(assemblyName))
+                .ToList();
             return matchingFilters;
         }
 
diff --git a/main/OpenCover.Framework/IFilter.cs b/main/OpenCover.Framework/IFilter.cs
index 6657b0d7a..af676813f 100644
--- a/main/OpenCover.Framework/IFilter.cs
+++ b/main/OpenCover.Framework/IFilter.cs
@@ -18,10 +18,11 @@ public interface IFilter
         /// <summary>
         /// Decides whether an assembly should be included in the instrumentation
         /// </summary>
+        /// <param name="processName">The name of the process being profiled</param>
         /// <param name="assemblyName">the name of the assembly under profile</param>
         /// <remarks>All assemblies matching either the inclusion or exclusion filter should be included 
         /// as it is the class that is being filtered within these unless the class filter is *</remarks>
-        bool UseAssembly(string assemblyName);
+        bool UseAssembly(string processName, string assemblyName);
 
         /// <summary>
         /// Decides whether an assembly should be analysed for test methods
@@ -44,6 +45,16 @@ public interface IFilter
         /// <returns>false - if pair matches the exclusion filter or matches no filters, true - if pair matches in the inclusion filter</returns>
         bool InstrumentClass(string assemblyName, string className);
 
+        /// <summary>
+        /// Determine if an [assemblyname]classname pair matches the current Exclusion or Inclusion filters  
+        /// </summary>
+        /// <param name="processName">The name of the process</param>
+        /// <param name="assemblyName">the name of the assembly under profile</param>
+        /// <param name="className">the name of the class under profile</param>
+        /// <returns>false - if pair matches the exclusion filter or matches no filters, true - if pair matches in the inclusion filter</returns>
+        bool InstrumentClass(string processName, string assemblyName, string className);
+
+
         /// <summary>
         /// Add attribute exclusion filters
         /// </summary>
@@ -88,6 +99,13 @@ public interface IFilter
         /// filters should be treated as regular expressions rather than wildcard
         /// </summary>
         bool RegExFilters { get; }
+
+        /// <summary>
+        /// Should we instrument this asssembly
+        /// </summary>
+        /// <param name="processName"></param>
+        /// <returns></returns>
+        bool InstrumentProcess(string processName);
     }
 
 }
diff --git a/main/OpenCover.Framework/Manager/IManagedCommunicationBlock.cs b/main/OpenCover.Framework/Manager/IManagedCommunicationBlock.cs
index 056d59e57..d2cefcc2c 100644
--- a/main/OpenCover.Framework/Manager/IManagedCommunicationBlock.cs
+++ b/main/OpenCover.Framework/Manager/IManagedCommunicationBlock.cs
@@ -5,13 +5,39 @@
 
 namespace OpenCover.Framework.Manager
 {
+    /// <summary>
+    /// Define a command communication interface
+    /// </summary>
     public interface IManagedCommunicationBlock : IDisposable
     {
+        /// <summary>
+        /// The communication data
+        /// </summary>
         MemoryMappedViewStream StreamAccessorComms { get; }
+
+        /// <summary>
+        /// Signalled by the profiler when the profiler wants some information
+        /// </summary>
         EventWaitHandle ProfilerRequestsInformation { get; }
+
+        /// <summary>
+        /// Signalled by the host when the data requested is available
+        /// </summary>
         EventWaitHandle InformationReadyForProfiler { get; }
+
+        /// <summary>
+        /// signalled by the profiler when te data has been read by the profiler
+        /// </summary>
         EventWaitHandle InformationReadByProfiler { get; }
+
+        /// <summary>
+        /// The data being communicated
+        /// </summary>
         byte[] DataCommunication { get; }
+
+        /// <summary>
+        /// A handle to the pinned data
+        /// </summary>
         GCHandle PinnedDataCommunication { get; }
     }
 }
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Manager/IManagedMemoryBlock.cs b/main/OpenCover.Framework/Manager/IManagedMemoryBlock.cs
index 430da6513..33d65f536 100644
--- a/main/OpenCover.Framework/Manager/IManagedMemoryBlock.cs
+++ b/main/OpenCover.Framework/Manager/IManagedMemoryBlock.cs
@@ -4,12 +4,34 @@
 
 namespace OpenCover.Framework.Manager
 {
+    /// <summary>
+    /// Define a results communication interface
+    /// </summary>
     public interface IManagedMemoryBlock : IDisposable
     {
+        /// <summary>
+        /// Signalled by profiler when the profiler has results
+        /// </summary>
         EventWaitHandle ProfilerHasResults { get; }
+
+        /// <summary>
+        /// Signalled by host when results ahve been read
+        /// </summary>
         EventWaitHandle ResultsHaveBeenReceived { get; }
+
+        /// <summary>
+        /// Access the results
+        /// </summary>
         MemoryMappedViewStream StreamAccessorResults { get; }
+
+        /// <summary>
+        /// Get the buffer size
+        /// </summary>
         int BufferSize { get; }
+
+        /// <summary>
+        /// Get the buffer
+        /// </summary>
         byte[] Buffer { get; }
     }
 }
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Manager/IMemoryManager.cs b/main/OpenCover.Framework/Manager/IMemoryManager.cs
index 48e65ad93..83c3a32b5 100644
--- a/main/OpenCover.Framework/Manager/IMemoryManager.cs
+++ b/main/OpenCover.Framework/Manager/IMemoryManager.cs
@@ -4,24 +4,75 @@
 
 namespace OpenCover.Framework.Manager
 {
+    /// <summary>
+    /// Defines the buffer between the host and a profiler instance 
+    /// </summary>
     public class ManagedBufferBlock
     {
+        /// <summary>
+        /// Defines the buffer between the host and a profiler instance 
+        /// </summary>
         public ManagedBufferBlock()
         {
             Active = true;
         }
+
+        /// <summary>
+        /// A communication block is where all commands are sent from profiler to host 
+        /// </summary>
         public IManagedCommunicationBlock CommunicationBlock { get; set; }
+
+        /// <summary>
+        /// A memory block is were the results are sent
+        /// </summary>
         public IManagedMemoryBlock MemoryBlock { get; set; }
+
+        /// <summary>
+        /// The buffer identifier
+        /// </summary>
         public uint BufferId { get; set; }
+
+        /// <summary>
+        /// Is the block still active?
+        /// </summary>
         public bool Active { get; set; }
     }
 
+    /// <summary>
+    /// Defines the interface for a memory manager implementation
+    /// </summary>
     public interface IMemoryManager : IDisposable
     {
+        /// <summary>
+        /// Initialise a memory manager
+        /// </summary>
+        /// <param name="nameSpace"></param>
+        /// <param name="key"></param>
+        /// <param name="servicePrincipal"></param>
         void Initialise(string nameSpace, string key, IEnumerable<string> servicePrincipal);
+
+        /// <summary>
+        /// Allocate a <see cref="ManagedBufferBlock"/> that is used to communicate between host and profiler
+        /// </summary>
+        /// <param name="bufferSize"></param>
+        /// <param name="bufferId"></param>
+        /// <returns></returns>
         ManagedBufferBlock AllocateMemoryBuffer(int bufferSize, out uint bufferId);
+
+        /// <summary>
+        /// Get the list of all allocated blocks
+        /// </summary>
         IList<ManagedBufferBlock> GetBlocks { get; }
+
+        /// <summary>
+        /// Deactivate a <see cref="ManagedBufferBlock"/>
+        /// </summary>
+        /// <param name="bufferId"></param>
         void DeactivateMemoryBuffer(uint bufferId);
+        
+        /// <summary>
+        /// Remove all deactivated blocks
+        /// </summary>
         void RemoveDeactivatedBlocks();
     }
 }
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Manager/MemoryManager.cs b/main/OpenCover.Framework/Manager/MemoryManager.cs
index 7115905ef..c97604ef1 100644
--- a/main/OpenCover.Framework/Manager/MemoryManager.cs
+++ b/main/OpenCover.Framework/Manager/MemoryManager.cs
@@ -57,6 +57,8 @@ internal class ManagedMemoryBlock : ManagedBlock, IManagedMemoryBlock
             public int BufferSize { get; private set; }
             public byte[] Buffer { get; private set; }
 
+            private readonly Semaphore _semaphore; 
+
             /// <summary>
             /// Gets an ACL for unit test purposes
             /// </summary>
@@ -72,46 +74,56 @@ internal ManagedMemoryBlock(string @namespace, string key, int bufferSize, int b
                 Namespace = @namespace;
                 Key = key;
 
-                EventWaitHandleSecurity open = null;
-                MemoryMappedFileSecurity transparent = null;
+                EventWaitHandleSecurity handleSecurity = null;
+                MemoryMappedFileSecurity memSecurity = null;
+                SemaphoreSecurity semaphoreSecurity = null;
 
-                var service = servicePrincpal.FirstOrDefault();
+                var serviceIdentity = servicePrincpal.FirstOrDefault();
                 var currentIdentity = WindowsIdentity.GetCurrent();
-                if (service != null && currentIdentity != null)
+                if (serviceIdentity != null && currentIdentity != null)
                 {
-                    open = new EventWaitHandleSecurity();
-                    open.AddAccessRule(new EventWaitHandleAccessRule(currentIdentity.Name, EventWaitHandleRights.FullControl, AccessControlType.Allow));
+                    handleSecurity = new EventWaitHandleSecurity();
+                    handleSecurity.AddAccessRule(new EventWaitHandleAccessRule(currentIdentity.Name, EventWaitHandleRights.FullControl, AccessControlType.Allow));
 
                     // The event handles need more than just EventWaitHandleRights.Modify | EventWaitHandleRights.Synchronize to work
-                    open.AddAccessRule(new EventWaitHandleAccessRule(service, EventWaitHandleRights.FullControl, AccessControlType.Allow));
+                    handleSecurity.AddAccessRule(new EventWaitHandleAccessRule(serviceIdentity, EventWaitHandleRights.FullControl, AccessControlType.Allow));
+
+                    memSecurity = new MemoryMappedFileSecurity();
+                    memSecurity.AddAccessRule(new AccessRule<MemoryMappedFileRights>(currentIdentity.Name, MemoryMappedFileRights.FullControl, AccessControlType.Allow));
+                    memSecurity.AddAccessRule(new AccessRule<MemoryMappedFileRights>(serviceIdentity, MemoryMappedFileRights.ReadWrite, AccessControlType.Allow));
 
-                    transparent = new MemoryMappedFileSecurity();
-                    transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(currentIdentity.Name, MemoryMappedFileRights.FullControl, AccessControlType.Allow));
-                    transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(service, MemoryMappedFileRights.ReadWrite, AccessControlType.Allow));
+                    semaphoreSecurity = new SemaphoreSecurity();
+                    semaphoreSecurity.AddAccessRule(new SemaphoreAccessRule(currentIdentity.Name, SemaphoreRights.FullControl, AccessControlType.Allow));
+                    semaphoreSecurity.AddAccessRule(new SemaphoreAccessRule(serviceIdentity, SemaphoreRights.FullControl, AccessControlType.Allow));
                 }
 
                 bool createdNew;
 
                 ProfilerHasResults = new EventWaitHandle(
                     false,
-                    EventResetMode.ManualReset, 
-                    MakeName(@"\OpenCover_Profiler_Communication_SendResults_Event_", bufferId),
+                    EventResetMode.ManualReset,
+                    MakeName(@"\OpenCover_Profiler_Results_SendResults_Event_", bufferId),
                     out createdNew,
-                    open);
+                    handleSecurity);
 
                 ResultsHaveBeenReceived = new EventWaitHandle(
                     false, 
-                    EventResetMode.ManualReset, 
-                    MakeName(@"\OpenCover_Profiler_Communication_ReceiveResults_Event_", bufferId),
+                    EventResetMode.ManualReset,
+                    MakeName(@"\OpenCover_Profiler_Results_ReceiveResults_Event_", bufferId),
                     out createdNew,
-                    open);
+                    handleSecurity);
+
+                _semaphore = new Semaphore(0, 2, 
+                    MakeName(@"\OpenCover_Profiler_Results_Semaphore_", bufferId), 
+                    out createdNew,
+                    semaphoreSecurity);
 
                 _mmfResults = MemoryMappedFile.CreateNew(
                     MakeName(@"\OpenCover_Profiler_Results_MemoryMapFile_", bufferId),
                     bufferSize,
                     MemoryMappedFileAccess.ReadWrite,
                     MemoryMappedFileOptions.None,
-                    transparent,
+                    memSecurity,
                     HandleInheritability.Inheritable);
 
                 Buffer = new byte[bufferSize];
@@ -124,9 +136,15 @@ internal ManagedMemoryBlock(string @namespace, string key, int bufferSize, int b
 
             public void Dispose()
             {
-                Debug.WriteLine("*** disposing memory block ***");
-                StreamAccessorResults.Dispose();
-                _mmfResults.Dispose();
+                _semaphore.Do(s =>
+                {
+                    s.Release(1);
+                    s.Dispose();
+                });
+                ProfilerHasResults.Do(e => e.Dispose());
+                ResultsHaveBeenReceived.Do(e => e.Dispose());
+                StreamAccessorResults.Do(r => r.Dispose());
+                _mmfResults.Do(r => r.Dispose());
             }
         }
 
@@ -143,6 +161,7 @@ internal class ManagedCommunicationBlock : ManagedBlock, IManagedCommunicationBl
             public byte[] DataCommunication { get; private set; }
             public GCHandle PinnedDataCommunication { get; private set; }
 
+            private readonly Semaphore _semaphore; 
             /// <summary>
             /// Gets an ACL for unit test purposes
             /// </summary>
@@ -159,31 +178,26 @@ internal ManagedCommunicationBlock(string @namespace, string key, int bufferSize
                 Namespace = @namespace;
                 Key = key;
 
-                EventWaitHandleSecurity open = null;
-                MemoryMappedFileSecurity transparent = null;
+                EventWaitHandleSecurity eventSecurity = null;
+                MemoryMappedFileSecurity memorySecurity = null;
 
-                var service = servicePrincpal.FirstOrDefault();
+                var serviceIdentity = servicePrincpal.FirstOrDefault();
                 var currentIdentity = WindowsIdentity.GetCurrent();
-                if (service != null && currentIdentity != null)
+                SemaphoreSecurity semaphoreSecurity = null;
+                if (serviceIdentity != null && currentIdentity != null)
                 {
-                    open = new EventWaitHandleSecurity();
-                    open.AddAccessRule(new EventWaitHandleAccessRule(currentIdentity.Name, EventWaitHandleRights.FullControl, AccessControlType.Allow));
-                    open.AddAccessRule(new EventWaitHandleAccessRule(service, EventWaitHandleRights.FullControl, AccessControlType.Allow));
+                    eventSecurity = new EventWaitHandleSecurity();
+                    eventSecurity.AddAccessRule(new EventWaitHandleAccessRule(currentIdentity.Name, EventWaitHandleRights.FullControl, AccessControlType.Allow));
+                    eventSecurity.AddAccessRule(new EventWaitHandleAccessRule(serviceIdentity, EventWaitHandleRights.FullControl, AccessControlType.Allow));
 
-                    transparent = new MemoryMappedFileSecurity();
-                    transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(currentIdentity.Name, MemoryMappedFileRights.FullControl, AccessControlType.Allow));
-                    transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(service, MemoryMappedFileRights.ReadWrite, AccessControlType.Allow));
-                }
-
-                _memoryMappedFile = MemoryMappedFile.CreateNew(
-                    MakeName(@"\OpenCover_Profiler_Communication_MemoryMapFile_", bufferId),
-                    bufferSize,
-                    MemoryMappedFileAccess.ReadWrite,
-                    MemoryMappedFileOptions.None,
-                    transparent,
-                    HandleInheritability.Inheritable);
+                    memorySecurity = new MemoryMappedFileSecurity();
+                    memorySecurity.AddAccessRule(new AccessRule<MemoryMappedFileRights>(currentIdentity.Name, MemoryMappedFileRights.FullControl, AccessControlType.Allow));
+                    memorySecurity.AddAccessRule(new AccessRule<MemoryMappedFileRights>(serviceIdentity, MemoryMappedFileRights.ReadWrite, AccessControlType.Allow));
 
-                StreamAccessorComms = _memoryMappedFile.CreateViewStream(0, bufferSize, MemoryMappedFileAccess.ReadWrite);
+                    semaphoreSecurity = new SemaphoreSecurity();
+                    semaphoreSecurity.AddAccessRule(new SemaphoreAccessRule(currentIdentity.Name, SemaphoreRights.FullControl, AccessControlType.Allow));
+                    semaphoreSecurity.AddAccessRule(new SemaphoreAccessRule(serviceIdentity, SemaphoreRights.FullControl, AccessControlType.Allow));
+                }
 
                 bool createdNew;
 
@@ -192,21 +206,36 @@ internal ManagedCommunicationBlock(string @namespace, string key, int bufferSize
                     EventResetMode.ManualReset,
                     MakeName(@"\OpenCover_Profiler_Communication_SendData_Event_", bufferId),
                     out createdNew,
-                    open);
+                    eventSecurity);
 
                 InformationReadyForProfiler = new EventWaitHandle(
                     false, 
                     EventResetMode.ManualReset,
                     MakeName(@"\OpenCover_Profiler_Communication_ReceiveData_Event_", bufferId),
                     out createdNew,
-                    open);
+                    eventSecurity);
 
                 InformationReadByProfiler = new EventWaitHandle(
                     false, 
                     EventResetMode.ManualReset,
                     MakeName(@"\OpenCover_Profiler_Communication_ChunkData_Event_", bufferId),
                     out createdNew,
-                    open);
+                    eventSecurity);
+
+                _semaphore = new Semaphore(0, 2,
+                    MakeName(@"\OpenCover_Profiler_Communication_Semaphore_", bufferId),
+                    out createdNew,
+                    semaphoreSecurity);
+
+                _memoryMappedFile = MemoryMappedFile.CreateNew(
+                    MakeName(@"\OpenCover_Profiler_Communication_MemoryMapFile_", bufferId),
+                    bufferSize,
+                    MemoryMappedFileAccess.ReadWrite,
+                    MemoryMappedFileOptions.None,
+                    memorySecurity,
+                    HandleInheritability.Inheritable);
+
+                StreamAccessorComms = _memoryMappedFile.CreateViewStream(0, bufferSize, MemoryMappedFileAccess.ReadWrite);
 
                 DataCommunication = new byte[bufferSize];
                 PinnedDataCommunication = GCHandle.Alloc(DataCommunication, GCHandleType.Pinned);
@@ -214,9 +243,16 @@ internal ManagedCommunicationBlock(string @namespace, string key, int bufferSize
 
             public void Dispose()
             {
-                Debug.WriteLine("*** disposing communication block ***");
-                StreamAccessorComms.Dispose();
-                _memoryMappedFile.Dispose();
+                _semaphore.Do(s =>
+                {
+                    s.Release(1);
+                    s.Dispose();
+                });
+                ProfilerRequestsInformation.Do(e => e.Dispose());
+                InformationReadyForProfiler.Do(e => e.Dispose());
+                InformationReadByProfiler.Do(e => e.Dispose());
+                StreamAccessorComms.Do(r => r.Dispose());
+                _memoryMappedFile.Do(f => f.Dispose());
                 PinnedDataCommunication.Free();
             }
         }
@@ -300,9 +336,8 @@ public void RemoveDeactivatedBlocks()
                 var list = _blocks.Where(b => !b.Active).ToList();
                 foreach (var b in list)
                 {
-                    Debug.WriteLine("*** removing deactivated ***");
-                    b.CommunicationBlock.Dispose();
-                    b.MemoryBlock.Dispose();
+                    b.CommunicationBlock.Do(x => x.Dispose());
+                    b.MemoryBlock.Do(x => x.Dispose());
                     _blocks.RemoveAt(_blocks.IndexOf(b));
                 }
             }
@@ -310,13 +345,12 @@ public void RemoveDeactivatedBlocks()
 
         public void Dispose()
         {
-            //Console.WriteLine("Disposing...");
             lock (_lockObject)
             {
-                foreach(var block in _blocks.Where(b => b.Active))
+                foreach(var block in _blocks)
                 {
-                    block.CommunicationBlock.Dispose();
-                    block.MemoryBlock.Dispose();
+                    block.CommunicationBlock.Do(x => x.Dispose());
+                    block.MemoryBlock.Do(x => x.Dispose());
                 }
                 _blocks.Clear();
             }
diff --git a/main/OpenCover.Framework/Manager/ProfilerManager.cs b/main/OpenCover.Framework/Manager/ProfilerManager.cs
index eb062f5f9..545776677 100644
--- a/main/OpenCover.Framework/Manager/ProfilerManager.cs
+++ b/main/OpenCover.Framework/Manager/ProfilerManager.cs
@@ -12,6 +12,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using log4net;
 using OpenCover.Framework.Communication;
 using OpenCover.Framework.Persistance;
 using OpenCover.Framework.Utility;
@@ -38,6 +39,8 @@ public class ProfilerManager : IProfilerManager
 
         private ConcurrentQueue<byte[]> _messageQueue;
 
+        private static readonly ILog DebugLogger = LogManager.GetLogger("DebugLogger");
+
         /// <summary>
         /// Create an instance of the profiler manager
         /// </summary>
@@ -56,6 +59,11 @@ public ProfilerManager(ICommunicationManager communicationManager, IPersistance
             _perfCounters = perfCounters;
         }
 
+        /// <summary>
+        /// Start the target process
+        /// </summary>
+        /// <param name="process"></param>
+        /// <param name="servicePrincipal"></param>
         public void RunProcess(Action<Action<StringDictionary>> process, string[] servicePrincipal)
         {
             var key = Guid.NewGuid().GetHashCode().ToString("X");
@@ -159,6 +167,11 @@ private WaitCallback SaveVisitData(EventWaitHandle queueMgmt)
             };
         }
 
+        /// <summary>
+        /// wait for how long
+        /// </summary>
+        internal static int BufferWaitCount = 30;
+
         private bool _continueWait = true;
 
         private void ProcessMessages(WaitHandle[] handles)
@@ -173,38 +186,58 @@ private void ProcessMessages(WaitHandle[] handles)
                         break;
 
                     case 1:
-                        _communicationManager.HandleCommunicationBlock(_mcb, block => threadHandles.Add(StartProcessingThread(block)));
+                        _communicationManager.HandleCommunicationBlock(_mcb,
+                            block => Task.Factory.StartNew(() =>
+                            {
+                                lock (threadHandles)
+                                {
+                                    threadHandles.Add(StartProcessingThread(block));
+                                }
+                            }));
                         break;
                 }
             } while (_continueWait);
 
+            // we need to let the profilers dump the thread buffers over before they close - max 15s (ish)
+            var i = 0;
+            while (i < BufferWaitCount && _memoryManager.GetBlocks.Any(b => b.Active))
+            {
+                DebugLogger.InfoFormat("Waiting for {0} processes to close", _memoryManager.GetBlocks.Count(b => b.Active));
+                Thread.Sleep(500);
+                i++;
+            }
+
+            // grab anything left in the main buffers
             foreach (var block in _memoryManager.GetBlocks.Where(b => b.Active).Select(b => b.MemoryBlock))
             {
                 var data = new byte[block.BufferSize];
                 block.StreamAccessorResults.Seek(0, SeekOrigin.Begin);
                 block.StreamAccessorResults.Read(data, 0, block.BufferSize);
-                _messageQueue.Enqueue(data);    
+                _messageQueue.Enqueue(data);
             }
 
-            if (threadHandles.Any())
+            lock (threadHandles)
             {
-                var tasks = threadHandles
-                    .Select((e, index) => new {Pair = e, Block = index / NumHandlesPerBlock})
-                    .GroupBy(g => g.Block)
-                    .Select(g => g.Select(a => a.Pair).ToList())
-                    .Select(g => Task.Factory.StartNew(() =>
-                    {
-                        g.Select(h => h.Item1).ToList().ForEach(h => h.Set());
-                        WaitHandle.WaitAll(g.Select(h => h.Item2).ToArray<WaitHandle>(), new TimeSpan(0, 0, 20));
-                    })).ToArray();
-                Task.WaitAll(tasks);
-
-                foreach(var threadHandle in threadHandles)
+                if (threadHandles.Any())
                 {
-                    threadHandle.Item1.Dispose();
-                    threadHandle.Item2.Dispose();
+                    var tasks = threadHandles
+                        .Select((e, index) => new {Pair = e, Block = index/NumHandlesPerBlock})
+                        .GroupBy(g => g.Block)
+                        .Select(g => g.Select(a => a.Pair).ToList())
+                        .Select(g => Task.Factory.StartNew(() =>
+                        {
+                            g.Select(h => h.Item1).ToList().ForEach(h => h.Set());
+                            WaitHandle.WaitAll(g.Select(h => h.Item2).ToArray<WaitHandle>(), new TimeSpan(0, 0, 20));
+                        })).ToArray();
+                    Task.WaitAll(tasks);
+
+                    foreach (var threadHandle in threadHandles)
+                    {
+                        threadHandle.Item1.Dispose();
+                        threadHandle.Item2.Dispose();
+                    }
+                    threadHandles.Clear();
                 }
-                threadHandles.Clear();
             }
 
             _messageQueue.Enqueue(new byte[0]);
@@ -212,6 +245,7 @@ private void ProcessMessages(WaitHandle[] handles)
 
         private Tuple<EventWaitHandle, EventWaitHandle> StartProcessingThread(ManagedBufferBlock block)
         {
+            DebugLogger.InfoFormat("Starting Process Block => {0}", block.BufferId);
             var terminateThread = new ManualResetEvent(false);
             var threadTerminated = new ManualResetEvent(false);
 
@@ -221,6 +255,7 @@ private Tuple<EventWaitHandle, EventWaitHandle> StartProcessingThread(ManagedBuf
                     threadActivated, threadTerminated));
                 threadActivated.WaitOne();
             }
+            DebugLogger.InfoFormat("Started Process Block => {0}", block.BufferId);
             return new Tuple<EventWaitHandle, EventWaitHandle>(terminateThread, threadTerminated);
         }
 
diff --git a/main/OpenCover.Framework/Model/IInstrumentationModelBuilderFactory.cs b/main/OpenCover.Framework/Model/IInstrumentationModelBuilderFactory.cs
index a0fe927be..7a917c16d 100644
--- a/main/OpenCover.Framework/Model/IInstrumentationModelBuilderFactory.cs
+++ b/main/OpenCover.Framework/Model/IInstrumentationModelBuilderFactory.cs
@@ -4,13 +4,19 @@
 // This source code is released under the MIT License; see the accompanying license file.
 //
 
-using System.Collections.Generic;
-using OpenCover.Framework.Strategy;
-
 namespace OpenCover.Framework.Model
 {
+    /// <summary>
+    /// Define the model builder factory
+    /// </summary>
     public interface IInstrumentationModelBuilderFactory
     {
+        /// <summary>
+        /// Create a model builder for a module
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="moduleName"></param>
+        /// <returns></returns>
         IInstrumentationModelBuilder CreateModelBuilder(string modulePath, string moduleName);
     }
 }
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Model/InstrumentationModelBuilderFactory.cs b/main/OpenCover.Framework/Model/InstrumentationModelBuilderFactory.cs
index 60eca7e86..160356ea9 100644
--- a/main/OpenCover.Framework/Model/InstrumentationModelBuilderFactory.cs
+++ b/main/OpenCover.Framework/Model/InstrumentationModelBuilderFactory.cs
@@ -4,14 +4,15 @@
 // This source code is released under the MIT License; see the accompanying license file.
 //
 
-using System.Collections.Generic;
-using System.Linq;
 using OpenCover.Framework.Strategy;
 using OpenCover.Framework.Symbols;
 using log4net;
 
 namespace OpenCover.Framework.Model
 {
+    /// <summary>
+    /// Implement a model builder factory
+    /// </summary>
     public class InstrumentationModelBuilderFactory : IInstrumentationModelBuilderFactory
     {
         private readonly ICommandLine _commandLine;
@@ -19,6 +20,13 @@ public class InstrumentationModelBuilderFactory : IInstrumentationModelBuilderFa
         private readonly ILog _logger;
         private readonly ITrackedMethodStrategyManager _trackedMethodStrategyManager;
 
+        /// <summary>
+        /// Instantiate a model builder factory
+        /// </summary>
+        /// <param name="commandLine"></param>
+        /// <param name="filter"></param>
+        /// <param name="logger"></param>
+        /// <param name="trackedMethodStrategyManager"></param>
         public InstrumentationModelBuilderFactory(ICommandLine commandLine, IFilter filter, ILog logger, ITrackedMethodStrategyManager trackedMethodStrategyManager)
         {
             _commandLine = commandLine;
diff --git a/main/OpenCover.Framework/Persistance/BasePersistance.cs b/main/OpenCover.Framework/Persistance/BasePersistance.cs
index 79e57e234..d09e25b1b 100644
--- a/main/OpenCover.Framework/Persistance/BasePersistance.cs
+++ b/main/OpenCover.Framework/Persistance/BasePersistance.cs
@@ -15,7 +15,9 @@ public abstract class BasePersistance : IPersistance
         protected readonly ICommandLine CommandLine;
         private readonly ILog _logger;
         private uint _trackedMethodId;
-        private readonly Dictionary<Module, Dictionary<int, KeyValuePair<Class, Method>>> _moduleMethodMap = new Dictionary<Module, Dictionary<int, KeyValuePair<Class, Method>>>(); 
+        private readonly Dictionary<Module, Dictionary<int, KeyValuePair<Class, Method>>> _moduleMethodMap = new Dictionary<Module, Dictionary<int, KeyValuePair<Class, Method>>>();
+
+        private static readonly ILog DebugLogger = LogManager.GetLogger("DebugLogger");
 
         /// <summary>
         /// constructor
@@ -25,13 +27,20 @@ public abstract class BasePersistance : IPersistance
         protected BasePersistance(ICommandLine commandLine, ILog logger)
         {
             CommandLine = commandLine;
-            _logger = logger;
+            _logger = logger ?? DebugLogger;
             CoverageSession = new CoverageSession();
             _trackedMethodId = 0;
         }
 
+        /// <summary>
+        /// A coverage session
+        /// </summary>
         public CoverageSession CoverageSession { get; private set; }
 
+        /// <summary>
+        /// Add the <see cref="Module"/> to the current session
+        /// </summary>
+        /// <param name="module"></param>
         public void PersistModule(Module module)
         {
             if (module == null) return;
@@ -56,6 +65,9 @@ public void PersistModule(Module module)
             CoverageSession.Modules = list.ToArray();
         }
 
+        /// <summary>
+        /// Clear the current coverage session data
+        /// </summary>
         protected void ClearCoverageSession()
         {
             _moduleMethodMap.Clear();
@@ -374,7 +386,7 @@ from method in @class.Methods.Where(x => !x.ShouldSerializeSkippedDueTo())
                         @class.Summary.MaxCyclomaticComplexity = Math.Max(@class.Summary.MaxCyclomaticComplexity, method.CyclomaticComplexity);
                     }
 
-                    @class.Summary.NumClasses = (@class.Summary.NumMethods > 0) ? 1 : 0; ;
+                    @class.Summary.NumClasses = (@class.Summary.NumMethods > 0) ? 1 : 0; 
                     @class.Summary.VisitedClasses = (@class.Summary.VisitedMethods > 0) ? 1 : 0;
 
                     AddPoints(module.Summary, @class.Summary);
@@ -434,6 +446,13 @@ private static void AddPoints(Summary parent, Summary child)
             parent.VisitedMethods += child.VisitedMethods;
         }
 
+        /// <summary>
+        /// Get the sequence points for a function
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="sequencePoints"></param>
+        /// <returns></returns>
         public bool GetSequencePointsForFunction(string modulePath, int functionToken, out InstrumentationPoint[] sequencePoints)
         {
             sequencePoints = new InstrumentationPoint[0];
@@ -452,6 +471,13 @@ public bool GetSequencePointsForFunction(string modulePath, int functionToken, o
             return false;      
         }
 
+        /// <summary>
+        /// Get the branch ponts for a function
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="branchPoints"></param>
+        /// <returns></returns>
         public bool GetBranchPointsForFunction(string modulePath, int functionToken, out BranchPoint[] branchPoints)
         {
             branchPoints = new BranchPoint[0];
@@ -466,6 +492,13 @@ public bool GetBranchPointsForFunction(string modulePath, int functionToken, out
             return false;
         }
 
+        /// <summary>
+        /// Get <see cref="Method"/> data for a function
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="class"></param>
+        /// <returns></returns>
         private Method GetMethod(string modulePath, int functionToken, out Class @class)
         {
             @class = null;
@@ -479,6 +512,12 @@ private Method GetMethod(string modulePath, int functionToken, out Class @class)
             return pair.Value;
         }
 
+        /// <summary>
+        /// Get the class name of a function
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="functionToken"></param>
+        /// <returns></returns>
         public string GetClassFullName(string modulePath, int functionToken)
         {
             Class @class;
@@ -486,12 +525,16 @@ public string GetClassFullName(string modulePath, int functionToken)
             return @class != null ? @class.FullName : null;
         }
 
+        /// <summary>
+        /// Save the visit data to the session model
+        /// </summary>
+        /// <param name="data"></param>
         public void SaveVisitData(byte[] data)
         {
             var nCount = BitConverter.ToUInt32(data, 0);
             if (nCount > (data.Count()/4) - 1)
             {
-                _logger.DebugFormat("Failed to process points as count ({0}) exceeded available buffer size ({1})",
+                _logger.ErrorFormat("Failed to process points as count ({0}) exceeded available buffer size ({1})",
                     nCount, (data.Count()/4) - 1);
                 return;
             }
@@ -502,7 +545,7 @@ public void SaveVisitData(byte[] data)
                 {
                     if (!InstrumentationPoint.AddVisitCount(spid, _trackedMethodId))
                     {
-                        _logger.DebugFormat("Failed to add a visit to {0} with tracking method {1}. Max point count is {2}", 
+                        _logger.ErrorFormat("Failed to add a visit to {0} with tracking method {1}. Max point count is {2}", 
                             spid, _trackedMethodId, InstrumentationPoint.Count);
                     }
                 }
@@ -514,6 +557,14 @@ public void SaveVisitData(byte[] data)
             }
         }
 
+        /// <summary>
+        /// determine if the method (test method) should be tracked
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="assemblyName"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="uniqueId"></param>
+        /// <returns></returns>
         public bool GetTrackingMethod(string modulePath, string assemblyName, int functionToken, out uint uniqueId)
         {
             uniqueId = 0;
diff --git a/main/OpenCover.Framework/Persistance/FilePersistance.cs b/main/OpenCover.Framework/Persistance/FilePersistance.cs
index 1023e9ed7..ffc063810 100644
--- a/main/OpenCover.Framework/Persistance/FilePersistance.cs
+++ b/main/OpenCover.Framework/Persistance/FilePersistance.cs
@@ -26,7 +26,7 @@ public class FilePersistance : BasePersistance
         /// </summary>
         /// <param name="commandLine"></param>
         /// <param name="logger"></param>
-        public FilePersistance(ICommandLine commandLine, ILog logger) : base(commandLine, logger)
+        public FilePersistance(ICommandLine commandLine, ILog logger) : base(commandLine, null)
         {
             _logger = logger;
         }
diff --git a/main/OpenCover.Framework/Service/IProfilerCommunication.cs b/main/OpenCover.Framework/Service/IProfilerCommunication.cs
index 81ed6927f..2c17dab2a 100644
--- a/main/OpenCover.Framework/Service/IProfilerCommunication.cs
+++ b/main/OpenCover.Framework/Service/IProfilerCommunication.cs
@@ -24,17 +24,62 @@ namespace OpenCover.Framework.Service
     //    public int Path { get; set; }
     //}
 
+    /// <summary>
+    /// Defines the tye of operations the profiler will make
+    /// </summary>
     public interface IProfilerCommunication
     {
-        bool TrackAssembly(string modulePath, string assemblyName);
+        /// <summary>
+        /// Should we track this assembly
+        /// </summary>
+        /// <param name="processName"></param>
+        /// <param name="modulePath"></param>
+        /// <param name="assemblyName"></param>
+        /// <returns></returns>
+        bool TrackAssembly(string processName, string modulePath, string assemblyName);
 
-        bool GetSequencePoints(string modulePath, string assemblyName, int functionToken, out InstrumentationPoint[] sequencePoints);
+        /// <summary>
+        /// Get sequence points
+        /// </summary>
+        /// <param name="processName"></param>
+        /// <param name="modulePath"></param>
+        /// <param name="assemblyName"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="sequencePoints"></param>
+        /// <returns></returns>
+        bool GetSequencePoints(string processName, string modulePath, string assemblyName, int functionToken, out InstrumentationPoint[] sequencePoints);
 
-        bool GetBranchPoints(string modulePath, string assemblyName, int functionToken, out BranchPoint[] branchPoints);
+        /// <summary>
+        /// Get branch points
+        /// </summary>
+        /// <param name="processName"></param>
+        /// <param name="modulePath"></param>
+        /// <param name="assemblyName"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="branchPoints"></param>
+        /// <returns></returns>
+        bool GetBranchPoints(string processName, string modulePath, string assemblyName, int functionToken, out BranchPoint[] branchPoints);
 
+        /// <summary>
+        /// We are stopping...
+        /// </summary>
         void Stopping();
 
+        /// <summary>
+        /// Should we track this method
+        /// </summary>
+        /// <param name="modulePath"></param>
+        /// <param name="assemblyName"></param>
+        /// <param name="functionToken"></param>
+        /// <param name="uniqueId"></param>
+        /// <returns></returns>
         bool TrackMethod(string modulePath, string assemblyName, int functionToken, out uint uniqueId);
 
+        /// <summary>
+        /// Should we track this process
+        /// </summary>
+        /// <param name="processName"></param>
+        /// <returns></returns>
+        bool TrackProcess(string processName);
     }
 }
diff --git a/main/OpenCover.Framework/Service/ProfilerCommunication.cs b/main/OpenCover.Framework/Service/ProfilerCommunication.cs
index d2e11c801..e8f01d189 100644
--- a/main/OpenCover.Framework/Service/ProfilerCommunication.cs
+++ b/main/OpenCover.Framework/Service/ProfilerCommunication.cs
@@ -28,12 +28,12 @@ public ProfilerCommunication(IFilter filter,
             _instrumentationModelBuilderFactory = instrumentationModelBuilderFactory;
         }
 
-        public bool TrackAssembly(string modulePath, string assemblyName)
+        public bool TrackAssembly(string processName, string modulePath, string assemblyName)
         {
             if (_persistance.IsTracking(modulePath)) return true;
             Module module = null;
             var builder = _instrumentationModelBuilderFactory.CreateModelBuilder(modulePath, assemblyName);
-            if (!_filter.UseAssembly(assemblyName))
+            if (!_filter.UseAssembly(processName, assemblyName))
             {
                 module = builder.BuildModuleModel(false);
                 module.MarkAsSkipped(SkippedMethod.Filter);
@@ -59,38 +59,38 @@ public bool TrackAssembly(string modulePath, string assemblyName)
             return !module.ShouldSerializeSkippedDueTo();
         }
 
-        public bool GetBranchPoints(string modulePath, string assemblyName, int functionToken, out BranchPoint[] instrumentPoints)
+        public bool GetBranchPoints(string processName, string modulePath, string assemblyName, int functionToken, out BranchPoint[] instrumentPoints)
         {
             BranchPoint[] points = null;
 
             var ret = GetPoints(() => _persistance.GetBranchPointsForFunction(modulePath, functionToken, out points),
-                    modulePath, assemblyName, functionToken, out instrumentPoints);
+                    processName, modulePath, assemblyName, functionToken, out instrumentPoints);
 
             instrumentPoints = points;
             return ret;
         }
 
-        public bool GetSequencePoints(string modulePath, string assemblyName, int functionToken, out InstrumentationPoint[] instrumentPoints)
+        public bool GetSequencePoints(string processName, string modulePath, string assemblyName, int functionToken, out InstrumentationPoint[] instrumentPoints)
         {
             InstrumentationPoint[] points = null;
 
             var ret = GetPoints(() => _persistance.GetSequencePointsForFunction(modulePath, functionToken, out points),
-                                modulePath, assemblyName, functionToken, out instrumentPoints);
+                                processName, modulePath, assemblyName, functionToken, out instrumentPoints);
 
             instrumentPoints = points;
             return ret;
         }
 
-        private bool GetPoints<T>(Func<bool> getPointsFunc, string modulePath, string assemblyName, int functionToken, out T[] points)
+        private bool GetPoints<T>(Func<bool> getPointsFunc, string processName, string modulePath, string assemblyName, int functionToken, out T[] points)
         {
             points = new T[0];
-            return CanReturnPoints(modulePath, assemblyName, functionToken) && getPointsFunc();
+            return CanReturnPoints(processName, modulePath, assemblyName, functionToken) && getPointsFunc();
         }
 
-        private bool CanReturnPoints(string modulePath, string assemblyName, int functionToken)
+        private bool CanReturnPoints(string processName, string modulePath, string assemblyName, int functionToken)
         {
             var className = _persistance.GetClassFullName(modulePath, functionToken);
-            return _filter.InstrumentClass(assemblyName, className);
+            return _filter.InstrumentClass(processName, assemblyName, className);
         }
 
         public void Stopping()
@@ -102,5 +102,10 @@ public bool TrackMethod(string modulePath, string assemblyName, int functionToke
         {
             return _persistance.GetTrackingMethod(modulePath, assemblyName,functionToken, out uniqueId);
         }
+
+        public bool TrackProcess(string processName)
+        {
+            return _filter.InstrumentProcess(processName);
+        }
     }
 }
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Symbols/CecilSymbolManager.cs b/main/OpenCover.Framework/Symbols/CecilSymbolManager.cs
index 9d5dc38a9..c295906f3 100644
--- a/main/OpenCover.Framework/Symbols/CecilSymbolManager.cs
+++ b/main/OpenCover.Framework/Symbols/CecilSymbolManager.cs
@@ -398,17 +398,16 @@ private void GetBranchPointsForToken(int token, List<BranchPoint> list)
                 UInt32 ordinal = 0;
                 var instructions = methodDefinition.SafeGetMethodBody().Instructions;
                 
-                // if method is generated MoveNext skip switch if it is the first branch
-                var skipFirstSwitch = Regex.IsMatch(methodDefinition.FullName, @"\<.+\>d__\d+::MoveNext\(\)$");
+                // if method is a generated MoveNext skip first branch (could be a switch or a branch)
+                var skipFirstBranch = Regex.IsMatch(methodDefinition.FullName, @"\<.+\>d__\d+::MoveNext\(\)$");
 
                 foreach (var instruction in instructions.Where(instruction => instruction.OpCode.FlowControl == FlowControl.Cond_Branch))
                 {
-                    if (instruction.OpCode.Code == Code.Switch && skipFirstSwitch)
+                    if (skipFirstBranch)
                     {
-                        skipFirstSwitch = false;
+                        skipFirstBranch = false;
                         continue;
                     }
-                    skipFirstSwitch = false; 
 
                     if (BranchIsInGeneratedFinallyBlock(instruction, methodDefinition)) continue;
 
diff --git a/main/OpenCover.Framework/Symbols/ISymbolManager.cs b/main/OpenCover.Framework/Symbols/ISymbolManager.cs
index 8fa5dce75..8aea025dd 100644
--- a/main/OpenCover.Framework/Symbols/ISymbolManager.cs
+++ b/main/OpenCover.Framework/Symbols/ISymbolManager.cs
@@ -8,26 +8,71 @@
 
 namespace OpenCover.Framework.Symbols
 {
+    /// <summary>
+    /// defines a symbol manager for an assembly/module being profiled
+    /// </summary>
     public interface ISymbolManager
     {
+        /// <summary>
+        /// The path to the module
+        /// </summary>
         string ModulePath { get; }
 
+        /// <summary>
+        /// The name of the module
+        /// </summary>
         string ModuleName { get; }
 
+        /// <summary>
+        /// The source files that made up the module
+        /// </summary>
+        /// <returns></returns>
         File[] GetFiles();
 
+        /// <summary>
+        /// The types (with implementation) found in the module
+        /// </summary>
+        /// <returns></returns>
         Class[] GetInstrumentableTypes();
 
+        /// <summary>
+        /// The methods for a type in the module
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="files"></param>
+        /// <returns></returns>
         Method[] GetMethodsForType(Class type, File[] files);
 
+        /// <summary>
+        /// The sequence points for a method
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns></returns>
         SequencePoint[] GetSequencePointsForToken(int token);
 
+        /// <summary>
+        /// The branch points for a method
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns></returns>
         BranchPoint[] GetBranchPointsForToken(int token);
 
+        /// <summary>
+        /// The cyclomatic complexity for a method
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns></returns>
         int GetCyclomaticComplexityForToken(int token);
 
+        /// <summary>
+        /// The source assembly
+        /// </summary>
         AssemblyDefinition SourceAssembly { get; }
 
+        /// <summary>
+        /// Test methods that are being tracked
+        /// </summary>
+        /// <returns></returns>
         TrackedMethod[] GetTrackedMethods();
     }
 }
\ No newline at end of file
diff --git a/main/OpenCover.Framework/Utility/PerfCounters.cs b/main/OpenCover.Framework/Utility/PerfCounters.cs
index 3ee767280..e1774b247 100644
--- a/main/OpenCover.Framework/Utility/PerfCounters.cs
+++ b/main/OpenCover.Framework/Utility/PerfCounters.cs
@@ -3,28 +3,33 @@
 namespace OpenCover.Framework.Utility
 {
     /// <summary>
-    /// 
+    /// Expose some performance counters
     /// </summary>
-    /// 
     [ExcludeFromCoverage("Performance counters can only be created by Administrators")] 
     public class PerfCounters : IPerfCounters
     {
         private PerformanceCounter _memoryQueue;
         private PerformanceCounter _queueThrougput;
 
+        /// <summary>
+        /// get the current queue size
+        /// </summary>
         public int CurrentMemoryQueueSize { set { _memoryQueue.RawValue = value; } }
         public void IncrementBlocksReceived()
         {
             _queueThrougput.RawValue += 1;
         }
 
+        /// <summary>
+        /// Instantiate the Performance Counters
+        /// </summary>
         public PerfCounters()
         {
             CreateCounters();
             ResetCounters();
         }
 
-        private const string InstanceName = "OpenCover";
+        //private const string InstanceName = "OpenCover";
         private const string CategoryName = "OpenCover";
         private const string MemoryQueue = "MemoryQueue";
         private const string QueueThroughput = "QueueThroughput";
@@ -61,6 +66,9 @@ public void ResetCounters()
     [ExcludeFromCoverage("Performance counters can only be created by Administrators")] 
     public class NullPerfCounter : IPerfCounters
     {
+        /// <summary>
+        /// A null performance counters implementation
+        /// </summary>
         public int CurrentMemoryQueueSize { set; private get; }
         public void IncrementBlocksReceived()
         {
diff --git a/main/OpenCover.Framework/log4net.config b/main/OpenCover.Framework/log4net.config
index 4d8afe674..d6c61f707 100644
--- a/main/OpenCover.Framework/log4net.config
+++ b/main/OpenCover.Framework/log4net.config
@@ -19,19 +19,19 @@
         <conversionPattern value="%message%newline" />
       </layout>
     </appender>
-    <appender name="DebugAppender" type="log4net.Appender.DebugAppender">
+    <appender name="OutputDebugStringAppender" type="log4net.Appender.OutputDebugStringAppender">
       <layout type="log4net.Layout.PatternLayout">
-        <conversionPattern value="%message" />
+        <conversionPattern value="OpenCover: (Host) %message" />
       </layout>
-      <filter type="log4net.Filter.LevelRangeFilter">
-        <levelMin value="DEBUG" />
-        <levelMax value="DEBUG" />
-      </filter>
     </appender>
 
+    <logger name="DebugLogger" additivity="false">
+       <level value="ALL" />
+       <appender-ref ref="OutputDebugStringAppender" />
+    </logger>
+    
     <root>
       <appender-ref ref="ColoredConsoleAppender" />
-      <appender-ref ref="DebugAppender" />
     </root>
     
   </log4net>
diff --git a/main/OpenCover.Installer/Components.wxs b/main/OpenCover.Installer/Components.wxs
index c13a751eb..5eeece707 100644
--- a/main/OpenCover.Installer/Components.wxs
+++ b/main/OpenCover.Installer/Components.wxs
@@ -36,6 +36,9 @@
         <File Id="GENDARME_FRAMEWORK_DLL" Source="..\bin\Release\Gendarme.Framework.dll" KeyPath="yes" />
         <File Id="GENDARME_RULES_MAINTAINABILITY_DLL" Source="..\bin\Release\Gendarme.Rules.Maintainability.dll" />
       </Component>
+      <Component Id="CrashReporter_Signed_3rdParty" Guid="{d2a05736-4ed9-4bf1-9fc0-d507794a5a68}">
+        <File Id="CRASHREPORTER_NET_DLL" Source="..\bin\Release\CrashReporter.NET.dll" KeyPath="yes" />
+      </Component>
       <Component Id="Log4Net_3rdParty" Guid="{12E6BB24-EC81-4831-A1CD-9DF0600901A0}">
         <File Id="LOG4NET_DLL" Source="..\bin\Release\log4net.dll" KeyPath="yes" />
         <File Id="LOG4NET_CONFIG" Source="..\bin\Release\log4net.config" />
diff --git a/main/OpenCover.Installer/Product.wxs b/main/OpenCover.Installer/Product.wxs
index 5f0b9c5e8..c8de0522f 100644
--- a/main/OpenCover.Installer/Product.wxs
+++ b/main/OpenCover.Installer/Product.wxs
@@ -45,6 +45,7 @@
       <ComponentRef Id="Autofac_3rdParty" />
       <ComponentRef Id="MonoCecil_3rdParty" />
       <ComponentRef Id="Gendarme_Signed_3rdParty" />
+      <ComponentRef Id="CrashReporter_Signed_3rdParty" />
       <ComponentRef Id="Log4Net_3rdParty" />
       <ComponentRef Id="X86Profiler" />
       <ComponentRef Id="X64Profiler" />
diff --git a/main/OpenCover.Profiler/CodeCoverage.cpp b/main/OpenCover.Profiler/CodeCoverage.cpp
index 30b4f119b..0e7cd679f 100644
--- a/main/OpenCover.Profiler/CodeCoverage.cpp
+++ b/main/OpenCover.Profiler/CodeCoverage.cpp
@@ -92,9 +92,9 @@ HRESULT CCodeCoverage::OpenCoverInitialise(IUnknown *pICorProfilerInfoUnk){
 
     m_useOldStyle = (tstring(instrumentation) == _T("oldSchool"));
 
-    if (!m_host.Initialise(key, ns))
+    if (!m_host.Initialise(key, ns, szExeName))
     {
-        RELTRACE(_T("    ::Initialize => Failed to initialise the profiler communications -> GetLastError() => %d"), ::GetLastError());
+        RELTRACE(_T("    ::Initialize => Profiler will not run for this process."));
         return E_FAIL;
     }
 
@@ -161,7 +161,9 @@ DWORD CCodeCoverage::AppendProfilerEventMask(DWORD currentEventMask)
 /// <summary>Handle <c>ICorProfilerCallback::Shutdown</c></summary>
 HRESULT STDMETHODCALLTYPE CCodeCoverage::Shutdown( void) 
 { 
-	if (m_chainedProfiler != NULL)
+    RELTRACE(_T("::Shutdown - Starting"));
+
+    if (m_chainedProfiler != NULL)
 		m_chainedProfiler->Shutdown();
 
     m_host.CloseChannel(m_tracingEnabled);
diff --git a/main/OpenCover.Profiler/Messages.h b/main/OpenCover.Profiler/Messages.h
index 2fb63accb..227346daa 100644
--- a/main/OpenCover.Profiler/Messages.h
+++ b/main/OpenCover.Profiler/Messages.h
@@ -42,6 +42,7 @@ enum MSG_Type : int
     MSG_TrackMethod = 4,
     MSG_AllocateMemoryBuffer = 5,
     MSG_CloseChannel = 6,
+    MSG_TrackProcess = 7,
 };
 
 enum MSG_IdType : ULONG
@@ -58,6 +59,7 @@ enum MSG_IdType : ULONG
 typedef struct _MSG_TrackAssembly_Request
 {
     MSG_Type type;
+    WCHAR szProcessName[512];
     WCHAR szModulePath[512];
     WCHAR szAssemblyName[512];
 } MSG_TrackAssembly_Request;
@@ -71,6 +73,7 @@ typedef struct _MSG_GetSequencePoints_Request
 {
     MSG_Type type;
     int functionToken;
+    WCHAR szProcessName[512];
     WCHAR szModulePath[512];
     WCHAR szAssemblyName[512];
 } MSG_GetSequencePoints_Request;
@@ -86,6 +89,7 @@ typedef struct _MSG_GetBranchPoints_Request
 {
     MSG_Type type;
     int functionToken;
+    WCHAR szProcessName[512];
     WCHAR szModulePath[512];
     WCHAR szAssemblyName[512];
 } MSG_GetBranchPoints_Request;
@@ -140,6 +144,17 @@ typedef struct _MSG_CloseChannel_Response
     BOOL bResponse;
 } MSG_CloseChannel_Response;
 
+typedef struct _MSG_TrackProcess_Request
+{
+    MSG_Type type;
+    WCHAR szProcessName[512];
+} MSG_TrackProcess_Request;
+
+typedef struct _MSG_TrackProcess_Response
+{
+    BOOL bResponse;
+} MSG_TrackProcess_Response;
+
 #pragma pack(pop)
 
 typedef union _MSG_Union
@@ -155,7 +170,9 @@ typedef union _MSG_Union
     MSG_TrackMethod_Response trackMethodResponse;
     MSG_AllocateBuffer_Request allocateBufferRequest;
     MSG_AllocateBuffer_Response allocateBufferResponse;
-    MSG_CloseChannel_Request closeChannelBufferRequest;
+    MSG_CloseChannel_Request closeChannelRequest;
     MSG_CloseChannel_Response closeChannelResponse;
+    MSG_TrackProcess_Request trackProcessRequest;
+    MSG_TrackProcess_Response trackProcessResponse;
 } MSG_Union;
 
diff --git a/main/OpenCover.Profiler/ProfilerCommunication.cpp b/main/OpenCover.Profiler/ProfilerCommunication.cpp
index 33f0d4b92..0e7501ce7 100644
--- a/main/OpenCover.Profiler/ProfilerCommunication.cpp
+++ b/main/OpenCover.Profiler/ProfilerCommunication.cpp
@@ -7,15 +7,15 @@
 #include "ProfilerCommunication.h"
 #include "ReleaseTrace.h"
 
-#include <concrt.h>
-
-#include <TlHelp32.h>
+//#include <concrt.h>
+//#include <TlHelp32.h>
 
 #include <sstream>
 
 #define ONERROR_GOEXIT(hr) if (FAILED(hr)) goto Exit
 #define COMM_WAIT_SHORT 10000
 #define COMM_WAIT_LONG 60000
+#define COMM_WAIT_VSHORT 3000
 
 ProfilerCommunication::ProfilerCommunication() 
 {
@@ -26,9 +26,10 @@ ProfilerCommunication::~ProfilerCommunication()
 {
 }
 
-bool ProfilerCommunication::Initialise(TCHAR *key, TCHAR *ns)
+bool ProfilerCommunication::Initialise(TCHAR *key, TCHAR *ns, TCHAR *processName)
 {
 	m_key = key;
+    m_processName = processName;
 
 	std::wstring sharedKey = key;
 	sharedKey.append(_T("-1"));
@@ -38,25 +39,53 @@ bool ProfilerCommunication::Initialise(TCHAR *key, TCHAR *ns)
     m_mutexCommunication.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_Mutex_") + m_key).c_str());
     if (!m_mutexCommunication.IsValid()) return false;
     
-	RELTRACE(_T("Initialised mutexes"));
+    USES_CONVERSION;
+    ATLTRACE(_T("ProfilerCommunication::Initialise(...) => Initialised mutexes => %s"), W2CT(sharedKey.c_str()));
 
-    m_eventProfilerRequestsInformation.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_SendData_Event_") + sharedKey).c_str());
-    if (!m_eventProfilerRequestsInformation.IsValid()) return false;
+    auto resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_SendData_Event_") + sharedKey);
+    m_eventProfilerRequestsInformation.Initialise(resource_name.c_str());
+    if (!m_eventProfilerRequestsInformation.IsValid()) {
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+        return false;
+    }
 
-    m_eventInformationReadByProfiler.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_ChunkData_Event_") + sharedKey).c_str());
-    if (!m_eventInformationReadByProfiler.IsValid()) return false;
+    resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_ChunkData_Event_") + sharedKey);
+    m_eventInformationReadByProfiler.Initialise(resource_name.c_str());
+    if (!m_eventInformationReadByProfiler.IsValid()) {
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) = >Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+        return false;
+    }
 
-    m_eventInformationReadyForProfiler.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_ReceiveData_Event_") + sharedKey).c_str());
-    if (!m_eventInformationReadyForProfiler.IsValid()) return false;
+    resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_ReceiveData_Event_") + sharedKey);
+    m_eventInformationReadyForProfiler.Initialise(resource_name.c_str());
+    if (!m_eventInformationReadyForProfiler.IsValid()) {
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+        return false;
+    }
 
-    m_memoryCommunication.OpenFileMapping((m_namespace + _T("\\OpenCover_Profiler_Communication_MemoryMapFile_") + sharedKey).c_str());
-    if (!m_memoryCommunication.IsValid()) return false;
+    resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_MemoryMapFile_") + sharedKey);
+    m_memoryCommunication.OpenFileMapping(resource_name.c_str());
+    if (!m_memoryCommunication.IsValid()) {
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+        return false;
+    }
 
-    RELTRACE(_T("Initialised communication interface"));
+    resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_Semaphore_") + sharedKey);
+    _semapore_communication.Initialise(resource_name.c_str());
+    if (!_semapore_communication.IsValid()) {
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+        return false;
+    }
+    m_pMSG = (MSG_Union*)m_memoryCommunication.MapViewOfFile(0, 0, MAX_MSG_SIZE);
 
     hostCommunicationActive = true;
 
-    m_pMSG = (MSG_Union*)m_memoryCommunication.MapViewOfFile(0, 0, MAX_MSG_SIZE);
+    ATLTRACE(_T("ProfilerCommunication::Initialise(...) => Initialised communication interface => %s"), W2CT(sharedKey.c_str()));
+
+    if (!TrackProcess()){
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) => ProfilerCommunication => process is not be tracked"));
+        return false;
+    }
 
     ULONG bufferId =  0;
     if (AllocateBuffer(MAX_MSG_SIZE, bufferId))
@@ -70,38 +99,92 @@ bool ProfilerCommunication::Initialise(TCHAR *key, TCHAR *ns)
 
         memoryKey = m_key + memoryKey;
 
-        RELTRACE(_T("Re-initialising communication interface => %d"), bufferId);
+        ATLTRACE(_T("ProfilerCommunication::Initialise(...) => Re-initialising communication interface => %s"), W2CT(memoryKey.c_str()));
 
-        m_eventProfilerRequestsInformation.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_SendData_Event_") + memoryKey).c_str());
-        if (!m_eventProfilerRequestsInformation.IsValid()) return false;
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_SendData_Event_") + memoryKey);
+        m_eventProfilerRequestsInformation.Initialise(resource_name.c_str());
+        if (!m_eventProfilerRequestsInformation.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
-        m_eventInformationReadByProfiler.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_ChunkData_Event_") + memoryKey).c_str());
-        if (!m_eventInformationReadByProfiler.IsValid()) return false;
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_ChunkData_Event_") + memoryKey);
+        m_eventInformationReadByProfiler.Initialise(resource_name.c_str());
+        if (!m_eventInformationReadByProfiler.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
-        m_eventInformationReadyForProfiler.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_ReceiveData_Event_") + memoryKey).c_str());
-        if (!m_eventInformationReadyForProfiler.IsValid()) return false;
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_ReceiveData_Event_") + memoryKey);
+        m_eventInformationReadyForProfiler.Initialise(resource_name.c_str());
+        if (!m_eventInformationReadyForProfiler.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
-        m_memoryCommunication.OpenFileMapping((m_namespace + _T("\\OpenCover_Profiler_Communication_MemoryMapFile_") + memoryKey).c_str());
-        if (!m_memoryCommunication.IsValid()) return false;
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_MemoryMapFile_") + memoryKey);
+        m_memoryCommunication.OpenFileMapping(resource_name.c_str());
+        if (!m_memoryCommunication.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
         m_pMSG = (MSG_Union*)m_memoryCommunication.MapViewOfFile(0, 0, MAX_MSG_SIZE);
 
-        RELTRACE(_T("Re-initialised communication interface => %d"), bufferId);
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Communication_Semaphore_") + memoryKey);
+        _semapore_communication.Initialise(resource_name.c_str());
+        if (!_semapore_communication.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
-        m_eventProfilerHasResults.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_SendResults_Event_") + memoryKey).c_str());
-        if (!m_eventProfilerHasResults.IsValid()) return false;
+        ATLTRACE(_T("ProfilerCommunication::Initialise(...) => Re-initialised communication interface => %s"), W2CT(memoryKey.c_str()));
 
-        m_eventResultsHaveBeenReceived.Initialise((m_namespace + _T("\\OpenCover_Profiler_Communication_ReceiveResults_Event_") + memoryKey).c_str());
-        if (!m_eventResultsHaveBeenReceived.IsValid()) return false;
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Results_SendResults_Event_") + memoryKey);
+        m_eventProfilerHasResults.Initialise(resource_name.c_str());
+        if (!m_eventProfilerHasResults.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
-        m_memoryResults.OpenFileMapping((m_namespace + _T("\\OpenCover_Profiler_Results_MemoryMapFile_") + memoryKey).c_str());
-        if (!m_memoryResults.IsValid()) return false;
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Results_ReceiveResults_Event_") + memoryKey);
+        m_eventResultsHaveBeenReceived.Initialise(resource_name.c_str());
+        if (!m_eventResultsHaveBeenReceived.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
+
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Results_MemoryMapFile_") + memoryKey);
+        m_memoryResults.OpenFileMapping(resource_name.c_str());
+        if (!m_memoryResults.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
 
         m_pVisitPoints = (MSG_SendVisitPoints_Request*)m_memoryResults.MapViewOfFile(0, 0, MAX_MSG_SIZE);
 
         m_pVisitPoints->count = 0;
 
-        RELTRACE(_T("Initialised results interface => %d"), bufferId);
+        resource_name = (m_namespace + _T("\\OpenCover_Profiler_Results_Semaphore_") + memoryKey);
+        _semapore_results.Initialise(resource_name.c_str());
+        if (!_semapore_results.IsValid()) {
+            RELTRACE(_T("ProfilerCommunication::Initialise(...) => Failed to initialise resource %s => ::GetLastError() = %d"), W2CT(resource_name.c_str()), ::GetLastError());
+            hostCommunicationActive = false;
+            return false;
+        }
+
+        RELTRACE(_T("ProfilerCommunication::Initialise(...) => Initialised results interface => %s"), W2CT(memoryKey.c_str()));
+    }
+    else {
+        hostCommunicationActive = false;
     }
 
     return hostCommunicationActive;
@@ -171,6 +254,9 @@ void ProfilerCommunication::SendThreadVisitPoints(MSG_SendVisitPoints_Request* p
     if (!hostCommunicationActive)
         return;
 
+    if (!TestSemaphore(_semapore_results))
+        return;
+
     handle_exception([=](){
         memcpy(m_pVisitPoints, pVisitPoints, sizeof(MSG_SendVisitPoints_Request));
     }, _T("SendThreadVisitPoints"));
@@ -188,6 +274,9 @@ void ProfilerCommunication::AddVisitPointToBuffer(ULONG uniqueId, MSG_IdType msg
     if (!hostCommunicationActive) 
         return;
     
+    if (!TestSemaphore(_semapore_results))
+        return;
+
     handle_exception([=](){
         m_pVisitPoints->points[m_pVisitPoints->count].UniqueId = (uniqueId | msgType);
     }, _T("AddVisitPointToBuffer"));
@@ -245,6 +334,8 @@ bool ProfilerCommunication::GetSequencePoints(mdToken functionToken, WCHAR* pMod
         {
             m_pMSG->getSequencePointsRequest.type = MSG_GetSequencePoints;
             m_pMSG->getSequencePointsRequest.functionToken = functionToken;
+            USES_CONVERSION;
+            wcscpy_s(m_pMSG->getSequencePointsRequest.szProcessName, T2CW(m_processName.c_str()));
             wcscpy_s(m_pMSG->getSequencePointsRequest.szModulePath, pModulePath);
             wcscpy_s(m_pMSG->getSequencePointsRequest.szAssemblyName, pAssemblyName);
         }, 
@@ -280,6 +371,8 @@ bool ProfilerCommunication::GetBranchPoints(mdToken functionToken, WCHAR* pModul
         {
             m_pMSG->getBranchPointsRequest.type = MSG_GetBranchPoints;
             m_pMSG->getBranchPointsRequest.functionToken = functionToken;
+            USES_CONVERSION;
+            wcscpy_s(m_pMSG->getBranchPointsRequest.szProcessName, T2CW(m_processName.c_str()));
             wcscpy_s(m_pMSG->getBranchPointsRequest.szModulePath, pModulePath);
             wcscpy_s(m_pMSG->getBranchPointsRequest.szAssemblyName, pAssemblyName);
         }, 
@@ -314,6 +407,8 @@ bool ProfilerCommunication::TrackAssembly(WCHAR* pModulePath, WCHAR* pAssemblyNa
         [=]()
         {
             m_pMSG->trackAssemblyRequest.type = MSG_TrackAssembly; 
+            USES_CONVERSION;
+            wcscpy_s(m_pMSG->trackAssemblyRequest.szProcessName, T2CW(m_processName.c_str()));
             wcscpy_s(m_pMSG->trackAssemblyRequest.szModulePath, pModulePath);
             wcscpy_s(m_pMSG->trackAssemblyRequest.szAssemblyName, pAssemblyName);
         }, 
@@ -364,22 +459,25 @@ bool ProfilerCommunication::AllocateBuffer(LONG bufferSize, ULONG &bufferId)
         return false;
 
     bool response = false;
-
-    RequestInformation(
-        [=]()
-        {
-            m_pMSG->allocateBufferRequest.type = MSG_AllocateMemoryBuffer; 
-            m_pMSG->allocateBufferRequest.lBufferSize = bufferSize;
-        }, 
-        [=, &response, &bufferId]()->BOOL
-        {
-            response =  m_pMSG->allocateBufferResponse.bResponse == TRUE;
-            bufferId = m_pMSG->allocateBufferResponse.ulBufferId;
-			::ZeroMemory(m_pMSG, MAX_MSG_SIZE);
-            return FALSE;
-        }
-        , COMM_WAIT_SHORT
-        , _T("AllocateBuffer"));
+    int repeat = 0;
+    while (!response && (++repeat <= 3)){
+        hostCommunicationActive = true;
+        RequestInformation(
+            [=]()
+            {
+                m_pMSG->allocateBufferRequest.type = MSG_AllocateMemoryBuffer; 
+                m_pMSG->allocateBufferRequest.lBufferSize = bufferSize;
+            }, 
+            [=, &response, &bufferId]()->BOOL
+            {
+                response =  m_pMSG->allocateBufferResponse.bResponse == TRUE;
+                bufferId = m_pMSG->allocateBufferResponse.ulBufferId;
+			    ::ZeroMemory(m_pMSG, MAX_MSG_SIZE);
+                return FALSE;
+            }
+            , COMM_WAIT_VSHORT
+            , _T("AllocateBuffer"));
+    }
 
     return response;
 }
@@ -391,6 +489,9 @@ void ProfilerCommunication::CloseChannel(bool sendSingleBuffer){
     if (!hostCommunicationActive)
         return;
 
+    if (!TestSemaphore(_semapore_results))
+        return;
+
     if (sendSingleBuffer)
         SendVisitPoints();
     else
@@ -404,8 +505,8 @@ void ProfilerCommunication::CloseChannel(bool sendSingleBuffer){
     RequestInformation(
         [=]()
         {
-            m_pMSG->closeChannelBufferRequest.type = MSG_CloseChannel;
-            m_pMSG->closeChannelBufferRequest.ulBufferId = m_bufferId;
+            m_pMSG->closeChannelRequest.type = MSG_CloseChannel;
+            m_pMSG->closeChannelRequest.ulBufferId = m_bufferId;
         },
         [=, &response]()->BOOL
         {
@@ -418,6 +519,32 @@ void ProfilerCommunication::CloseChannel(bool sendSingleBuffer){
     return;
 }
 
+bool ProfilerCommunication::TrackProcess(){
+    CScopedLock<CMutex> lock(m_mutexCommunication);
+
+    if (!hostCommunicationActive)
+        return false;
+
+    bool response = false;
+
+    RequestInformation(
+        [=]()
+        {
+            m_pMSG->trackProcessRequest.type = MSG_TrackProcess;
+            USES_CONVERSION;
+            wcscpy_s(m_pMSG->trackProcessRequest.szProcessName, T2CW(m_processName.c_str()));
+        },
+        [=, &response]()->BOOL
+        {
+            response = m_pMSG->trackProcessResponse.bResponse == TRUE;
+            return FALSE;
+        }
+        , COMM_WAIT_SHORT
+        , _T("TrackProcess"));
+
+    return response;
+}
+
 void ProfilerCommunication::report_runtime(const std::runtime_error& re, const tstring &msg){
     USES_CONVERSION;
     RELTRACE(_T("Runtime error: %s - %s"), msg.c_str(), A2T(re.what()));
@@ -473,7 +600,11 @@ template<class BR, class PR>
 void ProfilerCommunication::RequestInformation(BR buildRequest, PR processResults, DWORD dwTimeout, tstring message)
 {
 	ATL::CComCritSecLock<ATL::CComAutoCriticalSection> lock(m_critComms);
-    if (!hostCommunicationActive) return;
+    if (!hostCommunicationActive) 
+        return;
+
+    if (!TestSemaphore(_semapore_communication))
+        return;
 
 	try {
 
diff --git a/main/OpenCover.Profiler/ProfilerCommunication.h b/main/OpenCover.Profiler/ProfilerCommunication.h
index e298ca5e4..703946720 100644
--- a/main/OpenCover.Profiler/ProfilerCommunication.h
+++ b/main/OpenCover.Profiler/ProfilerCommunication.h
@@ -23,13 +23,12 @@ class ProfilerCommunication
 public:
     ProfilerCommunication();
     ~ProfilerCommunication(void);
-    bool Initialise(TCHAR* key, TCHAR *ns);
+    bool Initialise(TCHAR* key, TCHAR *ns, TCHAR *processName);
 
 public:
     bool TrackAssembly(WCHAR* pModulePath, WCHAR* pAssemblyName);
     bool GetPoints(mdToken functionToken, WCHAR* pModulePath, WCHAR* pAssemblyName, std::vector<SequencePoint> &seqPoints, std::vector<BranchPoint> &brPoints);
     bool TrackMethod(mdToken functionToken, WCHAR* pModulePath, WCHAR* pAssemblyName, ULONG &uniqueId);
-    bool AllocateBuffer(LONG bufferSize, ULONG &bufferId);
 	inline void AddTestEnterPoint(ULONG uniqueId) { AddVisitPointToBuffer(uniqueId, IT_MethodEnter); }
 	inline void AddTestLeavePoint(ULONG uniqueId) { AddVisitPointToBuffer(uniqueId, IT_MethodLeave); }
 	inline void AddTestTailcallPoint(ULONG uniqueId) { AddVisitPointToBuffer(uniqueId, IT_MethodTailcall); }
@@ -37,6 +36,10 @@ class ProfilerCommunication
     void AddVisitPointToThreadBuffer(ULONG uniqueId, MSG_IdType msgType);
     void CloseChannel(bool sendSingleBuffer);
 
+private:
+    bool AllocateBuffer(LONG bufferSize, ULONG &bufferId);
+    bool TrackProcess();
+
 public: 
     void ThreadCreated(ThreadID threadID, DWORD osThreadID);
     void ThreadDestroyed(ThreadID threadID);
@@ -53,12 +56,22 @@ class ProfilerCommunication
 private:
     tstring m_key;
     tstring m_namespace;
+    tstring m_processName;
 
     template<class BR, class PR>
     void RequestInformation(BR buildRequest, PR processResults, DWORD dwTimeout, tstring message);
 
     ULONG m_bufferId;
 
+    bool TestSemaphore(CSemaphoreEx &semaphore){
+        // the previous value should always be zero unless the host process has released 
+        // and that means we have disposed of the shared memory
+        if (hostCommunicationActive && semaphore.ReleaseAndWait() != 0) {
+            hostCommunicationActive = false;
+        }
+        return hostCommunicationActive;
+    }
+
 private:
     CMutex m_mutexCommunication;
     CSharedMemory m_memoryCommunication;
@@ -66,12 +79,14 @@ class ProfilerCommunication
     CEvent m_eventInformationReadyForProfiler;
     CEvent m_eventInformationReadByProfiler;
     MSG_Union *m_pMSG;
+    CSemaphoreEx _semapore_communication;
 
 private:
     CSharedMemory m_memoryResults;
     CEvent m_eventProfilerHasResults;
     CEvent m_eventResultsHaveBeenReceived;
     MSG_SendVisitPoints_Request *m_pVisitPoints;
+    CSemaphoreEx _semapore_results;
 
 private:
     ATL::CComAutoCriticalSection m_critResults;
diff --git a/main/OpenCover.Profiler/ReleaseTrace.h b/main/OpenCover.Profiler/ReleaseTrace.h
index 4f96b0bf3..c5a6ab0f8 100644
--- a/main/OpenCover.Profiler/ReleaseTrace.h
+++ b/main/OpenCover.Profiler/ReleaseTrace.h
@@ -13,8 +13,8 @@ class CReleaseTrace
 	    {
 	}
 
-	const char* PREFIX = "OpenCover: ";
-	const wchar_t* WPREFIX = L"OpenCover: ";
+	const char* PREFIX = "OpenCover: (Profiler) ";
+	const wchar_t* WPREFIX = L"OpenCover: (Profiler) ";
 
 #pragma warning(push)
 #pragma warning(disable : 4793)
@@ -63,3 +63,8 @@ class CReleaseTrace
 };
 
 #define RELTRACE CReleaseTrace()
+
+#ifdef _DEBUG
+#undef ATLTRACE
+#define ATLTRACE CReleaseTrace()
+#endif
\ No newline at end of file
diff --git a/main/OpenCover.Profiler/SharedMemory.cpp b/main/OpenCover.Profiler/SharedMemory.cpp
index 42f6c6b61..8d8fe5189 100644
--- a/main/OpenCover.Profiler/SharedMemory.cpp
+++ b/main/OpenCover.Profiler/SharedMemory.cpp
@@ -33,7 +33,7 @@ void* CSharedMemory::MapViewOfFile(DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow
     }
     void* pMappedData = ::MapViewOfFile(
         m_hMemory,
-        FILE_MAP_ALL_ACCESS,
+        SECTION_MAP_WRITE | SECTION_MAP_READ,
         dwFileOffsetHigh,
         dwFileOffsetLow,
         dwNumberOfBytesToMap
diff --git a/main/OpenCover.Profiler/Synchronization.h b/main/OpenCover.Profiler/Synchronization.h
index 44da73f78..c2022712c 100644
--- a/main/OpenCover.Profiler/Synchronization.h
+++ b/main/OpenCover.Profiler/Synchronization.h
@@ -5,6 +5,8 @@
 //
 #pragma once
 
+#include "ReleaseTrace.h"
+
 class CMutex
 {
 public:
@@ -22,6 +24,47 @@ class CMutex
 	void CloseHandle() {if (m_hMutex!=NULL) { ::CloseHandle(m_hMutex); m_hMutex=NULL; }}
 };
 
+class CSemaphore
+{
+public:
+    CSemaphore() : m_hSemaphore(NULL) {}
+    ~CSemaphore() { CloseHandle(); }
+    bool IsValid() { return m_hSemaphore != NULL; }
+
+public:
+    void Initialise(const TCHAR * pName) { CloseHandle(); m_hSemaphore = ::CreateSemaphore(NULL, 0, 2, pName); _handleName = pName; }
+    void Enter(){ if (IsValid()) { ::WaitForSingleObject(m_hSemaphore, INFINITE); } }
+    void Leave(){ if (IsValid()) { ::ReleaseSemaphore(m_hSemaphore, 1, NULL); } }
+
+protected:
+    HANDLE m_hSemaphore;
+    tstring _handleName;
+
+private:
+    void CloseHandle() { if (IsValid()) { ::CloseHandle(m_hSemaphore); m_hSemaphore = NULL; } }
+};
+
+class CSemaphoreEx : public CSemaphore {
+public:
+    LONG ReleaseAndWait() {
+        if (IsValid()) {
+            LONG prevCount = -1;
+            if (::ReleaseSemaphore(m_hSemaphore, 1, &prevCount) && prevCount == 0){ // +1
+                if (::WaitForSingleObject(m_hSemaphore, 1000) == WAIT_TIMEOUT){     // -1
+                    RELTRACE(_T("Semaphore wait timed out => %s"), _handleName.c_str());
+                    return -1;
+                }
+            }
+            else {
+                RELTRACE(_T("Semaphore count failed => %s, %d"), _handleName.c_str(), prevCount);
+            }
+            return prevCount;
+        }
+        return -1;
+    }
+
+};
+
 template<class T>
 class CScopedLock
 {
diff --git a/main/OpenCover.Test/Framework/CommandLineParserTests.cs b/main/OpenCover.Test/Framework/CommandLineParserTests.cs
index 73ab1dcfe..1f9deaf4a 100644
--- a/main/OpenCover.Test/Framework/CommandLineParserTests.cs
+++ b/main/OpenCover.Test/Framework/CommandLineParserTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using OpenCover.Framework;
@@ -733,5 +734,24 @@ public void InvalidServiceStartTimeoutThrowsException(string invalidTimeout)
             Assert.That(thrownException.Message, Contains.Substring("servicestarttimeout"));
             Assert.That(thrownException.Message, Contains.Substring(invalidTimeout));
         }
+
+        [Test]
+        [TestCase("-{nunit-console*}[*]* -{pdb*}[*]* -{nunit-agent*}[*]*")]
+        [TestCase("-[System*]* -[Xyz*]* -[Zap*]*")]
+        [TestCase("-{nunit-console*}[System*]* -[Xyz*]* -{nunit-agent*}[Zap*]*")]
+        public void FilterParsing_NonGreedy(string filterArg)
+        {
+            var parser = new CommandLineParser(GetFilter(filterArg, false).ToArray()).Do(_ => _.ExtractAndValidateArguments());
+
+            // assert
+            Assert.AreEqual(3, parser.Filters.Count);
+        }
+
+        static IEnumerable<string> GetFilter(string filterArg, bool defaultFilters)
+        {
+            yield return "-target:t";
+            yield return string.Format("-filter:\"{0}\"", filterArg);
+            if (!defaultFilters) yield return "-nodefaultfilters";
+        }
     }
 }
diff --git a/main/OpenCover.Test/Framework/Communication/MessageHandlerTests.cs b/main/OpenCover.Test/Framework/Communication/MessageHandlerTests.cs
index a8cd1bdb9..52b16cc6b 100644
--- a/main/OpenCover.Test/Framework/Communication/MessageHandlerTests.cs
+++ b/main/OpenCover.Test/Framework/Communication/MessageHandlerTests.cs
@@ -49,7 +49,7 @@ public void Handles_MSG_TrackAssembly()
 
             // assert
             Container.GetMock<IProfilerCommunication>()
-                .Verify(x=>x.TrackAssembly(It.IsAny<string>(), It.IsAny<string>()), Times.Once());
+                .Verify(x => x.TrackAssembly(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once());
 
         }
 
@@ -87,7 +87,6 @@ public void Handles_MSG_AllocateMemoryBuffer()
             Instance.StandardMessage(MSG_Type.MSG_AllocateMemoryBuffer, _mockCommunicationBlock.Object, (i, block) => { }, block => { });
 
             // assert
-            uint uniqueId;
             Container.GetMock<IMemoryManager>()
                 .Verify(x => x.AllocateMemoryBuffer(It.IsAny<int>(), out bufferId), Times.Once());
 
@@ -107,7 +106,7 @@ public void Handles_MSG_GetSequencePoints()
             // assert
             InstrumentationPoint[] points;
             Container.GetMock<IProfilerCommunication>()
-                .Verify(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points), Times.Once());
+                .Verify(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points), Times.Once());
 
         }
 
@@ -120,8 +119,9 @@ public void Handles_MSG_GetSequencePoints_Small()
                 .Returns(new MSG_GetSequencePoints_Request());
 
             var points = Enumerable.Repeat(new InstrumentationPoint(), 2).ToArray();
+            Assert.NotNull(points);
             Container.GetMock<IProfilerCommunication>()
-                .Setup(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
+                .Setup(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
 
             var chunked = false;
             // act
@@ -143,10 +143,11 @@ public void Handles_MSG_GetSequencePoints_Large_StartsToChunk()
                 .Returns(new MSG_GetSequencePoints_Request());
 
             var points = Enumerable.Repeat(new InstrumentationPoint(), 10000).ToArray();
+            Assert.NotNull(points);
 
             //var points = new[] { new SequencePoint(), new SequencePoint(), new SequencePoint(), new SequencePoint(), new SequencePoint(), new SequencePoint() };
             Container.GetMock<IProfilerCommunication>()
-                .Setup(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
+                .Setup(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
             
             var chunked = false;
             // act
@@ -174,7 +175,7 @@ public void Handles_MSG_GetBranchPoints()
             // assert
             BranchPoint[] points;
             Container.GetMock<IProfilerCommunication>()
-                .Verify(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points), Times.Once());
+                .Verify(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points), Times.Once());
 
         }
 
@@ -187,8 +188,10 @@ public void Handles_MSG_GetBranchPoints_Small()
                 .Returns(new MSG_GetBranchPoints_Request());
 
             var points = Enumerable.Repeat(new BranchPoint(), 2).ToArray();
+            Assert.NotNull(points);
+
             Container.GetMock<IProfilerCommunication>()
-                .Setup(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
+                .Setup(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
 
             var chunked = false;
             // act
@@ -210,9 +213,10 @@ public void Handles_MSG_GetBranchPoints_Large_StartsToChunk()
                 .Returns(new MSG_GetBranchPoints_Request());
 
             var points = Enumerable.Repeat(new BranchPoint(), 10000).ToArray();
+            Assert.NotNull(points);
 
             Container.GetMock<IProfilerCommunication>()
-                .Setup(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
+                .Setup(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points));
 
             var chunked = false;
             // act
@@ -242,6 +246,31 @@ public void WhenComplete_Stop_ProfilerCommunication()
             Container.GetMock<IProfilerCommunication>().Verify(x => x.Stopping(), Times.Once());
         }
 
+        [Test]
+        public void Handles_MSG_CloseChannel_ReturnsDoneAsTrue()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_CloseChannel_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_CloseChannel_Request());
+
+            var response = new MSG_CloseChannel_Response { done = false };
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.StructureToPtr(It.IsAny<MSG_CloseChannel_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
+                .Callback<MSG_CloseChannel_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_CloseChannel, _mockCommunicationBlock.Object,
+                (i, block) => { },
+                block => { });
+
+            // assert
+            Assert.AreEqual(true, response.done);
+            Container.GetMock<IMemoryManager>()
+                .Verify(x => x.DeactivateMemoryBuffer(It.IsAny<uint>()), Times.Once);
+
+        }
+
         [Test]
         public void ExceptionDuring_MSG_GetSequencePoints_ReturnsLastBlockAsEmpty()
         {
@@ -251,15 +280,16 @@ public void ExceptionDuring_MSG_GetSequencePoints_ReturnsLastBlockAsEmpty()
                 .Returns(new MSG_GetSequencePoints_Request());
 
             var points = Enumerable.Repeat(new SequencePoint(), 100).ToArray<InstrumentationPoint>();
+            Assert.NotNull(points);
 
             Container.GetMock<IProfilerCommunication>()
-                .Setup(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points))
+                .Setup(x => x.GetSequencePoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points))
                 .Throws<NullReferenceException>();
 
-            var response = new MSG_GetSequencePoints_Response(){count = -1, more = true};
+            var response = new MSG_GetSequencePoints_Response{count = -1, more = true};
             Container.GetMock<IMarshalWrapper>()
                 .Setup(x => x.StructureToPtr(It.IsAny<MSG_GetSequencePoints_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
-                .Callback<MSG_GetSequencePoints_Response, IntPtr, bool>((pts, ptr, b) => { response = pts; });
+                .Callback<MSG_GetSequencePoints_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
 
             var chunked = false;
             
@@ -283,15 +313,16 @@ public void ExceptionDuring_MSG_GetBranchPoints_ReturnsLastBlockAsEmpty()
                 .Returns(new MSG_GetBranchPoints_Request());
 
             var points = Enumerable.Repeat(new BranchPoint(), 100).ToArray();
+            Assert.NotNull(points);
 
             Container.GetMock<IProfilerCommunication>()
-                .Setup(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points))
+                .Setup(x => x.GetBranchPoints(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out points))
                 .Throws<NullReferenceException>();
 
-            var response = new MSG_GetBranchPoints_Response() { count = -1, more = true };
+            var response = new MSG_GetBranchPoints_Response { count = -1, more = true };
             Container.GetMock<IMarshalWrapper>()
                 .Setup(x => x.StructureToPtr(It.IsAny<MSG_GetBranchPoints_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
-                .Callback<MSG_GetBranchPoints_Response, IntPtr, bool>((pts, ptr, b) => { response = pts; });
+                .Callback<MSG_GetBranchPoints_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
 
             var chunked = false;
 
@@ -305,5 +336,154 @@ public void ExceptionDuring_MSG_GetBranchPoints_ReturnsLastBlockAsEmpty()
             Assert.AreEqual(0, response.count);
             Assert.AreEqual(false, response.more);
         }
+
+        [Test]
+        public void ExceptionDuring_MSG_AllocateMemoryBuffer_ReturnsAllocatedAsFalse()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_AllocateBuffer_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_AllocateBuffer_Request());
+
+            var response = new MSG_AllocateBuffer_Response { allocated = true };
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.StructureToPtr(It.IsAny<MSG_AllocateBuffer_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
+                .Callback<MSG_AllocateBuffer_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
+
+            uint bufferId;
+            Container.GetMock<IMemoryManager>()
+                .Setup(x => x.AllocateMemoryBuffer(It.IsAny<int>(), out bufferId))
+                .Throws<NullReferenceException>();
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_AllocateMemoryBuffer, _mockCommunicationBlock.Object,
+                (i, block) => {  },
+                block => { });
+
+            // assert
+            Assert.AreEqual(false, response.allocated);
+        }
+
+        [Test]
+        public void ExceptionDuring_MSG_CloseChannel_ReturnsDoneAsTrue()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_CloseChannel_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_CloseChannel_Request());
+
+            var response = new MSG_CloseChannel_Response { done = false };
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.StructureToPtr(It.IsAny<MSG_CloseChannel_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
+                .Callback<MSG_CloseChannel_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
+
+            Container.GetMock<IMemoryManager>()
+                .Setup(x => x.DeactivateMemoryBuffer(It.IsAny<uint>()))
+                .Throws<NullReferenceException>();
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_CloseChannel, _mockCommunicationBlock.Object,
+                (i, block) => { },
+                block => { });
+
+            // assert
+            Assert.AreEqual(true, response.done);
+        }
+
+        [Test]
+        public void ExceptionDuring_MSG_TrackMethod_ReturnsTrackAsFalse()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_TrackMethod_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_TrackMethod_Request());
+
+            var response = new MSG_TrackMethod_Response { track = true };
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.StructureToPtr(It.IsAny<MSG_TrackMethod_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
+                .Callback<MSG_TrackMethod_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
+
+            uint uniqueId;
+            Container.GetMock<IProfilerCommunication>()
+                .Setup(x => x.TrackMethod(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out uniqueId))
+                .Throws<NullReferenceException>();
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_TrackMethod, _mockCommunicationBlock.Object,
+                (i, block) => { },
+                block => { });
+
+            // assert
+            Assert.AreEqual(false, response.track);
+        }
+
+        [Test]
+        public void ExceptionDuring_MSG_TrackAssembly_ReturnsTrackAsFalse()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_TrackAssembly_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_TrackAssembly_Request());
+
+            var response = new MSG_TrackAssembly_Response { track = true };
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.StructureToPtr(It.IsAny<MSG_TrackAssembly_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
+                .Callback<MSG_TrackAssembly_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
+
+            Container.GetMock<IProfilerCommunication>()
+                .Setup(x => x.TrackAssembly(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
+                .Throws<NullReferenceException>();
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_TrackAssembly, _mockCommunicationBlock.Object,
+                (i, block) => { },
+                block => { });
+
+            // assert
+            Assert.AreEqual(false, response.track);
+        }
+
+        [Test]
+        public void Handles_MSG_TrackProcess()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_TrackProcess_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_TrackProcess_Request());
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_TrackProcess, _mockCommunicationBlock.Object, (i, block) => { }, block => { });
+
+            // assert
+            Container.GetMock<IProfilerCommunication>()
+                .Verify(x => x.TrackProcess(It.IsAny<string>()), Times.Once());
+
+        }
+
+        [Test]
+        public void ExceptionDuring_MSG_TrackProcess_ReturnsTrackAsFalse()
+        {
+            // arrange 
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.PtrToStructure<MSG_TrackProcess_Request>(It.IsAny<IntPtr>()))
+                .Returns(new MSG_TrackProcess_Request());
+
+            var response = new MSG_TrackProcess_Response { track = true };
+            Container.GetMock<IMarshalWrapper>()
+                .Setup(x => x.StructureToPtr(It.IsAny<MSG_TrackProcess_Response>(), It.IsAny<IntPtr>(), It.IsAny<bool>()))
+                .Callback<MSG_TrackProcess_Response, IntPtr, bool>((msg, ptr, b) => { response = msg; });
+
+            Container.GetMock<IProfilerCommunication>()
+                .Setup(x => x.TrackProcess(It.IsAny<string>()))
+                .Throws<NullReferenceException>();
+
+            // act
+            Instance.StandardMessage(MSG_Type.MSG_TrackProcess, _mockCommunicationBlock.Object,
+                (i, block) => { },
+                block => { });
+
+            // assert
+            Assert.AreEqual(false, response.track);
+        }
     }
 }
diff --git a/main/OpenCover.Test/Framework/FilterTests.cs b/main/OpenCover.Test/Framework/FilterTests.cs
index 8f9acf469..967871e28 100644
--- a/main/OpenCover.Test/Framework/FilterTests.cs
+++ b/main/OpenCover.Test/Framework/FilterTests.cs
@@ -15,69 +15,95 @@ public class FilterTests
     {
         #region TestData for AddFilter tests
 
-        public class AssemblyClassData
+        public class FilterData
         {
-            public string AssemblyClass { get; set; }
+            public FilterData()
+            {
+                ProcessResult = ".*";
+            }
+
+            public string FilterExpression { get; set; }
+            public string ProcessResult { get; set; }
             public string AssemblyResult { get; set; }
             public string ClassResult { get; set; }
             public FilterType FilterTypeResult { get; set; }
         }
 
-#pragma warning disable 169
-
-        private readonly string[] _invalidAssemblyClassPairs = { "Garbage", "+[]", "-[ ]", "[ ", " ]", "+[]]", "-[][", @"-[\]", @"+[X]\", "-[X]]", "+[X][" };
-
-        private readonly AssemblyClassData[] _assemblyClassPairs =
-                                                              {
-                                                                  new AssemblyClassData
-                                                                      {
-                                                                          AssemblyClass = "+[System]Console",
-                                                                          AssemblyResult = "System",
-                                                                          ClassResult = "Console",
-                                                                          FilterTypeResult = FilterType.Inclusion, 
-                                                                      },
-                                                                  new AssemblyClassData
-                                                                      {
-                                                                          AssemblyClass = "+[My App]Namespace",
-                                                                          AssemblyResult = "My App",
-                                                                          ClassResult = "Namespace",
-                                                                          FilterTypeResult = FilterType.Inclusion, 
-                                                                      },
-                                                                  new AssemblyClassData
-                                                                      {
-                                                                          AssemblyClass = "+[System]",
-                                                                          AssemblyResult = "System",
-                                                                          ClassResult = "",
-                                                                          FilterTypeResult = FilterType.Inclusion, 
-                                                                      },
-                                                                  new AssemblyClassData
-                                                                      {
-                                                                          AssemblyClass = "-[System.*]Console",
-                                                                          AssemblyResult = @"System\..*",
-                                                                          ClassResult = "Console",
-                                                                          FilterTypeResult = FilterType.Exclusion, 
-                                                                      },
-                                                                  new AssemblyClassData
-                                                                      {
-                                                                          AssemblyClass = "+[System]Console.*",
-                                                                          AssemblyResult = "System",
-                                                                          ClassResult = @"Console\..*",
-                                                                          FilterTypeResult = FilterType.Inclusion, 
-                                                                      },
-                                                                  new AssemblyClassData
-                                                                      {
-                                                                          AssemblyClass = "-[System.*]Console.*",
-                                                                          AssemblyResult = @"System\..*",
-                                                                          ClassResult = @"Console\..*",
-                                                                          FilterTypeResult = FilterType.Exclusion, 
-                                                                      }
-                                                              };
-#pragma warning restore 169
+        private readonly string[] _invalidFilterExpressions =
+        {
+            "Garbage", "+[]", "-[ ]", "[ ", " ]", "+[]]", "-[][",
+            @"-[\]", @"+[X]\", "-[X]]", "+[X][", "-{[*]*", "+}[*]*",
+            "+{}[*]*", "-[*]", "-[]*", "-{*}[*]", "-{*}[]*"
+        };
+
+        private readonly FilterData[] _filterExpressions =
+        {
+            new FilterData
+            {
+                FilterExpression = "+[My App]Namespace",
+                AssemblyResult = "My App",
+                ClassResult = "Namespace",
+                FilterTypeResult = FilterType.Inclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "-[System.*]Console",
+                AssemblyResult = @"System\..*",
+                ClassResult = "Console",
+                FilterTypeResult = FilterType.Exclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "+[System]Console.*",
+                AssemblyResult = "System",
+                ClassResult = @"Console\..*",
+                FilterTypeResult = FilterType.Inclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "-[System.*]Console.*",
+                AssemblyResult = @"System\..*",
+                ClassResult = @"Console\..*",
+                FilterTypeResult = FilterType.Exclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "+{*}[System.*]Console.*",
+                AssemblyResult = @"System\..*",
+                ClassResult = @"Console\..*",
+                ProcessResult = ".*",
+                FilterTypeResult = FilterType.Inclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "+[*]*",
+                AssemblyResult = ".*",
+                ClassResult = ".*",
+                FilterTypeResult = FilterType.Inclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "+{*}[*]*",
+                AssemblyResult = ".*",
+                ClassResult = ".*",
+                ProcessResult = ".*",
+                FilterTypeResult = FilterType.Inclusion,
+            },
+            new FilterData
+            {
+                FilterExpression = "-{MyApplication.*}[*]*",
+                AssemblyResult = ".*",
+                ClassResult = ".*",
+                ProcessResult = @"MyApplication\..*",
+                FilterTypeResult = FilterType.Exclusion,
+            }
+
+        };
         #endregion
 
         [Test]
         public void AddFilter_ThrowsException_WhenInvalid_AssemblyClassPair(
-            [ValueSource("_invalidAssemblyClassPairs")]string assemblyClassPair)
+            [ValueSource("_invalidFilterExpressions")]string assemblyClassPair)
         {
             // arrange
             var filter = new Filter();
@@ -89,23 +115,32 @@ public void AddFilter_ThrowsException_WhenInvalid_AssemblyClassPair(
 
         [Test]
         public void AddFilter_Adds_ValidAssemblyClassPair(
-            [ValueSource("_assemblyClassPairs")]AssemblyClassData assemblyClassPair)
+            [ValueSource("_filterExpressions")]FilterData assemblyClassPair)
         {
             // arrange
             var filter = new Filter();
 
             // act
-            filter.AddFilter(assemblyClassPair.AssemblyClass);
+            filter.AddFilter(assemblyClassPair.FilterExpression);
 
             // assert
             Assert.AreEqual(1, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ?
                 filter.InclusionFilters.Count : filter.ExclusionFilters.Count);
 
-            Assert.AreEqual(assemblyClassPair.AssemblyResult, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ?
-                filter.InclusionFilters[0].AssemblyName : filter.ExclusionFilters[0].AssemblyName);
+            Assert.AreEqual(assemblyClassPair.ProcessResult,
+                assemblyClassPair.FilterTypeResult == FilterType.Inclusion ? 
+                filter.InclusionFilters[0].ProcessName
+                    : filter.ExclusionFilters[0].ProcessName);
 
-            Assert.AreEqual(assemblyClassPair.ClassResult, assemblyClassPair.FilterTypeResult == FilterType.Inclusion ?
-                filter.InclusionFilters[0].ClassName : filter.ExclusionFilters[0].ClassName);
+            Assert.AreEqual(assemblyClassPair.AssemblyResult,
+                assemblyClassPair.FilterTypeResult == FilterType.Inclusion ? 
+                filter.InclusionFilters[0].AssemblyName
+                    : filter.ExclusionFilters[0].AssemblyName);
+
+            Assert.AreEqual(assemblyClassPair.ClassResult, 
+                assemblyClassPair.FilterTypeResult == FilterType.Inclusion ? 
+                filter.InclusionFilters[0].ClassName
+                : filter.ExclusionFilters[0].ClassName);
         }
 
         #region Test Data for UseAssembly tests
@@ -173,7 +208,7 @@ public void UseAssembly_Tests(
             data.Filters.ForEach(filter.AddFilter);
 
             // act
-            var result = filter.UseAssembly(data.Assembly);
+            var result = filter.UseAssembly("processName.exe", data.Assembly);
 
             // result
             Assert.AreEqual(data.ExpectedResult, result,
@@ -698,7 +733,7 @@ public void CanHandle_AssemblyFilters_ExpressedAs_RegularExpressions(string asse
             // act
 
             // assert
-            Assert.AreEqual(canUse, filter.UseAssembly(assembly));
+            Assert.AreEqual(canUse, filter.UseAssembly("processName.exe", assembly));
         }
 
         [Test]
@@ -757,7 +792,44 @@ public void Can_BuildFilter_From_CommandLine(string[] commandLine, bool matchAss
         {
             var filter = Filter.BuildFilter(new CommandLineParser(commandLine).Do(_ => _.ExtractAndValidateArguments()));
             Assert.IsNotNull(filter);
-            Assert.AreEqual(matchAssembly, filter.UseAssembly("System"));
+            Assert.AreEqual(matchAssembly, filter.UseAssembly("processName.exe", "System"));
+        }
+
+        [Test]
+        [TestCase("+{*}[*]*", null, true, false)]
+        [TestCase("-{*}[*]*", "process.exe", true, false)]
+        [TestCase("-{pro*}[*]*", "process.exe", true, false)]
+        [TestCase("-{*cess}[*]*", "process.exe", true, false)]
+        [TestCase("+{*}[*]*", "process.exe", true, true)]
+        [TestCase("+{pro*}[*]*", "process.exe", true, true)]
+        [TestCase("+{*cess}[*]*", "process.exe", true, true)]
+        [TestCase("-{*}[*]* +{pro*}[*]*", "process.exe", true, false)]
+        [TestCase("+{abc*}[*]* +{pro*}[*]*", "process.exe", true, true)]
+        [TestCase("-{*}[ABC*]* +[*]*", "process.exe", true, true)]
+        [TestCase("-{*}[ABC*]* +{*}[*]*", "process.exe", false, true)]
+        [TestCase("-{pro*}[D*F]* +[*]*", "process.exe", false, true)]
+        [TestCase("-{*cess}[*GHI]* +[*]*", "process.exe", false, true)]
+        [TestCase("+{ABC}[*]*", "process.exe", false, false)]
+        [TestCase("+{pro*}[*]*", "process.exe", false, true)]
+        public void CanFilterByProcessName(string filterArg, string processName, bool defaultFilters, bool expected)
+        {
+            // arrange
+            var filter = Filter.BuildFilter(new CommandLineParser(GetFilter(filterArg, defaultFilters).ToArray()).Do(_ => _.ExtractAndValidateArguments()));
+
+            // act
+            var instrument = filter.InstrumentProcess(processName);
+
+            // assert
+            Assert.AreEqual(expected, instrument);
+        }
+
+        static IEnumerable<string> GetFilter(string filterArg, bool defaultFilters)
+        {
+            yield return "-target:t";
+            yield return string.Format("-filter:\"{0}\"", filterArg);
+            if (!defaultFilters) yield return "-nodefaultfilters";
         }
+
+        
     }
 }
diff --git a/main/OpenCover.Test/Framework/Manager/MemoryManagerTests.cs b/main/OpenCover.Test/Framework/Manager/MemoryManagerTests.cs
new file mode 100644
index 000000000..ad4509d24
--- /dev/null
+++ b/main/OpenCover.Test/Framework/Manager/MemoryManagerTests.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using OpenCover.Framework.Manager;
+
+namespace OpenCover.Test.Framework.Manager
+{
+    [TestFixture]
+    public class MemoryManagerTests
+    {
+        private MemoryManager _manager;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _manager = new MemoryManager();
+            _manager.Initialise("Local", "C#", new String[0]);
+        }
+
+        [TearDown]
+        public void Teardown()
+        {
+            _manager.Dispose();
+        }
+
+        [Test]
+        public void DeactivateMemoryBuffer_SetsActive_ForBlock_False()
+        {
+            // arrange
+            uint bufferId;
+            _manager.AllocateMemoryBuffer(100, out bufferId);
+            Assert.AreEqual(1, _manager.GetBlocks.Count);
+            Assert.IsTrue(_manager.GetBlocks.First().Active);
+
+            // act
+            _manager.DeactivateMemoryBuffer(bufferId);
+
+            // assert
+            Assert.IsFalse(_manager.GetBlocks.First().Active);
+        }
+
+        [Test]
+        public void RemoveDeactivatedBlocks_RemovesAllBlocks_ThatHaveActiveFalse()
+        {
+            // arrange
+            uint bufferId;
+            _manager.AllocateMemoryBuffer(100, out bufferId);
+            _manager.AllocateMemoryBuffer(100, out bufferId);
+            Assert.AreEqual(2, _manager.GetBlocks.Count);
+            Assert.AreEqual(2, _manager.GetBlocks.Count(b => b.Active));
+            _manager.DeactivateMemoryBuffer(bufferId);
+            Assert.AreEqual(2, _manager.GetBlocks.Count);
+            Assert.AreEqual(1, _manager.GetBlocks.Count(b => b.Active));
+            
+            // act
+            _manager.RemoveDeactivatedBlocks();
+
+            // assert
+            Assert.AreEqual(1, _manager.GetBlocks.Count);
+            Assert.AreEqual(1, _manager.GetBlocks.Count(b => b.Active));
+        }
+    }
+}
\ No newline at end of file
diff --git a/main/OpenCover.Test/Framework/Manager/ProfilerManagerTests.cs b/main/OpenCover.Test/Framework/Manager/ProfilerManagerTests.cs
index a2a91a743..999053948 100644
--- a/main/OpenCover.Test/Framework/Manager/ProfilerManagerTests.cs
+++ b/main/OpenCover.Test/Framework/Manager/ProfilerManagerTests.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Specialized;
-using System.Diagnostics;
 using System.Linq;
 using System.Security.AccessControl;
 using System.Security.Principal;
@@ -403,6 +402,8 @@ private void RunSimpleProcess(StringDictionary dict)
 
         private void RunProcess(StringDictionary dict, Action<EventWaitHandle> getStandardMessageDataReady, Action doExtraWork)
         {
+            ProfilerManager.BufferWaitCount = 0;
+
             // arrange
             EventWaitHandle standardMessageDataReady = null;
 
diff --git a/main/OpenCover.Test/Framework/Model/InstrumentationModelBuilderTests.cs b/main/OpenCover.Test/Framework/Model/InstrumentationModelBuilderTests.cs
index 8766f346b..fee20efd6 100644
--- a/main/OpenCover.Test/Framework/Model/InstrumentationModelBuilderTests.cs
+++ b/main/OpenCover.Test/Framework/Model/InstrumentationModelBuilderTests.cs
@@ -23,7 +23,7 @@ public void BuildModuleModel_Gets_ModulePath_From_SymbolReader()
                 .Returns("ModulePath");
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -44,7 +44,7 @@ public void BuildModuleModel_Gets_ModuleName_From_SymbolReader()
                 .Returns("ModuleName");
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -64,7 +64,7 @@ public void BuildModuleModel_GetsClasses_From_SymbolReader()
                 .Returns(new[] {@class});
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -88,7 +88,7 @@ public void BuildModuleModel_DoesNotGetMethods_For_SkippedClasses()
                 .Returns(new[] { @class });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -119,7 +119,7 @@ public void BuildModuleModel_Gets_DeclaredMethods_From_SymbolReader()
                 .Returns(new[] { new SequencePoint() });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -150,7 +150,7 @@ public void BuildModuleModel_Gets_SequencePoints_From_SymbolReader()
                 .Returns(new[] { seqPoint });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -204,7 +204,7 @@ public void CanBuildModelOf_RealAssembly()
                 .Returns(System.IO.Path.Combine(Environment.CurrentDirectory, "OpenCover.Test.dll"));
             
             Container.GetMock<IFilter>()
-               .Setup(x => x.UseAssembly(It.IsAny<string>()))
+               .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                .Returns(true);
 
             // act
@@ -273,7 +273,7 @@ public void BuildModuleModel_MethodPoint_WhenOffsetZero()
                 .Returns(new[] { seqPoint });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -304,7 +304,7 @@ public void BuildModuleModel_MethodPoint_WhenOffsetGreaterThanZero()
                 .Returns(new[] { seqPoint });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -340,7 +340,7 @@ public void BuildModuleModel_Gets_BranchPoints_WhenHaveSequencePoints()
                 .Returns(new[] { brPoint });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
@@ -371,7 +371,7 @@ public void BuildModuleModel_Gets_NoBranchPoints_WhenNoSequencePoints()
                 .Returns(new[] { brPoint });
 
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             // act
diff --git a/main/OpenCover.Test/Framework/Persistance/BasePersistenceTests.cs b/main/OpenCover.Test/Framework/Persistance/BasePersistenceTests.cs
index 466692a0f..f53dcb00d 100644
--- a/main/OpenCover.Test/Framework/Persistance/BasePersistenceTests.cs
+++ b/main/OpenCover.Test/Framework/Persistance/BasePersistenceTests.cs
@@ -1067,7 +1067,7 @@ public void SaveVisitPoints_Warns_WhenPointID_IsOutOfRange_High()
             Instance.SaveVisitData(data.ToArray());
 
             //assert
-            Container.GetMock<ILog>().Verify(x => x.DebugFormat(It.IsAny<string>(),
+            Container.GetMock<ILog>().Verify(x => x.ErrorFormat(It.IsAny<string>(),
                 It.IsAny<object>(), It.IsAny<object>(), It.IsAny<object>()), Times.Once());
         }
 
@@ -1083,7 +1083,7 @@ public void SaveVisitPoints_Warns_WhenPointID_IsOutOfRange_Low()
             Instance.SaveVisitData(data.ToArray());
 
             //assert
-            Container.GetMock<ILog>().Verify(x => x.DebugFormat(It.IsAny<string>(),
+            Container.GetMock<ILog>().Verify(x => x.ErrorFormat(It.IsAny<string>(),
                 It.IsAny<object>(), It.IsAny<object>(), It.IsAny<object>()), Times.Once());
         }
 
diff --git a/main/OpenCover.Test/Framework/Service/ProfilerCommunicationTests.cs b/main/OpenCover.Test/Framework/Service/ProfilerCommunicationTests.cs
index 9286c6f7f..28214b4a2 100644
--- a/main/OpenCover.Test/Framework/Service/ProfilerCommunicationTests.cs
+++ b/main/OpenCover.Test/Framework/Service/ProfilerCommunicationTests.cs
@@ -18,7 +18,7 @@ public void TrackAssembly_Adds_AssemblyToModel_If_FilterUseAssembly_Returns_True
         {
             // arrange
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             Container.GetMock<IFilter>()
@@ -39,7 +39,7 @@ public void TrackAssembly_Adds_AssemblyToModel_If_FilterUseAssembly_Returns_True
                 .Returns(new Module());
 
             // act
-            var track = Instance.TrackAssembly("moduleName", "assemblyName");
+            var track = Instance.TrackAssembly("processName", "moduleName", "assemblyName");
             
             // assert
             Assert.IsTrue(track);
@@ -68,7 +68,7 @@ public void TrackAssembly_Adds_AssemblyToModel_If_FilterUseTestAssembly_Returns_
                 .Returns<Module, bool>((m, f) => m);
 
             // act
-            var track = Instance.TrackAssembly("moduleName", "assemblyName");
+            var track = Instance.TrackAssembly("processName", "moduleName", "assemblyName");
 
             // assert
             Assert.IsFalse(track);
@@ -81,7 +81,7 @@ public void TrackAssembly_Adds_AssemblyToModel_AsSkipped_If_FilterUseAssembly_Re
         {
             // arrange
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(false);
 
             var mockModelBuilder = new Mock<IInstrumentationModelBuilder>();
@@ -94,7 +94,7 @@ public void TrackAssembly_Adds_AssemblyToModel_AsSkipped_If_FilterUseAssembly_Re
                 .Returns(new Module());
 
             // act
-            var track = Instance.TrackAssembly("moduleName", "assemblyName");
+            var track = Instance.TrackAssembly("processName", "moduleName", "assemblyName");
 
             // assert
             Assert.IsFalse(track);
@@ -107,7 +107,7 @@ public void TrackAssembly_Adds_AssemblyToModel_AsSkipped_If_CanInstrument_Return
         {
             // arrange
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             Container.GetMock<IFilter>()
@@ -128,7 +128,7 @@ public void TrackAssembly_Adds_AssemblyToModel_AsSkipped_If_CanInstrument_Return
                 .Returns(false);
 
             // act
-            var track = Instance.TrackAssembly("moduleName", "assemblyName");
+            var track = Instance.TrackAssembly("processName", "moduleName", "assemblyName");
 
             // assembly
             Assert.IsFalse(track);
@@ -142,7 +142,7 @@ public void TrackAssembly_Adds_AssemblyToModel_AsSkipped_If_ExcludedByAttribute(
         {
             // arrange
             Container.GetMock<IFilter>()
-                .Setup(x => x.UseAssembly(It.IsAny<string>()))
+                .Setup(x => x.UseAssembly(It.IsAny<string>(), It.IsAny<string>()))
                 .Returns(true);
 
             Container.GetMock<IFilter>()
@@ -163,7 +163,7 @@ public void TrackAssembly_Adds_AssemblyToModel_AsSkipped_If_ExcludedByAttribute(
                 .Returns(true);
 
             // act
-            var track = Instance.TrackAssembly("moduleName", "assemblyName");
+            var track = Instance.TrackAssembly("processName", "moduleName", "assemblyName");
 
             // assembly
             Assert.IsFalse(track);
@@ -198,12 +198,12 @@ public void GetSequencePoints_Returns_False_When_No_Data_In_Model()
                .Setup(x => x.IsTracking(It.IsAny<string>()))
                .Returns(true);
             Container.GetMock<IFilter>()
-               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>()))
+               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                .Returns(true);
 
             // act
             InstrumentationPoint[] instrumentPoints;
-            var result = Instance.GetSequencePoints("moduleName", "moduleName", 1, out instrumentPoints);
+            var result = Instance.GetSequencePoints("processName", "moduleName", "moduleName", 1, out instrumentPoints);
 
             // assert
             Assert.IsFalse(result);
@@ -224,7 +224,7 @@ public void GetSequencePoints_Returns_False_When_Not_Tracking_Assembly()
            
             // act
             InstrumentationPoint[] instrumentPoints;
-            var result = Instance.GetSequencePoints("moduleName", "moduleName", 1, out instrumentPoints);
+            var result = Instance.GetSequencePoints("processName", "moduleName", "moduleName", 1, out instrumentPoints);
 
             // assert
             Assert.IsFalse(result);
@@ -249,7 +249,7 @@ public void GetSequencePoints_Returns_False_When_Not_Tracking_Class()
 
             // act
             InstrumentationPoint[] instrumentPoints;
-            var result = Instance.GetSequencePoints("moduleName", "moduleName", 1, out instrumentPoints);
+            var result = Instance.GetSequencePoints("processName", "moduleName", "moduleName", 1, out instrumentPoints);
 
             // assert
             Assert.IsFalse(result);
@@ -270,12 +270,12 @@ public void GetSequencePoints_Returns_SequencePoints_When_Data_In_Model()
                .Setup(x => x.IsTracking(It.IsAny<string>()))
                .Returns(true);
             Container.GetMock<IFilter>()
-               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>()))
+               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                .Returns(true);
 
             // act
             InstrumentationPoint[] instrumentPoints;
-            var result = Instance.GetSequencePoints("moduleName", "moduleName", 1, out instrumentPoints);
+            var result = Instance.GetSequencePoints("processName", "moduleName", "moduleName", 1, out instrumentPoints);
 
             // assert
             Assert.IsTrue(result);
@@ -296,12 +296,12 @@ public void GetBranchPoints_Returns_False_When_No_Data_In_Model()
                .Setup(x => x.IsTracking(It.IsAny<string>()))
                .Returns(true);
             Container.GetMock<IFilter>()
-               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>()))
+               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                .Returns(true);
 
             // act
             BranchPoint[] instrumentPoints;
-            var result = Instance.GetBranchPoints("moduleName", "moduleName", 1, out instrumentPoints);
+            var result = Instance.GetBranchPoints("processName", "moduleName", "moduleName", 1, out instrumentPoints);
 
             // assert
             Assert.IsFalse(result);
@@ -312,7 +312,7 @@ public void GetBranchPoints_Returns_False_When_No_Data_In_Model()
         public void GetBranchPoints_Returns_SequencePoints_When_Data_In_Model()
         {
             // arrange
-            var points = new[] { new BranchPoint(),  };
+            var points = new[] { new BranchPoint() };
             Container.GetMock<IPersistance>()
                 .Setup(x => x.GetBranchPointsForFunction(It.IsAny<string>(), It.IsAny<int>(), out points))
                 .Returns(true)
@@ -321,12 +321,12 @@ public void GetBranchPoints_Returns_SequencePoints_When_Data_In_Model()
                .Setup(x => x.IsTracking(It.IsAny<string>()))
                .Returns(true);
             Container.GetMock<IFilter>()
-               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>()))
+               .Setup(x => x.InstrumentClass(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                .Returns(true);
 
             // act
             BranchPoint[] instrumentPoints;
-            var result = Instance.GetBranchPoints("moduleName", "moduleName", 1, out instrumentPoints);
+            var result = Instance.GetBranchPoints("processName", "moduleName", "moduleName", 1, out instrumentPoints);
 
             // assert
             Assert.IsTrue(result);
@@ -344,7 +344,7 @@ public void TrackMethod_True_WhenMethodIsTracked()
                 .Returns(true);
 
             // act
-            uint uniqueId = 0;
+            uint uniqueId;
             var result = Instance.TrackMethod("", "", 0, out uniqueId);
 
             // assert
@@ -356,18 +356,32 @@ public void TrackMethod_True_WhenMethodIsTracked()
         public void TrackMethod_False_When_MethodNotTracked()
         {
             // arrange
-            uint trackid = 0;
+            uint trackid;
             Container.GetMock<IPersistance>()
                 .Setup(x => x.GetTrackingMethod(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), out trackid))
                 .Returns(false);
 
             // act
-            uint uniqueId = 0;
+            uint uniqueId;
             var result = Instance.TrackMethod("", "", 0, out uniqueId);
 
             // assert
             Assert.IsFalse(result);
         }
 
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TrackProcessResponse_IsFulfilledByFilter(bool expected)
+        {
+            // arrange
+            Container.GetMock<IFilter>().Setup(x => x.InstrumentProcess(It.IsAny<string>())).Returns(expected);
+
+            // action
+            var response = Instance.TrackProcess("abc");
+
+            // assert
+            Assert.AreEqual(expected, response);
+        }
     }
 }
diff --git a/main/OpenCover.Test/OpenCover.Test.csproj b/main/OpenCover.Test/OpenCover.Test.csproj
index 629b02218..fb09b74b3 100644
--- a/main/OpenCover.Test/OpenCover.Test.csproj
+++ b/main/OpenCover.Test/OpenCover.Test.csproj
@@ -147,6 +147,7 @@
     <Compile Include="Framework\CommandLineParserBaseTests.cs" />
     <Compile Include="Framework\CommandLineParserTests.cs" />
     <Compile Include="Framework\FilterTests.cs" />
+    <Compile Include="Framework\Manager\MemoryManagerTests.cs" />
     <Compile Include="Framework\Manager\ProfilerManagerTests.cs" />
     <Compile Include="Framework\Model\InstrumentationPointTests.cs" />
     <Compile Include="Framework\Model\InstrumentationModelBuilderTests.cs" />
diff --git a/main/OpenCover.sln b/main/OpenCover.sln
index babfb4e24..9998ffef6 100644
--- a/main/OpenCover.sln
+++ b/main/OpenCover.sln
@@ -11,6 +11,7 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.Console", "OpenCover.Console\OpenCover.Console.csproj", "{42EA7A31-2D5C-4B50-ACEA-D56C3BAB0CC2}"
 	ProjectSection(ProjectDependencies) = postProject
 		{EE9B358A-335C-43E9-BC35-853807C5E776} = {EE9B358A-335C-43E9-BC35-853807C5E776}
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E} = {0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Build", "Build", "{4337F24C-830C-4A9A-987B-2348F9222C39}"
@@ -57,8 +58,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{C4B551
 		.nuget\packages.config = .nuget\packages.config
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.Gendarme.Signer", "OpenCover.Gendarme.Signer\OpenCover.Gendarme.Signer.csproj", "{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}"
-EndProject
 Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "OpenCover.Installer", "OpenCover.Installer\OpenCover.Installer.wixproj", "{F6D7F279-F302-4741-BE54-DD75D32E378F}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.Specs", "OpenCover.Specs\OpenCover.Specs.csproj", "{5A908D9D-617E-408F-ACED-9E505693DE96}"
@@ -72,6 +71,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.UITest", "OpenCov
 		{27AD5F08-0625-4093-8782-F7936737FAB7} = {27AD5F08-0625-4093-8782-F7936737FAB7}
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenCover.3rdParty.Signer", "OpenCover.3rdParty.Signer\OpenCover.3rdParty.Signer.csproj", "{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
@@ -142,14 +143,6 @@ Global
 		{746A6B40-4570-40CB-BBE5-CEECEE9E220F}.Release|x64.Build.0 = Release|Any CPU
 		{746A6B40-4570-40CB-BBE5-CEECEE9E220F}.Release|x86.ActiveCfg = Release|Any CPU
 		{746A6B40-4570-40CB-BBE5-CEECEE9E220F}.Release|x86.Build.0 = Release|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x64.Build.0 = Debug|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x86.Build.0 = Debug|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x64.ActiveCfg = Release|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x64.Build.0 = Release|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x86.ActiveCfg = Release|Any CPU
-		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x86.Build.0 = Release|Any CPU
 		{F6D7F279-F302-4741-BE54-DD75D32E378F}.Debug|x64.ActiveCfg = Debug|x86
 		{F6D7F279-F302-4741-BE54-DD75D32E378F}.Debug|x86.ActiveCfg = Debug|x86
 		{F6D7F279-F302-4741-BE54-DD75D32E378F}.Release|x64.ActiveCfg = Release|x86
@@ -187,6 +180,14 @@ Global
 		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Release|x64.Build.0 = Release|Any CPU
 		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Release|x86.ActiveCfg = Release|Any CPU
 		{E8513153-6298-411D-9BD9-0DB0CC708D34}.Release|x86.Build.0 = Release|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x64.Build.0 = Debug|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Debug|x86.Build.0 = Debug|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x64.ActiveCfg = Release|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x64.Build.0 = Release|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x86.ActiveCfg = Release|Any CPU
+		{0B94C4BF-762B-4722-BF5A-30E7F6D2CB7E}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/main/cmdline/dogfood.cmd b/main/cmdline/dogfood.cmd
index 0dc450f87..7d00a3c70 100644
--- a/main/cmdline/dogfood.cmd
+++ b/main/cmdline/dogfood.cmd
@@ -1 +1 @@
-OpenCover.Console.exe -register:user -target:..\..\..\main\packages\NUnit.Runners.2.6.4\tools\nunit-console-x86.exe -targetargs:"OpenCover.Test.dll /noshadow /exclude:AdminOnly" -filter:"+[Open*]* -[OpenCover.T*]*" -output:opencovertests.xml
+OpenCover.Console.exe -register:user -target:..\..\..\main\packages\NUnit.Runners.2.6.4\tools\nunit-console-x86.exe -targetargs:"OpenCover.Test.dll /noshadow /exclude:AdminOnly" -filter:"+[Open*]* -[OpenCover.T*]* -{nunit-console*}[*]* -{pdb*}[*]*" -output:opencovertests.xml
diff --git a/main/cmdline/report_coverage.cmd b/main/cmdline/report_coverage.cmd
index c81f1c1fc..49b7c453d 100644
--- a/main/cmdline/report_coverage.cmd
+++ b/main/cmdline/report_coverage.cmd
@@ -1 +1 @@
-..\..\..\main\packages\ReportGenerator.2.1.8.0\ReportGenerator.exe -reports:opencovertests.xml -targetdir:report
\ No newline at end of file
+..\..\..\main\packages\ReportGenerator.2.1.8.0\tools\ReportGenerator.exe -reports:opencovertests.xml -targetdir:report
\ No newline at end of file
diff --git a/main/packages/repositories.config b/main/packages/repositories.config
index 473154f93..9b80b5cf2 100644
--- a/main/packages/repositories.config
+++ b/main/packages/repositories.config
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <repositories>
+  <repository path="..\OpenCover.3rdParty.Signer\packages.config" />
   <repository path="..\OpenCover.Console\packages.config" />
   <repository path="..\OpenCover.Extensions\packages.config" />
   <repository path="..\OpenCover.Framework\packages.config" />