public void WriteToConsoleOutTests()
{
// Expected result is the same for both types of method invocation.
const string expected = "Warn WWW\nError EEE\nFatal FFF\nTrace TTT\nDebug DDD\nInfo III\n";
using (var loggerScope = new InternalLoggerScope(true))
{
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
InternalLogger.LogToConsole = true;
{
StringWriter consoleOutWriter1 = new StringWriter()
{
NewLine = "\n"
};
// Redirect the console output to a StringWriter.
loggerScope.SetConsoleOutput(consoleOutWriter1);
// Named (based on LogLevel) public methods.
InternalLogger.Warn("WWW");
InternalLogger.Error("EEE");
InternalLogger.Fatal("FFF");
InternalLogger.Trace("TTT");
InternalLogger.Debug("DDD");
InternalLogger.Info("III");
TestWriter(expected, consoleOutWriter1);
}
//
// Redirect the console output to another StringWriter.
{
StringWriter consoleOutWriter2 = new StringWriter()
{
NewLine = "\n"
};
loggerScope.SetConsoleOutput(consoleOutWriter2);
// Invoke Log(LogLevel, string) for every log level.
InternalLogger.Log(LogLevel.Warn, "WWW");
InternalLogger.Log(LogLevel.Error, "EEE");
InternalLogger.Log(LogLevel.Fatal, "FFF");
InternalLogger.Log(LogLevel.Trace, "TTT");
InternalLogger.Log(LogLevel.Debug, "DDD");
InternalLogger.Log(LogLevel.Info, "III");
TestWriter(expected, consoleOutWriter2);
}
//lambdas
{
StringWriter consoleOutWriter1 = new StringWriter()
{
NewLine = "\n"
};
// Redirect the console output to a StringWriter.
loggerScope.SetConsoleOutput(consoleOutWriter1);
// Named (based on LogLevel) public methods.
InternalLogger.Warn(() => "WWW");
InternalLogger.Error(() => "EEE");
InternalLogger.Fatal(() => "FFF");
InternalLogger.Trace(() => "TTT");
InternalLogger.Debug(() => "DDD");
InternalLogger.Info(() => "III");
TestWriter(expected, consoleOutWriter1);
}
}
}
protected override void InitializeTarget()
{
base.InitializeTarget();
#pragma warning disable 618
if (UseTransactions.HasValue)
#pragma warning restore 618
{
InternalLogger.Warn("DatabaseTarget(Name={0}): UseTransactions property is obsolete and will not be used - will be removed in NLog 6", Name);
}
bool foundProvider = false;
string providerName = string.Empty;
#if !NETSTANDARD
if (!string.IsNullOrEmpty(ConnectionStringName))
{
// read connection string and provider factory from the configuration file
var cs = ConnectionStringsSettings[ConnectionStringName];
if (cs == null)
{
throw new NLogConfigurationException($"Connection string '{ConnectionStringName}' is not declared in <connectionStrings /> section.");
}
if (!string.IsNullOrEmpty(cs.ConnectionString?.Trim()))
{
ConnectionString = SimpleLayout.Escape(cs.ConnectionString.Trim());
}
providerName = cs.ProviderName?.Trim() ?? string.Empty;
}
#endif
if (ConnectionString != null)
{
try
{
var connectionString = BuildConnectionString(LogEventInfo.CreateNullEvent());
var dbConnectionStringBuilder = new DbConnectionStringBuilder {
ConnectionString = connectionString
};
if (dbConnectionStringBuilder.TryGetValue("provider connection string", out var connectionStringValue))
{
// Special Entity Framework Connection String
if (dbConnectionStringBuilder.TryGetValue("provider", out var providerValue))
{
// Provider was overriden by ConnectionString
providerName = providerValue.ToString()?.Trim() ?? string.Empty;
}
// ConnectionString was overriden by ConnectionString :)
ConnectionString = SimpleLayout.Escape(connectionStringValue.ToString());
}
}
catch (Exception ex)
{
#if !NETSTANDARD
if (!string.IsNullOrEmpty(ConnectionStringName))
{
InternalLogger.Warn(ex, "DatabaseTarget(Name={0}): DbConnectionStringBuilder failed to parse '{1}' ConnectionString", Name, ConnectionStringName);
}
else
#endif
InternalLogger.Warn(ex, "DatabaseTarget(Name={0}): DbConnectionStringBuilder failed to parse ConnectionString", Name);
}
}
#if !NETSTANDARD
if (string.IsNullOrEmpty(providerName))
{
string dbProvider = DBProvider?.Trim() ?? string.Empty;
if (!string.IsNullOrEmpty(dbProvider))
{
foreach (DataRow row in DbProviderFactories.GetFactoryClasses().Rows)
{
var invariantname = (string)row["InvariantName"];
if (string.Equals(invariantname, dbProvider, StringComparison.OrdinalIgnoreCase))
{
providerName = invariantname;
break;
}
}
}
}
if (!string.IsNullOrEmpty(providerName))
{
try
{
ProviderFactory = DbProviderFactories.GetFactory(providerName);
foundProvider = true;
}
catch (Exception ex)
{
InternalLogger.Error(ex, "DatabaseTarget(Name={0}): DbProviderFactories failed to get factory from ProviderName={1}", Name, providerName);
throw;
}
}
#endif
if (!foundProvider)
{
try
{
SetConnectionType();
if (ConnectionType == null)
{
InternalLogger.Warn("DatabaseTarget(Name={0}): No ConnectionType created from DBProvider={1}", Name, DBProvider);
}
}
catch (Exception ex)
{
InternalLogger.Error(ex, "DatabaseTarget(Name={0}): Failed to create ConnectionType from DBProvider={1}", Name, DBProvider);
throw;
}
}
}
private void ParseExtensionsElement(NLogXmlElement extensionsElement, string baseDirectory)
{
extensionsElement.AssertName("extensions");
foreach (var addElement in extensionsElement.Elements("add"))
{
string prefix = addElement.GetOptionalAttribute("prefix", null);
if (prefix != null)
{
prefix = prefix + ".";
}
string type = StripOptionalNamespacePrefix(addElement.GetOptionalAttribute("type", null));
if (type != null)
{
this.configurationItemFactory.RegisterType(Type.GetType(type, true), prefix);
}
string assemblyFile = addElement.GetOptionalAttribute("assemblyFile", null);
if (assemblyFile != null)
{
try
{
#if SILVERLIGHT
var si = Application.GetResourceStream(new Uri(assemblyFile, UriKind.Relative));
var assemblyPart = new AssemblyPart();
Assembly asm = assemblyPart.Load(si.Stream);
#else
string fullFileName = Path.Combine(baseDirectory, assemblyFile);
InternalLogger.Info("Loading assembly file: {0}", fullFileName);
Assembly asm = Assembly.LoadFrom(fullFileName);
#endif
this.configurationItemFactory.RegisterItemsFromAssembly(asm, prefix);
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
InternalLogger.Error("Error loading extensions: {0}", exception);
if (LogManager.ThrowExceptions)
{
throw new NLogConfigurationException("Error loading extensions: " + assemblyFile, exception);
}
}
continue;
}
string assemblyName = addElement.GetOptionalAttribute("assembly", null);
if (assemblyName != null)
{
try
{
InternalLogger.Info("Loading assembly name: {0}", assemblyName);
#if SILVERLIGHT
var si = Application.GetResourceStream(new Uri(assemblyName + ".dll", UriKind.Relative));
var assemblyPart = new AssemblyPart();
Assembly asm = assemblyPart.Load(si.Stream);
#else
Assembly asm = Assembly.Load(assemblyName);
#endif
this.configurationItemFactory.RegisterItemsFromAssembly(asm, prefix);
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
InternalLogger.Error("Error loading extensions: {0}", exception);
if (LogManager.ThrowExceptions)
{
throw new NLogConfigurationException("Error loading extensions: " + assemblyName, exception);
}
}
continue;
}
}
}
protected override void Write(LogEventInfo logEvent)
{
try
{
var log = new Log();
log.Time = logEvent.TimeStamp;
log.Message = CleanseLogMessage.Cleanse(logEvent.FormattedMessage);
log.Logger = logEvent.LoggerName;
if (log.Logger.StartsWith("NzbDrone."))
{
log.Logger = log.Logger.Remove(0, 9);
}
if (logEvent.Exception != null)
{
if (string.IsNullOrWhiteSpace(log.Message))
{
log.Message = logEvent.Exception.Message;
}
else
{
log.Message += ": " + logEvent.Exception.Message;
}
log.Exception = logEvent.Exception.ToString();
log.ExceptionType = logEvent.Exception.GetType().ToString();
}
log.Level = logEvent.Level.Name;
var sqlCommand = new SQLiteCommand(INSERT_COMMAND, _connection);
sqlCommand.Parameters.Add(new SQLiteParameter("Message", DbType.String)
{
Value = log.Message
});
sqlCommand.Parameters.Add(new SQLiteParameter("Time", DbType.DateTime)
{
Value = log.Time.ToUniversalTime()
});
sqlCommand.Parameters.Add(new SQLiteParameter("Logger", DbType.String)
{
Value = log.Logger
});
sqlCommand.Parameters.Add(new SQLiteParameter("Exception", DbType.String)
{
Value = log.Exception
});
sqlCommand.Parameters.Add(new SQLiteParameter("ExceptionType", DbType.String)
{
Value = log.ExceptionType
});
sqlCommand.Parameters.Add(new SQLiteParameter("Level", DbType.String)
{
Value = log.Level
});
sqlCommand.ExecuteNonQuery();
}
catch (SQLiteException ex)
{
InternalLogger.Error(ex, "Unable to save log event to database");
throw;
}
}
private NLogEvents TranslateLogEvents(IList <AsyncLogEventInfo> logEvents)
{
if (logEvents.Count == 0 && !LogManager.ThrowExceptions)
{
InternalLogger.Error("LogReceiverServiceTarget(Name={0}): LogEvents array is empty, sending empty event...", Name);
return(new NLogEvents());
}
string clientID = string.Empty;
if (ClientId != null)
{
clientID = ClientId.Render(logEvents[0].LogEvent);
}
var networkLogEvents = new NLogEvents
{
ClientName = clientID,
LayoutNames = new StringCollection(),
Strings = new StringCollection(),
BaseTimeUtc = logEvents[0].LogEvent.TimeStamp.ToUniversalTime().Ticks
};
var stringTable = new Dictionary <string, int>();
for (int i = 0; i < Parameters.Count; ++i)
{
networkLogEvents.LayoutNames.Add(Parameters[i].Name);
}
if (IncludeEventProperties)
{
for (int i = 0; i < logEvents.Count; ++i)
{
var ev = logEvents[i].LogEvent;
MergeEventProperties(ev);
if (ev.HasProperties)
{
// add all event-level property names in 'LayoutNames' collection.
foreach (var prop in ev.Properties)
{
string propName = prop.Key as string;
if (propName != null)
{
if (!networkLogEvents.LayoutNames.Contains(propName))
{
networkLogEvents.LayoutNames.Add(propName);
}
}
}
}
}
}
networkLogEvents.Events = new NLogEvent[logEvents.Count];
for (int i = 0; i < logEvents.Count; ++i)
{
AsyncLogEventInfo ev = logEvents[i];
networkLogEvents.Events[i] = TranslateEvent(ev.LogEvent, networkLogEvents, stringTable);
}
return(networkLogEvents);
}
protected override void Write(LogEventInfo logEvent)
{
var uncompressedMessage = GetMessage(logEvent);
var message = CompressMessage(uncompressedMessage);
var routingKey = RenderLogEvent(Topic, logEvent);
if (routingKey.IndexOf("{0}") >= 0)
{
routingKey = routingKey.Replace("{0}", logEvent.Level.Name);
}
var model = _Model;
var modelExchange = _ModelExchange;
if (model == null || !model.IsOpen)
{
StartConnection(_Connection, Timeout, true);
model = _Model;
modelExchange = _ModelExchange;
}
var basicProperties = GetBasicProperties(logEvent, model);
if (model == null || !model.IsOpen)
{
if (!AddUnsent(routingKey, basicProperties, message))
{
throw new InvalidOperationException("LogEvent discarded because RabbitMQ instance is offline and reached MaxBuffer");
}
return;
}
bool restartConnection = true;
try
{
CheckUnsent(model, modelExchange);
Publish(model, message, basicProperties, routingKey, modelExchange);
restartConnection = false;
}
catch (IOException e)
{
InternalLogger.Error(e, "RabbitMQTarget(Name={0}): Could not send to RabbitMQ instance: {1}", Name, e.Message);
if (!AddUnsent(routingKey, basicProperties, message))
{
throw;
}
}
catch (ObjectDisposedException e)
{
InternalLogger.Error(e, "RabbitMQTarget(Name={0}): Could not send to RabbitMQ instance: {1}", Name, e.Message);
if (!AddUnsent(routingKey, basicProperties, message))
{
throw;
}
}
catch (Exception e)
{
restartConnection = false; // Skip connection reconnect, maybe the LogEvent is broken, or maybe halfway there
InternalLogger.Error(e, "RabbitMQTarget(Name={0}): Could not send to RabbitMQ instance: {1}", Name, e.Message);
throw;
}
finally
{
if (restartConnection)
{
StartConnection(_Connection, Math.Min(500, Timeout), true);
}
}
}
private Logger GetLogger(LoggerCacheKey cacheKey)
{
lock (this.syncRoot)
{
Logger existingLogger = loggerCache.Retrieve(cacheKey);
if (existingLogger != null)
{
// Logger is still in cache and referenced.
return(existingLogger);
}
Logger newLogger;
if (cacheKey.ConcreteType != null && cacheKey.ConcreteType != typeof(Logger))
{
var fullName = cacheKey.ConcreteType.FullName;
try
{
//creating instance of static class isn't possible, and also not wanted (it cannot inherited from Logger)
if (cacheKey.ConcreteType.IsStaticClass())
{
var errorMessage = string.Format("GetLogger / GetCurrentClassLogger is '{0}' as loggerType can be a static class and should inherit from Logger",
fullName);
InternalLogger.Error(errorMessage);
if (ThrowExceptions)
{
throw new NLogRuntimeException(errorMessage);
}
newLogger = CreateDefaultLogger(ref cacheKey);
}
else
{
var instance = FactoryHelper.CreateInstance(cacheKey.ConcreteType);
newLogger = instance as Logger;
if (newLogger == null)
{
//well, it's not a Logger, and we should return a Logger.
var errorMessage = string.Format("GetLogger / GetCurrentClassLogger got '{0}' as loggerType which doesn't inherit from Logger", fullName);
InternalLogger.Error(errorMessage);
if (ThrowExceptions)
{
throw new NLogRuntimeException(errorMessage);
}
// Creating default instance of logger if instance of specified type cannot be created.
newLogger = CreateDefaultLogger(ref cacheKey);
}
}
}
catch (Exception ex)
{
if (ex.MustBeRethrown())
{
throw;
}
var errorMessage = string.Format("GetLogger / GetCurrentClassLogger. Cannot create instance of type '{0}'. It should have an default contructor. ", fullName);
if (ThrowExceptions)
{
throw new NLogRuntimeException(errorMessage, ex);
}
InternalLogger.Error(errorMessage + ". Exception : {0}", ex);
// Creating default instance of logger if instance of specified type cannot be created.
newLogger = CreateDefaultLogger(ref cacheKey);
}
}
else
{
newLogger = new Logger();
}
if (cacheKey.ConcreteType != null)
{
newLogger.Initialize(cacheKey.Name, this.GetConfigurationForLogger(cacheKey.Name, this.Configuration), this);
}
// TODO: Clarify what is the intention when cacheKey.ConcreteType = null.
// At the moment, a logger typeof(Logger) will be created but the ConcreteType
// will remain null and inserted into the cache.
// Should we set cacheKey.ConcreteType = typeof(Logger) for default loggers?
loggerCache.InsertOrUpdate(cacheKey, newLogger);
return(newLogger);
}
}
/// <summary>
/// Logs an exception using the internal logger class.
/// </summary>
/// <param name="ex">The ex to log to the internal logger.</param>
private void LogException(Exception ex)
{
InternalLogger.Error("Unable to send Sentry request: {0}", ex.Message);
}
private void ProcessPendingEvents(object state)
{
bool?wroteFullBatchSize = false;
AsyncContinuation[] continuations;
bool lockTaken = false;
try
{
if (TimeToSleepBetweenBatches <= 0)
{
Monitor.Enter(this.lockObject);
lockTaken = true;
}
lock (this.continuationQueueLock)
{
continuations = this.flushAllContinuations.Count > 0
? this.flushAllContinuations.ToArray()
: new AsyncContinuation[] { null };
this.flushAllContinuations.Clear();
}
if (this.WrappedTarget == null)
{
InternalLogger.Error("AsyncWrapper '{0}': WrappedTarget is NULL", this.Name);
return;
}
for (int x = 0; x < continuations.Length; x++)
{
var continuation = continuations[x];
int count = this.BatchSize;
if (continuation != null)
{
count = -1; // Dequeue all
}
AsyncLogEventInfo[] logEventInfos = this.RequestQueue.DequeueBatch(count);
if (logEventInfos.Length == 0)
{
wroteFullBatchSize = null; // Nothing to write
}
else if (logEventInfos.Length == BatchSize)
{
wroteFullBatchSize = true;
}
if (InternalLogger.IsTraceEnabled || continuation != null)
{
InternalLogger.Trace("AsyncWrapper '{0}': Flushing {1} events.", this.Name, logEventInfos.Length);
}
if (continuation != null)
{
// write all events, then flush, then call the continuation
this.WrappedTarget.WriteAsyncLogEvents(logEventInfos, ex => this.WrappedTarget.Flush(continuation));
}
else
{
// just write all events
this.WrappedTarget.WriteAsyncLogEvents(logEventInfos);
}
}
}
catch (Exception exception)
{
wroteFullBatchSize = false; // Something went wrong, lets throttle retry
InternalLogger.Error(exception, "AsyncWrapper '{0}': Error in lazy writer timer procedure.", this.Name);
if (exception.MustBeRethrown())
{
throw;
}
}
finally
{
if (TimeToSleepBetweenBatches <= 0 && wroteFullBatchSize == true)
{
this.StartInstantWriterTimer(); // Found full batch, fast schedule to take next batch (within lock to avoid pile up)
}
if (lockTaken)
{
Monitor.Exit(this.lockObject);
}
if (TimeToSleepBetweenBatches <= 0)
{
// If queue was not empty, then more might have arrived while writing the first batch
// Uses throttled timer here, so we can process in batches (faster)
if (wroteFullBatchSize.HasValue && !wroteFullBatchSize.Value)
{
this.StartLazyWriterTimer(); // Queue was not empty, more might have come (Skip expensive RequestQueue-check)
}
else if (!wroteFullBatchSize.HasValue)
{
if (this.RequestQueue.RequestCount > 0)
{
this.StartLazyWriterTimer(); // Queue was checked as empty, but now we have more
}
else
{
lock (this.continuationQueueLock)
if (this.flushAllContinuations.Count > 0)
{
this.StartLazyWriterTimer();
} // Flush queue was checked as empty, but now we have more
}
}
}
else
{
this.StartLazyWriterTimer();
}
}
}
private void SendBatch(IEnumerable <LogEventInfo> logEvents)
{
//Checks target is initialized and not disposed
if (_client == null)
{
throw new ObjectDisposedException("AwsSqsTarget", "AmazonSQSClient for AwsSqsTarget is NULL. Target may not have been initialized or was disposed.");
}
//Create batch of messages
List <Amazon.SQS.Model.SendMessageBatchRequestEntry> sendMesssageReqs = new List <Amazon.SQS.Model.SendMessageBatchRequestEntry>();
int id = 0;
foreach (var logEvent in logEvents)
{
//Renders the message using the current layout
Amazon.SQS.Model.SendMessageBatchRequestEntry batchReqEntry = new Amazon.SQS.Model.SendMessageBatchRequestEntry();
batchReqEntry.DelaySeconds = DelaySeconds;
batchReqEntry.MessageBody = this.Layout.Render(logEvent);
batchReqEntry.Id = id.ToString();
//Write message attributes
batchReqEntry.MessageAttributes.Add("Logger", new Amazon.SQS.Model.MessageAttributeValue()
{
StringValue = logEvent.LoggerName, DataType = "String"
});
batchReqEntry.MessageAttributes.Add("Level", new Amazon.SQS.Model.MessageAttributeValue()
{
StringValue = logEvent.Level.ToString(), DataType = "String"
});
batchReqEntry.MessageAttributes.Add("SequenceID", new Amazon.SQS.Model.MessageAttributeValue()
{
StringValue = logEvent.SequenceID.ToString(), DataType = "Number"
});
//Other LogEventInfo Properties ...
//logEvent.Parameters;
//logEvent.Properties;
//logEvent.Message;
//logEvent.FormattedMessage;
//logEvent.TimeStamp;
//logEvent.Exception;
//logEvent.FormatProvider;
//logEvent.HasStackTrace;
//logEvent.StackTrace;
//logEvent.UserStackFrame;
//logEvent.UserStackFrameNumber;
sendMesssageReqs.Add(batchReqEntry);
id++; //increment message id;
}
//Sends the batch of messages
Amazon.SQS.Model.SendMessageBatchRequest batchReq = new Amazon.SQS.Model.SendMessageBatchRequest(QueueUrl, sendMesssageReqs);
var result = _client.SendMessageBatchAsync(batchReq).ConfigureAwait(false).GetAwaiter().GetResult();
//Check result for failed messages
if (result.Failed.Count > 0)
{
var m = result.Failed.Count.ToString() + " messages sent to Amazon SQS failed. See internal NLog log for details.";
InternalLogger.Error(m);
foreach (var f in result.Failed)
{
InternalLogger.Error("Message failed to send. Code = " + f.Code
+ ", Id = " + f.Id
+ ", SenderFault = " + f.SenderFault.ToString()
+ ", Message = " + f.Message);
}
if (ThrowExceptions)
{
throw new Exception(m);
}
}
}
public string FormPayload(AsyncLogEventInfo ev)
{
var logEvent = ev.LogEvent;
//var document = GetAllProperties(logEvent);
//document.Add("date", logEvent.TimeStamp);
//document.Add("level", logEvent.Level.Name);
//document.Add("message", RenderLogEvent(Layout, logEvent));
var document = new Dictionary <string, object>
{
{ "date", logEvent.TimeStamp },
{ "level", logEvent.Level.Name },
{ "message", RenderLogEvent(Layout, logEvent) }
};
if (Source != null)
{
document.Add("ddsource", Source);
}
if (Service != null)
{
document.Add("service", Service);
}
if (Host != null)
{
document.Add("host", Host);
}
if (Tags != null)
{
document.Add("ddtags", Tags);
}
if (logEvent.Exception != null)
{
var jsonString = JsonConvert.SerializeObject(logEvent.Exception, _jsonSerializerSettings.Value);
var ex = JsonConvert.DeserializeObject <ExpandoObject>(jsonString);
document.Add("exception", ex.ReplaceDotInKeys());
}
foreach (var field in Fields)
{
var renderedField = RenderLogEvent(field.Layout, logEvent);
if (string.IsNullOrWhiteSpace(renderedField))
{
continue;
}
try
{
document[field.Name] =
renderedField.ToSystemType(field.LayoutType, logEvent.FormatProvider, JsonSerializer);
}
catch (Exception ex)
{
_jsonSerializer = null; // Reset as it might now be in bad state
InternalLogger.Error(ex, "ElasticSearch: Error while formatting field: {0}", field.Name);
}
}
if (IncludeAllProperties && logEvent.HasProperties)
{
foreach (var p in logEvent.Properties)
{
var propertyKey = p.Key.ToString();
if (_excludedProperties.Contains(propertyKey))
{
continue;
}
if (document.ContainsKey(propertyKey))
{
continue;
}
document[propertyKey] = p.Value;
}
}
var result = JsonConvert.SerializeObject(document, Formatting.None, Settings);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionMethodExpression" /> class.
/// </summary>
/// <param name="conditionMethodName">Name of the condition method.</param>
/// <param name="methodInfo"><see cref="MethodInfo"/> of the condition method.</param>
/// <param name="methodParameters">The method parameters.</param>
public ConditionMethodExpression(string conditionMethodName, MethodInfo methodInfo, IEnumerable <ConditionExpression> methodParameters)
{
this.MethodInfo = methodInfo;
this.conditionMethodName = conditionMethodName;
this.MethodParameters = new List <ConditionExpression>(methodParameters).AsReadOnly();
ParameterInfo[] formalParameters = this.MethodInfo.GetParameters();
if (formalParameters.Length > 0 && formalParameters[0].ParameterType == typeof(LogEventInfo))
{
this.acceptsLogEvent = true;
}
int actualParameterCount = this.MethodParameters.Count;
if (this.acceptsLogEvent)
{
actualParameterCount++;
}
// Count the number of required and optional parameters
int requiredParametersCount = 0;
int optionalParametersCount = 0;
foreach (var param in formalParameters)
{
if (param.IsOptional)
{
++optionalParametersCount;
}
else
{
++requiredParametersCount;
}
}
if (!((actualParameterCount >= requiredParametersCount) && (actualParameterCount <= formalParameters.Length)))
{
string message;
if (optionalParametersCount > 0)
{
message = string.Format(
CultureInfo.InvariantCulture,
"Condition method '{0}' requires between {1} and {2} parameters, but passed {3}.",
conditionMethodName,
requiredParametersCount,
formalParameters.Length,
actualParameterCount);
}
else
{
message = string.Format(
CultureInfo.InvariantCulture,
"Condition method '{0}' requires {1} parameters, but passed {2}.",
conditionMethodName,
requiredParametersCount,
actualParameterCount);
}
InternalLogger.Error(message);
throw new ConditionParseException(message);
}
this.lateBoundMethod = Internal.ReflectionHelpers.CreateLateBoundMethod(MethodInfo);
if (formalParameters.Length > MethodParameters.Count)
{
this.lateBoundMethodDefaultParameters = new object[formalParameters.Length - MethodParameters.Count];
for (int i = MethodParameters.Count; i < formalParameters.Length; ++i)
{
ParameterInfo param = formalParameters[i];
this.lateBoundMethodDefaultParameters[i - MethodParameters.Count] = param.DefaultValue;
}
}
else
{
this.lateBoundMethodDefaultParameters = null;
}
}
public void WriteToStringWriterTests()
{
try
{
// Expected result is the same for both types of method invocation.
const string expected = "Warn WWW\nError EEE\nFatal FFF\nTrace TTT\nDebug DDD\nInfo III\n";
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
{
StringWriter writer1 = new StringWriter()
{
NewLine = "\n"
};
InternalLogger.LogWriter = writer1;
// Named (based on LogLevel) public methods.
InternalLogger.Warn("WWW");
InternalLogger.Error("EEE");
InternalLogger.Fatal("FFF");
InternalLogger.Trace("TTT");
InternalLogger.Debug("DDD");
InternalLogger.Info("III");
TestWriter(expected, writer1);
}
{
//
// Reconfigure the LogWriter.
StringWriter writer2 = new StringWriter()
{
NewLine = "\n"
};
InternalLogger.LogWriter = writer2;
// Invoke Log(LogLevel, string) for every log level.
InternalLogger.Log(LogLevel.Warn, "WWW");
InternalLogger.Log(LogLevel.Error, "EEE");
InternalLogger.Log(LogLevel.Fatal, "FFF");
InternalLogger.Log(LogLevel.Trace, "TTT");
InternalLogger.Log(LogLevel.Debug, "DDD");
InternalLogger.Log(LogLevel.Info, "III");
TestWriter(expected, writer2);
}
{
//
// Reconfigure the LogWriter.
StringWriter writer2 = new StringWriter()
{
NewLine = "\n"
};
InternalLogger.LogWriter = writer2;
// Invoke Log(LogLevel, string) for every log level.
InternalLogger.Log(LogLevel.Warn, () => "WWW");
InternalLogger.Log(LogLevel.Error, () => "EEE");
InternalLogger.Log(LogLevel.Fatal, () => "FFF");
InternalLogger.Log(LogLevel.Trace, () => "TTT");
InternalLogger.Log(LogLevel.Debug, () => "DDD");
InternalLogger.Log(LogLevel.Info, () => "III");
TestWriter(expected, writer2);
}
}
finally
{
InternalLogger.Reset();
}
}
public void ExceptionTests()
{
using (new InternalLoggerScope())
{
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
var ex1 = new Exception("e1");
var ex2 = new Exception("e2", new Exception("inner"));
var ex3 = new NLogConfigurationException("config error");
var ex4 = new NLogConfigurationException("config error", ex2);
var ex5 = new PathTooLongException();
ex5.Data["key1"] = "value1";
Exception ex6 = null;
const string prefix = " Exception: ";
{
string expected =
"Warn WWW1" + prefix + ex1 + Environment.NewLine +
"Error EEE1" + prefix + ex2 + Environment.NewLine +
"Fatal FFF1" + prefix + ex3 + Environment.NewLine +
"Trace TTT1" + prefix + ex4 + Environment.NewLine +
"Debug DDD1" + prefix + ex5 + Environment.NewLine +
"Info III1" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Warn(ex1, "WWW1");
InternalLogger.Error(ex2, "EEE1");
InternalLogger.Fatal(ex3, "FFF1");
InternalLogger.Trace(ex4, "TTT1");
InternalLogger.Debug(ex5, "DDD1");
InternalLogger.Info(ex6, "III1");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
{
string expected =
"Warn WWW2" + prefix + ex1 + Environment.NewLine +
"Error EEE2" + prefix + ex2 + Environment.NewLine +
"Fatal FFF2" + prefix + ex3 + Environment.NewLine +
"Trace TTT2" + prefix + ex4 + Environment.NewLine +
"Debug DDD2" + prefix + ex5 + Environment.NewLine +
"Info III2" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Warn(ex1, () => "WWW2");
InternalLogger.Error(ex2, () => "EEE2");
InternalLogger.Fatal(ex3, () => "FFF2");
InternalLogger.Trace(ex4, () => "TTT2");
InternalLogger.Debug(ex5, () => "DDD2");
InternalLogger.Info(ex6, () => "III2");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
{
string expected =
"Warn WWW3" + prefix + ex1 + Environment.NewLine +
"Error EEE3" + prefix + ex2 + Environment.NewLine +
"Fatal FFF3" + prefix + ex3 + Environment.NewLine +
"Trace TTT3" + prefix + ex4 + Environment.NewLine +
"Debug DDD3" + prefix + ex5 + Environment.NewLine +
"Info III3" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Log(ex1, LogLevel.Warn, "WWW3");
InternalLogger.Log(ex2, LogLevel.Error, "EEE3");
InternalLogger.Log(ex3, LogLevel.Fatal, "FFF3");
InternalLogger.Log(ex4, LogLevel.Trace, "TTT3");
InternalLogger.Log(ex5, LogLevel.Debug, "DDD3");
InternalLogger.Log(ex6, LogLevel.Info, "III3");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
{
string expected =
"Warn WWW4" + prefix + ex1 + Environment.NewLine +
"Error EEE4" + prefix + ex2 + Environment.NewLine +
"Fatal FFF4" + prefix + ex3 + Environment.NewLine +
"Trace TTT4" + prefix + ex4 + Environment.NewLine +
"Debug DDD4" + prefix + ex5 + Environment.NewLine +
"Info III4" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
InternalLogger.LogWriter = consoleOutWriter;
// Named (based on LogLevel) public methods.
InternalLogger.Log(ex1, LogLevel.Warn, () => "WWW4");
InternalLogger.Log(ex2, LogLevel.Error, () => "EEE4");
InternalLogger.Log(ex3, LogLevel.Fatal, () => "FFF4");
InternalLogger.Log(ex4, LogLevel.Trace, () => "TTT4");
InternalLogger.Log(ex5, LogLevel.Debug, () => "DDD4");
InternalLogger.Log(ex6, LogLevel.Info, () => "III4");
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
}
}
public void VerifyInternalLoggerLevelFilter(bool?internalLogToTrace, bool?logToTrace)
{
foreach (LogLevel logLevelConfig in LogLevel.AllLevels)
{
var mockTraceListener = SetupTestConfiguration <MockTraceListener>(logLevelConfig, internalLogToTrace, logToTrace);
List <string> expected = new List <string>();
string input = "Logger1 Hello";
expected.Add(input);
InternalLogger.Trace(input);
InternalLogger.Debug(input);
InternalLogger.Info(input);
InternalLogger.Warn(input);
InternalLogger.Error(input);
InternalLogger.Fatal(input);
input += "No.{0}";
expected.Add(string.Format(input, 1));
InternalLogger.Trace(input, 1);
InternalLogger.Debug(input, 1);
InternalLogger.Info(input, 1);
InternalLogger.Warn(input, 1);
InternalLogger.Error(input, 1);
InternalLogger.Fatal(input, 1);
input += ", We come in {1}";
expected.Add(string.Format(input, 1, "Peace"));
InternalLogger.Trace(input, 1, "Peace");
InternalLogger.Debug(input, 1, "Peace");
InternalLogger.Info(input, 1, "Peace");
InternalLogger.Warn(input, 1, "Peace");
InternalLogger.Error(input, 1, "Peace");
InternalLogger.Fatal(input, 1, "Peace");
input += " and we are {2} to god";
expected.Add(string.Format(input, 1, "Peace", true));
InternalLogger.Trace(input, 1, "Peace", true);
InternalLogger.Debug(input, 1, "Peace", true);
InternalLogger.Info(input, 1, "Peace", true);
InternalLogger.Warn(input, 1, "Peace", true);
InternalLogger.Error(input, 1, "Peace", true);
InternalLogger.Fatal(input, 1, "Peace", true);
input += ", Please don't {3}";
expected.Add(string.Format(input, 1, "Peace", true, null));
InternalLogger.Trace(input, 1, "Peace", true, null);
InternalLogger.Debug(input, 1, "Peace", true, null);
InternalLogger.Info(input, 1, "Peace", true, null);
InternalLogger.Warn(input, 1, "Peace", true, null);
InternalLogger.Error(input, 1, "Peace", true, null);
InternalLogger.Fatal(input, 1, "Peace", true, null);
input += " the {4}";
expected.Add(string.Format(input, 1, "Peace", true, null, "Messenger"));
InternalLogger.Trace(input, 1, "Peace", true, null, "Messenger");
InternalLogger.Debug(input, 1, "Peace", true, null, "Messenger");
InternalLogger.Info(input, 1, "Peace", true, null, "Messenger");
InternalLogger.Warn(input, 1, "Peace", true, null, "Messenger");
InternalLogger.Error(input, 1, "Peace", true, null, "Messenger");
InternalLogger.Fatal(input, 1, "Peace", true, null, "Messenger");
Assert.Equal(expected.Count * (LogLevel.Fatal.Ordinal - logLevelConfig.Ordinal + 1), mockTraceListener.Messages.Count);
for (int i = 0; i < expected.Count; ++i)
{
int msgCount = LogLevel.Fatal.Ordinal - logLevelConfig.Ordinal + 1;
for (int j = 0; j < msgCount; ++j)
{
Assert.Contains(expected[i], mockTraceListener.Messages.First());
mockTraceListener.Messages.RemoveAt(0);
}
}
Assert.Empty(mockTraceListener.Messages);
}
}
private void UpdateEventLogSource()
{
if (!_needEventLogSourceUpdate)
{
return;
}
lock (this)
{
_operational = false;
// if we throw anywhere, we remain non-operational
try
{
if (!_needEventLogSourceUpdate)
{
return;
}
if (EventLog.SourceExists(_sourceName, _machineName))
{
string currentLogName = EventLog.LogNameFromSourceName(_sourceName, _machineName);
if (currentLogName != _logName)
{
// re-create the association between Log and Source
EventLog.DeleteEventSource(_sourceName, _machineName);
#if DOTNET_2_0
EventSourceCreationData escd = new EventSourceCreationData(_sourceName, _logName);
escd.MachineName = _machineName;
EventLog.CreateEventSource(escd);
#else
EventLog.CreateEventSource(_sourceName, _logName, _machineName);
#endif
}
else
{
// ok, Source registered and associated with the correct Log
}
}
else
{
#if DOTNET_2_0
EventSourceCreationData escd = new EventSourceCreationData(_sourceName, _logName);
escd.MachineName = _machineName;
EventLog.CreateEventSource(escd);
#else
// source doesn't exist, register it.
EventLog.CreateEventSource(_sourceName, _logName, _machineName);
#endif
}
// mark the configuration as operational
_operational = true;
}
catch (Exception ex)
{
InternalLogger.Error("Error when connecting to EventLog: {0}", ex);
}
finally
{
_needEventLogSourceUpdate = false;
}
}
}
private void AwsLogLibraryAlert(object sender, AWSLoggerCore.LogLibraryEventArgs e)
{
InternalLogger.Error(e.Exception, "AWSTarget(Name={0}) - CloudWatch Network Error - ServiceUrl={1}", Name, e.ServiceUrl);
}
public void AddToArchive(string archiveFileName, string fileName, bool createDirectoryIfNotExists)
{
if (MaxArchiveFileToKeep < 1)
{
InternalLogger.Warn("AddToArchive is called. Even though the MaxArchiveFiles is set to less than 1");
return;
}
if (!File.Exists(fileName))
{
InternalLogger.Error("Error while trying to archive, Source File : {0} Not found.", fileName);
return;
}
while (archiveFileEntryQueue.Count >= MaxArchiveFileToKeep)
{
string oldestArchivedFileName = archiveFileEntryQueue.Dequeue();
try
{
File.Delete(oldestArchivedFileName);
}
catch (Exception exceptionThrown)
{
InternalLogger.Warn("Can't Delete Old Archive File : {0} , Exception : {1}", oldestArchivedFileName, exceptionThrown);
}
}
String archiveFileNamePattern = archiveFileName;
if (archiveFileEntryQueue.Contains(archiveFileName))
{
InternalLogger.Trace("Archive File {0} seems to be already exist. Trying with Different File Name..", archiveFileName);
int NumberToStartWith = 1;
archiveFileNamePattern = Path.GetFileNameWithoutExtension(archiveFileName) + ".{#}" + Path.GetExtension(archiveFileName);
while (File.Exists(ReplaceNumber(archiveFileNamePattern, NumberToStartWith)))
{
InternalLogger.Trace("Archive File {0} seems to be already exist, too. Trying with Different File Name..", archiveFileName);
NumberToStartWith++;
}
}
try
{
File.Move(fileName, archiveFileNamePattern);
}
catch (DirectoryNotFoundException)
{
if (createDirectoryIfNotExists)
{
InternalLogger.Trace("Directory For Archive File is not created. Creating it..");
try
{
Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
File.Move(fileName, archiveFileNamePattern);
}
catch (Exception ExceptionThrown)
{
InternalLogger.Error("Can't create Archive File Directory , Exception : {0}", ExceptionThrown);
throw;
}
}
else
{
throw;
}
}
catch (Exception ExceptionThrown)
{
InternalLogger.Error("Can't Archive File : {0} , Exception : {1}", fileName, ExceptionThrown);
throw;
}
archiveFileEntryQueue.Enqueue(archiveFileName);
}
/// <summary>
/// Never throws
/// </summary>
private void StartConnection(IConnection oldConnection, int timeoutMilliseconds, bool checkInitialized)
{
if (!ReferenceEquals(oldConnection, _Connection) && (_Model?.IsOpen ?? false))
{
return;
}
var t = Task.Run(() =>
{
// Do not lock on SyncRoot, as we are waiting on this task while holding SyncRoot-lock
lock (_sync)
{
if (checkInitialized && !IsInitialized)
{
return;
}
if (!ReferenceEquals(oldConnection, _Connection) && (_Model?.IsOpen ?? false))
{
return;
}
InternalLogger.Info("RabbitMQTarget(Name={0}): Connection attempt started...", Name);
oldConnection = _Connection ?? oldConnection;
if (oldConnection != null)
{
var shutdownEvenArgs = new ShutdownEventArgs(ShutdownInitiator.Application, 504 /*Constants.ChannelError*/,
"Model not open to RabbitMQ instance", null);
ShutdownAmqp(oldConnection, shutdownEvenArgs);
}
IModel model = null;
IConnection connection = null;
string exchange = null;
try
{
var factory = GetConnectionFac(out exchange, out var exchangeType, out var clientProvidedName);
connection = string.IsNullOrEmpty(clientProvidedName) ? factory.CreateConnection() : factory.CreateConnection(clientProvidedName);
connection.ConnectionShutdown += (s, e) => ShutdownAmqp(ReferenceEquals(_Connection, connection) ? connection : null, e);
try
{
model = connection.CreateModel();
}
catch (Exception e)
{
InternalLogger.Error(e, "RabbitMQTarget(Name={0}): Could not create model, {1}", Name, e.Message);
throw;
}
if (model != null && !Passive)
{
try
{
model.ExchangeDeclare(exchange, exchangeType, Durable);
}
catch (Exception e)
{
InternalLogger.Error(e, string.Format("RabbitMQTarget(Name={0}): Could not declare exchange={1}. Error={2}", Name, exchange, e.Message));
throw;
}
}
}
catch (Exception e)
{
var shutdownConnection = connection;
connection = null;
if (shutdownConnection == null)
{
InternalLogger.Error(e, string.Format("RabbitMQTarget(Name={0}): Could not connect to Rabbit instance: {1}", Name, e.Message));
}
else
{
model?.Dispose();
model = null;
shutdownConnection.Close(TimeSpan.FromMilliseconds(1000));
shutdownConnection.Abort(TimeSpan.FromMilliseconds(1000));
}
}
finally
{
if (connection != null && model != null)
{
if ((_Model?.IsOpen ?? false))
{
InternalLogger.Info("RabbitMQTarget(Name={0}): Connection attempt completed succesfully, but not needed", Name);
}
else
{
_Connection = connection;
_Model = model;
_ModelExchange = exchange;
InternalLogger.Info("RabbitMQTarget(Name={0}): Connection attempt completed succesfully", Name);
}
}
}
}
});
var completedTask = Task.WhenAny(t, Task.Delay(TimeSpan.FromMilliseconds(timeoutMilliseconds))).ConfigureAwait(false).GetAwaiter().GetResult();
if (!ReferenceEquals(completedTask, t))
{
InternalLogger.Warn("RabbitMQTarget(Name={0}): Starting connection-task timed out, continuing", Name);
}
else if (completedTask.Exception != null)
{
InternalLogger.Error(completedTask.Exception, "RabbitMQTarget(Name={0}): Starting connection-task failed: {0}", Name, completedTask.Exception.Message);
}
}
/// <summary>
/// Sends the
/// rendered logging event over the network optionally concatenating it with a newline character.
/// </summary>
/// <param name="logEvent">The logging event.</param>
protected override void Write(AsyncLogEventInfo logEvent)
{
string address = RenderLogEvent(Address, logEvent.LogEvent);
InternalLogger.Trace("NetworkTarget(Name={0}): Sending to address: '{1}'", Name, address);
byte[] bytes = GetBytesToWrite(logEvent.LogEvent);
if (KeepConnection)
{
LinkedListNode <NetworkSender> senderNode;
try
{
senderNode = GetCachedNetworkSender(address);
}
catch (Exception ex)
{
InternalLogger.Error(ex, "NetworkTarget(Name={0}): Failed to create sender to address: '{1}'", Name, address);
throw;
}
ChunkedSend(
senderNode.Value,
bytes,
ex =>
{
if (ex != null)
{
InternalLogger.Error(ex, "NetworkTarget(Name={0}): Error when sending.", Name);
ReleaseCachedConnection(senderNode);
}
logEvent.Continuation(ex);
});
}
else
{
NetworkSender sender;
LinkedListNode <NetworkSender> linkedListNode;
lock (_openNetworkSenders)
{
//handle too many connections
var tooManyConnections = _openNetworkSenders.Count >= MaxConnections;
if (tooManyConnections && MaxConnections > 0)
{
switch (OnConnectionOverflow)
{
case NetworkTargetConnectionsOverflowAction.DiscardMessage:
InternalLogger.Warn("NetworkTarget(Name={0}): Discarding message otherwise to many connections.", Name);
logEvent.Continuation(null);
return;
case NetworkTargetConnectionsOverflowAction.AllowNewConnnection:
InternalLogger.Debug("NetworkTarget(Name={0}): Too may connections, but this is allowed", Name);
break;
case NetworkTargetConnectionsOverflowAction.Block:
while (_openNetworkSenders.Count >= MaxConnections)
{
InternalLogger.Debug("NetworkTarget(Name={0}): Blocking networktarget otherwhise too many connections.", Name);
Monitor.Wait(_openNetworkSenders);
InternalLogger.Trace("NetworkTarget(Name={0}): Entered critical section.", Name);
}
InternalLogger.Trace("NetworkTarget(Name={0}): Limit ok.", Name);
break;
}
}
try
{
sender = CreateNetworkSender(address);
}
catch (Exception ex)
{
InternalLogger.Error(ex, "NetworkTarget(Name={0}): Failed to create sender to address: '{1}'", Name, address);
throw;
}
linkedListNode = _openNetworkSenders.AddLast(sender);
}
ChunkedSend(
sender,
bytes,
ex =>
{
lock (_openNetworkSenders)
{
TryRemove(_openNetworkSenders, linkedListNode);
if (OnConnectionOverflow == NetworkTargetConnectionsOverflowAction.Block)
{
Monitor.PulseAll(_openNetworkSenders);
}
}
if (ex != null)
{
InternalLogger.Error(ex, "NetworkTarget(Name={0}): Error when sending.", Name);
}
sender.Close(ex2 => { });
logEvent.Continuation(ex);
});
}
}
/// <summary>
/// Timer callback method that will log the stats.
/// </summary>
/// <param name="o">mandatory object parameter. (Not used)</param>
private void ReportStats(object o)
{
StringBuilder builder = null;
try
{
PoolConfiguration configuration = (PoolConfiguration)o;
builder = this.Get <StringBuilderPool, StringBuilder>().Get();
builder.Append(StatsPoolNameChars, 0, StatsPoolNameChars.Length);
builder.Append('|');
builder.Append(StatsPoolSizeChars, 0, StatsPoolSizeChars.Length);
builder.Append('|');
builder.Append(StatsObjectsInPoolChars, 0, StatsObjectsInPoolChars.Length);
builder.Append('|');
builder.Append(StatsInUseChars, 0, StatsInUseChars.Length);
builder.Append('|');
builder.Append(StatsGivenOutChars, 0, StatsGivenOutChars.Length);
builder.Append('|');
builder.Append(StatsThrownAwayChars, 0, StatsThrownAwayChars.Length);
builder.Append('|');
builder.Append(StatsNewLine, 0, StatsNewLine.Length);
foreach (var pool in this.pools)
{
pool.WriteStatsTo(builder);
}
if (configuration.ResetPoolStatisticsAfterReporting)
{
lock (this.pools)
{
foreach (var pool in this.pools)
{
pool.ResetStats();
}
}
}
if (!string.IsNullOrEmpty(configuration.PoolStatisticsLoggerName))
{
LogManager.GetLogger(configuration.PoolStatisticsLoggerName).Info(builder.ToString());
}
else
{
InternalLogger.Info(builder.ToString());
}
this.statsTimer.Change(configuration.OutputPoolStatisticsInterval * 1000, Timeout.Infinite);
}
catch (Exception e)
{
InternalLogger.Error("Error occured while reporting pool statistics:{0}", e);
}
finally
{
if (builder != null)
{
try
{
this.PutBack(builder);
}
catch (Exception e)
{
InternalLogger.Error("Error occured while putting back string builder slim into the pool:{0}", e);
}
}
}
}
protected override void Write(LogEventInfo logEvent)
{
if (logEvent == null)
{
return;
}
GraylogMessageBuilder messageBuilder = new GraylogMessageBuilder()
.WithProperty("short_message", logEvent.FormattedMessage)
.WithProperty("host", Host)
.WithLevel(logEvent.Level)
.WithCustomProperty("logger_name", logEvent.LoggerName);
if (!string.IsNullOrEmpty(Facility))
{
messageBuilder.WithCustomProperty("facility", Facility);
}
var properties = GetAllProperties(logEvent);
foreach (var property in properties)
{
try
{
if (!string.IsNullOrEmpty(property.Key))
{
if (Convert.GetTypeCode(property.Value) != TypeCode.Object)
{
messageBuilder.WithCustomProperty(property.Key, property.Value);
}
else
{
messageBuilder.WithCustomProperty(property.Key, property.Value?.ToString());
}
}
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
{
InternalLogger.Error(ex, "GraylogHttp(Name={0}): Fail to handle LogEvent Properties", Name);
}
}
if (logEvent.Exception != null)
{
if (!string.IsNullOrEmpty(logEvent.Exception.Message))
{
messageBuilder.WithCustomProperty("_exception_message", logEvent.Exception.Message);
}
if (!string.IsNullOrEmpty(logEvent.Exception.StackTrace))
{
messageBuilder.WithCustomProperty("_exception_stack_trace", logEvent.Exception.StackTrace);
}
}
try
{
_policy.Execute(() =>
{
var content = new StringContent(messageBuilder.Render(logEvent.TimeStamp), Encoding.UTF8, "application/json");
return(_httpClient.PostAsync(_requestAddress, content).Result.EnsureSuccessStatusCode());
});
}
catch (BrokenCircuitException)
{
InternalLogger.Error(
"GraylogHttp(Name={0}): The Graylog server seems to be inaccessible, the log messages were not sent to the server.",
Name);
}
}
private void ParseIncludeElement(ILoggingConfigurationElement includeElement, string baseDirectory, bool autoReloadDefault)
{
includeElement.AssertName("include");
string newFileName = includeElement.GetRequiredValue("file", "nlog");
var ignoreErrors = includeElement.GetOptionalBooleanValue("ignoreErrors", false);
try
{
newFileName = ExpandSimpleVariables(newFileName);
newFileName = SimpleLayout.Evaluate(newFileName);
var fullNewFileName = newFileName;
if (baseDirectory != null)
{
fullNewFileName = Path.Combine(baseDirectory, newFileName);
}
#if SILVERLIGHT && !WINDOWS_PHONE
newFileName = newFileName.Replace("\\", "/");
if (Application.GetResourceStream(new Uri(fullNewFileName, UriKind.Relative)) != null)
#else
if (File.Exists(fullNewFileName))
#endif
{
InternalLogger.Debug("Including file '{0}'", fullNewFileName);
ConfigureFromFile(fullNewFileName, autoReloadDefault);
}
else
{
//is mask?
if (newFileName.Contains("*"))
{
ConfigureFromFilesByMask(baseDirectory, newFileName, autoReloadDefault);
}
else
{
if (ignoreErrors)
{
//quick stop for performances
InternalLogger.Debug("Skipping included file '{0}' as it can't be found", fullNewFileName);
return;
}
throw new FileNotFoundException("Included file not found: " + fullNewFileName);
}
}
}
catch (Exception exception)
{
if (exception.MustBeRethrownImmediately())
{
throw;
}
var configurationException = new NLogConfigurationException(exception, "Error when including '{0}'.", newFileName);
InternalLogger.Error(exception, configurationException.Message);
if (!ignoreErrors)
{
throw configurationException;
}
}
}
protected override void Write(LogEventInfo logEvent)
{
IBasicProperties basicProperties = this.GetBasicProperties(logEvent);
byte[] message = this.GetMessage(logEvent);
byte[] array = this.CompressMessage(message);
string topic = this.GetTopic(logEvent);
IModel model = this._Model;
bool flag = model == null || !model.IsOpen;
if (flag)
{
this.StartConnection(this._Connection, this.Timeout, true);
model = this._Model;
}
bool flag2 = model == null || !model.IsOpen;
if (flag2)
{
bool flag3 = !this.AddUnsent(topic, basicProperties, array);
if (flag3)
{
throw new InvalidOperationException("LogEvent discarded because RabbitMQ instance is offline and reached MaxBuffer");
}
}
else
{
bool flag4 = true;
try
{
this.CheckUnsent(model);
this.Publish(model, array, basicProperties, topic);
flag4 = false;
}
catch (IOException ex)
{
InternalLogger.Error(ex, "RabbitMQTarget(Name={0}): Could not send to RabbitMQ instance: {1}", new object[]
{
base.Name,
ex.Message
});
bool flag5 = !this.AddUnsent(topic, basicProperties, array);
if (flag5)
{
throw;
}
}
catch (ObjectDisposedException ex2)
{
InternalLogger.Error(ex2, "RabbitMQTarget(Name={0}): Could not send to RabbitMQ instance: {1}", new object[]
{
base.Name,
ex2.Message
});
bool flag6 = !this.AddUnsent(topic, basicProperties, array);
if (flag6)
{
throw;
}
}
catch (Exception ex3)
{
flag4 = false;
InternalLogger.Error(ex3, "RabbitMQTarget(Name={0}): Could not send to RabbitMQ instance: {1}", new object[]
{
base.Name,
ex3.Message
});
throw;
}
finally
{
bool flag7 = flag4;
if (flag7)
{
this.StartConnection(this._Connection, Math.Min(500, this.Timeout), true);
}
}
}
}
private void Send(NLogEvents events, IList <AsyncLogEventInfo> asyncContinuations, AsyncContinuation flushContinuations)
{
if (!OnSend(events, asyncContinuations))
{
if (flushContinuations != null)
{
flushContinuations(null);
}
return;
}
#if WCF_SUPPORTED
var client = CreateLogReceiver();
client.ProcessLogMessagesCompleted += (sender, e) =>
{
if (e.Error != null)
{
InternalLogger.Error(e.Error, "LogReceiverServiceTarget(Name={0}): Error while sending", Name);
}
// report error to the callers
for (int i = 0; i < asyncContinuations.Count; ++i)
{
asyncContinuations[i].Continuation(e.Error);
}
if (flushContinuations != null)
{
flushContinuations(e.Error);
}
// send any buffered events
SendBufferedEvents(null);
};
inCall = true;
#if SILVERLIGHT
if (!Deployment.Current.Dispatcher.CheckAccess())
{
Deployment.Current.Dispatcher.BeginInvoke(() => client.ProcessLogMessagesAsync(events));
}
else
{
client.ProcessLogMessagesAsync(events);
}
#else
client.ProcessLogMessagesAsync(events);
#endif
#else
var client = new SoapLogReceiverClient(this.EndpointAddress);
this.inCall = true;
client.BeginProcessLogMessages(
events,
result =>
{
Exception exception = null;
try
{
client.EndProcessLogMessages(result);
}
catch (Exception ex)
{
InternalLogger.Error(ex, "LogReceiverServiceTarget(Name={0}): Error while sending", Name);
if (ex.MustBeRethrownImmediately())
{
throw; // Throwing exceptions here will crash the entire application (.NET 2.0 behavior)
}
exception = ex;
}
// report error to the callers
for (int i = 0; i < asyncContinuations.Count; ++i)
{
asyncContinuations[i].Continuation(exception);
}
if (flushContinuations != null)
{
flushContinuations(exception);
}
// send any buffered events
this.SendBufferedEvents(null);
},
null);
#endif
}
private void StartConnection(IConnection oldConnection, int timeoutMilliseconds, bool checkInitialized)
{
bool arg_3F_0;
if (oldConnection != this._Connection)
{
IModel expr_30 = this._Model;
arg_3F_0 = (expr_30 != null && expr_30.IsOpen);
}
else
{
arg_3F_0 = false;
}
bool flag = arg_3F_0;
if (!flag)
{
Task task = Task.Factory.StartNew(delegate
{
object sync = this._sync;
bool flag3 = false;
try
{
Monitor.Enter(sync, ref flag3);
bool flag4 = checkInitialized && !this.IsInitialized;
if (!flag4)
{
bool arg_77_0;
if (oldConnection != this._Connection)
{
IModel expr_68 = this._Model;
arg_77_0 = (expr_68 != null && expr_68.IsOpen);
}
else
{
arg_77_0 = false;
}
bool flag5 = arg_77_0;
if (!flag5)
{
InternalLogger.Info <string>("RabbitMQTarget(Name={0}): Connection attempt started...", this.Name);
oldConnection = (this._Connection ?? oldConnection);
bool flag6 = oldConnection != null;
if (flag6)
{
ShutdownEventArgs reason = new ShutdownEventArgs(ShutdownInitiator.Application, 504, "Model not open to RabbitMQ instance", null);
this.ShutdownAmqp(oldConnection, reason);
}
IModel model = null;
IConnection connection = null;
try
{
connection = this.GetConnectionFac().CreateConnection();
connection.ConnectionShutdown += delegate(object s, ShutdownEventArgs e)
{
this.ShutdownAmqp((this._Connection == connection) ? connection : null, e);
};
try
{
model = connection.CreateModel();
}
catch (Exception ex)
{
IConnection connection3 = connection;
connection = null;
InternalLogger.Error(ex, "RabbitMQTarget(Name={0}): Could not create model, {1}", new object[]
{
this.Name,
ex.Message
});
connection3.Close(1000);
connection3.Abort(1000);
}
bool flag7 = model != null && !this.Passive;
if (flag7)
{
try
{
model.ExchangeDeclare(this.Exchange, this.ExchangeType, this.Durable, false, null);
}
catch (Exception ex2)
{
IConnection connection2 = connection;
connection = null;
InternalLogger.Error(ex2, string.Format("RabbitMQTarget(Name={0}): Could not declare exchange: {1}", this.Name, ex2.Message));
model.Dispose();
model = null;
connection2.Close(1000);
connection2.Abort(1000);
}
}
}
catch (Exception ex3)
{
connection = null;
InternalLogger.Error(ex3, string.Format("RabbitMQTarget(Name={0}): Could not connect to Rabbit instance: {1}", this.Name, ex3.Message));
}
finally
{
bool flag8 = connection != null && model != null;
if (flag8)
{
IModel expr_291 = this._Model;
bool flag9 = expr_291 != null && expr_291.IsOpen;
if (flag9)
{
InternalLogger.Info <string>("RabbitMQTarget(Name={0}): Connection attempt completed succesfully, but not needed", this.Name);
}
else
{
this._Connection = connection;
this._Model = model;
InternalLogger.Info <string>("RabbitMQTarget(Name={0}): Connection attempt completed succesfully", this.Name);
}
}
}
}
}
}
finally
{
if (flag3)
{
Monitor.Exit(sync);
}
}
});
bool flag2 = !task.Wait(TimeSpan.FromMilliseconds((double)timeoutMilliseconds));
if (flag2)
{
InternalLogger.Warn <string>("RabbitMQTarget(Name={0}): Starting connection-task timed out, continuing", base.Name);
}
}
}
/// <summary>
/// Sends the
/// rendered logging event over the network optionally concatenating it with a newline character.
/// </summary>
/// <param name="logEvent">The logging event.</param>
protected override void Write(AsyncLogEventInfo logEvent)
{
string address = this.Address.Render(logEvent.LogEvent);
byte[] bytes = this.GetBytesToWrite(logEvent.LogEvent);
if (this.KeepConnection)
{
var senderNode = this.GetCachedNetworkSender(address);
this.ChunkedSend(
senderNode.Value,
bytes,
ex =>
{
if (ex != null)
{
InternalLogger.Error(ex, "Error when sending.");
this.ReleaseCachedConnection(senderNode);
}
logEvent.Continuation(ex);
});
}
else
{
NetworkSender sender;
LinkedListNode <NetworkSender> linkedListNode;
lock (this.openNetworkSenders)
{
//handle too many connections
var tooManyConnections = this.openNetworkSenders.Count >= MaxConnections;
if (tooManyConnections && MaxConnections > 0)
{
switch (this.OnConnectionOverflow)
{
case NetworkTargetConnectionsOverflowAction.DiscardMessage:
InternalLogger.Warn("Discarding message otherwise to many connections.");
logEvent.Continuation(null);
return;
case NetworkTargetConnectionsOverflowAction.AllowNewConnnection:
InternalLogger.Debug("Too may connections, but this is allowed");
break;
case NetworkTargetConnectionsOverflowAction.Block:
while (this.openNetworkSenders.Count >= this.MaxConnections)
{
InternalLogger.Debug("Blocking networktarget otherwhise too many connections.");
System.Threading.Monitor.Wait(this.openNetworkSenders);
InternalLogger.Trace("Entered critical section.");
}
InternalLogger.Trace("Limit ok.");
break;
}
}
sender = this.SenderFactory.Create(address, MaxQueueSize);
sender.Initialize();
linkedListNode = this.openNetworkSenders.AddLast(sender);
}
this.ChunkedSend(
sender,
bytes,
ex =>
{
lock (this.openNetworkSenders)
{
TryRemove(this.openNetworkSenders, linkedListNode);
if (this.OnConnectionOverflow == NetworkTargetConnectionsOverflowAction.Block)
{
System.Threading.Monitor.PulseAll(this.openNetworkSenders);
}
}
if (ex != null)
{
InternalLogger.Error(ex, "Error when sending.");
}
sender.Close(ex2 => { });
logEvent.Continuation(ex);
});
}
}
private void ShutdownAmqp(IConnection connection, ShutdownEventArgs reason)
{
bool flag = reason.ReplyCode != 200;
if (flag)
{
InternalLogger.Warn <string, ushort, string>("RabbitMQTarget(Name={0}): Connection shutdown. ReplyCode={1}, ReplyText={2}", base.Name, reason.ReplyCode, reason.ReplyText);
}
else
{
InternalLogger.Info <string, ushort, string>("RabbitMQTarget(Name={0}): Connection shutdown. ReplyCode={1}, ReplyText={2}", base.Name, reason.ReplyCode, reason.ReplyText);
}
object sync = this._sync;
lock (sync)
{
bool flag3 = connection != null;
if (flag3)
{
IModel model = null;
bool flag4 = connection == this._Connection;
if (flag4)
{
model = this._Model;
this._Connection = null;
this._Model = null;
}
try
{
bool flag5 = reason.ReplyCode == 200 && connection.IsOpen;
if (flag5)
{
if (model != null)
{
model.Close();
}
}
else if (model != null)
{
model.Abort();
}
}
catch (Exception ex)
{
InternalLogger.Error(ex, "RabbitMQTarget(Name={0}): Could not close model: {1}", new object[]
{
base.Name,
ex.Message
});
}
try
{
bool flag6 = reason.ReplyCode == 200 && connection.IsOpen;
if (flag6)
{
connection.Close(reason.ReplyCode, reason.ReplyText, 1500);
}
else
{
connection.Abort(reason.ReplyCode, reason.ReplyText, 1500);
}
}
catch (Exception ex2)
{
InternalLogger.Error(ex2, "RabbitMQTarget(Name={0}): Could not close connection: {1}", new object[]
{
base.Name,
ex2.Message
});
}
}
}
}
/// <summary>
/// Creates new task to handle the writing of the input <see cref="LogEventInfo"/>
/// </summary>
/// <param name="logEvent">LogEvent to write</param>
/// <returns>New Task created [true / false]</returns>
private bool TaskCreation(AsyncLogEventInfo logEvent)
{
try
{
if (_cancelTokenSource.IsCancellationRequested)
{
logEvent.Continuation(null);
return(false);
}
if (logEvent.LogEvent == null)
{
InternalLogger.Debug("{0} Flush Completed", Name);
logEvent.Continuation(null);
return(false);
}
var newTask = WriteAsyncTask(logEvent.LogEvent, _cancelTokenSource.Token);
if (newTask == null)
{
InternalLogger.Debug("{0} WriteAsyncTask returned null", Name);
}
else
{
lock (SyncRoot)
{
_previousTask = newTask;
if (TaskTimeoutSeconds > 0)
{
_taskTimeoutTimer.Change(TaskTimeoutSeconds * 1000, Timeout.Infinite);
}
// NOTE - Not using _cancelTokenSource for ContinueWith, or else they will also be cancelled on timeout
#if (SILVERLIGHT && !WINDOWS_PHONE) || NET4_0
var continuation = logEvent.Continuation;
_previousTask.ContinueWith(completedTask => TaskCompletion(completedTask, continuation));
#else
_previousTask.ContinueWith(_taskCompletion, logEvent.Continuation);
#endif
if (_previousTask.Status == TaskStatus.Created)
{
_previousTask.Start(TaskScheduler);
}
}
return(true);
}
}
catch (Exception ex)
{
try
{
InternalLogger.Error(ex, "{0} WriteAsyncTask failed on creation", Name);
logEvent.Continuation(ex);
}
catch
{
// Don't wanna die
}
}
return(false);
}
internal void DoInvoke(object[] parameters, AsyncContinuation continuation, HttpWebRequest request, Func <AsyncCallback, IAsyncResult> beginFunc,
Func <IAsyncResult, Stream> getStreamFunc)
{
Stream postPayload = null;
if (Protocol == WebServiceProtocol.HttpGet)
{
PrepareGetRequest(request);
}
else
{
if (_activeProtocol.Value == null)
{
_activeProtocol = new KeyValuePair <WebServiceProtocol, HttpPostFormatterBase>(this.Protocol, _postFormatterFactories[this.Protocol](this));
}
postPayload = _activeProtocol.Value.PrepareRequest(request, parameters);
}
AsyncContinuation sendContinuation =
ex =>
{
if (ex != null)
{
DoInvokeCompleted(continuation, ex);
return;
}
try
{
request.BeginGetResponse(
r =>
{
try
{
using (var response = request.EndGetResponse(r))
{
}
DoInvokeCompleted(continuation, null);
}
catch (Exception ex2)
{
InternalLogger.Error(ex2, "Error when sending to Webservice: {0}", this.Name);
if (ex2.MustBeRethrown())
{
throw;
}
DoInvokeCompleted(continuation, ex2);
}
},
null);
}
catch (Exception ex2)
{
InternalLogger.Error(ex2, "Error when sending to Webservice: {0}", this.Name);
if (ex2.MustBeRethrown())
{
throw;
}
DoInvokeCompleted(continuation, ex2);
}
};
if (postPayload != null && postPayload.Length > 0)
{
postPayload.Position = 0;
try
{
pendingManualFlushList.BeginOperation();
beginFunc(
result =>
{
try
{
using (Stream stream = getStreamFunc(result))
{
WriteStreamAndFixPreamble(postPayload, stream, this.IncludeBOM, this.Encoding);
postPayload.Dispose();
}
sendContinuation(null);
}
catch (Exception ex)
{
InternalLogger.Error(ex, "Error when sending to Webservice: {0}", this.Name);
if (ex.MustBeRethrown())
{
throw;
}
postPayload.Dispose();
DoInvokeCompleted(continuation, ex);
}
});
}
catch (Exception ex)
{
InternalLogger.Error(ex, "Error when sending to Webservice: {0}", this.Name);
if (ex.MustBeRethrown())
{
throw;
}
DoInvokeCompleted(continuation, ex);
}
}
else
{
pendingManualFlushList.BeginOperation();
sendContinuation(null);
}
}
