public void MessageBatching_Works_Default1()
{
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.ActiveTraceLevel = SourceLevels.Information;
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
sut.Info.Log("Dummy Message");
sut.Flush();
sut.Info.Log("Dummy Message");
sut.Flush();
Assert.Equal(1, mmh.LastMessageBatchSize);
}
/// [Trait(Traits.Age, Traits.Fresh)]
//[Trait(Traits.Style, Traits.Unit)]
public void MessageBatching_Works_Enabled()
{
const int MESSAGE_BATCHSIZE = 10;
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.SetMessageBatching(MESSAGE_BATCHSIZE, 500000);
sut.ActiveTraceLevel = SourceLevels.Information;
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
for (int i = 0; i < 100; i++)
{
sut.Info.Log("Dummy Message");
if (i % 25 == 0)
{
//Thread.Sleep(100);
// The flush forces the write, this is needed otherwise it bombs through
// too fast for more than one write to the handler to occur.
sut.Flush();
}
if (mmh.TotalMessagesRecieved > 0)
{
// Any time that we get a batch it must be at least MESSAGE_BATCHSIZE msgs.
Assert.True(mmh.LastMessageBatchSize >= MESSAGE_BATCHSIZE, $"Batch Size NotBig Enough at {i} batch Size {mmh.LastMessageBatchSize}");
}
}
}
public void ObjectDump_WritesObjectContents()
{
#if ACTIVEDEBUG
var ied = new IEmergencyDiagnostics();
#else
var ied = new MockEmergencyDiagnostics();
#endif
try {
ied.Log("START OD");
TestObject to = new TestObject();
to.stringvalue = "arfle barfle gloop";
Bilge sut = TestHelper.GetBilgeAndClearDown();
ied.Log("Before Anything Done");
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
sut.Info.Dump(to, "context");
ied.Log("FLUSH OD");
sut.Flush();
ied.Log("FlushAfter OD");
mmh.SetMustContainForBody("arfle barfle gloop");
ied.Log("ASSERT OD");
mmh.AssertAllConditionsMetForAllMessages(true, true);
} finally {
ied.Log("END OD");
ied.Shutdown();
}
}
public void QueuedMessagesNotWrittenIfWriteOnFailSet()
{
MockMessageHandler mmh = new MockMessageHandler();
Bilge b = TestHelper.GetBilgeAndClearDown();
b.AddHandler(mmh);
b.WriteOnFail = true;
WriteASeriesOfMessages(b);
b.Flush();
Assert.Equal <int>(0, mmh.TotalMessagesRecieved);
}
public void MethodName_MatchesThisMethodName()
{
MockMessageHandler mmh = new MockMessageHandler();
mmh.SetMethodNameMustContain(nameof(MethodName_MatchesThisMethodName));
Bilge b = TestHelper.GetBilgeAndClearDown();
b.AddHandler(mmh);
b.Info.Log("This is a message");
b.Flush();// (true);
mmh.AssertAllConditionsMetForAllMessages(true);
}
public void Bilge_EnterSection_TracesSection()
{
var mmh = new MockMessageHandler();
Bilge sut = new Bilge(tl: SourceLevels.Verbose);
sut.AddHandler(mmh);
mmh.SetMethodNameMustContain("monkeyfish");
sut.Info.EnterSection("random sectiion", "monkeyfish");
sut.Flush();
mmh.AssertAllConditionsMetForAllMessages(true, true);
}
public void Assert_False_FailsIfTrue()
{
var mmh = new MockMessageHandler();
Bilge sut = new Bilge();
sut.AddHandler(mmh);
sut.Assert.True(false);
sut.Flush();
Assert.True(mmh.AssertionMessageCount > 0);
}
public void BasicAlert_GetsWritten_TraceOff()
{
Bilge sut = TestHelper.GetBilgeAndClearDown();
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
Bilge.Alert.Online("test-appname");
sut.Flush();
Assert.Equal(1, mmh.TotalMessagesRecieved);
}
public void ExecuteTest()
{
clockers.Clear();
if (Debugger.IsAttached)
{
MESSAGESTOSEND = 100;
}
Func <Bilge> defaultBilge = () => {
return(b);
};
Func <Bilge> bigBatch = () => {
var bx = new Bilge(tl: SourceLevels.Verbose);
bx.SetMessageBatching(1000, 5000);
return(bx);
};
Func <Bilge> bilgeNoBatching = () => {
Bilge bx = new Bilge(tl: SourceLevels.Verbose);
bx.DisableMessageBatching();
return(bx);
};
Action <string, Action <Bilge>, Bilge> runPerformanceTest = (nameOfTheTest, testMethodToExecute, bilgeInstanceToUse) => {
clockers.Add(nameOfTheTest, new Stopwatch());
Bilge bToUse = bilgeInstanceToUse;
clockers[nameOfTheTest].Start();
testMethodToExecute(bToUse);
clockers[nameOfTheTest].Stop();
};
clockers.Add("main", new Stopwatch());
clockers.Add("main-noflush", new Stopwatch());
clockers["main"].Start();
clockers["main-noflush"].Start();
runPerformanceTest("singleLog-default", StandardLogOnMainThread, defaultBilge());
runPerformanceTest("singleLog-nobatch", StandardLogOnMainThread, bilgeNoBatching());
runPerformanceTest("singleLog-bigbatch", StandardLogOnMainThread, bigBatch());
//runPerformanceTest("standard-onelog-nobatch", StandardLogOnMainThread, bilgeNoBatching());
runPerformanceTest("mutilog-default", MultiLogOnMainThread, defaultBilge());
clockers["main-noflush"].Stop();
b.Flush();
clockers["main"].Stop();
}
public void Bilge_LeaveSection_TracesSection()
{
var mmh = new MockMessageHandler();
Bilge sut = new Bilge(tl: SourceLevels.Verbose);
sut.AddHandler(mmh);
mmh.SetMethodNameMustContain("bannanaball");
sut.Info.LeaveSection("bannanaball");
sut.Flush();
mmh.AssertAllConditionsMetForAllMessages(true, true);
}
public void InfoNotLogged_IfNotInfo()
{
MockMessageHandler mmh = new MockMessageHandler();
Bilge b = TestHelper.GetBilgeAndClearDown();
b.ActiveTraceLevel = SourceLevels.Warning;
b.AddHandler(mmh);
b.Info.Log("msg");
b.Verbose.Log("Msg");
b.Flush();
Assert.Equal <int>(0, mmh.TotalMessagesRecieved);
}
/// [Trait(Traits.Age, Traits.Fresh)]
//[Trait(Traits.Style, Traits.Unit)]
public void MessageBatching_Works_Timed()
{
const int MESSAGE_BATCHSIZE = 10000;
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.SetMessageBatching(MESSAGE_BATCHSIZE, 250);
sut.ActiveTraceLevel = SourceLevels.Information;
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
sut.Info.Log("Dummy Message");
Stopwatch timeSoFar = new Stopwatch();
timeSoFar.Start();
bool writesFound = false;
while (timeSoFar.Elapsed.TotalMilliseconds < 750)
{
// This is not particularly precise because of threading and guarantees so we are using some generous margins for error.
// With the write time of not less than 250 we shouldnt see any writes for the first 175 MS. If we do then its a test fail.
// Similarly if we reach 750 ms and havent seen any writes thats a test fail.
if (timeSoFar.ElapsedMilliseconds < 175)
{
Assert.Equal(0, mmh.TotalMessagesRecieved);
}
else
{
if (mmh.TotalMessagesRecieved > 0)
{
writesFound = true;
break;
}
}
if (timeSoFar.ElapsedMilliseconds > 350)
{
sut.Flush();
}
}
if (!writesFound)
{
throw new InvalidOperationException("The writes never hit the listener");
}
}
public void Enter_WritesMethodName()
{
Bilge sut = TestHelper.GetBilgeAndClearDown();
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
sut.Info.E();
sut.Flush();
mmh.SetMustContainForBody(nameof(Enter_WritesMethodName));
// E generates more than one message, therefore we have to check that one of the messages had the name in it.
mmh.AssertAllConditionsMetForAllMessages(true, true);
}
public void Context_FromConstructorReachesMessage()
{
MockMessageHandler mmh = new MockMessageHandler();
string context = "xxCtxtxx";
mmh.AssertContextIs(context);
Bilge sut = TestHelper.GetBilgeAndClearDown(context);
sut.AddHandler(mmh);
sut.Info.Log("Message should have context");
sut.Flush();
Thread.Sleep(1);
mmh.AssertAllConditionsMetForAllMessages(true);
}
public void ProcessId_IsCorrectProcessId()
{
int testProcId = Process.GetCurrentProcess().Id;
MockMessageHandler mmh = new MockMessageHandler();
mmh.AssertProcessId(testProcId);
mmh.AssertManagedThreadId(Thread.CurrentThread.ManagedThreadId);
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.AddHandler(mmh);
sut.Info.Log("Message Written");
sut.Flush();
mmh.AssertAllConditionsMetForAllMessages(true);
}
public void Exit_WritesMethodName()
{
var mmh = new MockMessageHandler();
mmh.SetMethodNameMustContain(nameof(Exit_WritesMethodName));
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.ActiveTraceLevel = SourceLevels.Verbose;
sut.AddHandler(mmh);
sut.Info.X();
sut.Flush();
// X generates more than one message, therefore we have to check that one of the messages had the name in it.
mmh.AssertAllConditionsMetForAllMessages(true, true);
}
public void DirectWrite_IsPossible()
{
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.DisableMessageBatching();
sut.ActiveTraceLevel = SourceLevels.Verbose;
var mmh = new MockMessageHandler();
sut.AddHandler(mmh);
sut.Direct.Write("DirectMessage", "DirectFurther");
sut.Flush();
Assert.Equal(1, mmh.TotalMessagesRecieved);
}
public void QueuedMessagesWritten_AfterFlush()
{
MockMessageHandler mmh = new MockMessageHandler();
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.AddHandler(mmh);
sut.WriteOnFail = true;
WriteASeriesOfMessages(sut);
Assert.Equal <int>(0, mmh.TotalMessagesRecieved);
sut.TriggerWrite();
sut.Flush();
mmh.AssertAllConditionsMetForAllMessages(true);
}
public void Action_WhenExecuted_WritesToTraceStream()
{
var mmh = new MockMessageHandler();
mmh.SetMethodNameMustContain(nameof(Action_WhenExecuted_WritesToTraceStream));
Bilge sut = TestHelper.GetBilgeAndClearDown();
sut.ActiveTraceLevel = SourceLevels.Verbose;
sut.AddHandler(mmh);
Assert.Equal(0, mmh.TotalMessagesRecieved);
sut.Action.Occured("test", "test");
sut.Flush();
Assert.True(mmh.TotalMessagesRecieved > 0);
}
private static void Main(string[] args)
{
Console.WriteLine("Plisky Tool - Online.");
var clas = new CommandArgumentSupport();
clas.ArgumentPostfix = "=";
clas.ProcessArguments(options, args);
if (!ValidateArgumentSettings(options))
{
// TODO : Merge this in with the same code below
Console.WriteLine("Fatal: Argument Validation Failed.");
Console.WriteLine();
string s = clas.GenerateShortHelp(options, "Plisky Tool");
Console.WriteLine(s);
return;
}
if ((options.Debug) || (!string.IsNullOrEmpty(options.Trace)))
{
Console.WriteLine("Debug Mode, Adding Trace Handler");
Bilge.AddHandler(new ConsoleHandler(), HandlerAddOptions.SingleType);
Bilge.SetConfigurationResolver((name, inLevel) => {
SourceLevels returnLvl = SourceLevels.Verbose;
if ((options.Trace != null) && (options.Trace.ToLowerInvariant() == "info"))
{
returnLvl = SourceLevels.Information;
}
if ((name.Contains("Plisky-Versioning")) || (name.Contains("Plisky-Tool")))
{
return(returnLvl);
}
return(inLevel);
});
}
Bilge b = new Bilge("Plisky-Tool");
Bilge.Alert.Online("Plisky-Tool");
b.Verbose.Dump(options, "App Options");
if (PerformActionsFromCommandline())
{
if (versionerUsed != null)
{
VersioningOutputter vo = new VersioningOutputter(versionerUsed);
vo.DoOutput(options.OutputsActive);
}
b.Info.Log("All Actions - Complete - Exiting.");
}
else
{
// TODO : Merge this in with the same code Above
string s = clas.GenerateShortHelp(options, "Plisky Tool");
Console.WriteLine(s);
}
b.Verbose.Log("Plisky Tool - Exit.");
b.Flush();
}
internal void AllDone()
{
b.Info.Log("All Done.");
b.Flush();
}
private static void Main(string[] args)
{
string dt = $"{DateTime.Now.Hour}{DateTime.Now.Minute}{DateTime.Now.Second}";
FileSystemHandler fsh = new FileSystemHandler(new FSHandlerOptions("c:\\Temp\\votalot\\dummy" + dt + ".log"));
fsh.SetFormatter(new FlimFlamV2Formatter());
Bilge.AddMessageHandler(new ConsoleHandler());
Bilge.AddMessageHandler(new TCPHandler("127.0.0.1", 9060));
Bilge.AddMessageHandler(fsh);
Bilge.Alert.Online("TestClient");
#if CORE
// Due to the dependency on configurations and the different ways that you can configure a core service this is not
// implemented within Bilge even as a default but is documented instead.
Bilge.SetConfigurationResolver((s, lvl) => {
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", false, true)
.Build();
SourceLevels result = lvl;
string defaultValue = configuration["logging:loglevel:default"];
string specificForThisInstance = configuration[$"logging:loglevel:{s}"];
if (Enum.TryParse <SourceLevels>(specificForThisInstance, out SourceLevels slSpecific))
{
result = slSpecific;
}
else
{
if (Enum.TryParse <SourceLevels>(defaultValue, out SourceLevels slDefault))
{
result = slDefault;
}
}
return(result);
});
#else
Bilge.SetConfigurationResolver((instanceName, lvl) => {
// Logic -> Try Source Switch, Failing that Trace Switch, failing that SourceSwitch + Switch, Failing that TraceSwitch+Switch.
SourceLevels result = lvl;
bool tryTraceSwitches = true;
try {
SourceSwitch ss = new SourceSwitch(instanceName);
if (ss.Level == SourceLevels.Off)
{
ss = new SourceSwitch($"{instanceName}Switch");
if (ss.Level == SourceLevels.Off)
{
}
else
{
tryTraceSwitches = false;
result = ss.Level;
}
}
else
{
tryTraceSwitches = false;
result = ss.Level;
}
} catch (SystemException) {
// This is the higher level exception of a ConfigurationErrorsException but that one requires a separate reference
// This occurs when a TraceSwitch has the same name as the source switch with a value that is not supported by source switch e.g. Info
}
if (tryTraceSwitches)
{
TraceSwitch ts = new TraceSwitch(instanceName, "");
if (ts.Level == TraceLevel.Off)
{
ts = new TraceSwitch($"{instanceName}Switch", "");
if (ts.Level != TraceLevel.Off)
{
result = Bilge.ConvertTraceLevel(ts.Level);
}
}
else
{
result = Bilge.ConvertTraceLevel(ts.Level);
}
}
return(result);
});
#endif
Bilge b = new Bilge("PliskyConsoleTestApp");
b.ActiveTraceLevel = SourceLevels.Verbose;
b.Verbose.Log("Hello Cruel World");
bool traceSwitchTests = false;
bool bulkFileWriteTests = false;
bool perfTests = false;
bool basicWriteAllTest = true;
bool actionTest = true;
if (actionTest)
{
int acCount = 0;
b.Action.RegisterHandler((m) => {
if (m.Success)
{
acCount++;
}
}, "bob");
b.Action.Occured("Event", "Data");
if (acCount == 0)
{
throw new InvalidOperationException("didnt work");
}
}
if (basicWriteAllTest)
{
Bilge.SetConfigurationResolver((instanceName, lvl) => {
return(SourceLevels.Verbose);
});
ModularWriting mw = new ModularWriting();
mw.DoWrite();
}
if (bulkFileWriteTests)
{
ProductionLoggingTest(b);
}
b.Flush();
if (perfTests)
{
PerformanceTest p = new PerformanceTest();
p.AnalysisBatchVsNoBatch();
//p.ExecuteTest();
p.WriteOutput();
Bilge.ForceFlush();
}
Console.ReadLine();
return;
b.AddHandler(new SimpleTraceFileHandler(@"c:\temp\"));
if (traceSwitchTests)
{
Console.WriteLine("Actual Trace Level : " + b.ActiveTraceLevel.ToString());
try {
TraceSource ts = new TraceSource("monkeySwitch", SourceLevels.Off);
TraceSwitch tx = new TraceSwitch("monkey2Switch", "test", "Off");
SourceSwitch sw = new SourceSwitch("boner", "off");
Console.WriteLine($"{ts.Switch.Level} >> {tx.Level} >> {sw.Level}");
Console.ReadLine();
} catch (Exception ex) {
}
}
bool doDirectWriting = false;
if (args.Length > 0)
{
if (args[0] == "direct")
{
doDirectWriting = true;
}
}
if (doDirectWriting)
{
var dr = new DirectWriting(b);
dr.DoDirectWrites();
}
ModularWriting mr = new ModularWriting();
mr.DoWrite();
b.Flush();
Console.WriteLine("Readline");
Console.ReadLine();
}
