Optimize Exception Handling and Log

Flow.Launcher.Core/Configuration/Portable.cs

@@ -47,7 +47,7 @@ public void DisablePortableMode()
             }
             catch (Exception e)
             {
-                Log.Exception("|Portable.DisablePortableMode|Error occured while disabling portable mode", e);
+                Log.Exception(nameof(Portable),"Error occured while disabling portable mode", e);
             }
         }
 
@@ -71,7 +71,7 @@ public void EnablePortableMode()
             }
             catch (Exception e)
             {
-                Log.Exception("|Portable.EnablePortableMode|Error occured while enabling portable mode", e);
+                Log.Exception(nameof(Portable),"Error occured while enabling portable mode", e);
             }
         }
 

Flow.Launcher.Core/Plugin/JsonRPCPlugin.cs

@@ -42,7 +42,7 @@ public List<Result> LoadContextMenus(Result selectedResult)
             }
             catch (Exception e)
             {
-                Log.Exception($"|JsonRPCPlugin.LoadContextMenus|Exception on result <{selectedResult}>", e);
+                Log.Exception(nameof(JsonRPCPlugin), $"Exception on result <{selectedResult}>", e);
                 return null;
             }
         }
@@ -183,11 +183,11 @@ protected string Execute(ProcessStartInfo startInfo)
                     var error = standardError.ReadToEnd();
                     if (!string.IsNullOrEmpty(error))
                     {
-                        Log.Error($"|JsonRPCPlugin.Execute|{error}");
+                        Log.Error("JsonRPCPlugin", $"{error}");
                         return string.Empty;
                     }
 
-                    Log.Error("|JsonRPCPlugin.Execute|Empty standard output and standard error.");
+                    Log.Error("JsonRPCPlugin", "Empty standard output and standard error.");
                     return string.Empty;
                 }
 
@@ -204,9 +204,8 @@ protected string Execute(ProcessStartInfo startInfo)
             }
             catch (Exception e)
             {
-                Log.Exception(
-                    $"|JsonRPCPlugin.Execute|Exception for filename <{startInfo.FileName}> with argument <{startInfo.Arguments}>",
-                    e);
+                Log.Exception(nameof(JsonRPCPlugin),
+                    $"Exception for filename <{startInfo.FileName}> with argument <{startInfo.Arguments}>", e);
                 return string.Empty;
             }
         }
@@ -218,7 +217,7 @@ protected async Task<Stream> ExecuteAsync(ProcessStartInfo startInfo, Cancellati
                 using var process = Process.Start(startInfo);
                 if (process == null)
                 {
-                    Log.Error("|JsonRPCPlugin.ExecuteAsync|Can't start new process");
+                    Log.Error("JsonRPCPlugin", "Can't start new process");
                     return Stream.Null;
                 }
 
@@ -233,11 +232,11 @@ protected async Task<Stream> ExecuteAsync(ProcessStartInfo startInfo, Cancellati
 
                     if (!string.IsNullOrEmpty(error))
                     {
-                        Log.Error($"|JsonRPCPlugin.ExecuteAsync|{error}");
+                        Log.Error("JsonRPCPlugin", $"{error}");
                         return Stream.Null;
                     }
 
-                    Log.Error("|JsonRPCPlugin.ExecuteAsync|Empty standard output and standard error.");
+                    Log.Error("JsonRPCPlugin", "Empty standard output and standard error.");
                     return Stream.Null;
                 }
 
@@ -246,7 +245,8 @@ protected async Task<Stream> ExecuteAsync(ProcessStartInfo startInfo, Cancellati
             catch (Exception e)
             {
                 Log.Exception(
-                    $"|JsonRPCPlugin.ExecuteAsync|Exception for filename <{startInfo.FileName}> with argument <{startInfo.Arguments}>",
+                    "JsonRPCPlugin",
+                    $"Exception for filename <{startInfo.FileName}> with argument <{startInfo.Arguments}>",
                     e);
                 return Stream.Null;
             }
@@ -261,7 +261,7 @@ public async Task<List<Result>> QueryAsync(Query query, CancellationToken token)
             }
             catch (Exception e)
             {
-                Log.Exception($"|JsonRPCPlugin.Query|Exception when query <{query}>", e);
+                Log.Exception(nameof(JsonRPCPlugin),$"Exception when query <{query}>", e);
                 return null;
             }
         }

Flow.Launcher.Core/Plugin/PluginConfig.cs

@@ -33,7 +33,7 @@ public static List<PluginMetadata> Parse(string[] pluginDirectories)
                     }
                     catch (Exception e)
                     {
-                        Log.Exception($"|PluginConfig.ParsePLuginConfigs|Can't delete <{directory}>", e);
+                        Log.Exception(nameof(PluginConfig),$"Can't delete <{directory}>", e);
                     }
                 }
                 else
@@ -54,7 +54,7 @@ private static PluginMetadata GetPluginMetadata(string pluginDirectory)
             string configPath = Path.Combine(pluginDirectory, Constant.PluginMetadataFileName);
             if (!File.Exists(configPath))
             {
-                Log.Error($"|PluginConfig.GetPluginMetadata|Didn't find config file <{configPath}>");
+                Log.Error(nameof(PluginConfig),$"Didn't find config file <{configPath}>");
                 return null;
             }
 
@@ -70,19 +70,19 @@ private static PluginMetadata GetPluginMetadata(string pluginDirectory)
             }
             catch (Exception e)
             {
-                Log.Exception($"|PluginConfig.GetPluginMetadata|invalid json for config <{configPath}>", e);
+                Log.Exception(nameof(PluginConfig),$"invalid json for config <{configPath}>", e);
                 return null;
             }
 
             if (!AllowedLanguage.IsAllowed(metadata.Language))
             {
-                Log.Error($"|PluginConfig.GetPluginMetadata|Invalid language <{metadata.Language}> for config <{configPath}>");
+                Log.Error(nameof(PluginConfig),$"Invalid language <{metadata.Language}> for config <{configPath}>");
                 return null;
             }
 
             if (!File.Exists(metadata.ExecuteFilePath))
             {
-                Log.Error($"|PluginConfig.GetPluginMetadata|execute file path didn't exist <{metadata.ExecuteFilePath}> for conifg <{configPath}");
+                Log.Error(nameof(PluginConfig),$"execute file path didn't exist <{metadata.ExecuteFilePath}> for conifg <{configPath}");
                 return null;
             }
 

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -22,7 +22,7 @@ public static class PluginManager
 
         public static List<PluginPair> AllPlugins { get; private set; }
         public static readonly HashSet<PluginPair> GlobalPlugins = new();
-        public static readonly Dictionary<string, PluginPair> NonGlobalPlugins = new ();
+        public static readonly Dictionary<string, PluginPair> NonGlobalPlugins = new();
 
         public static IPublicAPI API { private set; get; }
 
@@ -33,7 +33,7 @@ public static class PluginManager
         /// <summary>
         /// Directories that will hold Flow Launcher plugin directory
         /// </summary>
-        private static readonly string[] Directories = { Constant.PreinstalledDirectory, DataLocation.PluginsDirectory };
+        private static readonly string[] Directories = {Constant.PreinstalledDirectory, DataLocation.PluginsDirectory};
 
         private static void DeletePythonBinding()
         {
@@ -99,12 +99,13 @@ public static async Task InitializePlugins(IPublicAPI api)
             {
                 try
                 {
-                    var milliseconds = await Stopwatch.DebugAsync($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>",
-                                                        () => pair.Plugin.InitAsync(new PluginInitContext(pair.Metadata, API)));
+                    var milliseconds = await Stopwatch.DebugAsync(nameof(PluginManager),
+                        $"Init method time cost for <{pair.Metadata.Name}>",
+                        () => pair.Plugin.InitAsync(new PluginInitContext(pair.Metadata, API)));
 
                     pair.Metadata.InitTime += milliseconds;
-                    Log.Info(
-                        $"|PluginManager.InitializePlugins|Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
+                    Log.Info(nameof(PluginManager),
+                        $"Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
                 }
                 catch (Exception e)
                 {
@@ -149,15 +150,16 @@ public static ICollection<PluginPair> ValidPluginsForQuery(Query query)
             if (NonGlobalPlugins.ContainsKey(query.ActionKeyword))
             {
                 var plugin = NonGlobalPlugins[query.ActionKeyword];
-                return new List<PluginPair> { plugin };
+                return new List<PluginPair> {plugin};
             }
             else
             {
                 return GlobalPlugins;
             }
         }
 
-        public static async Task<List<Result>> QueryForPlugin(PluginPair pair, Query query, CancellationToken token)
+        public static async Task<List<Result>> QueryForPluginAsync(PluginPair pair, Query query,
+            CancellationToken token)
         {
             var results = new List<Result>();
             try
@@ -166,12 +168,12 @@ public static async Task<List<Result>> QueryForPlugin(PluginPair pair, Query que
 
                 long milliseconds = -1L;
 
-                milliseconds = await Stopwatch.DebugAsync($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}",
+                milliseconds = await Stopwatch.DebugAsync(nameof(PluginManager), $"Cost for {metadata.Name}",
                     async () => results = await pair.Plugin.QueryAsync(query, token).ConfigureAwait(false));
 
                 token.ThrowIfCancellationRequested();
                 if (results == null)
-                    return results;
+                    return null;
                 UpdatePluginMetadata(results, metadata, query);
 
                 metadata.QueryCount += 1;
@@ -184,10 +186,6 @@ public static async Task<List<Result>> QueryForPlugin(PluginPair pair, Query que
                 // null will be fine since the results will only be added into queue if the token hasn't been cancelled
                 return null;
             }
-            catch (Exception e)
-            {
-                Log.Exception($"|PluginManager.QueryForPlugin|Exception for plugin <{pair.Metadata.Name}> when query <{query}>", e);
-            }
 
             return results;
         }
@@ -228,7 +226,7 @@ public static List<Result> GetContextMenusForPlugin(Result result)
             var pluginPair = _contextMenuPlugins.FirstOrDefault(o => o.Metadata.ID == result.PluginID);
             if (pluginPair != null)
             {
-                var plugin = (IContextMenu)pluginPair.Plugin;
+                var plugin = (IContextMenu) pluginPair.Plugin;
 
                 try
                 {
@@ -242,9 +240,8 @@ public static List<Result> GetContextMenusForPlugin(Result result)
                 }
                 catch (Exception e)
                 {
-                    Log.Exception(
-                        $"|PluginManager.GetContextMenusForPlugin|Can't load context menus for plugin <{pluginPair.Metadata.Name}>",
-                        e);
+                    Log.Exception(nameof(PluginManager),
+                        $"Can't load context menus for plugin <{pluginPair.Metadata.Name}>", e);
                 }
             }
 
@@ -309,4 +306,4 @@ public static void ReplaceActionKeyword(string id, string oldActionKeyword, stri
             }
         }
     }
-}
+}

Flow.Launcher.Core/Plugin/PluginsLoader.cs

@@ -38,8 +38,8 @@ public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
 
             foreach (var metadata in metadatas)
             {
-                var milliseconds = Stopwatch.Debug(
-                    $"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
+                var milliseconds = Stopwatch.Debug(nameof(PluginsLoader),
+                    $"Constructor init cost for {metadata.Name}", () =>
                     {
 #if DEBUG
                         var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
@@ -64,19 +64,19 @@ public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
                         }
                         catch (Exception e) when (assembly == null)
                         {
-                            Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for the plugin: {metadata.Name}", e);
+                            Log.Exception(nameof(PluginsLoader), $"Couldn't load assembly for the plugin: {metadata.Name}", e);
                         }
                         catch (InvalidOperationException e)
                         {
-                            Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
+                            Log.Exception(nameof(PluginsLoader), $"Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
                         }
                         catch (ReflectionTypeLoadException e)
                         {
-                            Log.Exception($"|PluginsLoader.DotNetPlugins|The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
+                            Log.Exception(nameof(PluginsLoader), $"The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
                         }
                         catch (Exception e)
                         {
-                            Log.Exception($"|PluginsLoader.DotNetPlugins|The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
+                            Log.Exception(nameof(PluginsLoader), $"The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
                         }
 #endif
                         if (plugin == null)

Flow.Launcher.Core/Resource/Internationalization.cs

@@ -51,7 +51,8 @@ private void AddPluginLanguageDirectories()
                 }
                 else
                 {
-                    Log.Error($"|Internationalization.AddPluginLanguageDirectories|Can't find plugin path <{location}> for <{plugin.Metadata.Name}>");
+                    Log.Error("Internationalization",
+                        $"Can't find plugin path <{location}> for <{plugin.Metadata.Name}>");
                 }
             }
         }
@@ -72,10 +73,11 @@ public void ChangeLanguage(string languageCode)
         private Language GetLanguageByLanguageCode(string languageCode)
         {
             var lowercase = languageCode.ToLower();
-            var language = AvailableLanguages.GetAvailableLanguages().FirstOrDefault(o => o.LanguageCode.ToLower() == lowercase);
+            var language = AvailableLanguages.GetAvailableLanguages()
+                .FirstOrDefault(o => o.LanguageCode.ToLower() == lowercase);
             if (language == null)
             {
-                Log.Error($"|Internationalization.GetLanguageByLanguageCode|Language code can't be found <{languageCode}>");
+                Log.Error("Internationalization", $"Language code can't be found <{languageCode}>");
                 return AvailableLanguages.English;
             }
             else
@@ -94,9 +96,9 @@ public void ChangeLanguage(Language language)
             {
                 LoadLanguage(language);
             }
+
             UpdatePluginMetadataTranslations();
             Settings.Language = language.LanguageCode;
-
         }
 
         public bool PromptShouldUsePinyin(string languageCodeToSet)
@@ -109,7 +111,8 @@ public bool PromptShouldUsePinyin(string languageCodeToSet)
             if (languageToSet != AvailableLanguages.Chinese && languageToSet != AvailableLanguages.Chinese_TW)
                 return false;
 
-            if (MessageBox.Show("Do you want to turn on search with Pinyin?", string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.No)
+            if (MessageBox.Show("Do you want to turn on search with Pinyin?", string.Empty, MessageBoxButton.YesNo) ==
+                MessageBoxResult.No)
                 return false;
 
             return true;
@@ -161,7 +164,7 @@ public string GetTranslation(string key)
             }
             else
             {
-                Log.Error($"|Internationalization.GetTranslation|No Translation for key {key}");
+                Log.Error("Internationalization", $"No Translation for key {key}");
                 return $"No Translation for key {key}";
             }
         }
@@ -179,7 +182,7 @@ private void UpdatePluginMetadataTranslations()
                 }
                 catch (Exception e)
                 {
-                    Log.Exception($"|Internationalization.UpdatePluginMetadataTranslations|Failed for <{p.Metadata.Name}>", e);
+                    Log.Exception(nameof(Internationalization), $"Failed for <{p.Metadata.Name}>", e);
                 }
             }
         }
@@ -195,15 +198,16 @@ public string LanguageFile(string folder, string language)
                 }
                 else
                 {
-                    Log.Error($"|Internationalization.LanguageFile|Language path can't be found <{path}>");
+                    Log.Error(nameof(Internationalization), $"Language path can't be found <{path}>");
                     string english = Path.Combine(folder, DefaultFile);
                     if (File.Exists(english))
                     {
                         return english;
                     }
                     else
                     {
-                        Log.Error($"|Internationalization.LanguageFile|Default English Language path can't be found <{path}>");
+                        Log.Error(nameof(Internationalization),
+                            $"Default English Language path can't be found <{path}>");
                         return string.Empty;
                     }
                 }

Flow.Launcher.Core/Resource/Theme.cs

@@ -63,7 +63,7 @@ private void MakesureThemeDirectoriesExist()
                     }
                     catch (Exception e)
                     {
-                        Log.Exception($"|Theme.MakesureThemeDirectoriesExist|Exception when create directory <{dir}>", e);
+                        Log.Exception(nameof(Theme),$"Exception when create directory <{dir}>", e);
                     }
                 }
             }
@@ -93,7 +93,7 @@ public bool ChangeTheme(string theme)
             }
             catch (DirectoryNotFoundException e)
             {
-                Log.Error($"|Theme.ChangeTheme|Theme <{theme}> path can't be found");
+                Log.Error(nameof(Theme),$"Theme <{theme}> path can't be found");
                 if (theme != defaultTheme)
                 {
                     MessageBox.Show(string.Format(InternationalizationManager.Instance.GetTranslation("theme_load_failure_path_not_exists"), theme));
@@ -103,7 +103,7 @@ public bool ChangeTheme(string theme)
             }
             catch (XamlParseException e)
             {
-                Log.Error($"|Theme.ChangeTheme|Theme <{theme}> fail to parse");
+                Log.Error(nameof(Theme),$"Theme <{theme}> fail to parse");
                 if (theme != defaultTheme)
                 {
                     MessageBox.Show(string.Format(InternationalizationManager.Instance.GetTranslation("theme_load_failure_parse_error"), theme));