public void Test_log4net_InsertOnStartReplaceOnEnd()
{
Audit.Core.Configuration.Setup()
.UseLog4net(_ => _
.LogLevel(LogLevel.Info));
_adapter.Clear();
using (var s = new AuditScopeFactory().Create(new AuditScopeOptions()
{
CreationPolicy = EventCreationPolicy.InsertOnStartReplaceOnEnd,
EventType = "Test_log4net_InsertOnStartReplaceOnEnd"
}))
{
}
var events = _adapter.PopAllEvents();
Assert.AreEqual(2, events.Length);
Assert.AreEqual("Test_log4net_InsertOnStartReplaceOnEnd", JsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject.ToString()).EventType);
Assert.AreEqual("Test_log4net_InsertOnStartReplaceOnEnd", JsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject.ToString()).EventType);
var jsonAdapter = new JsonAdapter();
Assert.AreEqual(jsonAdapter.Deserialize <AuditEvent>(events[0].MessageObject.ToString()).CustomFields["EventId"].ToString(), jsonAdapter.Deserialize <AuditEvent>(events[1].MessageObject.ToString()).CustomFields["EventId"].ToString());
}
void DisposeLogger()
{
// remove appender and drain events
repository.Root.RemoveAppender(memoryAppender);
memoryAppender.Clear();
//mark repository as configured and notify that is has changed.
repository.Configured = true;
repository.RaiseConfigurationChanged(EventArgs.Empty);
}
protected void Page_Load(object sender, EventArgs e)
{
// gather log4net output with small hack to get results...
ILoggerRepository repository = LogManager.GetRepository();
IAppender[] appenders = repository.GetAppenders();
MemoryAppender appender = null;
foreach (IAppender a in appenders)
{
if (a is MemoryAppender)
{
// we found our appender to look results from
appender = a as MemoryAppender;
break;
}
}
if (appender != null)
{
appender.Clear();
fulfillmentService.ProcessCustomer(customerEditController.CurrentCustomer.Id);
LoggingEvent[] events = appender.GetEvents();
StringWriter stringWriter = new StringWriter();
PatternLayout layout = new PatternLayout("%date{HH:mm:ss} %-5level %logger{1}: %message<br />");
foreach (LoggingEvent loggingEvent in events)
{
layout.Format(stringWriter, loggingEvent);
}
results.Text = stringWriter.ToString();
}
}
public void TearDown()
{
_memoryAppender.Clear();
LogManager.ResetConfiguration();
Assert.That(LogManager.GetLogger(typeof(FilteringAssemblyLoader)).IsDebugEnabled, Is.False);
}
/// <summary>
/// Handles when the <see cref="ScreenManager"/> updates.
/// </summary>
/// <param name="screenManager">The screen manager.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
void ScreenManager_Updated(IScreenManager screenManager, EventArgs e)
{
// The logger we use to grab log messages and output to the console will continue to queue messages
// indefinitely until it is cleared. Because of this, we can't just flush the log by overriding
// the screen's Update method. Instead, we have this event hook for when the ScreenManager
// updates so we can clear out the log buffer every tick.
// Get the latest events
LoggingEvent[] events;
try
{
events = _logger.GetEvents();
}
catch (ArgumentException)
{
// There is some bug in the _logger.GetEvents() that can throw this exception...
return;
}
_logger.Clear();
// Ensure there are events
if (events != null && events.Length > 0)
{
foreach (var ev in events)
{
var styledText = new StyledText(ev.RenderedMessage, ev.Level.GetColor());
_txtOutput.AppendLine(styledText);
}
}
// Move to the last line in the log textbox
_txtOutput.LineBufferOffset = Math.Max(0, _txtOutput.LineCount - _txtOutput.MaxVisibleLines);
}
public SamplesForm()
{
InitializeComponent();
_buttonStorageScuVerify.Text = STR_Verify;
if (String.IsNullOrEmpty(Properties.Settings.Default.ScpStorageFolder))
{
Properties.Settings.Default.ScpStorageFolder = Path.Combine(Path.GetTempPath(), "DicomImages");
}
_destinationSyntaxCombo.Items.Clear();
_destinationSyntaxCombo.Items.Add(TransferSyntax.ExplicitVrLittleEndian);
foreach (TransferSyntax syntax in DicomCodecRegistry.GetCodecTransferSyntaxes())
{
_destinationSyntaxCombo.Items.Add(syntax);
}
ComboBoxQueryScuQueryTypeSelectedIndexChanged(null, null);
ComboBoxMoveScuQueryTypeSelectedIndexChanged(null, null);
// Logging stuff
Closing += SamplesFormClosing;
BasicConfigurator.Configure(_appender);
_timer = new Timer(delegate
{
try
{
LoggingEvent[] events = _appender.GetEvents();
if (events != null && events.Length > 0)
{
// if there are events, we clear them from the logger,
// since we're done with them
_appender.Clear();
foreach (LoggingEvent ev in events)
{
// the line we want to log
string line = String.Format("({0}) {1} {2} [{3}]: {4}\r\n",
ev.ThreadName,
ev.TimeStamp.ToShortDateString(),
ev.TimeStamp.ToLongTimeString(), ev.Level,
ev.RenderedMessage);
AppendText(line);
if (ev.ExceptionObject != null)
{
AppendText(string.Format("{0}: {1}\r\n", ev.ExceptionObject, ev.ExceptionObject.Message));
AppendText("Stack Trace:\r\n" + ev.ExceptionObject.StackTrace + "\r\n");
}
}
}
}
catch (Exception x)
{
Platform.Log(LogLevel.Error, x, "Unexpected exception with logging event");
}
}, null, 500);
_timer.Start();
}
private void Init()
{
ILoggerFactory iLog = new Log4NetLoggerFactory();
LoggerFactory.BindFactory(iLog);
IAppender[] iAppenders = LogManager.GetRepository().GetAppenders();
appender = iAppenders[0] as MemoryAppender;
appender.Clear();
}
public override void TearDown()
{
_memoryAppender.Clear();
LogManager.ResetConfiguration();
Assert.That(LogManager.GetLogger(typeof(LoggingClientTransactionListener)).IsDebugEnabled, Is.False);
base.TearDown();
}
/// <summary>
/// Fills the text writer.
/// </summary>
/// <param name="sw">
/// The sw.
/// </param>
/// <remarks>
/// </remarks>
private void FillTextWriter(TextWriter sw)
{
if (ma != null)
{
var events = ma.GetEvents();
var iLayout = (PatternLayout)ma.Layout;
iLayout.Format(sw, events[events.GetUpperBound(0)]);
ma.Clear();
}
}
private async void button5_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
button5.Enabled = false;
Hierarchy hierarchy = LogManager.GetRepository() as Hierarchy;
MemoryAppender mappender = hierarchy.Root.GetAppender("MemoryAppender") as MemoryAppender;
try
{
var dL = checkBox1.Checked ? symbols.GetDeviceLists() : db.GetDeviceLists();
if (dL == null)
{
MessageBox.Show("Nepodařilo se získat seznam zařízení. Generování zastaveno.", "Upozornění", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
mappender.Clear();
if (!RefreshDatablock(SelectedDb))
{
if (MessageBox.Show($"Chyba při provádění refreshe databloků z projektu. Pokračovat s offline daty?", "Dotaz", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
}
await PointGeneratorCimplicity.Run(SelectedDb, definitions, pointStructures, dL);
}
catch (AggregateException ex)
{
MessageBox.Show(string.Join("\n", ex.InnerExceptions.Select(x => x.Message)), "Chyba", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (Exception ex)
{
MessageBox.Show(string.Join("\n", ex.Message), "Chyba", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
button5.Enabled = true;
Cursor.Current = Cursors.Default;
}
var ev = mappender.PopAllEvents();
if (ev != null && ev.Length > 0)
{
if (MessageBox.Show("Během generování se vyskytly chyby. Chceš je zobrazit?", "Upozornění", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
var dlg = new LogFrm(ev.OrderBy(x => x.Properties["datablock"]).Select(x => x.RenderedMessage).ToArray());
dlg.Show(this);
}
}
}
public void DetatchMemoryLogger(string name)
{
try
{
MemoryAppender appender = GetMemoryAppender(name);
LoggingHierarchy.Root.RemoveAppender(appender);
appender.Clear();
}
catch (Exception)
{
// Ignore
}
}
public void TearDown()
{
if (ShowLogOutput)
{
var logEvents = MemoryAppender.GetEvents().Reverse().ToArray();
Console.WriteLine(logEvents.Skip(1).First().RenderedMessage);
Console.WriteLine(logEvents.First().RenderedMessage);
}
MemoryAppender.Clear();
LogManager.ResetConfiguration();
Assert.That(LogManager.GetLogger(typeof(DiagnosticOutputRuleMergeDecorator)).IsDebugEnabled, Is.False);
_serviceLocatorScope.Dispose();
}
public LogEventList GetPendingLoggingEvents()
{
LogEventList list = new LogEventList();
if (appender != null)
{
LoggingEvent[] result = appender.GetEvents();
foreach (LoggingEvent evt in result)
{
list.Add(new LogEvent(evt));
}
appender.Clear();
}
return(list);
}
public void TestInitialize()
{
// The test assembly has no notion of the default AnalysisPrograms.exe binary location.
// We have to mock it.
ConfigFile.ConfigFolder =
Path.GetFullPath(
Path.Combine(
Assembly.GetExecutingAssembly().Location,
"../ConfigFiles"));
// clear the log
memoryAppender.Clear();
// flush the cache (important to reset state between tests)
ConfigFile.FlushCache();
}
public static IEnumerable <LoggingEvent> NextLoggingEvent()
{
while (true)
{
Queue <LoggingEvent> events = new Queue <LoggingEvent>(appender.GetEvents().ToList());
if (events != null && events.Count > 0)
{
appender.Clear();
while (events.Count > 0)
{
yield return(events.Dequeue());
}
}
else
{
Thread.Sleep(300);
yield return(null);
}
}
}
private void LogerWatch()
{
while (logWatching)
{
LoggingEvent[] events = appender.GetEvents();
if (events != null && events.Length > 0)
{
// if there are events, we clear them from the logger,
// since we're done with them
appender.Clear();
foreach (LoggingEvent ev in events)
{
//string line = ev.LoggerName + ": " + ev.RenderedMessage + "\r\n";
string line = ev.RenderedMessage + "\r\n";
AppendLog(line);
}
}
Thread.Sleep(500);
}
}
private static ReadMeTranslationEntry GetTranslationEntry(MemoryAppender appender, MethodBase methodInfo,
Type type)
{
var tAttr = methodInfo.GetCustomAttribute <TranslationReadMeAttribute>();
if (tAttr == null)
{
return(null);
}
var test = Activator.CreateInstance(type);
methodInfo.Invoke(test, new object[0]);
var record = appender.GetEvents()
.Select(e => e.MessageObject)
.OfType <Tuple <Expression, string> >()
.Single();
appender.Clear();
var expression = record.Item1;
var sql = record.Item2;
var expStr = expression.ToReadableString();
expStr = QueryableNameRegex.Replace(expStr, @"db.$1s");
expStr = SingleLineCommentsRegex.Replace(expStr, "");
return(new ReadMeTranslationEntry
{
TranslationAttr = tAttr,
ExpressionString = expStr,
Sql = sql
});
}
/// <summary>
/// Handles the Tick event of the tmrUpdateDisplay control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="eArgs">The <see cref="System.EventArgs"/> instance containing the event data.</param>
void tmrUpdateDisplay_Tick(object sender, EventArgs eArgs)
{
++_interfaceUpdateTicker;
// Get the latest events
LoggingEvent[] events;
try
{
events = _logger.GetEvents();
}
catch (ArgumentException)
{
// There is some bug in the _logger.GetEvents() that can throw this exception...
return;
}
_logger.Clear();
// Ensure there are events
if (events != null && events.Length > 0)
{
_logBuffer.AddRange(events);
if (_logBuffer.Count > _logBufferSize)
{
_logBuffer.RemoveRange(0, _logBuffer.Count - _logBufferSize + _logBufferRemoveExtra);
}
events = GetFilteredEvents(events);
if (events != null && events.Length > 0)
{
lstLog.SuspendLayout();
lstLog.Enabled = false;
try
{
// Add the events
lstLog.Items.AddRange(events.Cast <object>().ToArray());
// If too long, truncate
while (lstLog.Items.Count > _maxLogDisplayLines)
{
lstLog.Items.RemoveAt(0);
}
// Scroll down to see the latest item if nothing is selected
if (lstLog.SelectedIndex < 0)
{
lstLog.SelectedIndex = lstLog.Items.Count - 1;
lstLog.ClearSelected();
// Auto-scroll
var numItems = lstLog.ClientSize.Height / lstLog.ItemHeight;
lstLog.TopIndex = Math.Max(0, lstLog.Items.Count - numItems + 1);
}
else
{
lstLog.TopIndex = lstLog.SelectedIndex;
}
}
finally
{
lstLog.Enabled = true;
lstLog.ResumeLayout();
}
}
}
// Update the CPU and memory usage values
if (_interfaceUpdateTicker % 8 == 0)
{
// Bandwidth
if (_server != null && _server.ServerSockets != null)
{
try
{
var totalBytes = _server.ServerSockets.Statistics.ReceivedBytes + _server.ServerSockets.Statistics.SentBytes;
var totalMegabytes = totalBytes / 1000f / 1000f;
lblBandwidth.Text = string.Format("{0:0.##} MB", totalMegabytes);
}
catch
{
lblBandwidth.Text = "ERROR";
}
}
else
{
lblBandwidth.Text = "";
}
// User count
if (_server != null)
{
try
{
lblUserCount.Text = _server.World.GetUsers().Count().ToString();
}
catch
{
lblUserCount.Text = "ERROR";
}
}
else
{
lblUserCount.Text = "0";
}
// CPU
if (_cpuCounter != null)
{
try
{
lblCPU.Text = Math.Round(_cpuCounter.NextValue()) + "%";
}
catch
{
lblCPU.Text = "ERROR";
}
}
else
{
lblCPU.Text = "?";
}
// Memory used
try
{
lblRAMUsed.Text = SystemPerformance.Memory.ProcessUsageMB + " MB";
}
catch
{
lblRAMUsed.Text = "ERROR";
}
// Memory free
try
{
lblRAMFree.Text = SystemPerformance.Memory.AvailableMB + " MB";
}
catch
{
lblRAMFree.Text = "ERROR";
}
}
}
public void Setup()
{
_log4NetMemoryLog.Clear();
}
public void ClearEvents()
{
_memAppender.Clear();
}
protected void ClearLogEvents()
{
_loggedEvents.Clear();
}
/// <summary>
/// Handles the Tick event of the tmrUpdateDisplay control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="eArgs">The <see cref="System.EventArgs"/> instance containing the event data.</param>
void tmrUpdateDisplay_Tick(object sender, EventArgs eArgs)
{
++_interfaceUpdateTicker;
// Get the latest events
LoggingEvent[] events;
try
{
events = _logger.GetEvents();
}
catch (ArgumentException)
{
// There is some bug in the _logger.GetEvents() that can throw this exception...
return;
}
_logger.Clear();
// Ensure there are events
if (events != null && events.Length > 0)
{
_logBuffer.AddRange(events);
if (_logBuffer.Count > _logBufferSize)
{
_logBuffer.RemoveRange(0, _logBuffer.Count - _logBufferSize + _logBufferRemoveExtra);
}
events = GetFilteredEvents(events);
if (events != null && events.Length > 0)
{
lstLog.SuspendLayout();
lstLog.Enabled = false;
try
{
// Add the events
lstLog.Items.AddRange(events);
// If too long, truncate
while (lstLog.Items.Count > _maxLogDisplayLines)
{
lstLog.Items.RemoveAt(0);
}
// Scroll down to see the latest item if nothing is selected
if (lstLog.SelectedIndex < 0)
{
lstLog.SelectedIndex = lstLog.Items.Count - 1;
lstLog.ClearSelected();
// Auto-scroll
var numItems = lstLog.ClientSize.Height / lstLog.ItemHeight;
lstLog.TopIndex = Math.Max(0, lstLog.Items.Count - numItems + 1);
}
else
{
lstLog.TopIndex = lstLog.SelectedIndex;
}
}
finally
{
lstLog.Enabled = true;
lstLog.ResumeLayout();
}
}
}
// Update the CPU and memory usage values
if (_interfaceUpdateTicker % 4 == 0)
{
lblCPU.Text = Math.Round(_cpuCounter.NextValue()) + "%";
lblRAMUsed.Text = SystemPerformance.Memory.ProcessUsageMB + " MB";
lblRAMFree.Text = SystemPerformance.Memory.AvailableMB + " MB";
}
}
public void Dispose()
{
_appender.Clear();
}