public void TestReconfiguration()
{
RollbarLoggerConfig config = new RollbarLoggerConfig();
Assert.AreEqual("seedToken", config.RollbarDestinationOptions.AccessToken);
Console.WriteLine(config.TraceAsString());
config.Reconfigured += Config_Reconfigured;
Assert.AreEqual(0, this._actualReconfigCount);
IRollbarDestinationOptions rollbarDestinationOptions = config.RollbarDestinationOptions;
RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions();
destinationOptions.AccessToken = "CUSTOM";
config.RollbarDestinationOptions.Reconfigure(destinationOptions);
Assert.AreEqual(1, this._actualReconfigCount);
Assert.AreSame(rollbarDestinationOptions, config.RollbarDestinationOptions);
Assert.AreEqual("CUSTOM", config.RollbarDestinationOptions.AccessToken, "Options reconfig works!");
Console.WriteLine(config.TraceAsString());
RollbarLoggerConfig newConfig = new RollbarLoggerConfig();
Assert.AreEqual("seedToken", newConfig.RollbarDestinationOptions.AccessToken);
Console.WriteLine(newConfig.TraceAsString());
Assert.AreNotSame(rollbarDestinationOptions, newConfig.RollbarDestinationOptions);
newConfig.Reconfigured += Config_Reconfigured;
rollbarDestinationOptions = newConfig.RollbarDestinationOptions;
newConfig.Reconfigure(config);
Assert.AreEqual(8, this._actualReconfigCount);
Assert.AreEqual("CUSTOM", newConfig.RollbarDestinationOptions.AccessToken, "Structured config's reconfig works!");
Console.WriteLine(newConfig.TraceAsString());
Assert.AreSame(rollbarDestinationOptions, newConfig.RollbarDestinationOptions);
Assert.AreNotSame(config, newConfig);
Assert.AreNotSame(config.RollbarDestinationOptions, newConfig.RollbarDestinationOptions);
}
public void TestGetSafeScrubFields()
{
var scrubFields = new string[] { "one", "two", "three", };
var scrubSafelistFields = new string[] { "two", };
var expectedSafeScrubFields = new string[] { "one", "three", };
var destinationOptions = new RollbarDestinationOptions(RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment);
var dataSecurityOptions = new RollbarDataSecurityOptions();
dataSecurityOptions.ScrubFields = scrubFields;
dataSecurityOptions.ScrubSafelistFields = scrubSafelistFields;
var loggerConfig = new RollbarLoggerConfig(RollbarUnitTestSettings.AccessToken);
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
loggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions);
var result = loggerConfig.RollbarDataSecurityOptions.GetFieldsToScrub();
Assert.AreEqual(expectedSafeScrubFields.Length, result.Count);
foreach (var expected in expectedSafeScrubFields)
{
Assert.IsTrue(result.Contains(expected));
}
}
public void TestBasics()
{
RollbarDestinationOptions options = new RollbarDestinationOptions();
Console.WriteLine(options.TraceAsString());
Assert.AreEqual(null, options.AccessToken, "AccessToken is null!");
var results = options.Validate();
Assert.AreEqual(1, results.Count, "One Validation Rule failed!");
Console.WriteLine("Validation Results:");
foreach (var result in results)
{
Console.WriteLine($" {result}");
}
Console.WriteLine();
options.AccessToken = "ACCESS_TOKEN";
Console.WriteLine(options.TraceAsString());
Assert.AreEqual("ACCESS_TOKEN", options.AccessToken, "Expected AccessToken");
results = options.Validate();
Assert.AreEqual(0, results.Count, "No Validation Rule failed!");
Console.WriteLine("Validation Results:");
foreach (var result in results)
{
Console.WriteLine($" {result}");
}
Console.WriteLine();
}
public PayloadFixture()
{
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment);
this._config = new RollbarLoggerConfig();
this._config.RollbarDestinationOptions.Reconfigure(destinationOptions);
}
public void ConvenienceMethodsUseAppropriateErrorLevels(ErrorLevel expectedLogLevel)
{
var acctualLogLevel = ErrorLevel.Info;
void Transform(Payload payload)
{
acctualLogLevel = payload.Data.Level.Value;
}
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarPayloadManipulationOptions payloadManipulationOptions =
new RollbarPayloadManipulationOptions(Transform);
var loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions);
using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig))
{
try
{
var blockingLogger = logger.AsBlockingLogger(TimeSpan.FromMilliseconds(TIME_OUT));
var ex = new Exception();
switch (expectedLogLevel)
{
case ErrorLevel.Critical:
blockingLogger.Critical(ex);
break;
case ErrorLevel.Error:
blockingLogger.Error(ex);
break;
case ErrorLevel.Warning:
blockingLogger.Warning(ex);
break;
case ErrorLevel.Info:
blockingLogger.Info(ex);
break;
case ErrorLevel.Debug:
blockingLogger.Debug(ex);
break;
}
}
catch
{
Assert.Fail();
}
}
Assert.AreEqual(expectedLogLevel, acctualLogLevel);
}
public static RollbarDestinationOptions GetLiveTestRollbarDestinationOptions()
{
var options =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
return(options);
}
public void SetupFixture()
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
this._loggerConfig =
new RollbarLoggerConfig();
this._loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
}
/// <summary>
/// Provides configuration for RollbarSink.
/// </summary>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <param name="rollbarAccessToken">The Rollbar access token.</param>
/// <param name="rollbarEnvironment">The Rollbar environment.</param>
/// <param name="rollbarBlockingLoggingTimeout">The Rollbar blocking logging timeout.</param>
/// <param name="formatProvider">The format provider.</param>
/// <param name="restrictedToMinimumLevel">
/// The minimum level for events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.
/// </param>
/// <param name="levelSwitch">A switch allowing the pass-through minimum level to be changed at runtime.</param>
/// <returns>LoggerConfiguration.</returns>
public static LoggerConfiguration RollbarSink(
this LoggerSinkConfiguration loggerConfiguration,
string rollbarAccessToken,
string rollbarEnvironment,
TimeSpan?rollbarBlockingLoggingTimeout,
IFormatProvider?formatProvider,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
LoggingLevelSwitch?levelSwitch = null
)
{
RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions(rollbarAccessToken, rollbarEnvironment);
IRollbarInfrastructureConfig config = new RollbarInfrastructureConfig();
config.RollbarLoggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
return(loggerConfiguration.RollbarSink(config, rollbarBlockingLoggingTimeout, formatProvider, restrictedToMinimumLevel, levelSwitch));
}
/// <summary>
/// Provides the live rollbar configuration.
/// </summary>
/// <param name="rollbarAccessToken">The rollbar access token.</param>
/// <param name="rollbarEnvironment">The rollbar environment.</param>
/// <returns>IRollbarConfig.</returns>
protected IRollbarLoggerConfig ProvideLiveRollbarConfig(string rollbarAccessToken, string rollbarEnvironment)
{
if (this._loggerConfig == null)
{
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(rollbarAccessToken, rollbarEnvironment);
RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions();
dataSecurityOptions.ScrubFields = new string[] { "secret", "super_secret", };
RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
loggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions);
this._loggerConfig = loggerConfig;
}
return(this._loggerConfig);
}
public void ReconfigureRollbarTest()
{
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig1 =
new RollbarLoggerConfig();
loggerConfig1.RollbarDestinationOptions.Reconfigure(destinationOptions);
destinationOptions.AccessToken =
RollbarUnitTestSettings.AccessToken.Replace('0', '1');
RollbarLoggerConfig loggerConfig2 =
new RollbarLoggerConfig();
loggerConfig2.RollbarDestinationOptions.Reconfigure(destinationOptions);
Assert.AreNotEqual(loggerConfig1.RollbarDestinationOptions.AccessToken, loggerConfig2.RollbarDestinationOptions.AccessToken);
int initialCount = RollbarQueueController.Instance.GetQueuesCount();
int initialCount1 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken);
int initialCount2 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken);
Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
using (var logger1 = RollbarFactory.CreateNew().Configure(loggerConfig1))
{
Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
logger1.Configure(loggerConfig2);
Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
}
}
public void ExceptionWhileTransformingPayloadAsync()
{
this._transformException = false;
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions();
payloadManipulationOptions.Transform = delegate {
throw new NullReferenceException();
};
loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions);
using IRollbar logger = RollbarFactory.CreateNew().Configure(loggerConfig);
logger.InternalEvent += Logger_InternalEvent;
try
{
this.IncrementCount <CommunicationEventArgs>();
logger.Log(ErrorLevel.Error, "test message");
}
catch
{
logger.InternalEvent -= Logger_InternalEvent;
Assert.Fail("should never get here!");
throw;
}
this._signal.Wait();
logger.InternalEvent -= Logger_InternalEvent;
Assert.IsTrue(this._transformException);
}
public void MultithreadedStressTest_BlockingLogs()
{
RollbarLoggerFixture.stressLogsCount = 0;
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
RollbarInfrastructureOptions infrastructureOptions = new RollbarInfrastructureOptions();
infrastructureOptions.ReportingQueueDepth = 200;
RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions.Reconfigure(infrastructureOptions);
this.IncrementCount <CommunicationEventArgs>(RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions.ReportingQueueDepth);
TimeSpan rollbarBlockingTimeout = TimeSpan.FromMilliseconds(55000);
List <IRollbar> rollbars =
new List <IRollbar>(MultithreadedStressTestParams.TotalThreads);
List <ILogger> loggers = new List <ILogger>(MultithreadedStressTestParams.TotalThreads);
for (int i = 0; i < MultithreadedStressTestParams.TotalThreads; i++)
{
var rollbar = RollbarFactory.CreateNew().Configure(loggerConfig);
loggers.Add(rollbar.AsBlockingLogger(rollbarBlockingTimeout));
rollbars.Add(rollbar);
}
PerformTheMultithreadedStressTest(loggers.ToArray());
rollbars.ForEach(r => {
r.Dispose();
});
}
public void BasicPayloadBundleTest()
{
const int totalExceptionFrames = 5;
System.Exception exceptionObj = ExceptionSimulator.GetExceptionWith(totalExceptionFrames);
IRollbarPackage package = new ObjectPackage(exceptionObj, true);
Assert.IsTrue(package.MustApplySynchronously);
Assert.IsNull(package.RollbarData);
//var rollbarData = package.PackageAsRollbarData();
//Assert.AreSame(rollbarData, package.RollbarData);
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions("ACCESS_TOKEN", "ENV");
IRollbarLoggerConfig config = infrastructureConfig.RollbarLoggerConfig;
config.RollbarDestinationOptions.Reconfigure(destinationOptions);
using (IRollbar rollbarLogger = RollbarFactory.CreateNew(config))
{
PayloadBundle bundle = new PayloadBundle(rollbarLogger as RollbarLogger, package, ErrorLevel.Critical);
var payload = bundle.GetPayload();
}
}
public void LongReportIsAsync()
{
const int maxCallLengthInMillisec = 50;
TimeSpan payloadSubmissionDelay = TimeSpan.FromMilliseconds(3 * maxCallLengthInMillisec);
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions();
payloadManipulationOptions.Transform = delegate
{
Thread.Sleep(payloadSubmissionDelay);
};
loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions);
using IRollbar logger = RollbarFactory.CreateNew().Configure(loggerConfig);
try
{
this.IncrementCount <CommunicationEventArgs>();
Stopwatch sw = Stopwatch.StartNew();
logger.Log(ErrorLevel.Error, "test message");
sw.Stop();
Assert.IsTrue(sw.ElapsedMilliseconds < maxCallLengthInMillisec);
Thread.Sleep(payloadSubmissionDelay);
}
catch
{
Assert.Fail("should never get here!");
}
}
public void QueueRegisterationTest()
{
Console.WriteLine($"Unrealeased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}");
// we need to make sure we are starting clean:
RollbarQueueController.Instance.FlushQueues();
RollbarQueueController.Instance.Stop(true);
RollbarQueueController.Instance.Start();
//while (RollbarQueueController.Instance.GetQueuesCount() > 0)
//{
// Thread.Sleep(TimeSpan.FromMilliseconds(250));
//}
Console.WriteLine($"Unreleased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}");
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig1 =
new RollbarLoggerConfig();
loggerConfig1.RollbarDestinationOptions.Reconfigure(destinationOptions);
destinationOptions.AccessToken =
RollbarUnitTestSettings.AccessToken.Replace('0', '1');
RollbarLoggerConfig loggerConfig2 =
new RollbarLoggerConfig();
loggerConfig2.RollbarDestinationOptions.Reconfigure(destinationOptions);
Console.WriteLine($"Unreleased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}");
Assert.AreNotEqual(loggerConfig1.RollbarDestinationOptions.AccessToken, loggerConfig2.RollbarDestinationOptions.AccessToken);
int initialCount = RollbarQueueController.Instance.GetQueuesCount();
int initialCount1 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken);
int initialCount2 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken);
Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
using (var logger1 = RollbarFactory.CreateNew().Configure(loggerConfig1))
{
Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 1,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
using (var logger2 = RollbarFactory.CreateNew().Configure(loggerConfig1))
{
Assert.AreEqual(initialCount + 2, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 2,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
using (var logger3 = RollbarFactory.CreateNew().Configure(loggerConfig2))
{
Assert.AreEqual(initialCount + 3, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 2,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 1,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
}
// an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles:
while ((initialCount + 2) != RollbarQueueController.Instance.GetQueuesCount())
{
Thread.Sleep(TimeSpan.FromMilliseconds(250));
}
// if everything is good, we should get here way before this test method times out:
Assert.AreEqual(initialCount + 2, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 2,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
}
// an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles:
while ((initialCount + 1) != RollbarQueueController.Instance.GetQueuesCount())
{
Thread.Sleep(TimeSpan.FromMilliseconds(250));
}
// if everything is good, we should get here way before this test method times out:
Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 1,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
}
// an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles:
while ((initialCount + 0) != RollbarQueueController.Instance.GetQueuesCount())
{
Console.WriteLine($"Unreleased queues count: {RollbarQueueController.Instance.GetUnReleasedQueuesCount()}");
Thread.Sleep(TimeSpan.FromMilliseconds(250));
}
// if everything is good, we should get here way before this test method times out:
Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.RollbarDestinationOptions.AccessToken));
Assert.AreEqual(initialCount2 + 0,
RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.RollbarDestinationOptions.AccessToken));
}
public void ScopedInstanceTest()
{
// we need to make sure we are starting clean:
RollbarQueueController.Instance.FlushQueues();
RollbarQueueController.Instance.Start();
var accessTokenQueues =
RollbarQueueController.Instance.GetQueues(RollbarUnitTestSettings.AccessToken);
while (accessTokenQueues.Any())
{
string msg = "Initial queues count: " + accessTokenQueues.Count();
System.Diagnostics.Trace.WriteLine(msg);
Console.WriteLine(msg);
foreach (var queue in accessTokenQueues)
{
msg = "---Payloads in a queue: " + queue.GetPayloadCount();
System.Diagnostics.Trace.WriteLine(msg);
Console.WriteLine(msg);
if (!queue.IsReleased)
{
queue.Release();
}
else
{
queue.Flush();
}
}
Thread.Sleep(TimeSpan.FromMilliseconds(250));
accessTokenQueues =
RollbarQueueController.Instance.GetQueues(RollbarUnitTestSettings.AccessToken);
}
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
int totalInitialQueues = RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken);
using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig))
{
Assert.AreEqual(totalInitialQueues + 1, RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken));
this.IncrementCount <CommunicationEventArgs>();
logger.Log(ErrorLevel.Error, "test message");
}
// an unused queue does not get removed immediately (but eventually) - so let's wait for it for a few processing cycles:
int currentQueuesCount =
RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken);
while (totalInitialQueues != currentQueuesCount)
{
string msg = "Current queues count: " + currentQueuesCount + " while initial count was: " + totalInitialQueues;
System.Diagnostics.Trace.WriteLine(msg);
Console.WriteLine(msg);
Thread.Sleep(TimeSpan.FromMilliseconds(250));
currentQueuesCount =
RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken);
}
// if everything is good, we should get here way before this test method times out:
Assert.AreEqual(totalInitialQueues, RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken));
}
public void ConvenienceMethodsUseAppropriateErrorLevels(ErrorLevel expectedLogLevel)
{
var awaitAsyncSend = new ManualResetEventSlim(false);
var acctualLogLevel = ErrorLevel.Info;
void Transform(Payload payload)
{
acctualLogLevel = payload.Data.Level.Value;
awaitAsyncSend.Set();
}
RollbarDestinationOptions destinationOptions =
new RollbarDestinationOptions(
RollbarUnitTestSettings.AccessToken,
RollbarUnitTestSettings.Environment
);
RollbarLoggerConfig loggerConfig = new RollbarLoggerConfig();
loggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
RollbarPayloadManipulationOptions payloadManipulationOptions = new RollbarPayloadManipulationOptions();
payloadManipulationOptions.Transform = Transform;
loggerConfig.RollbarPayloadManipulationOptions.Reconfigure(payloadManipulationOptions);
this.IncrementCount <CommunicationEventArgs>();
using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig))
{
try
{
//TODO: implement and add SynchronousPackage around the payload object!!!
var ex = new Exception();
switch (expectedLogLevel)
{
case ErrorLevel.Critical:
logger.Critical(ex);
break;
case ErrorLevel.Error:
logger.Error(ex);
break;
case ErrorLevel.Warning:
logger.Warning(ex);
break;
case ErrorLevel.Info:
logger.Info(ex);
break;
case ErrorLevel.Debug:
logger.Debug(ex);
break;
}
}
catch
{
Assert.Fail("should never reach here!");
}
}
awaitAsyncSend.Wait();
Assert.AreEqual(expectedLogLevel, acctualLogLevel);
}
public void TestRollbarConfigEqualityMethod()
{
RollbarDestinationOptions destinationOptions = new RollbarDestinationOptions("12345", "env1");
RollbarLoggerConfig rConfig = new RollbarLoggerConfig();
rConfig.RollbarDestinationOptions.Reconfigure(destinationOptions);
// test the same config instance references:
Assert.IsTrue(rConfig.Equals(rConfig), "Same instances are always equal.");
destinationOptions = new RollbarDestinationOptions("12345", "env1"); // same as rConfig...
RollbarLoggerConfig rConfigSimilar = new RollbarLoggerConfig();
rConfigSimilar.RollbarDestinationOptions.Reconfigure(destinationOptions);
destinationOptions = new RollbarDestinationOptions("12345", "env2");
RollbarLoggerConfig rConfigOneDiff = new RollbarLoggerConfig();
destinationOptions = new RollbarDestinationOptions("02345", "env1");
RollbarLoggerConfig rConfigAnotherDiff = new RollbarLoggerConfig();
destinationOptions = new RollbarDestinationOptions("02345", "env2");
RollbarLoggerConfig rConfigTwoDiffs = new RollbarLoggerConfig();
destinationOptions = new RollbarDestinationOptions("12345", null);
RollbarLoggerConfig rConfigOneNullifed = new RollbarLoggerConfig();
// test different config instances simple properties:
Assert.IsTrue(rConfig.Equals(rConfigSimilar), "Simple properties: Similar instances are always equal.");
Assert.IsFalse(rConfig.Equals(rConfigOneDiff), "Simple properties: One different property value makes unequal.");
Assert.IsFalse(rConfig.Equals(rConfigAnotherDiff), "Simple properties: Another different property value makes unequal.");
Assert.IsFalse(rConfig.Equals(rConfigTwoDiffs), "Simple properties: Multiple different property values make unequal.");
Assert.IsFalse(rConfig.Equals(rConfigOneNullifed), "Simple properties: Nullified property of one config instance makes unequal.");
// test structured/complex properties:
Person person = new Person()
{
UserName = "******", Email = "*****@*****.**",
};
Person personSimilar = new Person()
{
UserName = "******", Email = "*****@*****.**",
};
Person personOneDiff = new Person()
{
UserName = "******", Email = "*****@*****.**",
};
Person personOneNull = new Person()
{
UserName = "******", Email = null,
};
RollbarPayloadAdditionOptions additionOptions = new RollbarPayloadAdditionOptions();
additionOptions.Person = person;
rConfig.RollbarPayloadAdditionOptions.Reconfigure(additionOptions);
Assert.IsTrue(rConfig.Equals(rConfig), "Structured properties: Same instances are always equal.");
additionOptions.Person = person;
rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions);
Assert.IsTrue(rConfig.Equals(rConfigSimilar), "Structured properties: Similar #1 instances are always equal.");
additionOptions.Person = personSimilar;
rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions);
Assert.IsTrue(rConfig.Equals(rConfigSimilar), "Structured properties: Similar #2 instances are always equal.");
additionOptions.Person = personOneDiff;
rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions);
Assert.IsFalse(rConfig.Equals(rConfigSimilar), "Structured properties: One different property value makes unequal.");
additionOptions.Person = personOneNull;
rConfigSimilar.RollbarPayloadAdditionOptions.Reconfigure(additionOptions);
Assert.IsFalse(rConfig.Equals(rConfigSimilar), "Structured properties: Nullified property of one config instance makes unequal.");
}
