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