public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (!this.IsEnabled(logLevel))
{
return;
}
var builder = exception != null?_client.CreateException(exception)
: _client.CreateEvent().SetType(Exceptionless.Models.Event.KnownTypes.Log);
builder.SetMessage(formatter(state, exception));
builder.SetProperty(Exceptionless.Models.Event.KnownDataKeys.Level, ConvertLogLevel(logLevel).ToString());
builder.SetSource(_name);
var logEntity = state as IExceptionLessLogEntity;
if (logEntity != null)
{
if (logEntity.Data != null)
{
builder.AddObject(logEntity.Data);
}
if (logEntity.Tags != null)
{
builder.AddTags(logEntity.Tags);
}
if (logEntity.User != null)
{
builder.SetUserIdentity(logEntity.User);
}
}
builder.Submit();
}
public static EventBuilder CreateFromLogEvent(this ExceptionlessClient client, LoggingEvent ev)
{
var builder = ev.ExceptionObject != null?client.CreateException(ev.ExceptionObject) : client.CreateLog(ev.LoggerName, ev.RenderedMessage, ev.Level.Name);
builder.Target.Date = ev.TimeStamp;
if (!String.IsNullOrWhiteSpace(ev.RenderedMessage))
{
builder.SetMessage(ev.RenderedMessage);
}
if (ev.ExceptionObject != null)
{
builder.SetSource(ev.LoggerName);
}
var props = ev.GetProperties();
foreach (var key in props.GetKeys().Where(key => !_ignoredEventProperties.Contains(key, StringComparer.OrdinalIgnoreCase)))
{
string propName = key;
if (propName.StartsWith("log4net:"))
{
propName = propName.Substring(8);
}
builder.SetProperty(propName, props[key]);
}
return(builder);
}
/// <summary>
/// 创建事件生成器
/// </summary>
private EventBuilder CreateBuilder(LogLevel level, ILogContent content)
{
if (content.Exception != null)
{
return(_client.CreateException(content.Exception));
}
return(_client.CreateLog(GetMessage(content), ConvertTo(level)));
}
public static EventBuilder CreateFromLogEvent(this ExceptionlessClient client, LogEventInfo ev)
{
var builder = ev.Exception != null?client.CreateException(ev.Exception) : client.CreateLog(ev.FormattedMessage);
builder.Target.Date = ev.TimeStamp;
builder.SetSource(ev.LoggerName);
if (ev.Exception == null)
{
builder.AddObject(ev.Level.Name, "Level");
}
foreach (var p in ev.Properties)
{
builder.AddObject(p.Value, p.Key.ToString());
}
return(builder);
}
public static EventBuilder CreateFromLogEvent(this ExceptionlessClient client, LogEvent log)
{
var builder = log.Exception != null
? client.CreateException(log.Exception)
: client.CreateLog(log.GetSource(), log.RenderMessage(), log.GetLevel());
builder.Target.Date = log.Timestamp;
if (log.Level == LogEventLevel.Fatal)
{
builder.MarkAsCritical();
}
if (!String.IsNullOrWhiteSpace(log.RenderMessage()))
{
builder.SetMessage(log.RenderMessage());
}
return(builder);
}
public static EventBuilder CreateFromLogEvent(this ExceptionlessClient client, LogEventInfo ev)
{
var builder = ev.Exception != null?client.CreateException(ev.Exception) : client.CreateLog(ev.LoggerName, ev.FormattedMessage, ev.Level.Name);
builder.Target.Date = ev.TimeStamp;
if (!String.IsNullOrWhiteSpace(ev.FormattedMessage))
{
builder.SetMessage(ev.FormattedMessage);
}
if (ev.Exception != null)
{
builder.SetSource(ev.LoggerName);
}
foreach (var p in ev.Properties.Where(kvp => !_ignoredEventProperties.Contains(kvp.Key.ToString(), StringComparer.OrdinalIgnoreCase)))
{
builder.AddObject(p.Value, p.Key.ToString());
}
return(builder);
}
/// <inheritdoc />
/// <summary>
/// Writes a log entry.
/// </summary>
/// <typeparam name="TState">The type of the state object.</typeparam>
/// <param name="logLevel">Entry will be written on this level.</param>
/// <param name="eventId">Id of the event.</param>
/// <param name="state">The entry to be written. Can be also an object.</param>
/// <param name="exception">The exception related to this entry.</param>
/// <param name="formatter">Function to create a <see cref="T:System.String" /> message of the <paramref name="state" /> and <paramref name="exception" />.</param>
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
if (!IsEnabled(logLevel))
{
return;
}
string message = formatter(state, exception);
if (String.IsNullOrEmpty(message) && exception == null)
{
return;
}
var builder = exception == null?_client.CreateLog(_source, message, logLevel.ToLogLevel()) : _client.CreateException(exception);
builder.Target.Date = DateTimeOffset.Now;
if (!String.IsNullOrEmpty(message))
{
builder.SetMessage(message);
}
if (exception != null)
{
builder.SetSource(_source);
}
// Add event id, if available
if (eventId.Id != 0)
{
builder.SetProperty("EventId", eventId.Id);
}
// If within a scope, add scope's reference id
if (ExceptionlessLoggingScope.Current != null)
{
builder.SetEventReference("Parent", ExceptionlessLoggingScope.Current.Id);
}
// The logging framework passes in FormattedLogValues, which implements IEnumerable<KeyValuePair<string, object>>;
// add each property and value as individual objects for proper visibility in Exceptionless
if (state is IEnumerable <KeyValuePair <string, object> > stateProps)
{
foreach (var prop in stateProps)
{
// Logging the message template is superfluous
if (prop.Key != "{OriginalFormat}")
{
builder.SetProperty(prop.Key, prop.Value);
}
}
}
else
{
// Otherwise, attach the entire object, using its type as the name
builder.AddObject(state);
}
builder.Submit();
}
public void EventLog(Exception exception)
{
client.CreateException(exception).Submit();
}
public void Exception(Exception exception, params string[] tags)
{
_Exceptionless.CreateException(exception)
.AddTags(tags).Submit();
}
