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); } } }