public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
// Write header
if (!string.IsNullOrWhiteSpace(this.Header))
writer.WriteLine(this.Header);
// Write properties
writer.WriteLine("{0}SourceId : {1}",
this.Prefix, eventEntry.ProviderId);
writer.WriteLine("{0}EventId : {1}",
this.Prefix, eventEntry.EventId);
writer.WriteLine("{0}Keywords : {1}",
this.Prefix, eventEntry.Schema.Keywords);
writer.WriteLine("{0}Level : {1}",
this.Prefix, eventEntry.Schema.Level);
writer.WriteLine("{0}Message : {1}",
this.Prefix, eventEntry.FormattedMessage);
writer.WriteLine("{0}Opcode : {1}",
this.Prefix, eventEntry.Schema.Opcode);
writer.WriteLine("{0}Task : {1} {2}",
this.Prefix, eventEntry.Schema.Task, eventEntry.Schema.TaskName);
writer.WriteLine("{0}Version : {1}",
this.Prefix, eventEntry.Schema.Version);
writer.WriteLine("{0}Payload :{1}",
this.Prefix, FormatPayload(eventEntry));
writer.WriteLine("{0}Timestamp : {1}",
this.Prefix, eventEntry.GetFormattedTimestamp(this.DateTimeFormat));
// Write footer
if (!string.IsNullOrWhiteSpace(this.Footer))
writer.WriteLine(this.Footer);
writer.WriteLine();
}
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
var eventId = eventEntry.EventId;
var activityId = eventEntry.ActivityId;
var formattedMessage = eventEntry.FormattedMessage;
var timestamp = eventEntry.Timestamp;
writer.WriteLine("[{0}], [{1}], {2}, ActivityId: {3}", timestamp, eventId, formattedMessage, activityId);
}
private static string FormatPayload(EventEntry entry)
{
var eventSchema = entry.Schema;
var sb = new StringBuilder();
for (int i = 0; i < entry.Payload.Count; i++)
{
// Any errors will be handled in the event sink.
sb.AppendFormat(" [{0} : {1}]",
eventSchema.Payload[i], entry.Payload[i]);
}
return sb.ToString();
}
private Dictionary<string, object> GetExtras(EventEntry entry)
{
IEnumerator<string> keysEnumerator = ((ICollection<string>) entry.Schema.Payload).GetEnumerator();
IEnumerator<object> valuesEnumerator = entry.Payload.GetEnumerator();
var extras = new Dictionary<string, object>();
while (keysEnumerator.MoveNext() && valuesEnumerator.MoveNext())
extras[keysEnumerator.Current] = valuesEnumerator.Current;
return extras;
}
internal static void XmlWritePayload(XmlWriter writer, EventEntry entry)
{
writer.WriteStartElement("Payload");
var eventSchema = entry.Schema;
for (int i = 0; i < entry.Payload.Count; i++)
{
XmlWriteProperty(writer, eventSchema.Payload[i], entry.Payload[i]);
}
writer.WriteEndElement();
}
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
if (throwOnWrite)
{
throw new InvalidOperationException();
}
this.WriteEventCalls.Add(Tuple.Create(eventEntry, writer));
if (eventEntry.Payload.Count > 0)
{
writer.Write(eventEntry.Payload[0]);
}
}
void IEventTextFormatter.WriteEvent(EventEntry eventEntry, TextWriter writer)
{
writer.Write(eventEntry.GetFormattedTimestamp("o") + " ");
writer.Write("EventId=" + eventEntry.EventId + " ");
writer.Write("EventName=" + eventEntry.Schema.EventName + " ");
writer.Write("Level=" + eventEntry.Schema.Level + " ");
writer.Write("\"FormattedMessage=" + eventEntry.FormattedMessage + "\" ");
for (int i = 0; i < eventEntry.Payload.Count; i++)
{
if (i != 0) writer.Write(" ");
writer.Write("\"{0}={1}\"", eventEntry.Schema.Payload[i], eventEntry.Payload[i]);
}
writer.WriteLine();
}
/// <summary>
/// Writes the event.
/// </summary>
/// <param name="eventData">The <see cref="EventWrittenEventArgs" /> instance containing the event data.</param>
/// <param name="writer">The writer.</param>
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
// Write header
if (!string.IsNullOrWhiteSpace(this.Header))
{
writer.WriteLine(this.Header);
}
if (eventEntry.Payload.First().ToString() == "error")
{
writer.WriteLine("This is an entry containing and error and should not be logged");
throw new InvalidOperationException("error");
}
if (eventEntry.Schema.Level >= this.Detailed)
{
// Write properties
writer.WriteLine("SourceId : {0}", eventEntry.ProviderId);
writer.WriteLine("EventId : {0}", eventEntry.EventId);
writer.WriteLine("Keywords : {0}", eventEntry.Schema.Keywords);
writer.WriteLine("Level : {0}", eventEntry.Schema.Level);
writer.WriteLine("Message : {0}", eventEntry.FormattedMessage);
writer.WriteLine("Opcode : {0}", eventEntry.Schema.Opcode);
writer.WriteLine("Task : {0} {1}", eventEntry.Schema.Task, eventEntry.Schema.EventName);
writer.WriteLine("Version : {0}", eventEntry.Schema.Version);
writer.WriteLine("Payload :{0}", FormatPayload(eventEntry));
writer.WriteLine("Timestamp : {0}", eventEntry.GetFormattedTimestamp(this.DateTimeFormat));
}
else
{
writer.WriteLine("EventId : {0}, Level : {1}, Message : {2}, Payload :{3}, Timestamp : {4}",
eventEntry.EventId,
eventEntry.Schema.Level,
eventEntry.FormattedMessage,
FormatPayload(eventEntry),
eventEntry.GetFormattedTimestamp(this.DateTimeFormat));
}
// Write footer
if (!string.IsNullOrWhiteSpace(this.Footer))
{
writer.WriteLine(this.Footer);
}
writer.WriteLine();
}
private void WriteJsonEntry(EventEntry entry)
{
this.writer.WriteStartObject();
WriteValue("EventId", entry.EventId);
WriteValue("EventName", entry.Schema.EventName);
WriteValue("Timestamp", ToJsonIso8601(entry.Timestamp.UtcDateTime));
WriteValue("Keywords", (long)entry.Schema.Keywords);
WriteValue("ProviderId", entry.Schema.ProviderId);
WriteValue("ProviderName", entry.Schema.ProviderName);
WriteValue("InstanceName", this.instanceName);
WriteValue("Level", (int)entry.Schema.Level);
WriteValue("Message", entry.FormattedMessage);
WriteValue("Opcode", (int)entry.Schema.Opcode);
WriteValue("Task", (int)entry.Schema.Task);
WriteValue("Version", entry.Schema.Version);
WriteValue("ProcessId", entry.ProcessId);
WriteValue("ThreadId", entry.ThreadId);
WriteValue("ActivityId", entry.ActivityId);
WriteValue("RelatedActivityId", entry.RelatedActivityId);
//If we are not going to flatten the payload then write opening
if (!flattenPayload)
{
writer.WritePropertyName("Payload");
writer.WriteStartObject();
}
foreach (var payload in entry.Schema.Payload.Zip(entry.Payload, Tuple.Create))
{
this.WriteValue(
this.flattenPayload
? string.Format(CultureInfo.InvariantCulture, PayloadFlattenFormatString, payload.Item1)
: payload.Item1,
payload.Item2);
}
//If we are not going to flatten the payload then write closing
if (!flattenPayload)
{
writer.WriteEndObject();
}
this.writer.WriteEndObject();
this.writer.WriteWhitespace("\n");
}
internal static string XmlSerializePayload(EventEntry entry)
{
try
{
var settings = new XmlWriterSettings()
{
OmitXmlDeclaration = true // Do not add xml declaration
};
var writer = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(writer, settings))
{
XmlWritePayload(xmlWriter, entry);
xmlWriter.Flush();
return writer.ToString();
}
}
catch (Exception e)
{
SemanticLoggingEventSource.Log.CustomSinkUnhandledFault(e.ToString());
return string.Format("<Error>{0}</Error>", string.Format(CultureInfo.CurrentCulture, Properties.Resources.XmlSerializationError, e.Message));
}
}
public JsonPacket Create(string projectId, EventEntry entry,
ISentryExceptionLocator exceptionLocator)
{
var extras = GetExtras(entry);
var packet = new JsonPacket(projectId)
{
Message = entry.FormattedMessage,
Level = GetLogLevel(entry.Schema.Level),
Tags = GetTags(entry),
Extra = extras,
TimeStamp = entry.Timestamp.UtcDateTime
};
if (exceptionLocator != null)
{
var exceptions = exceptionLocator.Locate(extras);
if (exceptions != null)
packet.Exceptions = exceptions.ToList();
}
return packet;
}
private void WriteJsonEntry(EventEntry entry)
{
this.writer.WriteStartObject();
this.writer.WritePropertyName("index");
// Write the batch "index" operation header
this.writer.WriteStartObject();
// ES index names must be lower case and cannot contain whitespace or any of the following characters \/*?"<>|,
WriteValue("_index", this.GetIndexName(entry.Timestamp.UtcDateTime));
WriteValue("_type", this.entryType);
this.writer.WriteEndObject();
this.writer.WriteEndObject();
this.writer.WriteRaw("\n"); //ES requires this \n separator
this.writer.WriteStartObject();
WriteValue("EventId", entry.EventId);
WriteValue("EventDate", entry.Timestamp.UtcDateTime);
WriteValue("Keywords", (long)entry.Schema.Keywords);
WriteValue("ProviderId", entry.Schema.ProviderId);
WriteValue("ProviderName", entry.Schema.ProviderName);
WriteValue("InstanceName", this.instanceName);
WriteValue("Level", (int)entry.Schema.Level);
WriteValue("LevelName", entry.Schema.Level.ToString());
WriteValue("Message", entry.FormattedMessage);
WriteValue("Opcode", (int)entry.Schema.Opcode);
WriteValue("Task", (int)entry.Schema.Task);
WriteValue("Version", entry.Schema.Version);
WriteValue("ProcessId", entry.ProcessId);
WriteValue("ThreadId", entry.ThreadId);
if (entry.ActivityId != Guid.Empty)
{
WriteValue("ActivityId", entry.ActivityId);
}
if (entry.RelatedActivityId != Guid.Empty)
{
WriteValue("RelatedActivityId", entry.RelatedActivityId);
}
//If we have a global context, write each property
if (this.globalContextExtension != null)
{
foreach (var pair in globalContextExtension)
{
this.WriteValue("Context_" + pair.Key, pair.Value);
}
}
//If we are not going to flatten the payload then write opening
if (!flattenPayload)
{
writer.WritePropertyName("Payload");
writer.WriteStartObject();
}
foreach (var payload in entry.Schema.Payload.Zip(entry.Payload, Tuple.Create))
{
this.WriteValue(
this.flattenPayload
? string.Format(CultureInfo.InvariantCulture, PayloadFlattenFormatString, payload.Item1)
: payload.Item1,
payload.Item2);
}
//If we are not going to flatten the payload then write closing
if (!flattenPayload)
{
writer.WriteEndObject();
}
this.writer.WriteEndObject();
this.writer.WriteRaw("\n");
}
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
writer.Close();
writer.Write(eventEntry.FormattedMessage ?? (object)eventEntry.Payload);
}
private Dictionary<string, string> GetTags(EventEntry entry)
{
return new Dictionary<string, string>
{
{"EventKeywords", entry.Schema.KeywordsDescription},
{"EventOpcode", entry.Schema.OpcodeName},
{"EventTask", entry.Schema.TaskName},
{"EventName", entry.Schema.EventName},
{"EventVersion", entry.Schema.Version.ToString(CultureInfo.InvariantCulture)}
};
}
private static string FormatPayload(EventEntry entry)
{
string strContext = null;
string strCode = null;
string strMessage = null;
string strDetail = null;
var eventSchema = entry.Schema;
var sb = new StringBuilder();
for(int i = 0; i < entry.Payload.Count; i++)
{
switch ((string)eventSchema.Payload[i])
{
case "strContext":
strContext = (string)entry.Payload[i];
break;
case "strCode":
strCode = (string)entry.Payload[i];
break;
case "strMessage":
strMessage = (string)entry.Payload[i];
break;
case "strDetail":
strDetail = (string)entry.Payload[i];
break;
}
}
switch(entry.EventId)
{
case 1:
// auth failure
sb.AppendFormat("{0}: {1}\r\n", strMessage, strDetail);
break;
case 2:
// web failure
sb.AppendFormat("{0}: {1}\r\n{2}\r\n", strCode, strDetail, strContext);
break;
}
return sb.ToString();
}
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
Console.ForegroundColor = ConsoleColor.Red;
writer.WriteLine("{0} {1}", eventEntry.GetFormattedTimestamp("yyyy.MM.dd hh.mm.ss"), FormatPayload(eventEntry));
Console.ResetColor();
}
private static string FormatPayload(EventEntry entry)
{
var eventSchema = entry.Schema;
var sb = new StringBuilder();
for (int i = 0; i < entry.Payload.Count; i++)
{
try
{
sb.AppendFormat(" [{0} : {1}]", eventSchema.Payload[i], entry.Payload[i]);
}
catch (Exception e)
{
SemanticLoggingEventSource.Log.EventEntryTextWriterFailed(e.ToString());
sb.AppendFormat(" [{0} : {1}]", "Exception", string.Format(CultureInfo.CurrentCulture, Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Properties.Resources.TextSerializationError, e.Message));
}
}
return sb.ToString();
}
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
writer.Write(eventEntry.FormattedMessage);
}
/// <summary>
/// Writes the event.
/// </summary>
/// <param name="eventEntry">The <see cref="EventEntry" /> instance containing the event data.</param>
/// <param name="writer">The writer.</param>
public void WriteEvent(Microsoft.Practices.EnterpriseLibrary.SemanticLogging.EventEntry eventEntry, TextWriter writer)
{
Guard.ArgumentNotNull(eventEntry, "eventEntry");
Guard.ArgumentNotNull(writer, "writer");
// format the event entry using html
using (HtmlTextWriter htmlWriter = new HtmlTextWriter(writer))
{
// write start of a table
htmlWriter.AddAttribute(HtmlTextWriterAttribute.Border, "0");
htmlWriter.AddAttribute(HtmlTextWriterAttribute.Cellpadding, "0");
htmlWriter.AddAttribute(HtmlTextWriterAttribute.Cellspacing, "0");
htmlWriter.AddAttribute(HtmlTextWriterAttribute.Width, "100%");
htmlWriter.RenderBeginTag(HtmlTextWriterTag.Table);
if (eventEntry.Schema.Level <= this.VerbosityThreshold || this.VerbosityThreshold == EventLevel.LogAlways)
{
// Write with verbosityThreshold format
this.WriteTwoCols(htmlWriter, PropertyNames.ProviderId, eventEntry.ProviderId);
this.WriteTwoCols(htmlWriter, PropertyNames.EventId, eventEntry.EventId);
this.WriteTwoCols(htmlWriter, PropertyNames.Keywords, eventEntry.Schema.Keywords);
this.WriteTwoCols(htmlWriter, PropertyNames.Level, eventEntry.Schema.Level);
this.WriteTwoCols(htmlWriter, PropertyNames.Opcode, eventEntry.Schema.Opcode);
this.WriteTwoCols(htmlWriter, PropertyNames.Task, eventEntry.Schema.Task);
this.WriteTwoCols(htmlWriter, PropertyNames.Timestamp, eventEntry.GetFormattedTimestamp(this.DateTimeFormat));
this.WriteTwoCols(htmlWriter, PropertyNames.ProcessId, eventEntry.ProcessId);
this.WriteTwoCols(htmlWriter, PropertyNames.ThreadId, eventEntry.ThreadId);
if (eventEntry.ActivityId != Guid.Empty)
{
this.WriteTwoCols(htmlWriter, PropertyNames.ActivityId, eventEntry.ActivityId);
}
if (eventEntry.RelatedActivityId != Guid.Empty)
{
this.WriteTwoCols(htmlWriter, PropertyNames.RelatedActivityId, eventEntry.RelatedActivityId);
}
this.WriteTwoCols(htmlWriter, null, null); // leave an empty row
this.WriteTwoRows(htmlWriter, PropertyNames.Message, eventEntry.FormattedMessage);
}
else
{
// Write with summary format
this.WriteTwoCols(htmlWriter, PropertyNames.EventId, eventEntry.EventId);
this.WriteTwoCols(htmlWriter, PropertyNames.Level, eventEntry.Schema.Level);
this.WriteTwoCols(htmlWriter, PropertyNames.Timestamp, eventEntry.GetFormattedTimestamp(this.DateTimeFormat));
this.WriteTwoCols(htmlWriter, PropertyNames.ProcessId, eventEntry.ProcessId);
this.WriteTwoCols(htmlWriter, PropertyNames.ThreadId, eventEntry.ThreadId);
if (eventEntry.ActivityId != Guid.Empty)
{
this.WriteTwoCols(htmlWriter, PropertyNames.ActivityId, eventEntry.ActivityId);
}
if (eventEntry.RelatedActivityId != Guid.Empty)
{
this.WriteTwoCols(htmlWriter, PropertyNames.RelatedActivityId, eventEntry.RelatedActivityId);
}
this.WriteTwoCols(htmlWriter, null, null); // leave an empty row
this.WriteTwoRows(htmlWriter, PropertyNames.Message, eventEntry.FormattedMessage);
}
htmlWriter.RenderEndTag(); // </table>
}
}
public void WriteEvent(EventEntry eventEntry, TextWriter writer)
{
writer.WriteLine("{0} {1,-32} {2}", eventEntry.Timestamp.ToString("yyyy-MM-dd HH:mm:ss"), "[" + Limit(eventEntry.Schema.ProviderName, 30) + "]", eventEntry.FormattedMessage);
}
private async Task RenderEvent(EventEntry evt)
{
string message = evt.FormattedMessage;
switch (evt.Schema.Level)
{
case EventLevel.Critical:
await Console.WriteFatalLine(message);
break;
case EventLevel.Error:
await Console.WriteErrorLine(message);
break;
case EventLevel.Informational:
await Console.WriteInfoLine(message);
break;
case EventLevel.Verbose:
await Console.WriteTraceLine(message);
break;
case EventLevel.Warning:
await Console.WriteWarningLine(message);
break;
}
}
private static void RenderEvent(EventEntry evt)
{
string message = evt.FormattedMessage;
string levelStr;
if(!_levelMap.TryGetValue(evt.Schema.Level, out levelStr)) {
levelStr = "????";
}
levelStr = levelStr.PadRight(_maxLen);
Console.WriteLine("[{0}] {1}", levelStr, message);
}
public string CaptureEventEntry(EventEntry entry, ISentryExceptionLocator exceptionLocator)
{
var packet = _packetFactory.Create(CurrentDsn.ProjectID, entry, exceptionLocator);
return base.Send(packet, CurrentDsn);
}
