private void LogAfter(MethodInfo methodInfo, object[] args, object result, string correlationId)
{
var dic = new Dictionary <string, string>();
var parameters = methodInfo.GetParameters();
if (parameters.Any())
{
for (var i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var arg = args[i];
dic.Add(parameter.Name, GetStringValue(arg));
}
}
var data = new
{
Class = _decorated.GetType().FullName,
Method = methodInfo.Name,
Result = GetStringValue(result),
Parameters = dic,
CorrelationId = correlationId
};
_exceptionlessClient.CreateLog($"Method completed: {data.Class}.{data.Method}", LogLevel.Debug).AddObject(data).Submit();
}
public async Task ExceptionlessMoreInfo()
{
ExceptionlessClient _client = ExceptionlessClient.Default;
_client.CreateLog("测试日志1", LogLevel.Info).Submit();
_client.CreateLog("测试日志2", LogLevel.Trace).Submit();
}
public void LogError(string source, string message, params string[] args)
{
if (args.Length > 0)
{
_client.CreateLog(source, message, LogLevel.Error).AddTags(args).Submit();
}
else
{
_client.SubmitLog(source, message, LogLevel.Error);
}
}
private static void WriteExceptionlessLog(string source, string message, LogLevel logLevel, params string[] tags)
{
if (source.IsNullOrWhiteSpace())
{
exceptionlessClient?.CreateLog(message, logLevel).AddTags(tags).Submit();
}
else
{
exceptionlessClient?.CreateLog(source, message, logLevel).AddTags(tags).Submit();
}
}
public IHttpActionResult Github(JObject value)
{
var authInfo = value.ToObject <ExternalAuthInfo>();
if (authInfo == null || String.IsNullOrEmpty(authInfo.Code))
{
return(NotFound());
}
if (String.IsNullOrEmpty(Settings.Current.GitHubAppId) || String.IsNullOrEmpty(Settings.Current.GitHubAppSecret))
{
return(NotFound());
}
var client = new GitHubWithPrivateEmailsClient(new RequestFactory(), new RuntimeClientConfiguration {
ClientId = Settings.Current.GitHubAppId,
ClientSecret = Settings.Current.GitHubAppSecret,
RedirectUri = authInfo.RedirectUri
});
UserInfo userInfo;
try {
userInfo = client.GetUserInfo(authInfo.Code);
} catch (Exception ex) {
ex.ToExceptionless().MarkAsCritical().AddTags("External Login", "GitHub").AddObject(authInfo).Submit();
return(BadRequest("Unable to get user info."));
}
User user;
try {
user = AddExternalLogin(userInfo);
} catch (ApplicationException) {
return(BadRequest("Account Creation is currently disabled."));
} catch (Exception ex) {
ex.ToExceptionless().MarkAsCritical().AddTags("External Login", "GitHub").AddObject(authInfo).AddObject(userInfo).Submit();
return(BadRequest("An error occurred while processing user info."));
}
if (user == null)
{
_exceptionless.CreateLog(typeof(AuthController).Name, "Unable to process user info.", "Error").AddTags("External Login", "GitHub").AddObject(authInfo).AddObject(userInfo).Submit();
return(BadRequest("Unable to process user info."));
}
if (!String.IsNullOrWhiteSpace(authInfo.InviteToken))
{
AddInvitedUserToOrganization(authInfo.InviteToken, user);
}
return(Ok(new { Token = GetToken(user) }));
}
public static void Log(this ExceptionlessClient client, string logMessage, string source = null, LogLevels level = LogLevels.Info)
{
if (client.LoggingEnabled())
{
client.CreateLog(source, logMessage, level.Text()).Submit();
}
}
public Task CommitAsync()
{
_exceptionlessClient.CreateLog(_messageTitle, _logLevel)
.AddObject(string.Join(Environment.NewLine, _messageDetails), "Details")
.Submit();
return(_exceptionlessClient.ProcessQueueAsync());
}
/// <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)));
}
private void CreateLog(Exception exception, string type, string message, global::Exceptionless.Logging.LogLevel level)
{
_exceptionlessClient.CreateLog(
type,
message,
level)
.SetException(exception)
.Submit();
_exceptionlessClient.ProcessQueue();
}
/// <summary>
/// 记录日志
/// </summary>
/// <param name="client">客户端</param>
/// <param name="log">日志内容</param>
public static void Log(this ExceptionlessClient client, ExceptionlessLog log)
{
var uuid = Uuid.Next();
var eventBuilder = client.CreateLog(log.Message).AddTags(log.Tag);
eventBuilder.AddObject(log.InputData);
eventBuilder.AddObject(log.OutputData);
eventBuilder.SetReferenceId(uuid);
eventBuilder.SetSource(uuid);
eventBuilder.SetProperty(log.PropertyName, log.Property);
eventBuilder.SetVersion(uuid);
eventBuilder.SetUserIdentity(log.UserId);
eventBuilder.Submit();
}
private static void WriteMessageToExceptionless(LogEntity logEntity, LogLevel logLevel)
{
var tag = "信息";
if (logLevel == LogLevel.Warn)
{
tag = "警告";
}
if (logLevel == LogLevel.Trace)
{
tag = "跟踪";
}
ExceptionlessClient.CreateLog(logEntity.ToString(), logLevel)
.AddTags(tag)
.SetReferenceId(Guid.NewGuid().ToString("N"))
.SetProperty("IpAddress", Computer.IpAddress)
.SetProperty("MacAddress", Computer.MacAddress)
.Submit();
}
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.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, 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);
}
/// <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 EventLogDebug(Type source, string msg)
{
client.CreateLog(source.FullName, msg, LogLevel.Debug).Submit();
}
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);
}
public void Debug(string message, params string[] tags)
{
_Exceptionless.CreateLog(message, LogLevel.Debug)
.AddTags(tags).Submit();
}