protected HttpWebRequest GetRequest(LoggingEvent[] loggingEvents) { var request = (HttpWebRequest)WebRequest.Create(Url); request.KeepAlive = false; request.Timeout = 5000; request.ServicePoint.ConnectionLeaseTimeout = 5000; request.ServicePoint.MaxIdleTime = 5000; request.ServicePoint.ConnectionLimit = 50; request.Accept = "application/json"; request.UserAgent = "Pulsus " + Constants.Version; request.Method = "POST"; request.ContentType = "application/json"; var bytes = GetRequestBody(loggingEvents, Compress); request.ContentLength = bytes.Length; if (Compress) request.Headers.Add("Content-Encoding", "gzip"); using (var requestStream = request.GetRequestStream()) { requestStream.Write(bytes, 0, bytes.Length); } return request; }
public void PushingWithNoTargetsShouldThrow() { var eventDispatcher = new DefaultEventDispatcher(); var loggingEvent = new LoggingEvent { Text = "Event" }; Executing.This(() => eventDispatcher.Push(loggingEvent, false)).Should().Throw<InvalidOperationException>(); }
/// <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="Mammothcode.Public.Core.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); } }
public override void Push(LoggingEvent[] loggingEvents) { if (loggingEvents == null) throw new ArgumentNullException("loggingEvents"); _queue.Enqueue(loggingEvents); }
protected override void Append (LoggingEvent loggingEvent) { try { base.Append (loggingEvent); if (maximumEntries == 0) { return; } lock (m_eventsList.SyncRoot) { int elementsToRemove = m_eventsList.Count - maximumEntries; if (elementsToRemove > 0) { UnityEngine.Debug.Log ("Removing " + elementsToRemove + " elements."); m_eventsList.RemoveRange (0, elementsToRemove); } } } catch(Exception e) { UnityEngine.Debug.LogError(e); } }
public override void Push(LoggingEvent[] loggingEvents) { foreach (var loggingEvent in loggingEvents) { Console.WriteLine(Format.Format(loggingEvent)); } }
/// <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(declaringType, "Failed to append to appender [" + appender.Name + "]", ex); } } return m_appenderList.Count; }
public void Post(LoggingEvent[] loggingEvents) { var request = GetRequest(loggingEvents); try { var response = request.GetResponse() as HttpWebResponse; if (response == null) throw new Exception("There was an error posting the server"); if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Created && response.StatusCode != HttpStatusCode.Accepted) throw new Exception(string.Format("The server returned a {0} status with the message: {1}", response.StatusCode, response.StatusDescription)); } catch (WebException ex) { if (ex.Response == null) throw new Exception(string.Format("Response Status: {0}, Description: {1}", ex.Status, ex.Message), ex); var responseStream = ex.Response.GetResponseStream(); if (responseStream == null) throw new Exception("GetResponseStream() returned null", ex); var reader = new StreamReader(responseStream); var responseContent = reader.ReadToEnd(); throw new Exception(string.Format("Response Status: {0}, Content: {1}", ex.Status, responseContent), ex); } }
public EmailTemplateModel(LoggingEvent loggingEvent) { if (loggingEvent == null) throw new ArgumentNullException("loggingEvent"); LoggingEvent = loggingEvent; HttpContextInformation = loggingEvent.GetData<HttpContextInformation>(Constants.DataKeys.HttpContext); StackTrace = loggingEvent.GetData<string>(Constants.DataKeys.StackTrace); SqlInformation = loggingEvent.GetData<SqlInformation>(Constants.DataKeys.SQL); ExceptionInformation = loggingEvent.GetData<ExceptionInformation>(Constants.DataKeys.Exception); GeneralSection = new Dictionary<string, object>(); LoadGeneralSection(); CustomData = loggingEvent.Data.Where(x => !x.Key.StartsWith("MS_", StringComparison.InvariantCultureIgnoreCase)).ToDictionary(x => x.Key, x => x.Value); if (!CustomData.Any()) CustomData = null; RequestSection = new Dictionary<string, object>(); LoadRequestSection(); LevelText = Enum.GetName(typeof (LoggingEventLevel), LoggingEvent.Level); LevelClass = "green"; var loggingEventLevelValue = (int) loggingEvent.Level; if (loggingEventLevelValue >= 40000 && loggingEventLevelValue <= 60000) LevelClass = "yellow"; else if (loggingEventLevelValue > 60000) LevelClass = "red"; Footer = string.Format(CultureInfo.InvariantCulture, "Pulsus | {0} | {1}", Constants.Version, Constants.WebSite); }
public void NullDataValueShouldReturnDefaultValue() { var loggingEvent = new LoggingEvent(); loggingEvent.Data.Add("test", null); var value = loggingEvent.GetData<string>("test"); value.Should().Be.Null(); }
protected override void Append(LoggingEvent loggingEvent) { if (string.Empty.Equals(loggingEvent.MessageObject)) return; if (loggingEvent.MessageObject != null) { Messages.Add(loggingEvent.MessageObject.ToString()); } }
protected override void Convert(TextWriter writer, LoggingEvent loggingEvent) { if (HttpContext.Current == null) { writer.Write(SystemInfo.NotAvailableText); } else { Convert(writer, loggingEvent, HttpContext.Current); } }
/// <summary> /// Write the TimeStamp to the output /// </summary> /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> /// <param name="loggingEvent">the event being logged</param> /// <remarks> /// <para> /// Pass the <see cref="LoggingEvent.TimeStamp"/> to the <see cref="IDateFormatter"/> /// for it to render it to the writer. /// </para> /// <para> /// The <see cref="LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted /// to Universal time before it is rendered. /// </para> /// </remarks> /// <seealso cref="DatePatternConverter"/> override protected void Convert(TextWriter writer, LoggingEvent loggingEvent) { try { m_dateFormatter.FormatDate(loggingEvent.TimeStamp.ToUniversalTime(), writer); } catch (Exception ex) { LogLog.Error(declaringType, "Error occurred while converting date.", ex); } }
public void SerializedDataShoudBeCorrectlyDeserialized() { const string serializedData = "{ \"custom-data\" : { \"StringField\" : \"test\", \"IntField\" : 9 } }"; var loggingEvent = new LoggingEvent(); loggingEvent.Data = JsonConvert.DeserializeObject<IDictionary<string, object>>(serializedData); var result = loggingEvent.GetData<CustomData>("custom-data"); result.Should().Not.Be.Null(); result.StringField.Should().Be("test"); result.IntField.Should().Be(9); }
public override FilterDecision Decide(LoggingEvent loggingEvent) { if (loggingEvent.LoggerName.StartsWith("NServiceBus.")) { if (loggingEvent.Level < Level.Warn) { return FilterDecision.Deny; } } return FilterDecision.Accept; }
/// <summary> /// Write the ASP.Net HttpContext 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="Mammothcode.Public.Core.Util.PatternConverter.Option"/> /// property. /// </para> /// </remarks> protected override void Convert(TextWriter writer, LoggingEvent loggingEvent, HttpContext httpContext) { if (Option != null) { WriteObject(writer, loggingEvent.Repository, httpContext.Items[Option]); } else { WriteObject(writer, loggingEvent.Repository, httpContext.Items); } }
public void Log(LoggingEvent.LogLevels logLevel, string processName, string subProcessName, string logCategory, string logMessage) { LoggingEvent logEvent = new LoggingEvent(); logEvent.LogLevel = logLevel; logEvent.DateTimeSource = DateTime.Now; logEvent.ProcessName = processName; logEvent.SubProcessName = subProcessName; logEvent.LogCategory = logCategory; logEvent.LogMessage = logMessage; m_Queue.Enqueue(logEvent); m_EventContinue.Set(); }
public void Enqueue(LoggingEvent[] loggingEvents) { lock (_locker) { // ignore new logging events if (_loggingEventQueue.Count >= MaxQueueSize) return; foreach (var loggingEvent in loggingEvents) _loggingEventQueue.Enqueue(loggingEvent); } }
protected override void Append(LoggingEvent loggingEvent) { EventHandler<OnLog4NetLogEventArgs> temp = OnLog; if (temp != null) { lock (_syncRoot) { temp(null, new OnLog4NetLogEventArgs(loggingEvent)); } } }
public void LogEvents (LoggingEvent [] events) { if (events != null) { foreach (LoggingEvent logEvent in events) { string logFile = Path.Combine (AppDomain.CurrentDomain.BaseDirectory, "log"); using (StreamWriter sw = File.AppendText (logFile)) { sw.WriteLine (logEvent.Message); } } } }
/// <summary> /// Write the property value to the output /// </summary> /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> /// <param name="loggingEvent">the event being logged</param> /// <remarks> /// <para> /// Writes out the value of a named property. The property name /// should be set in the <see cref="Mammothcode.Public.Core.Util.PatternConverter.Option"/> /// property. /// </para> /// <para> /// If the <see cref="Mammothcode.Public.Core.Util.PatternConverter.Option"/> is set to <c>null</c> /// then all the properties are written as key value pairs. /// </para> /// </remarks> override protected void Convert(TextWriter writer, LoggingEvent loggingEvent) { if (Option != null) { // Write the value for the specified key WriteObject(writer, loggingEvent.Repository, loggingEvent.LookupProperty(Option)); } else { // Write all the key value pairs WriteDictionary(writer, loggingEvent.Repository, loggingEvent.GetProperties()); } }
public void CanPushToDefaultTargets() { var target1Mock = new Mock<ITarget>(); var target2Mock = new Mock<ITarget>(); var eventDispatcher = new DefaultEventDispatcher { DefaultTargets = new[] { target1Mock.Object, target2Mock.Object } }; var loggingEvent = new LoggingEvent { Text = "Event" }; eventDispatcher.Push(loggingEvent, false); target1Mock.Verify(o => o.Log(loggingEvent)); target2Mock.Verify(o => o.Log(loggingEvent)); }
public void NonSerializedDataShouldCorrectlyRetrieved() { var loggingEvent = new LoggingEvent(); loggingEvent.Data["custom-data"] = new CustomData() { StringField = "test", IntField = 9 }; var result = loggingEvent.GetData<CustomData>("custom-data"); result.Should().Not.Be.Null(); result.StringField.Should().Be("test"); result.IntField.Should().Be(9); }
public static LoggingEvent Deserialize(MsSqlLoggingEvent mssqlLoggingEvent) { var result = new LoggingEvent(); result.EventId = mssqlLoggingEvent.EventId; result.Timestamp = mssqlLoggingEvent.Timestamp; result.Level = mssqlLoggingEvent.Level; result.Value = mssqlLoggingEvent.Value; result.Text = mssqlLoggingEvent.Text; result.Tags = Pulsus.Tags.Clean(mssqlLoggingEvent.Tags).ToList(); result.Data = JsonConvert.DeserializeObject<Dictionary<string, object>>(mssqlLoggingEvent.Data); result.User = mssqlLoggingEvent.User; result.Source = mssqlLoggingEvent.Source; return result; }
public static MsSqlLoggingEvent Serialize(LoggingEvent loggingEvent) { var result = new MsSqlLoggingEvent(); result.EventId = loggingEvent.EventId; result.Timestamp = loggingEvent.Timestamp; result.Level = loggingEvent.Level; result.Value = loggingEvent.Value; result.Text = loggingEvent.Text; result.Tags = string.Join(" ", loggingEvent.Tags.ToArray()); result.Data = JsonConvert.SerializeObject(loggingEvent.Data); result.User = loggingEvent.User; result.Source = loggingEvent.Source; return result; }
public override void Push(LoggingEvent[] loggingEvents) { if (loggingEvents == null) throw new ArgumentNullException("loggingEvents"); if (string.IsNullOrEmpty(Url)) throw new Exception("There is no URL defined for the server target."); Uri uri; if (!Uri.TryCreate(Url, UriKind.Absolute, out uri)) throw new Exception("The URL defined for the server target is not valid"); Post(loggingEvents); }
public void CanAddAndPushToTargets() { var target1Mock = new Mock<ITarget>(); var target2Mock = new Mock<ITarget>(); var eventDispatcher = new DefaultEventDispatcher(); eventDispatcher.AddTarget(target1Mock.Object); eventDispatcher.AddTarget(target2Mock.Object); var loggingEvent = new LoggingEvent { Text = "Event" }; eventDispatcher.Push(loggingEvent, false); target1Mock.Verify(o => o.Log(loggingEvent)); target2Mock.Verify(o => o.Log(loggingEvent)); }
public void ThrottlingMustBeActivatedWhenThresholdIsReached() { var loggingEvent = new LoggingEvent() { Text = "Test" }; var emailTarget = new EmailTargetTester(); emailTarget.ThrottlingWindow = 1; emailTarget.ThrottlingThreshold = 60; emailTarget.ThrottlingDuration = 10; for (var i = 0; i < 100; i++) emailTarget.Push(new[] { loggingEvent }); emailTarget.Counter.Should().Be(60); }
public override void Push(LoggingEvent[] loggingEvents) { if (HostingEnvironment.IsHosted) { lock (_locker) { if (_shuttingDown) return; PushInternal(loggingEvents); } } else { PushInternal(loggingEvents); } }
public override void Push(LoggingEvent[] loggingEvents) { if (loggingEvents == null) throw new ArgumentNullException("loggingEvents"); if (string.IsNullOrEmpty(AccessKey)) throw new Exception("You must define an AccessKey"); if (string.IsNullOrEmpty(SecretKey)) throw new Exception("You must specify a SecretKey"); if (string.IsNullOrEmpty(BucketName)) throw new Exception("You must specify a BucketName"); foreach (var loggingEvent in loggingEvents) Post(loggingEvent); }
private void UpdateControl(LoggingEvent loggingEvent) { if (loggingEvent.Level != Level.Info) { return; } if (_listView == null) { return; } if (_listView.IsDisposed) { return; } // There may be performance issues if the buffer gets too long // So periodically clear the buffer if (_listView.Items.Count > maxTextLength) { _listView.Items.Clear(); } ListViewItem lvi = new ListViewItem(); //switch (loggingEvent.Level.ToString()) //{ // case "INFO": // lvi.ForeColor = System.Drawing.Color.Blue; // break; // case "WARN": // lvi.ForeColor = System.Drawing.Color.Orange; // break; // case "ERROR": // lvi.ForeColor = System.Drawing.Color.Red; // break; // case "FATAL": // lvi.ForeColor = System.Drawing.Color.DarkOrange; // break; // case "DEBUG": // lvi.ForeColor = System.Drawing.Color.DarkGreen; // break; // default: // lvi.ForeColor = System.Drawing.Color.Black; // break; //} //if (this._listView.Items.Count % 2 == 0) //{ // lvi.BackColor = System.Drawing.Color.Silver; //} //else //{ // lvi.BackColor = System.Drawing.Color.LightBlue; //} lvi.Text = loggingEvent.TimeStamp.ToString("HH:mm:ss"); // lvi.SubItems.Add(loggingEvent.UserName); //lvi.SubItems.Add(loggingEvent.Level.DisplayName); //lvi.SubItems.Add(loggingEvent.LoggerName); // lvi.SubItems.Add(string.Format("{0}.{1}.{2}", loggingEvent.LocationInformation.ClassName, loggingEvent.LocationInformation.MethodName, loggingEvent.LocationInformation.LineNumber)); lvi.SubItems.Add(loggingEvent.RenderedMessage); _listView.Items.Add(lvi); lvi.EnsureVisible(); //_listView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent); }
/// <summary> /// Call the getter /// </summary> /// <param name="loggingEvent">the event to get a value for/from</param> /// <returns>the value gotten</returns> public object Format(LoggingEvent loggingEvent) { return(m_getter == null ? null : m_getter(loggingEvent)); }
protected override void Append(LoggingEvent loggingEvent) { if (RavenClient == null) { RavenClient = new RavenClient(DSN) { Logger = Logger, Compression = CompressionEnabled, Environment = Environment, // If something goes wrong when sending the event to Sentry, make sure this is written to log4net's internal // log. See <add key="log4net.Internal.Debug" value="true"/> ErrorOnCapture = ex => LogLog.Error(typeof(SentryAppender), "[" + Name + "] " + ex.Message, ex) }; } var httpExtra = HttpExtra.GetHttpExtra(); object extra; if (httpExtra != null) { extra = new { Environment = new EnvironmentExtra(), Http = httpExtra }; } else { extra = new { Environment = new EnvironmentExtra() }; } var tags = _tagLayouts.ToDictionary(t => t.Name, t => (t.Layout.Format(loggingEvent) ?? "").ToString()); var exception = loggingEvent.ExceptionObject ?? loggingEvent.MessageObject as Exception; var level = Translate(loggingEvent.Level); if (loggingEvent.ExceptionObject != null) { // We should capture buth the exception and the message passed var @event = new SentryEvent(loggingEvent.RenderedMessage) { Extra = extra, Level = level, Tags = tags }; RavenClient.Capture(@event); } else if (loggingEvent.MessageObject is Exception) { // We should capture the exception with no custom message var @event = new SentryEvent(exception) { Extra = extra, Level = level, Tags = tags }; RavenClient.Capture(@event); } else { // Just capture message var message = loggingEvent.RenderedMessage; if (message != null) { var @event = new SentryEvent(loggingEvent.RenderedMessage) { Extra = extra, Level = level, Tags = tags }; RavenClient.Capture(@event); } } }
/// <inheritdoc/> protected override void Append(LoggingEvent loggingEvent) { var entries = new[] { BuildLogEntry(loggingEvent) }; Write(entries); }
/// <summary> /// Get the fully qualified string data /// </summary> /// <param name="loggingEvent">the event being logged</param> /// <returns>the fully qualified name</returns> /// <remarks> /// <para> /// Overridden by subclasses to get the fully qualified name before the /// precision is applied to it. /// </para> /// <para> /// Return the fully qualified <c>'.'</c> (dot/period) separated string. /// </para> /// </remarks> abstract protected string GetFullyQualifiedName(LoggingEvent loggingEvent);
protected override string GetFullyQualifiedName(LoggingEvent loggingEvent) { return(loggingEvent.MessageObject.ToString()); }
/// <summary> /// Gets the fully qualified name of the logger /// </summary> /// <param name="loggingEvent">the event being logged</param> /// <returns>The fully qualified logger name</returns> /// <remarks> /// <para> /// Returns the <see cref="LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>. /// </para> /// </remarks> override protected string GetFullyQualifiedName(LoggingEvent loggingEvent) { return(loggingEvent.LoggerName); }
/// <summary> /// Lookup the property for <see cref="Key"/> /// </summary> /// <param name="loggingEvent">The event to format</param> /// <returns>returns property value</returns> /// <remarks> /// <para> /// Looks up and returns the object value of the property /// named <see cref="Key"/>. If there is no property defined /// with than name then <c>null</c> will be returned. /// </para> /// </remarks> public virtual object Format(LoggingEvent loggingEvent) { return(loggingEvent.LookupProperty(m_key)); }
protected override void Append(LoggingEvent loggingEvent) { loggingEvent.Fix = FixFlags.LocationInfo; LastLoggingEvent = loggingEvent; }
protected override void Append(LoggingEvent loggingEvent) { var message = this.RenderLoggingEvent(loggingEvent); _twilio.SendSmsMessage(From, To, message); }
protected override void HttpConvert(TextWriter writer, LoggingEvent loggingEvent, HttpContext currentContext) { writer.Write(currentContext.Request.UrlReferrer); }
private LogEntrySourceLocation BuildLogEntryLocation(LoggingEvent loggingEvent) { string file = null; long? line = null; string function = null; if (loggingEvent.LocationInformation?.FileName != null) { file = loggingEvent.LocationInformation?.FileName; } long lineNumber; if (long.TryParse(loggingEvent.LocationInformation?.LineNumber, out lineNumber)) { line = lineNumber; } string function0 = null; string fullTypeName = loggingEvent.LocationInformation?.ClassName; if (fullTypeName != null) { var type = _typeCache.GetOrAdd(fullTypeName, () => { try { return(AppDomain.CurrentDomain.GetAssemblies() .SelectMany(a => a.GetTypes()) .FirstOrDefault(t => t.FullName == fullTypeName)); } catch { // Ignore exceptions. This is best-effort only, and expected to fail in some situations. // Returning null caches the failure. return(null); } }); if (type != null) { function0 = type.AssemblyQualifiedName; } } string function1 = loggingEvent.LocationInformation?.MethodName; if (function0 != null || function1 != null) { function = $"[{function0 ?? ""}].{function1 ?? ""}"; } if (file != null || line != null || function != null) { var sourceLocation = new LogEntrySourceLocation(); if (file != null) { sourceLocation.File = file; } if (line != null) { sourceLocation.Line = line.Value; } if (function != null) { // Format of "function" is: // "[<assembly-qualified type name>].<method name>" // E.g. "[Google.Cloud.Logging.Log4Net.Tests.Log4NetTest, Google.Cloud.Logging.Log4Net.Tests, Version=1.0.0.0, Culture=neutral, PublicKeyToken=185c282632e132a0].LogInfo" sourceLocation.Function = function; } return(sourceLocation); } return(null); }
public void Format(TextWriter writer, LoggingEvent loggingEvent) { InnerLayout.Format(writer, loggingEvent); }
protected override void Append(LoggingEvent loggingEvent) { Logged?.Invoke(loggingEvent); }
/// <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> protected override void Convert(TextWriter writer, LoggingEvent loggingEvent) { writer.Write(loggingEvent.UserName); }
public AzureLoggingEventEntity(LoggingEvent e, PartitionKeyTypeEnum partitionKeyType, string message, int sequenceNumber) : this(e, partitionKeyType) { Message = message; SequenceNumber = sequenceNumber; }
/* Example log4j schema event * * <log4j:event logger="first logger" level="ERROR" thread="Thread-3" timestamp="1051494121460"> * <log4j:message><![CDATA[errormsg 3]]></log4j:message> * <log4j:NDC><![CDATA[third]]></log4j:NDC> * <log4j:MDC> * <log4j:data name="some string" value="some valuethird"/> * </log4j:MDC> * <log4j:throwable><![CDATA[java.lang.Exception: someexception-third * at org.apache.log4j.chainsaw.Generator.run(Generator.java:94) * ]]></log4j:throwable> * <log4j:locationInfo class="org.apache.log4j.chainsaw.Generator" * method="run" file="Generator.java" line="94"/> * <log4j:properties> * <log4j:data name="log4jmachinename" value="windows"/> * <log4j:data name="log4japp" value="udp-generator"/> * </log4j:properties> * </log4j:event> * */ /* Since log4j 1.3 the log4j:MDC has been combined into the log4j:properties element */ /// <summary> /// Actually do the writing of the xml /// </summary> /// <param name="writer">the writer to use</param> /// <param name="loggingEvent">the event to write</param> /// <remarks> /// <para> /// Generate XML that is compatible with the log4j schema. /// </para> /// </remarks> override protected void FormatXml(XmlWriter writer, LoggingEvent loggingEvent) { // Translate logging events for log4j // Translate hostname property if (loggingEvent.LookupProperty(LoggingEvent.HostNameProperty) != null && loggingEvent.LookupProperty("log4jmachinename") == null) { loggingEvent.GetProperties()["log4jmachinename"] = loggingEvent.LookupProperty(LoggingEvent.HostNameProperty); } // translate appdomain name if (loggingEvent.LookupProperty("log4japp") == null && loggingEvent.Domain != null && loggingEvent.Domain.Length > 0) { loggingEvent.GetProperties()["log4japp"] = loggingEvent.Domain; } // translate identity name if (loggingEvent.Identity != null && loggingEvent.Identity.Length > 0 && loggingEvent.LookupProperty(LoggingEvent.IdentityProperty) == null) { loggingEvent.GetProperties()[LoggingEvent.IdentityProperty] = loggingEvent.Identity; } // translate user name if (loggingEvent.UserName != null && loggingEvent.UserName.Length > 0 && loggingEvent.LookupProperty(LoggingEvent.UserNameProperty) == null) { loggingEvent.GetProperties()[LoggingEvent.UserNameProperty] = loggingEvent.UserName; } // Write the start element writer.WriteStartElement("log4j:event"); writer.WriteAttributeString("logger", loggingEvent.LoggerName); // Calculate the timestamp as the number of milliseconds since january 1970 // // We must convert the TimeStamp to UTC before performing any mathematical // operations. This allows use to take into account discontinuities // caused by daylight savings time transitions. TimeSpan timeSince1970 = loggingEvent.TimeStamp.ToUniversalTime() - s_date1970; writer.WriteAttributeString("timestamp", XmlConvert.ToString((long)timeSince1970.TotalMilliseconds)); writer.WriteAttributeString("level", loggingEvent.Level.DisplayName); writer.WriteAttributeString("thread", loggingEvent.ThreadName); // Append the message text writer.WriteStartElement("log4j:message"); Transform.WriteEscapedXmlString(writer, loggingEvent.RenderedMessage, this.InvalidCharReplacement); writer.WriteEndElement(); object ndcObj = loggingEvent.LookupProperty("NDC"); if (ndcObj != null) { string valueStr = loggingEvent.Repository.RendererMap.FindAndRender(ndcObj); if (valueStr != null && valueStr.Length > 0) { // Append the NDC text writer.WriteStartElement("log4j:NDC"); Transform.WriteEscapedXmlString(writer, valueStr, this.InvalidCharReplacement); writer.WriteEndElement(); } } // Append the properties text PropertiesDictionary properties = loggingEvent.GetProperties(); if (properties.Count > 0) { writer.WriteStartElement("log4j:properties"); foreach (System.Collections.DictionaryEntry entry in properties) { writer.WriteStartElement("log4j:data"); writer.WriteAttributeString("name", (string)entry.Key); // Use an ObjectRenderer to convert the object to a string string valueStr = loggingEvent.Repository.RendererMap.FindAndRender(entry.Value); writer.WriteAttributeString("value", valueStr); writer.WriteEndElement(); } writer.WriteEndElement(); } string exceptionStr = loggingEvent.GetExceptionString(); if (exceptionStr != null && exceptionStr.Length > 0) { // Append the stack trace line writer.WriteStartElement("log4j:throwable"); Transform.WriteEscapedXmlString(writer, exceptionStr, this.InvalidCharReplacement); writer.WriteEndElement(); } if (LocationInfo) { LocationInfo locationInfo = loggingEvent.LocationInformation; writer.WriteStartElement("log4j:locationInfo"); writer.WriteAttributeString("class", locationInfo.ClassName); writer.WriteAttributeString("method", locationInfo.MethodName); writer.WriteAttributeString("file", locationInfo.FileName); writer.WriteAttributeString("line", locationInfo.LineNumber); writer.WriteEndElement(); } writer.WriteEndElement(); }
protected override void Append(LoggingEvent loggingEvent) { this.concurrentQueue_0.Enqueue(loggingEvent); }
protected override void Append(LoggingEvent loggingEvent) { var message = RenderLoggingEvent(loggingEvent); OnUiLogReceived(new UiLogEventArgs(message)); }
public void DoAppend(LoggingEvent loggingEvent) { }
/// <summary> /// Write the ThreadName to the output /// </summary> /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> /// <param name="loggingEvent">the event being logged</param> /// <remarks> /// <para> /// Writes the <see cref="LoggingEvent.ThreadName"/> to the <paramref name="writer" />. /// </para> /// </remarks> override protected void Convert(TextWriter writer, LoggingEvent loggingEvent) { writer.Write(loggingEvent.ThreadName); }
protected override void Append(LoggingEvent loggingEvent) { string renderedMessage = base.RenderLoggingEvent(loggingEvent); ILayout layout = base.Layout; // do something here }
protected override void Append(LoggingEvent loggingEvent) { Action operation = () => { this.RichTextBox.AppendText(RenderLoggingEvent(loggingEvent)); }; this.RichTextBox.Invoke(operation); }
/// <summary> /// Log the logEvent through this repository. /// </summary> /// <param name="logEvent">the event to log</param> /// <remarks> /// <para> /// This method should not normally be used to log. /// The <see cref="ILog"/> interface should be used /// for routine logging. This interface can be obtained /// using the <see cref="zlog4net.LogManager.GetLogger(string)"/> method. /// </para> /// <para> /// The <c>logEvent</c> is delivered to the appropriate logger and /// that logger is then responsible for logging the event. /// </para> /// </remarks> abstract public void Log(LoggingEvent logEvent);
public override FilterDecision Decide(LoggingEvent loggingEvent) { return(FilterDecision.Accept); }
/// <summary> /// Does the actual writing of the XML. /// </summary> /// <param name="writer">The writer to use to output the event to.</param> /// <param name="loggingEvent">The event to write.</param> /// <remarks> /// <para> /// Subclasses should override this method to format /// the <see cref="LoggingEvent"/> as XML. /// </para> /// </remarks> abstract protected void FormatXml(XmlWriter writer, LoggingEvent loggingEvent);
/// <summary> /// Convert the pattern to the rendered message /// </summary> /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param> /// <param name="loggingEvent">the event being logged</param> /// <returns>the relevant location information</returns> protected override void Convert(TextWriter writer, LoggingEvent loggingEvent) { loggingEvent.WriteRenderedMessage(writer); }
public SerializableLogEvent(LoggingEvent loggingEvent) { _loggingEvent = loggingEvent; }
public RecordInfo(RecordHeader header, LoggingEvent data) { Header = header; Data = data; }
/// <summary> /// Decide if the <see cref="LoggingEvent"/> should be logged through an appender. /// </summary> /// <param name="loggingEvent">The <see cref="LoggingEvent"/> to decide upon</param> /// <returns>The decision of the filter</returns> /// <remarks> /// <para> /// If the decision is <see cref="FilterDecision.Deny"/>, then the event will be /// dropped. If the decision is <see cref="FilterDecision.Neutral"/>, then the next /// filter, if any, will be invoked. If the decision is <see cref="FilterDecision.Accept"/> then /// the event will be logged without consulting with other filters in /// the chain. /// </para> /// <para> /// This method is marked <c>abstract</c> and must be implemented /// in a subclass. /// </para> /// </remarks> public abstract FilterDecision Decide(LoggingEvent loggingEvent);