Add some more verbose logging

govert · govert · commit 418eceba30ed · 2015-07-20T00:31:56.000+02:00
diff --git a/Source/ExcelDna.Integration/AssemblyLoader.cs b/Source/ExcelDna.Integration/AssemblyLoader.cs
@@ -58,6 +58,8 @@ public static void ProcessAssemblies(
 
             foreach (ExportedAssembly assembly in assemblies)
             {
+                Logger.Initialization.Verbose("Processing assembly {0}. ExplicitExports {1}, ExplicitRegistration {2}, ComServer {3}, IsDynamic {4}", 
+                    assembly.Assembly.FullName, assembly.ExplicitExports, assembly.ExplicitRegistration, assembly.ComServer, assembly.IsDynamic);
                 // Patch contributed by y_i on CodePlex:
                 // http://stackoverflow.com/questions/11915389/assembly-gettypes-throwing-an-exception
                 Type[] types;
@@ -80,6 +82,8 @@ public static void ProcessAssemblies(
                 foreach (Type type in types)
                 {
                     if (type == null) continue; // We might get nulls from ReflectionTypeLoadException above
+
+                    Logger.Initialization.Verbose("Processing type {0}", type.FullName);
                     try
                     {
                         object[] attribs = type.GetCustomAttributes(false);
@@ -96,12 +100,11 @@ public static void ProcessAssemblies(
                     }
                     catch (Exception e)
                     {
-                        // TODO: This is unexpected - raise to LogDisplay?
-                        Debug.Print("Type {0} could not be analysed. Error: {1}", type.FullName, e.ToString()); 
+                        Logger.Initialization.Warn("Type {0} could not be processed. Error: {1}", type.FullName, e.ToString()); 
                     }
                 }
             }
-            // Sigh. Excel server (service?) stuff is till ugly - but no reeal reason to remove it yet.
+            // Sigh. Excel server (service?) stuff is still ugly - but no real reason to remove it yet.
             AssemblyLoaderExcelServer.GetExcelServerMethods(excelServerInfos, methods);
         }
 
@@ -117,7 +120,7 @@ static void GetExcelMethods(Type t, bool explicitExports, List<MethodInfo> excel
                 t.Namespace == "My")
             {
                 // Ignored cases
-                Logger.Registration.Info("Type ignored: {0}", t.FullName);
+                Logger.Initialization.Info("Type ignored: {0}", t.FullName);
                 return;
             }
 
@@ -161,12 +164,12 @@ static bool IsMethodSupported(MethodInfo mi, bool explicitExports)
             // We want to log methods that are marked for export, but have unsupported types.
             if (!isSupported && IsMethodMarkedForExport(mi))
             {
-                Logger.Registration.Error("Method not registered - unsupported types: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);
+                Logger.Initialization.Error("Method not registered - unsupported signature, abstract or generic: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);
             }
             else if (!isSupported)
             {
                 // CONSIDER: More detailed logging
-                Logger.Registration.Info("Method not registered - unsupported types: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);
+                Logger.Initialization.Info("Method not registered - unsupported signature, abstract or generic: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);
             }
 
             return isSupported;
@@ -246,11 +249,12 @@ static public void GetExcelAddIns(ExportedAssembly assembly, Type t, bool loadRi
                     info.Instance = Activator.CreateInstance(t);
                     info.ParentDnaLibrary = assembly.ParentDnaLibrary;
                     addIns.Add(info);
+                    Logger.Registration.Verbose("GetExcelAddIns - Created add-in object of type: {0}", t.FullName);
                 }
             }
             catch (Exception e) // I think only CreateInstance can throw an exception here...
             {
-                Debug.Print("GetExcelAddIns CreateInstance problem for type: {0} - exception: {1}", t.FullName, e);
+                Logger.Initialization.Warn("GetExcelAddIns CreateInstance problem for type: {0} - exception: {1}", t.FullName, e);
             }
 
 		}
@@ -277,6 +281,7 @@ static public void GetRtdServerTypes(Type t, List<Type> rtdServerTypes, out bool
                     //rtdServerTypes[t.FullName] = t;
                     rtdServerTypes.Add(t);
                     isRtdServer = true;
+                    Logger.Initialization.Verbose("GetRtdServerTypes - Found RTD server type: {0}", t.FullName);
                 }
             }
         }
@@ -333,6 +338,7 @@ static public void GetComClassTypes(ExportedAssembly assembly, Type type, object
                     TypeLibPath = assembly.TypeLibPath
                 };
                 comClassTypes.Add(comClassType);
+                Logger.Initialization.Verbose("GetComClassTypes - Found type {0}, with ProgId {1}", type.FullName, progId);
             }
         }
 
diff --git a/Source/ExcelDna.Integration/DnaLibrary.cs b/Source/ExcelDna.Integration/DnaLibrary.cs
@@ -245,6 +245,7 @@ internal List<ExportedAssembly> GetAssemblies(string pathResolveRoot)
         // TODO: Check that the registration calls we make in SyncContext.Install are safe in the COM Server context!?
         internal void Initialize()
         {
+            Logger.Initialization.Verbose("{0} - Begin Initialize", Name);
             // Get MethodsInfos and AddIn classes from assemblies
             List<Type> rtdServerTypes = new List<Type>();
             List<ExcelComClassType> comClassTypes = new List<ExcelComClassType>();
@@ -253,7 +254,7 @@ internal void Initialize()
             _exportedAssemblies = GetAssemblies(dnaResolveRoot);
             AssemblyLoader.ProcessAssemblies(_exportedAssemblies, _methods, _addIns, rtdServerTypes, comClassTypes);
 
-            // Register RTD Server Types immediately
+            // Register RTD Server Types (i.e. remember that these types are available as RTD servers, with relevant ProgId etc.)
             RtdRegistration.RegisterRtdServerTypes(rtdServerTypes);
 
             // CAREFUL: This interacts with the implementation of ExcelRtdServer to implement the thread-safe synchronization.
@@ -268,10 +269,14 @@ internal void Initialize()
                     break;
                 }
             }
-            if (registerSyncManager) SynchronizationManager.Install();  // TODO: Careful here!?
+            if (registerSyncManager)
+            {
+                SynchronizationManager.Install();  // TODO: Careful here!?
+            }
 
             // Register COM Server Types immediately
             ComServer.RegisterComClassTypes(comClassTypes);
+            Logger.Initialization.Verbose("{0} - End Initialize", Name);
         }
 
         // Only called for the Root DnaLibrary.
@@ -305,6 +310,7 @@ internal void AutoOpen()
 
         internal void AutoClose()
         {
+            Logger.Initialization.Verbose("DnaLibrary AutoClose");
             UnloadCustomUI();
 
             foreach (AssemblyLoader.ExcelAddInInfo addIn in _addIns)
diff --git a/Source/ExcelDna.Integration/ExcelRtd.cs b/Source/ExcelDna.Integration/ExcelRtd.cs
@@ -70,8 +70,13 @@ public static void RegisterRtdServerTypes(IEnumerable<Type> rtdServerTypes)
                 {
                     ProgIdAttribute progIdAtt = (ProgIdAttribute)attrs[0];
                     registeredRtdServerTypes[progIdAtt.Value] = rtdType;
+                    Logger.Initialization.Verbose("RTD Server found - Type {0}, ProgId {1}", rtdType.FullName, progIdAtt.Value);
+                }
+                else
+                {
+                    registeredRtdServerTypes[rtdType.FullName] = rtdType;
+                    Logger.Initialization.Verbose("RTD Server found - Type {0} (No ProgId)", rtdType.FullName);
                 }
-                registeredRtdServerTypes[rtdType.FullName] = rtdType;
             }
         }
 
diff --git a/Source/ExcelDna.Integration/ExcelSynchronizationContext.cs b/Source/ExcelDna.Integration/ExcelSynchronizationContext.cs
@@ -60,18 +60,27 @@ internal static class SynchronizationManager
         // Called from the Initialize (loading COM /RTD server) and/or from AutoOpen
         internal static void Install()
         {
-            Debug.Assert(ExcelDnaUtil.IsMainThread, "SynchronizationManager must be Installed from the main Excel thread.");
+            if (!ExcelDnaUtil.IsMainThread)
+            {
+                Logger.Initialization.Error("SynchronizationManager must be Installed from the main Excel thread.");
+                return;
+            }
             if (_syncWindow == null)
             {
+                Logger.Initialization.Info("SynchronizationManager - Install");
                 _syncWindow = new SynchronizationWindow();
             }
         }
 
         internal static void Uninstall()
         {
-            Debug.Assert(ExcelDnaUtil.IsMainThread, "SynchronizationManager must be Uninstalled from the main Excel thread.");
-            _syncWindow.Dispose();
-            _syncWindow = null;
+            if (_syncWindow != null)
+            {
+                Logger.Initialization.Info("SynchronizationManager - Uninstall");
+                Debug.Assert(ExcelDnaUtil.IsMainThread, "SynchronizationManager must be Uninstalled from the main Excel thread.");
+                _syncWindow.Dispose();
+                _syncWindow = null;
+            }
         }
 
         internal static bool IsInstalled
diff --git a/Source/ExcelDna.Loader/XlRegistration.cs b/Source/ExcelDna.Loader/XlRegistration.cs
@@ -112,7 +112,7 @@ public static object GetRegistrationInfo(object param)
         static void Register(List<MethodInfo> methods, List<object> targets, List<object> methodAttributes, List<List<object>> argumentAttributes)
         {
             Debug.Assert(targets == null || targets.Count == methods.Count);
-
+            Logger.Registration.Verbose("Registering {0} methods", methods.Count);
             List<XlMethodInfo> xlMethods = XlMethodInfo.ConvertToXlMethodInfos(methods, targets, methodAttributes, argumentAttributes);
             xlMethods.ForEach(RegisterXlMethod);
             // Increment the registration version (safe to call a few times)

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,8 @@ public static void ProcessAssemblies(`
`58`	`58`
`59`	`59`	`foreach (ExportedAssembly assembly in assemblies)`
`60`	`60`	`{`
	`61`	`+ Logger.Initialization.Verbose("Processing assembly {0}. ExplicitExports {1}, ExplicitRegistration {2}, ComServer {3}, IsDynamic {4}",`
	`62`	`+ assembly.Assembly.FullName, assembly.ExplicitExports, assembly.ExplicitRegistration, assembly.ComServer, assembly.IsDynamic);`
`61`	`63`	`// Patch contributed by y_i on CodePlex:`
`62`	`64`	`// http://stackoverflow.com/questions/11915389/assembly-gettypes-throwing-an-exception`
`63`	`65`	`Type[] types;`
`@@ -80,6 +82,8 @@ public static void ProcessAssemblies(`
`80`	`82`	`foreach (Type type in types)`
`81`	`83`	`{`
`82`	`84`	`if (type == null) continue; // We might get nulls from ReflectionTypeLoadException above`
	`85`	`+`
	`86`	`+ Logger.Initialization.Verbose("Processing type {0}", type.FullName);`
`83`	`87`	`try`
`84`	`88`	`{`
`85`	`89`	`object[] attribs = type.GetCustomAttributes(false);`
`@@ -96,12 +100,11 @@ public static void ProcessAssemblies(`
`96`	`100`	`}`
`97`	`101`	`catch (Exception e)`
`98`	`102`	`{`
`99`		`- // TODO: This is unexpected - raise to LogDisplay?`
`100`		`- Debug.Print("Type {0} could not be analysed. Error: {1}", type.FullName, e.ToString());`
	`103`	`+ Logger.Initialization.Warn("Type {0} could not be processed. Error: {1}", type.FullName, e.ToString());`
`101`	`104`	`}`
`102`	`105`	`}`
`103`	`106`	`}`
`104`		`- // Sigh. Excel server (service?) stuff is till ugly - but no reeal reason to remove it yet.`
	`107`	`+ // Sigh. Excel server (service?) stuff is still ugly - but no real reason to remove it yet.`
`105`	`108`	`AssemblyLoaderExcelServer.GetExcelServerMethods(excelServerInfos, methods);`
`106`	`109`	`}`
`107`	`110`
`@@ -117,7 +120,7 @@ static void GetExcelMethods(Type t, bool explicitExports, List<MethodInfo> excel`
`117`	`120`	`t.Namespace == "My")`
`118`	`121`	`{`
`119`	`122`	`// Ignored cases`
`120`		`- Logger.Registration.Info("Type ignored: {0}", t.FullName);`
	`123`	`+ Logger.Initialization.Info("Type ignored: {0}", t.FullName);`
`121`	`124`	`return;`
`122`	`125`	`}`
`123`	`126`
`@@ -161,12 +164,12 @@ static bool IsMethodSupported(MethodInfo mi, bool explicitExports)`
`161`	`164`	`// We want to log methods that are marked for export, but have unsupported types.`
`162`	`165`	`if (!isSupported && IsMethodMarkedForExport(mi))`
`163`	`166`	`{`
`164`		`- Logger.Registration.Error("Method not registered - unsupported types: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);`
	`167`	`+ Logger.Initialization.Error("Method not registered - unsupported signature, abstract or generic: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);`
`165`	`168`	`}`
`166`	`169`	`else if (!isSupported)`
`167`	`170`	`{`
`168`	`171`	`// CONSIDER: More detailed logging`
`169`		`- Logger.Registration.Info("Method not registered - unsupported types: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);`
	`172`	`+ Logger.Initialization.Info("Method not registered - unsupported signature, abstract or generic: '{0}.{1}'", mi.DeclaringType.Name, mi.Name);`
`170`	`173`	`}`
`171`	`174`
`172`	`175`	`return isSupported;`
`@@ -246,11 +249,12 @@ static public void GetExcelAddIns(ExportedAssembly assembly, Type t, bool loadRi`
`246`	`249`	`info.Instance = Activator.CreateInstance(t);`
`247`	`250`	`info.ParentDnaLibrary = assembly.ParentDnaLibrary;`
`248`	`251`	`addIns.Add(info);`
	`252`	`+ Logger.Registration.Verbose("GetExcelAddIns - Created add-in object of type: {0}", t.FullName);`
`249`	`253`	`}`
`250`	`254`	`}`
`251`	`255`	`catch (Exception e) // I think only CreateInstance can throw an exception here...`
`252`	`256`	`{`
`253`		`- Debug.Print("GetExcelAddIns CreateInstance problem for type: {0} - exception: {1}", t.FullName, e);`
	`257`	`+ Logger.Initialization.Warn("GetExcelAddIns CreateInstance problem for type: {0} - exception: {1}", t.FullName, e);`
`254`	`258`	`}`
`255`	`259`
`256`	`260`	`}`
`@@ -277,6 +281,7 @@ static public void GetRtdServerTypes(Type t, List<Type> rtdServerTypes, out bool`
`277`	`281`	`//rtdServerTypes[t.FullName] = t;`
`278`	`282`	`rtdServerTypes.Add(t);`
`279`	`283`	`isRtdServer = true;`
	`284`	`+ Logger.Initialization.Verbose("GetRtdServerTypes - Found RTD server type: {0}", t.FullName);`
`280`	`285`	`}`
`281`	`286`	`}`
`282`	`287`	`}`
`@@ -333,6 +338,7 @@ static public void GetComClassTypes(ExportedAssembly assembly, Type type, object`
`333`	`338`	`TypeLibPath = assembly.TypeLibPath`
`334`	`339`	`};`
`335`	`340`	`comClassTypes.Add(comClassType);`
	`341`	`+ Logger.Initialization.Verbose("GetComClassTypes - Found type {0}, with ProgId {1}", type.FullName, progId);`
`336`	`342`	`}`
`337`	`343`	`}`
`338`	`344`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,13 @@ public static void RegisterRtdServerTypes(IEnumerable<Type> rtdServerTypes)`
`70`	`70`	`{`
`71`	`71`	`ProgIdAttribute progIdAtt = (ProgIdAttribute)attrs[0];`
`72`	`72`	`registeredRtdServerTypes[progIdAtt.Value] = rtdType;`
	`73`	`+ Logger.Initialization.Verbose("RTD Server found - Type {0}, ProgId {1}", rtdType.FullName, progIdAtt.Value);`
	`74`	`+ }`
	`75`	`+ else`
	`76`	`+ {`
	`77`	`+ registeredRtdServerTypes[rtdType.FullName] = rtdType;`
	`78`	`+ Logger.Initialization.Verbose("RTD Server found - Type {0} (No ProgId)", rtdType.FullName);`
`73`	`79`	`}`
`74`		`- registeredRtdServerTypes[rtdType.FullName] = rtdType;`
`75`	`80`	`}`
`76`	`81`	`}`
`77`	`82`
Original file line number	Diff line number	Diff line change
`@@ -60,18 +60,27 @@ internal static class SynchronizationManager`
`60`	`60`	`// Called from the Initialize (loading COM /RTD server) and/or from AutoOpen`
`61`	`61`	`internal static void Install()`
`62`	`62`	`{`
`63`		`- Debug.Assert(ExcelDnaUtil.IsMainThread, "SynchronizationManager must be Installed from the main Excel thread.");`
	`63`	`+ if (!ExcelDnaUtil.IsMainThread)`
	`64`	`+ {`
	`65`	`+ Logger.Initialization.Error("SynchronizationManager must be Installed from the main Excel thread.");`
	`66`	`+ return;`
	`67`	`+ }`
`64`	`68`	`if (_syncWindow == null)`
`65`	`69`	`{`
	`70`	`+ Logger.Initialization.Info("SynchronizationManager - Install");`
`66`	`71`	`_syncWindow = new SynchronizationWindow();`
`67`	`72`	`}`
`68`	`73`	`}`
`69`	`74`
`70`	`75`	`internal static void Uninstall()`
`71`	`76`	`{`
`72`		`- Debug.Assert(ExcelDnaUtil.IsMainThread, "SynchronizationManager must be Uninstalled from the main Excel thread.");`
`73`		`- _syncWindow.Dispose();`
`74`		`- _syncWindow = null;`
	`77`	`+ if (_syncWindow != null)`
	`78`	`+ {`
	`79`	`+ Logger.Initialization.Info("SynchronizationManager - Uninstall");`
	`80`	`+ Debug.Assert(ExcelDnaUtil.IsMainThread, "SynchronizationManager must be Uninstalled from the main Excel thread.");`
	`81`	`+ _syncWindow.Dispose();`
	`82`	`+ _syncWindow = null;`
	`83`	`+ }`
`75`	`84`	`}`
`76`	`85`
`77`	`86`	`internal static bool IsInstalled`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ public static object GetRegistrationInfo(object param)`
`112`	`112`	`static void Register(List<MethodInfo> methods, List<object> targets, List<object> methodAttributes, List<List<object>> argumentAttributes)`
`113`	`113`	`{`
`114`	`114`	`Debug.Assert(targets == null \|\| targets.Count == methods.Count);`
`115`		`-`
	`115`	`+ Logger.Registration.Verbose("Registering {0} methods", methods.Count);`
`116`	`116`	`List<XlMethodInfo> xlMethods = XlMethodInfo.ConvertToXlMethodInfos(methods, targets, methodAttributes, argumentAttributes);`
`117`	`117`	`xlMethods.ForEach(RegisterXlMethod);`
`118`	`118`	`// Increment the registration version (safe to call a few times)`