public void WriteToStringWriterWithArgsTests()
{
try
{
// Expected result is the same for both types of method invocation.
const string expected = "Warn WWW 0\nError EEE 0, 1\nFatal FFF 0, 1, 2\nTrace TTT 0, 1, 2\nDebug DDD 0, 1\nInfo III 0\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 {0}", 0);
InternalLogger.Error("EEE {0}, {1}", 0, 1);
InternalLogger.Fatal("FFF {0}, {1}, {2}", 0, 1, 2);
InternalLogger.Trace("TTT {0}, {1}, {2}", 0, 1, 2);
InternalLogger.Debug("DDD {0}, {1}", 0, 1);
InternalLogger.Info("III {0}", 0);
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 {0}", 0);
InternalLogger.Log(LogLevel.Error, "EEE {0}, {1}", 0, 1);
InternalLogger.Log(LogLevel.Fatal, "FFF {0}, {1}, {2}", 0, 1, 2);
InternalLogger.Log(LogLevel.Trace, "TTT {0}, {1}, {2}", 0, 1, 2);
InternalLogger.Log(LogLevel.Debug, "DDD {0}, {1}", 0, 1);
InternalLogger.Log(LogLevel.Info, "III {0}", 0);
TestWriter(expected, writer2);
}
}
finally
{
InternalLogger.Reset();
}
}
/// <summary>
/// Used to (re)initialize target when attaching it to another RTB control
/// </summary>
/// <param name="form">form owning textboxControl</param>
/// <param name="textboxControl">a new control to attach to</param>
private void AttachToControl(Form form, RichTextBox textboxControl)
{
InternalLogger.Info("Attaching target {0} to textbox {1}.{2}", this.Name, form.Name, textboxControl.Name);
DetachFromControl();
this.TargetForm = form;
this.TargetRichTextBox = textboxControl;
#if LINKS_SUPPORTED
if (this.SupportLinks)
{
this.TargetRichTextBox.DetectUrls = false;
this.TargetRichTextBox.LinkClicked += TargetRichTextBox_LinkClicked;
}
#endif
//OnReattach?
switch (messageRetention)
{
case RichTextBoxTargetMessageRetentionStrategy.None:
break;
case RichTextBoxTargetMessageRetentionStrategy.All:
if (lastLoggedTextBoxControl != textboxControl) //don't log to same RTB as befre, because it already has everything. Happens in case of config reload, see https://github.com/NLog/NLog.Windows.Forms/pull/22
{
lock (messageQueueLock)
{
foreach (MessageInfo messageInfo in messageQueue)
{
DoSendMessageToTextbox(messageInfo.Message, messageInfo.Rule, messageInfo.LogEvent);
}
}
}
break;
case RichTextBoxTargetMessageRetentionStrategy.OnlyMissed:
lock (messageQueueLock)
{
while (messageQueue.Count > 0)
{
MessageInfo messageInfo = messageQueue.Dequeue();
DoSendMessageToTextbox(messageInfo.Message, messageInfo.Rule, messageInfo.LogEvent);
}
}
break;
default:
HandleError("Unexpected retention strategy {0}", messageRetention);
break;
}
}
private void ScrollToCurrentItem()
{
if (Element.ListLayout == HorizontalListViewLayout.Grid || Control.NumberOfItemsInSection(0) == 0)
{
return;
}
InternalLogger.Info($"ScrollToCurrentItem( Element.CurrentIndex = {Element.CurrentIndex} )");
_isInternalScroll = true;
Control.ScrollToItem(
NSIndexPath.FromRowSection(Element.CurrentIndex, 0),
UICollectionViewScrollPosition.Left,
false);
}
private void ShutdownAmqp(IConnection connection, ShutdownEventArgs reason)
{
if (reason.ReplyCode != 200 /* Constants.ReplySuccess*/)
{
InternalLogger.Warn("RabbitMQTarget(Name={0}): Connection shutdown. ReplyCode={1}, ReplyText={2}", Name, reason.ReplyCode, reason.ReplyText);
}
else
{
InternalLogger.Info("RabbitMQTarget(Name={0}): Connection shutdown. ReplyCode={1}, ReplyText={2}", Name, reason.ReplyCode, reason.ReplyText);
}
lock (SyncRoot)
{
if (connection != null && ReferenceEquals(connection, _Connection))
{
var model = _Model;
_Connection = null;
_Model = null;
try
{
if (model != null && model.IsOpen &&
reason.ReplyCode != 504 && //Constants.ChannelError
reason.ReplyCode != 320 //Constants.ConnectionForced
)
{
model.Abort(); //model.Close();
}
}
catch (Exception e)
{
InternalLogger.Error(e, "RabbitMQTarget(Name={0}): Could not close model: {1}", Name, e.Message);
}
try
{
if (connection.IsOpen)
{
connection.Close(reason.ReplyCode, reason.ReplyText, 1000);
connection.Abort(1000); // you get 2 seconds to shut down!
}
}
catch (Exception e)
{
InternalLogger.Error(e, "RabbitMQTarget(Name={0}): Could not close connection: {1}", Name, e.Message);
}
}
}
}
public void TestMinLevelSwitch_lambda(string rawLogLevel, int count)
{
Action log = () =>
{
InternalLogger.Fatal(() => "L1");
InternalLogger.Error(() => "L2");
InternalLogger.Warn(() => "L3");
InternalLogger.Info(() => "L4");
InternalLogger.Debug(() => "L5");
InternalLogger.Trace(() => "L6");
};
TestMinLevelSwitch_inner(rawLogLevel, count, log);
}
/// <summary>
/// This method must be called by the UI element in charge of displaying data.
/// Per example, on android, a scroll listener can reference this paginator as an IInfiniteListLoader and call it from OnScroll.
/// The call to this method is nearly transparent as it returns immediately and doesn't block the caller.
/// (benchmarked as 4 ticks for a call (10 000 ticks == 1ms)).
/// </summary>
public void OnScroll(int lastVisibleIndex)
{
TaskMonitor <bool> .Create(
ShouldLoadNextPage(lastVisibleIndex),
whenSuccessfullyCompleted : (task, shouldLoad) =>
{
if (shouldLoad)
{
InternalLogger.Info($"Scrolled: loading more (max index of visible item {lastVisibleIndex})");
int pageToLoad = lastVisibleIndex / PageSize + 2;
LoadPage(pageToLoad, calledFromScroll: true);
}
});
}
/// <summary>
/// Stops the watching.
/// </summary>
public void StopWatching()
{
lock (this)
{
foreach (var watcher in watchers)
{
InternalLogger.Info("Stopping file watching for path '{0}' filter '{1}'", watcher.Path, watcher.Filter);
watcher.EnableRaisingEvents = false;
watcher.Dispose();
}
watchers.Clear();
}
}
/// <summary>
/// Initializes the configuration.
/// </summary>
/// <param name="reader"><see cref="XmlReader"/> containing the configuration section.</param>
/// <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
/// <param name="ignoreErrors">Ignore any errors during configuration.</param>
private void Initialize(XmlReader reader, string fileName, bool ignoreErrors)
{
try
{
reader.MoveToContent();
var content = new NLogXmlElement(reader);
if (fileName != null)
{
InternalLogger.Info("Configuring from an XML element in {0}...", fileName);
#if SILVERLIGHT
string key = fileName;
#else
string key = Path.GetFullPath(fileName);
#endif
this.visitedFile[key] = true;
this.originalFileName = fileName;
this.ParseTopLevel(content, Path.GetDirectoryName(fileName));
}
else
{
this.ParseTopLevel(content, null);
}
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
NLogConfigurationException ConfigException = new NLogConfigurationException("Exception occurred when loading configuration from " + fileName, exception);
if (!ignoreErrors)
{
if (LogManager.ThrowExceptions)
{
throw ConfigException;
}
else
{
InternalLogger.Error("Error in Parsing Configuration File. Exception : {0}", ConfigException);
}
}
else
{
InternalLogger.Error("Error in Parsing Configuration File. Exception : {0}", ConfigException);
}
}
}
/// <summary>
/// Initializes the configuration.
/// </summary>
/// <param name="reader"><see cref="XmlReader"/> containing the configuration section.</param>
/// <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
/// <param name="ignoreErrors">Ignore any errors during configuration.</param>
private void Initialize(XmlReader reader, string fileName, bool ignoreErrors)
{
try
{
InitializeSucceeded = null;
reader.MoveToContent();
var content = new NLogXmlElement(reader);
if (fileName != null)
{
this.originalFileName = fileName;
this.ParseTopLevel(content, fileName, autoReloadDefault: false);
InternalLogger.Info("Configured from an XML element in {0}...", fileName);
}
else
{
this.ParseTopLevel(content, null, autoReloadDefault: false);
}
InitializeSucceeded = true;
this.CheckUnusedTargets();
}
catch (Exception exception)
{
InitializeSucceeded = false;
if (exception.MustBeRethrown())
{
throw;
}
NLogConfigurationException ConfigException = new NLogConfigurationException("Exception occurred when loading configuration from " + fileName, exception);
if (!ignoreErrors)
{
if (LogManager.ThrowExceptions)
{
throw ConfigException;
}
else
{
InternalLogger.Error("Error in Parsing Configuration File. Exception : {0}", ConfigException);
}
}
else
{
InternalLogger.Error("Error in Parsing Configuration File. Exception : {0}", ConfigException);
}
}
}
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;
}
}
internal Core(string[] args)
{
Console.Title = $"Initializing...";
Logger = InternalLogger.GetOrCreateLogger <Core>(this, nameof(Core));
OS.Init(true);
RuntimeSpanCounter.Restart();
File.WriteAllText("version.txt", Constants.Version?.ToString());
ParseStartupArguments();
if (File.Exists(Constants.TraceLogFile))
{
File.Delete(Constants.TraceLogFile);
}
Config = new CoreConfig(this);
Config.LoadAsync().Wait();
IsUpdatesAllowed = !NoUpdates && Config.AutoUpdates;
Config.LocalIP = Helpers.GetLocalIpAddress()?.ToString() ?? "-Invalid-";
Config.PublicIP = Helpers.GetPublicIP()?.ToString() ?? "-Invalid-";
if (!IsNetworkAvailable)
{
Logger.Warn("No Internet connection.");
Logger.Info($"Starting offline mode...");
}
Pins = new PinsWrapper(
Config.GpioConfiguration.OutputModePins,
Config.GpioConfiguration.InputModePins,
Constants.BcmGpioPins,
Config.GpioConfiguration.RelayPins,
Config.GpioConfiguration.InfraredSensorPins,
Config.GpioConfiguration.SoundSensorPins
);
Controller = new GpioCore(Pins, this, Config.GpioConfiguration.GpioSafeMode);
ModuleLoader = new ModuleLoader();
RestServer = new RestCore(Config.RestServerPort, Config.Debug);
JobManager.AddJob(() => SetConsoleTitle(), (s) => s.WithName("ConsoleUpdater").ToRunEvery(1).Seconds());
Logger.CustomLog(FiggleFonts.Ogre.Render("LUNA"), ConsoleColor.Green);
Logger.CustomLog($"---------------- Starting Luna v{Constants.Version} ----------------", ConsoleColor.Blue);
IsBaseInitiationCompleted = true;
PostInitiation().Wait();
InternalConfigWatcher = new ConfigWatcher(this);
InternalModuleWatcher = new ModuleWatcher(this);
InitiationCompleted = true;
}
public void WriteToConsoleErrorTests()
{
// 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.LogToConsoleError = true;
{
StringWriter consoleWriter1 = new StringWriter()
{
NewLine = "\n"
};
// Redirect the console output to a StringWriter.
Console.SetError(consoleWriter1);
// 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, consoleWriter1);
}
{
//
// Redirect the console output to another StringWriter.
StringWriter consoleWriter2 = new StringWriter()
{
NewLine = "\n"
};
Console.SetError(consoleWriter2);
// 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, consoleWriter2);
}
}
private void AllocateBitmap(int measuredWidth, int measuredHeight)
{
InternalLogger.Info($"AllocateBitmap( width: {measuredWidth}, height: {measuredHeight} )");
int nonRoundedScaledWidth = DownScaleSize(measuredWidth);
int nonRoundedScaledHeight = DownScaleSize(measuredHeight);
int scaledWidth = RoundSize(nonRoundedScaledWidth);
int scaledHeight = RoundSize(nonRoundedScaledHeight);
roundingHeightScaleFactor = (float)nonRoundedScaledHeight / scaledHeight;
roundingWidthScaleFactor = (float)nonRoundedScaledWidth / scaledWidth;
internalBitmap = Bitmap.CreateBitmap(scaledWidth, scaledHeight, blurAlgorithm.GetSupportedBitmapConfig());
}
public override int FindTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int velocityX, int velocityY)
{
var targetSnapPosition = base.FindTargetSnapPosition(layoutManager, velocityX, velocityY);
InternalLogger.Info($"FindTargetSnapPosition() : {targetSnapPosition}");
if (WeakNativeView.TryGetTarget(out var target))
{
target.IsSnapHelperBusy = targetSnapPosition == -1;
target.CurrentSnapIndex = targetSnapPosition > -1 ? targetSnapPosition : target.CurrentSnapIndex;
System.Diagnostics.Debug.WriteLine($">>>>>> CurrentSnapIndex: {target.CurrentSnapIndex}");
}
return(targetSnapPosition);
}
public override int[] CalculateDistanceToFinalSnap(RecyclerView.LayoutManager layoutManager, View targetView)
{
int[] result = new int[2];
result[0] = layoutManager.CanScrollHorizontally()
? DistanceToStart(targetView, GetHorizontalHelper(layoutManager))
: 0;
result[1] = layoutManager.CanScrollVertically()
? DistanceToStart(targetView, GetVerticalHelper(layoutManager))
: 0;
InternalLogger.Info($"CalculateDistanceToFinalSnap()");
return(result);
}
/// <inheritdoc />
public void Handle(IMessageContext messageContext)
{
var handlerMethods = (EventHandlerMethodWithObject[])
messageContext.Items[EventHandlerLocatorMiddleware.HandlerMethodsKey];
var handlerObjects = new object[handlerMethods.Length];
for (int i = 0; i < handlerMethods.Length; i++)
{
object handler = null;
// Event already implements Handle method within it.
if (handlerMethods[i].Method.DeclaringType == messageContext.Content.GetType())
{
handler = messageContext.Content;
}
if (handler == null && handlerMethods[i].Object != null)
{
handler = handlerMethods[i].Object;
}
if (handler == null)
{
try
{
if (UseInternalObjectResolver)
{
handler = CreateHandlerWithCache(handlerMethods[i].Method.DeclaringType,
messageContext.ServiceProvider, Id);
}
else
{
handler = messageContext.ServiceProvider.GetService(handlerMethods[i].Method.DeclaringType);
}
}
catch (Exception ex)
{
InternalLogger.Info(string.Format(Properties.Strings.ExceptionOnResolve,
handlerMethods[i].Method.Name, ex), nameof(EventHandlerExecutorMiddleware));
}
}
if (handler == null)
{
InternalLogger.Warn(string.Format(Properties.Strings.CannotResolveHandler,
handlerMethods[i].Method.Name), nameof(EventHandlerExecutorMiddleware));
}
handlerObjects[i] = handler;
}
messageContext.Items[HandlerObjectKey] = handlerObjects;
}
private void CheckUnsent()
{
var count = _UnsentMessages.Count;
for (var i = 0; i < count; i++)
{
var tuple = _UnsentMessages[i];
InternalLogger.Info("publishing unsent message: {0}.", tuple);
Publish(tuple.Item1, tuple.Item2, tuple.Item3);
}
if (count > 0)
{
_UnsentMessages.Clear();
}
}
internal bool GenerateDefaultConfig()
{
Logger.Info("Generating default config...");
if (!Directory.Exists(Constants.ConfigDirectory))
{
Directory.CreateDirectory(Constants.ConfigDirectory);
}
if (File.Exists(Constants.CoreConfigPath))
{
return(true);
}
SaveAsync().RunSynchronously();
return(true);
}
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>
/// 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 void UpdateCurrentIndex(
CollectionViewRenderer nativeView,
CancellationToken token)
{
if (token.IsCancellationRequested)
{
return;
}
if (nativeView?.LinearLayoutManager == null || _element == null)
{
return;
}
nativeView._isCurrentIndexUpdateBackfire = true;
try
{
int newIndex = -1;
if (_element.SnapStyle != SnapStyle.None)
{
newIndex = nativeView.CurrentSnapIndex;
}
else
{
newIndex = nativeView.LinearLayoutManager.FindFirstCompletelyVisibleItemPosition();
if (newIndex == -1)
{
newIndex = nativeView.LinearLayoutManager.FindFirstVisibleItemPosition();
}
}
if (newIndex == -1)
{
InternalLogger.Warn(
"Failed to find the current index: UpdateCurrentIndex returns nothing");
return;
}
_element.CurrentIndex = newIndex;
InternalLogger.Info($"CurrentIndex: {_element.CurrentIndex}");
}
finally
{
nativeView._isCurrentIndexUpdateBackfire = false;
}
}
/// <summary>
/// Constructs a new instance of <see cref="XmlLoggingConfiguration" />
/// class and reads the configuration from the specified config file.
/// </summary>
/// <param name="fileName">Configuration file to be read.</param>
/// <param name="ignoreErrors">Ignore any errors during configuration.</param>
public XmlLoggingConfiguration(string fileName, bool ignoreErrors)
{
InternalLogger.Info("Configuring from {0}...", fileName);
_originalFileName = fileName;
try
{
ConfigureFromFile(fileName);
}
catch (Exception ex)
{
InternalLogger.Error("Error {0}...", ex);
if (!ignoreErrors)
{
throw new NLogConfigurationException("Exception occured when loading configuration from '" + fileName + "'", ex);
}
}
}
private void OnItemReplaced(int itemIndex, object newItem)
{
InternalLogger.Info($"OnItemReplaced( itemIndex: {itemIndex} )");
using var h = new Handler(Looper.MainLooper);
h.Post(
() =>
{
if (_isDisposed)
{
return;
}
_dataSource[itemIndex] = newItem;
NotifyItemChanged(itemIndex);
});
}
internal void Dump()
{
InternalLogger.Debug("--- NLog configuration dump. ---");
InternalLogger.Debug("Targets:");
foreach (var target in targets.Values)
{
InternalLogger.Info("{0}", target);
}
InternalLogger.Debug("Rules:");
foreach (var rule in LoggingRules)
{
InternalLogger.Info("{0}", rule);
}
InternalLogger.Debug("--- End of NLog configuration dump ---");
}
internal void ReloadConfigOnTimer(object state)
{
LoggingConfiguration configurationToReload = (LoggingConfiguration)state;
InternalLogger.Info("Reloading configuration...");
lock (this)
{
if (_reloadTimer != null)
{
_reloadTimer.Dispose();
_reloadTimer = null;
}
_watcher.StopWatching();
try
{
if (Configuration != configurationToReload)
{
throw new Exception("Config changed in between. Not reloading.");
}
LoggingConfiguration newConfig = configurationToReload.Reload();
if (newConfig != null)
{
Configuration = newConfig;
if (ConfigurationReloaded != null)
{
ConfigurationReloaded(true, null);
}
}
else
{
throw new Exception("Configuration.Reload() returned null. Not reloading.");
}
}
catch (Exception ex)
{
_watcher.Watch(configurationToReload.FileNamesToWatch);
if (ConfigurationReloaded != null)
{
ConfigurationReloaded(false, ex);
}
}
}
}
public void WriteToStringWriterTests()
{
// 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");
Assert.True(writer1.ToString() == expected);
//
// 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");
Assert.True(writer2.ToString() == expected);
}
/// <summary>
/// Initializes the configuration.
/// </summary>
/// <param name="reader"><see cref="XmlReader"/> containing the configuration section.</param>
/// <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
/// <param name="ignoreErrors">Ignore any errors during configuration.</param>
private void Initialize(XmlReader reader, string fileName, bool ignoreErrors)
{
try
{
InitializeSucceeded = null;
reader.MoveToContent();
var content = new NLogXmlElement(reader);
if (fileName != null)
{
this.originalFileName = fileName;
this.ParseTopLevel(content, fileName, autoReloadDefault: false);
InternalLogger.Info("Configured from an XML element in {0}...", fileName);
}
else
{
this.ParseTopLevel(content, null, autoReloadDefault: false);
}
InitializeSucceeded = true;
// Automatically reconfigure existing pools as soon as the configuration has been loaded
this.PoolConfiguration.ReconfigurePools(this.PoolFactory);
this.CheckUnusedTargets();
}
catch (Exception exception)
{
InitializeSucceeded = false;
if (exception.MustBeRethrownImmediately())
{
throw;
}
var configurationException = new NLogConfigurationException("Exception occurred when loading configuration from " + fileName, exception);
InternalLogger.Error(configurationException, "Error in Parsing Configuration File.");
if (!ignoreErrors)
{
if (exception.MustBeRethrown())
{
throw configurationException;
}
}
}
}
protected override void Write(LogEventInfo logEvent)
{
if (_messageQueue.Count >= MaxMessageCount)
{
InternalLogger.Info(string.Format("Сообщение не будет обработано [{0}]", Layout.Render(logEvent)));
return;
}
_messageQueue.Enqueue(new Message
{
Payload = Layout.Render(logEvent),
Topic = Topic.Render(logEvent),
Exchange = Exchange.Render(logEvent)
});
CreateWorker();
}
/// <summary>
/// Initializes the target.
/// </summary>
protected override void InitializeTarget()
{
PauseLogging = false;
if (DetectConsoleAvailable)
{
string reason;
PauseLogging = !ConsoleTargetHelper.IsConsoleAvailable(out reason);
if (PauseLogging)
{
InternalLogger.Info("Console has been detected as turned off. Disable DetectConsoleAvailable to skip detection. Reason: {0}", reason);
}
}
base.InitializeTarget();
if (Header != null)
{
this.WriteToOutput(Header.Render(LogEventInfo.CreateNullEvent()));
}
}
protected override void CloseTarget()
{
InternalLogger.Warn("Closing {0} target", nameof(AzureBlobStorageLogTarget));
var result = _log.ShutdownAsync().Result;
if (!result.Succeeded)
{
InternalLogger.Error(
result.Exception,
"Failed to shutdown {0} target appropriately. Error: {1}",
nameof(AzureBlobStorageLogTarget),
result.Diagnostics ?? result.ErrorMessage ?? string.Empty);
}
else
{
InternalLogger.Info("Closed {0} target successfully", nameof(AzureBlobStorageLogTarget));
}
}
