/// <summary> /// This logging is done with simple methods like local logging. The <paramref name="message"/> will be extended with application information and possibly exception information. /// </summary> /// <param name="severityLevel">The severity level for this log.</param> /// <param name="message">The message to log.</param> /// <param name="exception">An optional exception that will have it's information incorporated in the message.</param> /// <param name="memberName">Method or property name of the caller</param> /// <param name="filePath">Full path of the source file that contains the caller. This is the file path at compile time.</param> /// <param name="lineNumber">Line number in the source file at which the method is called</param> public static void FallbackSafeLog( LogSeverityLevel severityLevel, string message, Exception exception = null, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0) { try { var hideStackTrace = severityLevel < LogSeverityLevel.Error; // ReSharper disable ExplicitCallerInfoArgument var location = LocationToLogString(memberName, filePath, lineNumber); // ReSharper restore ExplicitCallerInfoArgument var messageWithLogInfo = $"{severityLevel}: {message}"; messageWithLogInfo += $"\r{FulcrumApplication.ToLogString()}"; messageWithLogInfo += ContextToLogString(); messageWithLogInfo += $"\r{location}"; if (exception != null) { messageWithLogInfo += $"\r{exception.ToLogString(hideStackTrace)}"; } FulcrumApplication.Setup.FallbackLogger.SafeLog(severityLevel, messageWithLogInfo); } catch (Exception) { // We give up } }
public void LogFormat(string format, LogSeverityLevel severityLevel, string category = null, [CallerFilePath] string filePath = "", [CallerMemberName] string memberName = "", [CallerLineNumber] int lineNumber = 0, params object[] args) { Log(string.Format(format, args), severityLevel, category); }
public void Log(string message, LogSeverityLevel severityLevel, string category = null, [CallerFilePath] string filePath = "", [CallerMemberName] string memberName = "", [CallerLineNumber] int lineNumber = 0) { if ((int)severityLevel >= (int)MinimumSeverityLevel) { Debug.WriteLine(severityLevel + ": " + message + ", File: " + filePath + ", MemberName: " + memberName + ", LineNumber: " + lineNumber); } }
/// <summary> /// /// </summary> /// <param name="logAllThreshold">If any of the log records in the batch has this or higher severity level, /// the <see cref="ApplicationSetup.LogSeverityLevelThreshold"/> will be ignored and consequently all log records will be logged. /// Set this to <see cref="LogSeverityLevel.None"/> to avoid this functionality, i.e. only <see cref="ApplicationSetup.LogSeverityLevelThreshold"/> will be used.</param> /// <param name="releaseRecordsAsLateAsPossible">This is relevant when a log record is logged that fulfills the <paramref name="logAllThreshold"/> threshold. /// If true, the logs in the batch will not be released until <see cref="EndBatch"/> is called. If false, then the current log records will be immediately released /// and the following individual logs in the batch will be release immediately.</param> public static void StartBatch( LogSeverityLevel logAllThreshold = LogSeverityLevel.Error, bool releaseRecordsAsLateAsPossible = false) { AsyncLocalBatch.Value = new BatchInfo(); Batch.LogRecords = new List <LogRecord>(); Batch.ContextId = FulcrumApplication.Context.ContextId; Batch.HasReachedThreshold = false; Batch.LogAllThreshold = logAllThreshold; Batch.ReleaseRecordsAsLateAsPossible = releaseRecordsAsLateAsPossible; FulcrumApplication.Context.IsInBatchLogger = true; }
/// <inheritdoc /> public void SafeLog(LogSeverityLevel logSeverityLevel, string message) { try { if (logSeverityLevel == LogSeverityLevel.None) { return; } Console.WriteLine($"\r{logSeverityLevel} {message}\r"); } catch (Exception) { // This method must never fail. } }
/// <summary> /// Safe logging of a message. Will check for errors, but never throw an exception. If the log can't be made, a fallback log will be created. /// </summary> /// <param name="logger">The logger to use for publishing the message.</param> /// <param name="severityLevel">The severity level for this log.</param> /// <param name="message">The message to log (will be concatenated with any <paramref name="exception"/> information).</param> /// <param name="exception">Optional exception</param> public static async Task LogAsync(IFulcrumLogger logger, LogSeverityLevel severityLevel, string message, Exception exception = null) { try { InternalContract.RequireNotNull(logger, nameof(logger)); var formattedMessage = FormatMessage(message, exception); await logger.LogAsync(severityLevel, formattedMessage); } catch (Exception) { // TODO: Log somewhere //var formattedMessage = FormatMessage(message, e); //await SafeLogger.Instance.LogAsync(tenant, SeverityLevel.Critical, formattedMessage); } }
/// <inheritdoc /> public void SafeLog(LogSeverityLevel logSeverityLevel, string message) { try { if (logSeverityLevel == LogSeverityLevel.None) { return; } message = $"[{DateTimeOffset.Now}] {message}"; TraceEventType eventType; switch (logSeverityLevel) { case LogSeverityLevel.Verbose: eventType = TraceEventType.Verbose; break; case LogSeverityLevel.Information: eventType = TraceEventType.Information; break; case LogSeverityLevel.Warning: eventType = TraceEventType.Warning; break; case LogSeverityLevel.Error: eventType = TraceEventType.Error; break; case LogSeverityLevel.Critical: eventType = TraceEventType.Critical; break; // ReSharper disable once RedundantCaseLabel case LogSeverityLevel.None: default: TraceSource.TraceEvent(TraceEventType.Critical, 0, $"Unexpected {nameof(logSeverityLevel)} ({logSeverityLevel}) for message:\r{message}."); return; } TraceSource.TraceEvent(eventType, 0, $"\r{message}\r"); } catch (Exception) { // This method should never fail. } }
public void Initialize() { FulcrumApplicationHelper.UnitTestSetup(typeof(TestLogHelper).FullName); _loggedSeverityLevel = LogSeverityLevel.None; _loggedMessage = null; var fallbackLoggerMock = new Mock <IFallbackLogger>(); fallbackLoggerMock .Setup(logger => logger.SafeLog(It.IsAny <LogSeverityLevel>(), It.IsAny <string>())) .Callback((LogSeverityLevel sl, string m) => { _loggedSeverityLevel = sl; _loggedMessage = m; }); FulcrumApplication.Setup.FallbackLogger = fallbackLoggerMock.Object; }
public UberLoggerStackdriver(StartCoroutineDelegate startCoroutine, string backendUrl, int maxMessagesPerPost, float minIntervalBetweenPosts, LogSeverityLevel logSeverityLevel, IncludeCallstackMode includeCallstacks, int maxRetries, string sessionId) { this.startCoroutine = startCoroutine; this.backendUrl = backendUrl; this.maxMessagesPerPost = maxMessagesPerPost; this.minIntervalBetweenPosts = minIntervalBetweenPosts; this.logSeverityLevel = logSeverityLevel; this.includeCallstacks = includeCallstacks; this.maxRetries = maxRetries; this.sessionId = sessionId; stackdriverEntries = new StackdriverEntries(sessionId); stackdriverEntriesInFlight = new StackdriverEntries(sessionId); Assert.IsNotNull(this.backendUrl, "You must supply a target URL for the UberLoggerStackdriver backend API. UberLoggerStackdriver will be inactive."); }
/// <summary> /// Safe logging of a message. Will check for errors, but never throw an exception. If the log can't be made, a fallback log will be created. /// </summary> /// <param name="logger">The logger to use for publishing the message.</param> /// <param name="tenant">Current tenant.</param> /// <param name="severityLevel">The severity level for this log.</param> /// <param name="message">The message to log (will be concatenated with any <paramref name="exception"/> information).</param> /// <param name="exception">Optional exception</param> public static void Log(IFulcrumLogger logger, ITenant tenant, LogSeverityLevel severityLevel, string message, Exception exception = null) { try { InternalContract.RequireNotNull(logger, nameof(logger)); InternalContract.RequireNotNull(tenant, nameof(tenant)); var formattedMessage = FormatMessage(message, exception); logger.Log(tenant, severityLevel, formattedMessage); } catch (Exception) { // TODO: Log somewhere //var formattedMessage = FormatMessage(message, e); //SafeLogger.Instance.Log(tenant, SeverityLevel.Critical, formattedMessage); } }
public void Log(LogSeverityLevel severity, string message) { var line = new LogRecord { DateTime = DateTime.Now, Severity = severity, Message = message }; _dbcontext.LogRecords.Add(line); if (_dbcontext.LogRecords.Count() > 50) { _dbcontext.LogRecords.RemoveRange(_dbcontext.LogRecords.OrderBy(l => l.DateTime).Take(10)); } _dbcontext.SaveChanges(); }
private string LastMessage(LogSeverityLevel severityLevel) { var count = 0; while (count++ < 100 && _numberOfLogs < _expectedNumberOfLogs) { Thread.Sleep(TimeSpan.FromMilliseconds(10)); } Assert.IsFalse(_numberOfLogs < _expectedNumberOfLogs, $"Expected {_expectedNumberOfLogs} logs, got {_numberOfLogs}"); while (count++ < 100 && _numberOfLogs <= _expectedNumberOfLogs && !_lastMessageDictionary.ContainsKey(severityLevel)) { Thread.Sleep(TimeSpan.FromMilliseconds(10)); } Assert.IsFalse(_numberOfLogs > _expectedNumberOfLogs, $"Expected {_expectedNumberOfLogs} logs, got {_numberOfLogs}"); return(!_lastMessageDictionary.ContainsKey(severityLevel) ? null : _lastMessageDictionary[severityLevel]); }
private void OnLogHandlerEvent(string log, LogSeverityLevel level) { switch (level) { case LogSeverityLevel.Information: this.WriteRuninglog(log, "ok"); break; case LogSeverityLevel.Warning: this.WriteRuninglog(log, "error"); break; case LogSeverityLevel.Error: break; default: break; } }
/// <inheritdoc /> public void SafeLog(LogSeverityLevel logSeverityLevel, string message) { try { if (logSeverityLevel == LogSeverityLevel.None) { return; } if (logSeverityLevel >= LogSeverityLevel.Warning) { System.Diagnostics.Trace.WriteLine($"\r{logSeverityLevel} {message}\r"); } else { System.Diagnostics.Debug.WriteLine($"\r{logSeverityLevel} {message}\r"); } } catch (Exception) { // This method must never fail. } }
public void FallbackSafeLog() { const LogSeverityLevel expectedLevel = LogSeverityLevel.Error; const string exceptionMessage = "ExceptionMessage"; const string message = "TestMessage"; try { throw new TestException(exceptionMessage); } catch (Exception expectedException) { // ReSharper disable ExplicitCallerInfoArgument LogHelper.FallbackSafeLog(expectedLevel, message, expectedException, "memberName", "filePath", 42); // ReSharper restore ExplicitCallerInfoArgument UT.Assert.AreEqual(expectedLevel, _loggedSeverityLevel); UT.Assert.IsNotNull(_loggedMessage); // ReSharper disable ExplicitCallerInfoArgument UT.Assert.IsTrue(_loggedMessage.Contains(LogHelper.LocationToLogString("memberName", "filePath", 42))); // ReSharper restore ExplicitCallerInfoArgument UT.Assert.IsTrue(_loggedMessage.Contains(FulcrumApplication.ToLogString())); } }
public bool IsEnabled(LogSeverityLevel logSeverityLevel) { return(false); }
/// <summary> /// Compares the current <see cref="SeverityLevel"/> with the supplied <paramref name="severityLevel"/>. /// </summary> /// <returns>True if the current level is greater than or equal to the value in the parameter <paramref name="severityLevel"/>.</returns> public bool IsGreaterThanOrEqualTo(LogSeverityLevel severityLevel) { return((int)SeverityLevel >= (int)severityLevel); }
public bool IsEnabled(LogSeverityLevel logSeverityLevel) { return(_logger.IsEnabled((LogLevel)logSeverityLevel)); }
public LogEntry(string message, LogSeverityLevel severity) { Message = message; Severity = severity; }
public static void Write(this ILogger logger, string message, LogSeverityLevel logSeverityLevel) { logger.Write(new LogEntry(message, logSeverityLevel)); }
public DefaultLoggingProvider(LogSeverityLevel minimumSeverityLevel = LogSeverityLevel.Debug) { MinimumSeverityLevel = minimumSeverityLevel; }
public void Log(LogSeverityLevel logSeverityLevel, string message) { throw new NotImplementedException(); }
public bool IsEnabled(LogSeverityLevel severity) { return(true); }
public static IApplicationBuilder UseNexusBatchLogs( this IApplicationBuilder builder, LogSeverityLevel logAllThreshold = LogSeverityLevel.Error, bool releaseRecordsAsLateAsPossible = false) { return(builder.UseMiddleware <BatchLogs>(logAllThreshold, releaseRecordsAsLateAsPossible)); }