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)); }