/// <summary>
/// Logs to file.
/// </summary>
/// <param name="logElement">The log element.</param>
private static async void LogToFile(LogElement logElement)
{
var json = JsonConvert.SerializeObject(logElement);
var path = Path.Combine(ApplicationData.Current.LocalFolder.Path, "ErrorLog.json");
try
{
if (!File.Exists(path))
{
using (var sw = File.CreateText(path))
{
await sw.WriteLineAsync(Package.Current.DisplayName + " - Error log:");
}
}
using (var sw = File.AppendText(path))
{
await sw.WriteLineAsync(json);
}
}
catch (UnauthorizedAccessException ex)
{
await ex.Display("Unable to access error log file.");
}
catch (Exception)
{
// ignored
}
}
public LogElement ToLogElement()
{
var statemsg = string.Empty;
IEnumerable <LogElement.ItemElement> elms;
if (State is SolaceLogState sls)
{
statemsg = sls.Message;
elms = sls.Values.Select(x =>
new LogElement.ItemElement()
{
Position = x.Position,
Value = x.Value?.ToString() ?? string.Empty
});
}
else
{
elms = new List <LogElement.ItemElement>();
statemsg = State?.ToString() ?? string.Empty;
}
var le = new LogElement()
{
TimeStamp = this.TimeStamp,
Level = this.Level,
EventId = this.Id.Id,
SenderService = this.Name,
Message = statemsg,
Elements = elms,
Exception = new LogElement.ExceptionElement(this.Exception),
};
return(le);
}
/// <summary>
/// Logs to database.
/// </summary>
/// <param name="ex">The ex.</param>
/// <returns></returns>
public static async Task LogToDb(Exception ex)
{
var logElement = new LogElement
{
Message = ex.Message,
ElementType = ex.GetType().Name,
Source = ex.Source
};
try
{
if (!await LogElements.Instance.AddLogElement(logElement))
{
LogToFile(logElement);
}
}
catch (Exception e)
{
LogToFile(new LogElement
{
Message = e.Message,
ElementType = e.GetType().Name,
Source = e.Source
});
LogToFile(logElement);
}
}
/// <summary>
/// Iterates over the <c>Logfile</c> and returns each line that is a log event in respect to the specified definitions in <cref name="EventDefinition"/>.
/// </summary>
/// <returns>An iterator for log events.</returns>
public IEnumerable <LogEvent> GetEventIterator()
{
if (this.streamreader == null)
{
this.InitializeFileSteam();
}
using (this.streamreader)
{
string line;
while ((line = this.streamreader.ReadLine()) != null)
{
this.currentLine++;
var element = new LogElement(line, this.currentLine);
List <LogEvent> events;
if (this.EventDefinition.GetEvent(element, out events))
{
foreach (var logEvent in events)
{
yield return(logEvent);
}
}
}
}
this.CloseFileStream();
}
/// <inheritdoc />
public IEnumerator <LogElement> GetEnumerator()
{
while (_stream != null && !_stream.EndOfStream)
{
string line;
while ((line = _stream.ReadLine()) != null)
{
if (string.IsNullOrEmpty(line))
{
continue;
}
_currentOffset = 0;
_currentElement = new LogElement();
if (ReadElement(line))
{
// we can publish prior record now as we have finished
// reading exception strings (if any)
if (_priorElement != null)
{
Offset += _currentOffset;
yield return(_priorElement);
}
_priorElement = _currentElement;
}
}
// publish last record
if (_currentElement?.IsValid(_dateFormat) ?? false)
{
yield return(_currentElement);
}
}
}
private void log(string logString)
{
LogElement element = new LogElement();
element.setDescription(logString);
logs.Add(element);
logUpdated?.Invoke(this, element);
}
/// <summary>
/// Adds the log element.
/// </summary>
/// <param name="logElement">The log element.</param>
/// <returns></returns>
public async Task <bool> AddLogElement(LogElement logElement)
{
var postBody = JsonConvert.SerializeObject(logElement);
var response = await _client
.PostAsync("logelements", new StringContent(postBody, Encoding.UTF8, "application/json"))
.ConfigureAwait(false);
return(response.IsSuccessStatusCode);
}
public ClientRuntimeConfiguration()
{
User = new UserElement();
Client = new ClientServiceTypeConfiguration();
LogInfo = new LogElement
{
ProviderType = typeof(Logger).AssemblyQualifiedName
};
}
private void ConfigurationShouldHaveLogElement(LogElement logElement)
{
ArrayList list = new ArrayList();
list.Add(logElement);
LoggerConfigurationMock
.Setup(loggerConfiguration => loggerConfiguration.GetLogElementsForLevel(logElement.Level))
.Returns(list);
}
public async Task <IHttpActionResult> PostLogElement(LogElement logElement)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_db.LogElements.Add(logElement);
await _db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = logElement.LogElementId }, logElement));
}
static void WriteLogThread()
{
while (true)
{
LogElement e = logElementQueue.Take();
lock (listeners)
foreach (var l in listeners)
{
l.Write(e);
}
}
}
void Start()
{
var logStart = new LogElement
{
dataTime = DateTime.Now,
name = "Start logging",
objName = "Logging"
};
logs.Add(logStart);
//show = true;
}
/// <summary>
/// Parses a single <see cref="LogElement"/> object and returns all <see cref="LogEvent"/>s that match the parsed object.
/// </summary>
/// <param name="element">A single <c>LogElement</c> object representing an element of the logfile.</param>
/// <param name="events">A <c>List</c> of <c>LogEvents</c> that is used to return the matching <c>LogEvents</c> for this parsers event definition.</param>
/// <returns></returns>
public bool GetEvent(LogElement element, out List<LogEvent> events)
{
events = new List<LogEvent>();
var match = false;
foreach (var def in this.definitionProvider.Definitions)
{
foreach (var regex in def.DetectionPatterns)
{
List<string> matches;
if (StringHelper.TryGetMatch(element.LogMessage, regex, out matches))
{
events.Add(this.CreateEvent(def, this.definitionProvider.Timestamp, element));
match = true;
break;
}
}
}
return match;
}
/// <summary>
/// Parses a single <see cref="LogElement"/> object and returns all <see cref="LogEvent"/>s that match the parsed object.
/// </summary>
/// <param name="element">A single <c>LogElement</c> object representing an element of the logfile.</param>
/// <param name="events">A <c>List</c> of <c>LogEvents</c> that is used to return the matching <c>LogEvents</c> for this parsers event definition.</param>
/// <returns></returns>
public bool GetEvent(LogElement element, out List <LogEvent> events)
{
events = new List <LogEvent>();
var match = false;
foreach (var def in this.definitionProvider.Definitions)
{
foreach (var regex in def.DetectionPatterns)
{
List <string> matches;
if (StringHelper.TryGetMatch(element.LogMessage, regex, out matches))
{
events.Add(this.CreateEvent(def, this.definitionProvider.Timestamp, element));
match = true;
break;
}
}
}
return(match);
}
public void Log <TState>(
LogLevel logLevel,
EventId eventId,
TState state,
Exception exception,
Func <TState, Exception, string> formatter)
{
if (!IsEnabled(logLevel))
{
return;
}
var log = new LogElement(DateTime.Now, logLevel, "", "_name", state.ToString() ?? "", formatter(state, exception));
//var requestLoggerScope = serviceProvider.GetRequiredService<RequestLoggerScope>();
//requestLoggerScope.AddLog(log);
ColorConsoleLoggerConfiguration config = _getCurrentConfig();
if (config.EventId == 0 || config.EventId == eventId.Id)
{
ConsoleColor originalColor = Console.ForegroundColor;
Console.ForegroundColor = config.LogLevels[logLevel];
Console.WriteLine($"[{eventId.Id,2}: {logLevel,-12}]");
//if(scopes.Value.Count > 0)
//{
// HierarchicalLoggerScope scope;
// if (scopes.Value.TryPop(out scope))
// {
// Console.WriteLine($"{scope}");
// }
//}
Console.ForegroundColor = originalColor;
Console.WriteLine($" {_name} - {formatter(state, exception)}");
}
}
internal static BaseLogger CreateInstance(LogElement logElement)
{
if (_instance == null)
{
Type providerType = Type.GetType(logElement.ProviderType);
if (providerType == null)
{
throw new InvalidConfigurationException("Could not locate Log Provider :" + logElement.ProviderType);
}
if (!providerType.ImplementsClass <BaseLogger>())
{
throw new InvalidConfigurationException("Log Provider does not implement ILogger:" +
logElement.ProviderType);
}
var args = new CommandArgs(logElement.Parameters);
_instance = (BaseLogger)Activator.CreateInstance(providerType, args);
}
return(_instance);
}
/// <summary>
/// Logs the specified error to database.
/// </summary>
/// <param name="ex">The exception.</param>
/// <param name="db">The database.</param>
/// <returns></returns>
public static async Task <Exception> Log(this Exception ex, StudentTaskContext db)
{
var logElement = new LogElement
{
Message = ex.Message,
ElementType = ex.GetType().Name,
Source = ex.StackTrace
};
db.LogElements.Add(logElement);
try
{
await db.SaveChangesAsync();
}
catch (Exception)
{
// ignored
}
return(ex);
}
private static void InitializeTracing(ManagedJob job, LogElement logElement)
{
if (logElement == null)
{
logElement = new LogElement();
logElement.FileName = job.Name + ".log";
logElement.LogLevel = InstanceConfig.CurrentInstance.Log.LogLevel;
logElement.MaxLogSize = InstanceConfig.CurrentInstance.Log.MaxLogSize;
}
// Check if path includes a directory part of some sort
if (!logElement.FileName.Contains(Path.DirectorySeparatorChar.ToString()))
{
// Append server directory
logElement.FileName = Path.Combine(Path.GetDirectoryName(InstanceConfig.CurrentInstance.Log.FileName), logElement.FileName);
}
job.Tracing.Switch.Level = ConfigurationHelper.ConvertLogLevel(logElement.LogLevel);
RollingFileTraceListener listener = new RollingFileTraceListener(logElement.FileName, logElement.MaxLogSize);
//listener.TraceOutputOptions = TraceOptions.DateTime |TraceOptions.ThreadId; // todo fixme
job.Tracing.Listeners.Add(listener);
}
private UnitTestContext(IArguments arguments)
{
if (arguments == null)
{
throw new InvalidOperationException(
"Current Context could not be initialized. No arguments passed to the context");
}
var element = new LogElement
{
Parameters = "-ShowOnConsole:true ",
ProviderType = "KonfDB.Infrastructure.Logging.Logger, KonfDBC"
};
if (arguments.ContainsKey("runtime-logConfigPath"))
{
element.Parameters += "-path:" + arguments["runtime-logConfigPath"];
}
var logger = LogFactory.CreateInstance(element);
CurrentContext.CreateDefault(logger, arguments, null);
}
static internal void WriteLogEntry(LogType type, string msg, string path, string tag)
{
// normalize newlines to windows format
if (msg != null)
{
msg = msg.Replace("\r\n", "\n").Replace("\n", "\r\n");
}
var logElement = new LogElement()
{
Time = DateTime.Now, Type = type, Message = msg, Path = path, Tag = tag
};
logElementQueue.Add(logElement);
lock (history)
{
history.Add(logElement);
while (history.Count > 50)
{
history.RemoveAt(0);
}
}
}
/// <summary>
/// Iterates over the <c>Logfile</c> and returns each line that is a log event in respect to the specified definitions in <cref name="EventDefinition"/>.
/// </summary>
/// <returns>An iterator for log events.</returns>
public IEnumerable<LogEvent> GetEventIterator()
{
if (this.streamreader == null)
this.InitializeFileSteam();
using (this.streamreader)
{
string line;
while ((line = this.streamreader.ReadLine()) != null)
{
this.currentLine++;
var element = new LogElement(line, this.currentLine);
List<LogEvent> events;
if (this.EventDefinition.GetEvent(element, out events))
{
foreach (var logEvent in events){
yield return logEvent;
}
}
}
}
this.CloseFileStream();
}
public void addLog(LogElement element)
{
LogListBox.Items.Add(element.description);
}
private bool verbosityFilter(object obj)
{
LogElement elem = (LogElement)obj;
return(elem.Verbosity <= verbLevel);
}
private LogEvent CreateEvent(DefinitionElement definition, Timestamp timestamp, LogElement element)
{
var logEvent = new LogEvent(definition.Category, element);
foreach (string key in definition.GetMetadataKeys())
{
string regex;
if (definition.Metadata.TryGetValue(key, out regex))
{
List <string> matches;
if (StringHelper.TryGetMatch(element.LogMessage, regex, out matches))
{
logEvent.AddMetadata(key, matches);
}
}
if (!String.IsNullOrEmpty(timestamp.Pattern) && !String.IsNullOrEmpty(timestamp.Format))
{
List <string> rawTimestamp;
if (StringHelper.TryGetMatch(element.LogMessage, timestamp.Pattern, out rawTimestamp))
{
var timestampObject = DateTime.ParseExact(rawTimestamp.ElementAt(0), timestamp.Format, CultureInfo.InvariantCulture);
logEvent.Timestamp = timestampObject;
}
}
}
return(logEvent);
}
private LogEvent CreateEvent(DefinitionElement definition, Timestamp timestamp, LogElement element)
{
var logEvent = new LogEvent(definition.Category, element);
foreach (string key in definition.GetMetadataKeys())
{
string regex;
if (definition.Metadata.TryGetValue(key, out regex))
{
List<string> matches;
if (StringHelper.TryGetMatch(element.LogMessage, regex, out matches)){
logEvent.AddMetadata(key, matches);
}
}
if (!String.IsNullOrEmpty(timestamp.Pattern) && !String.IsNullOrEmpty(timestamp.Format))
{
List<string> rawTimestamp;
if (StringHelper.TryGetMatch(element.LogMessage, timestamp.Pattern, out rawTimestamp))
{
var timestampObject = DateTime.ParseExact(rawTimestamp.ElementAt(0), timestamp.Format, CultureInfo.InvariantCulture);
logEvent.Timestamp = timestampObject;
}
}
}
return logEvent;
}
private void addLogEntry(object sender, LogElement logElement)
{
_view.addLog(logElement);
}
