/// <summary> /// Logs a message with the specified <see cref="TraceLevel"/>. /// Default <see cref="TraceLevel"/> is <see cref="TraceLevel.Info"/> /// </summary> /// <param name="message">The message to log</param> /// <param name="traceLevel">The trace to write to</param> public static void Log(string message, TraceLevel traceLevel = TraceLevel.Info) { switch (traceLevel) { case TraceLevel.Info: Trace.WriteLine(message, traceLevel.ToString()); break; case TraceLevel.Warning: Trace.WriteLine(message, traceLevel.ToString()); break; case TraceLevel.Error: Trace.WriteLine(message, traceLevel.ToString()); break; case TraceLevel.Verbose: Trace.WriteLine(message, traceLevel.ToString()); break; case TraceLevel.Off: default: break; } }
public void Log(TraceLevel severity, string className, string message, Exception exception) { if (exception == null) { ThriftLog.Info($"Zookeeper {severity.ToString()} {className} {message} "); } else { ThriftLog.Info($"Zookeeper {severity.ToString()} {className} {message} {exception.Message} {exception.StackTrace}"); } }
private string GetSectionPrefix(TraceLevel traceLevel) { const int fixedLengthTraceLevel = 7; var postFixLength = fixedLengthTraceLevel - traceLevel.ToString().Length; var strTrcLvl = traceLevel.ToString().PadRight(postFixLength); var prefix = string.Format("[{0}] ", strTrcLvl); for (var i = 0; i < _indentLevel; i++) { prefix += LEVEL_INDICATOR; } return(prefix); }
private void writeLog(TraceLevel level, string value) { if (level <= this.Level && textBox != null) { textBox.AppendText(DateTime.Now + " " + level.ToString() + ": " + value + "\r\n"); textBox.Refresh(); } if (level <= this.Level && logStream != null) { byte[] ss = Encoding.ASCII.GetBytes(DateTime.Now + " " + level.ToString() + ": " + value + "\r\n"); logStream.Write(ss, 0, ss.Length); logStream.Flush(); } Trace.WriteLineIf(level <= this.Level, DateTime.Now + " " + level.ToString() + ": " + value); }
/// <summary> /// Writes the specified trace level, message and optional exception. /// </summary> /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param> /// <param name="message">The trace message.</param> /// <param name="ex">The trace exception. This parameter is optional.</param> public void Trace(TraceLevel level, string message, Exception?ex) { StringBuilder sb = new StringBuilder(); sb.Append( DateTime.Now.ToString( "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff", CultureInfo.InvariantCulture ) ); sb.Append(" "); sb.Append(level.ToString("g")); sb.Append(" "); sb.Append(message); string s = sb.ToString(); lock (_lock) { if (_traceMessages.Count >= 1000) { _traceMessages.Dequeue(); } _traceMessages.Enqueue(s); } }
public void Log(string message, TraceLevel level) { using (StreamWriter writer = File.AppendText(fileName + ".log")) { writer.WriteLine(message + "\t" + level.ToString() + "\t" + DateTime.Now); } }
/// <summary> /// Logs message to underlying loggers. /// </summary> /// <param name="callInfo">The call information.</param> /// <param name="traceLevel">The trace level.</param> /// <param name="message">The message.</param> private static void Log(CallInfo callInfo, TraceLevel traceLevel, string message) { string messageToLog = callInfo.ToString() + " -- " + traceLevel.ToString() + " -- " + message; Console.WriteLine(messageToLog); telemetryClient.TrackTrace(messageToLog); }
internal static void TraceOut(TraceLevel level, string text, string category, int indent) { if ( level.Equals(TraceLevel.Error) && TcPluginTraceSwitch.TraceError || level.Equals(TraceLevel.Warning) && TcPluginTraceSwitch.TraceWarning || level.Equals(TraceLevel.Info) && TcPluginTraceSwitch.TraceInfo || level.Equals(TraceLevel.Verbose) && TcPluginTraceSwitch.TraceVerbose ) { var timeStr = GetTraceTimeString(); if (indent < 0 && Trace.IndentLevel > 0) { Trace.IndentLevel--; } var levelStr = level.ToString() .Replace("Verbose", "Debug") .Replace("Warning", "Warn ") .Replace("Info", "Info "); Trace.WriteLine($"[A{AppDomain.CurrentDomain.Id}|T{Thread.CurrentThread.ManagedThreadId}] {text}", timeStr + " - " + levelStr + " - " + category); if (indent > 0) { Trace.IndentLevel++; } } }
private void LoggerWriteLine(int indent, TraceLevel level, string line, IReadOnlyList <KeyValuePair <string, object> > logState = null, Exception exception = null, bool labels = false) { if (level != TraceLevel.Off && labels) { var color = level switch { TraceLevel.Warning => ConsoleColor.Yellow, TraceLevel.Error => ConsoleColor.Red, _ => ConsoleColor.Green, }; var levelStr = level.ToString(); this.IO.Writer.Write("["); this.WriteAsColor(levelStr, color); this.IO.Writer.Write("] ".PadRight(9 - levelStr.Length)); } var shift = string.Join("", Enumerable.Repeat(' ', indent * 2)); this.IO.Writer.Write(shift); var index = -1; for (var i = 0; i < line.Length; i++) { if (line[i] == '{') { index = i; continue; } if (line[i] == '}') { var substr = line[index..i].Replace("{", "").Replace("}", "");
private void Log(string message, TraceLevel level) { if (level == TraceLevel.Warning) { Trace.TraceWarning(message); } else if (level == TraceLevel.Error) { Trace.TraceError(message); } else { Trace.TraceInformation(message); } if (ConsoleOutput) { Console.WriteLine(message); } if (!Directory.Exists(LogDirectory)) { Directory.CreateDirectory(LogDirectory); } var logEntry = string.Format("[{0} {1}][{2}]: {3}\r\n", DateTime.Now.ToString("yyyy-MM-dd"), DateTime.Now.ToString("hh:mm:sstt"), level.ToString().ToUpper(), message); File.AppendAllText(LogFile, logEntry); }
public void Trace(TraceLevel level, string message, Exception ex) { if (level <= LevelFilter) { _output.WriteLine("{0}: {1}", level.ToString(), message); } }
public override void Log(TraceLevel level, object value, [CallerMemberName] string methodName = null) { if ((int)MaximumTraceLevel < (int)level) { return; } var msg = string.Format("{0}", value).Nullify(); if (msg != null) { msg = DateTime.Now + " | " + msg; } if (LogToConsole) { base.Log(level, value, methodName); } if (msg != null && LogToFile) { Task.Factory.StartNew(() => { using (var writer = new StreamWriter(FilePath, true, Encoding.UTF8)) { writer.WriteLine(level.ToString().PadRight(7) + " | #" + _counter + " | T" + Thread.CurrentThread.ManagedThreadId + " | " + msg); writer.Flush(); _counter++; } }, CancellationToken.None, TaskCreationOptions.None, _scheduler); } }
private void loglevelMenuItem_Click(object sender, RoutedEventArgs e) { try { // update UI TraceLevel level = TraceLevel.Error; foreach (var pair in this.logLevelMenuItemGroup) { if (pair.Item1 == sender) { pair.Item1.IsChecked = true; level = pair.Item2; } else { pair.Item1.IsChecked = false; } } this.levelValueLabel.Content = level.ToString(); // set log level Logger.LogLevel = level; } catch (Exception exception) { ErrorMessage(exception.Message); } }
public static void Log(TraceLevel loglevel, string type, string message, string user, string host) { OdbcConnection con = new OdbcConnection(ConfigurationManager.ConnectionStrings["MASTERDB2LOCAL"].ConnectionString); try { string query = string.Format("INSERT INTO AB_WEB_LOGS (LOGLEVEL, APPLICATIONNAME, LOGTYPENAME, THREAD, USERNAME, MACHINE, MESSAGE, AUDITTIMESTAMP) " + " VALUES('{0}','{1}','{2}','{3}','{4}','{5}', '{6}' , CURRENT TIMESTAMP)", loglevel.ToString(), "Multilinhas", type, HttpContext.Current.Session.SessionID, user, host, message); OdbcDataAdapter ad = new OdbcDataAdapter(); con.Open(); ad.InsertCommand = new OdbcCommand(query, con); ad.InsertCommand.ExecuteNonQuery(); con.Dispose(); } catch { //throw new Exception(ex.Message); } }
public FileLogTraceWriter(TraceLevel traceLevel, string sectionTitle) { _traceLevel = traceLevel; fileName = "JsonNETTraceLog" + "-" + _traceLevel.ToString() + ".log"; string text = "*** " + sectionTitle + ": " + traceLevel.ToString() + " ***" + Environment.NewLine; System.IO.File.AppendAllText(fileName, text); }
/// <summary> /// Constructs a new instance. /// </summary> /// <param name="window">The duration of the sliding window.</param> /// <param name="threshold">The maximum number of matching trace messages to allow before triggering a notification.</param> /// <param name="filter">The optional event filter to apply on each <see cref="TraceEvent"/>.</param> /// <param name="message">The optional message to use for notifications.</param> /// <param name="level">The maximum trace level of trace messages that will match the filter.</param> public SlidingWindowTraceFilter(TimeSpan window, int threshold, Func<TraceEvent, bool> filter = null, string message = null, TraceLevel level = TraceLevel.Error) { _window = window; _level = level; Threshold = threshold; _filter = filter; _notificationMessage = message ?? string.Format("{0} events at level '{1}' or lower have occurred within time window {2}.", threshold, level.ToString(), _window); }
} // Logger // ---------------------------------------------------------------------- private void Log(TraceLevel logLevel, object message, Exception exception) { if (!IsSupportedException(exception)) { return; } if (level.Level >= logLevel) { StringBuilder buf = new StringBuilder(name); buf.Append(": "); switch (logLevel) { case TraceLevel.Off: buf.Append("Fatal"); break; case TraceLevel.Verbose: buf.Append("Debug"); break; default: buf.Append(logLevel.ToString()); break; } buf.Append(": "); if (message != null) { buf.Append(message); } if (exception != null) { buf.Append(": "); buf.Append(exception.ToString()); } switch (logLevel) { case TraceLevel.Off: // used by 'fatal' case TraceLevel.Error: Trace.TraceError(buf.ToString()); break; case TraceLevel.Warning: Trace.TraceWarning(buf.ToString()); break; case TraceLevel.Info: goto default; case TraceLevel.Verbose: goto default; default: Trace.TraceInformation(buf.ToString()); break; } } } // Log
public void SettingTraceLevelTo(TraceLevel level) { var target = new Parameters { Trace = level }; var expected = " /trace:" + level.ToString().ToLower(); target.ToString().Should().Be(expected); }
public void Message(TraceLevel level, string text, string source, TextPosition position) { if (string.IsNullOrEmpty(source)) { Console.Error.WriteLine($"Twofold: {level.ToString()}: {text}"); Trace.WriteLine($"Twofold: {level.ToString()}: {text}"); return; } string positionText = ""; if (position.IsValid) { positionText = position.ToString(); } Console.Error.WriteLine($"{source}{positionText}: {level.ToString()}: {text}"); Trace.WriteLine($"{source}{positionText}: {level.ToString()}: {text}"); }
/// <summary> /// Writes the specified trace level, message and optional exception. /// </summary> /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param> /// <param name="message">The trace message.</param> /// <param name="ex">The trace exception. This parameter is optional.</param> public void Trace(TraceLevel level, string message, Exception ex) { string traceMessage = DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff", CultureInfo.InvariantCulture) + " " + level.ToString("g") + " " + message; if (_traceMessages.Count >= 1000) _traceMessages.Dequeue(); _traceMessages.Enqueue(traceMessage); }
/// <summary> /// Creates an entry with the given message text and application-defined event identifier to the event log list. /// </summary> /// <param name="title">The title.</param> /// <param name="message">The string to write to the event log.</param> /// <param name="level">Specifies what messages to output for the.</param> /// <param name="source">The source denominator of the message.</param> public ActivityLogCT(string title, string message, TraceLevel level, string source) : this() { Title = title; Body = message; this.ActivityPriority = level.ToString(); this.ActivitySource = source; this.Expires = DateTime.Now + new TimeSpan(2, 0, 0, 0); }
public void LogFunctionTraceEvent(TraceLevel level, string subscriptionId, string appName, string functionName, string eventName, string source, string details, string summary, Exception exception = null) { var elements = new string[] { level.ToString(), subscriptionId, appName, functionName, eventName, source, summary, details }; string evt = string.Join(" ", elements.Where(p => !string.IsNullOrEmpty(p))); lock (_syncLock) { Events.Add(evt); } }
public TraceLevelObject(TraceLevel level) { TLevel = level; Name = level.ToString(); if ((Properties.Settings.Default.ColoredLevels & (int)level) != 0) { RowColors = ColorUtil.TraceLevelPalette[level]; } }
public void WriteLine(string message, TraceLevel lvl = TraceLevel.TRACE) { var timestamp = UseTimeStamp ? DateTime.Now.ToString("u") + " " : ""; var lvlStr = lvl == TraceLevel.NONE ? "" : $"[{lvl.ToString()}]:"; lock (TraceStream) { TraceStream.WriteLine($"{timestamp}{lvlStr}{message}"); } }
public void Format_Verbose_Builds_Trace_With_All_TraceRecord_Properties(TraceLevel level) { // Arrange HttpRequestMessage request = new HttpRequestMessage { RequestUri = new Uri("http://localhost"), Method = HttpMethod.Get }; InvalidOperationException exception; try { // Want the full stack trace in the payload throw new InvalidOperationException("TestException"); } catch (InvalidOperationException ex) { exception = ex; } TraceRecord traceRecord = new TraceRecord(request, "TestCategory", level) { Message = "TestMessage", Operation = "TestOperation", Operator = "TestOperator", Status = HttpStatusCode.Accepted, Exception = exception }; // Act string formattedTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.Format( traceRecord ); // Assert AssertContainsExactly( formattedTrace, new Dictionary <string, string> { { "Level", level.ToString() }, { "Kind", TraceKind.Trace.ToString() }, { "Category", "'TestCategory'" }, { "Id", request.GetCorrelationId().ToString() }, { "Message", "'TestMessage'" }, { "Operation", "TestOperator.TestOperation" }, { "Status", "202 (Accepted)" }, { "Exception", exception.ToString() }, } ); }
private static void TraceLine(TraceLevel level, string format, object[] args) { if ((args == null) || (args.Length == 0)) { format = format.Replace("{", "{{"); format = format.Replace("}", "}}"); } string message = /*DateTime.Now.ToString("HH:mm:ss") + " : " +*/ string.Format(format, args); Trace.WriteLineIf(DoTrace(level), message, level.ToString()); }
public void Log(string message, TraceLevel level) { Log log = new Log { Message = message, Date = DateTime.Now, Level = level.ToString() }; Context.Logs.Add(log); Context.SaveChanges(); }
private void UpdateLogLevelUI(TraceLevel level) { // set menu item foreach (var pair in this.logLevelMenuItemGroup) { pair.Item1.IsChecked = (pair.Item2 == level); } this.levelValueLabel.Content = level.ToString(); return; }
public override void OnTcTrace(TraceLevel level, string text) { string msg = TcTrace.GetTraceTimeString() + " - " + level.ToString().Substring(0, 1) + " : " + text; foreach (object o in controls) { if (o is WpfListerControl) { ((WpfListerControl)o).AddLogMessage(msg); } } }
public void TracerLog(TraceLevel level, object obj) { using (DatabaseContext context = new DatabaseContext()) { context.Log.Add(new DatabaseLog { Message = (string)obj, TraceLevel = level.ToString(), Timestamp = DateTime.Now }); } }
private static void InternalWrite(TraceLevel level, string format, params object[] args) { try { if (_init == 0) { if (0 == System.Threading.Interlocked.Exchange(ref _init, 1)) { Open(); } } int depth = 2; if (args.Length > 0) { format = String.Format(format, args); } if (level <= _consoleLogLevel) { Console_LogWrite(level, format); } StackFrame frame; System.Reflection.MethodBase method; do { frame = new StackFrame(depth++); method = frame.GetMethod(); }while (method.ReflectedType.FullName.StartsWith("System.", StringComparison.OrdinalIgnoreCase) || method.ReflectedType.GetCustomAttributes(typeof(System.Diagnostics.DebuggerNonUserCodeAttribute), true).Length > 0); string methodName, callingType; methodName = String.Format("{0}", method); callingType = String.Format("{0}", method.ReflectedType); string full = String.Format("{0:D2}{1,8} - {2} at {3}", System.Threading.Thread.CurrentThread.ManagedThreadId, level == TraceLevel.Off ? "None" : level.ToString(), format, methodName); Trace.WriteLine(full, callingType); if (LogWrite != null) { LogWrite(method, level, format); } } catch (Exception e) { Trace.WriteLine(e.ToString(), "CSharpTest.Net.QuickLog.Write()"); } }
private static void Log(string message, TraceLevel level) { //TODO: Need to implement for real. Right now we just Debug Trace if ((Level & level) != 0) { System.Diagnostics.Debug.WriteLine($"{level.ToString().ToUpper()}: {message}"); } if (traceListener != null) { traceListener(message); } }
/// <summary> /// Writes the specified trace level, message and optional exception. /// </summary> /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param> /// <param name="message">The trace message.</param> /// <param name="ex">The trace exception. This parameter is optional.</param> public void Trace(TraceLevel level, string message, Exception ex) { if (_traceMessages.Count >= 1000) _traceMessages.Dequeue(); StringBuilder sb = new StringBuilder(); sb.Append(DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff", CultureInfo.InvariantCulture)); sb.Append(" "); sb.Append(level.ToString("g")); sb.Append(" "); sb.Append(message); _traceMessages.Enqueue(sb.ToString()); }
public static void Initialize(string logName, TraceLevel level) { if (!initialized) { Level = level; if (writer == null && Level > TraceLevel.Off) { writer = new InternalTraceWriter(logName); writer.WriteLine("InternalTrace: Initializing at level " + Level.ToString()); } initialized = true; } }
public static void Log(TraceLevel level, string message, string category, Exception ex) { Writer.WriteLine("{0} {1,-5} [{2,2}] {3}: {4}", DateTime.Now.ToString(TIME_FMT), level == TraceLevel.Verbose ? "Debug" : level.ToString(), #if NET_2_0 System.Threading.Thread.CurrentThread.ManagedThreadId, #else AppDomain.GetCurrentThreadId(), #endif category, message); if (ex != null) Writer.WriteLine(ex.ToString()); }
// Token: 0x060002C0 RID: 704 // RVA: 0x0002F2C8 File Offset: 0x0002D4C8 public void Trace(TraceLevel level, string message, Exception ex) { string item = string.Concat(new string[] { DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff", CultureInfo.InvariantCulture), " ", level.ToString("g"), " ", message }); if (this._traceMessages.Count >= 1000) { this._traceMessages.Dequeue(); } this._traceMessages.Enqueue(item); }
public static IisExpressWrapper Start(string appPath, TraceLevel traceLevel = TraceLevel.none) { int port = CassiniDev.CassiniNetworkUtils.GetAvailablePort( 8000, 8999, System.Net.IPAddress.Loopback, includeIdlePorts: false); if (port == 0) { throw new ApplicationException("Couldn't get available port for new IISExpress instance."); } var startInfo = new System.Diagnostics.ProcessStartInfo() { Arguments = String.Format(@"/path:""{0}"" /systray:true /clr:v4.0 /trace:{1} /port:{2}", appPath, traceLevel.ToString(), port), FileName = @"C:\Program Files (x86)\IIS Express\iisexpress.exe", WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden, RedirectStandardError = true, //RedirectStandardInput = true, RedirectStandardOutput = true, UseShellExecute = false, }; var process = System.Diagnostics.Process.Start(startInfo); var iew = new IisExpressWrapper(appPath, port, process); process.OutputDataReceived += iew.process_OutputDataReceived; process.ErrorDataReceived += iew.process_ErrorDataReceived; process.BeginErrorReadLine(); process.BeginOutputReadLine(); // Hack: wait a little for IIS Express to start. iew._iisStartedEvent.Wait(TimeSpan.FromMilliseconds(2000)); return iew; }
public static void writeAudit(string appName, TraceLevel traceLevel, string message, string userID) { if (traceType == TraceType.DB || traceType == TraceType.Both) { Trace trace = new Trace(); trace.AppName = appName; trace.Message = message; trace.TraceType = (short)traceLevel; trace.TraceLevel = (short)traceLevel; trace.UserID = userID; trace.CreateDateTime = DateTime.Now; DBLogs.Traces.Add(trace); DBLogs.SaveChanges(); } if (traceType == TraceType.File || traceType == TraceType.Both) { string msg = string.Empty; msg = DateTime.Now.ToLongDateString() + " : " + appName + " : " + traceLevel.ToString() + " : " + message + " : " + userID; writeFile(msg,WS_LogsFilePath + "\\" + traceFileName); } }
private LogLevel GetLogLevel(TraceLevel level) { // translates webapi log level to nlog log level return LogLevel.FromString(level.ToString()); }
private string GetSectionPrefix(TraceLevel traceLevel) { const int fixedLengthTraceLevel = 7; int postFixLength = fixedLengthTraceLevel - traceLevel.ToString().Length; var strTrcLvl = traceLevel.ToString().PadRight(postFixLength); var prefix = string.Format("[{0}] ", strTrcLvl); for (var i = 0; i < _indentLevel; i++) { prefix += LEVEL_INDICATOR; } return prefix; }
private void writeToTextFile(TraceLevel messageLevel, string message) { this.pLogFileMutex.Lock(); StreamWriter writer = null; try { writer = new StreamWriter(this.pLogFilePath + this.pLogFileName + "_" + DateTime.Today.ToString("yyyy-MM-dd"), true); writer.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "," + Csv.Escape(this.pLoggingSystemName) + ",'" + Csv.Escape(messageLevel.ToString()) + "'," + Csv.Escape(message)); writer.Close(); this.pLogFileMutex.Unlock(); } catch (Exception) { if (writer != null) { writer.Close(); } this.pLogFileMutex.Unlock(); } }
public string GetWithNullableEnumParameter(TraceLevel? level) { return level.ToString(); }
public void SetParameterTraceLevel(TraceLevel traceLevel) { var configFileParameters = new ConfigFileParameters { TraceLevel = traceLevel }; var pathParameters = new PathParameters { TraceLevel = traceLevel }; var expected = " /trace:" + traceLevel.ToString().ToLower(); configFileParameters.ToString().Should().Be(expected); pathParameters.ToString().Should().Be(expected); }
private static void Log(TraceLevel level, string message) { string.Format("{0}:{1}:{2}: {3}", (object) (level != TraceLevel.Off ? level.ToString().PadRight(7) : "Always".PadRight(7)), (object) DateTime.UtcNow.ToString("yyyyMMdd.HHmmss"), (object) ("(" + DateTime.Now.ToString("yyyyMMdd.HHmmss:fffff ") + ")"), (object) message); }
private static void InternalWrite(TraceLevel level, string format, params object[] args) { try { if (_init == 0) { if (0 == System.Threading.Interlocked.Exchange(ref _init, 1)) { Open(); } } int depth = 2; if (args.Length > 0) format = String.Format(format, args); if (level <= _consoleLogLevel) Console_LogWrite(level, format); StackFrame frame; System.Reflection.MethodBase method; do { frame = new StackFrame(depth++); method = frame.GetMethod(); } while (method.ReflectedType.FullName.StartsWith("System.", StringComparison.OrdinalIgnoreCase) || method.ReflectedType.GetCustomAttributes(typeof(System.Diagnostics.DebuggerNonUserCodeAttribute), true).Length > 0); string methodName, callingType; methodName = String.Format("{0}", method); callingType = String.Format("{0}", method.ReflectedType); string full = String.Format("{0:D2}{1,8} - {2} at {3}", System.Threading.Thread.CurrentThread.ManagedThreadId, level == TraceLevel.Off ? "None" : level.ToString(), format, methodName); Trace.WriteLine(full, callingType); if (LogWrite != null) LogWrite(method, level, format); } catch (Exception e) { Trace.WriteLine(e.ToString(), "CSharpTest.Net.QuickLog.Write()"); } }
public void Trace_Verbose_Writes_Correct_Message_To_TraceListeners_With_All_Fields_Set(TraceLevel level) { // Arrange SystemDiagnosticsTraceWriter writer = CreateTraceWriter(); writer.MinimumLevel = level; writer.IsVerbose = true; HttpRequestMessage request = new HttpRequestMessage { RequestUri = new Uri("http://localhost"), Method = HttpMethod.Get }; InvalidOperationException exception = new InvalidOperationException("TestException"); // Act writer.Trace(request, "TestCategory", level, (tr) => { tr.Message = "TestMessage"; tr.Operation = "TestOperation"; tr.Operator = "TestOperator"; tr.Status = HttpStatusCode.Accepted; tr.Exception = exception; }); // Assert string expected = String.Format("Level={0}, Kind=Trace, Category='TestCategory', Id={1}, Message='TestMessage', Operation=TestOperator.TestOperation, Status=202 (Accepted), Exception={2}", level.ToString(), request.GetCorrelationId().ToString(), exception.ToString()); string actual = ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages[0].Trim(); string timePrefix = "] "; actual = actual.Substring(actual.IndexOf(timePrefix) + timePrefix.Length); Assert.Equal(expected, actual); }
public void Format_Verbose_Builds_Trace_With_All_TraceRecord_Properties(TraceLevel level) { // Arrange HttpRequestMessage request = new HttpRequestMessage { RequestUri = new Uri("http://localhost"), Method = HttpMethod.Get }; InvalidOperationException exception; try { // Want the full stack trace in the payload throw new InvalidOperationException("TestException"); } catch (InvalidOperationException ex) { exception = ex; } TraceRecord traceRecord = new TraceRecord(request, "TestCategory", level) { Message = "TestMessage", Operation = "TestOperation", Operator = "TestOperator", Status = HttpStatusCode.Accepted, Exception = exception }; // Act string formattedTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.Format(traceRecord); // Assert AssertContainsExactly(formattedTrace, new Dictionary<string, string> { { "Level", level.ToString() }, { "Kind", TraceKind.Trace.ToString() }, { "Category", "'TestCategory'"}, { "Id", request.GetCorrelationId().ToString() }, { "Message", "'TestMessage'" }, { "Operation", "TestOperator.TestOperation" }, { "Status", "202 (Accepted)" }, { "Exception", exception.ToString() }, }); }
//private void InitializeConfigFile() //{ // _appConfigFile = new FileInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "nHydrate\\" + _configName)); // if (!_appConfigFile.Directory.Exists) // _appConfigFile.Directory.Create(); // if (!_appConfigFile.Exists) // _appConfigFile.Create(); // _appFileWatcher = new FileSystemWatcher(_appConfigFile.DirectoryName, _appConfigFile.Name); // _appFileWatcher.NotifyFilter = NotifyFilters.LastWrite; // _appFileWatcher.Changed += new FileSystemEventHandler(mAppFileWatcher_Changed); // _appFileWatcher.EnableRaisingEvents = true; //} #endregion #region TraceStatements private static void Log(TraceLevel level, string message) { string traceLevelString; if (level == TraceLevel.Off) { traceLevelString = "Always"; traceLevelString = traceLevelString.PadRight(7); } else { traceLevelString = level.ToString(); traceLevelString = traceLevelString.PadRight(7); } var logString = String.Format("{0}:{1}: {2}", traceLevelString, DateTime.UtcNow.ToString("yyyyMMdd.HHmmss"), message); Trace.WriteLine(logString); }
public void SettingTraceLevelTo(TraceLevel level) { var target = new Parameters {Trace = level}; var expected = " /trace:" + level.ToString().ToLower(); target.ToString().Should().Be(expected); }
// ---------------------------------------------------------------------- private void Log( TraceLevel logLevel, object message, Exception exception ) { if ( !IsSupportedException( exception ) ) { return; } if ( level.Level >= logLevel ) { StringBuilder buf = new StringBuilder( name ); buf.Append( ": " ); switch ( logLevel ) { case TraceLevel.Off: buf.Append( "Fatal" ); break; case TraceLevel.Verbose: buf.Append( "Debug" ); break; default: buf.Append( logLevel.ToString() ); break; } buf.Append( ": " ); if ( message != null ) { buf.Append( message ); } if ( exception != null ) { buf.Append( ": " ); buf.Append( exception.ToString() ); } switch ( logLevel ) { case TraceLevel.Off: // used by 'fatal' case TraceLevel.Error: Trace.TraceError( buf.ToString() ); break; case TraceLevel.Warning: Trace.TraceWarning( buf.ToString() ); break; case TraceLevel.Info: goto default; case TraceLevel.Verbose: goto default; default: Trace.TraceInformation( buf.ToString() ); break; } } }
public static void TurnTraceSwitchOn(TraceLevel traceLevel = TraceLevel.Info) { TraceSwitch = new TraceSwitch("DataConnection", "DataConnection trace switch", traceLevel.ToString()); }
static void log(TraceLevel level, string message) { bool log = false; switch (level) { case TraceLevel.Info: log = TRACE_SWITCH.TraceInfo; break; case TraceLevel.Error: log = TRACE_SWITCH.TraceError; break; case TraceLevel.Verbose: log = TRACE_SWITCH.TraceVerbose; break; case TraceLevel.Warning: log = TRACE_SWITCH.TraceWarning; break; } Trace.WriteLineIf(log, string.Format("{0} {1}: {2}", DateTime.Now.ToString("yyyyMMdd HH:mm:ss.ff"), level.ToString(), message)); }
/// <summary> /// Writes a message to the log /// </summary> /// <param name="message"></param> /// <param name="level"></param> public void Write(string message, TraceLevel level) { if (!MayWriteType(level)) return; var caller = "TShock"; var frame = new StackTrace().GetFrame(2); if (frame != null) { var meth = frame.GetMethod(); if (meth != null && meth.DeclaringType != null) caller = meth.DeclaringType.Name; } var logEntry = string.Format("{0} - {1}: {2}: {3}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture), caller, level.ToString().ToUpper(), message); try { _logWriter.WriteLine(logEntry); _logWriter.Flush(); } catch (ObjectDisposedException) { ServerApi.LogWriter.PluginWriteLine(TShock.instance, logEntry, TraceLevel.Error); Console.WriteLine("Unable to write to log as log has been disposed."); Console.WriteLine("{0} - {1}: {2}: {3}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture), caller, level.ToString().ToUpper(), message); } }
private void writeLog(TraceLevel level, string value) { if (level <= this.Level && textBox != null) { textBox.AppendText(DateTime.Now+" "+level.ToString()+": "+value+"\r\n"); textBox.Refresh(); } if(level <= this.Level && logStream != null) { byte[] ss = Encoding.ASCII.GetBytes(DateTime.Now+" "+level.ToString()+": "+value+"\r\n"); logStream.Write(ss, 0, ss.Length); logStream.Flush(); } Trace.WriteLineIf(level <= this.Level, DateTime.Now+" "+level.ToString()+": "+value); }
private static void doWrite(string message, TraceLevel level = TraceLevel.Info) { string line = "[" + DateTime.Now.ToString() + "]"; line += "[" + level.ToString() + "]" + "[" + message + "]"; StackTrace st = new StackTrace(); if (st.FrameCount < 2) { line += "[UNKNOWN_PACKAGE::UNKNOWN_METHOD]"; } else { int verboseStacktraceLength = st.FrameCount; string stack = ""; if (level != TraceLevel.Verbose) verboseStacktraceLength = 3; for ( int frameIdx = 2; frameIdx < verboseStacktraceLength; frameIdx++ ) { stack += "\n"; if (frameIdx > 2) stack += " "; StackFrame sf = st.GetFrame(frameIdx); MethodBase mb = sf.GetMethod(); stack += "[" + mb.Module.Name + "::" + mb.DeclaringType.FullName + "::" + mb.Name + "]"; if (level == TraceLevel.Error || level == TraceLevel.Verbose) stack += "[" + sf.GetFileName() + "::" + sf.GetFileLineNumber() + "]"; } stack = stack.Substring(1); line += stack; } System.Diagnostics.Trace.WriteLine( line ); foreach ( TraceCallback fn in _callbacks ) fn.Invoke( line ); }