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";
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.IncludeTimestamp = false;
InternalLogger.LogToConsole = true;
{
StringWriter consoleOutWriter1 = new StringWriter()
{
NewLine = "\n"
};
// Redirect the console output to a StringWriter.
Console.SetOut(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"
};
Console.SetOut(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);
}
}
private void WriteLogEntries(IList <LogEntry> logEntries, object continuationList)
{
bool withinTaskLimit = Interlocked.Increment(ref _pendingTaskCount) <= TaskPendingLimit;
try
{
if (!withinTaskLimit)
{
// The task queue has become too long. We will throttle, and wait for the task-queue to become shorter
InternalLogger.Debug("GoogleStackdriver(Name={0}): Throttle started because {1} tasks are pending", Name, _pendingTaskCount);
for (int i = -100; i < TimeoutSeconds * 1000; i += 100)
{
withinTaskLimit = _prevTask?.Wait(100, _cancelTokenSource.Token) ?? true; // Throttle
if (withinTaskLimit)
{
_pendingTaskCount = 1; // All pending tasks has completed
break;
}
if (Interlocked.Read(ref _pendingTaskCount) < TaskPendingLimit)
{
withinTaskLimit = true; // Some pending tasks has completed
break;
}
}
if (!withinTaskLimit)
{
// The tasks queue is not moving. We start a new task queue and ignores the old one
InternalLogger.Info("GoogleStackdriver(Name={0}): Throttle timeout but {1} tasks are still pending", Name, _pendingTaskCount);
}
}
if (withinTaskLimit && _prevTask != null)
{
_prevTask = _prevTask.ContinueWith(_writeLogEntriesBegin, logEntries, _cancelTokenSource.Token);
}
else
{
_prevTask = WriteLogEntriesBegin(null, logEntries);
}
_prevTask = _prevTask.ContinueWith(_writeLogEntriesCompleted, continuationList);
}
catch (Exception ex)
{
Interlocked.Decrement(ref _pendingTaskCount);
InternalLogger.Error(ex, "GoogleStackdriver(Name={0}): Failed to begin writing {1} LogEntries", Name, logEntries.Count);
throw;
}
}
public ShadowView(Context context, View shadowSource, float cornerRadius, string tag = null)
: base(context)
{
_renderScript = RenderScript.Create(context);
_weakSource = new JniWeakReference <View>(shadowSource);
_cache = BitmapCache.Instance;
_shadeInfos = new Dictionary <Shade, ShadeInfo>();
_cornerRadius = cornerRadius;
LogTag = !string.IsNullOrEmpty(tag) ? $"{nameof(ShadowView)}@{tag}" : nameof(ShadowView);
InternalLogger.Debug(LogTag, () => $"ShadowView(): {++instanceCount} instances");
}
protected override void OnLayout(bool changed, int l, int t, int r, int b)
{
base.OnLayout(changed, l, t, r, b);
InternalLogger.Debug(_tag, () => $"OnLayout( {l}l, {t}t, {r}r, {b}b )");
var children = GetChildAt(1);
if (children == null)
{
return;
}
_shadowView?.Layout(children.MeasuredWidth, children.MeasuredHeight);
}
public void Log()
{
lock (_cacheLock)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine();
stringBuilder.AppendLine($"BitmapCache: {_cache.Count} bitmaps");
foreach (var keyValue in _cache)
{
stringBuilder.AppendLine($" {keyValue.Key}:{keyValue.Value.ReferenceCount:00}");
}
InternalLogger.Debug(LogTag, () => stringBuilder.ToString());
}
}
private void DisposeBitmap(Shade shade)
{
#if DEBUG
var stopWatch = new Stopwatch();
stopWatch.Start();
#endif
InternalLogger.Debug(LogTag, () => $"DisposeBitmap( shade: {shade} )");
var shadeInfo = _shadeInfos[shade];
_shadeInfos.Remove(shade);
_cache.Remove(shadeInfo.Hash);
#if DEBUG
LogPerf(LogTag, stopWatch);
#endif
}
public Bitmap Add(string hash, Func <Bitmap> create)
{
InternalLogger.Debug(LogTag, () => $"Add( hash: {hash} )");
lock (_cacheLock)
{
if (_cache.TryGetValue(hash, out var bucket))
{
bucket.ReferenceCount++;
InternalLogger.Debug(LogTag, () => $"Reference count: {bucket.ReferenceCount}");
return(bucket.Value);
}
return(Create(hash, create));
}
}
/// <summary>
/// Renders the specified ASP.NET Session value and appends it to the specified <see cref="StringBuilder" />.
/// </summary>
/// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param>
/// <param name="logEvent">Logging event.</param>
protected override void DoAppend(StringBuilder builder, LogEventInfo logEvent)
{
if (this.Variable == null)
{
return;
}
var context = HttpContextAccessor.HttpContext;
if (context?.Session == null)
{
InternalLogger.Debug("Session is null");
return;
}
#if !ASP_NET_CORE
var value = PropertyReader.GetValue(Variable, k => context.Session[k], EvaluateAsNestedProperties);
#else
if (context.Items == null || context.Features.Get <ISessionFeature>()?.Session == null)
{
return;
}
//because session.get / session.getstring also creating log messages in some cases, this could lead to stackoverflow issues.
//We remember on the context.Items that we are looking up a session value so we prevent stackoverflows
if (context.Items.ContainsKey(NLogRetrievingSessionValue))
{
return;
}
context.Items[NLogRetrievingSessionValue] = true;
object value;
try
{
value = PropertyReader.GetValue(Variable, k => context.Session.GetString(k), EvaluateAsNestedProperties);
}
catch (Exception ex)
{
InternalLogger.Warn(ex, "Retrieving session value failed. ");
return;
}
finally
{
context.Items.Remove(NLogRetrievingSessionValue);
}
#endif
var formatProvider = GetFormatProvider(logEvent, Culture);
builder.Append(Convert.ToString(value, formatProvider));
}
private bool TaskCreation(AsyncLogEventInfo logEvent)
{
try
{
if (_cancelTokenSource.IsCancellationRequested)
{
logEvent.Continuation(null);
return(false);
}
if (logEvent.LogEvent == null)
{
InternalLogger.Debug("{0} Flush Completed", this.Name);
logEvent.Continuation(null);
return(false);
}
var newTask = WriteAsyncTask(logEvent.LogEvent, _cancelTokenSource.Token);
if (newTask == null)
{
InternalLogger.Debug("{0} WriteAsync returned null", this.Name);
}
else
{
lock (this.SyncRoot)
{
_previousTask = newTask;
_previousTask.ContinueWith(_taskCompletion, logEvent.Continuation, _cancelTokenSource.Token);
if (_previousTask.Status == TaskStatus.Created)
{
_previousTask.Start(TaskScheduler.Default);
}
}
return(true);
}
}
catch (Exception ex)
{
try
{
InternalLogger.Error(ex, "{0} WriteAsync failed on creation", this.Name);
logEvent.Continuation(ex);
}
catch
{
// Don't wanna die
}
}
return(false);
}
protected override void Write(LogEventInfo logEvent)
{
if (logEvent == null || logEvent.Exception == null)
{
return;
}
InternalLogger.Debug("Sending Exception to api.exceptron.com. Process Name: {0}", Process.GetCurrentProcess().ProcessName);
try
{
var exceptionData = new ExceptionData
{
Exception = logEvent.Exception,
Component = logEvent.LoggerName,
Message = logEvent.FormattedMessage,
};
if (UserId != null)
{
exceptionData.UserId = UserId.Render(logEvent);
}
if (logEvent.Level <= LogLevel.Info)
{
exceptionData.Severity = ExceptionSeverity.None;
}
else if (logEvent.Level <= LogLevel.Warn)
{
exceptionData.Severity = ExceptionSeverity.Warning;
}
else if (logEvent.Level <= LogLevel.Error)
{
exceptionData.Severity = ExceptionSeverity.Error;
}
else if (logEvent.Level <= LogLevel.Fatal)
{
exceptionData.Severity = ExceptionSeverity.Fatal;
}
ExceptronClient.SubmitException(exceptionData);
}
catch (Exception e)
{
InternalLogger.Warn("Unable to report exception. {0}", e);
throw;
}
}
/// <summary>
/// (re-)create a event source, if it isn't there. Works only with fixed sourcenames.
/// </summary>
/// <param name="fixedSource">sourcenaam. If source is not fixed (see <see cref="SimpleLayout.IsFixedText"/>, then pass <c>null</c> or emptystring.</param>
/// <param name="alwaysThrowError">always throw an Exception when there is an error</param>
private void CreateEventSourceIfNeeded(string fixedSource, bool alwaysThrowError)
{
if (string.IsNullOrEmpty(fixedSource))
{
InternalLogger.Debug("Skipping creation of event source because it contains layout renderers");
//we can only create event sources if the source is fixed (no layout)
return;
}
// if we throw anywhere, we remain non-operational
try
{
if (EventLog.SourceExists(fixedSource, this.MachineName))
{
string currentLogName = EventLog.LogNameFromSourceName(fixedSource, this.MachineName);
if (!currentLogName.Equals(this.Log, StringComparison.CurrentCultureIgnoreCase))
{
// re-create the association between Log and Source
EventLog.DeleteEventSource(fixedSource, this.MachineName);
var eventSourceCreationData = new EventSourceCreationData(fixedSource, this.Log)
{
MachineName = this.MachineName
};
EventLog.CreateEventSource(eventSourceCreationData);
}
}
else
{
var eventSourceCreationData = new EventSourceCreationData(fixedSource, this.Log)
{
MachineName = this.MachineName
};
EventLog.CreateEventSource(eventSourceCreationData);
}
}
catch (Exception exception)
{
InternalLogger.Error("Error when connecting to EventLog: {0}", exception);
if (alwaysThrowError || exception.MustBeRethrown())
{
throw;
}
throw;
}
}
private bool TryLoadLoggingConfiguration(LogFactory logFactory, string configFile, out LoggingConfiguration config)
{
try
{
#if SILVERLIGHT && !WINDOWS_PHONE
Uri configFileUri = new Uri(configFile, UriKind.Relative);
var streamResourceInfo = Application.GetResourceStream(configFileUri);
if (streamResourceInfo != null)
{
InternalLogger.Debug("Loading config from Resource {0}", configFileUri);
using (var xmlReader = XmlReader.Create(streamResourceInfo.Stream))
{
config = LoadXmlLoggingConfiguration(xmlReader, null, logFactory);
return(true);
}
}
#else
if (_appEnvironment.FileExists(configFile))
{
config = LoadXmlLoggingConfigurationFile(logFactory, configFile);
return(true); // File exists, and maybe the config is valid, stop search
}
#endif
}
catch (IOException ex)
{
InternalLogger.Warn(ex, "Skipping invalid config file location: {0}", configFile);
}
catch (UnauthorizedAccessException ex)
{
InternalLogger.Warn(ex, "Skipping inaccessible config file location: {0}", configFile);
}
catch (SecurityException ex)
{
InternalLogger.Warn(ex, "Skipping inaccessible config file location: {0}", configFile);
}
catch (Exception ex)
{
InternalLogger.Error(ex, "Failed loading from config file location: {0}", configFile);
if (ex.MustBeRethrown())
{
throw;
}
}
config = null;
return(false); // No valid file found
}
public void TestNotEquals()
{
var logEvent1 = new LogEventInfo(LogLevel.Debug, "logger1", "message1");
AsyncContinuation cont1 = new AsyncContinuation(exception => { });
AsyncContinuation cont2 = new AsyncContinuation(exception => { InternalLogger.Debug("test"); });
var async1 = new AsyncLogEventInfo(logEvent1, cont1);
var async2 = new AsyncLogEventInfo(logEvent1, cont2);
Assert.False(async1.Equals(async2));
Assert.False(async1 == async2);
Assert.True(async1 != async2);
//2 delegates will return the same hashcode, https://stackoverflow.com/questions/6624151/why-do-2-delegate-instances-return-the-same-hashcode
//and that isn't really bad, so ignore this
// Assert.NotEqual(async1.GetHashCode(), async2.GetHashCode());
}
protected override void OnSizeChanged(int w, int h, int oldw, int oldh)
{
base.OnSizeChanged(w, h, oldw, oldh);
if (w <= MinimumSize || h <= MinimumSize)
{
return;
}
if (_weakSource.TryGetTarget(out var source) && (w != oldw || h != oldh))
{
InternalLogger.Debug(LogTag, () => $"OnSizeChanged( {source.MeasuredWidth}w, {source.MeasuredHeight}h )");
RefreshBitmaps();
}
}
/// <summary>
/// Registers the specified target object under a given name.
/// </summary>
/// <param name="name">
/// Name of the target.
/// </param>
/// <param name="target">
/// The target object.
/// </param>
/// <exception cref="ArgumentException">when <paramref name="name"/> is <see langword="null"/></exception>
/// <exception cref="ArgumentNullException">when <paramref name="target"/> is <see langword="null"/></exception>
public void AddTarget(string name, Target target)
{
if (name == null)
{
// TODO: NLog 5 - The ArgumentException should be changed to ArgumentNullException for name parameter.
throw new ArgumentException("Target name cannot be null", "name");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
InternalLogger.Debug("Registering target {0}: {1}", name, target.GetType().FullName);
_targets[name] = target;
}
protected override void OnAttachedToWindow()
{
InternalLogger.Debug($"BlurView@{GetHashCode()}", $"OnAttachedToWindow()");
base.OnAttachedToWindow();
var mDecorView = GetRootView();
if (mDecorView == null)
{
SetRootView(GetActivityDecorView());
}
else
{
OnAttached(mDecorView);
}
}
/// <summary>
/// Renders the ASP.NET Session ID appends it to the specified <see cref="StringBuilder" />.
/// </summary>
/// <param name="builder">The <see cref="StringBuilder" /> to append the rendered data to.</param>
/// <param name="logEvent">Logging event.</param>
protected override void DoAppend(StringBuilder builder, LogEventInfo logEvent)
{
var context = HttpContextAccessor.HttpContext;
if (context?.Session == null)
{
InternalLogger.Debug("aspnet-sessionid - HttpContext Session is null");
return;
}
#if !ASP_NET_CORE
builder.Append(context.Session.SessionID);
#else
builder.Append(context.Session.Id);
#endif
}
/// <summary>
/// Closes all targets and releases any unmanaged resources.
/// </summary>
public void Close()
{
InternalLogger.Debug("Closing logging configuration...");
foreach (Target target in _aliveTargets)
{
try
{
InternalLogger.Debug("Closing target {1} ({0})", target.Name, target.GetType().FullName);
target.Close();
}
catch (Exception ex)
{
InternalLogger.Error("Error while closing target: {0} {1}", target.Name, ex);
}
}
}
private void CreateShadowController(UIView shadowSource, Shadows formsElement)
{
Layer.BackgroundColor = new CGColor(0, 0, 0, 0);
Layer.MasksToBounds = false;
_shadowsLayer = new CALayer {
MasksToBounds = false
};
Layer.InsertSublayer(_shadowsLayer, 0);
_shadowsController = new iOSShadowsController(shadowSource, _shadowsLayer, formsElement.CornerRadius);
_shadowsController.UpdateShades(formsElement.Shades);
instanceCount++;
InternalLogger.Debug(_tag, () => $"Create ShadowView => {instanceCount} instances");
}
private static void SafeAddHiddenAssembly(string assemblyName, bool logOnException = true)
{
try
{
InternalLogger.Trace("Hide {0}", assemblyName);
var assembly = Assembly.Load(new AssemblyName(assemblyName));
LogManager.AddHiddenAssembly(assembly);
}
catch (Exception ex)
{
if (logOnException)
{
InternalLogger.Debug(ex, "Hiding assembly {0} failed. This could influence the ${callsite}", assemblyName);
}
}
}
private void WriteDebugMessages(string message, Exception e)
{
message = LE + message;
if (!this.Debug)
{
return;
}
string[] messages = { message, e.ToString() };
foreach (var msg in messages)
{
System.Diagnostics.Debug.WriteLine(msg);
Console.Error.WriteLine(msg);
//Log to NLog's internal logger also
InternalLogger.Debug(msg);
}
}
/// <summary>
/// Builds the default configuration item factory.
/// </summary>
/// <returns>Default factory.</returns>
private static ConfigurationItemFactory BuildDefaultFactory()
{
var nlogAssembly = typeof(ILogger).Assembly;
var factory = new ConfigurationItemFactory(nlogAssembly);
factory.RegisterExtendedItems();
#if !SILVERLIGHT
var assemblyLocation = Path.GetDirectoryName(new Uri(nlogAssembly.CodeBase).LocalPath);
if (assemblyLocation == null)
{
InternalLogger.Warn("No auto loading because Nlog.dll location is unknown");
return(factory);
}
var extensionDlls = Directory.GetFiles(assemblyLocation, "NLog*.dll")
.Select(Path.GetFileName)
.Where(x => !x.Equals("NLog.dll", StringComparison.OrdinalIgnoreCase))
.Where(x => !x.Equals("NLog.UnitTests.dll", StringComparison.OrdinalIgnoreCase))
.Where(x => !x.Equals("NLog.Extended.dll", StringComparison.OrdinalIgnoreCase))
.Select(x => Path.Combine(assemblyLocation, x));
InternalLogger.Debug("Start auto loading, location: {0}", assemblyLocation);
foreach (var extensionDll in extensionDlls)
{
InternalLogger.Info("Auto loading assembly file: {0}", extensionDll);
var success = false;
try
{
var extensionAssembly = Assembly.LoadFrom(extensionDll);
InternalLogger.LogAssemblyVersion(extensionAssembly);
factory.RegisterItemsFromAssembly(extensionAssembly);
success = true;
}
catch (Exception)
{
InternalLogger.Warn("Auto loading assembly file: {0} failed! Skipping this file.", extensionDll);
}
if (success)
{
InternalLogger.Info("Auto loading assembly file: {0} succeeded!", extensionDll);
}
}
InternalLogger.Debug("Auto loading done");
#endif
return(factory);
}
private bool TryGetBody(HttpRequest httpRequest, long?contentLength, out Stream body)
{
body = null;
if (contentLength <= 0)
{
return(false);
}
if (MaxContentLength > 0 && contentLength > MaxContentLength)
{
InternalLogger.Debug("AspNetRequestPostedBody: body stream is too big. ContentLength={0}", contentLength);
return(false);
}
body = GetBodyStream(httpRequest);
if (body == null)
{
InternalLogger.Debug("AspNetRequestPostedBody: body stream was null");
return(false);
}
if (!body.CanRead)
{
InternalLogger.Debug("AspNetRequestPostedBody: body stream has been closed");
return(false);
}
if (!body.CanSeek)
{
if (!TryEnableBuffering(httpRequest, contentLength, out body))
{
return(false);
}
}
else
{
if (MaxContentLength > 0 && !contentLength.HasValue && body.Length > MaxContentLength)
{
InternalLogger.Debug("AspNetRequestPostedBody: body stream too big. Body.Length={0}", body.Length);
body = null;
return(false);
}
}
return(true);
}
/// <summary>
/// Enqueues another item. If the queue is overflown the appropriate
/// action is taken as specified by <see cref="OnOverflow"/>.
/// </summary>
/// <param name="logEventInfo">The log event info.</param>
/// <returns>Queue was empty before enqueue</returns>
public bool Enqueue(AsyncLogEventInfo logEventInfo)
{
lock (this)
{
if (this.logEventInfoQueue.Count >= this.RequestLimit)
{
InternalLogger.Debug("Async queue is full");
switch (this.OnOverflow)
{
case AsyncTargetWrapperOverflowAction.Discard:
InternalLogger.Debug("Discarding one element from queue");
var dequeued = this.logEventInfoQueue.Dequeue();
if (BufferOverflowed != null)
{
BufferOverflowed.Invoke(this.OnOverflow, this.RequestLimit, this.logEventInfoQueue.Count, dequeued);
}
break;
case AsyncTargetWrapperOverflowAction.Grow:
InternalLogger.Debug("The overflow action is Grow, adding element anyway");
if (BufferOverflowed != null)
{
BufferOverflowed.Invoke(this.OnOverflow, this.RequestLimit, this.logEventInfoQueue.Count, logEventInfo);
}
break;
case AsyncTargetWrapperOverflowAction.Block:
while (this.logEventInfoQueue.Count >= this.RequestLimit)
{
InternalLogger.Debug("Blocking because the overflow action is Block...");
if (BufferOverflowed != null)
{
BufferOverflowed.Invoke(this.OnOverflow, this.RequestLimit, this.logEventInfoQueue.Count, logEventInfo);
}
System.Threading.Monitor.Wait(this);
InternalLogger.Trace("Entered critical section.");
}
InternalLogger.Trace("Limit ok.");
break;
}
}
this.logEventInfoQueue.Enqueue(logEventInfo);
return(this.logEventInfoQueue.Count == 1);
}
}
protected override void Write(LogEventInfo logEvent)
{
var connectionString = ConnectionString.Render(logEvent);
if (_client == null || !string.Equals(_connectionString, connectionString, System.StringComparison.OrdinalIgnoreCase))
{
_client = CloudStorageAccount.Parse(connectionString).CreateCloudBlobClient();
InternalLogger.Debug("Initialized connection to {0}", connectionString);
}
string containerName = Container.Render(logEvent);
string blobName = BlobName.Render(logEvent);
if (_container == null || _container.Name != containerName)
{
_container = _client.GetContainerReference(containerName);
InternalLogger.Debug("Got container reference to {0}", containerName);
if (_container.CreateIfNotExists())
{
InternalLogger.Debug("Created container {0}", containerName);
}
_blob = null;
}
if (_blob == null || _blob.Name != blobName)
{
_blob = _container.GetAppendBlobReference(blobName);
if (!_blob.Exists())
{
try
{
_blob.Properties.ContentType = "text/plain";
_blob.CreateOrReplace(AccessCondition.GenerateIfNotExistsCondition());
InternalLogger.Debug("Created blob: {0}", blobName);
}
catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict)
{
// to be expected
}
}
}
_blob.AppendText(Layout.Render(logEvent) + "\r\n", Encoding.UTF8);
}
private void ParseIncludeElement(NLogXmlElement includeElement, string baseDirectory, bool autoReloadDefault)
{
includeElement.AssertName("include");
string newFileName = includeElement.GetRequiredAttribute("file");
try
{
newFileName = this.ExpandSimpleVariables(newFileName);
newFileName = SimpleLayout.Evaluate(newFileName);
if (baseDirectory != null)
{
newFileName = Path.Combine(baseDirectory, newFileName);
}
#if SILVERLIGHT
newFileName = newFileName.Replace("\\", "/");
if (Application.GetResourceStream(new Uri(newFileName, UriKind.Relative)) != null)
#else
if (File.Exists(newFileName))
#endif
{
InternalLogger.Debug("Including file '{0}'", newFileName);
this.ConfigureFromFile(newFileName, autoReloadDefault);
}
else
{
throw new FileNotFoundException("Included file not found: " + newFileName);
}
}
catch (Exception exception)
{
InternalLogger.Error(exception, "Error when including '{0}'.", newFileName);
if (exception.MustBeRethrown())
{
throw;
}
if (includeElement.GetOptionalBooleanAttribute("ignoreErrors", false))
{
return;
}
throw new NLogConfigurationException("Error when including: " + newFileName, exception);
}
}
public void ExceptionTests()
{
using (new InternalLoggerScope())
{
InternalLogger.LogLevel = LogLevel.Trace;
InternalLogger.LogToConsole = true;
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 WWW" + prefix + ex1 + Environment.NewLine +
"Error EEE" + prefix + ex2 + Environment.NewLine +
"Fatal FFF" + prefix + ex3 + Environment.NewLine +
"Trace TTT" + prefix + ex4 + Environment.NewLine +
"Debug DDD" + prefix + ex5 + Environment.NewLine +
"Info III" + Environment.NewLine;
StringWriter consoleOutWriter = new StringWriter()
{
NewLine = Environment.NewLine
};
// Redirect the console output to a StringWriter.
Console.SetOut(consoleOutWriter);
// Named (based on LogLevel) public methods.
InternalLogger.Warn(ex1, "WWW");
InternalLogger.Error(ex2, "EEE");
InternalLogger.Fatal(ex3, "FFF");
InternalLogger.Trace(ex4, "TTT");
InternalLogger.Debug(ex5, "DDD");
InternalLogger.Info(ex6, "III");
consoleOutWriter.Flush();
var strings = consoleOutWriter.ToString();
Assert.Equal(expected, strings);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseMutexFileAppender" /> class.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="createParameters">The create parameters.</param>
protected BaseMutexFileAppender(string fileName, ICreateFileParameters createParameters)
: base(fileName, createParameters)
{
if (createParameters.IsArchivingEnabled)
{
if (PlatformDetector.SupportsSharableMutex)
{
#if SupportsMutex
ArchiveMutex = CreateArchiveMutex();
#endif
}
else
{
InternalLogger.Debug("Mutex for file archive not supported");
}
}
}
/// <summary>
/// Enqueues another item. If the queue is overflown the appropriate
/// action is taken as specified by <see cref="AsyncRequestQueueBase.OnOverflow"/>.
/// </summary>
/// <param name="logEventInfo">The log event info.</param>
/// <returns>Queue was empty before enqueue</returns>
public override bool Enqueue(AsyncLogEventInfo logEventInfo)
{
long currentCount = Interlocked.Increment(ref _count);
bool queueWasEmpty = currentCount == 1; // Inserted first item in empty queue
if (currentCount > RequestLimit)
{
InternalLogger.Debug("Async queue is full");
switch (OnOverflow)
{
case AsyncTargetWrapperOverflowAction.Discard:
{
do
{
if (_logEventInfoQueue.TryDequeue(out var lostItem))
{
InternalLogger.Debug("Discarding one element from queue");
queueWasEmpty = Interlocked.Decrement(ref _count) == 1 || queueWasEmpty;
OnLogEventDropped(lostItem.LogEvent);
break;
}
currentCount = Interlocked.Read(ref _count);
queueWasEmpty = true;
} while (currentCount > RequestLimit);
}
break;
case AsyncTargetWrapperOverflowAction.Block:
{
WaitForBelowRequestLimit();
queueWasEmpty = true;
}
break;
case AsyncTargetWrapperOverflowAction.Grow:
{
InternalLogger.Debug("The overflow action is Grow, adding element anyway");
OnLogEventQueueGrows(currentCount);
RequestLimit *= 2;
}
break;
}
}
_logEventInfoQueue.Enqueue(logEventInfo);
return(queueWasEmpty);
}
internal static HttpRequestBase TryGetRequest(this HttpContextBase context)
{
try
{
var request = context?.Request;
if (request == null)
{
InternalLogger.Debug("HttpContext Request Lookup returned null");
}
return(request);
}
catch (HttpException ex)
{
InternalLogger.Debug(ex, "HttpContext Request Lookup failed.");
return(null);
}
}
