private void LogTo(SynchronizationContext syncContext, LoggingMessage logMessage, ObservableCollection <LoggingMessageWrapper> collection)
{
syncContext.Post(arg =>
{
collection.Insert(0, new LoggingMessageWrapper(logMessage));
while (collection.Count > 1000)
{
collection.RemoveAt(1000);
}
if (collection == this.DetailLogging)
{
if (logMessage.MessageType == LoggingMessageType.Error)
{
this.CountErrors++;
}
else
{
switch (logMessage.MetaData)
{
case "IN":
this.CountMessagesIn++;
break;
case "OUT":
this.CountMessagesOut++;
break;
}
}
}
}, null);
}
private static void OnAuthReceived(object sender, BasicDeliverEventArgs args)
{
var body = args.Body;
var token = Encoding.UTF8.GetString(body);
var rabbitMqProducer = RabbitMqProducer.Create(StaticQueues.LoggingQueue);
Console.WriteLine($"Gained token: {token}, Start writing messages.");
while (true)
{
var message = Console.ReadLine();
if (message == "q")
{
break;
}
var payload = new LoggingMessage {
Sender = APPLICATIONID, Group = GROUPID, Body = message
};
var json = JsonConvert.SerializeObject(payload);
var basicProperties =
new BasicProperties {
Headers = new Dictionary <string, object> {
{ "token", token }
}
};
rabbitMqProducer.SendMessage(json, basicProperties);
}
rabbitMqProducer.Disconnect();
}
public IHttpActionResult SubmitLog([FromBody] LoggingMessage logging)
{
switch (logging.LogType)
{
case 1:
Devicelog.Info(null, logging.PrepareLogMessage());
break;
case 2:
Devicelog.Warn(null, logging.PrepareLogMessage());
break;
case 3:
Devicelog.Debug(null, logging.PrepareLogMessage());
break;
case 4:
Devicelog.Error(logging.ExceptionObj, logging.PrepareLogMessage());
break;
default:
Devicelog.Info(null, logging.PrepareLogMessage());
break;
}
return(Ok(new { Status = Constants.WebApiStatusOk, data = "Success" }));
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaLogMessageEventArgs"/> class.
/// </summary>
/// <param name="message">The message.</param>
internal MediaLogMessageEventArgs(LoggingMessage message)
{
TimestampUtc = message.TimestampUtc;
MessageType = message.MessageType;
Message = message.Message;
AspectName = message.AspectName;
}
protected override async Task OnWriteMessageAsync(LoggingMessage message)
{
var msg = message.ToString();
el.WriteEntry(Name, msg, EventLogEntryType);
await Task.Yield();
}
protected override async Task OnWriteMessageAsync(LoggingMessage message)
{
var msg = message.ToString();
switch (Level)
{
case StandardLevels.Critical:
_l4nLogger.Fatal(msg);
break;
case StandardLevels.Important:
_l4nLogger.Error(msg);
break;
case StandardLevels.Warning:
_l4nLogger.Warn(msg);
break;
case StandardLevels.Infomation:
_l4nLogger.InfoFormat(msg);
break;
case StandardLevels.Debug:
_l4nLogger.Debug(msg);
break;
default:
break;
}
await Task.Yield();
}
/// <summary>
/// Send Error message
/// </summary>
/// <param name="severity"></param>
/// <param name="message">The message.</param>
/// <param name="fundid"></param>
public void Log(LogLevel severity, string message, string fundid = "")
{
//Send to user log
_userlog.Log(severity, message);
//Send as message
EventRunner.Enqueue(LoggingMessage.Create(fundid, message, severity.Name));
}
public ActionResult DeleteConfirmed(long id)
{
LoggingMessage loggingMessage = db.LoggingMessages.Find(id);
db.LoggingMessages.Remove(loggingMessage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task SendMessageAsync(string message)
{
if (await _messageChannel.SendAsync(new Message(message)))
{
var newLoggingMessage = new LoggingMessage(
DateTime.UtcNow, LoggingMessageType.Info, "OUT", message, null);
this.LogTo(_syncContext, newLoggingMessage, this.DetailLogging);
this.LogTo(_syncContext, newLoggingMessage, this.Messages);
}
}
// GET: Logging/Delete/5
public ActionResult Delete(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LoggingMessage loggingMessage = db.LoggingMessages.Find(id.Value);
db.LoggingMessages.Remove(loggingMessage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// GET: Logging/Details/5
public ActionResult Details(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LoggingMessage loggingMessage = db.LoggingMessages.Find(id);
if (loggingMessage == null)
{
return(HttpNotFound());
}
return(View(loggingMessage));
}
public void OnMessageReceived(Message message)
{
try
{
var newLoggingMessage = new LoggingMessage(
DateTime.UtcNow, LoggingMessageType.Info, "IN", message.ToString(), null);
this.LogTo(_syncContext, newLoggingMessage, this.DetailLogging);
this.LogTo(_syncContext, newLoggingMessage, this.Messages);
}
finally
{
message.ReturnToPool();
}
}
public LoggingMessage AddSettingsFileNotFoundMessage(Type target)
{
string msgString = "";
if (target == typeof(ReaderState))
{
msgString = "The state file wasn't found, a new one has been generated with default values.";
}
if (target == typeof(Settings))
{
msgString = "The settings file wasn't found, a new one has been generated with default values.";
}
var msg = new LoggingMessage(msgString, LoggingMessageType.Warning);
_messages.Add(msg);
return(msg);
}
public LoggingMessage AddSettingsSavingFailedMessage(Type target)
{
string msgString = "";
if (target == typeof(ReaderState))
{
msgString = "The state file couldn't be saved under the usual name.";
}
if (target == typeof(Settings))
{
msgString = "The settings file couldn't be saved under the usual name.";
}
var msg = new LoggingMessage(msgString, LoggingMessageType.Warning);
_messages.Add(msg);
return(msg);
}
public LoggingMessage AddSettingsLoadingSuccessfulMessage(Type target)
{
string msgString = "";
if (target == typeof(ReaderState))
{
msgString = "Saved state was loaded succesfully.";
}
if (target == typeof(Settings))
{
msgString = "Saved settings were loaded succesfully.";
}
var msg = new LoggingMessage(msgString);
_messages.Add(msg);
return(msg);
}
//**
// Be extra careful : the name fo the fucntion below have to match a certain format "AddSettings" + SettingsMessageType + "Message"
// in order to be called with a reflexive method in MainWindowViewModel
//**
public LoggingMessage AddSettingsLoadingFailedMessage(Type target)
{
string msgString = "";
if (target == typeof(ReaderState))
{
msgString = "The state file is corrupted and couldn't be loaded, loading default state instead.";
}
if (target == typeof(Settings))
{
msgString = "The settings file is corrupted and couldn't be loaded, loading default settings instead.";
}
var msg = new LoggingMessage(msgString, LoggingMessageType.Error);
_messages.Add(msg);
return(msg);
}
/// <inheritdoc /> void ILoggingHandler.HandleLogMessage(LoggingMessage message) => RaiseMessageLoggedEvent(message);
public LoggingMessageWrapper(LoggingMessage message)
{
_message = message;
}
internal void SendOnMessageLogged(LoggingMessage message) => Connector?.OnMessageLogged(this, message);
public void LogTrace(LoggingMessage loggingMessage)
{
this._repository.LogTrace(loggingMessage.Message, loggingMessage.ClientFunction);
}
/// <inheritdoc />
void ILoggingHandler.HandleLogMessage(LoggingMessage message)
{
}
internal void RaiseMessageLoggedEvent(LoggingMessage e) => MessageLogged?.Invoke(this, new MediaLogMessageEventArgs(e));
/// <inheritdoc /> void ILoggingHandler.HandleLogMessage(LoggingMessage message) => SendOnMessageLogged(message);
public void Log(LoggingMessage loggingMessage)
{
this.LogTo(_syncContext, loggingMessage, this.DetailLogging);
}
public static void RaiseFFmpegMessageLogged(LoggingMessage message) => FFmpegMessageLogged?.Invoke(null, message);
/// <inheritdoc /> void ILoggingHandler.HandleLogMessage(LoggingMessage message) => MediaEngine.RaiseFFmpegMessageLogged(message);
/// <inheritdoc /> public void OnMessageLogged(MediaEngine sender, LoggingMessage e) => Parent?.RaiseMessageLoggedEvent(e);
public void AddNewMessage(LoggingMessage message)
{
_messages.Add(message);
}
