public void Emit(LogEvent logEvent)
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
string logMessage = null;
if (logEvent.Properties.ContainsKey("Class"))
{
LogEventPropertyValue property;
if (logEvent.Properties.TryGetValue("Class", out property))
{
var render = new StringWriter();
_textFormatterClass.Format(logEvent, render);
logMessage = LogManager.logPrefix + render.ToString();
string ignoreClass = property.ToString();
if (ignoreHashSet.Contains(ignoreClass))
{
if (!String.IsNullOrWhiteSpace(LogManager.outputLogFile))
{
File.AppendAllText(LogManager.outputLogFile, logMessage);
}
return;
}
}
}
else
{
var renderSpace = new StringWriter();
_textFormatter.Format(logEvent, renderSpace);
logMessage = LogManager.logPrefix + renderSpace.ToString();
}
if (!String.IsNullOrWhiteSpace(LogManager.outputLogFile))
{
File.AppendAllText(LogManager.outputLogFile, logMessage);
}
//Raise the event on the delegate's thread, should be UI.
//Necessary otherwise deadlocks ensue and handshake failure due to cross-thread calls..
RaiseEventOnUIThread(OnLogEvent, logMessage);
}
public void Emit(LogEvent logEvent)
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
var sr = new StringWriter();
textFormatter.Format(logEvent, sr);
var text = sr.ToString().Trim();
var category = logEvent.Properties.TryGetValue("SourceContext", out var value) ? value.ToString() : "";
var logger = loggerCategories.GetOrAdd(category, s => CoreLoggerFactory.CreateLogger(s));
switch (logEvent.Level)
{
case LogEventLevel.Fatal:
logger.LogCritical(text);
break;
case LogEventLevel.Error:
logger.LogError(text);
break;
case LogEventLevel.Warning:
logger.LogWarning(text);
break;
case LogEventLevel.Information:
logger.LogInformation(text);
break;
case LogEventLevel.Debug:
logger.LogDebug(text);
break;
case LogEventLevel.Verbose:
logger.LogTrace(text);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected override async Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
var tasks = new List <Task>();
foreach (var logEvent in events)
{
using (var render = new StringWriter(CultureInfo.InvariantCulture))
{
formatter.Format(logEvent, render);
var message = new Message <Null, byte[]> {
Value = Encoding.UTF8.GetBytes(render.ToString())
};
tasks.Add(producer.ProduceAsync(topic, message));
}
}
await Task.WhenAll(tasks);
}
public void Emit(LogEvent logEvent)
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
var renderSpace = new StringWriter();
_textFormatter.Format(logEvent, renderSpace);
// Events.Enqueue(renderSpace.ToString());
var valueToAdd = renderSpace.ToString();
Application.Current.Dispatcher.Invoke(new Action(() =>
{
_debugOutput.Items.Add(valueToAdd);
_debugOutput.ScrollIntoView(valueToAdd);
}));
}
public SerializedClefLog CreateFromEvents(IEnumerable <LogEvent> logEvents)
{
if (logEvents == null)
{
throw new ArgumentNullException(nameof(logEvents));
}
using (var memory = new MemoryStream())
{
var result = SerializedClefLog.Empty;
LogEvent firstEvent = null;
LogEvent lastEvent = null;
using (var zipArchive = new ZipArchive(memory, ZipArchiveMode.Create, false))
using (var zip = zipArchive.CreateEntry("log.clef").Open())
using (var writer = new StreamWriter(zip, Encoding.UTF8, 1024, false))
{
foreach (var logEvent in logEvents)
{
if (firstEvent == null)
{
firstEvent = logEvent;
}
m_formatter.Format(logEvent, writer);
lastEvent = logEvent;
}
writer.Flush();
zip.Flush();
}
if (firstEvent != null)
{
result = new SerializedClefLog(
firstEvent.Timestamp,
lastEvent.Timestamp,
new MemoryStream(memory.GetBuffer(), false));
}
return(result);
}
}
private async void TryConnectToServer()
{
await targetProtocol.Connect();
var localLogger = new LoggerConfiguration().WriteTo.Sink(this, LogEventLevel.Verbose).CreateLogger();
localLogger.Information("Source Process: {AssignProcessName}",
Assembly.GetEntryAssembly()?.GetName().Name ?? "No Name");
while (true)
{
var logEvent = await buffer.Reader.ReadAsync();
using var ms = new MemoryStream();
using var write = new StreamWriter(ms);
format.Format(logEvent, write);
write.Flush();
await targetProtocol.Write(ms.GetBuffer(), 0, (int)ms.Length);
}
}
/// <summary>
/// Emit the provided log event to the sink.
/// </summary>
/// <param name="logEvent">The log event to write.</param>
public void Emit(LogEvent logEvent)
{
if (logEvent == null)
{
throw new ArgumentNullException("logEvent");
}
var renderSpace = new StringWriter();
_textFormatter.Format(logEvent, renderSpace);
var tag = logEvent.Properties.Where(x => x.Key == Constants.SourceContextPropertyName).Select(x => x.Value.ToString("l", null)).FirstOrDefault() ?? "";
switch (logEvent.Level)
{
case LogEventLevel.Debug:
AndroidLog.Debug(tag, renderSpace.ToString());
break;
case LogEventLevel.Information:
AndroidLog.Info(tag, renderSpace.ToString());
break;
case LogEventLevel.Verbose:
AndroidLog.Verbose(tag, renderSpace.ToString());
break;
case LogEventLevel.Warning:
AndroidLog.Warn(tag, renderSpace.ToString());
break;
case LogEventLevel.Error:
AndroidLog.Error(tag, renderSpace.ToString());
break;
case LogEventLevel.Fatal:
AndroidLog.Wtf(tag, renderSpace.ToString());
break;
default:
AndroidLog.WriteLine(LogPriority.Assert, tag, renderSpace.ToString());
break;
}
}
private string FormatPayload(IEnumerable <LogEvent> events)
{
var payload = new StringWriter();
payload.Write("{\"events\":[");
var delimStart = "";
foreach (var logEvent in events)
{
payload.Write(delimStart);
formatter.Format(logEvent, payload);
delimStart = ",";
}
payload.Write("]}");
return(payload.ToString());
}
/// <summary>
/// Emit a batch of log events to datadog.
/// </summary>
/// <param name="events">The events to emit.</param>
/// <remarks>Override either <see cref="PeriodicBatchingSink.EmitBatch"/> or <see cref="PeriodicBatchingSink.EmitBatchAsync"/>,
/// not both.</remarks>
protected override void EmitBatch(IEnumerable <LogEvent> events)
{
if (events == null)
{
throw new ArgumentNullException("events");
}
foreach (var logEvent in events)
{
var payload = new StringWriter();
var title = "Log Event - " + logEvent.Level;
var alertType = GetAlertTypeFromEvent(logEvent);
_textFormatter.Format(logEvent, payload);
_statsd.Add(title, payload.ToString(), alertType, hostname: _datadogConfiguration.Hostname, tags: _datadogConfiguration.Tags);
}
_statsd.Send();
}
/// <summary>
/// Create a log event entity from a Serilog <see cref="LogEvent"/>.
/// </summary>
/// <param name="log">The event to log</param>
/// <param name="formatProvider"></param>
/// <param name="textFormatter"></param>
/// <param name="partitionKey">partition key to store</param>
/// <param name="rowKey">row key to store</param>
public LogEventEntity(
LogEvent log,
ITextFormatter textFormatter,
string partitionKey,
string rowKey)
{
Timestamp = log.Timestamp.ToUniversalTime();
PartitionKey = partitionKey;
RowKey = GetValidRowKey(rowKey);
MessageTemplate = log.MessageTemplate.Text;
Level = log.Level.ToString();
Exception = log.Exception?.ToString();
RenderedMessage = log.RenderMessage();
//Use the underlying TextFormatter to serialise the entire JSON object for the data column
var s = new StringWriter();
textFormatter.Format(log, s);
Data = s.ToString();
}
public void Emit(LogEvent logEvent)
{
if (logEvent.Properties.ContainsKey(skipUnityLogEventSinkPropertyName))
{
return;
}
using (StringWriter stringBuffer = new())
{
formatter.Format(logEvent, stringBuffer);
// Need to escape curly braces because Debug.LogFormat is used
string logString = stringBuffer.ToString().Trim()
.Replace("{", "{{")
.Replace("}", "}}")
+ unityLogEventSinkMarker;
LogType logType = GetUnityLogType(logEvent);
UnityEngine.Object contextObject = GetUnityEngineContextObject(logEvent);
Debug.LogFormat(logType, LogOption.NoStacktrace, contextObject, logString);
}
}
/// <inheritdoc/>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="logEvent"/> is <c>null</c>.</exception>
public void Emit(LogEvent logEvent)
{
if (logEvent is null)
{
throw new ArgumentNullException(nameof(logEvent));
}
if (!_messageSender.CanTrySend)
{
_log.Warn("Sink not initialized. Dropping log entry");
return;
}
_messageSender.TrySend(
_formatter.Format(logEvent),
_source.SourceName,
_source.SourceCategory,
_source.SourceHost);
}
public void Emit(LogEvent logEvent)
{
var renderMessage = logEvent.RenderMessage();
logEvent.AddPropertyIfAbsent(new LogEventProperty("RenderMessage", new ScalarValue(renderMessage)));
var strWriter = new StringWriter();
_formatter.Format(logEvent, strWriter);
var jsonMessage = strWriter.ToString();
var destinationAddress = Dns.GetHostAddresses(_destination).FirstOrDefault(p => p.AddressFamily == AddressFamily.InterNetwork);
var destinationEndpoint = new IPEndPoint(destinationAddress, 8086);
var logPackage = Encoding.ASCII.GetBytes(jsonMessage);
lock (_lock)
{
_udpClient.Send(logPackage, logPackage.Length, destinationEndpoint);
}
}
private void GenerateEntry(
LokiLogEvent lokiLogEvent,
ITextFormatter formatter,
LokiStream stream)
{
var buffer = new StringWriter(new StringBuilder(DefaultWriteBufferCapacity));
var logEvent = lokiLogEvent.LogEvent;
var timestamp = logEvent.Timestamp;
if (_useInternalTimestamp)
{
logEvent.AddPropertyIfAbsent(
new LogEventProperty("Timestamp", new ScalarValue(timestamp)));
timestamp = lokiLogEvent.InternalTimestamp;
}
formatter.Format(logEvent, buffer);
stream.AddEntry(timestamp, buffer.ToString().TrimEnd('\r', '\n'));
}
public void Emit(LogEvent logEvent)
{
if (logEvent.Level < _minimumLevel)
{
return;
}
var writer = new StringWriter();
_textFormatter.Format(logEvent, writer);
var renderedString = writer.ToString();
var request = new PublishRequest
{
TopicArn = _logTopicArn,
Message = renderedString
};
_snsClient.PublishAsync(request).GetAwaiter().GetResult();
}
private string RenderLogEventColumn(LogEvent logEvent)
{
LogEvent preparedLogEvent;
if (_columnOptions.LogEvent.ExcludeAdditionalProperties)
{
var filteredProperties = logEvent.Properties.Where(p => !_additionalColumnPropertyNames.Contains(p.Key));
preparedLogEvent = new LogEvent(logEvent.Timestamp, logEvent.Level, logEvent.Exception, logEvent.MessageTemplate,
filteredProperties.Select(x => new LogEventProperty(x.Key, x.Value)));
}
else
{
preparedLogEvent = logEvent;
}
var sb = new StringBuilder();
using (var writer = new System.IO.StringWriter(sb))
_logEventFormatter.Format(preparedLogEvent, writer);
return(sb.ToString());
}
/// <summary>
/// Emit a batch of log events, running to completion synchronously.
/// </summary>
/// <param name="events">The events to emit.</param>
protected override void EmitBatch(IEnumerable <LogEvent> events)
{
var batchedEvents = new List <EventData>();
foreach (var logEvent in events)
{
var render = new StringWriter();
_formatter.Format(logEvent, render);
var eventHubData = new EventData(Encoding.UTF8.GetBytes(render.ToString()))
{
PartitionKey = _partitionKey
};
eventHubData.Properties.Add(
"Type", "SerilogEvent_" + DateTime.Now.ToLongTimeString());
batchedEvents.Add(eventHubData);
}
_eventHubClient.SendBatch(batchedEvents);
}
#pragma warning disable VSTHRD010
/// <inheritdoc/>
public void Emit(LogEvent logEvent)
{
var sw = new StringWriter();
_formatter.Format(logEvent, sw);
var message = sw.ToString();
if (_pane is IVsOutputWindowPaneNoPump noPump)
{
noPump.OutputStringNoPump(message);
}
else
{
ErrorHandler.ThrowOnFailure(_pane.OutputStringThreadSafe(message));
}
if (logEvent.Level == LogEventLevel.Error)
{
_pane.Activate();
}
}
/// <summary>
/// Format the log events into a payload.
/// </summary>
/// <param name="logEvents">
/// The events to format.
/// </param>
/// <param name="formatter">
/// The formatter turning the log events into a textual representation.
/// </param>
/// <param name="output">
/// The payload to send over the network.
/// </param>
public void Format(IEnumerable <LogEvent> logEvents, ITextFormatter formatter, TextWriter output)
{
if (logEvents == null)
{
throw new ArgumentNullException(nameof(logEvents));
}
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
IEnumerable <string> formattedLogEvents = logEvents.Select(
logEvent =>
{
var writer = new StringWriter();
formatter.Format(logEvent, writer);
return(writer.ToString());
});
Format(formattedLogEvents, output);
}
protected override async Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
foreach (var logEvent in events)
{
var sw = new StringWriter();
_formatter.Format(logEvent, sw);
var loggerName = "Default";
if (logEvent.Properties.TryGetValue(global::Serilog.Core.Constants.SourceContextPropertyName, out LogEventPropertyValue sourceContext))
{
var sv = sourceContext as ScalarValue;
if (sv?.Value is string value)
{
loggerName = value;
}
}
await _eventBus.Publish(new WriteLogEvent(sw.ToString(), logEvent.Timestamp.DateTime, 1,
(int)logEvent.Level, loggerName)).ConfigureAwait(false);
}
}
void UpdateLog(LogEvent loggingEvent)
{
if (Logs.Count > MaxTextLength)
{
Clear();
}
var sr = new StringWriter();
textFormatter.Format(loggingEvent, sr);
var log = sr.ToString();
switch (loggingEvent.Level)
{
case LogEventLevel.Information:
Logs.Add(new LogMessage(log, Colors.Black, true));
break;
case LogEventLevel.Warning:
Logs.Add(new LogMessage(log, Colors.DarkOrange));
break;
case LogEventLevel.Error:
Logs.Add(new LogMessage(log, Colors.Red));
break;
case LogEventLevel.Fatal:
Logs.Add(new LogMessage(log, Colors.DarkOrange));
break;
case LogEventLevel.Debug:
Logs.Add(new LogMessage(log, Colors.Green));
break;
default:
Logs.Add(new LogMessage(log, Colors.Black));
break;
}
}
public void WriteFormattedLogEvents()
{
// Arrange
var batchFormatter = new DefaultBatchFormatter();
var formattedLogEvents = logEvents.Select(logEvent =>
{
var formattedLogEvent = new StringWriter();
textFormatter.Format(logEvent, formattedLogEvent);
return(formattedLogEvent.ToString());
});
// Act
batchFormatter.Format(formattedLogEvents, output);
// Assert
var got = JsonConvert.DeserializeObject <DefaultBatch>(output.ToString());
got.Events.Length.ShouldBe(2);
got.Events[0].RenderedMessage.ShouldBe("Event 1");
got.Events[1].RenderedMessage.ShouldBe("Event 2");
}
public void WriteFormattedLogEvents()
{
// Arrange
var batchFormatter = new ArrayBatchFormatter();
var formattedLogEvents = logEvents.Select(logEvent =>
{
var formattedLogEvent = new StringWriter();
textFormatter.Format(logEvent, formattedLogEvent);
return(formattedLogEvent.ToString());
});
// Act
batchFormatter.Format(formattedLogEvents, output);
// Assert
var actual = JsonConvert.DeserializeObject <NormalTextLogEvent[]>(output.ToString());
actual.Length.ShouldBe(2);
actual[0].RenderedMessage.ShouldBe("Event 1");
actual[1].RenderedMessage.ShouldBe("Event 2");
}
public void Emit(LogEvent logEvent)
{
if (logEvent == null)
{
throw new ArgumentNullException(nameof(logEvent));
}
var renderSpace = new StringWriter();
_textFormatter.Format(logEvent, renderSpace);
var levelName = Enum.GetName(typeof(LogEventLevel), logEvent.Level);
if (logEvent.Level > LogEventLevel.Warning)
{
LogsStore.Instance.Errors.Add(
new LogMessage(logEvent.Timestamp.LocalDateTime, levelName, renderSpace.ToString()));
}
LogsStore.Instance.Logs.Add(new LogMessage(logEvent.Timestamp.LocalDateTime, levelName,
renderSpace.ToString()));
}
public void Emit(LogEvent logEvent)
{
var sb = new StringBuilder();
_formatter.Format(logEvent, new StringWriter(sb));
var data = sb.ToString().Replace("RenderedMessage", "message");
Task.Factory.StartNew(async() =>
{
try
{
using (var httpClient = new HttpClient(_msgHandler, false))
{
var content = new StringContent(data);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
content.Headers.Add("ApiKey", _apiKey);
await httpClient.PostAsync(_url, content);
}
} catch { } /* This is a logging framework. We don't care about logs not succeeding */
});
}
protected override Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
var semaphore = new SemaphoreSlim(Environment.ProcessorCount);
return(Task.WhenAll(events.Select(async e =>
{
await semaphore.WaitAsync();
try
{
using (var writerHolder = _stringWriterPool.Get())
{
_formatter.Format(e, writerHolder.Object);
await _producer.ProduceAsync(writerHolder.Object.ToString());
}
}
finally
{
semaphore.Release();
}
})));
}
private async Task Send(IEnumerable <LogEvent> events)
{
var allEvents = new StringWriter();
foreach (var logEvent in events)
{
_jsonFormatter.Format(logEvent, allEvents);
}
var request = new EventCollectorRequest(_splunkHost, allEvents.ToString(), _uriPath);
var response = await _httpClient.SendAsync(request).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
//Do Nothing?
}
else
{
//Application Errors sent via HTTP Event Collector
if (HttpEventCollectorApplicationErrors.Any(x => x == response.StatusCode))
{
SelfLog.WriteLine(
"A status code of {0} was received when attempting to send to {1}. The event has been discarded and will not be placed back in the queue.",
response.StatusCode.ToString(), _splunkHost);
}
else
{
//Put the item back in the queue & retry on next go
SelfLog.WriteLine(
"A status code of {0} was received when attempting to send to {1}. The event has been placed back in the queue",
response.StatusCode.ToString(), _splunkHost);
foreach (var logEvent in events)
{
_queue.Enqueue(logEvent);
}
}
}
}
protected override async Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
Stream stream;
try
{
stream = await _blob.OpenWriteAsync(false);
}
catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == 404)
{
// When the blob doesn't already exist, create it
stream = await _blob.OpenWriteAsync(true);
}
using (StreamWriter writer = new StreamWriter(stream))
{
foreach (LogEvent evnt in events)
{
_formatter.Format(evnt, writer);
}
}
}
public async Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
var timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds();
var secretEnc = Encoding.UTF8.GetBytes(_connectionInfo.Secret);
var stringToSign = $"{timestamp}\n{_connectionInfo.Secret}";
var stringToSignEnc = Encoding.UTF8.GetBytes(stringToSign);
var hmac256 = new HMACSHA256(secretEnc);
var hashMessage = hmac256.ComputeHash(stringToSignEnc);
var sign = Convert.ToBase64String(hashMessage);
var payload = new StringWriter();
foreach (var logEvent in events)
{
_textFormatter.Format(logEvent, payload);
}
RobotMessageText robotMessage = new RobotMessageText();
robotMessage.text.content = payload.ToString();
var str = new StringContent(JsonConvert.SerializeObject(robotMessage), Encoding.UTF8,
"application/json");
await _client.PostAsync($"{BaseUrl}{_connectionInfo.Token}×tamp={timestamp}&sign={sign}", str);
}
/// <summary>
/// Emit a batch of log events, running to completion synchronously.
/// </summary>
/// <param name="events">The events to emit.</param>
/// <remarks>
/// Override either <see cref="M:Serilog.Sinks.PeriodicBatching.PeriodicBatchingSink.EmitBatchAsync(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent})" /> or <see cref="M:Serilog.Sinks.PeriodicBatching.PeriodicBatchingSink.EmitBatchAsync(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent})" />,
/// not both.
/// </remarks>
protected override async Task EmitBatchAsync(IEnumerable <LogEvent> events)
{
if (events.Any() == false)
{
await Task.FromResult(0);
}
if (_client == null)
{
_client = new LeClient(false, _useSsl, _url);
}
await _client.ConnectAsync().ConfigureAwait(false);
foreach (var logEvent in events)
{
var renderSpace = new StringWriter();
_textFormatter.Format(logEvent, renderSpace);
var renderedString = renderSpace.ToString();
// LogEntries uses a NewLine character to determine the end of a log message
// this causes problems with stack traces.
if (!string.IsNullOrEmpty(renderedString))
{
renderedString = renderedString.Replace("\n", "");
}
var finalLine = _token + renderedString + '\n';
var data = Utf8.GetBytes(finalLine);
await _client.WriteAsync(data, 0, data.Length).ConfigureAwait(false);
}
await _client.FlushAsync().ConfigureAwait(false);
_client.Close();
}
/// <summary>
/// Recourse against the current property path to retrieve the property value to return.
/// </summary>
/// <param name="obj">The object containing the value to extract.</param>
/// <param name="currentPathIndex">
/// The recursion index, indicating the current position in the property path.
/// </param>
/// <param name="textFormatter">
/// The formatter that will be used to format the entity or property values.
/// </param>
/// <returns>
/// The formatted property value obtained matching the current <see cref="FormatParameters" />
/// against the specified array of <see href="System.Object"/>s, and formatting the result
/// using the specified <paramref name="textFormatter"/>.
/// </returns>
private string GetPropertyValue( object obj, int currentPathIndex, ITextFormatter textFormatter )
{
// if there is a constant value, returns it
if ( this.Constant != null ) return textFormatter.Format( this.Format, Constant );
// if object is null, cannot go ahead with the resolution.)
if ( obj == null ) return textFormatter.Format( this.Format, null );
// if the current property in the property path is null or empty,
// should return the formatted whole object.
var propertyName = currentPathIndex < this.PropertyPath.Count ? this.PropertyPath[currentPathIndex] : null;
if ( string.IsNullOrEmpty( propertyName ) )
{
return textFormatter.Format( this.Format, obj );
}
// else extracts the current property
var type = obj.GetType();
var property = type.GetProperty( propertyName );
if ( property == null )
throw new FormatException( "Invalid property: " + propertyName );
// extracts the property value from the object
var propertyValue = property.GetValue( obj, null );
// recourse to resolve the property value;
return GetPropertyValue( propertyValue, currentPathIndex + 1, textFormatter );
}
