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