public string ConvertEntriesToJsonArray(List <Entry> entries) { if (entries == null || entries.Count == 0) { return(null); } JsonArray arr = new JsonArray(); foreach (var entry in entries) { JsonObject obj = new JsonObject(); obj["Created"] = JsonValue.CreateNumberValue(entry.Created.Ticks); obj["Id"] = JsonValue.CreateNumberValue(entry.Id); obj["Level"] = JsonValue.CreateNumberValue((int)entry.Level); if (entry.Category != null) { obj["Category"] = JsonValue.CreateStringValue(entry.Category); } if (entry.Message != null) { obj["Message"] = JsonValue.CreateStringValue(EntryFormatter.FormatMessage(entry)); } arr.Add(obj); } return(arr.Stringify()); }
/// <summary> /// Adds <paramref name="entryFormatter" /> or the default formatter for <typeparamref name="TEntry" /> to each of /// the <see cref="ILogWriterConfig" /> objects in <paramref name="logWriterConfigs" /> that are of type /// <see cref="TextLogWriterConfig" />. /// <para> /// This is a convenience function to make it easy to apply the same formatting for the same entry types to multiple /// logwriters. /// </para> /// </summary> /// <typeparam name="TEntry"></typeparam> /// <param name="logWriterConfigs">A collection of <see cref="ILogWriterConfig" /> objects.</param> /// <param name="entryFormatter"> /// The <see cref="EntryFormatter{TEntry}" /> to use for all entries of type <typeparamref name="TEntry" />; /// or <c>null</c> to use the default entryformatter for <typeparamref name="TEntry" />. /// </param> /// <param name="overwriteExistingFormatters"> /// If <c>true</c>, existing formatters for <typeparamref name="TEntry" /> are /// overwritten with default formatters. /// </param> /// <returns>The <paramref name="logWriterConfigs" /> parameter, for fluent call chaining.</returns> public static IEnumerable <ILogWriterConfig> FormatAll <TEntry>(this IEnumerable <ILogWriterConfig> logWriterConfigs, EntryFormatter <TEntry> entryFormatter = null, bool overwriteExistingFormatters = false) where TEntry : ILogEntry { Contract.Requires <ArgumentNullException>(logWriterConfigs != null); if (entryFormatter == null) { // Try creating the default entry formatter entryFormatter = DefaultFormatterAttribute.GetDefaultFormatterFor <TEntry>(); if (entryFormatter == null) { throw new ArgumentNullException(nameof(entryFormatter), $"No [DefaultFormatter] attribute could be found for entry type {typeof(TEntry).FullName}, so {nameof(entryFormatter)} argument must be set."); } } foreach (var logWriterConfig in logWriterConfigs) { var textLogWriterConfig = logWriterConfig as TextLogWriterConfig; if (textLogWriterConfig != null) { if (overwriteExistingFormatters || !textLogWriterConfig.HasFormatterFor <TEntry>()) { textLogWriterConfig.Format(entryFormatter); } } } return(logWriterConfigs); }
public void SkipNullsInEntries() { var formatter = new EntryFormatter(new DataFormatter()); string serialized = formatter.FormatEntryText("title with no description", null, Enums.LogLevel.Info, Enums.DataType.Text, DateTime.Now); Assert.DoesNotContain("\"data\"", serialized); Assert.DoesNotContain("null", serialized); }
/// <summary> /// Enables sending trace messages to all configured log writers. /// </summary> /// <param name="traceManager"></param> /// <param name="switches"></param> /// <param name="traceFormatter"></param> /// <returns></returns> public static void TraceToAllLogWriters(this TraceManagerConfig config, SwitchSet switches = null, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(config != null); TraceTo(config, config.LogManagerConfig.Writers, switches, traceFormatter); }
public static TraceWriterConfig TraceToDebugger(this TraceManagerConfig traceManagerConfig, string tracerName = Tracer.All, ITraceSwitch traceSwitch = null, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(tracerName != null); return(TraceToDebugger(traceManagerConfig, CreateSwitchSet(tracerName, traceSwitch), traceFormatter)); }
public static TraceWriterConfig TraceToTestOutput(this TraceManagerConfig traceManagerConfig, ITestOutputHelper testOutput, SwitchSet switchSet, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(testOutput != null); Contract.Requires <ArgumentNullException>(switchSet != null); return(TraceManagerConfigFluentExtensions.TraceTo(traceManagerConfig, new TestOutputLogWriterConfig(testOutput), switchSet, traceFormatter)); }
public static TraceWriterConfig TraceTo(this TraceManagerConfig traceManagerConfig, Func <TextWriter> createTextWriterFunc, SwitchSet switchSet, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(createTextWriterFunc != null); Contract.Requires <ArgumentNullException>(switchSet != null); return(TraceTo(traceManagerConfig, new TextWriterLogWriterConfig(createTextWriterFunc), switchSet, traceFormatter)); }
public static TraceWriterConfig TraceToTestOutput(this TraceManagerConfig traceManagerConfig, ITestOutputHelper testOutput, string tracerName = Tracer.All, ITraceSwitch traceSwitch = null, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(testOutput != null); Contract.Requires <ArgumentNullException>(tracerName != null); return(TraceManagerConfigFluentExtensions.TraceTo(traceManagerConfig, new TestOutputLogWriterConfig(testOutput), tracerName, traceSwitch, traceFormatter)); }
/// <summary> /// Trace to the text logwriter configured by <paramref name="textLogWriterConfig" />. /// </summary> /// <param name="traceManagerConfig"></param> /// <param name="textLogWriterConfig"></param> /// <param name="switchSet"></param> /// <param name="traceFormatter"></param> /// <returns></returns> public static TraceWriterConfig TraceTo(this TraceManagerConfig traceManagerConfig, TextLogWriterConfig textLogWriterConfig, SwitchSet switchSet, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(textLogWriterConfig != null); Contract.Requires <ArgumentNullException>(switchSet != null); textLogWriterConfig.Format(traceFormatter); var traceWriterConfig = new TraceWriterConfig(textLogWriterConfig, switchSet); traceManagerConfig.Writers.Add(traceWriterConfig); return(traceWriterConfig); }
public void TestDeserializeFromMemmoryStream() { var entryFormatter = new EntryFormatter(new DataFormatter()); List <object> logs; using (var stream = new MemoryStream()) { using (var streamWriter = new StreamWriter(stream, Encoding.UTF8, leaveOpen: true)) streamWriter.Write(entryFormatter.FormatEntryText("log title", "log description", LogLevel.Warning, DataType.Text, DateTime.Now)); stream.Seek(0, SeekOrigin.Begin); logs = JLogParser.Parse(stream, Encoding.UTF8).ToList(); } Assert.Single(logs); }
/// <summary> /// Enables sending trace messages to all specified <paramref name="logWriterConfigs" />. This method can be called /// multiple times /// to specify different switch settings for different logWriters. /// </summary> /// <param name="traceManagerConfig"></param> /// <param name="logWriterConfigs"></param> /// <param name="switches"></param> /// <param name="traceFormatter"></param> /// <returns></returns> public static void TraceTo(this TraceManagerConfig traceManagerConfig, IEnumerable <ILogWriterConfig> logWriterConfigs, SwitchSet switches = null, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(logWriterConfigs != null); if (switches == null) { switches = TraceManagerConfig.CreateDefaultSwitchSet(); } logWriterConfigs.FormatAll(traceFormatter); foreach (var logWriterConfig in logWriterConfigs) { traceManagerConfig.Writers.Add(new TraceWriterConfig(logWriterConfig, switches)); } }
public override async Task WriteEntriesAsync(List <Entry> entries) { // make five tries, if background workers are accessing the file also - so access could denied sometimes for (int i = 0; i < 5; i++) { try { // for the first call - create the storage file if (_storageFile == null) { _storageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync( FileName, CreationCollisionOption.OpenIfExists); } List <string> lines = new List <string>(); foreach (var entry in entries) { var message = EntryFormatter.FormatMessage(entry); var line = string.Format(_format, entry.Created, entry.Level, entry.Category, message); lines.Add(line); } // check the size of the log file await CheckLogFileSize(); // write the buffered log entries to the file await FileIO.AppendLinesAsync(_storageFile, lines); // everything is ok to return here... return; } catch (Exception ex) { InternalTrace(Entry.CreateError("DelayedWorker exception: " + ex.Message + DateTime.Now.ToString())); } // Writing to the log file was not successful. Wait for a short period and do a retry await Task.Delay(300); } }
/// <summary> /// Sets formatting for entry types <typeparamref name="TEntry" /> using <paramref name="entryFormatter" />. /// </summary> /// <typeparam name="TEntry">The log entry type for the specified <paramref name="entryFormatter" />.</typeparam> /// <param name="entryFormatter"> /// The <see cref="EntryFormatter{TEntry}" /> to use to format <typeparamref name="TEntry" /> objects. /// If <c>null</c>, the <see cref="DefaultFormatterAttribute" /> on <typeparamref name="TEntry" /> is used to resolve a /// default formatter. /// </param> /// <returns><c>this</c>, to support chaining configuration calls in a fluent manner.</returns> /// <remarks> /// If <see cref="Format{TEntry}(LogJam.Writer.Text.EntryFormatter{TEntry})" /> is called more than once for the same /// <typeparamref name="TEntry" /> value, the last formatter is the only one used. In other words, repeating the call /// replaces /// earlier formatters. /// </remarks> public TextLogWriterConfig Format <TEntry>(EntryFormatter <TEntry> entryFormatter = null) where TEntry : ILogEntry { if (entryFormatter == null) { // Try creating the default entry formatter entryFormatter = DefaultFormatterAttribute.GetDefaultFormatterFor <TEntry>(); if (entryFormatter == null) { throw new ArgumentNullException(nameof(entryFormatter), $"No [DefaultFormatter] attribute could be found for entry type {typeof(TEntry).FullName}, so {nameof(entryFormatter)} argument must be set."); } } Type entryType = typeof(TEntry); Action <TextLogWriter> configureAction = (mw) => mw.AddFormat(entryFormatter); // Remove any existing formatters for the same TEntry. _formatters.RemoveAll(tuple => tuple.Item1 == entryType); _formatters.Add(new Tuple <Type, object, Action <TextLogWriter> >(entryType, entryFormatter, configureAction)); return(this); }
internal JLogger(ISink sink, EntryFormatter entryFormatter) { this.sink = sink; this.entryFormatter = entryFormatter; }
public override Task WriteEntriesAsync(List <Entry> entries) { var task = Task.Factory.StartNew(async() => { try { var db = await LogDbContext.CreateAsync(); List <DbEntry> dbEntries = new List <DbEntry>(); foreach (var entry in entries) { var dbEntry = new DbEntry() { Id = entry.Id, Created = entry.Created, Category = entry.Category, Level = entry.Level, Message = EntryFormatter.FormatMessage(entry) }; //db.InsertAsync(dbEntry); dbEntries.Add(dbEntry); } await db.InsertAllAsync(dbEntries); //db.SubmitChanges(); var entryCount = await db.Table <DbEntry>().CountAsync(); if (entryCount > this.MaxEntryCount) { var deleteCount = entryCount - this.MaxEntryCount; var deleteThem = await db.Table <DbEntry>().OrderBy(e => e.DbEntryId).Take(deleteCount).ToListAsync(); foreach (var deleteOne in deleteThem) { await db.DeleteAsync(deleteOne); } //try //{ // db.(System.Data.Linq.ConflictMode.ContinueOnConflict); //} //catch (Exception ccex) //{ // InternalTrace(Entry.CreateError(("WriteEntriesAsync conflict ignore: " + ccex.Message))); //// ignore conflicts //foreach (var conflict in db.ChangeConflicts) //{ // if (conflict.IsDeleted) // { // conflict.Resolve(RefreshMode.KeepCurrentValues); // } // else // { // conflict.Resolve(RefreshMode.OverwriteCurrentValues); // } //} //} } if (DumpEnabled && !NeverDump && _dumpTask == null) { _dumpTask = Task.Run(() => DumpAsync()); } } catch (Exception ex) { InternalTrace(Entry.CreateError("AddLine failed: " + ex.Message)); } }); return(task); }
public static TraceWriterConfig TraceToConsole(this TraceManagerConfig traceManagerConfig, SwitchSet switchSet, EntryFormatter <TraceEntry> traceFormatter = null, bool colorize = true) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(switchSet != null); ConsoleLogWriterConfig consoleLogWriterConfig = traceManagerConfig.LogManagerConfig.UseConsole(colorize); return(TraceTo(traceManagerConfig, consoleLogWriterConfig, switchSet, traceFormatter)); }
public static TraceWriterConfig TraceToDebugger(this TraceManagerConfig traceManagerConfig, SwitchSet switchSet, EntryFormatter <TraceEntry> traceFormatter = null) { Contract.Requires <ArgumentNullException>(traceManagerConfig != null); Contract.Requires <ArgumentNullException>(switchSet != null); DebuggerLogWriterConfig debuggerLogWriterConfig = traceManagerConfig.LogManagerConfig.UseDebugger(); return(TraceTo(traceManagerConfig, debuggerLogWriterConfig, switchSet, traceFormatter)); }
public override Task WriteEntriesAsync(List <Entry> entries) { var task = Task.Factory.StartNew(() => { try { using (var db = CreateLogDbContext()) { foreach (var entry in entries) { var dbEntry = new DbEntry() { Id = entry.Id, Created = entry.Created, Category = entry.Category, Level = entry.Level, Message = EntryFormatter.FormatMessage(entry) }; db.Entries.InsertOnSubmit(dbEntry); } db.SubmitChanges(); var entryCount = db.Entries.Count(); if (entryCount > this.MaxEntryCount) { var deleteCount = entryCount - this.MaxEntryCount; var deleteThem = db.Entries.OrderBy(e => e.DbEntryId).Take(deleteCount).ToList(); db.Entries.DeleteAllOnSubmit(deleteThem); try { db.SubmitChanges(System.Data.Linq.ConflictMode.ContinueOnConflict); } catch (ChangeConflictException ccex) { InternalTrace(Entry.CreateError(("WriteEntriesAsync conflict ignore: " + ccex.Message))); // ignore conflicts foreach (var conflict in db.ChangeConflicts) { if (conflict.IsDeleted) { conflict.Resolve(RefreshMode.KeepCurrentValues); } else { conflict.Resolve(RefreshMode.OverwriteCurrentValues); } } } } } if (DumpEnabled && !NeverDump && _dumpTask == null) { _dumpTask = Task.Run(() => DumpAsync()); } } catch (Exception ex) { InternalTrace(Entry.CreateError("AddLine failed: " + ex.Message)); } }); return(task); }
/// <summary> /// Formats and writes <paramref name="entries" /> to <paramref name="testOutputHelper" />. /// </summary> /// <param name="testOutputHelper"></param> /// <param name="entries"></param> /// <param name="entryFormatter"></param> /// <typeparam name="TEntry">The log entry type; must implement <see cref="ILogEntry" /></typeparam> public static void WriteEntries <TEntry>(this ITestOutputHelper testOutputHelper, IEnumerable <TEntry> entries, EntryFormatter <TEntry> entryFormatter = null) where TEntry : ILogEntry { Contract.Requires <ArgumentNullException>(entries != null); Contract.Requires <ArgumentNullException>(testOutputHelper != null); var setupLog = new SetupLog(); var formatWriter = new TestOutputFormatWriter(testOutputHelper, setupLog); var logWriter = new TextLogWriter(setupLog, formatWriter); logWriter.AddFormat(entryFormatter); IEntryWriter <TEntry> entryWriter; logWriter.TryGetEntryWriter(out entryWriter); using (logWriter) { logWriter.Start(); for (var enumerator = entries.GetEnumerator(); enumerator.MoveNext();) { TEntry logEntry = enumerator.Current; entryWriter.Write(ref logEntry); } } }
/// <summary> /// Formats and writes <paramref name="entries" /> to <paramref name="textWriter" />. /// </summary> /// <param name="entries"></param> /// <param name="textWriter"></param> /// <param name="entryFormatter"></param> /// <typeparam name="TEntry"></typeparam> public static void WriteEntriesTo <TEntry>(this IEnumerable <TEntry> entries, TextWriter textWriter, EntryFormatter <TEntry> entryFormatter = null) where TEntry : ILogEntry { Contract.Requires <ArgumentNullException>(entries != null); Contract.Requires <ArgumentNullException>(textWriter != null); if (entryFormatter == null) { // Try creating the default log formatter entryFormatter = DefaultFormatterAttribute.GetDefaultFormatterFor <TEntry>(); if (entryFormatter == null) { throw new ArgumentNullException(nameof(entryFormatter), $"No [DefaultFormatter] could be found for entry type {typeof(TEntry).FullName}, so logFormatter argument must be set."); } } var setupLog = new SetupLog(); var formatWriter = new TextWriterFormatWriter(setupLog, textWriter, disposeWriter: false); var logWriter = new TextLogWriter(setupLog, formatWriter); logWriter.AddFormat(entryFormatter); IEntryWriter <TEntry> entryWriter; logWriter.TryGetEntryWriter(out entryWriter); using (logWriter) { logWriter.Start(); for (var enumerator = entries.GetEnumerator(); enumerator.MoveNext();) { TEntry logEntry = enumerator.Current; entryWriter.Write(ref logEntry); } } }