/// <summary>
/// Renders the <see cref="T:log4net.Core.LoggingEvent" /> to a string.
/// </summary>
/// <param name="loggingEvent">The event to render.</param>
/// <param name="writer">The TextWriter to write the formatted event to</param>
/// <remarks>
/// <para>
/// Helper method to render a <see cref="T:log4net.Core.LoggingEvent" /> to
/// a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout" />
/// set to render the <paramref name="loggingEvent" /> to
/// a string.
/// </para>
/// <para>If there is exception data in the logging event and
/// the layout does not process the exception, this method
/// will append the exception text to the rendered string.
/// </para>
/// <para>
/// Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)" />
/// where possible. If, however, the caller needs to render the event
/// to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)" /> does
/// provide an efficient mechanism for doing so.
/// </para>
/// </remarks>
protected void RenderLoggingEvent(TextWriter writer, LoggingEvent loggingEvent)
{
if (m_layout == null)
{
throw new InvalidOperationException("A layout must be set");
}
if (m_layout.IgnoresException)
{
string exceptionString = loggingEvent.GetExceptionString();
if (exceptionString != null && exceptionString.Length > 0)
{
m_layout.Format(writer, loggingEvent);
// 布局中设置了exception才有必要输出
if (m_layout is PatternLayout layout && layout.ConversionPattern.Contains("%exception"))
{
writer.WriteLine(exceptionString);
}
}
else
{
m_layout.Format(writer, loggingEvent);
}
}
else
{
m_layout.Format(writer, loggingEvent);
}
}
/// <summary>
/// Format the logging event as an object.
/// </summary>
/// <param name="loggingEvent">The event to format</param>
/// <returns>returns the formatted event</returns>
/// <remarks>
/// <para>
/// Format the logging event as an object.
/// </para>
/// <para>
/// Uses the <see cref="ILayout"/> object supplied to
/// the constructor to perform the formatting.
/// </para>
/// </remarks>
public virtual object Format(LoggingEvent loggingEvent)
{
var writer = new StringWriter(CultureInfo.InvariantCulture);
m_layout.Format(writer, loggingEvent);
return(writer.ToString());
}
/// <summary>
/// Implement this method to create your own layout format.
/// </summary>
/// <param name="writer">The TextWriter to write the formatted event to</param>
/// <param name="loggingEvent">The event to format</param>
/// <remarks>
/// <para>
/// This method is called by an appender to format
/// the <paramref name="loggingEvent"/> as text.
/// </para>
/// </remarks>
virtual public void Format(TextWriter writer, LoggingEvent loggingEvent)
{
if (m_nestedLayout != null)
{
m_nestedLayout.Format(writer, loggingEvent);
}
}
/// <summary>
/// Format the logging event as an object.
/// </summary>
/// <param name="loggingEvent">The event to format</param>
/// <returns>returns the formatted event</returns>
/// <remarks>
/// <para>
/// Format the logging event as an object.
/// </para>
/// <para>
/// Uses the <see cref="ILayout"/> object supplied to
/// the constructor to perform the formatting.
/// </para>
/// </remarks>
virtual public object Format(LoggingEvent loggingEvent)
{
StringWriter writer = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);
m_layout.Format(writer, loggingEvent);
return(writer.ToString());
}
public static string FormatString(this ILayout layout, LoggingEvent loggingEvent)
{
using (var writer = new StringWriter())
{
layout.Format(writer, loggingEvent);
return(writer.ToString());
}
}
/// <summary>
/// Renders the <see cref="LoggingData"/> to a string.
/// </summary>
/// <param name="loggingEvent">The event to render.</param>
/// <param name="writer">The TextWriter to write the formatted event to</param>
/// <remarks>
/// <para>
/// Helper method to render a <see cref="LoggingData"/> to
/// a string. This appender must have a <see cref="Layout"/>
/// set to render the <paramref name="loggingEvent"/> to
/// a string.
/// </para>
/// <para>If there is exception data in the logging event and
/// the layout does not process the exception, this method
/// will append the exception text to the rendered string.
/// </para>
/// <para>
/// Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
/// where possible. If, however, the caller needs to render the event
/// to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
/// provide an efficient mechanism for doing so.
/// </para>
/// </remarks>
protected void RenderLoggingEvent(TextWriter writer, LoggingData loggingEvent)
{
if (m_layout == null)
{
throw new InvalidOperationException("A layout must be set");
}
// The layout will render the exception
m_layout.Format(writer, loggingEvent);
}
public string ToString(bool excludeLastExceptionStackTrace)
{
using (var writer = new StringWriter())
{
_layout.Format(writer, _event);
var line = writer.ToString();
var exception = _event.GetExceptionString();
var exclude = (IsLast && excludeLastExceptionStackTrace);
return(string.IsNullOrEmpty(exception) || exclude ? line : string.Format("{0}\n{1}", line, exception));
}
}
public static string MakeBodyXml(ILayout layout, IEnumerable <LoggingEvent> buffer)
{
TextWriter writer = new StringWriter();
writer.Write(layout.Header);
foreach (var loggingEvent in buffer)
{
layout.Format(writer, loggingEvent);
}
writer.Write(layout.Footer);
writer.Flush();
return(writer.ToString());
}
private JObject SendEvent(ILayout layout, LoggingEvent ev)
{
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
layout.Format(writer, ev);
}
JsonReader reader = new JsonTextReader(new StringReader(builder.ToString()));
reader.DateParseHandling = DateParseHandling.None;
return(JObject.Load(reader));
}
public static string GetFormattedString(this LoggingEvent loggingEvent, ILayout layout)
{
if (layout == null)
{
return($"{loggingEvent.RenderedMessage} {loggingEvent.GetExceptionString()}{Environment.NewLine}");
}
using var stringWriter = new StringWriter();
layout.Format(stringWriter, loggingEvent);
var message = stringWriter.ToString();
return(message);
}
internal static string GetXmlString(this LoggingEvent loggingEvent, ILayout layout = null)
{
string message = loggingEvent.RenderedMessage + Environment.NewLine + loggingEvent.GetExceptionString();
if (layout != null)
{
using (var w = new StringWriter())
{
layout.Format(w, loggingEvent);
message = w.ToString();
}
}
var logXml = new XElement(
"LogEntry",
new XElement("UserName", loggingEvent.UserName),
new XElement("TimeStamp",
loggingEvent.TimeStamp.ToString(CultureInfo.InvariantCulture)),
new XElement("ThreadName", loggingEvent.ThreadName),
new XElement("LoggerName", loggingEvent.LoggerName),
new XElement("Level", loggingEvent.Level),
new XElement("Identity", loggingEvent.Identity),
new XElement("Domain", loggingEvent.Domain),
new XElement("CreatedOn", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)),
new XElement("RenderedMessage", message),
new XElement("Location", loggingEvent.LocationInformation.FullInfo)
);
if (loggingEvent.Properties != null && loggingEvent.Properties.Count > 0)
{
var props = loggingEvent.Properties;
if (props.Contains("AddPropertiesToXml"))
{
foreach (var k in props.GetKeys())
{
var key = k.Replace(":", "_")
.Replace("@", "_")
.Replace(".", "_");
logXml.Add(new XElement(key, props[k].ToString()));
}
}
}
if (loggingEvent.ExceptionObject != null)
{
logXml.Add(new XElement("Exception", loggingEvent.ExceptionObject.ToString()));
}
return(logXml.ToString());
}
public void DoAppend(log4net.Core.LoggingEvent loggingEvent)
{
if (loggingEvent.Level.CompareTo(Threshold) >= 0)
{
lock (this)
{
if (output == null)
{
output = new StringWriter();
}
Layout.Format(output, loggingEvent);
}
}
}
private static string CalculateHostName(ILayout identity, LoggingEvent loggingEvent)
{
var writer = new StringWriter();
if (identity != null)
{
identity.Format(writer, loggingEvent);
}
else
{
writer.Write(loggingEvent.Domain);
}
return(String.Format("{0}:", writer));
}
internal static string GetXmlString(this LoggingEvent loggingEvent, ILayout layout = null)
{
string message = loggingEvent.RenderedMessage + Environment.NewLine + loggingEvent.GetExceptionString();
if (layout != null)
{
using (var w = new StringWriter())
{
layout.Format(w, loggingEvent);
message = w.ToString();
}
}
var logXml = new XElement(
"LogEntry",
new XElement("UserName", loggingEvent.UserName),
new XElement("TimeStamp",
loggingEvent.TimeStamp.ToString(CultureInfo.InvariantCulture)),
new XElement("ThreadName", loggingEvent.ThreadName),
new XElement("LoggerName", loggingEvent.LoggerName),
new XElement("Level", loggingEvent.Level),
new XElement("Identity", loggingEvent.Identity),
new XElement("Domain", loggingEvent.Domain),
new XElement("CreatedOn", DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)),
new XElement("RenderedMessage", message),
new XElement("Location", loggingEvent.LocationInformation.FullInfo)
);
if (loggingEvent.Properties != null && loggingEvent.Properties.Count > 0)
{
var props = loggingEvent.Properties;
if (props.Contains("AddPropertiesToXml"))
{
foreach (var k in props.GetKeys())
{
var key = k.Replace(":", "_")
.Replace("@", "_")
.Replace(".", "_");
logXml.Add(new XElement(key, props[k].ToString()));
}
}
}
if (loggingEvent.ExceptionObject != null)
{
logXml.Add(new XElement("Exception", loggingEvent.ExceptionObject.ToString()));
}
return logXml.ToString();
}
public virtual void Append(Log log)
{
if (!v_closed)
{
v_layout.Format(v_writer, log);
if (v_logmode == LogMode.Immediate)
{
WriteLogs();
}
}
else
{
new ObjectDisposedException(string.Format("{0}/({1})", this.Name, "Writer"));
}
}
public AzureLayoutLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType, ILayout layout)
{
Level = e.Level.ToString();
Message = e.RenderedMessage + Environment.NewLine + e.GetExceptionString();
ThreadName = e.ThreadName;
EventTimeStamp = e.TimeStamp;
using (var w = new StringWriter())
{
layout.Format(w, e);
Message = w.ToString();
}
PartitionKey = e.MakePartitionKey(partitionKeyType);
RowKey = e.MakeRowKey();
}
public AzureLayoutLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType, ILayout layout)
{
Level = e.Level.ToString();
Message = e.RenderedMessage + Environment.NewLine + e.GetExceptionString();
ThreadName = e.ThreadName;
EventTimeStamp = e.TimeStamp;
using (var w = new StringWriter())
{
layout.Format(w, e);
Message = w.ToString();
}
PartitionKey = e.MakePartitionKey(partitionKeyType);
RowKey = e.MakeRowKey();
}
/// <inheritdoc />
/// <summary>
/// Formats the specified log entry.
/// </summary>
/// <param name="entry">The entry.</param>
/// <returns>
/// The log <paramref name="entry" /> as a string
/// </returns>
public string FormatEntry(LogEntry entry)
{
LoggingEvent loggingEvent = Log4NetHelper.LogEntryToLoggingEvent(entry);
if (loggingEvent == null)
{
return(string.Empty);
}
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
_layout.Format(writer, loggingEvent);
writer.Close();
}
return(builder.ToString());
}
public static string PreviewPattern(string InfoData, string LayoutType, string ConversionPattern, Object Host)
{
string sResult = string.Empty;
StringWriter oWriter = new StringWriter();
LoggingEvent oEvent = new LoggingEvent(Host.GetType(), null, "Logger Name", Level.All, InfoData, null);
ILayout oLayer = (ILayout)Assembly.Load(Constants.msCONST_LOG4NET_ASSEMBLY_NAME).CreateInstance(LayoutType);
if (null == oLayer)
{
sResult = "This pattern layout is not supported. No preview work.";
}
else
{
if (oLayer.GetType() == typeof(PatternLayout))
{
((PatternLayout)oLayer).ConversionPattern = ConversionPattern;
((PatternLayout)oLayer).ActivateOptions();
}
oLayer.Format(oWriter, oEvent);
sResult = oWriter.GetStringBuilder().ToString();
}
return(sResult);
}
public AzureLayoutLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType, ILayout layout)
{
Level = e.Level.ToString();
Message = e.RenderedMessage + Environment.NewLine + e.GetExceptionString();
ThreadName = e.ThreadName;
EventTimeStamp = e.TimeStamp;
using (var w = new StringWriter())
{
layout.Format(w, e);
Message = w.ToString();
}
// Azure Storage Table string is encoded as a UTF-16-encoded value.
// String values may be up to 64 KB in size. Note that the maximum number of characters supported is about 32 K or less.
// To be safe we allow 32k characters instead of 32KB of string.
if (Message.Length >= 32000)
{
Message = $"{Message.Substring(0, 31987)}... TRUNCATED";
}
PartitionKey = e.MakePartitionKey(partitionKeyType);
RowKey = e.MakeRowKey();
}
public void Append(int level, string category, DateTime time, string content)
{
Exconsole.WriteLineColorEscaped(_layout.Format(level, category, time, content));
}
/// <summary>
/// Format the logging event as an object.
/// </summary>
/// <param name="loggingEvent">The event to format</param>
/// <returns>returns the formatted event</returns>
/// <remarks>
/// <para>Format the logging event as an object.</para>
/// <para>Uses the <see cref="ILayout"/> object supplied to
/// the constructor to perform the formatting.</para>
/// </remarks>
virtual public object Format(LoggingEvent loggingEvent)
{
return(m_layout.Format(loggingEvent));
}
private static string GetPatternLayoutData(ILayout layout, int maxsize, LoggingEvent loggevent)
{
return(GetLayoutData(maxsize, loggevent, (textWriter, loggevent1) => layout.Format(textWriter, loggevent)));
}
public void Append(int level, string category, DateTime time, string content)
{
Console.Error.WriteLine(_layout.Format(level, category, time, content));
}
private string Render(LoggingEvent loggingEvent, ILayout layout)
{
var m = new StringWriter();
layout.Format(m, loggingEvent);
return m.ToString();
}
public void Format(TextWriter writer, LoggingEvent loggingEvent)
{
InnerLayout.Format(writer, loggingEvent);
}
