review updates and bugfixes

Author: BRUNER Patrick

src/LogExpert.Core/Classes/JsonConverters/ColumnizerJsonConverter.cs

@@ -92,6 +92,7 @@ public override object ReadJson (JsonReader reader, Type objectType, object? exi
         try
         {
             columnizerType = Type.GetType(typeName, throwOnError: false);
+            //FindColumnizerTypeByAssemblyQualifiedName(typeName);
 
             // If Type.GetType fails, try finding it manually
             if (columnizerType == null)
@@ -134,6 +135,7 @@ FileLoadException or
     private static Type FindColumnizerTypeByName (string name)
     {
         // Search all loaded assemblies for a type implementing ILogLineColumnizer with matching GetName()
+
         foreach (var currentAssembly in AppDomain.CurrentDomain.GetAssemblies())
         {
             foreach (var type in currentAssembly.GetTypes().Where(t => typeof(ILogLineColumnizer).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract))
@@ -181,15 +183,12 @@ private static Type FindColumnizerTypeByAssemblyQualifiedName (string assemblyQu
         var typeName = typeNameParts[0].Trim();
         var assemblyName = typeNameParts[1].Trim();
 
-        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Where(a => a.GetName().Name == assemblyName))
         {
-            if (assembly.GetName().Name == assemblyName)
+            var type = assembly.GetType(typeName);
+            if (type != null && typeof(ILogLineColumnizer).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
             {
-                var type = assembly.GetType(typeName);
-                if (type != null && typeof(ILogLineColumnizer).IsAssignableFrom(type) && !type.IsInterface && !type.IsAbstract)
-                {
-                    return type;
-                }
+                return type;
             }
         }
 

src/LogExpert.Core/Helpers/RegexHelper.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Concurrent;
 using System.Text.RegularExpressions;
 
@@ -18,7 +17,7 @@ public static class RegexHelper
     public static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(2);
 
     private static readonly ConcurrentDictionary<RegexCacheKey, Regex> _cache = new();
-    private const int MaxCacheSize = 100;
+    private const int MAX_CACHE_SIZE = 100;
 
     /// <summary>
     /// Creates a regex with timeout protection.
@@ -29,17 +28,11 @@ public static class RegexHelper
     /// <returns>A Regex instance with timeout protection.</returns>
     /// <exception cref="ArgumentNullException">Thrown if pattern is null.</exception>
     /// <exception cref="ArgumentException">Thrown if pattern is invalid.</exception>
-    public static Regex CreateSafeRegex(
-        string pattern,
-        RegexOptions options = RegexOptions.None,
-        TimeSpan? timeout = null)
+    public static Regex CreateSafeRegex (string pattern, RegexOptions options = RegexOptions.None, TimeSpan? timeout = null)
     {
         ArgumentNullException.ThrowIfNull(pattern);
 
-        return new Regex(
-            pattern,
-            options,
-            timeout ?? DefaultTimeout);
+        return new Regex(pattern, options, timeout ?? DefaultTimeout);
     }
 
     /// <summary>
@@ -49,16 +42,14 @@ public static Regex CreateSafeRegex(
     /// <param name="pattern">The regular expression pattern.</param>
     /// <param name="options">Regex options to use.</param>
     /// <returns>A cached Regex instance with timeout protection.</returns>
-    public static Regex GetOrCreateCached(
-        string pattern,
-        RegexOptions options = RegexOptions.None)
+    public static Regex GetOrCreateCached (string pattern, RegexOptions options = RegexOptions.None)
     {
         var key = new RegexCacheKey(pattern, options);
 
         return _cache.GetOrAdd(key, k =>
         {
             // Evict oldest entries if cache is full
-            if (_cache.Count >= MaxCacheSize)
+            if (_cache.Count >= MAX_CACHE_SIZE)
             {
                 TrimCache();
             }
@@ -73,7 +64,7 @@ public static Regex GetOrCreateCached(
     /// <param name="pattern">The pattern to validate.</param>
     /// <param name="error">Output parameter containing error message if validation fails.</param>
     /// <returns>True if the pattern is valid, false otherwise.</returns>
-    public static bool IsValidPattern(string pattern, out string? error)
+    public static bool IsValidPattern (string pattern, out string? error)
     {
         if (string.IsNullOrEmpty(pattern))
         {
@@ -103,7 +94,7 @@ public static bool IsValidPattern(string pattern, out string? error)
     /// <summary>
     /// Clears the regex cache. Useful for testing or memory management.
     /// </summary>
-    public static void ClearCache()
+    public static void ClearCache ()
     {
         _cache.Clear();
     }
@@ -113,15 +104,15 @@ public static void ClearCache()
     /// </summary>
     public static int CacheSize => _cache.Count;
 
-    private static void TrimCache()
+    private static void TrimCache ()
     {
         // Keep most recent 50 entries (half of max)
-        var toRemove = _cache.Keys.Take(_cache.Count - MaxCacheSize / 2).ToList();
+        var toRemove = _cache.Keys.Take(_cache.Count - MAX_CACHE_SIZE / 2).ToList();
         foreach (var key in toRemove)
         {
-            _cache.TryRemove(key, out _);
+            _ = _cache.TryRemove(key, out _);
         }
     }
 
-    private record RegexCacheKey(string Pattern, RegexOptions Options);
+    private record RegexCacheKey (string Pattern, RegexOptions Options);
 }

src/PluginRegistry/DefaultPluginLoader.cs

@@ -14,7 +14,7 @@ public class DefaultPluginLoader : IPluginLoader
     private static readonly Logger _logger = LogManager.GetCurrentClassLogger();
 
     /// <summary>
-    /// Loads a plugin from the specified assembly path.
+    /// Loads all plugins from the specified assembly path.
     /// </summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Catch Unexpected errors")]
     public PluginLoadResult LoadPlugin (string assemblyPath)
@@ -61,30 +61,45 @@ public PluginLoadResult LoadPlugin (string assemblyPath)
 
             _logger.Debug("Found {Count} plugin type(s) in assembly", pluginTypes.Count);
 
-            // Instantiate first plugin type
-            var pluginType = pluginTypes.First();
-            _logger.Debug("Instantiating plugin type: {Type}", pluginType.FullName);
+            // Instantiate ALL plugin types, not just the first one
+            var plugins = new List<object>();
 
-            var plugin = Activator.CreateInstance(pluginType);
+            foreach (var pluginType in pluginTypes)
+            {
+                _logger.Debug("Instantiating plugin type: {Type}", pluginType.FullName);
+
+                var plugin = Activator.CreateInstance(pluginType);
+
+                if (plugin == null)
+                {
+                    _logger.Error("Failed to instantiate plugin type: {Type}", pluginType.FullName);
+                    continue; // Skip this plugin but continue with others
+                }
+
+                plugins.Add(plugin);
+                _logger.Info("Successfully instantiated plugin: {Type}", pluginType.Name);
+            }
 
-            if (plugin == null)
+            if (plugins.Count == 0)
             {
-                _logger.Error("Failed to instantiate plugin type: {Type}", pluginType.FullName);
                 return new PluginLoadResult
                 {
                     Success = false,
-                    ErrorMessage = $"Failed to create instance of plugin type: {pluginType.FullName}",
+                    ErrorMessage = $"Failed to create instances of any plugin types in assembly",
                     Manifest = manifest
                 };
             }
 
-            _logger.Info("Successfully loaded plugin: {Type}", pluginType.Name);
+            _logger.Info("Successfully loaded {Count} plugin(s) from assembly", plugins.Count);
 
+            // For backward compatibility, return the first plugin instance
+            // The PluginRegistry will handle loading all types via LoadPluginAssembly
             return new PluginLoadResult
             {
                 Success = true,
-                Plugin = plugin,
-                Manifest = manifest
+                Plugin = plugins.First(),
+                Manifest = manifest,
+                AllPlugins = plugins
             };
         }
         catch (FileNotFoundException ex)

src/PluginRegistry/Interfaces/IPluginLoader.cs

@@ -35,10 +35,15 @@ public class PluginLoadResult
     public bool Success { get; set; }
 
     /// <summary>
-    /// The loaded plugin instance, if successful.
+    /// The loaded plugin instance, if successful (for backward compatibility, returns first plugin).
     /// </summary>
     public object? Plugin { get; set; }
 
+    /// <summary>
+    /// All loaded plugin instances when an assembly contains multiple plugins.
+    /// </summary>
+    public List<object>? AllPlugins { get; set; }
+    
     /// <summary>
     /// The plugin manifest, if available.
     /// </summary>

src/RegexColumnizer/RegexColumnizer.cs

@@ -157,7 +157,7 @@ public void Configure (ILogLineColumnizerCallback callback, string configDir)
             }
         }
 
-        string filePath = Path.Combine(configDir, $"{name}.json");
+        string filePath = Path.Join(configDir, $"{name}Columnizer.json");
 
         RegexColumnizerConfigDialog dlg = new(_config);
         if (dlg.ShowDialog() == DialogResult.OK)
@@ -283,8 +283,7 @@ private static void ValidateColumnizerName (string name)
         // Check for path traversal patterns
         if (name.Contains("..", StringComparison.OrdinalIgnoreCase) || name.Contains('~', StringComparison.OrdinalIgnoreCase))
         {
-            throw new InvalidOperationException(
-                $"Columnizer name '{name}' contains path traversal patterns which are not allowed");
+            throw new InvalidOperationException($"Columnizer name '{name}' contains path traversal patterns which are not allowed");
         }
     }
 
@@ -329,10 +328,16 @@ public void Init ()
         try
         {
             Regex = RegexHelper.GetOrCreateCached(_config.Expression, RegexOptions.Compiled);
-            var skip = Regex.GetGroupNames().Length == 1 ? 0 : 1;
+            var skip = Regex.GetGroupNames().Length == 1
+                ? 0
+                : 1;
+
             columns = [.. Regex.GetGroupNames().Skip(skip)];
         }
-        catch (Exception ex)
+        catch (Exception ex) when (ex is ArgumentException or
+                                         ArgumentNullException or
+                                         OverflowException or
+                                         RegexParseException)
         {
             Regex = null;
             columns = ["text"];