/// <summary> /// Creates the proper. /// </summary> /// <param name="rollbarConfig">The rollbar configuration.</param> /// <param name="rollbarBlockingLoggingTimeout">The rollbar blocking logging timeout.</param> public static ILogger CreateProper( IRollbarConfig rollbarConfig, TimeSpan?rollbarBlockingLoggingTimeout ) { IRollbar rollbar = RollbarFactory.CreateNew().Configure(rollbarConfig); if (rollbarBlockingLoggingTimeout.HasValue) { return(rollbar.AsBlockingLogger(rollbarBlockingLoggingTimeout.Value)); } else { return(rollbar.Logger); } }
/// <summary> /// Creates the proper. /// </summary> /// <param name="config">The configuration.</param> /// <param name="blockingLoggingTimeout">The blocking logging timeout.</param> /// <returns>ILogger.</returns> public static ILogger CreateProper( IRollbarLoggerConfig?config = null, TimeSpan?blockingLoggingTimeout = null ) { IRollbar rollbar = RollbarFactory.CreateNew(config); if (blockingLoggingTimeout.HasValue) { return(rollbar.AsBlockingLogger(blockingLoggingTimeout.Value)); } else { return(rollbar.Logger); } }
/// <summary> /// Creates the proper. /// </summary> /// <param name="rollbarConfig">The rollbar configuration.</param> /// <param name="rollbarBlockingLoggingTimeout">The rollbar blocking logging timeout.</param> /// <param name="rollbarAsyncLogger">The rollbar asynchronous logger.</param> /// <param name="rollbarLogger">The rollbar logger.</param> public static void CreateProper( IRollbarConfig rollbarConfig, TimeSpan?rollbarBlockingLoggingTimeout, out IAsyncLogger rollbarAsyncLogger, out ILogger rollbarLogger ) { IRollbar rollbar = RollbarFactory.CreateNew().Configure(rollbarConfig); if (rollbarBlockingLoggingTimeout.HasValue) { rollbarLogger = rollbar.AsBlockingLogger(rollbarBlockingLoggingTimeout.Value); rollbarAsyncLogger = null; } else { rollbarLogger = null; rollbarAsyncLogger = rollbar; } }
/// <summary> /// Enqueues the data. /// </summary> /// <param name="dataObject">The data object.</param> /// <param name="level">The level.</param> /// <param name="custom">The custom.</param> /// <param name="timeout">The timeout.</param> /// <param name="signal">The signal.</param> /// <returns>PayloadBundle.</returns> internal PayloadBundle EnqueueData( object dataObject, ErrorLevel level, IDictionary <string, object> custom, TimeSpan?timeout = null, SemaphoreSlim signal = null ) { // here is the last chance to decide if we need to actually send this payload // based on the current config settings and rate-limit conditions: if (string.IsNullOrWhiteSpace(this._config.AccessToken) || this._config.Enabled == false || (this._config.LogLevel.HasValue && level < this._config.LogLevel.Value) || ((this._payloadQueue.AccessTokenQueuesMetadata != null) && this._payloadQueue.AccessTokenQueuesMetadata.IsTransmissionSuspended) ) { // nice shortcut: return(null); } if (this._config.RethrowExceptionsAfterReporting) { System.Exception exception = dataObject as System.Exception; if (exception == null) { if (dataObject is Data data && data.Body != null) { exception = data.Body.OriginalException; } } if (exception != null) { try { // Here we need to create another logger instance with similar config but configured not to re-throw. // This would prevent infinite recursive calls (in case if we used this instance or any re-throwing instance). // Because we will be re-throwing the exception after reporting, let's report it fully-synchronously. // This logic is on a heavy side. But, fortunately, RethrowExceptionsAfterReporting is intended to be // a development time option: var config = new RollbarConfig(); config.Reconfigure(this._config); config.RethrowExceptionsAfterReporting = false; using (var rollbar = RollbarFactory.CreateNew(config)) { rollbar.AsBlockingLogger(TimeSpan.FromSeconds(1)).Log(level, dataObject, custom); } } catch { // In case there was a TimeoutException (or any un-expected exception), // there is nothing we can do here. // We tried our best... } finally { if (exception is AggregateException aggregateException) { exception = aggregateException.Flatten(); ExceptionDispatchInfo.Capture( exception.InnerException).Throw(); } else { ExceptionDispatchInfo.Capture(exception).Throw(); } } return(null); } } PayloadBundle payloadBundle = null; try { payloadBundle = CreatePayloadBundle(dataObject, level, custom, timeout, signal); } catch (System.Exception exception) { RollbarErrorUtility.Report( this, dataObject, InternalRollbarError.BundlingError, null, exception, payloadBundle ); return(null); } try { this._payloadQueue.Enqueue(payloadBundle); } catch (System.Exception exception) { RollbarErrorUtility.Report( this, dataObject, InternalRollbarError.EnqueuingError, null, exception, payloadBundle ); } return(payloadBundle); }
/// <summary> /// Creates the new instance of IRollbar. /// </summary> /// <param name="rollbarConfig">The rollbar configuration.</param> /// <returns></returns> public static IRollbar CreateNew(IRollbarConfig rollbarConfig) { return(RollbarFactory.CreateNew(false, rollbarConfig)); }
/// <summary> /// Creates the new instance of IRollbar. /// </summary> /// <returns></returns> public static IRollbar CreateNew() { return(RollbarFactory.CreateNew(null)); }
/// <summary> /// Enqueues the data. /// </summary> /// <param name="dataObject">The data object.</param> /// <param name="level">The level.</param> /// <param name="custom">The custom.</param> /// <param name="timeout">The timeout.</param> /// <param name="signal">The signal.</param> /// <returns>PayloadBundle.</returns> internal PayloadBundle?EnqueueData( object dataObject, ErrorLevel level, IDictionary <string, object?>?custom, TimeSpan?timeout = null, SemaphoreSlim?signal = null ) { // here is the last chance to decide if we need to actually send this payload // based on the current config settings and rate-limit conditions: if (string.IsNullOrWhiteSpace(this._config.RollbarDestinationOptions.AccessToken) || !this._config.RollbarDeveloperOptions.Enabled || (level < this._config.RollbarDeveloperOptions.LogLevel) ) { // nice shortcut: return(null); } if (this._config.RollbarDeveloperOptions.RethrowExceptionsAfterReporting) { System.Exception?exception = dataObject as System.Exception; if (exception == null && dataObject is Data data && data.Body != null ) { exception = data.Body.OriginalException; } if (exception != null) { try { // Here we need to create another logger instance with similar config but configured not to re-throw. // This would prevent infinite recursive calls (in case if we used this instance or any re-throwing instance). // Because we will be re-throwing the exception after reporting, let's report it fully-synchronously. // This logic is on a heavy side. But, fortunately, RethrowExceptionsAfterReporting is intended to be // a development time option: var config = new RollbarLoggerConfig(); config.Reconfigure(this._config); config.RollbarDeveloperOptions.RethrowExceptionsAfterReporting = false; using var rollbar = RollbarFactory.CreateNew(config); rollbar.AsBlockingLogger(TimeSpan.FromSeconds(1)).Log(level, dataObject, custom); } #pragma warning disable CA1031 // Do not catch general exception types catch { // In case there was a TimeoutException (or any un-expected exception), // there is nothing we can do here. // We tried our best... } #pragma warning restore CA1031 // Do not catch general exception types finally { if (exception is AggregateException aggregateException) { exception = aggregateException.Flatten(); } ExceptionDispatchInfo.Capture(exception).Throw(); } return(null); } } PayloadBundle?payloadBundle = null; try { payloadBundle = CreatePayloadBundle(dataObject, level, custom, timeout, signal); } #pragma warning disable CA1031 // Do not catch general exception types catch (System.Exception exception) { RollbarErrorUtility.Report( this, dataObject, InternalRollbarError.BundlingError, null, exception, payloadBundle ); return(null); } #pragma warning restore CA1031 // Do not catch general exception types try { _ = this._rollbarClient.PostAsJsonAsync(payloadBundle); } #pragma warning disable CA1031 // Do not catch general exception types catch (System.Exception exception) { RollbarErrorUtility.Report( this, dataObject, InternalRollbarError.EnqueuingError, null, exception, payloadBundle ); } #pragma warning restore CA1031 // Do not catch general exception types return(payloadBundle); }
/// <summary> /// Creates the new instance of IRollbar. /// </summary> /// <returns></returns> public static IRollbar CreateNew() { return(RollbarFactory.CreateNew(false)); }