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