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); }
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))); } }
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); }