public static void SetupLogger()
{
lock (SyncRoot)
{
if (isSetUp)
{
return;
}
var configuration = new LoggingConfiguration();
#if DEBUG
configuration.AddTarget(LogLevel.Trace, LogLevel.Fatal, new DebugTarget(new LoggingLayout()));
#endif
#if DEBUG
var minLogLevelForFileTarget = LogLevel.Debug;
#else
var minLogLevelForFileTarget = LogLevel.Info;
#endif
configuration.AddTarget(minLogLevelForFileTarget, LogLevel.Fatal, FileStreamingTarget.Instance);
configuration.IsEnabled = true;
LogManagerFactory.DefaultConfiguration = configuration;
isSetUp = true;
}
}
internal Logger(string name, LoggingConfiguration config)
{
this.Name = name;
// add a target...
if (config != null)
this.Configuration = config.Clone();
}
public static Logger GetLogger(string name, LoggingConfiguration config = null)
{
lock (_loggersLock)
{
if (!(Loggers.ContainsKey(name)))
Loggers[name] = new Logger(name, config);
return Loggers[name];
}
}
public static void Reset()
{
Loggers = new Dictionary<string, Logger>(StringComparer.OrdinalIgnoreCase);
// default logging config...
var config = new LoggingConfiguration();
config.AddTarget(LogLevel.Trace, LogLevel.Fatal, new DebugTarget());
config.AddTarget(LogLevel.Error, LogLevel.Fatal, new FileSnapshotTarget());
DefaultConfiguration = config;
}
public static ILogManager CreateLogManager(LoggingConfiguration config = null)
{
var cfg = config ?? DefaultConfiguration;
cfg.Freeze();
var manager = new LogManager(cfg);
Configurator.OnLogManagerCreated(manager);
return manager;
}
public static ILogManager CreateLogManager(LoggingConfiguration config = null)
{
var cfg = config ?? DefaultConfiguration;
cfg.Freeze();
ILogManager manager;
var managerFactory = PlatformAdapter.Resolve<ILogManagerFactory>(false);
if (managerFactory != null)
manager = managerFactory.Create(cfg);
else
manager = new LogManagerBase(cfg);
_configurator.OnLogManagerCreated(manager);
return manager;
}
public App()
{
var configuration = new LoggingConfiguration();
configuration.AddTarget(LogLevel.Trace, LogLevel.Fatal, new FileStreamingTarget());
configuration.IsEnabled = true;
LogManagerFactory.DefaultConfiguration = configuration;
Log = LogManagerFactory.DefaultLogManager.GetLogger<App>();
UnhandledException += App_UnhandledException;
GlobalCrashHandler.Configure();
BookieSettings.LoadSettings();
//var localSettings = ApplicationData.Current.LocalSettings;
//var theme = localSettings.Values["Theme"];
//if (theme == null)
//{
// Current.RequestedTheme = ApplicationTheme.Dark;
//}
//else if (theme.ToString() == "Dark")
//{
// Current.RequestedTheme = ApplicationTheme.Dark;
//}
//else if (theme.ToString() == "Light")
//{
// Current.RequestedTheme = ApplicationTheme.Light;
//}
WindowsAppInitializer.InitializeAsync(
WindowsCollectors.Metadata |
WindowsCollectors.Session);
InitializeComponent();
Suspending += OnSuspending;
//using (var db = new Context())
//{
// db.Database.Migrate();
//}
var covers = Globals.GetCoversFolder();
}
public App()
{
#region HOCKEYAPP SAMPLE CODE
//this is just a sample in memory logger using MetroLog
var config = new LoggingConfiguration();
var inMemoryLogTarget = new InMemoryLogTarget(40);
config.AddTarget(LogLevel.Warn, inMemoryLogTarget);
LogManagerFactory.DefaultConfiguration = config;
//main configuration method for HockeySDK. following lines are optional configurations options
HockeyClient.Current.Configure(DemoConstants.YOUR_APP_ID)
.SetExceptionDescriptionLoader((ex) => { return inMemoryLogTarget.LogLines.Aggregate((a, b) => a + "\n" + b); }) //return additional info from your logger on crash
// .RegisterCustomUnhandledExceptionLogic((eArgs) => { return true; }) // define a callback that is called after unhandled exception. returnvalue indicates if application exit should be called
// .RegisterCustomUnobserveredTaskExceptionLogic((eArgs) => { return false; }) // define a callback that is called after unobserved task exception. returnvalue indicates if application exit should be called
// .SetApiDomain("https://your.dedicated.hockey.server")
.SetContactInfo(DemoConstants.USER_NAME, DemoConstants.USER_EMAIL);
//optional register your logger for internal logging of HockeySDK
HockeyLogManager.GetLog = (t) => { return new HockeyAppMetroLogWrapper(t); };
//optional should only used in debug builds. register an event-handler to get exceptions in HockeySDK code that are "swallowed" (like problems writing crashlogs etc.)
#if DEBUG
((HockeyClient)HockeyClient.Current).OnHockeySDKInternalException += (sender, args) => {
if (Debugger.IsAttached)
{
//Debugger.Break();
}
};
#endif
#endregion
#region Standard template code
this.InitializeComponent();
this.Suspending += this.OnSuspending;
#endregion
}
/// <summary>
/// Gets a logger for the given user control instance.
/// </summary>
/// <param name="control"></param>
/// <param name="config">Optional configuration.</param>
/// <returns></returns>
public static ILogger GetLogger(this UserControl control, LoggingConfiguration config = null)
{
return pcl::MetroLog.LogManagerFactory.DefaultLogManager.GetLogger(control.GetType(), config);
}
public static Logger GetLogger(ILoggable loggable, LoggingConfiguration config)
{
return GetLogger(loggable.GetType().Name, config);
}
public ILogManager Create(LoggingConfiguration configuration)
{
return new LogManager(configuration);
}
/// <summary>
/// Constructor for the Application object.
/// </summary>
public App()
{
// Global handler for uncaught exceptions.
UnhandledException += Application_UnhandledException;
// Standard XAML initialization
InitializeComponent();
// Phone-specific initialization
InitializePhoneApplication();
// Language display initialization
InitializeLanguage();
// Show graphics profiling information while debugging.
if (Debugger.IsAttached)
{
// Display the current frame rate counters.
Application.Current.Host.Settings.EnableFrameRateCounter = true;
// Show the areas of the app that are being redrawn in each frame.
//Application.Current.Host.Settings.EnableRedrawRegions = true;
// Enable non-production analysis visualization mode,
// which shows areas of a page that are handed off to GPU with a colored overlay.
//Application.Current.Host.Settings.EnableCacheVisualization = true;
// Prevent the screen from turning off while under the debugger by disabling
// the application's idle detection.
// Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
// and consume battery power when the user is not using the phone.
PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
}
#region HOCKEYAPP SAMPLE CODE
//this is just a sample in memory logger using MetroLog
var config = new LoggingConfiguration();
var inMemoryLogTarget = new InMemoryLogTarget(40);
config.AddTarget(LogLevel.Warn, inMemoryLogTarget);
LogManagerFactory.DefaultConfiguration = config;
//main configuration method for HockeySDK. following lines are optional configurations options
HockeyClient.Current.Configure(DemoConstants.YOUR_APP_ID)
.SetExceptionDescriptionLoader((ex) => { return inMemoryLogTarget.LogLines.Aggregate((a, b) => a + "\n" + b); }) //return additional info from your logger on crash
// .SetApiDomain("https://your.dedicated.hockey.server")
.UseCustomResourceManager(AppResources.ResourceManager)
.SetContactInfo(DemoConstants.USER_NAME, DemoConstants.USER_EMAIL);
//optional register your logger for internal logging of HockeySDK
HockeyLogManager.GetLog = (t) => { return new HockeyAppMetroLogWrapper(t); };
//optional should only used in debug builds. register an event-handler to get exceptions in HockeySDK code that are "swallowed" (like problems writing crashlogs etc.)
#if DEBUG
((HockeyClient)HockeyClient.Current).OnHockeySDKInternalException += (sender, args) =>
{
if (Debugger.IsAttached)
{
Debugger.Break();
}
};
#endif
#endregion
}
public static Logger GetLogger(this ILoggable loggable, LoggingConfiguration config = null)
{
return LogManager.GetLogger(loggable, config);
}
public LogManager(LoggingConfiguration configuration) : base(configuration)
{
}
public LogManager(LoggingConfiguration configuration) : base(configuration)
{
}