protected override void EmitBatch(IEnumerable<LogEvent> events)
{
var payload = new StringWriter();
payload.Write("{\"events\":[");
var formatter = new JsonFormatter();
var delimStart = "";
foreach (var logEvent in events)
{
payload.Write(delimStart);
formatter.Format(logEvent, payload);
delimStart = ",";
}
payload.Write("]}");
var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");
if (!string.IsNullOrWhiteSpace(_apiKey))
content.Headers.Add(ApiKeyHeaderName, _apiKey);
var result = _httpClient.PostAsync(BulkUploadResource, content).Result;
if (!result.IsSuccessStatusCode)
SelfLog.WriteLine("Received failed result {0}: {1}", result.StatusCode, result.Content.ReadAsStringAsync().Result);
var returned = result.Content.ReadAsStringAsync().Result;
_minimumAcceptedLevel = SeqApi.ReadEventInputResult(returned);
}
protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
{
_nextRequiredLevelCheckUtc = DateTime.UtcNow.Add(RequiredLevelCheckInterval);
var payload = new StringWriter();
payload.Write("{\"events\":[");
var formatter = new JsonFormatter(closingDelimiter: "");
var delimStart = "";
foreach (var logEvent in events)
{
payload.Write(delimStart);
formatter.Format(logEvent, payload);
delimStart = ",";
}
payload.Write("]}");
var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");
if (!string.IsNullOrWhiteSpace(_apiKey))
content.Headers.Add(ApiKeyHeaderName, _apiKey);
var result = await _httpClient.PostAsync(BulkUploadResource, content).ConfigureAwait(false);
if (!result.IsSuccessStatusCode)
throw new LoggingFailedException(string.Format("Received failed result {0} when posting events to Seq", result.StatusCode));
var returned = await result.Content.ReadAsStringAsync();
_minimumAcceptedLevel = SeqApi.ReadEventInputResult(returned);
}
/// <summary>
/// Creates an instance of the Splunk UDP Sink
/// </summary>
/// <param name="hostAddress">The Splunk Host</param>
/// <param name="port">The UDP port configured in Splunk</param>
/// <param name="formatProvider">Optional format provider</param>
/// <param name="renderTemplate">If true, the message template will be rendered</param>
public UdpSink(IPAddress hostAddress, int port, IFormatProvider formatProvider = null, bool renderTemplate = true)
{
_socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
_socket.Connect(hostAddress, port);
_jsonFormatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
}
static string FormatToJson(LogEvent @event)
{
var formatter = new JsonFormatter();
var output = new StringWriter();
formatter.Format(@event, output);
return output.ToString();
}
/// <summary>
/// Creates an instance of the Splunk UDP Sink
/// </summary>
/// <param name="host">The Splunk Host</param>
/// <param name="port">The UDP port configured in Splunk</param>
/// <param name="formatProvider">Optional format provider</param>
public SplunkViaUdpSink(string host, int port, IFormatProvider formatProvider = null)
{
_socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
_socket.Connect(host, port);
_jsonFormatter = new JsonFormatter(renderMessage: true, formatProvider: formatProvider);
}
/// <summary>
/// Creates an instance of the Splunk TCP Sink
/// </summary>
/// <param name="host">The Splunk Host</param>
/// <param name="port">The UDP port configured in Splunk</param>
/// <param name="formatProvider">Optional format provider</param>
public SplunkViaTcpSink(string host, int port, IFormatProvider formatProvider = null)
{
_host = host;
_port = port;
_client = new TcpClient();
_client.Connect(host, port);
_jsonFormatter = new JsonFormatter(renderMessage: true, formatProvider: formatProvider);
}
/// <summary>
/// Creates an instance of the Splunk TCP Sink
/// </summary>
/// <param name="hostAddress">The Splunk Host</param>
/// <param name="port">The UDP port configured in Splunk</param>
/// <param name="formatProvider">Optional format provider</param>
public SplunkViaTcpSink(IPAddress hostAddress, int port, IFormatProvider formatProvider = null)
{
_port = port;
_hostAddress = hostAddress;
_client = new TcpClient();
_client.Connect(hostAddress, port);
_jsonFormatter = new JsonFormatter(renderMessage: true, formatProvider: formatProvider);
}
/// <summary>
/// Initializes a new instance of the <see cref="KafkaSink"/> class.
/// </summary>
/// <param name="kafkaClient">
/// The kafka Client.
/// </param>
/// <param name="options">
/// The configuration options.
/// </param>
public KafkaSink(AbstractKafkaClient kafkaClient, KafkaSinkOptions options)
: base(options.BatchPostingLimit, options.Period)
{
Contract.Requires<ArgumentNullException>(options != null);
Contract.Requires<ArgumentNullException>(kafkaClient != null);
this.kafkaClient = kafkaClient;
this.jsonFormatter = new JsonFormatter(renderMessage: options.RenderSerilogMessage);
}
static dynamic FormatJson(LogEvent @event)
{
var formatter = new JsonFormatter();
var output = new StringWriter();
formatter.Format(@event, output);
var serializer = new JsonSerializer { DateParseHandling = DateParseHandling.None };
return serializer.Deserialize(new JsonTextReader(new StringReader(output.ToString())));
}
/// <summary>
/// Creates an instance of the Splunk TCP Sink
/// </summary>
/// <param name="hostAddress">The Splunk Host</param>
/// <param name="port">The UDP port configured in Splunk</param>
/// <param name="formatProvider">Optional format provider</param>
public SplunkViaTcpSink(
IPAddress hostAddress,
int port,
IFormatProvider formatProvider = null)
{
var reconnectionPolicy = new ExponentialBackoffTcpReconnectionPolicy();
_writer = new TcpSocketWriter(hostAddress, port, reconnectionPolicy, 10000);
_jsonFormatter = new JsonFormatter(renderMessage: true, formatProvider: formatProvider);
}
/// <summary>
/// Creates an instance of the Splunk TCP Sink
/// </summary>
/// <param name="hostAddress">The Splunk Host</param>
/// <param name="port">The UDP port configured in Splunk</param>
/// <param name="formatProvider">Optional format provider</param>
/// <param name="renderTemplate">If true, the message template will be rendered</param>
public TcpSink(
IPAddress hostAddress,
int port,
IFormatProvider formatProvider = null,
bool renderTemplate = true)
{
var reconnectionPolicy = new ExponentialBackoffTcpReconnectionPolicy();
_writer = new TcpSocketWriter(hostAddress, port, reconnectionPolicy, 10000);
_jsonFormatter = new SplunkJsonFormatter(renderMessage: true, formatProvider: formatProvider, renderTemplate: renderTemplate);
}
public EventCollectorSink(string splunkHost,
string eventCollectorToken,
IFormatProvider formatProvider = null,
bool renderTemplate = true
)
{
_splunkHost = splunkHost;
_eventCollectorToken = eventCollectorToken;
_queue = new ConcurrentQueue<LogEvent>();
_jsonFormatter = new JsonFormatter(renderMessage: true, formatProvider: formatProvider);
_batchSizeLimit = 1;
var batchInterval = TimeSpan.FromSeconds(5);
RepeatAction.OnInterval(batchInterval, () => ProcessQueue().Wait(), new CancellationToken());
}
protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
{
var payload = new StringWriter();
payload.Write("{\"events\":[");
var formatter = new JsonFormatter(closingDelimiter: "");
var delimStart = "";
foreach (var logEvent in events)
{
payload.Write(delimStart);
formatter.Format(logEvent, payload);
delimStart = ",";
}
payload.Write("]}");
var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");
if (!string.IsNullOrWhiteSpace(_apiKey))
content.Headers.Add(ApiKeyHeaderName, _apiKey);
var result = await _httpClient.PostAsync(BulkUploadResource, content);
if (!result.IsSuccessStatusCode)
throw new LoggingFailedException(string.Format("Received failed result {0} when posting events to Seq", result.StatusCode));
}
/// <summary>
/// Construct a sink posting to the specified database.
/// </summary>
/// <param name="connectionString">Connection string to access the database.</param>
/// <param name="tableName">Name of the table to store the data in.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="autoCreateSqlTable">Create log table with the provided name on destination sql server.</param>
/// <param name="columnOptions">Options that pertain to columns</param>
public MSSqlServerSink(
string connectionString,
string tableName,
int batchPostingLimit,
TimeSpan period,
IFormatProvider formatProvider,
bool autoCreateSqlTable = false,
ColumnOptions columnOptions = null
)
: base(batchPostingLimit, period)
{
if (string.IsNullOrWhiteSpace(connectionString))
throw new ArgumentNullException("connectionString");
if (string.IsNullOrWhiteSpace(tableName))
throw new ArgumentNullException("tableName");
_connectionString = connectionString;
_tableName = tableName;
_formatProvider = formatProvider;
_columnOptions = columnOptions ?? new ColumnOptions();
if (_columnOptions.AdditionalDataColumns != null)
_additionalDataColumnNames = new HashSet<string>(_columnOptions.AdditionalDataColumns.Select(c => c.ColumnName), StringComparer.OrdinalIgnoreCase);
if (_columnOptions.Store.Contains(StandardColumn.LogEvent))
_jsonFormatter = new JsonFormatter(formatProvider: formatProvider);
// Prepare the data table
_eventsTable = CreateDataTable();
if (autoCreateSqlTable)
{
try
{
SqlTableCreator tableCreator = new SqlTableCreator(connectionString);
tableCreator.CreateTable(_eventsTable);
}
catch (Exception ex)
{
SelfLog.WriteLine("Exception {0} caught while creating table {1} to the database specified in the Connection string.", (object)ex, (object)tableName);
}
}
}
/// <summary>
/// Create an instance of the SplunkViaHttp sink.
/// </summary>
/// <param name="context">Connection info.</param>
/// <param name="index">The name of the splunk index to log to</param>
/// <param name="userName">The username to authenticate with</param>
/// <param name="password">The password to authenticate with</param>
/// <param name="batchSizeLimit">The size of the batch prior to logging</param>
/// <param name="batchInterval">The interval on which to log via http</param>
/// <param name="resourceNamespace">The resource namespaces</param>
/// <param name="transmitterArgs">The </param>
/// <param name="formatProvider">The format provider to be used when rendering the message</param>
public SplunkViaHttpSink(
SplunkClient.Context context,
string index,
string userName,
string password,
int batchSizeLimit,
TimeSpan batchInterval,
SplunkClient.Namespace resourceNamespace = null,
SplunkClient.TransmitterArgs transmitterArgs = null,
IFormatProvider formatProvider = null
)
{
_index = index;
_userName = userName;
_password = password;
_batchSizeLimit = batchSizeLimit;
_transmitterArgs = transmitterArgs;
_queue = new ConcurrentQueue<LogEvent>();
_jsonFormatter = new JsonFormatter(renderMessage: true, formatProvider: formatProvider);
_service = resourceNamespace == null
? new SplunkClient.Service(context, new SplunkClient.Namespace("nobody", "search"))
: new SplunkClient.Service(context, resourceNamespace);
RepeatAction.OnInterval(batchInterval, () => ProcessQueue().Wait(), new CancellationToken());
}
/// <summary>
/// Emit a batch of log events, running asynchronously.
/// </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 async Task EmitBatchAsync(IEnumerable<LogEvent> events)
{
var payload = new StringWriter();
payload.Write("{\"docs\":[");
var formatter = new JsonFormatter(
omitEnclosingObject: true,
formatProvider: _formatProvider,
renderMessage: true);
var delimStart = "{";
foreach (var logEvent in events)
{
payload.Write(delimStart);
formatter.Format(logEvent, payload);
payload.Write(
",\"UtcTimestamp\":\"{0:u}\"}}",
logEvent.Timestamp.ToUniversalTime().DateTime);
delimStart = ",{";
}
payload.Write("]}");
var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");
var result = await _httpClient.PostAsync(BulkUploadResource, content);
if (!result.IsSuccessStatusCode)
throw new LoggingFailedException(string.Format("Received failed result {0} when posting events to CouchDB", result.StatusCode));
}
/// <summary>
/// Emit a batch of log events, running asynchronously.
/// </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 async Task EmitBatchAsync(IEnumerable<LogEvent> events)
{
var payload = new StringWriter();
payload.Write("{\"docs\":[");
var formatter = new JsonFormatter(true);
var delimStart = "{";
foreach (var logEvent in events)
{
payload.Write(delimStart);
formatter.Format(logEvent, payload);
var renderedMessage = logEvent.RenderMessage(_formatProvider);
payload.Write(",\"UtcTimestamp\":\"{0:u}\",\"RenderedMessage\":\"{1}\"}}",
logEvent.Timestamp.ToUniversalTime().DateTime,
JsonFormatter.Escape(renderedMessage));
delimStart = ",{";
}
payload.Write("]}");
var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");
var result = await _httpClient.PostAsync(BulkUploadResource, content);
if (!result.IsSuccessStatusCode)
SelfLog.WriteLine("Received failed result {0}: {1}", result.StatusCode, result.Content.ReadAsStringAsync().Result);
}
static dynamic FormatEvent(LogEvent e)
{
var j = new JsonFormatter();
var f = new StringWriter();
j.Format(e, f);
var d = JsonConvert.DeserializeObject<dynamic>(f.ToString());
return d;
}
public CustomLogJsonFormatter(bool appendNewline = true, bool omitEnclosingObject = false)
{
_appendNewline = appendNewline;
_omitEnclosingObject = omitEnclosingObject;
_baseJsonFormatter = new JsonFormatter(omitEnclosingObject: omitEnclosingObject);
}
/// <summary>
/// Construct a sink posting to the specified database.
/// </summary>
/// <param name="connectionString">Connection string to access the database.</param>
/// <param name="tableName">Name of the table to store the data in.</param>
/// <param name="includeProperties">Specifies if the properties need to be saved as well.</param>
/// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
/// <param name="period">The time to wait between checking for event batches.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="storeTimestampInUtc">Store Timestamp In UTC</param>
/// <param name="additionalDataColumns">Additional columns for data storage.</param>
/// <param name="autoCreateSqlTable">Create log table with the provided name on destination sql server.</param>
/// <param name="excludeAdditionalProperties">Exclude properties from the Properties column if they are being saved to additional columns.</param>
/// <param name="storeLogEvent">Save the entire log event to the LogEvent column (nvarchar) as JSON.</param>
public MSSqlServerSink(
string connectionString,
string tableName,
bool includeProperties,
int batchPostingLimit,
TimeSpan period,
IFormatProvider formatProvider,
bool storeTimestampInUtc,
DataColumn[] additionalDataColumns = null,
bool autoCreateSqlTable = false,
bool excludeAdditionalProperties = false,
bool storeLogEvent = false
)
: base(batchPostingLimit, period)
{
if (string.IsNullOrWhiteSpace(connectionString))
throw new ArgumentNullException("connectionString");
if (string.IsNullOrWhiteSpace(tableName))
throw new ArgumentNullException("tableName");
_connectionString = connectionString;
_tableName = tableName;
_includeProperties = includeProperties;
_formatProvider = formatProvider;
_storeTimestampInUtc = storeTimestampInUtc;
_additionalDataColumns = additionalDataColumns;
if (_additionalDataColumns != null)
_additionalDataColumnNames = new HashSet<string>(_additionalDataColumns.Select(c => c.ColumnName), StringComparer.OrdinalIgnoreCase);
_excludeAdditionalProperties = excludeAdditionalProperties;
_storeLogEvent = storeLogEvent;
if (_storeLogEvent)
_jsonFormatter = new JsonFormatter(formatProvider: formatProvider);
// Prepare the data table
_eventsTable = CreateDataTable();
if (autoCreateSqlTable)
{
try
{
SqlTableCreator tableCreator = new SqlTableCreator(connectionString);
tableCreator.CreateTable(_eventsTable);
}
catch (Exception ex)
{
SelfLog.WriteLine("Exception {0} caught while creating table {1} to the database specified in the Connection string.", (object)ex, (object)tableName);
}
}
}
