public void WriteLog(ICorrelation correlation, LogEventLevel eventLevel, Exception exception, string formatMessage, params object[] args) { if (log == null) { log = loggerRepository.GetLogger(sourceType); } if (eventLevel == LogEventLevel.Verbose && !log.IsDebugEnabled) { return; } if (args != null && args.Length != 0) { formatMessage = string.Format(formatMessage, args); } log4net.Core.ILogger logger = log.Logger; LoggingEvent logEvent = new LoggingEvent(sourceType, logger.Repository, logger.Name, MapEventLevel(eventLevel), formatMessage, exception); if (correlation != null) { logEvent.Properties["CallerId"] = correlation.CallerId; logEvent.Properties["CorrelationId"] = correlation.CorrelationId; } logger.Log(logEvent); }
/// <summary> /// 获取自定义属性的值 /// </summary> /// <param name="property"></param> /// <returns></returns> private object LookupProperty(string property, log4net.Core.LoggingEvent loggingEvent) { object propertyValue = string.Empty; propertyValue = loggingEvent.Properties[property]; return(propertyValue); }
protected override void Append(LoggingEvent loggingEvent) { var writer = new StringWriter(CultureInfo.InvariantCulture); Layout.Format(writer, loggingEvent); Message = writer.ToString(); Level = loggingEvent.Level; }
[Test] public void TestSize2() { CyclicBuffer cb = new CyclicBuffer(2); Assert.AreEqual(0, cb.Length, "Empty Buffer should have length 0"); Assert.AreEqual(2, cb.MaxSize, "Buffer should have max size 2"); LoggingEvent event1 = new LoggingEvent(null, null, null, null, null, null); LoggingEvent event2 = new LoggingEvent(null, null, null, null, null, null); LoggingEvent event3 = new LoggingEvent(null, null, null, null, null, null); LoggingEvent discardedEvent = null; discardedEvent = cb.Append(event1); Assert.IsNull(discardedEvent, "No event should be discarded after append 1"); discardedEvent = cb.Append(event2); Assert.IsNull(discardedEvent, "No event should be discarded after append 2"); discardedEvent = cb.Append(event3); Assert.AreSame(event1, discardedEvent, "Expect event1 to now be discarded"); discardedEvent = cb.PopOldest(); Assert.AreSame(event2, discardedEvent, "Expect event2 to now be discarded"); LoggingEvent[] discardedEvents = cb.PopAll(); Assert.AreEqual(1, discardedEvents.Length, "Poped events length should be 1"); Assert.AreSame(event3, discardedEvents[0], "Expect event3 to now be popped"); Assert.AreEqual(0, cb.Length, "Buffer should be back to length 0"); Assert.AreEqual(2, cb.MaxSize, "Buffer should really really still have max size 2"); }
protected override void Append(LoggingEvent loggingEvent) { Level level = loggingEvent.Level; string message = RenderLoggingEvent(loggingEvent); if (level >= Level.Fatal) { Trace.Write(message, "Critical"); } else if (level >= Level.Error) { Trace.TraceError(message); } else if (level >= Level.Warn) { Trace.TraceWarning(message); } else if (level >= Level.Info) { Trace.TraceInformation(message); } else { Trace.Write(message); } if (ImmediateFlush) { Trace.Flush(); } }
protected override void Append(LoggingEvent loggingEvent) { try { Log _log = new Log(); string message = RenderLoggingEvent(loggingEvent); string maquina = Dns.GetHostName(); IPAddress[] ip = Dns.GetHostAddresses(maquina); _log.IdCorrelacao = LogicalThreadContext.Properties["CorrelationId"].ToString(); _log.DataHora = DateTime.Now; _log.Ip = ip[1].ToString(); _log.Maquina = maquina; _log.Usuario = loggingEvent.Identity; _log.SistemaOrigem = _sourcesystem; _log.Tipo = loggingEvent.Level.Name; _log.Dados = message; //Salva Fila Assincrono if (_salvar == null) { _salvar = new SaveAsynchronous(ConsumeAsynchronous, "ThreadLog", System.Threading.ThreadPriority.Normal, true); } _salvar.Save(_log); } catch (Exception ex) { //TODO: Erro na gravacao da fila??? } }
/// <summary> /// Convert the pattern to the rendered message /// </summary> /// <param name="writer"><see cref="T:System.IO.TextWriter" /> that will receive the formatted result.</param> /// <param name="loggingEvent">the event being logged</param> /// <remarks> /// Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)" /> to the precision /// specified by the <see cref="P:log4net.Util.PatternConverter.Option" /> property. /// </remarks> protected override void Convert(TextWriter writer, LoggingEvent loggingEvent) { string text = this.GetFullyQualifiedName(loggingEvent); if (this.m_precision <= 0 || text == null || text.Length < 2) { writer.Write(text); } else { int num = text.Length; string str = string.Empty; if (text.EndsWith(".")) { str = "."; text = text.Substring(0, num - 1); num--; } int num2 = text.LastIndexOf("."); int num3 = 1; while (num2 > 0 && num3 < this.m_precision) { num2 = text.LastIndexOf('.', num2 - 1); num3++; } if (num2 == -1) { writer.Write(text + str); } else { writer.Write(text.Substring(num2 + 1, num - num2 - 1) + str); } } }
protected override void Append(LoggingEvent loggingEvent) { Debug.WriteLine("ClassOutline.Logging:" + loggingEvent.RenderedMessage); dynamic tmp = null; if (loggingEvent.ExceptionObject != null) { tmp = new { Message = loggingEvent.RenderedMessage, }; } else { tmp = new { Message = loggingEvent.RenderedMessage, Exception = loggingEvent.ExceptionObject }; } var errorMessage = JsonConvert.SerializeObject(tmp); ReportError(errorMessage); }
/// <summary> /// Write the ASP.Net Cache item to the output /// </summary> /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> /// <param name="loggingEvent">The <see cref="LoggingEvent" /> on which the pattern converter should be executed.</param> /// <param name="httpContext">The <see cref="HttpContext" /> under which the ASP.Net request is running.</param> /// <remarks> /// <para> /// Writes out the value of a named property. The property name /// should be set in the <see cref="log4net.Util.PatternConverter.Option"/> /// property. /// </para> /// </remarks> protected override void Convert(TextWriter writer, LoggingEvent loggingEvent, HttpContext httpContext) { HttpRequest request = null; try { request = httpContext.Request; } catch (HttpException) { // likely a case of running in IIS integrated mode // when inside an Application_Start event. // treat it like a case of the Request // property returning null } if (request != null) { if (Option != null) { WriteObject(writer, loggingEvent.Repository, httpContext.Request.Params[Option]); } else { WriteObject(writer, loggingEvent.Repository, httpContext.Request.Params); } } else { writer.Write(SystemInfo.NotAvailableText); } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { //loggingEvent.Fix = FixFlags.ThreadName; //_logEvents.Add(loggingEvent); Console.WriteLine(loggingEvent.RenderedMessage); }
protected override void Append(LoggingEvent loggingEvent) { try { var config = ObjectFactory.GetInstance<IConfigRepository>(); if (!config.Get("LogToDatabase", false)) return; using (var uow = ObjectFactory.GetInstance<IUnitOfWork>()) { var logDO = new LogDO { Level = loggingEvent.Level.ToString(), Message = loggingEvent.RenderedMessage, Name = loggingEvent.LoggerName }; uow.LogRepository.Add(logDO); uow.SaveChanges(); } } catch (Exception) { //No reason to throw an error on our logging system... } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { switch (loggingEvent.Level.Name.ToLower()) { case "alert": case "critical": case "emergency": case "error": case "fatal": case "severe": _taskLoggingHelper.LogError(loggingEvent.RenderedMessage); break; case "warn": _taskLoggingHelper.LogWarning(loggingEvent.RenderedMessage); break; case "info": case "notice": _taskLoggingHelper.LogMessage(MessageImportance.Normal, loggingEvent.RenderedMessage); break; case "debug": case "fine": case "finer": case "finest": case "trace": case "verbose": default: _taskLoggingHelper.LogMessage(MessageImportance.Low, loggingEvent.RenderedMessage); break; } }
public void ConvertTestNoException() { var level = Level.Debug; var testId = "9001"; var resultString = "[MW@55555 MessageId=\"" + testId + "\" EventSeverity=\"" + level.DisplayName + "\"]"; var writer = new StreamWriter(new MemoryStream()); var converter = new StructuredDataConverter(); var props = new PropertiesDictionary(); props["MessageId"] = testId; props["log4net:StructuredDataPrefix"] = "MW@55555"; // Additional tests using stack data is prevented as the converter class only pulls from LoggingEvent.GetProperties() // The data behind this method is setup by log4net itself so testing stack usage would not really apply properly here //ThreadContext.Stacks["foo"].Push("bar"); var evt = new LoggingEvent(new LoggingEventData() { Properties = props, Level = level }); converter.Format(writer, evt); writer.Flush(); var result = TestUtilities.GetStringFromStream(writer.BaseStream); Assert.AreEqual(resultString, result); }
/// <summary> /// Append on on all attached appenders. /// </summary> /// <param name="loggingEvent">The event being logged.</param> /// <returns>The number of appenders called.</returns> /// <remarks> /// <para> /// Calls the <see cref="IAppender.DoAppend" /> method on all /// attached appenders. /// </para> /// </remarks> public int AppendLoopOnAppenders(LoggingEvent loggingEvent) { if (loggingEvent == null) { throw new ArgumentNullException("loggingEvent"); } // m_appenderList is null when empty if (m_appenderList == null) { return 0; } if (m_appenderArray == null) { m_appenderArray = m_appenderList.ToArray(); } foreach(IAppender appender in m_appenderArray) { try { appender.DoAppend(loggingEvent); } catch(Exception ex) { LogLog.Error("AppenderAttachedImpl: Failed to append to appender [" + appender.Name + "]", ex); } } return m_appenderList.Count; }
protected override void Convert(TextWriter writer, LoggingEvent loggingEvent) { var text = GetFullyQualifiedName(loggingEvent); if (m_precision == 0 || text == null || text.Length < 2) { writer.Write(text); return; } var elements = text .Trim() .Trim(new[] { '.' }) .Split(new[] { '.' }); if (m_precision > 0) { writer.Write( string.Join("/", elements .Reverse() .Take(m_precision) .Reverse() ) ); return; } writer.Write( string.Join("/", elements .Take(elements.Count() + m_precision) ) ); }
public override void Format(TextWriter writer, LoggingEvent loggingEvent) { var ctw = new CsvTextWriter(writer); // write the starting quote for the first field ctw.WriteQuote(); base.Format(ctw, loggingEvent); }
protected override void Append(LoggingEvent le) { if (m_console != null) m_console.LockOutput(); string loggingMessage = RenderLoggingEvent(le); try { if (m_console != null) { m_console.Output(loggingMessage, le.Level); } else { if (!loggingMessage.EndsWith("\n")) System.Console.WriteLine(loggingMessage); else System.Console.Write(loggingMessage); } } catch (Exception e) { System.Console.WriteLine("Couldn't write out log message: {0}", e); } finally { if (m_console != null) m_console.UnlockOutput(); } }
protected override void Append(LoggingEvent le) { if (OnLogLine != null && le.Level != Level.Debug) { OnLogLine(this, new LogEventArgs(string.Format("{0} [{1}] {2}\n", le.TimeStamp, le.Level, le.MessageObject))); } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { try { string asm, version; var app = SAPServiceFactory.ApplicationFactory(); GetAsmName(loggingEvent.LocationInformation.ClassName, out asm, out version); if (app != null) { UIAPILog(loggingEvent, app, asm); } if (B1DAO != null && loggingEvent.Level >= Level.Error) { DIAPILog(loggingEvent, asm, version); } } catch (COMException c) { // do nothing, SAP is closed, ignore. } catch (Exception e) { System.Windows.Forms.MessageBox.Show(String.Format("{0}\n\n{1}", e.Message, e.StackTrace)); // Cannot log, can't do anything. Just prevent app crash. } }
/// <summary> /// Append a logging event to the log /// </summary> /// <param name="loggingEvent">The logging event</param> protected override void Append(LoggingEvent loggingEvent) { if (null != m_logger && (loggingEvent.LoggerName == "NHibernate.SQL")) { m_logger.WriteLine(loggingEvent.MessageObject); } }
/// <summary> /// This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. /// </summary> /// <param name="loggingEvent">The event to log.</param> /// <remarks> /// <para> /// Writes the event to the console. /// </para> /// <para> /// The format of the output will depend on the appender's layout. /// </para> /// </remarks> protected override void Append(log4net.Core.LoggingEvent loggingEvent) { string loggingMessage = RenderLoggingEvent(loggingEvent); // see if there is a specified lookup. LevelColors levelColors = m_levelMapping.Lookup(loggingEvent.Level) as LevelColors; if (levelColors != null) { // Prepend the Ansi Color code loggingMessage = levelColors.CombinedColor + loggingMessage; } // on most terminals there are weird effects if we don't clear the background color // before the new line. This checks to see if it ends with a newline, and if // so, inserts the clear codes before the newline, otherwise the clear codes // are inserted afterwards. if (loggingMessage.Length > 1) { if (loggingMessage.EndsWith("\r\n") || loggingMessage.EndsWith("\n\r")) { loggingMessage = loggingMessage.Insert(loggingMessage.Length - 2, PostEventCodes); } else if (loggingMessage.EndsWith("\n") || loggingMessage.EndsWith("\r")) { loggingMessage = loggingMessage.Insert(loggingMessage.Length - 1, PostEventCodes); } else { loggingMessage = loggingMessage + PostEventCodes; } } else { if (loggingMessage[0] == '\n' || loggingMessage[0] == '\r') { loggingMessage = PostEventCodes + loggingMessage; } else { loggingMessage = loggingMessage + PostEventCodes; } } #if NETCF_1_0 // Write to the output stream Console.Write(loggingMessage); #else if (m_writeToErrorStream) { // Write to the error stream Console.Error.Write(loggingMessage); } else { // Write to the output stream Console.Write(loggingMessage); } #endif }
protected override void SendBuffer(LoggingEvent[] events) { BeginAsyncSend(); if (TryAsyncSend(events)) return; EndAsyncSend(); HandleError("Failed to async send logging events in SendBuffer"); }
/// <summary> /// 查找日志对象的属性值 /// </summary> /// <param name="property">属性</param> /// <param name="loggingEvent">日志事件</param> private object LookupProperty( string property, LoggingEvent loggingEvent ) { object propertyValue = string.Empty; PropertyInfo propertyInfo = loggingEvent.MessageObject.GetType().GetProperty( property ); if ( propertyInfo != null ) propertyValue = propertyInfo.GetValue( loggingEvent.MessageObject, null ); return propertyValue; }
protected override void Append(LoggingEvent loggingEvent) { if (FilterEvent(loggingEvent)) { _pendingTasks.Enqueue(loggingEvent); } }
override protected void Append(LoggingEvent loggingEvent) { if (m_queue == null) { if (MessageQueue.Exists(m_queueName)) { m_queue = new MessageQueue(m_queueName); } else { ErrorHandler.Error("Queue ["+m_queueName+"] not found"); } } if (m_queue != null) { Message message = new Message(); message.Label = RenderLabel(loggingEvent); using(System.IO.MemoryStream stream = new System.IO.MemoryStream()) { System.IO.StreamWriter writer = new System.IO.StreamWriter(stream, new System.Text.UTF8Encoding(false, true)); base.RenderLoggingEvent(writer, loggingEvent); writer.Flush(); stream.Position = 0; message.BodyStream = stream; m_queue.Send(message); } } }
private void AddProperties(object logSource, Exception exception, LoggingEvent loggingEvent) { loggingEvent.Properties["UserName"] = GetUserName(); try { ContextProperties contextProperties = _contextService.GetContextProperties(); if (contextProperties != null) { try { loggingEvent.Properties["UserAgent"] = contextProperties.UserAgent; loggingEvent.Properties["RemoteHost"] = contextProperties.RemoteHost; loggingEvent.Properties["Path"] = contextProperties.Path; loggingEvent.Properties["Query"] = contextProperties.Query; loggingEvent.Properties["RefererUrl"] = contextProperties.Referrer; loggingEvent.Properties["RequestId"] = contextProperties.RequestId; loggingEvent.Properties["SessionId"] = contextProperties.SessionId; } catch (Exception) { } } loggingEvent.Properties["ExceptionType"] = exception == null ? "" : exception.GetType().ToString(); loggingEvent.Properties["ExceptionMessage"] = exception == null ? "" : exception.Message; loggingEvent.Properties["ExceptionStackTrace"] = exception == null ? "" : exception.StackTrace; loggingEvent.Properties["LogSource"] = logSource.GetType().ToString(); } catch (Exception ex) { var type = typeof(Log4NetLoggingService); var logger = LogManager.GetLogger(type); logger.Logger.Log(type, Level.Fatal, "Exception when extracting properties: " + ex.Message, ex); } }
public override void Format(TextWriter textWriter, LoggingEvent loggingEvent) { base.Format(textWriter, loggingEvent); if (loggingEvent.ExceptionObject != null) textWriter.Write(Environment.StackTrace); }
protected void ParseBasicFields(LoggingEvent sourceLoggingEvent, Dictionary<string, object> resultDictionary) { resultDictionary["@timestamp"] = sourceLoggingEvent.TimeStamp.ToUniversalTime().ToString("O"); resultDictionary["LoggerName"] = sourceLoggingEvent.LoggerName; resultDictionary["HostName"] = MachineName; if (FixedFields.ContainsFlag(FixFlags.ThreadName)) { resultDictionary["ThreadName"] = sourceLoggingEvent.ThreadName; } if (FixedFields.ContainsFlag(FixFlags.Domain)) { resultDictionary["AppDomain"] = sourceLoggingEvent.Domain; } if (sourceLoggingEvent.Level != null) { resultDictionary["Level"] = sourceLoggingEvent.Level.DisplayName; } if (FixedFields.ContainsFlag(FixFlags.Identity)) { resultDictionary["Identity"] = sourceLoggingEvent.Identity; } if (FixedFields.ContainsFlag(FixFlags.UserName)) { resultDictionary["UserName"] = sourceLoggingEvent.UserName; } }
public void ConvertTestWithExceptionObject() { var level = Level.Debug; var writer = new StreamWriter(new MemoryStream()); var converter = new StructuredDataConverter(); Exception exception = null; try { throw new Exception("test exception message"); } catch (Exception ex) { exception = ex; } ILoggerRepository logRepository = Substitute.For<ILoggerRepository>(); var evt = new LoggingEvent(typeof(StructuredDataConverterTests), logRepository, "test logger", level, "test message", exception); evt.Properties["log4net:StructuredDataPrefix"] = "TEST@12345"; evt.Properties["log4net:syslog-exception-log"] = "file://some-log-file/who/cares"; converter.Format(writer, evt); writer.Flush(); var result = TestUtilities.GetStringFromStream(writer.BaseStream); Assert.IsTrue(Regex.IsMatch(result, "\\[TEST@12345 EventSeverity=\"DEBUG\" ExceptionSource=\"syslog4net\\.Tests\" ExceptionType=\"System\\.Exception\" ExceptionMessage=\"test exception message\" ExceptionMethodName=\"Void syslog4net\\.Tests\\.Converters\\.StructuredDataConverterTests\\.ConvertTestWithExceptionObject\\(\\)\" ExceptionFileName=\".*?StructuredDataConverterTests\\.cs\" ExceptionLineNumber=\"\\d+\" EventLog=\"file://some-log-file/who/cares\"\\]")); }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { if (_textBox == null) { if (String.IsNullOrEmpty(FormName) || String.IsNullOrEmpty(TextBoxName)) { return; } Form form = Application.OpenForms[FormName]; if (form == null) { return; } _textBox = (TextBox)FindControlRecursive(form, TextBoxName); if (_textBox == null) { return; } form.FormClosing += (s, e) => _textBox = null; } _textBox.BeginInvoke((MethodInvoker) delegate { _textBox.AppendText(RenderLoggingEvent(loggingEvent)); }); }
override protected void Append(LoggingEvent loggingEvent) { object messageObject = loggingEvent.MessageObject; if (messageObject != null && !(messageObject is string)) { Type messageType = messageObject.GetType(); if (m_expandProperties) { // Get all public instance properties foreach(PropertyInfo propertyInfo in messageType.GetProperties(BindingFlags.Instance | BindingFlags.Public)) { if (propertyInfo.CanRead) { loggingEvent.Properties[propertyInfo.Name] = propertyInfo.GetValue(messageObject, null); } } } if (m_expandFields) { // Get all public instance fields foreach(FieldInfo fieldInfo in messageType.GetFields(BindingFlags.Instance | BindingFlags.Public)) { loggingEvent.Properties[fieldInfo.Name] = fieldInfo.GetValue(messageObject); } } } // Delegate to base class which will forward base.Append(loggingEvent); }
private LoggingEvent Generate(log4net.Core.Level level, string m) { StackFrame stackFrame = null; System.Reflection.MethodBase method = null; var stackFrames = new StackTrace().GetFrames(); for (int indexFrame = 0; indexFrame < stackFrames.Length; ++indexFrame) { stackFrame = stackFrames[indexFrame]; method = stackFrame.GetMethod(); if (method.DeclaringType != typeof(Log4NetTraceListener) && method.Name != "TraceInternals") { break; } } var result = new log4net.Core.LoggingEvent(method.ReflectedType, _repository, new LoggingEventData() { Level = level, Message = m, LoggerName = base.Name, LocationInfo = new LocationInfo(GetMethodName(method), method.ToString(), stackFrame.GetFileName(), stackFrame.GetFileLineNumber().ToString()) }, FixFlags.All); return(result); }
public override void Format(TextWriter writer, LoggingEvent loggingEvent) { // check arguments if (loggingEvent == null) return; if (loggingEvent.MessageObject == null && loggingEvent.RenderedMessage == null) return; // get logger id string loggerId = loggingEvent.GetLoggingEventProperty("__objectId"); // prepare stuff string message = loggingEvent.MessageObject == null ? loggingEvent.RenderedMessage : loggingEvent.MessageObject.ToString(); string info = loggingEvent.GetLoggingEventProperty("__extendedInfo"); if (info != null) { message = message + " " + info; } string[] lines = message.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); string header = string.Format("{0} [{1}] ({3}|{4}|{5}) {2} : ", loggingEvent.TimeStamp.ToString("dd-MM-yyyy hh:mm:ss,fff"), loggingEvent.Level.DisplayName.PadLeft(5, ' '), this.LoggerName(loggingEvent.LoggerName), Thread.CurrentThread.GetHashCode().ToString(CultureInfo.InvariantCulture).PadLeft(2, ' '), loggerId.PadLeft(2), Thread.CurrentPrincipal != null ? Thread.CurrentPrincipal.Identity.Name : "unknown"); const string FILLER = "\t"; for (int i = 0; i < lines.Length; i++) { if (i == 0) { writer.Write(header); } else { writer.Write(FILLER); } writer.WriteLine(lines[i]); } }
protected override async void SendBuffer(LoggingEvent[] events) { if (events == null || !events.Any()) { return; } CheckSession(); var logsEvents = events.Where(e => e != null).Select(e => new Log(e)); await Task.Run(() => { try { Parallel.ForEach(logsEvents, (entry) => { documentSession.Store(entry); }); documentSession.SaveChanges(); } catch (Exception e) { ErrorHandler.Error("Exception while commiting to the Raven DB", e, ErrorCode.GenericFailure); } }); }
protected override void Append(LoggingEvent[] loggingEvents) { foreach (var loggingEvent in loggingEvents) { Append(loggingEvent); } }
protected override void Append(LoggingEvent loggingEvent) { if (string.IsNullOrEmpty(ApiKey)) return; List<string> tags = (Tags ?? "").Split(new[] {","}, StringSplitOptions.RemoveEmptyEntries).ToList(); tags = tags.Concat(EnvironmentalTags).OrderBy(x => x).Distinct().ToList(); string text = RenderLoggingEvent(loggingEvent); string title = BuildTitle(loggingEvent, text); string priority = (loggingEvent.Level >= Level.Error) ? "normal" : "low"; string alertType = GetAlertType(loggingEvent); string aggregateKey = new AggregationKeyCalculator().Calculate(title, loggingEvent.LoggerName); var datadogEvent = new DatadogEvent { Tags = tags, AlertyType = alertType, Priority = priority, Text = text, Title = title, AggregationKey = aggregateKey }; PostEvent(datadogEvent).Wait(); }
/// <summary> /// Send events to Seq. /// </summary> /// <param name="events">The buffered events to send.</param> protected override void SendBuffer(LoggingEvent[] events) { if (ServerUrl == null) return; var payload = new StringWriter(); payload.Write("{\"events\":["); LoggingEventFormatter.ToJson(events, payload); payload.Write("]}"); var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json"); if (!string.IsNullOrWhiteSpace(ApiKey)) content.Headers.Add(ApiKeyHeaderName, ApiKey); var baseUri = ServerUrl; if (!baseUri.EndsWith("/")) baseUri += "/"; using (var httpClient = new HttpClient { BaseAddress = new Uri(baseUri) }) { var result = httpClient.PostAsync(BulkUploadResource, content).Result; if (!result.IsSuccessStatusCode) ErrorHandler.Error(string.Format("Received failed result {0}: {1}", result.StatusCode, result.Content.ReadAsStringAsync().Result)); } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { var logInfo = new LogInfo { Message = loggingEvent.RenderedMessage, LocationInfo = loggingEvent.LocationInformation, Level = loggingEvent.Level, LoggerName = loggingEvent.LoggerName }; hub.Clients.All.addLog(logInfo); }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { // Append the event as usual base.Append(loggingEvent); // Then alert the Updated event that an event has occurred LogEvent?.Invoke(this, new LogEventArgs(loggingEvent)); }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { StringWriter writer = new StringWriter(); this.Layout.Format(writer, loggingEvent); // 已经得到了按照自己设置的格式的日志消息内容了,就是writer.toString()。然后你想把这句话显示在哪都可以了。。我是测试就直接控制台了。 Console.Write(writer.ToString()); }
private void LogInternal(Level logLevel, string message, List <KeyValuePair <string, object> > dicParameters) { if (logLevel != Level.Off) { log4net.Core.LoggingEvent logEntry = CreateLogEntry(logLevel, message, null, dicParameters); Push(logEntry); } }
internal static void LogEventContains(log4net.Core.LoggingEvent logEvent, ulong traceId, ulong spanId) { Assert.Contains(CorrelationIdentifier.TraceIdKey, logEvent.Properties.GetKeys()); Assert.Equal(traceId, ulong.Parse(logEvent.Properties[CorrelationIdentifier.TraceIdKey].ToString())); Assert.Contains(CorrelationIdentifier.SpanIdKey, logEvent.Properties.GetKeys()); Assert.Equal(spanId, ulong.Parse(logEvent.Properties[CorrelationIdentifier.SpanIdKey].ToString())); }
private string GetGelfJsonMessage(log4net.Core.LoggingEvent loggingEvent, Dictionary <string, string> innerAdditionalFields, GelfMessage gelfMessage) { var gelfJsonMessage = JsonConvert.SerializeObject(gelfMessage); var jsonObject = JObject.Parse(gelfJsonMessage); AddInnerAdditionalFields(jsonObject, innerAdditionalFields); AddLoggingEventAdditionalFields(jsonObject, loggingEvent); return(jsonObject.ToString()); }
private static string GetFullMessage(log4net.Core.LoggingEvent loggingEvent) { var fullMessage = loggingEvent.RenderedMessage; if (loggingEvent.ExceptionObject != null) { fullMessage = String.Format("{0} - {1}. {2}. {3}.", fullMessage, loggingEvent.ExceptionObject.Source, loggingEvent.ExceptionObject.Message, loggingEvent.ExceptionObject.StackTrace); } return(fullMessage); }
/// <summary> /// 通过反射获取传入的日志对象的某个属性的值 /// </summary> /// <param name="property"></param> /// <returns></returns> private object LookupProperty(string property, log4net.Core.LoggingEvent loggingEvent) { object propertyValue = string.Empty; PropertyInfo propertyInfo = loggingEvent.MessageObject.GetType().GetProperty(property); if (propertyInfo != null) { propertyValue = propertyInfo.GetValue(loggingEvent.MessageObject, null); } return(propertyValue); }
/// <summary> /// 重写 PatternLayout /// </summary> /// <param name="writer"></param> /// <param name="loggingEvent"></param> protected override void Convert(System.IO.TextWriter writer, log4net.Core.LoggingEvent loggingEvent) { if (Option != null) { WriteObject(writer, loggingEvent.Repository, LookupProperty(Option, loggingEvent)); } else { WriteDictionary(writer, loggingEvent.Repository, loggingEvent.GetProperties()); } }
public void DoAppend(log4net.Core.LoggingEvent loggingEvent) { if (loggingEvent.Level >= log4net.Core.Level.Error) { if (loggingEvent.ExceptionObject != null) { loggingEvent.ExceptionObject.SendToAppfail(); } } //TODO:提交更丰富log properties }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { try { var message = RenderLoggingEvent(loggingEvent); ConnectionFactory.GetConnection().AddToList(message); } catch (Exception exception) { ErrorHandler.Error("Unable to send logging event to remote redis host " + RemoteAddress + " on port " + RemotePort, exception, ErrorCode.WriteFailure); } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { lock (events) { events.Add(loggingEvent); if (LoggingEventArrived != null) { LoggingEventArrived.Invoke(this, new LoggingEventEventArgs(loggingEvent)); } } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { lock (eventQueue.SyncRoot) { eventQueue.Add(loggingEvent); //当loggername为 ":APP_STOP:" 时,立即将队列清空并且把数据写入 if (eventQueue.Count >= QueueSize || loggingEvent.LoggerName == ":APP_STOP:") { this.Clear(); } } }
/// <summary> /// /// </summary> /// <param name="loggingEvent"></param> protected override void Append(log4net.Core.LoggingEvent loggingEvent) { // Append the event as usual base.Append(loggingEvent); // Then alert the Updated event that an event has occurred var handler = Updated; if (handler != null) { handler(this, new EventArgs()); } }
internal static void LogEventDoesNotContainCorrelationIdentifiers(log4net.Core.LoggingEvent logEvent) { if (logEvent.Properties.Contains(CorrelationIdentifier.SpanIdKey) && logEvent.Properties.Contains(CorrelationIdentifier.TraceIdKey)) { LogEventContains(logEvent, traceId: 0, spanId: 0); } else { Assert.DoesNotContain(CorrelationIdentifier.SpanIdKey, logEvent.Properties.GetKeys()); Assert.DoesNotContain(CorrelationIdentifier.TraceIdKey, logEvent.Properties.GetKeys()); } }
protected override void Convert(System.IO.TextWriter writer, log4net.Core.LoggingEvent loggingEvent) { if (Option != null) { // Write the value for the specified key WriteObject(writer, loggingEvent.Repository, LookupProperty(Option, loggingEvent)); } else { // Write all the key value pairs WriteDictionary(writer, loggingEvent.Repository, loggingEvent.GetProperties()); } }
public void DoAppend(log4net.Core.LoggingEvent loggingEvent) { if (loggingEvent.Level.CompareTo(Threshold) >= 0) { lock (this) { if (output == null) { output = new StringWriter(); } Layout.Format(output, loggingEvent); } } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { if (_textBox == null) { return; } try { string sMessage = base.RenderLoggingEvent(loggingEvent); _textBox.BeginInvoke(new WriteMessageHandler(WriteMessage), sMessage); } catch { } }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { var platformInfo = new PlatformInfo { Host = Uri, Path = QueueName, Username = UserName, Password = Password ?? string.Empty }; var transportLayer = new EmsTransportLayer(platformInfo); var logMessage = new Message(); logMessage.SetBody <string>(loggingEvent.RenderedMessage); logMessage.AddHeader("LogLevel", loggingEvent.Level.ToString()); transportLayer.SendMessage(logMessage); }
private static void HandleLogEvent(object sender, log4net.Core.LoggingEvent lev) { try { if (LogEvents.Count > 500) { LogEvents.Remove(LogEvents[0]); } LogEvents.Add(lev); } catch (Exception) { LogEvents = new List <log4net.Core.LoggingEvent>(); } }
internal static void LogEventContains(log4net.Core.LoggingEvent logEvent, string service, string version, string env, ulong traceId, ulong spanId) { Assert.Contains(CorrelationIdentifier.ServiceKey, logEvent.Properties.GetKeys()); Assert.Equal(service, logEvent.Properties[CorrelationIdentifier.ServiceKey].ToString()); Assert.Contains(CorrelationIdentifier.VersionKey, logEvent.Properties.GetKeys()); Assert.Equal(version, logEvent.Properties[CorrelationIdentifier.VersionKey].ToString()); Assert.Contains(CorrelationIdentifier.EnvKey, logEvent.Properties.GetKeys()); Assert.Equal(env, logEvent.Properties[CorrelationIdentifier.EnvKey].ToString()); Assert.Contains(CorrelationIdentifier.TraceIdKey, logEvent.Properties.GetKeys()); Assert.Equal(traceId, ulong.Parse(logEvent.Properties[CorrelationIdentifier.TraceIdKey].ToString())); Assert.Contains(CorrelationIdentifier.SpanIdKey, logEvent.Properties.GetKeys()); Assert.Equal(spanId, ulong.Parse(logEvent.Properties[CorrelationIdentifier.SpanIdKey].ToString())); }
protected override void Append(log4net.Core.LoggingEvent loggingEvent) { if (_logwriter.BaseStream.Length > 500 * 1024) { _logwriter.Close(); File.Delete(_logpath); _logwriter = new StreamWriter(File.Open(_logpath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read)); } _logwriter.WriteLine("{0}|{1}|{2}|{3}|{4}", loggingEvent.Level.DisplayName, loggingEvent.ThreadName, loggingEvent.TimeStamp.ToShortDateString() + " " + loggingEvent.TimeStamp.ToShortTimeString() + "," + loggingEvent.TimeStamp.Millisecond, loggingEvent.LocationInformation.ClassName + "." + loggingEvent.LocationInformation.MethodName + "(" + loggingEvent.LocationInformation.LineNumber + ")", (loggingEvent.ExceptionObject != null ? (loggingEvent.ExceptionObject.Message + "\r\n" + loggingEvent.ExceptionObject.StackTrace) : (loggingEvent.MessageObject != null ? loggingEvent.MessageObject.ToString() : "null"))); _logwriter.Flush(); }
internal string BuildFromLoggingEvent(log4net.Core.LoggingEvent loggingEvent, string hostName, string facility, bool isConfiguredToIncludeLocationInformation, Dictionary <string, string> innerAdditionalFields) { var fullMessage = GetFullMessage(loggingEvent); var gelfMessage = new GelfMessage { Facility = (facility ?? "GELF"), File = "", FullMesage = fullMessage, Host = hostName, Level = GetSyslogSeverity(loggingEvent.Level), Line = "", ShortMessage = GetShortMessage(fullMessage), TimeStamp = loggingEvent.TimeStamp, Version = GELF_VERSION, }; if (isConfiguredToIncludeLocationInformation) { gelfMessage.File = loggingEvent.LocationInformation.FileName; gelfMessage.Line = loggingEvent.LocationInformation.LineNumber; } return(GetGelfJsonMessage(loggingEvent, innerAdditionalFields, gelfMessage)); }