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