/// <summary>
/// Add new section to running log card
/// </summary>
/// <param name="severity">Optional: severity of the section</param>
/// <param name="title">Optional: Title of the section</param>
/// <param name="text">Optional: Summary of the section</param>
/// <param name="eventTitle">Optional: Section event title</param>
/// <param name="eventSubtitle">Optional: Section event subtitle</param>
/// <param name="eventSummary">Optional: Section event summary</param>
/// <param name="markdown">If any text has markdown</param>
public void CreateNewMessageCard(LogSeverity?severity = null, string title = null, string text = null, string eventTitle = null, string eventSubtitle = null, string eventSummary = null, bool?markdown = null)
{
if (severity.HasValue && severity.Value == LogSeverity.Error)
{
_hasException = true;
}
if (severity.HasValue && severity.Value == LogSeverity.Warn && !_hasException)
{
_hasWarning = true;
}
var section = new O365ConnectorCardSection(title, text, eventTitle, eventSubtitle, eventSummary, null, null, markdown);
if (_card.Sections == null || !_card.Sections.Any())
{
_card.Sections = new List <O365ConnectorCardSection> {
section
};
}
else
{
_card.Sections.Add(section);
}
_currentSection = section;
}
private void _searchButton_Click(object sender, EventArgs e)
{
try
{
Cursor.Current = Cursors.WaitCursor;
string module = _moduleComboBox.Text.Length > 0 ? _moduleComboBox.Text : null;
LogSeverity?logSeverity = null;
if (!String.IsNullOrEmpty(_severityComboBox.Text))
{
logSeverity = (LogSeverity)Enum.Parse(typeof(LogSeverity), _severityComboBox.Text, true);
}
var result = Proxies.LogService.GetLogEntries(_startDatePicker.Value.Date, _endDatePicker.Value.Date.AddDays(1), _maxLogEntries, module, logSeverity).Result;
_maxEntriesReachedLabel.Visible = result.MaxEntriesReached;
if (result.MaxEntriesReached)
{
_maxEntriesReachedLabel.Text = String.Format(CultureInfo.CurrentCulture, "Warning: only the first {0} log messages are displayed, more are available.", result.LogEntries.Count);
}
_logListControl.LogEntries = new SortableBindingList <LogEntry>(result.LogEntries);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void Log(string message, LogSeverity severity, Exception exception)
{
LastMessageSeverity = severity;
LastMessage = message;
LastException = exception;
MessagesReceived++;
}
public void Handle(LogSeverity severity, Exception exception, string format, params object[] args)
{
LastMessageSeverity = severity;
LastMessage = string.Format(format, args);
LastException = exception;
MessagesHandled++;
}
public void Log(string message, LogSeverity severity, Exception exception)
{
LastMessageSeverity = severity;
LastMessage = message;
LastException = exception;
MessagesReceived++;
}
public async Task <IActionResult> GetLatestLogs(
[FromQuery] int pageSize = 200,
[FromQuery] int pageNum = 1,
[FromQuery] LogCategory?category = null,
[FromQuery] LogSeverity?severity = null,
[FromQuery] string sortBy = "Timestamp",
[FromQuery] bool sortDescending = true)
{
var pageInfo = new PageInfo
{
SortBy = sortBy,
SortDescending = sortDescending,
PageSize = pageSize,
PageNum = pageNum
};
var result = await _adminLogService.GetLatestLogEntries(pageInfo, category, severity);
var dtos = new List <Dto.LogEntry>();
foreach (var entry in result.Data)
{
dtos.Add(new Dto.LogEntry(entry));
}
return(Ok(new DataList <Dto.LogEntry>(dtos, result.PageInfo)));
}
/// <summary>
/// Gets the log entries.
/// </summary>
/// <param name="pageInfo">The page information.</param>
/// <param name="category">The category.</param>
/// <param name="serverity">The serverity.</param>
/// <param name="timestampStart">The timestamp start.</param>
/// <param name="timestampEnd">The timestamp end.</param>
/// <returns>A paged list of log entries.</returns>
public async Task <DataList <LogEntry> > GetLogEntries(PageInfo pageInfo,
LogCategory?category,
LogSeverity?serverity,
DateTime timestampStart,
DateTime timestampEnd)
{
var where = "WHERE Timestamp >= @TimetampStart AND Timestamp <= @TimetampEnd ";
var parameters = new DynamicParameters();
parameters.Add("@TimetampStart", timestampStart);
parameters.Add("@TimetampEnd", timestampEnd);
if (category != null)
{
where += "AND Category = @Category ";
parameters.Add("@Category", (int)category);
}
if (serverity != null)
{
where += "AND Severity = @Severity ";
parameters.Add("@Severity", (int)serverity);
}
var orderBy = "Timestamp" + (pageInfo.SortDescending ? " DESC" : "");
var data = await GetListPagedAsync <LogEntry>(where, parameters, orderBy, pageInfo.PageNum, pageInfo.PageSize);
pageInfo.TotalRecords = (int) await GetRecordCount <LogEntry>(where, parameters);
return(new DataList <LogEntry>(data, pageInfo));
}
public static async Task Log(string message, LogSeverity severity = LogSeverity.Info, LogCat cat = LogCat.Default, bool logConsole = true, bool logFile = true)
{
try
{
_logPath = _logPath ?? Path.Combine(SettingsManager.RootDirectory, "logs");
_logSeverity = _logSeverity ?? SettingsManager.Get("config", "logSeverity").ToSeverity();
if ((int)_logSeverity > (int)severity)
{
return;
}
var file = Path.Combine(_logPath, $"{cat}.log");
if (!Directory.Exists(_logPath))
{
Directory.CreateDirectory(_logPath);
}
var cc = Console.ForegroundColor;
switch (severity)
{
case LogSeverity.Critical:
case LogSeverity.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogSeverity.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LogSeverity.Info:
Console.ForegroundColor = ConsoleColor.White;
break;
case LogSeverity.Verbose:
case LogSeverity.Debug:
Console.ForegroundColor = ConsoleColor.DarkGray;
break;
}
if (logFile)
{
await File.AppendAllTextAsync(file, $"{DateTime.Now,-19} [{severity,8}]: {message}{Environment.NewLine}");
}
if (logConsole)
{
Console.WriteLine($"{DateTime.Now,-19} [{severity,8}] [{cat}]: {message}");
}
Console.ForegroundColor = cc;
}
catch
{
// ignored
}
}
public string Execute(LogSeverity?severity = null)
{
if (severity.HasValue)
{
Api.Shared.LogSeverity = severity.Value;
}
return("Current log severity is: " + Api.Shared.LogSeverity);
}
/// <summary>
/// Constructs a filter string based on log name, severity, type of log, before and after timestamps
/// and other advanced filter.
/// </summary>
protected string ConstructLogFilterString(string logName, LogSeverity?logSeverity, string selectedType,
DateTime?before, DateTime?after, string otherFilter)
{
string andOp = " AND ";
string filterString = "";
if (!string.IsNullOrWhiteSpace(logName))
{
// By setting logName = LogName in the filter, the list request
// will only return log entry that belongs to LogName.
// Example: logName = "Name of log".
filterString = $"logName = '{logName}'{andOp}".Replace('\'', '"');
}
if (logSeverity.HasValue)
{
// Example: severity >= ERROR.
string severityString = Enum.GetName(typeof(LogSeverity), logSeverity.Value).ToUpper();
filterString += $"severity = {severityString}{andOp}";
}
if (selectedType != null)
{
// Example: resource.type = "gce_instance".
filterString += $"resource.type = '{selectedType}'{andOp}".Replace('\'', '"');
}
if (before.HasValue)
{
// Example: timestamp <= "2016-06-27T14:40:00-04:00".
string beforeTimestamp = XmlConvert.ToString(before.Value, XmlDateTimeSerializationMode.Local);
filterString += $"timestamp <= '{beforeTimestamp}'{andOp}".Replace('\'', '"');
}
if (after.HasValue)
{
// Example: timestamp >= "2016-06-27T14:40:00-04:00".
string afterTimestamp = XmlConvert.ToString(after.Value, XmlDateTimeSerializationMode.Local);
filterString += $"timestamp >= '{afterTimestamp}'{andOp}".Replace('\'', '"');
}
if (otherFilter != null)
{
filterString += otherFilter;
}
// Strip the "AND " at the end if we have it.
if (filterString.EndsWith(andOp))
{
filterString = filterString.Substring(0, filterString.Length - andOp.Length);
}
return(filterString);
}
public static LogEntry Create(string message, Exception error = null, LogSeverity?severity = null)
{
if (severity == null)
{
severity = error == null
? LogSeverity.Info
: LogSeverity.Error;
}
var data = error == null
? new object[] { message }
: new object[] { message, error };
return(new LogEntry(severity.Value, data));
}
public async Task Get_User_Logs_By_Date_Window_And_Severity_Async_Test()
{
// Arrange
DateTime?start = newlog.DateCreated,
end = newlog.DateCreated;
LogSeverity?severity = newlog.Severity;
// Act
var existedLogs = await logService.GetUserLogsAsync(userId, start, end, severity, null);
// Assert
Assert.NotNull(existedLogs);
Assert.NotEmpty(existedLogs);
}
public static async Task Log(string message, LogSeverity severity = LogSeverity.Info, LogCat cat = LogCat.Default, bool logConsole = true, bool logFile = true)
{
try
{
_logPath = _logPath ?? Path.Combine(SettingsManager.DataDirectory, "logs");
_logSeverity = _logSeverity ?? SettingsManager.Settings.Config.LogSeverity.ToSeverity();
if ((int)_logSeverity > (int)severity)
{
return;
}
var file = Path.Combine(_logPath, $"{cat}.log");
if (!Directory.Exists(_logPath))
{
Directory.CreateDirectory(_logPath);
}
// var cc = Console.ForegroundColor;
logFile = logFile && !SettingsManager.Settings.Config.DisableLogIntoFiles;
if (logConsole)
{
var time = DateTime.Now.ToString("HH:mm:ss");
var msg = $"{time} [{severity,8}] [{cat,13}]: {message}";
await SystemLogFeeder.FeedMessage(msg, severity == LogSeverity.Critical || severity == LogSeverity.Error);
if (!SettingsManager.Settings.Config.RunAsServiceCompatibility)
{
try
{
switch (severity)
{
case LogSeverity.Critical:
case LogSeverity.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogSeverity.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LogSeverity.Info:
Console.ForegroundColor = ConsoleColor.White;
break;
case LogSeverity.Verbose:
case LogSeverity.Debug:
Console.ForegroundColor = ConsoleColor.DarkGray;
break;
case LogSeverity.Module:
Console.ForegroundColor = ConsoleColor.Gray;
break;
}
Console.WriteLine(msg);
}
catch
{
//ignore
}
}
}
if (logFile)
{
await File.AppendAllTextAsync(file, $"{DateTime.Now,-19} [{severity,8}]: {message}{Environment.NewLine}");
}
}
catch
{
// ignored
}
}
public static async Task Log(string message, LogSeverity severity = LogSeverity.Info, LogCat cat = LogCat.Default, bool logConsole = true, bool logFile = true)
{
try
{
_logPath = _logPath ?? Path.Combine(SettingsManager.DataDirectory, "logs");
_logSeverity = _logSeverity ?? SettingsManager.Settings?.Config.LogSeverity.ToSeverity() ?? LogSeverity.Module;
if ((int)_logSeverity > (int)severity)
{
return;
}
var file = Path.Combine(_logPath, (SettingsManager.Settings?.Config.UseSingleFileForLogging ?? false) ? "Default.log" : $"{cat}.log");
if (!Directory.Exists(_logPath))
{
Directory.CreateDirectory(_logPath);
}
// var cc = Console.ForegroundColor;
logFile = logFile && !(SettingsManager.Settings?.Config.DisableLogIntoFiles ?? false);
if (logConsole)
{
var time = DateTime.Now.ToString("HH:mm:ss");
var msg = $"{time} [{severity,8}] [{cat,13}]: {message}";
if (severity == LogSeverity.Critical || severity == LogSeverity.Error)
{
await SystemLogFeeder.FeedMessage($"```diff\n-{msg}\n```", severity);
}
else if (severity == LogSeverity.Warning)
{
await SystemLogFeeder.FeedMessage($"```diff\n+{msg}\n```", severity);
}
else
{
await SystemLogFeeder.FeedMessage(msg, severity);
}
if (!SettingsManager.Settings?.Config.RunAsServiceCompatibility ?? true)
{
try
{
switch (severity)
{
case LogSeverity.Critical:
case LogSeverity.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogSeverity.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LogSeverity.Info:
Console.ForegroundColor = ConsoleColor.White;
break;
case LogSeverity.Verbose:
case LogSeverity.Debug:
Console.ForegroundColor = ConsoleColor.DarkGray;
break;
case LogSeverity.Module:
Console.ForegroundColor = ConsoleColor.Gray;
break;
}
Console.WriteLine(msg);
}
catch
{
//ignore
}
}
}
if (logFile)
{
var format = (SettingsManager.Settings?.Config.UseSingleFileForLogging ?? false)
? $"{DateTime.Now,-19} [{severity,8}] [{cat,13}]: {message}{Environment.NewLine}"
: $"{DateTime.Now,-19} [{severity,8}]: {message}{Environment.NewLine}";
await WriteToResource(file, format);
}
}
catch
{
// ignored
}
}
public async Task <IList <LogEntity> > GetUserLogsAsync(string userId, DateTime?start, DateTime?end, LogSeverity?severity, LogType?type)
{
Expression <Func <Log <string>, bool> > filter = (log) => log.UserId == userId;
if (start.HasValue)
{
filter = filter.And(log => log.DateCreated >= start);
}
if (end.HasValue)
{
end = end.Value.AddMilliseconds(999 - end.Value.Millisecond);
filter = filter.And(log => log.DateCreated <= end);
}
if (severity.HasValue)
{
filter = filter.And(log => log.Severity == severity);
}
if (type.HasValue)
{
filter = filter.And(log => log.Type == type);
}
return(Mapper.Map <IList <LogEntity> >(await logRepository.GetOnAsync(filter)));
}
public static void WriteColoredLine(LogSeverity?severity, ConsoleTextFormat?format, params object[] args)
{
lock (_lockObj)
{
severity = severity ?? LogSeverity.Info;
format = format ?? ConsoleTextFormat.TimeAndText;
Console.ForegroundColor = SeverityToColor(severity.Value);
Console.Write($"[{Enum.GetName(typeof(LogSeverity), severity).ToUpper()}] ");
Console.Out.FlushAsync();
if (format == ConsoleTextFormat.TimeAndText)
{
Console.ForegroundColor = ConsoleColor.White;
Console.Write($"[{DateTime.Now.ToLocalTime().ToString()}] ");
Console.Out.FlushAsync();
}
Console.ForegroundColor = DefaultColor;
for (int i = 0; i < args.Length; i++)
{
object arg = args[i];
if (arg is ConsoleColor)
{
ConsoleColor?newColor = arg as ConsoleColor?;
if (newColor == null)
{
Console.ForegroundColor = ConsoleColor.Gray;
}
else
{
Console.ForegroundColor = newColor.Value;
}
Console.ForegroundColor = newColor.Value;
}
else if (arg is string)
{
string str = arg as string;
Regex colorRegex = new Regex(@"\$[[{[A-Za-z]+]]\$"); //Matches colors within $[[Black]]$
var matches = colorRegex.Matches(str);
if (matches.Count > 0)
{
string[] words = colorRegex.Split(str);
for (int y = 0; y < words.Length; y++)
{
string word = words[y];
Console.Write(words[y]);
Console.Out.FlushAsync();
if (y < matches.Count)
{
string color = matches[y].Value.Replace("$[[", "").Replace("]]$", "");
ConsoleColor parsedColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), matches[y].Value.Replace("$[[", "").Replace("]]$", ""), true);
Console.ForegroundColor = parsedColor;
}
}
}
else
{
Console.Write(str);
Console.Out.FlushAsync();
}
Console.ForegroundColor = DefaultColor;
}
}
Console.Write("\n");
Console.Out.FlushAsync();
}
}
public void Clear()
{
LastMessageSeverity = null;
LastMessage = null;
LastException = null;
}
public async Task <IActionResult> GetUserLogs(string userId, DateTime?from, DateTime?to, LogSeverity?severity, LogType?type)
{
try
{
if (!await userService.UserExistsAsync(userId))
{
ModelState.AddModelError(nameof(userId), $"User with Id {userId} Not Found");
return(BadRequest(ModelState));
}
var logs = Mapper.Map <List <LogDto> >(await logService.GetUserLogsAsync(userId, from, to, severity, type));
return(Ok(logs));
}
catch (Exception e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task<DataList<LogEntry>> GetLatestLogEntries(PageInfo pageInfo, LogCategory? category, LogSeverity? serverity)
{
return await _logData.GetLogEntries(pageInfo, category, serverity, DateTime.MinValue, DateTime.Now);
}
/// <summary>
/// Get all log entries for a certain module.
/// </summary>
/// <param name="lowerDate">Return messages logged after this date.</param>
/// <param name="upperDate">Return messages logged before this date.</param>
/// <param name="maxEntries">The maximum number of messages to return.</param>
/// <param name="module">The name of the module, or null.</param>
/// <param name="severity">The severity of the messages, or null.</param>
/// <returns>An array containing zero or more log message and 'maxEntriesReached' (set to true if more than 'maxEntries' messages where available).</returns>
public async Task <LogEntriesResult> GetLogEntries(DateTime lowerDate, DateTime upperDate, int maxEntries, string module, LogSeverity?severity)
{
var request = NewRequest(HttpMethod.Get, "Entries/{0}/{1}/{2}", lowerDate, upperDate, maxEntries);
if (module != null)
{
request.AddParameter("module", module);
}
if (severity.HasValue)
{
request.AddParameter("severity", severity.Value);
}
return(await ExecuteAsync <LogEntriesResult>(request).ConfigureAwait(false));
}
public void Clear()
{
LastMessageSeverity = null;
LastMessage = null;
LastException = null;
}