private LogResponse LogWorker(LogglyEvent logglyEvent)
{
var response = new LogResponse {Code = ResponseCode.Unknown};
try
{
if (LogglyConfig.Instance.IsEnabled)
{
if (LogglyConfig.Instance.Transport.LogTransport == LogTransport.Https)
{
// syslog has this data in the header, only need to add it for Http
logglyEvent.Data.AddIfAbsent("timestamp", logglyEvent.Timestamp);
}
var message = new LogglyMessage
{
Timestamp = logglyEvent.Timestamp
, Syslog = logglyEvent.Syslog
, Type = MessageType.Json
, Content = ToJson(logglyEvent.Data)
};
IMessageTransport transporter = TransportFactory();
response = transporter.Send(message);
}
else
{
response = new LogResponse {Code = ResponseCode.SendDisabled};
}
}
catch (Exception e)
{
LogglyException.Throw(e);
}
return response;
}
private LogglyEvent CreateLogglyEvent(LogEvent logEvent)
{
var logglyEvent = new LogglyEvent();
var isHttpTransport = LogglyConfig.Instance.Transport.LogTransport == LogTransport.Https;
logglyEvent.Syslog.Level = ToSyslogLevel(logEvent);
foreach (var key in logEvent.Properties.Keys)
{
var propertyValue = logEvent.Properties[key];
var simpleValue = LogglyPropertyFormatter.Simplify(propertyValue);
logglyEvent.Data.AddIfAbsent(key, simpleValue);
}
logglyEvent.Data.AddIfAbsent("Message", logEvent.RenderMessage(_formatProvider));
if (isHttpTransport)
{
// syslog will capture these via the header
logglyEvent.Data.AddIfAbsent("Level", logEvent.Level.ToString());
}
if (logEvent.Exception != null)
{
logglyEvent.Data.AddIfAbsent("Exception", logEvent.Exception);
}
return logglyEvent;
}
/// <summary>
/// Log the message to the supplied event log.
/// </summary>
/// <param name="log"></param>
public LogglyEvent CreateEvent(Dictionary <string, object> logData)
{
// Log using our information
// Start with the standard properties
Dictionary <string, object> data = new Dictionary <string, object>(logData);
// These fields are allowed to be overwritten by the caller
data["thread"] = System.Threading.Thread.CurrentThread.GetHashCode().ToString();
// Add the message data
if (_data != null)
{
foreach (var kvp in _data)
{
data[kvp.Key] = kvp.Value;
}
}
// Add the new stuff for this message
data["message"] = String.Format(_messageFormat, _args);
data["level"] = _level.ToString();
data["date"] = _date;
data["sendDelay"] = (DateTime.UtcNow - _insertionDate).TotalSeconds; // Bookkeeping
// Serialize and dispatch
var logglyEvent = new Loggly.LogglyEvent();
foreach (var key in data.Keys)
{
logglyEvent.Data.Add(key, data[key]);
}
return(logglyEvent);
}
protected virtual LogglyMessage BuildMessage(LogglyEvent logglyEvent)
{
return(new LogglyMessage
{
Timestamp = logglyEvent.Timestamp,
Syslog = logglyEvent.Syslog,
Type = MessageType.Json,
Content = ToJson(logglyEvent.Data),
CustomTags = logglyEvent.Options.Tags
});
}
private LogResponse LogWorker(LogglyEvent logglyEvent)
{
var response = new LogResponse {
Code = ResponseCode.Unknown
};
try
{
if (LogglyConfig.Instance.IsEnabled)
{
if (LogglyConfig.Instance.Transport.LogTransport == LogTransport.Https)
{
// syslog has this data in the header, only need to add it for Http
logglyEvent.Data.AddIfAbsent("timestamp", logglyEvent.Timestamp);
}
var message = new LogglyMessage
{
Timestamp = logglyEvent.Timestamp
, Syslog = logglyEvent.Syslog
, Type = MessageType.Json
, Content = ToJson(logglyEvent.Data)
};
IMessageTransport transporter = TransportFactory();
response = transporter.Send(message);
}
else
{
response = new LogResponse {
Code = ResponseCode.SendDisabled
};
}
}
catch (Exception e)
{
LogglyException.Throw(e);
}
return(response);
}
private async Task<LogResponse> LogWorker(LogglyEvent[] events)
{
var response = new LogResponse {Code = ResponseCode.Unknown};
try
{
if (LogglyConfig.Instance.IsEnabled)
{
if (LogglyConfig.Instance.Transport.LogTransport == LogTransport.Https)
{
if (!LogglyConfig.Instance.Transport.IsOmitTimestamp)
{
foreach (var e in events)
{
// syslog has this data in the header, only need to add it for Http
e.Data.AddIfAbsent("timestamp", e.Timestamp);
}
}
}
response = await _transport.Send(events.Select(x => new LogglyMessage
{
Timestamp = x.Timestamp,
Syslog = x.Syslog,
Type = MessageType.Json,
Content = ToJson(x.Data),
CustomTags = x.Options.Tags
})).ConfigureAwait(false);
}
else
{
response = new LogResponse {Code = ResponseCode.SendDisabled};
}
}
catch (Exception e)
{
LogglyException.Throw(e);
}
return response;
}
public Task <LogResponse> Log(LogglyEvent logglyEvent)
{
return(Task.Run(() => LogWorker(logglyEvent)));
}
public async Task<LogResponse> Log(LogglyEvent logglyEvent)
{
return await LogWorker(new [] {logglyEvent}).ConfigureAwait(false);
}
public async Task <LogResponse> Log(LogglyEvent logglyEvent)
{
return(await LogWorker(new [] { logglyEvent }).ConfigureAwait(false));
}
public Task<LogResponse> Log(LogglyEvent logglyEvent)
{
return Task.Run(() => LogWorker(logglyEvent));
}
public Task<LogResponse> Log(LogglyEvent logglyEvent)
{
return Task.Run(async () => await LogWorker(new [] {logglyEvent}).ConfigureAwait(false));
}
