public ContainerBuilder WithFakeCommonProperties(int managedThreadId = 0, string machineName = null, int processId = 0, string processName = null, string threadName = null, string appDomainName = null) { _selfLogOutput = new StringWriter(); SelfLog.Enable(TextWriter.Synchronized(_selfLogOutput)); var mock = new Mock <ICommonProperties>(); mock.SetupGet(m => m.ManagedThreadId).Returns(managedThreadId); mock.SetupGet(m => m.MachineName).Returns(machineName); mock.SetupGet(m => m.ProcessId).Returns(processId); mock.SetupGet(m => m.ProcessName).Returns(processName); mock.SetupGet(m => m.ThreadName).Returns(threadName); mock.SetupGet(m => m.AppDomainName).Returns(appDomainName); Container.RegisterInstance(mock.Object); return(this); }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .UseSerilog((hostingContext, loggerConfiguration) => { SelfLog.Enable(Console.WriteLine); // No DI here, so get option from Environment temporary. // see: https://github.com/serilog/serilog-aspnetcore/issues/169 loggerConfiguration .ReadFrom.Configuration(hostingContext.Configuration) .Enrich.FromLogContext() //.Enrich.WithCorrelationIdHeader("TraceId") ; }) .ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup <Startup>(); });
private static IPAddress ResolveIP(string uri) { try { var ipHostEntry = Dns.GetHostEntryAsync(uri).Result; if (!ipHostEntry.AddressList.Any()) { return(null); } return(ipHostEntry.AddressList.First()); } catch (Exception) { SelfLog.WriteLine("Could not resolve " + uri); return(null); } }
private bool _disposedValue; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (_disposedValue) { return; } if (disposing) { FlushAndCloseEventHandlers(); _semaphoreSlim.Dispose(); SelfLog.WriteLine("Sink halted successfully."); } _disposedValue = true; }
private static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .WriteTo.Kafka( new JsonFormatter(), new KafkaOptions(new List <string> { "kafka:9092" }, "console-example"), new BatchOptions()) .Enrich.FromLogContext() .CreateLogger(); Log.Information("Hello World!"); SelfLog.Enable(message => System.Console.WriteLine(message)); Log.CloseAndFlush(); }
public static Batch Read(LogEventQueue queue, int batchPostingLimit, long batchSizeLimitBytes) { var batch = new Batch(); var remainingBatchSizeBytes = batchSizeLimitBytes; while (true) { var result = queue.TryDequeue(remainingBatchSizeBytes, out var logEvent); if (result == LogEventQueue.DequeueResult.Ok) { batch.LogEvents.Add(logEvent); remainingBatchSizeBytes -= ByteSize.From(logEvent); // Respect batch posting limit if (batch.LogEvents.Count == batchPostingLimit) { batch.HasReachedLimit = true; break; } } else if (result == LogEventQueue.DequeueResult.MaxSizeViolation) { if (batch.LogEvents.Count == 0) { // This single log event exceeds the batch size limit, let's drop it queue.TryDequeue(long.MaxValue, out var logEventToDrop); SelfLog.WriteLine( "Event exceeds the batch size limit of {0} bytes set for this sink and will be dropped; data: {1}", batchSizeLimitBytes, logEventToDrop); } else { batch.HasReachedLimit = true; break; } } else if (result == LogEventQueue.DequeueResult.QueueEmpty) { break; } } return(batch); }
private async Task PostData(string signature, string dateString, string jsonString) { using (var client = new HttpClient()) { client.DefaultRequestHeaders.Add("Accept", "application/json"); client.DefaultRequestHeaders.Add("Log-Type", _logName); client.DefaultRequestHeaders.Add("Authorization", signature); client.DefaultRequestHeaders.Add("x-ms-date", dateString); client.DefaultRequestHeaders.Add("time-generated-field", ""); var httpContent = new StringContent(jsonString, Encoding.UTF8); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var response = await client.PostAsync(_analyticsUrl, httpContent); SelfLog.WriteLine(response.ReasonPhrase); } }
/// <summary> /// Emit a batch of log events, running asynchronously. /// </summary> /// <param name="events">The events to send to the syslog service</param> public async Task EmitBatchAsync(IEnumerable <LogEvent> events) { foreach (var logEvent in events) { var message = this.formatter.FormatMessage(logEvent); var data = Encoding.UTF8.GetBytes(message); try { await this.client.SendAsync(data, data.Length, this.endpoint).ConfigureAwait(false); } catch (SocketException ex) { SelfLog.WriteLine($"[{nameof(SyslogTcpSink)}] error while sending log event to syslog {this.endpoint.Address}:{this.endpoint.Port} - {ex.Message}\n{ex.StackTrace}"); } } }
private async Task Send(IEnumerable <LogEvent> events) { string allEvents = string.Empty; foreach (var logEvent in events) { var sw = new StringWriter(); _jsonFormatter.Format(logEvent, sw); var serialisedEvent = sw.ToString(); var splunkEvent = new SplunkEvent(serialisedEvent, _source, _sourceType, _host, _index, logEvent.Timestamp.ToEpoch()); allEvents = $"{allEvents}{splunkEvent.Payload}"; } var request = new EventCollectorRequest(_splunkHost, allEvents); var response = await _httpClient.SendAsync(request); 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); } } } }
public string GetConnectionString(string nameOrConnectionString, IConfiguration appConfiguration) { // If there is an `=`, we assume this is a raw connection string not a named value // If there are no `=`, attempt to pull the named value from config if (nameOrConnectionString.IndexOf("=", StringComparison.InvariantCultureIgnoreCase) > -1) { return(nameOrConnectionString); } var cs = appConfiguration?.GetConnectionString(nameOrConnectionString); if (string.IsNullOrEmpty(cs)) { SelfLog.WriteLine("MSSqlServer sink configured value {0} is not found in ConnectionStrings settings and does not appear to be a raw connection string.", nameOrConnectionString); } return(cs); }
private bool WeAreAtEndOfTheFileAndItIsNotLockedByAnotherThread(string file, long nextLineBeginsAtOffset) { try { return(_fileManager.GetFileLengthExclusiveAccess(file) <= nextLineBeginsAtOffset); } catch (IOException ex) { SelfLog.WriteLine("Swallowed I/O exception while testing locked status of {0}", ex, file); } catch (Exception ex) { SelfLog.WriteLine("Unexpected exception while testing locked status of {0}", ex, file); } return(false); }
public static object Simplify(LogEventPropertyValue value) { if (value is ScalarValue scalar) { return(SimplifyScalar(scalar.Value)); } if (value is DictionaryValue dict) { var result = new Dictionary <object, object>(); foreach (var element in dict.Elements) { var key = SimplifyScalar(element.Key.Value); if (result.ContainsKey(key)) { SelfLog.WriteLine("The key {0} is not unique in the provided dictionary after simplification to {1}.", element.Key, key); return(dict.Elements.Select(e => new Dictionary <string, object> { { "Key", SimplifyScalar(e.Key.Value) }, { "Value", Simplify(e.Value) } }) .ToArray()); } result.Add(key, Simplify(element.Value)); } return(result); } if (value is SequenceValue seq) { return(seq.Elements.Select(Simplify).ToArray()); } if (!(value is StructureValue str)) { return(null); } var props = str.Properties.ToDictionary(p => p.Name, p => Simplify(p.Value)); if (str.TypeTag != null) { props["$typeTag"] = str.TypeTag; } return(props); }
static Dictionary <string, LogLevel> GetLevelOverrides(IConfiguration configuration) { var dictionary = new Dictionary <string, LogLevel>(); foreach (IConfigurationSection configurationSection in configuration.GetSection("LogLevel").GetChildren().Where(cfg => cfg.Key != "Default")) { if (!Enum.TryParse <LogLevel>(configurationSection.Value, out var result)) { SelfLog.WriteLine("The level override setting `{0}` for `{1}` is invalid", configurationSection.Value, configurationSection.Key); } else { dictionary[configurationSection.Key] = result; } } return(dictionary); }
public static void Main(string[] args) { SelfLog.Enable(Console.Error); var configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", true, true) .AddUserSecrets(typeof(Program).Assembly) .AddEnvironmentVariables() .Build(); Log.Logger = new LoggerConfiguration() .ReadFrom.Configuration(configuration) .CreateLogger(); CreateHostBuilder(args).Build().Run(); }
protected override async Task EmitBatchAsync(IEnumerable <LogEvent> events) { if (events == null) { return; } int count = 0; try { var logs = new List <dynamic>(); foreach (var ev in events) { count++; var identity = ev.Properties["Identity"].ToString(); identity = identity.Substring(1, identity.Length - 2); var nodeId = ev.Properties["NodeId"].ToString(); nodeId = nodeId.Substring(1, nodeId.Length - 2); var logInfo = new { Exception = ev.Exception?.ToString(), Identity = identity, Level = ev.Level.ToString(), Logged = ev.Timestamp, Message = ev.RenderMessage(), NodeId = nodeId, DateTime = DateTime.Now }; logs.Add(logInfo); } HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, _api); httpRequestMessage.Headers.Add("DotnetSpiderToken", _token); var json = JsonConvert.SerializeObject(logs); httpRequestMessage.Content = new StringContent(json, Encoding.UTF8, "application/json"); await HttpClientDownloader.Default.SendAsync(httpRequestMessage); } catch (Exception ex) { SelfLog.WriteLine("Unable to write {0} log events to the database due to following error: {1}", count, ex.Message); } }
protected void SendMessage(string token, string chatId, TelegramMessage message) { SelfLog.WriteLine($"Trying to send message to chatId '{chatId}': '{message}'."); var telegramClient = TelegramClientFactory.CreateClient(token, proxy); var sendMessageTask = telegramClient.PostAsync(message: message, chatId: chatId); Task.WaitAll(sendMessageTask); var sendMessageResult = sendMessageTask.Result; if (sendMessageResult != null) { SelfLog.WriteLine($"Message sent to chatId '{chatId}': '{sendMessageResult.StatusCode}'."); } }
private static Dictionary <string, LogLevel> GetLevelOverrides(IConfiguration configuration) { var levelOverrides = new Dictionary <string, LogLevel>(); foreach (var overr in configuration.GetSection("LogLevel").GetChildren().Where(cfg => cfg.Key != "Default")) { if (!Enum.TryParse(overr.Value, out LogLevel value)) { SelfLog.WriteLine("The level override setting `{0}` for `{1}` is invalid", overr.Value, overr.Key); continue; } levelOverrides[overr.Key] = value; } return(levelOverrides); }
public override void Flush() { EnsureNotDisposed(); base.Flush(); var currentNotepadProcess = _currentNotepadProcess; var targetNotepadProcess = _notepadProcessFinderFunc(); if (currentNotepadProcess is null || targetNotepadProcess is null || currentNotepadProcess.Id != targetNotepadProcess.Id) { _currentNotepadProcess = currentNotepadProcess = targetNotepadProcess; _currentNotepadEditorHandle = IntPtr.Zero; if (currentNotepadProcess is null || currentNotepadProcess.HasExited) { // No instances of Notepad found... Nothing to do return; } var notepadWindowHandle = currentNotepadProcess.MainWindowHandle; var notepadEditorHandle = User32.FindWindowEx(notepadWindowHandle, IntPtr.Zero, "Edit", null); if (notepadEditorHandle == IntPtr.Zero) { SelfLog.WriteLine($"Unable to access a Notepad Editor on process {currentNotepadProcess.ProcessName} ({currentNotepadProcess.Id})"); return; } _currentNotepadEditorHandle = notepadEditorHandle; } // Get how many characters are in the Notepad editor already var textLength = User32.SendMessage(_currentNotepadEditorHandle, User32.WM_GETTEXTLENGTH, IntPtr.Zero, IntPtr.Zero); // Set the caret position to the end of the text User32.SendMessage(_currentNotepadEditorHandle, User32.EM_SETSEL, (IntPtr)textLength, (IntPtr)textLength); var buffer = base.GetStringBuilder(); var message = buffer.ToString(); // Write the log message to Notepad User32.SendMessage(_currentNotepadEditorHandle, User32.EM_REPLACESEL, (IntPtr)1, message); buffer.Clear(); }
public void WhenWaitingShouldCancel_OnDispose() { var wasCalled = false; var writtenToSelfLog = false; SelfLog.Enable(_ => writtenToSelfLog = true); using (var timer = new PortableTimer(async delegate { await Task.Delay(50); wasCalled = true; })) { timer.Start(TimeSpan.FromMilliseconds(20)); } Thread.Sleep(100); Assert.False(wasCalled, "tick handler was called"); Assert.False(writtenToSelfLog, "message was written to SelfLog"); }
public LoggingModule( IConfiguration configuration, IServiceCollection services) { SelfLog.Enable(Console.WriteLine); Log.Logger = new LoggerConfiguration() .ReadFrom.Configuration(configuration) .Enrich.FromLogContext() .Enrich.WithMachineName() .Enrich.WithThreadId() .Enrich.WithEnvironmentUserName() .Destructure.JsonNetTypes() .CreateLogger(); services.AddLogging(l => l.AddSerilog(Log.Logger)); }
static async Task Main(string[] args) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Information() .MinimumLevel.Override("Microsoft", LogEventLevel.Warning) .Enrich.FromLogContext() .WriteTo.InfluxDB("Test App" // Application Name , "Test Instance" // Instance or Environment Name , "http://localhost:8086" // InfluxDb Address , "_internal") // InfluxDb Database Name) .CreateLogger(); await BuildCommandLine() .UseHost(_ => Host.CreateDefaultBuilder(), host => { SelfLog.Enable(System.Console.Out); host.UseSerilog((hostingContext, loggerConfiguration) => { // could be configured here, but prefer earlier configuration }) .ConfigureAppConfiguration((hostingContext, config) => { // The next 2 lines commented out as they are added by default in the correct order // for more control first call config.Sources.Clear(); //config.AddJsonFile("appsettings.json", optional: true); //config.AddEnvironmentVariables(); config.AddUserSecrets <Program>(); var configuration = config.Build(); if (args is null) { //add some defaults from config var number = configuration.GetSection("Sample").GetValue <int>("number"); args = new string[0]; args = args.Append($"-n {number}").ToArray(); } config.AddCommandLine(args); }) .ConfigureServices((hostContext, services) => { services.AddOptions <SampleOptions>() .Bind(hostContext.Configuration.GetSection(SampleOptions.Sample)); }); })
bool TryAcquireMutex() { try { if (!_mutex.WaitOne(MutexWaitTimeout)) { SelfLog.WriteLine("Shared file mutex could not be acquired within {0} ms", MutexWaitTimeout); return(false); } } catch (AbandonedMutexException) { SelfLog.WriteLine("Inherited shared file mutex after abandonment by another process"); } return(true); }
public void CarriesMessageTemplateProperties() { var selfLog = new StringWriter(); SelfLog.Enable(selfLog); var(logger, sink) = SetUp(LogLevel.Trace); logger.LogInformation("Hello, {Recipient}", "World"); Assert.True(sink.Writes[0].Properties.ContainsKey("Recipient")); Assert.Equal("\"World\"", sink.Writes[0].Properties["Recipient"].ToString()); Assert.Equal("Hello, {Recipient}", sink.Writes[0].MessageTemplate.Text); SelfLog.Disable(); Assert.Empty(selfLog.ToString()); }
protected void SendMessage(string token, string chatId, TelegramMessage message) { SelfLog.WriteLine($"Trying to send message to chatId '{chatId}': '{message}'."); var client = new TelegramBot(botToken: token, timeoutSeconds: 5); var sendMessageTask = client.PostAsync(message: message, chatId: chatId); Task.WaitAll(sendMessageTask); var sendMessageResult = sendMessageTask.Result; if (sendMessageResult != null) { SelfLog.WriteLine($"Message sent to chatId '{chatId}': '{sendMessageResult.StatusCode}'."); } }
IEnumerable <LogEventProperty> ConstructPositionalProperties(MessageTemplate template, object[] messageTemplateParameters) { var positionalProperties = template.PositionalProperties; if (positionalProperties.Length != messageTemplateParameters.Length) { SelfLog.WriteLine("Positional property count does not match parameter count: {0}", template); } var result = new LogEventProperty[messageTemplateParameters.Length]; foreach (var property in positionalProperties) { int position; if (property.TryGetPositionalValue(out position)) { if (position < 0 || position >= messageTemplateParameters.Length) { SelfLog.WriteLine("Unassigned positional value {0} in: {1}", position, template); } else { result[position] = ConstructProperty(property, messageTemplateParameters[position]); } } } var next = 0; for (var i = 0; i < result.Length; ++i) { if (result[i] != null) { result[next] = result[i]; ++next; } } if (next != result.Length) { Array.Resize(ref result, next); } return(result); }
async void OnTick() { try { lock (_stateLock) { if (_disposed) { return; } // There's a little bit of raciness here, but it's needed to support the // current API, which allows the tick handler to reenter and set the next interval. if (_running) { Monitor.Wait(_stateLock); if (_disposed) { return; } } _running = true; } if (!_cancel.Token.IsCancellationRequested) { await _onTick(_cancel.Token); } } catch (OperationCanceledException tcx) { SelfLog.WriteLine("The timer was canceled during invocation: {0}", tcx); } finally { lock (_stateLock) { _running = false; Monitor.PulseAll(_stateLock); } } }
public LogEventPropertyValue CreatePropertyValue(object value, Destructuring destructuring) { try { return(CreatePropertyValue(value, destructuring, 1)); } catch (Exception ex) { SelfLog.WriteLine("Exception caught while converting property value: {0}", ex); if (_propagateExceptions) { throw; } return(new ScalarValue("Capturing the property value threw an exception: " + ex.GetType().Name)); } }
/// <summary> /// Emit a batch of log events. /// </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 <Events.LogEvent> events) { // This sink doesn't actually write batches, instead only using // the PeriodicBatching infrastructure to manage background work. // Probably needs modification. foreach (var logEvent in events) { var key = Guid.NewGuid().ToString(); var result = _couchbaseClient.StoreJson(Enyim.Caching.Memcached.StoreMode.Add, key, new LogEvent(logEvent, logEvent.RenderMessage(_formatProvider))); if (!result) { SelfLog.WriteLine("Failed to store value"); } } }
private static IDictionary <string, string> LogEventPropertiesToNewRelicExceptionProperties(LogEvent logEvent) { var properties = new Dictionary <string, string>(); foreach (var source in logEvent.Properties.Where(p => p.Value != null)) { var safeKey = source.Key.ToNewRelicSafeString(); if (properties.ContainsKey(safeKey)) { SelfLog.WriteLine("Transformed property {0} from event with message template {1} is already in dictionary", safeKey, logEvent.MessageTemplate.Text); continue; } properties.Add(safeKey, source.Value.ToString()); } return(properties); }
protected void SendMessageWithWebHooks(string webhookUri, string message) { SelfLog.WriteLine("Trying to send message to webhook '{0}': '{1}'.", webhookUri, message); if (!string.IsNullOrWhiteSpace(message)) { var slackClient = new SlackClient(webhookUri, 25); var sendMessageTask = slackClient.PostAsync(message); Task.WaitAll(sendMessageTask); var sendMessageResult = sendMessageTask.Result; if (sendMessageResult != null) { SelfLog.WriteLine("Message sent to webhook '{0}': '{1}'.", webhookUri, sendMessageResult.StatusCode); } } }