static void Main(string[] args) { // Define RollbarInfrastructureConfig: RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); // Add RollbarSink to the Serilog Logger using pre-configured RollbarConfig: Serilog.Core.Logger log = new LoggerConfiguration() .MinimumLevel.Information() .WriteTo.Console() .WriteTo.RollbarSink(rollbarInfrastructureConfig, TimeSpan.FromSeconds(3)) .CreateLogger(); var position = new { Latitude = 25, Longitude = 134 }; var elapsedMs = 34; // an informational trace via Serilog: log.Information("Processed {@Position} in {Elapsed:000} ms.", position, elapsedMs); // let's simulate some exception logging via Serilog: try { throw new ApplicationException("Oy vey via Serilog!"); } catch (Exception ex) { log.Error(ex, "What happened?"); } }
public static void ConfigureRollbar() { RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); dataSecurityOptions.ScrubFields = new string[] { "access_token", // normally, you do not want scrub this specific field (it is operationally critical), but it just proves safety net built into the notifier... "username", }; rollbarInfrastructureConfig.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); RollbarPayloadAdditionOptions payloadAdditionOptions = new RollbarPayloadAdditionOptions(); payloadAdditionOptions.Person = new Person("007") { Email = "*****@*****.**", UserName = "******" }; rollbarInfrastructureConfig.RollbarLoggerConfig.RollbarPayloadAdditionOptions.Reconfigure(payloadAdditionOptions); RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); // optionally, if you would like to monitor this Rollbar instance's internal events within your application: RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; }
private static void LoadDataSecurityOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection) { RollbarDataSecurityOptions dataSecurityOptions = new(); if (rollbarConfigSection.ScrubFields != null && rollbarConfigSection.ScrubFields.Length > 0) { dataSecurityOptions.ScrubFields = string.IsNullOrEmpty(rollbarConfigSection.ScrubFields) ? Array.Empty <string>() : rollbarConfigSection.ScrubFields.Split(listValueSplitters, StringSplitOptions.RemoveEmptyEntries); } if (rollbarConfigSection.ScrubSafelistFields != null && rollbarConfigSection.ScrubSafelistFields.Length > 0) { dataSecurityOptions.ScrubSafelistFields = string.IsNullOrEmpty(rollbarConfigSection.ScrubSafelistFields) ? Array.Empty <string>() : rollbarConfigSection.ScrubSafelistFields.Split(listValueSplitters, StringSplitOptions.RemoveEmptyEntries); } if (rollbarConfigSection.PersonDataCollectionPolicies.HasValue) { dataSecurityOptions.PersonDataCollectionPolicies = rollbarConfigSection.PersonDataCollectionPolicies.Value; } if (rollbarConfigSection.IpAddressCollectionPolicy.HasValue) { dataSecurityOptions.IpAddressCollectionPolicy = rollbarConfigSection.IpAddressCollectionPolicy.Value; } config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); }
/// <summary> /// Configures the Rollbar singleton-like notifier. /// </summary> private void ConfigureRollbarInfrastructure() { RollbarInfrastructureConfig config = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); config.RollbarLoggerConfig.RollbarDeveloperOptions.LogLevel = ErrorLevel.Debug; //RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); //dataSecurityOptions.ScrubFields = new string[] //{ // "url", // "method", //}; //config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); var telemetryOptions = new RollbarTelemetryOptions(true, 20) { TelemetryAutoCollectionTypes = TelemetryType.Log | TelemetryType.Error | TelemetryType.Network }; config.RollbarTelemetryOptions.Reconfigure(telemetryOptions); RollbarInfrastructure.Instance.Init(config); RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; var telemetryBody = new LogTelemetry("Rollbar infrastructure initialized!"); RollbarInfrastructure.Instance.TelemetryCollector.Capture(new Telemetry(TelemetrySource.Server, TelemetryLevel.Info, telemetryBody)); RollbarLocator.RollbarInstance.Info("Rollbar is ready to roll!"); }
/// <summary> /// Configures the Rollbar infrastructure. /// </summary> private static void ConfigureRollbarInfrastructure() { // minimally required Rollbar configuration: RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); // optionally, add data scrubbing options: RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); dataSecurityOptions.ScrubFields = new string[] { "access_token", // normally, you do not want scrub this specific field (it is operationally critical), but it just proves safety net built into the notifier... "username", }; rollbarInfrastructureConfig.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); // initialize Rollbar infrastructure: RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); // optionally, if you would like to monitor all Rollbar instances' internal events within your application: RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; // optionally, if you would like to monitor this Rollbar instance's internal events within your application: RollbarLocator.RollbarInstance.InternalEvent += OnRollbarInternalEvent; // basic test: RollbarLocator.RollbarInstance.Info($"{typeof(MvcApplication).Namespace}: Rollbar is up and running!"); }
/// <summary> /// Configures Rollbar-specific services. /// </summary> /// <param name="services">The service collection.</param> /// <param name="rollbarLogLevel">The LogLevel starting from which to log with Rollbar.</param> /// <param name="rollbarInfrastructureConfig">The valid Rollbar Infrastructure Configuration.</param> /// <param name="rollbarInternalEventHandler">Optional Rollbar Internal Event Handler.</param> /// <returns>N/A</returns> public static void ConfigureServices( IServiceCollection services, LogLevel rollbarLogLevel, RollbarInfrastructureConfig rollbarInfrastructureConfig, EventHandler <RollbarEventArgs>?rollbarInternalEventHandler = null ) { if (!services.Any(s => s.ServiceType == typeof(IHttpContextAccessor))) { services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); } RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); if (rollbarInternalEventHandler != null && RollbarInfrastructure.Instance.QueueController != null ) { RollbarInfrastructure.Instance.QueueController.InternalEvent += rollbarInternalEventHandler; } services.AddRollbarLogger(loggerOptions => { loggerOptions.Filter = (loggerName, logLevel) => logLevel >= rollbarLogLevel; }); }
static PayloadQueueFixture() { infrastructureConfig = new RollbarInfrastructureConfig(RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment); if (!RollbarInfrastructure.Instance.IsInitialized) { RollbarInfrastructure.Instance.Init(infrastructureConfig); } }
/// <summary> /// Loads the application settings. /// </summary> /// <param name="config">The configuration.</param> /// <param name="appSettings">The application settings.</param> /// <returns>false when the configuration was not found, otherwise true.</returns> public static bool LoadAppSettings(RollbarInfrastructureConfig config, IConfiguration appSettings) { Assumption.AssertNotNull(config, nameof(config)); const string rollbarAppConfigSectionName = "Rollbar"; return(AppSettingsUtility.LoadAppSettings(config, rollbarAppConfigSectionName, appSettings)); }
private static void LoadTelemetryOptions(RollbarInfrastructureConfig config) { RollbarTelemetryOptions telemetryOptions = new(); if (AppConfigUtility.LoadAppSettings(telemetryOptions)) { config.RollbarTelemetryOptions.Reconfigure(telemetryOptions); } }
/// <summary> /// Configures the Rollbar singleton-like notifier. /// </summary> private static void ConfigureRollbarSingleton() { // minimally required Rollbar configuration: RollbarInfrastructureConfig config = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); // optional: RollbarOfflineStoreOptions offlineStoreOptions = new RollbarOfflineStoreOptions(); offlineStoreOptions.EnableLocalPayloadStore = true; config.RollbarOfflineStoreOptions.Reconfigure(offlineStoreOptions); // optional: RollbarTelemetryOptions telemetryOptions = new RollbarTelemetryOptions(true, 3); config.RollbarTelemetryOptions.Reconfigure(telemetryOptions); // optional: //HttpProxyOptions proxyOptions = new HttpProxyOptions("http://something.com"); //config.RollbarLoggerConfig.HttpProxyOptions.Reconfigure(proxyOptions); // optional: RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); dataSecurityOptions.ScrubFields = new string[] { "access_token", // normally, you do not want scrub this specific field (it is operationally critical), but it just proves safety net built into the notifier... "username", "criticalObj[Sample.NetCore.ConsoleApp.Program+InstanceType]._baseNullField", "data.custom.criticalObj[Sample.NetCore.ConsoleApp.Program+InstanceType].<TypeName>k__BackingField", }; config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); // optional: RollbarPayloadAdditionOptions payloadAdditionOptions = new RollbarPayloadAdditionOptions(); payloadAdditionOptions.Person = new Person() { Id = "007", Email = "*****@*****.**", UserName = "******", }; config.RollbarLoggerConfig.RollbarPayloadAdditionOptions.Reconfigure(payloadAdditionOptions); // initialize the Rollbar Infrastructure: RollbarInfrastructure.Instance.Init(config); // optional step if you would like to monitor all Rollbar instances' internal events within your application: RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; // optional step if you would like to monitor this Rollbar instance's internal events within your application: //RollbarLocator.RollbarInstance.InternalEvent += OnRollbarInternalEvent; }
/// <summary> /// Loads the rollbar configuration. /// </summary> /// <returns>IRollbarConfig or null if no configuration store was found.</returns> public IRollbarInfrastructureConfig?LoadRollbarConfig() { RollbarInfrastructureConfig config = new RollbarInfrastructureConfig("seedToken"); if (this.Load(config)) { return(config); } return(null); }
static void Main(string[] args) { RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig(); AppSettingsUtility.LoadAppSettings(rollbarInfrastructureConfig); RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); RollbarLocator.RollbarInstance.AsBlockingLogger(TimeSpan.FromSeconds(3)) .Info($"{typeof(Program).Namespace} sample: Rollbar Notifier is alive based on appsetting.json!"); }
public void SetupFixture() { RollbarInfrastructureConfig infrastructureConfig = new RollbarInfrastructureConfig(RollbarUnitTestSettings.AccessToken, RollbarUnitTestSettings.Environment); RollbarInfrastructure.Instance.Init(infrastructureConfig); this._rollbarCommEvents.Clear(); this._rollbarCommErrorEvents.Clear(); RollbarQueueController.Instance.FlushQueues(); RollbarQueueController.Instance.InternalEvent += Instance_InternalEvent; }
/// <summary> /// Configures the Rollbar singleton-like notifier. /// </summary> private void ConfigureRollbar() { RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); // optionally, if you would like to monitor Rollbar internal events within your application: RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; }
/// <summary> /// Loads the application settings. /// </summary> /// <param name="config">The configuration.</param> /// <param name="appSettingsFolderPath">The application settings folder path.</param> /// <param name="appSettingsFileName">Name of the application settings file.</param> /// <returns>false when the configuration was not found, otherwise true.</returns> public static bool LoadAppSettings(RollbarInfrastructureConfig config, string appSettingsFolderPath, string appSettingsFileName) { Assumption.AssertNotNull(config, nameof(config)); IConfiguration?appSettingsConfig = AppSettingsUtility.LoadAppSettings(appSettingsFolderPath, appSettingsFileName); if (appSettingsConfig == null) { return(false); } AppSettingsUtility.LoadAppSettings(config, appSettingsConfig); return(true); }
public void TestBasics() { var config = new RollbarInfrastructureConfig(); Console.WriteLine(config.TraceAsString()); var results = config.Validate(); Assert.AreEqual(1, results.Count, "One Validation Rule failed!"); Console.WriteLine("Validation Results:"); foreach (var result in results) { Console.WriteLine($" {result}"); } Console.WriteLine(); }
/// <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)); }
private static void LoadDestinationOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection) { if (!string.IsNullOrWhiteSpace(rollbarConfigSection.AccessToken)) { RollbarDestinationOptions destinationOptions = new(rollbarConfigSection.AccessToken); if (!string.IsNullOrWhiteSpace(rollbarConfigSection.Environment)) { destinationOptions.Environment = rollbarConfigSection.Environment; } if (!string.IsNullOrWhiteSpace(rollbarConfigSection.EndPoint)) { destinationOptions.EndPoint = rollbarConfigSection.EndPoint; } config.RollbarLoggerConfig.RollbarDestinationOptions.Reconfigure(destinationOptions); } }
/// <summary> /// Configures the Rollbar singleton-like notifier. /// </summary> private void ConfigureRollbarSingleton() { RollbarInfrastructureConfig config = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); config.RollbarLoggerConfig.RollbarDeveloperOptions.LogLevel = ErrorLevel.Debug; //RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); //dataSecurityOptions.ScrubFields = new string[] //{ // "url", // "method", //}; //config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); RollbarInfrastructure.Instance.Init(config); RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; }
private static void LoadHttpProxyOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection) { if (!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyAddress)) { HttpProxyOptions httpProxyOptions = new(rollbarConfigSection.ProxyAddress); if (!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyUsername)) { httpProxyOptions.ProxyUsername = rollbarConfigSection.ProxyUsername; } if (!string.IsNullOrWhiteSpace(rollbarConfigSection.ProxyPassword)) { httpProxyOptions.ProxyPassword = rollbarConfigSection.ProxyPassword; } config.RollbarLoggerConfig.HttpProxyOptions.Reconfigure(httpProxyOptions); } }
/// <summary> /// Configures the Rollbar. /// </summary> private void ConfigureRollbar(IServiceCollection services) { RollbarInfrastructureConfig config = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); config.RollbarLoggerConfig.RollbarDeveloperOptions.LogLevel = ErrorLevel.Debug; config.RollbarInfrastructureOptions.MaxItems = 500; //RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); //dataSecurityOptions.ScrubFields = new string[] //{ // "url", // "method", //}; //config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); RollbarMiddleware.ConfigureServices(services, LogLevel.Information, config, OnRollbarInternalEvent); }
// STEP.2 - Setup Rollbar Infrastructure: private void ConfigureRollbarInfrastructure() { RollbarInfrastructureConfig config = new RollbarInfrastructureConfig( RollbarSamplesSettings.AccessToken, RollbarSamplesSettings.Environment ); RollbarDataSecurityOptions dataSecurityOptions = new RollbarDataSecurityOptions(); dataSecurityOptions.ScrubFields = new string[] { "url", "method", }; config.RollbarLoggerConfig.RollbarDataSecurityOptions.Reconfigure(dataSecurityOptions); RollbarInfrastructure.Instance.Init(config); // Optionally: RollbarInfrastructure.Instance.QueueController.InternalEvent += OnRollbarInternalEvent; }
static void Main(string[] args) { const string rollbarAccessToken = RollbarSamplesSettings.AccessToken; const string rollbarEnvironment = RollbarSamplesSettings.Environment; var config = new RollbarInfrastructureConfig(rollbarAccessToken, rollbarEnvironment); // minimally required Rollbar configuration RollbarInfrastructure.Instance.Init(config); Console.WriteLine("Hello World!"); RollbarLocator.RollbarInstance.AsBlockingLogger(TimeSpan.FromSeconds(5)) .Info("Sample.RollbarWithinStronglyNamedAssembly sample: Basic info log example.") .Debug("Sample.RollbarWithinStronglyNamedAssembly sample: First debug log.") .Error(new NullReferenceException("Sample.RollbarWithinStronglyNamedAssembly sample: null reference exception.")) .Error(new Exception("Sample.RollbarWithinStronglyNamedAssembly sample: trying out the TraceChain", new NullReferenceException())) ; Console.WriteLine("Hello Rollbar!"); }
private static void LoadOfflinePayloadStoreOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection) { RollbarOfflineStoreOptions offlineStoreOptions = new(); if (rollbarConfigSection.EnableLocalPayloadStore.HasValue) { offlineStoreOptions.EnableLocalPayloadStore = rollbarConfigSection.EnableLocalPayloadStore.Value; } if (!string.IsNullOrWhiteSpace(rollbarConfigSection.LocalPayloadStoreFileName)) { offlineStoreOptions.LocalPayloadStoreFileName = rollbarConfigSection.LocalPayloadStoreFileName; } if (!string.IsNullOrWhiteSpace(rollbarConfigSection.LocalPayloadStoreLocationPath)) { offlineStoreOptions.LocalPayloadStoreLocationPath = rollbarConfigSection.LocalPayloadStoreLocationPath; } config.RollbarOfflineStoreOptions.Reconfigure(offlineStoreOptions); }
public static RollbarInfrastructureConfig GetLiveTestRollbarInfrastructureConfig() { var config = new RollbarInfrastructureConfig(); var destinationOptions = RollbarUnitTestEnvironmentUtil.GetLiveTestRollbarDestinationOptions(); config .RollbarLoggerConfig .RollbarDestinationOptions .Reconfigure(destinationOptions); var infrastructureOptions = new RollbarInfrastructureOptions(); infrastructureOptions.PayloadPostTimeout = TimeSpan.FromSeconds(3); config .RollbarInfrastructureOptions .Reconfigure(infrastructureOptions); return(config); }
/// <summary> /// Loads the application settings. /// </summary> /// <param name="config">The configuration.</param> /// <param name="rollbarConfigSection">The application settings.</param> /// <returns>false when the configuration was not found, otherwise true.</returns> public static bool LoadAppSettings(RollbarInfrastructureConfig config, RollbarConfigSection?rollbarConfigSection) { if (rollbarConfigSection == null) { return(false); } LoadInfrastructureOptions(config, rollbarConfigSection); LoadOfflinePayloadStoreOptions(config, rollbarConfigSection); LoadDestinationOptions(config, rollbarConfigSection); LoadDeveloperOptions(config, rollbarConfigSection); LoadHttpProxyOptions(config, rollbarConfigSection); LoadDataSecurityOptions(config, rollbarConfigSection); LoadTelemetryOptions(config); var validationResults = config.Validate(); bool configLoadingResult = (validationResults == null) || (validationResults.Count == 0); Debug.Assert(configLoadingResult); return(configLoadingResult); }
private static void LoadDeveloperOptions(RollbarInfrastructureConfig config, RollbarConfigSection rollbarConfigSection) { if (rollbarConfigSection.Enabled.HasValue) { config.RollbarLoggerConfig.RollbarDeveloperOptions.Enabled = rollbarConfigSection.Enabled.Value; } if (rollbarConfigSection.Transmit.HasValue) { config.RollbarLoggerConfig.RollbarDeveloperOptions.Transmit = rollbarConfigSection.Transmit.Value; } if (rollbarConfigSection.RethrowExceptionsAfterReporting.HasValue) { config.RollbarLoggerConfig.RollbarDeveloperOptions.RethrowExceptionsAfterReporting = rollbarConfigSection.RethrowExceptionsAfterReporting.Value; } if (rollbarConfigSection.LogLevel.HasValue) { config.RollbarLoggerConfig.RollbarDeveloperOptions.LogLevel = rollbarConfigSection.LogLevel.Value; } }
/// <summary> /// Gets the Rollbar trace listener configuration. /// </summary> /// <returns>RollbarConfig.</returns> private IRollbarLoggerConfig?GetRollbarTraceListenerConfig() { if (string.IsNullOrWhiteSpace(this.Attributes[RollbarTraceListenerAttributes.rollbarAccessToken.ToString()])) { return(null); } if (!RollbarInfrastructure.Instance.IsInitialized) { #if !NETFX_47nOlder if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("BROWSER"))) { // We are running within Blazor WASM runtime environment that is known to be single threaded in its nature // at least at the moment, so no background threads are allowed and our infrastructure depends on the threads. // Hence, we can not initialize the infrastructure: // NO-OP... return(null); } #endif // It is safe to assume we can use the infrastructure: RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig( this.Attributes[RollbarTraceListenerAttributes.rollbarAccessToken.ToString()], this.Attributes[RollbarTraceListenerAttributes.rollbarEnvironment.ToString()] ); RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); return(rollbarInfrastructureConfig.RollbarLoggerConfig); } else { RollbarLoggerConfig rollbarLoggerConfig = new RollbarLoggerConfig( this.Attributes[RollbarTraceListenerAttributes.rollbarAccessToken.ToString()], this.Attributes[RollbarTraceListenerAttributes.rollbarEnvironment.ToString()] ); return(rollbarLoggerConfig); } }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureLogging((logging) => { // seed Rollbar infrastructure configuration: RollbarInfrastructureConfig rollbarInfrastructureConfig = new RollbarInfrastructureConfig(); // reconfigure the seed from the appsettings.json file: if (!AppSettingsUtility.LoadAppSettings(rollbarInfrastructureConfig)) { throw new ApplicationException("Couldn't load Rollbar configuration!"); } // init the Rollbar infrastructure with the loaded configuration: RollbarInfrastructure.Instance.Init(rollbarInfrastructureConfig); // add a well-configured RollbarLoggerProvider: logging.ClearProviders(); logging.AddProvider(new RollbarLoggerProvider(rollbarInfrastructureConfig.RollbarLoggerConfig)); } ) .ConfigureServices((hostContext, services) => { services.AddHostedService <Worker>(); });
public void CustomTelemetryOptionsMakeIntoTelemetryCollector() { int expectedTelemetryQueueDepth = 20; var config = new RollbarInfrastructureConfig("access_token", "special_environment"); Assert.IsFalse(config.RollbarTelemetryOptions.TelemetryEnabled); Assert.IsTrue(config.RollbarTelemetryOptions.TelemetryQueueDepth != expectedTelemetryQueueDepth); Assert.IsTrue(config.RollbarTelemetryOptions.TelemetryAutoCollectionTypes == TelemetryType.None); var telemetryOptions = new RollbarTelemetryOptions(true, 20) { TelemetryAutoCollectionTypes = TelemetryType.Log | TelemetryType.Error | TelemetryType.Network }; config.RollbarTelemetryOptions.Reconfigure(telemetryOptions); if (RollbarInfrastructure.Instance.IsInitialized) { RollbarInfrastructure.Instance.Config.Reconfigure(config); } else { RollbarInfrastructure.Instance.Init(config); } Assert.IsTrue(RollbarInfrastructure.Instance.TelemetryCollector.Config.TelemetryEnabled); Assert.AreEqual(expectedTelemetryQueueDepth, RollbarInfrastructure.Instance.TelemetryCollector.Config.TelemetryQueueDepth); Assert.IsTrue((RollbarInfrastructure.Instance.TelemetryCollector.Config.TelemetryAutoCollectionTypes & TelemetryType.Log) == TelemetryType.Log); Assert.IsTrue((RollbarInfrastructure.Instance.TelemetryCollector.Config.TelemetryAutoCollectionTypes & TelemetryType.Error) == TelemetryType.Error); Assert.IsTrue((RollbarInfrastructure.Instance.TelemetryCollector.Config.TelemetryAutoCollectionTypes & TelemetryType.Network) == TelemetryType.Network); Assert.IsTrue((RollbarInfrastructure.Instance.TelemetryCollector.Config.TelemetryAutoCollectionTypes & TelemetryType.Manual) == TelemetryType.None); Assert.AreEqual(expectedTelemetryQueueDepth, RollbarInfrastructure.Instance.TelemetryCollector.QueueDepth); }