public LogMessage(DateTime date, Log.Category category, LogVerbosity verbosity, string message)
{
Date = date;
Category = category;
Verbosity = verbosity;
Message = message;
}
public void WriteMessage(LogVerbosity verbosity, string message, params object[] values)
{
if (verbosity <= Verbosity)
{
WriteMessage(String.Format(message, values));
}
}
public void Log(LogVerbosity verbosity, string sender, string message, object payload = null)
{
var log = new Log()
{
Sender = sender, Message = message, Payload = payload
};
OnLog?.Invoke(this, log);
_logs.Add(log);
if (_logs.Count > 250)
{
_logs.RemoveAt(0);
}
//if (Debugger.IsAttached) return;
try
{
using (var eventLog = new EventLog("Application")
{
Source = _name
})
{
eventLog.WriteEntry($"{sender} {message}", ToEventLog(verbosity), 0);
}
}
catch { }
}
public void Write(LogVerbosity logType, string message)
{
if ((int)logType >= (int)Level)
{
TextWriter.WriteLine($"{DateTime.Now:hh:mm:ss:fff} | {logType} | {message}");
}
}
public static void Write(string message, LogVerbosity verbosity)
{
try
{
if (verbosity != LogVerbosity.Verbose && Log.m_LogCallback != null)
{
Log.m_LogCallback(message);
}
if (Log.m_Stream == null && !Log.m_OpenedDefaultLogFile)
{
Log.OpenFile("log.txt");
Log.m_OpenedDefaultLogFile = true;
}
if (Log.m_Stream != null)
{
message = DateTime.Now.ToString() + ": " + message;
message = message.Replace("\n", "\r\n");
Log.m_Stream.Write(message);
}
Log.m_Stream.Flush();
}
catch (Exception)
{
}
}
public void WriteMessage(LogVerbosity verbosity, string message)
{
if (verbosity <= Verbosity)
{
WriteMessage(message);
}
}
private static void ProcessConsoleLogItem()
{
foreach (var item in ConsoleLogQueue.GetConsumingEnumerable())
{
Object thing = item.Item1;
Nullable <ConsoleColor> color = item.Item2;
LogVerbosity verbosity = item.Item3;
bool writeLine = item.Item4;
if (color != null && color.HasValue)
{
WriteToConsoleLog(thing, color.Value, verbosity, writeLine);
}
else
{
if (thing is Object[])
{
WriteToConsoleLog(thing as object[], verbosity);
}
else
{
WriteToConsoleLog(thing, verbosity, writeLine);
}
}
}
}
private TestHttpDiagnosticsHandler CreateHandlerWithVerbosity(LogVerbosity verbosity)
{
return(new TestHttpDiagnosticsHandler(_logger, verbosity)
{
InnerHandler = _innerHandler
});
}
public Log(string logFile, string errorFile, LogVerbosity verbosity)
{
_loggers = new List <ILogger>();
Add(new FileLogger(verbosity, logFile, errorFile));
Add(new ConsoleLogger(verbosity));
Verbosity = verbosity;
}
public void Overrides(bool telemetryEnabled, int? logVerbosity, int? feedbackSetting, LogVerbosity expectedMaxLogLevel, bool expectedFeedback) {
var constants = Substitute.For<IApplicationConstants>();
constants.LocalMachineHive.Returns("rtvs");
var rtvsKey = Substitute.For<IRegistryKey>(); ;
rtvsKey.GetValue(LoggingPermissions.LogVerbosityValueName).Returns(logVerbosity);
rtvsKey.GetValue(LoggingPermissions.FeedbackValueName).Returns(feedbackSetting);
var hklm = Substitute.For<IRegistryKey>();
hklm.OpenSubKey("rtvs").Returns(rtvsKey);
var registry = Substitute.For<IRegistry>();
registry.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).Returns(hklm);
var telemetry = Substitute.For<ITelemetryService>();
telemetry.IsEnabled.Returns(telemetryEnabled);
var permissions = new LoggingPermissions(constants, telemetry, registry);
permissions.MaxVerbosity.Should().Be(expectedMaxLogLevel);
permissions.IsFeedbackPermitted.Should().Be(expectedFeedback);
if (logVerbosity.HasValue) {
var values = Enum.GetValues(typeof(LogVerbosity));
foreach (var v in values) {
permissions.CurrentVerbosity = (LogVerbosity)v;
((int)permissions.CurrentVerbosity).Should().BeGreaterOrEqualTo((int)LogVerbosity.None);
((int)permissions.CurrentVerbosity).Should().BeLessOrEqualTo((int)permissions.MaxVerbosity);
}
}
}
static void WriteVerbosity(LogVerbosity verbosity)
{
string output = "";
switch (verbosity)
{
case LogVerbosity.Normal:
output = "Normal";
break;
case LogVerbosity.Quiet:
output = "Quiet";
break;
case LogVerbosity.Verbose:
output = "Verbose";
break;
case LogVerbosity.VeryQuiet:
output = "VeryQuiet";
break;
}
LogHelper.ConsoleLog(string.Format("Verbosity: {0}", output), LogVerbosity.VeryQuiet);
}
public async Task Verbosity(LogVerbosity verbosity) {
var writer = Substitute.For<IActionLogWriter>();
var perm = Substitute.For<ILoggingPermissions>();
perm.CurrentVerbosity.Returns(verbosity);
var log = new Logger(string.Empty, perm, writer);
await log.WriteAsync(LogVerbosity.None, MessageCategory.Error, "message0");
await log.WriteAsync(LogVerbosity.Minimal, MessageCategory.Error, "message1");
await log.WriteAsync(LogVerbosity.Normal, MessageCategory.Error, "message2");
await log.WriteAsync(LogVerbosity.Traffic, MessageCategory.Error, "message3");
int i = 0;
foreach(var v in Enum.GetValues(typeof(LogVerbosity))) {
if ((int)v > (int)LogVerbosity.None && (int)v <= (int)verbosity) {
await writer.Received().WriteAsync(MessageCategory.Error, "message" + i.ToString());
} else {
await writer.DidNotReceive().WriteAsync(MessageCategory.Error, "message" + i.ToString());
}
i++;
}
writer.DidNotReceive().Flush();
if (verbosity > LogVerbosity.None) {
log.Flush();
writer.Received().Flush();
}
}
public async Task WriteFormatAsync(LogVerbosity verbosity, MessageCategory category, string format, params object[] arguments)
{
await EnsureCreatedAsync();
string message = string.Format(CultureInfo.InvariantCulture, format, arguments);
await _logs[(int)verbosity].WriteAsync(category, message);
}
private void Log_Message(LogVerbosity verbosity, Log.Category category, string message)
{
DateTime date = DateTime.Now;
lock (logBuffer)
logBuffer.Add(new LogMessage(date, category, verbosity, message));
}
/// <summary>
///
/// </summary>
/// <param name="verbose"></param>
/// <param name="msg"></param>
public void Write(LogVerbosity verbose, string msg)
{
msg = msg.Replace("{", "{{").Replace("}", "}}");
switch (verbose)
{
case LogVerbosity.Trace:
LogFile.OnDebug(msg);
break;
case LogVerbosity.Debug:
LogFile.OnDebug(msg);
break;
case LogVerbosity.Info:
LogFile.OnInfo(msg);
break;
case LogVerbosity.Warning:
LogFile.OnWarning(msg);
break;
case LogVerbosity.Error:
LogFile.OnError(msg);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="verbose_"></param>
/// <param name="msg_"></param>
public void Write(LogVerbosity verbose_, string msg_)
{
ConsoleColor color = Console.ForegroundColor;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0} [{1}] {2}",
DateTime.Now.ToString("HH:mm:ss.fff"),
Enum.GetName(typeof(LogVerbosity), verbose_),
msg_);
switch (verbose_)
{
case LogVerbosity.Trace: Console.ForegroundColor = ConsoleColor.DarkGray; break;
case LogVerbosity.Debug: Console.ForegroundColor = ConsoleColor.Green; break;
case LogVerbosity.Info: Console.ForegroundColor = ConsoleColor.White; break;
case LogVerbosity.Warning: Console.ForegroundColor = ConsoleColor.DarkYellow; break;
case LogVerbosity.Error: Console.ForegroundColor = ConsoleColor.Red; break;
}
Console.WriteLine(sb.ToString());
Console.ForegroundColor = color;
}
/// <summary>
/// Triggered when a new entry is added in the debug log.
/// </summary>
/// <param name="message">Message string.</param>
/// <param name="verbosity">Verbosity level defining message importance.</param>
/// <param name="category">Category of the sub-system reporting the message.</param>
private void OnEntryAdded(string message, LogVerbosity verbosity, int category)
{
// Check if compiler message or reported exception, otherwise parse it as a normal log message
ParsedLogEntry logEntry = ScriptCodeManager.ParseCompilerMessage(message);
if (logEntry == null)
{
logEntry = Debug.ParseExceptionMessage(message);
}
if (logEntry == null)
{
logEntry = Debug.ParseLogMessage(message);
}
ConsoleEntryData newEntry = new ConsoleEntryData();
newEntry.verbosity = verbosity;
newEntry.category = category;
newEntry.callstack = logEntry.callstack;
newEntry.message = logEntry.message;
entries.Add(newEntry);
if (DoesFilterMatch(verbosity))
{
listView.AddEntry(newEntry);
filteredEntries.Add(newEntry);
}
}
public static void Configure(LogDestinations?logDestination, LogVerbosity logVerbosity)
{
LogVerbosity = logVerbosity;
if (LogVerbosity == LogVerbosity.NoLogging)
{
return;
}
LogDestination = logDestination.Value;
SetupConsoleLogging();
SetupFileLogging();
IoC.IoCContainer.RegisterInstance <ILoggerFactory>(Logging.Factory);
IoC.IoCContainer.GetInstance <SetSynchronizationServiceLogger>();
IoC.IoCContainer.GetInstance <ThemeSynchronizerLogger>();
IoC.IoCContainer.GetInstance <SubthemeSynchronizerLogger>();
IoC.IoCContainer.GetInstance <SetSynchronizerLogger>();
IoC.IoCContainer.GetInstance <ThumbnailSynchronizerLogger>();
IoC.IoCContainer.GetInstance <AssetUncompressionLogger>();
IoC.IoCContainer.GetInstance <UserSynchronizationServiceLogger>();
IoC.IoCContainer.GetInstance <UserSynchronizerLogger>();
}
void HandleLogLine(string line)
{
if (line == null)
{
return;
}
string[] split = line.Split(new [] { ": " }, StringSplitOptions.None);
LogVerbosity verbosity = LogVerbosity.Log;
if (split.Length > 1)
{
if (split[0] == "ERROR")
{
// UBT error format
// "ERROR: Some message"
verbosity = LogVerbosity.Error;
}
else if (split[1] == "Error")
{
// Unreal error format
// "LogCategory: Error: Some message"
verbosity = LogVerbosity.Error;
}
else if (split[1] == "Warning")
{
// Unreal warning format
verbosity = LogVerbosity.Warning;
}
}
Output?.Invoke(line, verbosity);
}
public LogMessage(DateTime date, Log.Category category, LogVerbosity verbosity, string message)
{
Date = date;
Category = category;
Verbosity = verbosity;
Message = message;
}
private object AdditionalLogs(LogVerbosity verbosity)
{
return(verbosity == LogVerbosity.Trace
? @"autoreceive = on
lifecycle = on
router-misconfiguration = on"
: "");
}
private void SetLogVerbosityButton_Click(object sender, RoutedEventArgs e)
{
string verbosityText = (sender as MenuItem).Header.ToString();
LogVerbosity verbosity = (LogVerbosity)Enum.Parse(typeof(LogVerbosity), verbosityText);
Log.Verbosity = verbosity;
NotifyPropertyChanged(nameof(LogVerbosity));
}
/// <summary>
/// Logs a new message to the global debug log using the provided type.
/// </summary>
/// <param name="message">Message to log.</param>
/// <param name="verbosity">Verbosity level defining message importance.</param>
/// <param name="category">Optional index of the category to group the message under.</param>
internal static void LogMessage(object message, LogVerbosity verbosity, int category = 0)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(message.ToString());
Internal_LogMessage(sb.ToString(), verbosity, category);
}
public AkkaConfiguration(IAkkaNetworkAddress networkConf,
IAkkaDbConfiguration dbConf,
LogVerbosity logVerbosity = LogVerbosity.Warning)
{
Network = networkConf;
Persistence = dbConf;
_logVerbosity = logVerbosity;
}
private static void WriteToConsoleLog(Object thing, ConsoleColor color, LogVerbosity verbosity = LogVerbosity.Normal, bool writeLine = true)
{
if (ShouldDisplay(verbosity))
{
Console.ForegroundColor = color;
WriteToConsoleLog(thing, verbosity, writeLine);
Console.ResetColor();
}
}
public Log(string sender, string message, LogVerbosity logType = LogVerbosity.Debug, object payload = null)
: this()
{
Sender = sender;
Message = message;
Verbosity = logType;
Verbosity = logType;
Payload = payload;
}
/// <summary>
/// Initializes object instance
/// </summary>
/// <param name="client">client to perform attach</param>
/// <param name="verbosity">new verbosity value</param>
public SetVerbosityAction(LogClient client, LogVerbosity verbosity)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
_client = client;
_verbosity = verbosity;
}
public static void SetLogVerbosity(LogVerbosity logVerbosity, bool quietConsole = false)
{
var modifiedLevel = VerbosityToLevel(logVerbosity);
Logging.ModifyVerbosity(modifiedLevel, quietConsole);
Log.Debug("Log level changed to: " + logVerbosity);
// log test
//Logging.TestLogging();
}
public static void SetVerbosity(string _logID, LogVerbosity _verbosity)
{
if (_logID.Equals(KEY_DEBUG_LOG))
{
DebugVerbosity = _verbosity;
}
else
{
m_Logs[_logID].Verbosity = _verbosity;
}
}
static void Log(LogVerbosity verbosity, string message)
{
switch (verbosity)
{
case LogVerbosity.Error: Debug.LogError(message); break;
case LogVerbosity.Warn: Debug.LogWarning(message); break;
case LogVerbosity.Info: Debug.Log(message); break;
}
}
/// <summary>
/// Publish a new entry to the log if log verbosity
/// is the same or high as entry verbosity.
///
/// In a text log, the first line of each log entry is Verbosity
/// followed by semicolon separator and then Title of the log entry.
/// Remaining lines are Description of the log entry recorded with
/// 4 space indent but otherwise preserving its formatting.
///
/// Example:
///
/// Info: Sample Title
/// Sample Description Line 1
/// Sample Description Line 2
/// </summary>
public static void Publish(this Log obj, LogVerbosity verbosity, string title, string description)
{
// Populate only those fields of of the log entry that are passed to this method.
// The remaining fields will be populated if the log entry is published to a data
// source. They are not necessary if the log entry is published to a text log.
var logEntry = new LogEntry {
Verbosity = verbosity, Title = title, Description = description
};
// Publish the log entry to the log
obj.PublishEntry(logEntry);
}
/// <summary>
/// Logs a message
/// </summary>
/// <param name="message"></param>
/// <param name="logVerbosity"></param>
public static void Log(string message, LogVerbosity logVerbosity = LogVerbosity.Info)
{
if (_logStream == null)
{
throw new Exception("The log stream hasn't been setup yet!");
}
string formattedMessage = $"[{Global.TimeNow()} {logVerbosity}] {message}";
if (logVerbosity != LogVerbosity.Debug)
{
Messages.Enqueue(formattedMessage);
}
else if (logVerbosity == LogVerbosity.Debug && Config.bot.LogDebugMessages)
{
Messages.Enqueue(formattedMessage);
}
//Write to the console depending on log verbosity and settings
switch (logVerbosity)
{
case LogVerbosity.Info:
WriteMessageToConsole(formattedMessage, ConsoleColor.White);
break;
case LogVerbosity.Debug:
#if DEBUG
Debug.WriteLine(formattedMessage);
#endif
if (Config.bot.LogDebugMessages)
{
WriteMessageToConsole(formattedMessage, ConsoleColor.White);
}
break;
case LogVerbosity.Error:
WriteMessageToConsole(formattedMessage, ConsoleColor.Red);
break;
case LogVerbosity.Warn:
WriteMessageToConsole(formattedMessage, ConsoleColor.Yellow);
break;
case LogVerbosity.Music:
WriteMessageToConsole(formattedMessage, ConsoleColor.Blue);
break;
default:
throw new ArgumentOutOfRangeException(nameof(logVerbosity), logVerbosity, null);
}
}
private static void WriteToConsoleLog(Object thing, LogVerbosity verbosity = LogVerbosity.Normal, bool writeLine = true)
{
if (ShouldDisplay(verbosity))
{
if (writeLine)
{
Console.WriteLine(thing);
}
else
{
Console.Write(thing);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="verbose"></param>
/// <param name="msg"></param>
public void Write(LogVerbosity verbose, string msg)
{
if (Application.Current.Dispatcher.CheckAccess() == true)
{
LogEntries.Add(new LogEntry()
{
Severity = "[" + Enum.GetName(typeof(LogVerbosity), verbose) + "]",
DateTime = DateTime.Now,
Message = msg,
});
}
else
{
Application.Current.Dispatcher.BeginInvoke(new Action( () => Write(verbose, msg)));
}
}
/// <summary>
///
/// </summary>
/// <param name="verbose_"></param>
/// <param name="msg_"></param>
public void Write(LogVerbosity verbose_, string msg_)
{
ConsoleColor color = Console.ForegroundColor;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0} [{1}] {2}",
DateTime.Now.ToString("HH:mm:ss.fff"),
Enum.GetName(typeof(LogVerbosity), verbose_),
msg_);
switch (verbose_)
{
case LogVerbosity.Trace: Console.ForegroundColor = ConsoleColor.DarkGray; break;
case LogVerbosity.Debug: Console.ForegroundColor = ConsoleColor.Green; break;
case LogVerbosity.Info: Console.ForegroundColor = ConsoleColor.White; break;
case LogVerbosity.Warning: Console.ForegroundColor = ConsoleColor.DarkYellow; break;
case LogVerbosity.Error: Console.ForegroundColor = ConsoleColor.Red; break;
}
Console.WriteLine(sb.ToString());
Console.ForegroundColor = color;
}
private void Log_Message(LogVerbosity verbosity, Log.Category category, string message)
{
DateTime date = DateTime.Now;
lock (logBuffer)
logBuffer.Add(new LogMessage(date, category, verbosity, message));
}
public FlowTomatorNotification(LogVerbosity importance, string message)
{
Importance = importance;
Message = message;
}
private static void Write(LogVerbosity verbosity, Category category, string message, ConsoleColor color = ConsoleColor.Gray)
{
if (Verbosity <= verbosity)
{
lock (mutex)
{
ConsoleColor lastColor = Console.ForegroundColor;
Console.ForegroundColor = color;
Console.Write("[{0}] ", verbosity.ToString()[0]);
Console.ForegroundColor = lastColor;
Console.WriteLine(message);
}
}
if (Message != null)
Message(verbosity, category, message);
}
public void StartHost(SecureString password, string profilePath, ILogger outputLogger, LogVerbosity verbosity) {
if (_hostEnd != null) {
throw new InvalidOperationException("Host process is already running");
}
var useridentity = User as WindowsIdentity;
// In remote broker User Identity type is always WindowsIdentity
string suppressUI = (useridentity == null) ? string.Empty : " --suppress-ui ";
string brokerPath = Path.GetDirectoryName(typeof(Program).Assembly.GetAssemblyPath());
string rhostExePath = Path.Combine(brokerPath, RHostExe);
string arguments = Invariant($"{suppressUI}--rhost-name \"{Id}\" --rhost-log-verbosity {(int)verbosity} {CommandLineArguments}");
var username = new StringBuilder(NativeMethods.CREDUI_MAX_USERNAME_LENGTH + 1);
var domain = new StringBuilder(NativeMethods.CREDUI_MAX_PASSWORD_LENGTH + 1);
ProcessStartInfo psi = new ProcessStartInfo(rhostExePath) {
UseShellExecute = false,
CreateNoWindow = false,
Arguments = arguments,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
LoadUserProfile = true
};
if (useridentity != null && WindowsIdentity.GetCurrent().User != useridentity.User && password != null) {
uint error = NativeMethods.CredUIParseUserName(User.Name, username, username.Capacity, domain, domain.Capacity);
if (error != 0) {
_sessionLogger.LogError(Resources.Error_UserNameParse, User.Name, error);
throw new ArgumentException(Resources.Error_UserNameParse.FormatInvariant(User.Name, error));
}
psi.Domain = domain.ToString();
psi.UserName = username.ToString();
psi.Password = password;
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariableCreationBegin, User.Name, profilePath);
// if broker and rhost are run as different users recreate user environment variables.
psi.EnvironmentVariables["USERNAME"] = username.ToString();
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "USERNAME", psi.EnvironmentVariables["USERNAME"]);
psi.EnvironmentVariables["HOMEDRIVE"] = profilePath.Substring(0, 2);
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "HOMEDRIVE", psi.EnvironmentVariables["HOMEDRIVE"]);
psi.EnvironmentVariables["HOMEPATH"] = profilePath.Substring(2);
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "HOMEPATH", psi.EnvironmentVariables["HOMEPATH"]);
psi.EnvironmentVariables["USERPROFILE"] = Invariant($"{psi.EnvironmentVariables["HOMEDRIVE"]}{psi.EnvironmentVariables["HOMEPATH"]}");
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "USERPROFILE", psi.EnvironmentVariables["USERPROFILE"]);
psi.EnvironmentVariables["APPDATA"] = Invariant($"{psi.EnvironmentVariables["USERPROFILE"]}\\AppData\\Roaming");
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "APPDATA", psi.EnvironmentVariables["APPDATA"]);
psi.EnvironmentVariables["LOCALAPPDATA"] = Invariant($"{psi.EnvironmentVariables["USERPROFILE"]}\\AppData\\Local");
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "LOCALAPPDATA", psi.EnvironmentVariables["LOCALAPPDATA"]);
psi.EnvironmentVariables["TEMP"] = Invariant($"{psi.EnvironmentVariables["LOCALAPPDATA"]}\\Temp");
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "TEMP", psi.EnvironmentVariables["TEMP"]);
psi.EnvironmentVariables["TMP"] = Invariant($"{psi.EnvironmentVariables["LOCALAPPDATA"]}\\Temp");
_sessionLogger.LogTrace(Resources.Trace_EnvironmentVariable, "TMP", psi.EnvironmentVariables["TMP"]);
}
var shortHome = new StringBuilder(NativeMethods.MAX_PATH);
NativeMethods.GetShortPathName(Interpreter.Info.Path, shortHome, shortHome.Capacity);
psi.EnvironmentVariables["R_HOME"] = shortHome.ToString();
psi.EnvironmentVariables["PATH"] = Interpreter.Info.BinPath + ";" + Environment.GetEnvironmentVariable("PATH");
psi.WorkingDirectory = Path.GetDirectoryName(rhostExePath);
_process = new Process {
StartInfo = psi,
EnableRaisingEvents = true,
};
_process.ErrorDataReceived += (sender, e) => {
var process = (Process)sender;
outputLogger?.LogTrace(Resources.Trace_ErrorDataReceived, process.Id, e.Data);
};
_process.Exited += delegate {
_hostEnd?.Dispose();
_hostEnd = null;
State = SessionState.Terminated;
};
_sessionLogger.LogInformation(Resources.Info_StartingRHost, Id, User.Name, rhostExePath, arguments);
try {
StartSession();
} catch(Exception ex) {
_sessionLogger.LogError(Resources.Error_RHostFailedToStart, ex.Message);
throw;
}
_sessionLogger.LogInformation(Resources.Info_StartedRHost, Id, User.Name);
_process.BeginErrorReadLine();
var hostEnd = _pipe.ConnectHost(_process.Id);
_hostEnd = hostEnd;
ClientToHostWorker(_process.StandardInput.BaseStream, hostEnd).DoNotWait();
HostToClientWorker(_process.StandardOutput.BaseStream, hostEnd).DoNotWait();
}
public async Task WriteLineAsync(LogVerbosity verbosity, MessageCategory category, string message) {
await EnsureCreatedAsync();
await _logs[(int)verbosity].WriteAsync(category, message + Environment.NewLine);
}
public async Task WriteFormatAsync(LogVerbosity verbosity, MessageCategory category, string format, params object[] arguments) {
await EnsureCreatedAsync();
string message = string.Format(CultureInfo.InvariantCulture, format, arguments);
await _logs[(int)verbosity].WriteAsync(category, message);
}
