using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using StardewModdingAPI.Framework.Commands;
using StardewModdingAPI.Framework.Models;
using StardewModdingAPI.Framework.ModLoading;
using StardewModdingAPI.Internal.ConsoleWriting;
using StardewModdingAPI.Toolkit.Framework.ModData;
using StardewModdingAPI.Toolkit.Utilities;
namespace StardewModdingAPI.Framework.Logging
{
/// Manages the SMAPI console window and log file.
internal class LogManager : IDisposable
{
/*********
** Fields
*********/
/// The log file to which to write messages.
private readonly LogFileManager LogFile;
/// Prefixing a low-level message with this character indicates that the console interceptor should write the string without intercepting it. (The character itself is not written.)
private readonly char IgnoreChar = '\u200B';
/// Get a named monitor instance.
private readonly Func GetMonitorImpl;
/// Regex patterns which match console non-error messages to suppress from the console and log.
private readonly Regex[] SuppressConsolePatterns =
{
new Regex(@"^TextBox\.Selected is now '(?:True|False)'\.$", RegexOptions.Compiled | RegexOptions.CultureInvariant),
new Regex(@"^loadPreferences\(\); begin", RegexOptions.Compiled | RegexOptions.CultureInvariant),
new Regex(@"^savePreferences\(\); async=", RegexOptions.Compiled | RegexOptions.CultureInvariant),
new Regex(@"^DebugOutput:\s+(?:added cricket|dismount tile|Ping|playerPos)", RegexOptions.Compiled | RegexOptions.CultureInvariant),
new Regex(@"^Ignoring keys: ", RegexOptions.Compiled | RegexOptions.CultureInvariant)
};
/// Regex patterns which match console messages to show a more friendly error for.
private readonly ReplaceLogPattern[] ReplaceConsolePatterns =
{
// Steam not loaded
new ReplaceLogPattern(
search: new Regex(@"^System\.InvalidOperationException: Steamworks is not initialized\.[\s\S]+$", RegexOptions.Compiled | RegexOptions.CultureInvariant),
replacement:
#if SMAPI_FOR_WINDOWS
"Oops! Steam achievements won't work because Steam isn't loaded. See 'Launch SMAPI through Steam or GOG Galaxy' in the install guide for more info: https://smapi.io/install.",
#else
"Oops! Steam achievements won't work because Steam isn't loaded. You can launch the game through Steam to fix that.",
#endif
logLevel: LogLevel.Error
),
// save file not found error
new ReplaceLogPattern(
search: new Regex(@"^System\.IO\.FileNotFoundException: [^\n]+\n[^:]+: '[^\n]+[/\\]Saves[/\\]([^'\r\n]+)[/\\]([^'\r\n]+)'[\s\S]+LoadGameMenu\.FindSaveGames[\s\S]+$", RegexOptions.Compiled | RegexOptions.CultureInvariant),
replacement: "The game can't find the '$2' file for your '$1' save. See https://stardewvalleywiki.com/Saves#Troubleshooting for help.",
logLevel: LogLevel.Error
)
};
/*********
** Accessors
*********/
/// The core logger and monitor for SMAPI.
public Monitor Monitor { get; }
/// The core logger and monitor on behalf of the game.
public Monitor MonitorForGame { get; }
/*********
** Public methods
*********/
/****
** Initialization
****/
/// Construct an instance.
/// The log file path to write.
/// The colors to use for text written to the SMAPI console.
/// Whether to output log messages to the console.
/// Whether verbose logging is enabled. This enables more detailed diagnostic messages than are normally needed.
/// Whether to enable full console output for developers.
/// Get the screen ID that should be logged to distinguish between players in split-screen mode, if any.
public LogManager(string logPath, ColorSchemeConfig colorConfig, bool writeToConsole, bool isVerbose, bool isDeveloperMode, Func getScreenIdForLog)
{
// init construction logic
this.GetMonitorImpl = name => new Monitor(name, this.IgnoreChar, this.LogFile, colorConfig, isVerbose, getScreenIdForLog)
{
WriteToConsole = writeToConsole,
ShowTraceInConsole = isDeveloperMode,
ShowFullStampInConsole = isDeveloperMode
};
// init fields
this.LogFile = new LogFileManager(logPath);
this.Monitor = this.GetMonitor("SMAPI");
this.MonitorForGame = this.GetMonitor("game");
// redirect direct console output
var output = new InterceptingTextWriter(Console.Out, this.IgnoreChar);
if (writeToConsole)
output.OnMessageIntercepted += message => this.HandleConsoleMessage(this.MonitorForGame, message);
Console.SetOut(output);
}
/// Get a monitor instance derived from SMAPI's current settings.
/// The name of the module which will log messages with this instance.
public Monitor GetMonitor(string name)
{
return this.GetMonitorImpl(name);
}
/// Set the title of the SMAPI console window.
/// The new window title.
public void SetConsoleTitle(string title)
{
Console.Title = title;
}
/****
** Console input
****/
/// Run a loop handling console input.
[SuppressMessage("ReSharper", "FunctionNeverReturns", Justification = "The thread is aborted when the game exits.")]
public void RunConsoleInputLoop(CommandManager commandManager, Action reloadTranslations, Action handleInput, Func continueWhile)
{
// prepare console
this.Monitor.Log("Type 'help' for help, or 'help ' for a command's usage", LogLevel.Info);
commandManager
.Add(new HelpCommand(commandManager), this.Monitor)
.Add(new HarmonySummaryCommand(), this.Monitor)
.Add(new ReloadI18nCommand(reloadTranslations), this.Monitor);
// start handling command line input
Thread inputThread = new Thread(() =>
{
while (true)
{
// get input
string input = Console.ReadLine();
if (string.IsNullOrWhiteSpace(input))
continue;
// handle command
this.Monitor.LogUserInput(input);
handleInput(input);
}
});
inputThread.Start();
// keep console thread alive while the game is running
while (continueWhile())
Thread.Sleep(1000 / 10);
if (inputThread.ThreadState == ThreadState.Running)
inputThread.Abort();
}
/// Show a 'press any key to exit' message, and exit when they press a key.
public void PressAnyKeyToExit()
{
this.Monitor.Log("Game has ended. Press any key to exit.", LogLevel.Info);
this.PressAnyKeyToExit(showMessage: false);
}
/// Show a 'press any key to exit' message, and exit when they press a key.
/// Whether to print a 'press any key to exit' message to the console.
public void PressAnyKeyToExit(bool showMessage)
{
if (showMessage)
this.Monitor.Log("Game has ended. Press any key to exit.");
Thread.Sleep(100);
Console.ReadKey();
Environment.Exit(0);
}
/****
** Crash/update handling
****/
/// Create a crash marker and duplicate the log into the crash log.
public void WriteCrashLog()
{
try
{
File.WriteAllText(Constants.FatalCrashMarker, string.Empty);
File.Copy(this.LogFile.Path, Constants.FatalCrashLog, overwrite: true);
}
catch (Exception ex)
{
this.Monitor.Log($"SMAPI failed trying to track the crash details: {ex.GetLogSummary()}", LogLevel.Error);
}
}
/// Write an update alert marker file.
/// The new version found.
/// The download URL for the update.
public void WriteUpdateMarker(string version, string url)
{
File.WriteAllText(Constants.UpdateMarker, $"{version}|{url}");
}
/// Check whether SMAPI crashed or detected an update during the last session, and display them in the SMAPI console.
public void HandleMarkerFiles()
{
// show update alert
if (File.Exists(Constants.UpdateMarker))
{
string[] rawUpdateFound = File.ReadAllText(Constants.UpdateMarker).Split(new[] { '|' }, 2);
if (SemanticVersion.TryParse(rawUpdateFound[0], out ISemanticVersion updateFound))
{
if (Constants.ApiVersion.IsPrerelease() && updateFound.IsNewerThan(Constants.ApiVersion))
{
string url = rawUpdateFound.Length > 1
? rawUpdateFound[1]
: Constants.HomePageUrl;
this.Monitor.Log("A new version of SMAPI was detected last time you played.", LogLevel.Error);
this.Monitor.Log($"You can update to {updateFound}: {url}.", LogLevel.Error);
this.Monitor.Log("Press any key to continue playing anyway. (This only appears when using a SMAPI beta.)", LogLevel.Info);
Console.ReadKey();
}
}
File.Delete(Constants.UpdateMarker);
}
// show details if game crashed during last session
if (File.Exists(Constants.FatalCrashMarker))
{
this.Monitor.Log("The game crashed last time you played. If it happens repeatedly, see 'get help' on https://smapi.io.", LogLevel.Error);
this.Monitor.Log("If you ask for help, make sure to share your SMAPI log: https://smapi.io/log.", LogLevel.Error);
this.Monitor.Log("Press any key to delete the crash data and continue playing.", LogLevel.Info);
Console.ReadKey();
File.Delete(Constants.FatalCrashLog);
File.Delete(Constants.FatalCrashMarker);
}
}
/// Log a fatal exception which prevents SMAPI from launching.
/// The exception details.
public void LogFatalLaunchError(Exception exception)
{
switch (exception)
{
// audio crash
case InvalidOperationException ex when ex.Source == "Microsoft.Xna.Framework.Xact" && ex.StackTrace.Contains("Microsoft.Xna.Framework.Audio.AudioEngine..ctor"):
this.Monitor.Log("The game couldn't load audio. Do you have speakers or headphones plugged in?", LogLevel.Error);
this.Monitor.Log($"Technical details: {ex.GetLogSummary()}");
break;
// missing content folder exception
case FileNotFoundException ex when ex.Message == "Couldn't find file 'C:\\Program Files (x86)\\Steam\\SteamApps\\common\\Stardew Valley\\Content\\XACT\\FarmerSounds.xgs'.": // path in error is hardcoded regardless of install path
this.Monitor.Log("The game can't find its Content\\XACT\\FarmerSounds.xgs file. You can usually fix this by resetting your content files (see https://smapi.io/troubleshoot#reset-content ), or by uninstalling and reinstalling the game.", LogLevel.Error);
this.Monitor.Log($"Technical details: {ex.GetLogSummary()}");
break;
// path too long exception
case PathTooLongException:
{
string[] affectedPaths = PathUtilities.GetTooLongPaths(Constants.ModsPath).ToArray();
string message = affectedPaths.Any()
? $"SMAPI can't launch because some of your mod files exceed the maximum path length on {Constants.Platform}.\nIf you need help fixing this error, see https://smapi.io/help\n\nAffected paths:\n {string.Join("\n ", affectedPaths)}"
: $"The game failed to launch: {exception.GetLogSummary()}";
this.MonitorForGame.Log(message, LogLevel.Error);
}
break;
// generic exception
default:
this.MonitorForGame.Log($"The game failed to launch: {exception.GetLogSummary()}", LogLevel.Error);
break;
}
}
/****
** General log output
****/
/// Log the initial header with general SMAPI and system details.
/// The path from which mods will be loaded.
/// The custom SMAPI settings.
public void LogIntro(string modsPath, IDictionary customSettings)
{
// get platform label
string platformLabel = EnvironmentUtility.GetFriendlyPlatformName(Constants.Platform);
if ((Constants.GameFramework == GameFramework.Xna) != (Constants.Platform == Platform.Windows))
platformLabel += $" with {Constants.GameFramework}";
#if SMAPI_FOR_WINDOWS_64BIT_HACK
platformLabel += " 64-bit hack";
#endif
// init logging
this.Monitor.Log($"SMAPI {Constants.ApiVersion} with Stardew Valley {Constants.GameVersion} on {platformLabel}", LogLevel.Info);
this.Monitor.Log($"Mods go here: {modsPath}", LogLevel.Info);
if (modsPath != Constants.DefaultModsPath)
this.Monitor.Log("(Using custom --mods-path argument.)");
this.Monitor.Log($"Log started at {DateTime.UtcNow:s} UTC");
// log custom settings
if (customSettings.Any())
this.Monitor.Log($"Loaded with custom settings: {string.Join(", ", customSettings.OrderBy(p => p.Key).Select(p => $"{p.Key}: {p.Value}"))}");
}
/// Log details for settings that don't match the default.
/// The settings to log.
public void LogSettingsHeader(SConfig settings)
{
// developer mode
if (settings.DeveloperMode)
this.Monitor.Log("You enabled developer mode, so the console will be much more verbose. You can disable it by installing the non-developer version of SMAPI.", LogLevel.Info);
// warnings
if (!settings.CheckForUpdates)
this.Monitor.Log("You disabled update checks, so you won't be notified of new SMAPI or mod updates. Running an old version of SMAPI is not recommended. You can undo this by reinstalling SMAPI.", LogLevel.Warn);
if (!settings.RewriteMods)
this.Monitor.Log("You disabled rewriting broken mods, so many older mods may fail to load. You can undo this by reinstalling SMAPI.", LogLevel.Info);
if (!this.Monitor.WriteToConsole)
this.Monitor.Log("Writing to the terminal is disabled because the --no-terminal argument was received. This usually means launching the terminal failed.", LogLevel.Warn);
// verbose logging
this.Monitor.VerboseLog("Verbose logging enabled.");
}
/// Log info about loaded mods.
/// The full list of loaded content packs and mods.
/// The loaded content packs.
/// The loaded mods.
/// The mods which could not be loaded.
/// Whether to log issues for mods which directly use potentially sensitive .NET APIs like file or shell access.
public void LogModInfo(IModMetadata[] loaded, IModMetadata[] loadedContentPacks, IModMetadata[] loadedMods, IModMetadata[] skippedMods, bool logParanoidWarnings)
{
// log loaded mods
this.Monitor.Log($"Loaded {loadedMods.Length} mods" + (loadedMods.Length > 0 ? ":" : "."), LogLevel.Info);
foreach (IModMetadata metadata in loadedMods.OrderBy(p => p.DisplayName))
{
IManifest manifest = metadata.Manifest;
this.Monitor.Log(
$" {metadata.DisplayName} {manifest.Version}"
+ (!string.IsNullOrWhiteSpace(manifest.Author) ? $" by {manifest.Author}" : "")
+ (!string.IsNullOrWhiteSpace(manifest.Description) ? $" | {manifest.Description}" : ""),
LogLevel.Info
);
}
this.Monitor.Newline();
// log loaded content packs
if (loadedContentPacks.Any())
{
string GetModDisplayName(string id) => loadedMods.FirstOrDefault(p => p.HasID(id))?.DisplayName;
this.Monitor.Log($"Loaded {loadedContentPacks.Length} content packs:", LogLevel.Info);
foreach (IModMetadata metadata in loadedContentPacks.OrderBy(p => p.DisplayName))
{
IManifest manifest = metadata.Manifest;
this.Monitor.Log(
$" {metadata.DisplayName} {manifest.Version}"
+ (!string.IsNullOrWhiteSpace(manifest.Author) ? $" by {manifest.Author}" : "")
+ $" | for {GetModDisplayName(metadata.Manifest.ContentPackFor.UniqueID)}"
+ (!string.IsNullOrWhiteSpace(manifest.Description) ? $" | {manifest.Description}" : ""),
LogLevel.Info
);
}
this.Monitor.Newline();
}
// log mod warnings
this.LogModWarnings(loaded, skippedMods, logParanoidWarnings);
}
///
public void Dispose()
{
this.LogFile.Dispose();
}
/*********
** Protected methods
*********/
/// Redirect messages logged directly to the console to the given monitor.
/// The monitor with which to log messages as the game.
/// The message to log.
private void HandleConsoleMessage(IMonitor gameMonitor, string message)
{
// detect exception
LogLevel level = message.Contains("Exception") ? LogLevel.Error : LogLevel.Trace;
// ignore suppressed message
if (level != LogLevel.Error && this.SuppressConsolePatterns.Any(p => p.IsMatch(message)))
return;
// show friendly error if applicable
foreach (ReplaceLogPattern entry in this.ReplaceConsolePatterns)
{
string newMessage = entry.Search.Replace(message, entry.Replacement);
if (message != newMessage)
{
gameMonitor.Log(newMessage, entry.LogLevel);
gameMonitor.Log(message);
return;
}
}
// forward to monitor
gameMonitor.Log(message, level);
}
/// Write a summary of mod warnings to the console and log.
/// The loaded mods.
/// The mods which could not be loaded.
/// Whether to log issues for mods which directly use potentially sensitive .NET APIs like file or shell access.
private void LogModWarnings(IEnumerable mods, IModMetadata[] skippedMods, bool logParanoidWarnings)
{
// get mods with warnings
IModMetadata[] modsWithWarnings = mods.Where(p => p.Warnings != ModWarning.None).ToArray();
if (!modsWithWarnings.Any() && !skippedMods.Any())
return;
// log intro
{
int count = modsWithWarnings.Length + skippedMods.Length;
this.Monitor.Log($"Found {count} mod{(count == 1 ? "" : "s")} with warnings:", LogLevel.Info);
}
// log skipped mods
if (skippedMods.Any())
{
var loggedDuplicateIds = new HashSet();
this.Monitor.Log(" Skipped mods", LogLevel.Error);
this.Monitor.Log(" " + "".PadRight(50, '-'), LogLevel.Error);
this.Monitor.Log(" These mods could not be added to your game.", LogLevel.Error);
this.Monitor.Newline();
foreach (var list in this.GroupFailedModsByPriority(skippedMods))
{
if (list.Any())
{
foreach (IModMetadata mod in list.OrderBy(p => p.DisplayName))
{
string message = $" - {mod.DisplayName}{(" " + mod.Manifest?.Version?.ToString()).TrimEnd()} because {mod.Error}";
// duplicate mod: log first one only, don't show redundant version
if (mod.FailReason == ModFailReason.Duplicate && mod.HasManifest())
{
if (loggedDuplicateIds.Add(mod.Manifest.UniqueID))
continue; // already logged
message = $" - {mod.DisplayName} because {mod.Error}";
}
// log message
this.Monitor.Log(message, LogLevel.Error);
if (mod.ErrorDetails != null)
this.Monitor.Log($" ({mod.ErrorDetails})");
}
this.Monitor.Newline();
}
}
}
// log warnings
if (modsWithWarnings.Any())
{
// broken code
this.LogModWarningGroup(modsWithWarnings, ModWarning.BrokenCodeLoaded, LogLevel.Error, "Broken mods",
"These mods have broken code, but you configured SMAPI to load them anyway. This may cause bugs,",
"errors, or crashes in-game."
);
// changes serializer
this.LogModWarningGroup(modsWithWarnings, ModWarning.ChangesSaveSerializer, LogLevel.Warn, "Changed save serializer",
"These mods change the save serializer. They may corrupt your save files, or make them unusable if",
"you uninstall these mods."
);
// patched game code
this.LogModWarningGroup(modsWithWarnings, ModWarning.PatchesGame, LogLevel.Info, "Patched game code",
"These mods directly change the game code. They're more likely to cause errors or bugs in-game; if",
"your game has issues, try removing these first. Otherwise you can ignore this warning."
);
// unvalidated update tick
this.LogModWarningGroup(modsWithWarnings, ModWarning.UsesUnvalidatedUpdateTick, LogLevel.Info, "Bypassed safety checks",
"These mods bypass SMAPI's normal safety checks, so they're more likely to cause errors or save",
"corruption. If your game has issues, try removing these first."
);
// paranoid warnings
if (logParanoidWarnings)
{
this.LogModWarningGroup(
modsWithWarnings,
match: mod => mod.HasWarnings(ModWarning.AccessesConsole, ModWarning.AccessesFilesystem, ModWarning.AccessesShell),
level: LogLevel.Debug,
heading: "Direct system access",
blurb: new[]
{
"You enabled paranoid warnings and these mods directly access the filesystem, shells/processes, or",
"SMAPI console. (This is usually legitimate and innocent usage; this warning is only useful for",
"further investigation.)"
},
modLabel: mod =>
{
List labels = new List();
if (mod.HasWarnings(ModWarning.AccessesConsole))
labels.Add("console");
if (mod.HasWarnings(ModWarning.AccessesFilesystem))
labels.Add("files");
if (mod.HasWarnings(ModWarning.AccessesShell))
labels.Add("shells/processes");
return $"{mod.DisplayName} ({string.Join(", ", labels)})";
}
);
}
// no update keys
this.LogModWarningGroup(modsWithWarnings, ModWarning.NoUpdateKeys, LogLevel.Debug, "No update keys",
"These mods have no update keys in their manifest. SMAPI may not notify you about updates for these",
"mods. Consider notifying the mod authors about this problem."
);
// not crossplatform
this.LogModWarningGroup(modsWithWarnings, ModWarning.UsesDynamic, LogLevel.Debug, "Not crossplatform",
"These mods use the 'dynamic' keyword, and won't work on Linux/macOS."
);
}
}
/// Group failed mods by the priority players should update them, where mods in earlier groups are more likely to fix multiple mods.
/// The failed mods to group.
private IEnumerable> GroupFailedModsByPriority(IList failedMods)
{
var failedOthers = failedMods.ToList();
var skippedModIds = new HashSet(from mod in failedMods where mod.HasID() select mod.Manifest.UniqueID, StringComparer.OrdinalIgnoreCase);
// group B: dependencies which failed
var failedOtherDependencies = new List();
{
// get failed dependency IDs
var skippedDependencyIds = new HashSet(StringComparer.OrdinalIgnoreCase);
foreach (IModMetadata mod in failedMods)
{
foreach (string requiredId in skippedModIds.Intersect(mod.GetRequiredModIds()))
skippedDependencyIds.Add(requiredId);
}
// group matching mods
this.FilterThrough(
fromList: failedOthers,
toList: failedOtherDependencies,
match: mod => mod.HasID() && skippedDependencyIds.Contains(mod.Manifest.UniqueID)
);
}
// group A: failed root dependencies which other dependencies need
var failedRootDependencies = new List();
{
var skippedDependencyIds = new HashSet(failedOtherDependencies.Select(p => p.Manifest.UniqueID));
this.FilterThrough(
fromList: failedOtherDependencies,
toList: failedRootDependencies,
match: mod =>
{
// has no failed dependency
foreach (string requiredId in mod.GetRequiredModIds())
{
if (skippedDependencyIds.Contains(requiredId))
return false;
}
// another dependency depends on this mod
bool isDependedOn = false;
foreach (IModMetadata other in failedOtherDependencies)
{
if (other.HasRequiredModId(mod.Manifest.UniqueID, includeOptional: false))
{
isDependedOn = true;
break;
}
}
return isDependedOn;
}
);
}
// return groups
return new[]
{
failedRootDependencies,
failedOtherDependencies,
failedOthers
};
}
/// Filter matching items from one list and add them to the other.
/// The list item type.
/// The list to filter.
/// The list to which to add filtered items.
/// Matches items to filter through.
private void FilterThrough(IList fromList, IList toList, Func match)
{
for (int i = 0; i < fromList.Count; i++)
{
TItem item = fromList[i];
if (match(item))
{
toList.Add(item);
fromList.RemoveAt(i);
i--;
}
}
}
/// Write a mod warning group to the console and log.
/// The mods to search.
/// Matches mods to include in the warning group.
/// The log level for the logged messages.
/// A brief heading label for the group.
/// A detailed explanation of the warning, split into lines.
/// Formats the mod label, or null to use the .
private void LogModWarningGroup(IModMetadata[] mods, Func match, LogLevel level, string heading, string[] blurb, Func modLabel = null)
{
// get matching mods
string[] modLabels = mods
.Where(match)
.Select(mod => modLabel?.Invoke(mod) ?? mod.DisplayName)
.OrderBy(p => p)
.ToArray();
if (!modLabels.Any())
return;
// log header/blurb
this.Monitor.Log(" " + heading, level);
this.Monitor.Log(" " + "".PadRight(50, '-'), level);
foreach (string line in blurb)
this.Monitor.Log(" " + line, level);
this.Monitor.Newline();
// log mod list
foreach (string label in modLabels)
this.Monitor.Log($" - {label}", level);
this.Monitor.Newline();
}
/// Write a mod warning group to the console and log.
/// The mods to search.
/// The mod warning to match.
/// The log level for the logged messages.
/// A brief heading label for the group.
/// A detailed explanation of the warning, split into lines.
private void LogModWarningGroup(IModMetadata[] mods, ModWarning warning, LogLevel level, string heading, params string[] blurb)
{
this.LogModWarningGroup(mods, mod => mod.HasWarnings(warning), level, heading, blurb);
}
/*********
** Protected types
*********/
/// A console log pattern to replace with a different message.
private class ReplaceLogPattern
{
/*********
** Accessors
*********/
/// The regex pattern matching the portion of the message to replace.
public Regex Search { get; }
/// The replacement string.
public string Replacement { get; }
/// The log level for the new message.
public LogLevel LogLevel { get; }
/*********
** Public methods
*********/
/// Construct an instance.
/// The regex pattern matching the portion of the message to replace.
/// The replacement string.
/// The log level for the new message.
public ReplaceLogPattern(Regex search, string replacement, LogLevel logLevel)
{
this.Search = search;
this.Replacement = replacement;
this.LogLevel = logLevel;
}
}
}
}