protected virtual bool ExecuteCallback(bool timedout)
{
if (Disposed)
{
return(false);
}
using (new CorrelationScope())
{
using (IPerformanceTracker tracker = perf.TrackTask(Name))
{
try
{
callback(!timedout);
tracker.Commit(new { timedout });
return(true);
}
catch (Exception ex)
{
bool seenBefore = exception != null && exception.GetType() == ex.GetType();
exception = ex;
OnTaskException(new TaskExceptionEventArgs(ex, this, seenBefore));
tracker.Commit(new { ex });
return(false);
}
}
}
}
public static void Initialize(IPerformanceTracker tracker)
{
AppDomain.CurrentDomain.SetData("Cider_PerformanceTrackerInstanceKey", (object)tracker);
Performance._startFunc = new Func <ulong, string, bool>(tracker.StartTiming);
AppDomain.CurrentDomain.SetData("Cider_StartTimingFunctionKey", (object)Performance._startFunc);
Performance._endFunc = new Func <ulong, string, bool>(tracker.StopTiming);
AppDomain.CurrentDomain.SetData("Cider_StopTimingFunctionKey", (object)Performance._endFunc);
Performance._markFunc = new Func <ulong, string, bool>(tracker.MarkTime);
AppDomain.CurrentDomain.SetData("Cider_MarkTimeFunctionKey", (object)Performance._markFunc);
Performance._initialized = true;
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (!logger.IsEnabled())
{
return(await base.SendAsync(request, cancellationToken).ConfigureAwait(false));
}
using (new CorrelationScope(request.GetCorrelationId()))
{
using (IPerformanceTracker tracker = logger.TrackRequest(request))
{
HttpResponseMessage response = await base.SendAsync(request, cancellationToken).ConfigureAwait(true);
tracker.Commit(new { statusCode = response.StatusCode });
return(response);
}
}
}
/// <summary>
/// Added performance counters to persistence.
/// </summary>
protected virtual void PersistLogWithPerformanceTracking(Action logAction, string level, string container)
{
IPerformanceTracker performanceTracker = null;
try
{
if (LoggerSettings.UsePerformanceCounters)
{
try
{
performanceTracker = new PerformanceTracker(CreateActionInfo(level, container));
performanceTracker.ProcessActionStart();
}
catch (UnauthorizedAccessException) { }
catch (Exception)
{
// Just move on
}
}
logAction();
}
catch (Exception exception)
{
Trace.TraceError("VeryPrimitiveLogger: Persisting log failed with the following exception:\r\n{0}\r\n{1}", exception.Message, exception.StackTrace);
}
if (performanceTracker != null)
{
try
{
performanceTracker.ProcessActionComplete(false);
}
catch (UnauthorizedAccessException) { }
catch (Exception)
{
// Just move on
}
}
}
public static bool Initialise(Data.PackageData a_data, IConsoleHandler a_handler, IPerformanceTracker a_tracker, IDisplayHandler a_displayHandler)
{
s_data = a_data ?? throw new NullReferenceException("KDebug:: DEBUG DATA NULL");
bool bResult = false;
// Init Log
bResult = InitialiseLog();
if (bResult == false)
{
Reset();
return(false);
}
// Init Console
s_consoleImpl = new ConsoleImpl(a_handler, s_data.ConsoleData);
s_consoleImpl.OnAwake(s_data.ConsoleData);
// Init Debug Display Manager
s_displayManagerImpl = new DebugDisplayManagerImpl(a_data.DisplayData, a_displayHandler);
s_displayManagerImpl.OnAwake();
Tracker = a_tracker;
Tracker.OnAwake();
s_Initialised = true;
return(true);
}
public IWebHost Start()
{
container.Install(FromAssembly.This());
BeforeStart();
AppConfigurationProvider = container.Resolve <IAppConfigurationProvider>();
Configuration = AppConfigurationProvider.Get <WebHostConfiguration>();
Index = CreateIndex();
Storage = CreateStorage();
container
.Register(Component.For <IPathResolver>().ImplementedBy <PathResolver>())
.Register(Component.For <IJsonMergeVisitor>().ImplementedBy <JsonMergeVisitor>())
.Register(Component.For <IDiagnosticsDumpService>().ImplementedBy <DiagnosticsDumpService>())
.Register(Component.For <IJsonConverter>().ImplementedBy <DotjemJsonConverter>())
.Register(Component.For <ILazyComponentLoader>().ImplementedBy <LazyOfTComponentLoader>())
.Register(Component.For <IWindsorContainer>().Instance(container))
.Register(Component.For <IWebHost>().Instance(this))
.Register(Component.For <IStorageIndex>().Instance(Index))
.Register(Component.For <IStorageContext>().Instance(Storage))
.Register(Component.For <IWebHostConfiguration>().Instance(Configuration))
.Register(Component.For <IInitializationTracker>().Instance(Initialization));
ILogger perf = container.Resolve <ILogger>();
IPerformanceTracker startup = perf.TrackTask("Start");
DiagnosticsLogger = container.Resolve <IDiagnosticsLogger>();
perf.TrackAction(BeforeConfigure);
perf.TrackAction(() => Configure(container.Resolve <IPipeline>()), "Configure Pipeline");
perf.TrackAction(() => Configure(container), "Configure Container");
perf.TrackAction(() => Configure(Storage), "Configure Storage");
perf.TrackAction(() => Configure(Index), "Configure Index");
perf.TrackAction(() => Configure(new HttpRouterConfigurator(configuration.Routes)), "Configure Routes");
perf.TrackAction(AfterConfigure);
ResolveComponents();
Initialization.SetProgress("Bootstrapping.");
Task.Factory.StartNew(() =>
{
perf.TrackAction(BeforeInitialize);
Initialization.SetProgress("Initializing storage.");
perf.TrackAction(() => Initialize(Storage), "Initialize Storage");
Initialization.SetProgress("Initializing index.");
perf.TrackAction(() => Initialize(Index), "Initialize Index");
perf.TrackAction(AfterInitialize);
storageManager = container.Resolve <IStorageManager>();
indexManager = container.Resolve <IStorageIndexManager>();
Initialization.SetProgress("Loading index.");
perf.TrackAction(storageManager.Start);
perf.TrackAction(indexManager.Start);
perf.TrackAction(AfterStart);
Initialization.Complete();
startup.Dispose();
}).ContinueWith(async result => {
if (!result.IsFaulted)
{
return;
}
IDiagnosticsDumpService dump = Resolve <IDiagnosticsDumpService>();
Guid ticket = Guid.NewGuid();
try
{
if (result.Exception != null)
{
DiagnosticsLogger.LogException(Severity.Fatal, result.Exception, new { ticketId = ticket });
dump.Dump(ticket, result.Exception.ToString());
}
else
{
DiagnosticsLogger.LogFailure(Severity.Fatal, "Server startup failed. Unknown Error.", new { ticketId = ticket });
dump.Dump(ticket, "Server startup failed. Unknown Error.");
}
Initialization.SetProgress("Server startup failed. Please contact support. ({0})", ticket);
}
catch (Exception ex)
{
//TODO: (jmd 2015-10-01) Temporary Dumping of failure we don't know where to put.
string dumpMessage =
$"{ex}{Environment.NewLine}-----------------------------------{Environment.NewLine}{result.Exception}";
Initialization.SetProgress(dumpMessage);
dump.Dump(ticket, dumpMessage);
}
await Task.Delay(10.Minutes())
.ContinueWith(t =>
{
//NOTE: (jmd 2019-11-04) This restarts the application.
HttpRuntime.UnloadAppDomain();
});
});
return(this);
}
