public void TestUsingUnreasonablyShortTimeout()
{
// [DO]: let's send a payload using unreasonably short PayloadPostTimeout
// [EXPECT]: even under all the good networking conditions sending a payload should not succeed
RollbarInfrastructureOptions infrastructureOptions =
new RollbarInfrastructureOptions();
infrastructureOptions.PayloadPostTimeout =
TimeSpan.FromMilliseconds(5); // short enough
RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions
.Reconfigure(infrastructureOptions);
using (var logger = (RollbarLogger)RollbarFactory.CreateNew(RollbarInfrastructure.Instance.Config.RollbarLoggerConfig))
{
RollbarUnitTestEnvironmentUtil.TraceCurrentRollbarInfrastructureConfig();
RollbarUnitTestEnvironmentUtil.Trace(logger.Config, "Logger_Config");
var client = new RollbarClient(logger);
var bundle = new PayloadBundle(logger, RollbarClientFixture.CrateTestPackage(), ErrorLevel.Info);
client.EnsureHttpContentToSend(bundle);
var response = client.PostAsJson(bundle);
RollbarUnitTestEnvironmentUtil.Trace(response, "Rollbar API HTTP response");
Assert.IsNull(response);
Assert.AreEqual(1, bundle.Exceptions.Count);
//Assert.AreEqual("While PostAsJson(PayloadBundle payloadBundle)...", bundle.Exceptions.First().Message);
//Assert.IsTrue(bundle.Exceptions.First().InnerException.Message.StartsWith("One or more errors occurred"));
//Assert.AreEqual("A task was canceled.", bundle.Exceptions.First().InnerException.InnerException.Message);
}
}
/// <summary>
/// Provides the disposable rollbar.
/// </summary>
/// <returns>IRollbar.</returns>
protected IRollbar ProvideDisposableRollbar()
{
IRollbar rollbar = RollbarFactory.CreateNew(isSingleton: false, rollbarConfig: this.ProvideLiveRollbarConfig());
this._disposableRollbarInstances.Add(rollbar);
return(rollbar);
}
public void ScopedInstanceTest()
{
// we need to make sure we are starting clean:
while (RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken) > 0)
{
Thread.Sleep(TimeSpan.FromMilliseconds(250));
}
RollbarConfig loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
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:
while (totalInitialQueues != RollbarQueueController.Instance.GetQueuesCount(RollbarUnitTestSettings.AccessToken))
{
Thread.Sleep(TimeSpan.FromMilliseconds(250));
}
// 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 ThrowsExceptionWhenConfiguredWithInvalidConfigInstance()
{
RollbarConfig invalidConfig = new RollbarConfig(string.Empty)
{
Person = new Person(),
};
var rollbar = RollbarFactory.CreateNew();
try
{
rollbar.Configure(invalidConfig);
}
catch (RollbarException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.ToString());
Assert.IsTrue(ex.Data.Count > 0, "Expected to contain failed validation rules!");
return;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.ToString());
Assert.Fail("Should never reach here due to exception above!");
}
Assert.Fail("Should never reach here due to exception above!");
}
public void LongReportIsAsync()
{
const int maxCallLengthInMillisec = 50;
TimeSpan payloadSubmissionDelay = TimeSpan.FromMilliseconds(3 * maxCallLengthInMillisec);
RollbarConfig loggerConfig =
new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
loggerConfig.Transform = delegate { Thread.Sleep(payloadSubmissionDelay); };
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 ExceptionWhileTransformingPayloadAsync()
{
this._transformException = false;
RollbarConfig loggerConfig =
new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
loggerConfig.Transform = delegate { throw new NullReferenceException(); };
IRollbar logger = RollbarFactory.CreateNew().Configure(loggerConfig);
logger.InternalEvent += Logger_InternalEvent;
try
{
logger.Log(ErrorLevel.Error, "test message");
}
catch
{
Assert.IsTrue(false);
}
this._signal.Wait();
Assert.IsTrue(this._transformException);
}
public void ReportFromCatch()
{
try
{
var a = 10;
var b = 0;
var c = a / b;
}
catch (System.Exception ex)
{
using (IRollbar logger = RollbarFactory.CreateNew().Configure(this._loggerConfig))
{
try
{
this.ExpectedCommunicationEventsTotal++;
//TODO: implement and add SynchronousPackage around the payload object!!!
logger.Error(new System.Exception("outer exception", ex));
}
catch
{
Assert.Fail();
}
}
}
}
public void AllowsProxySettingsReconfiguration()
{
using (IRollbar logger = RollbarFactory.CreateNew().Configure(this._loggerConfig))
{
Assert.AreNotSame(this._loggerConfig, logger.Config);
logger.Configure(this._loggerConfig);
Assert.AreNotSame(this._loggerConfig, logger.Config);
int errorCount = 0;
logger.AsBlockingLogger(TimeSpan.FromSeconds(3)).Info("test 1");
this.ExpectedCommunicationEventsTotal++;
Assert.AreEqual(0, errorCount);
RollbarConfig newConfig = new RollbarConfig("seed");
newConfig.Reconfigure(this._loggerConfig);
Assert.AreNotSame(this._loggerConfig, newConfig);
logger.Configure(newConfig);
logger.AsBlockingLogger(TimeSpan.FromSeconds(3)).Info("test 2");
this.ExpectedCommunicationEventsTotal++;
Assert.AreEqual(0, errorCount);
newConfig.ProxyAddress = "www.fakeproxy.com";
newConfig.ProxyUsername = "******";
newConfig.ProxyPassword = "******";
logger.Configure(newConfig);
Assert.IsFalse(string.IsNullOrEmpty(logger.Config.ProxyAddress));
Assert.IsFalse(string.IsNullOrEmpty(logger.Config.ProxyUsername));
Assert.IsFalse(string.IsNullOrEmpty(logger.Config.ProxyPassword));
try
{
// the fake proxy settings will cause a timeout exception here:
this.ExpectedCommunicationErrorsTotal++;
logger.AsBlockingLogger(TimeSpan.FromSeconds(3)).Info("test 3 with fake proxy");
}
catch
{
errorCount++;
}
Assert.AreEqual(1, errorCount);
newConfig.ProxyAddress = null;
newConfig.ProxyUsername = null;
newConfig.ProxyPassword = null;
logger.Configure(newConfig);
Assert.IsTrue(string.IsNullOrEmpty(logger.Config.ProxyAddress));
Assert.IsTrue(string.IsNullOrEmpty(logger.Config.ProxyUsername));
Assert.IsTrue(string.IsNullOrEmpty(logger.Config.ProxyPassword));
try
{
// the fake proxy settings are gone, so, next call is expected to succeed:
this.ExpectedCommunicationEventsTotal++;
logger.AsBlockingLogger(TimeSpan.FromSeconds(15)).Info("test 4");
}
catch
{
errorCount++;
}
Assert.AreEqual(1, errorCount);
}
}
public void ExceptionWhileTransformingPayloadAsync()
{
this._transformException = false;
RollbarConfig loggerConfig =
new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
loggerConfig.Transform = delegate { throw new NullReferenceException(); };
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!");
}
this._signal.Wait();
logger.InternalEvent -= Logger_InternalEvent;
Assert.IsTrue(this._transformException);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PlugInCoreBase"/> class.
/// </summary>
/// <param name="rollbarConfig">The rollbar configuration.</param>
/// <param name="rollbarBlockingTimeout">The rollbar blocking timeout.</param>
protected PlugInCoreBase(
IRollbarInfrastructureConfig?rollbarConfig,
TimeSpan?rollbarBlockingTimeout
)
{
if (rollbarConfig == null)
{
var configLoader = new RollbarConfigurationLoader();
rollbarConfig = configLoader.LoadRollbarConfig();
}
if (rollbarConfig == null)
{
throw new RollbarException(InternalRollbarError.ConfigurationError, $"{this.GetType().FullName}: Failed to load Rollbar configuration!");
}
// first, initialize the infrastructure:
if (!RollbarInfrastructure.Instance.IsInitialized)
{
RollbarInfrastructure.Instance.Init(rollbarConfig);
}
// create proper IRollbar instance:
this.rollbar = RollbarFactory.CreateNew(rollbarConfig.RollbarLoggerConfig);
// create proper RollbarLogger instance:
if (rollbarBlockingTimeout.HasValue)
{
this.rollbarLogger = this.rollbar.AsBlockingLogger(rollbarBlockingTimeout.Value);
}
else
{
this.rollbarLogger = this.rollbar.Logger;
}
}
public void MultithreadedStressTest_BlockingLogs()
{
RollbarLoggerFixture.stressLogsCount = 0;
RollbarConfig loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
ReportingQueueDepth = 200,
};
this.IncrementCount <CommunicationEventArgs>(loggerConfig.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 MultithreadedStressTest()
{
RollbarLoggerFixture.stressLogsCount = 0;
//ConnectivityMonitor.Instance.Disable();
RollbarConfig loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
ReportingQueueDepth = 200,
//ProxyAddress = "proxy",
};
this.IncrementCount <CommunicationEventArgs>(loggerConfig.ReportingQueueDepth);
List <IRollbar> rollbars =
new List <IRollbar>(MultithreadedStressTestParams.TotalThreads);
for (int i = 0; i < MultithreadedStressTestParams.TotalThreads; i++)
{
var rollbar = RollbarFactory.CreateNew().Configure(loggerConfig);
rollbars.Add(rollbar);
}
PerformTheMultithreadedStressTest(rollbars.ToArray());
rollbars.ForEach(r => {
r.Dispose();
});
}
public void MultithreadedStressTest()
{
RollbarLoggerFixture.stressLogsCount = 0;
RollbarConfig loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
ReportingQueueDepth = 200,
};
List <IRollbar> rollbars =
new List <IRollbar>(MultithreadedStressTestParams.TotalThreads);
for (int i = 0; i < MultithreadedStressTestParams.TotalThreads; i++)
{
var rollbar = RollbarFactory.CreateNew().Configure(loggerConfig);
rollbar.InternalEvent += RollbarStress_InternalEvent;
rollbars.Add(rollbar);
}
PerformTheMultithreadedStressTest(rollbars.ToArray());
rollbars.ForEach(r => {
r.InternalEvent -= RollbarStress_InternalEvent;
r.Dispose();
});
}
public void TestUsingLongEnoughTimeout()
{
// [DO]: let's send a payload using reasonably long PayloadPostTimeout
// [EXPECT]: even under all the good networking conditions sending a payload should succeed
RollbarInfrastructureOptions infrastructureOptions =
new RollbarInfrastructureOptions();
infrastructureOptions.PayloadPostTimeout =
TimeSpan.FromMilliseconds(2000); // long enough
RollbarInfrastructure.Instance.Config.RollbarInfrastructureOptions
.Reconfigure(infrastructureOptions);
using (var logger = (RollbarLogger)RollbarFactory.CreateNew(RollbarInfrastructure.Instance.Config.RollbarLoggerConfig))
{
RollbarUnitTestEnvironmentUtil.TraceCurrentRollbarInfrastructureConfig();
RollbarUnitTestEnvironmentUtil.Trace(logger.Config, "Logger_Config");
var client = new RollbarClient(logger);
var bundle = new PayloadBundle(logger, RollbarClientFixture.CrateTestPackage(), ErrorLevel.Info);
client.EnsureHttpContentToSend(bundle);
var response = client.PostAsJson(bundle);
RollbarUnitTestEnvironmentUtil.Trace(response, "Rollbar API HTTP response");
Assert.IsNotNull(response, "let's send a payload using reasonably long PayloadPostTimeout");
Assert.AreEqual(0, response.Error);
Assert.AreEqual(0, bundle.Exceptions.Count);
}
}
public void ImplementsIDisposable()
{
using (IRollbar logger = RollbarFactory.CreateNew().Configure(this._loggerConfig))
{
IDisposable disposable = logger as IDisposable;
Assert.IsNotNull(disposable);
}
}
/// <summary>
/// Prevents a default instance of the <see cref="RollbarLogger" /> class from being created.
/// </summary>
private RollbarLogger()
{
this._name = string.Empty;
this._rollbarOptions = new RollbarOptions();
this._rollbar = RollbarFactory.CreateNew(null);
}
public void SetupFixture()
{
RollbarUnitTestEnvironmentUtil.SetupLiveTestRollbarInfrastructure();
RollbarQueueController.Instance.FlushQueues();
//RollbarQueueController.Instance.InternalEvent += Instance_InternalEvent;
_logger = RollbarFactory.CreateNew().Configure(RollbarInfrastructure.Instance.Config.RollbarLoggerConfig);
}
private static IRollbar ProvideRollbar()
{
IRollbarConfig loggerConfig = ProvideRollbarConfig();
// Let's give things change to stabilize:
//Thread.Sleep(TimeSpan.FromSeconds(2));
return(RollbarFactory.CreateNew().Configure(loggerConfig));
}
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 void ConvenienceMethodsUseAppropriateErrorLevels(ErrorLevel expectedLogLevel)
{
var awaitAsyncSend = new ManualResetEventSlim(false);
var acctualLogLevel = ErrorLevel.Info;
void Transform(Payload payload)
{
acctualLogLevel = payload.Data.Level.Value;
awaitAsyncSend.Set();
}
var loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
Transform = Transform,
};
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 QueueRegisteration()
{
RollbarConfig loggerConfig1 =
new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
RollbarConfig loggerConfig2 =
new RollbarConfig(RollbarUnitTestSettings.AccessToken.Replace('0', '1'))
{
Environment = RollbarUnitTestSettings.Environment,
};
Assert.AreNotEqual(loggerConfig1.AccessToken, loggerConfig2.AccessToken);
int initialCount = RollbarQueueController.Instance.GetQueuesCount();
int initialCount1 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken);
int initialCount2 = RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken);
Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
using (var logger1 = RollbarFactory.CreateNew().Configure(loggerConfig1))
{
Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
using (var logger2 = RollbarFactory.CreateNew().Configure(loggerConfig1))
{
Assert.AreEqual(initialCount + 2, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 2, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
using (var logger3 = RollbarFactory.CreateNew().Configure(loggerConfig2))
{
Assert.AreEqual(initialCount + 3, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 2, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
}
Assert.AreEqual(initialCount + 2, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 2, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
}
Assert.AreEqual(initialCount + 1, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 1, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
}
Assert.AreEqual(initialCount + 0, RollbarQueueController.Instance.GetQueuesCount());
Assert.AreEqual(initialCount1 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig1.AccessToken));
Assert.AreEqual(initialCount2 + 0, RollbarQueueController.Instance.GetQueuesCount(loggerConfig2.AccessToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="RollbarLogger" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="rollbarConfig">The rollbar configuration.</param>
/// <param name="rollbarOptions">The options.</param>
public RollbarLogger(string name
, IRollbarConfig rollbarConfig
, RollbarOptions rollbarOptions = default
)
{
this._name = name;
this._rollbarOptions = rollbarOptions ?? new RollbarOptions();
this._rollbar = RollbarFactory.CreateNew(rollbarConfig);
}
public void ProducesValidInstances()
{
var rollbar1 = RollbarFactory.CreateNew();
Assert.IsNotNull(rollbar1);
var rollbarLogger = rollbar1 as RollbarLogger;
Assert.IsNotNull(rollbarLogger);
Assert.IsFalse(rollbarLogger.IsSingleton);
}
public void ConvenienceMethodsUsesAppropriateErrorLevels(ErrorLevel expectedLogLevel)
{
var awaitAsyncSend = new ManualResetEventSlim(false);
var acctualLogLevel = ErrorLevel.Info;
void Transform(Payload payload)
{
acctualLogLevel = payload.Data.Level.Value;
awaitAsyncSend.Set();
}
var loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
Transform = Transform,
};
using (var logger = RollbarFactory.CreateNew().Configure(loggerConfig))
{
try
{
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.IsTrue(false);
}
}
awaitAsyncSend.Wait();
Assert.AreEqual(expectedLogLevel, acctualLogLevel);
}
public void ProducesValidInstances()
{
var rollbar1 = RollbarFactory.CreateNew();
Assert.IsNotNull(rollbar1);
Assert.AreNotSame(rollbar1, RollbarLocator.RollbarInstance);
var rollbarLogger = rollbar1 as RollbarLogger;
Assert.IsNotNull(rollbarLogger);
rollbar1.Dispose();
}
/// <summary>
/// Initializes a new instance of the <see cref="RollbarLogger" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="rollbarConfig">The rollbar configuration.</param>
/// <param name="rollbarOptions">The options.</param>
/// <param name="httpContextAccessor">The HTTP context accessor.</param>
public RollbarLogger(string name
, IRollbarConfig rollbarConfig
, RollbarOptions rollbarOptions
, IHttpContextAccessor httpContextAccessor
)
{
this._name = name;
this._rollbarOptions = rollbarOptions;
this._httpContextAccessor = httpContextAccessor;
this._rollbar = RollbarFactory.CreateNew(false).Configure(rollbarConfig);
}
public void ProducesUniqueInstances()
{
var rollbar1 = RollbarFactory.CreateNew();
Assert.IsNotNull(rollbar1);
var rollbar2 = RollbarFactory.CreateNew();
Assert.IsNotNull(rollbar2);
Assert.AreNotSame(rollbar2, rollbar1);
}
public void SetupFixture()
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
RollbarConfig loggerConfig =
new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
_logger = RollbarFactory.CreateNew().Configure(loggerConfig);
}
public void ConvenienceMethodsUsesAppropriateErrorLevels(ErrorLevel expectedLogLevel)
{
var acctualLogLevel = ErrorLevel.Info;
void Transform(Payload payload)
{
acctualLogLevel = payload.Data.Level.Value;
}
var loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
Transform = Transform,
};
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.IsTrue(false);
}
}
Assert.AreEqual(expectedLogLevel, acctualLogLevel);
}
public void ScopedInstanceTest()
{
// we need to make sure we are starting clean:
RollbarQueueController.Instance.FlushQueues();
var accessTokenQueues =
RollbarQueueController.Instance.GetQueues(RollbarUnitTestSettings.AccessToken);
while (accessTokenQueues.Count() > 0)
{
string msg = "Initial queues count: " + accessTokenQueues.Count();
System.Diagnostics.Trace.WriteLine(msg);
Console.WriteLine(msg);
foreach (var queue in accessTokenQueues)
{
queue.Release();
}
Thread.Sleep(TimeSpan.FromMilliseconds(250));
accessTokenQueues =
RollbarQueueController.Instance.GetQueues(RollbarUnitTestSettings.AccessToken);
}
RollbarConfig loggerConfig = new RollbarConfig(RollbarUnitTestSettings.AccessToken)
{
Environment = RollbarUnitTestSettings.Environment,
};
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));
}