public override void Format(ref TraceEntry traceEntry, FormatWriter formatWriter)
{
ColorCategory color = ColorCategory.None;
if (formatWriter.IsColorEnabled)
{
color = TraceLevelToColorCategory(traceEntry.TraceLevel);
}
int entryIndentLevel = formatWriter.IndentLevel + RelativeIndentLevel;
entryIndentLevel = Math.Min(entryIndentLevel, MaxIndentLevel);
formatWriter.BeginEntry(entryIndentLevel);
if (IncludeDate)
{
formatWriter.WriteDate(traceEntry.TimestampUtc, ColorCategory.Debug);
}
if (IncludeTimestamp)
{
formatWriter.WriteTimestamp(traceEntry.TimestampUtc, ColorCategory.Detail);
}
formatWriter.WriteField(TraceLevelToLabel(traceEntry.TraceLevel), color, 7);
formatWriter.WriteAbbreviatedTypeName(traceEntry.TracerName, ColorCategory.Debug, 36);
formatWriter.WriteField(traceEntry.Message.Trim(), color);
if (traceEntry.Details != null)
{
ColorCategory detailColor = color == ColorCategory.Debug ? ColorCategory.Debug : ColorCategory.Detail;
formatWriter.WriteLines(traceEntry.Details.ToString(), detailColor, 1);
}
formatWriter.EndEntry();
}
/// <summary>
/// Formats <paramref name="enumerable"/> as an array.
/// </summary>
/// <param name="enumerable"></param>
/// <param name="formatWriter"></param>
/// <param name="recursionLevel"></param>
/// <param name="lineage"></param>
/// <returns>The max <paramref name="recursionLevel"/> reached when <paramref name="enumerable"/> was formatted.</returns>
private int FormatAsEnumerable(IEnumerable enumerable, FormatWriter formatWriter, int recursionLevel, Stack <object> lineage)
{
int maxRecursionLevel = recursionLevel;
bool isEmpty = true;
bool enumerableContainsAllPrimitives = true;
// Determine if there are any non-primitive elements
foreach (object element in enumerable)
{
isEmpty = false;
if (!ShouldFormatAsPrimitive(element))
{
enumerableContainsAllPrimitives = false;
break;
}
}
if (isEmpty)
{
formatWriter.WriteField("[]", ColorCategory.Markup);
return(recursionLevel);
}
else
{
formatWriter.WriteField("[", ColorCategory.Markup);
formatWriter.IndentLevel += 1;
bool onFirstElement = true;
foreach (object element in enumerable)
{
if (!onFirstElement)
{
formatWriter.WriteText(",", ColorCategory.Markup);
}
if (!enumerableContainsAllPrimitives)
{
formatWriter.WriteEndLine();
}
onFirstElement = false;
// Format as a sub-object (indented, on a newline)
int propertyMaxRecursionLevel = InnerFormatObject(element, formatWriter, recursionLevel + 1, lineage, null);
maxRecursionLevel = Math.Max(maxRecursionLevel, propertyMaxRecursionLevel);
}
formatWriter.IndentLevel -= 1;
if (!enumerableContainsAllPrimitives)
{
formatWriter.WriteEndLine();
}
formatWriter.WriteField("]", ColorCategory.Markup);
}
return(maxRecursionLevel);
}
/// <inheritdoc />
public override void Format(ref LoggerEntry entry, FormatWriter formatWriter)
{
ColorCategory color = ColorCategory.None;
if (formatWriter.IsColorEnabled)
{
color = LogLevelToColorCategory(entry.LogLevel);
}
int entryIndentLevel = formatWriter.IndentLevel + RelativeIndentLevel;
entryIndentLevel = Math.Min(entryIndentLevel, MaxIndentLevel);
formatWriter.BeginEntry(entryIndentLevel);
if (IncludeDate)
{
formatWriter.WriteDate(entry.TimestampUtc, ColorCategory.Debug);
}
if (IncludeTimestamp)
{
formatWriter.WriteTimestamp(entry.TimestampUtc, ColorCategory.Detail);
}
formatWriter.WriteField(LogLevelToLabel(entry.LogLevel), color, 7);
formatWriter.WriteAbbreviatedTypeName(entry.CategoryName, ColorCategory.Debug, 36);
if (IncludeEventId)
{
formatWriter.WriteField(entry.EventId.ToString(), color, 6);
}
string message = entry.DefaultFormatter(entry.State, null);
formatWriter.WriteField(message.Trim(), color);
if (entry.Exception != null)
{
ColorCategory detailColor = color == ColorCategory.Debug ? ColorCategory.Debug : ColorCategory.Detail;
formatWriter.WriteLines(entry.Exception.ToString(), detailColor, 1);
}
formatWriter.EndEntry();
}
public override void Format(ref MessageEntry entry, FormatWriter formatWriter)
{
formatWriter.BeginEntry(0);
formatWriter.WriteTimestamp(entry.Timestamp);
var buf = formatWriter.FieldBuffer;
buf.Clear();
buf.Append('[');
if (entry.MessageId.HasValue)
{
buf.Append(entry.MessageId.Value);
}
else
{
buf.Append('?');
}
buf.Append(']');
formatWriter.WriteField(buf);
formatWriter.WriteField(entry.Text);
formatWriter.EndEntry();
}
/// <inheritdoc />
public override void Format(ref HttpRequestEntry entry, FormatWriter formatWriter)
{
StringBuilder buf = formatWriter.FieldBuffer;
formatWriter.BeginEntry(0);
// RequestNumber
buf.Clear();
buf.Append(entry.RequestNumber);
buf.Append('>');
formatWriter.WriteField(buf, ColorCategory.Markup, 3);
formatWriter.WriteTimestamp(entry.RequestStarted, ColorCategory.Detail);
formatWriter.WriteField(entry.Method, ColorCategory.Info, 3);
formatWriter.WriteField(entry.Uri, ColorCategory.Important);
FormatterHelper.FormatHeaders(formatWriter, entry.RequestHeaders);
formatWriter.WriteLine(); // Extra line break for readability
formatWriter.EndEntry();
formatWriter.IndentLevel++;
}
/// <inheritdoc />
public override void Format(ref LoggerBeginScopeEntry <object> entry, FormatWriter formatWriter)
{
formatWriter.BeginEntry();
if (IncludeDate)
{
formatWriter.WriteDate(entry.TimestampUtc, ColorCategory.Debug);
}
if (IncludeTimestamp)
{
formatWriter.WriteTimestamp(entry.TimestampUtc, ColorCategory.Detail);
}
formatWriter.WriteField("Begin", ColorCategory.Detail, 7);
formatWriter.WriteAbbreviatedTypeName(entry.CategoryName, ColorCategory.Debug, 36);
_reflectionFormatter.FormatObject(entry.State, formatWriter);
formatWriter.EndEntry();
}
/// <summary>
/// Reflects object <paramref name="o"/>, writes its type and properties to <paramref name="formatWriter"/>.
/// </summary>
/// <param name="o"></param>
/// <param name="formatWriter"></param>
public void FormatObject(object o, FormatWriter formatWriter)
{
if (o == null)
{
// Top level object is not usually expected to be null, which is why it's formatted as a warning
formatWriter.WriteField("(null)", ColorCategory.Warning);
}
else
{
// If o is a Primitive, don't format it as an object
if (ShouldFormatAsPrimitive(o))
{
FormatAsPrimitive(o, formatWriter);
}
else
{
InnerFormatObject(o, formatWriter, 0, new Stack <object>(10), null);
}
}
}
/// <summary>
/// Formats <paramref name="untypedDictionary"/> as dictionary with key type <typeparamref name="TKey"/> and value type <typeparamref name="TValue"/>.
/// </summary>
/// <param name="untypedDictionary"></param>
/// <param name="formatWriter"></param>
/// <param name="recursionLevel"></param>
/// <param name="lineage"></param>
/// <param name="parentPropertyType">The type of the property set to object <paramref name="untypedDictionary"/>. May be <c>null</c> if not applicable or unknown.</param>
/// <returns>The max <paramref name="recursionLevel"/> reached when <paramref name="untypedDictionary"/> was formatted.</returns>
// ReSharper disable once UnusedMember.Local
private int FormatAsDictionary <TKey, TValue>(object untypedDictionary, FormatWriter formatWriter, int recursionLevel, Stack <object> lineage, Type parentPropertyType)
{
// OK that this throws on failure; this shouldn't happen
var dictionary = (IEnumerable <KeyValuePair <TKey, TValue> >)untypedDictionary;
int maxRecursionLevel = recursionLevel;
if (!dictionary.Any())
{
formatWriter.WriteField("{}", ColorCategory.Markup);
return(recursionLevel);
}
else
{
formatWriter.WriteField("{", ColorCategory.Markup);
formatWriter.IndentLevel += 1;
bool onFirstKvp = true;
Type dictionaryType = dictionary.GetType();
if (IncludeTypeNames && (parentPropertyType != dictionaryType))
{
formatWriter.WriteField("type:", ColorCategory.Debug);
formatWriter.WriteText(_typeNameFunc(dictionaryType), ColorCategory.Debug);
onFirstKvp = false;
}
foreach (var kvp in dictionary)
{
if (!onFirstKvp)
{
formatWriter.WriteText(",", ColorCategory.Markup);
}
formatWriter.WriteEndLine();
onFirstKvp = false;
formatWriter.WriteField("{", ColorCategory.Markup);
formatWriter.IndentLevel += 1;
// If key is primitive, format on single line
TKey key = kvp.Key;
TValue value = kvp.Value;
int childMaxRecursionLevel;
if (ShouldFormatAsPrimitive(key))
{
formatWriter.WriteText(formatWriter.FieldDelimiter, ColorCategory.Markup);
FormatAsPrimitive(key, formatWriter);
formatWriter.WriteText(":", ColorCategory.Markup);
childMaxRecursionLevel = InnerFormatObject(value, formatWriter, recursionLevel + 1, lineage, typeof(TValue));
}
else
{
formatWriter.WriteField("Key", ColorCategory.Detail);
formatWriter.WriteText(":", ColorCategory.Markup);
childMaxRecursionLevel = InnerFormatObject(key, formatWriter, recursionLevel + 1, lineage, typeof(TKey));
maxRecursionLevel = Math.Max(maxRecursionLevel, childMaxRecursionLevel);
formatWriter.WriteText(",", ColorCategory.Markup);
formatWriter.WriteEndLine();
formatWriter.WriteField("Value", ColorCategory.Detail);
formatWriter.WriteText(":", ColorCategory.Markup);
childMaxRecursionLevel = InnerFormatObject(value, formatWriter, recursionLevel + 1, lineage, typeof(TValue));
}
maxRecursionLevel = Math.Max(maxRecursionLevel, childMaxRecursionLevel);
if (!ShouldFormatAsPrimitive(value))
{
formatWriter.WriteLine();
}
formatWriter.IndentLevel -= 1;
formatWriter.WriteField("}", ColorCategory.Markup);
}
formatWriter.WriteEndLine();
formatWriter.IndentLevel -= 1;
formatWriter.WriteField("}", ColorCategory.Markup);
}
return(maxRecursionLevel);
}
/// <summary>
/// Formats <paramref name="o"/> as an object.
/// </summary>
/// <param name="o"></param>
/// <param name="formatWriter"></param>
/// <param name="recursionLevel"></param>
/// <param name="lineage"></param>
/// <param name="parentPropertyType">The type of the property set to value <paramref name="o"/>. May be <c>null</c> if not applicable or unknown.</param>
/// <returns>The max <paramref name="recursionLevel"/> reached when <paramref name="o"/> was formatted.</returns>
private int FormatAsObject(object o, FormatWriter formatWriter, int recursionLevel, Stack <object> lineage, Type parentPropertyType)
{
int maxRecursionLevel = recursionLevel;
formatWriter.WriteField("{", ColorCategory.Markup);
if (recursionLevel > 0)
{
formatWriter.WriteEndLine();
}
formatWriter.IndentLevel += 1;
Type objectType = o.GetType();
if (IncludeTypeNames && (parentPropertyType != objectType))
{
formatWriter.WriteField("type:", ColorCategory.Debug);
formatWriter.WriteText(_typeNameFunc(objectType), ColorCategory.Debug);
formatWriter.WriteLine();
}
// Write properties
foreach (var property in objectType.GetReadablePublicProperties())
{
bool colonWritten = false;
void WriteErrorAsPropertyValue(string errorMessage)
{
if (!colonWritten)
{
formatWriter.WriteText(":", ColorCategory.Markup);
}
formatWriter.WriteText("!(", ColorCategory.Markup);
formatWriter.WriteText(errorMessage, ColorCategory.Warning);
formatWriter.WriteText(")!", ColorCategory.Markup);
}
try
{
formatWriter.WriteField(property.Name, ColorCategory.Detail);
Type propertyType = property.PropertyType;
ParameterInfo[] propertyIndexParameters = property.GetIndexParameters();
if (propertyIndexParameters.Length > 0)
{
// Properties with index parameters are not formatted - they act like functions, it's not possible to enumerate all contained values.
WriteErrorAsPropertyValue("Properties with index parameters are not formatted");
continue;
}
// GetValue(object) throws if the property has index parameters
object propertyValue = property.GetValue(o);
if (IncludeTypeNames)
{
// Only write the propertyType if it doesn't equal the subobject type
bool writePropertyType = !object.ReferenceEquals(propertyValue?.GetType(), propertyType);
if (writePropertyType)
{
formatWriter.WriteText("(", ColorCategory.Markup);
formatWriter.WriteText(_typeNameFunc(propertyType), ColorCategory.Debug);
formatWriter.WriteText(")", ColorCategory.Markup);
}
}
formatWriter.WriteText(":", ColorCategory.Markup);
colonWritten = true;
int propertyMaxRecursionLevel = InnerFormatObject(propertyValue, formatWriter, recursionLevel + 1, lineage, propertyType);
maxRecursionLevel = Math.Max(maxRecursionLevel, propertyMaxRecursionLevel);
}
catch (Exception excp)
{ // Exception reading or formatting the property value.
WriteErrorAsPropertyValue(excp.ToString());
}
}
// No newline for simple objects with no sub-objects
if (maxRecursionLevel > 1)
{
formatWriter.WriteEndLine();
}
formatWriter.IndentLevel -= 1;
formatWriter.WriteField("}", ColorCategory.Markup);
return(maxRecursionLevel);
}
/// <inheritdoc />
public override void Format(ref HttpResponseEntry entry, FormatWriter formatWriter)
{
StringBuilder buf = formatWriter.FieldBuffer;
formatWriter.IndentLevel--;
formatWriter.BeginEntry(0);
// RequestNumber
buf.Clear();
buf.Append(entry.RequestNumber);
buf.Append('<');
formatWriter.WriteField(buf, ColorCategory.Markup, 3);
formatWriter.WriteTimestamp(entry.RequestCompleted, ColorCategory.Detail);
// Ttfb
buf.Clear();
buf.AppendPadZeroes(entry.Ttfb.Seconds, 2);
buf.Append('.');
buf.AppendPadZeroes(entry.Ttfb.Milliseconds, 3);
buf.Append('s');
formatWriter.WriteField(buf, ColorCategory.Info);
// Determine response color from HTTP status code
ColorCategory responseColorCategory = ColorCategory.None;
if (formatWriter.IsColorEnabled)
{
var statusCode = entry.HttpStatusCode;
if ((statusCode >= 200) && (statusCode < 300))
{
responseColorCategory = ColorCategory.Success;
}
else if ((statusCode >= 300) && (statusCode < 400))
{
responseColorCategory = ColorCategory.Important;
}
else if (statusCode >= 500)
{
responseColorCategory = ColorCategory.Error;
}
else
{
responseColorCategory = ColorCategory.Warning;
}
}
formatWriter.WriteField(entry.Method, ColorCategory.Info, 3);
formatWriter.WriteField(entry.Uri, responseColorCategory);
formatWriter.WriteLine();
// HTTP status line
formatWriter.WriteLinePrefix(formatWriter.IndentLevel + 1);
formatWriter.WriteText(" HTTP/1.1 ", ColorCategory.Detail);
buf.Clear();
buf.Append(entry.HttpStatusCode);
formatWriter.WriteText(buf, 0, buf.Length, responseColorCategory);
formatWriter.WriteSpaces(1);
formatWriter.WriteText(entry.HttpReasonPhrase, ColorCategory.Detail);
formatWriter.WriteLine();
FormatterHelper.FormatHeaders(formatWriter, entry.ResponseHeaders);
formatWriter.WriteLine(); // Extra line break for readability
formatWriter.EndEntry();
}
