internal static void GoIntoScope(LoggingScope loggingScope) { NeedUpdateCurrentValue = true; var scopedRootEventId = LogEventIdFactory.Create(name: loggingScope.ToString()); scopedRootEventId.LoggingScopeTraceId = loggingScope.TranceId; }
public LinqToSparqlExpTranslator(StringBuilder stringBuilder) { using (var ls = new LoggingScope("LinqToSparqlExpTranslator ctor")) { this.stringBuilder = stringBuilder; } }
/// <inheritdoc /> public IDisposable BeginScope <TState>(TState state) { if (state == null) { throw new ArgumentNullException(nameof(state)); } return(LoggingScope.Push(StateNamespace, state)); }
public static LoggingScope Push(object state) { var current = currentScope.Value; var next = new LoggingScope(state, current); currentScope.Value = next; return(next); }
public MainWindow() { this.InitializeComponent(); #if DEBUG this.AttachDevTools(); #endif using var initScope = new TimedScope(LoggingScope.Global($"{nameof(MainWindow)}.InitializeServices")); Session = new Session(); var menuProvider = new MenuProvider(); Services.AddService <IMenuProvider>(menuProvider); Session.EditorViewModel = new EditorViewModel(menuProvider); Session.Services = Services; Services.AddService <Window>(this); Services.AddService <Session>(Session); Services.AddService <IRootViewModelContainer>(Session); Services.AddService <ViewRegistry>(new ViewRegistry()); Services.AddService <IDialogService>(new DialogService(Services)); var viewDataTemplate = new ViewDataTemplate(Services); Services.AddService <IViewUpdater>(viewDataTemplate); DataTemplates.Add(viewDataTemplate); Services.AddService <IUndoService>(new UndoService()); Services.AddService <IMemberViewProvider <IViewBuilder> >(new MemberViewProvider(Services)); var commandDispatcher = new CommandDispatcher(Services); Services.AddService <ICommandDispatcher>(commandDispatcher); // after all synchronous code caused by user input has been executed // we begin the commands processing. InputManager.Instance.PostProcess.Subscribe(async(e) => await commandDispatcher.ProcessDispatchedCommands()); var tabManager = new SimpleTabManager(Services); Services.AddService <ITabManager>(tabManager); Services.AddService <SimpleTabManager>(tabManager); var assetManager = new AssetManager(Services); Services.AddService <IAssetManager>(assetManager); Services.AddService <IAssetEditorRegistry>(assetManager); var pluginRegistry = new PluginRegistry(Services); pluginRegistry.RefreshAvailablePlugins(); Services.AddService <PluginRegistry>(pluginRegistry); foreach (var initialPlugin in pluginRegistry.AvailablePlugins) { pluginRegistry.Register(initialPlugin); } // It will be rendered by the DataTemplate DataContext = Session.EditorViewModel; }
/// <summary> /// Invokes the specified environment. /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public override async Task Invoke(IOwinContext context) { var method = context.Request.Method; var path = context.Request.Path; var scopeName = $"{path} [{method}]"; using (var scope = new LoggingScope(scopeName)) { await Next.Invoke(context); scope.Log("Status Code: {0}", context.Response.StatusCode); } }
public IEnumerator <T> ExecuteQuery() { using (var loggingScope = new LoggingScope("SparqlCommand<T>.ExecuteQuery()")) { #region Tracing #line hidden if (Logger.IsDebugEnabled) { Logger.Debug("{0}.", CommandText); } #line default #endregion MethodCallExpression e = null; IList <T> results = new List <T>(); switch (Connection.Store.QueryMethod) { case LinqQueryMethod.CustomSparql: case LinqQueryMethod.GenericSparql: case LinqQueryMethod.InMemorySparql: case LinqQueryMethod.NativeSparql: case LinqQueryMethod.RemoteSparql: //Set up the Connection and the Results Sink LinqToSparqlConnection <T> connection = (LinqToSparqlConnection <T>)Connection; if (connection.SparqlQuery.Expressions.ContainsKey("Select")) { e = connection.SparqlQuery.Expressions["Select"]; } ObjectDeserialiserQuerySink sink = new ObjectDeserialiserQuerySink(connection.SparqlQuery.OriginalType, typeof(T), InstanceName, ElideDuplicates, e, (RdfDataContext)connection.SparqlQuery.DataContext); //Compile and Parse the Query DateTime beforeQueryCompilation = DateTime.Now; SparqlQuery query = this._parser.ParseFromString(CommandText); DateTime afterQueryCompilation = DateTime.Now; DateTime beforeQueryRun = DateTime.Now; //Run the Query connection.Store.QueryProcessor.Run(query, sink); //Extract and Register Results DateTime afterQueryRun = DateTime.Now; ExtractResultsIntoList(results, sink); RegisterResults(connection.SparqlQuery, results); break; default: break; } return(results.GetEnumerator()); } }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { if (formatter == null) { throw new ArgumentNullException(nameof(formatter)); } if (logLevel < minLogLevel) { return; } var message = formatter(state, exception); if (string.IsNullOrEmpty(message)) { return; } var sb = new StringBuilder(); sb.Append(logLevel); sb.Append(": "); var leftMargin = sb.Length; sb.Append(Name); if (LoggingScope.Current != null) { sb.AppendLine(); sb.Append(' ', leftMargin); foreach (var scope in LoggingScope.Trace()) { sb.Append(" -> "); sb.Append(scope.State); } } sb.AppendLine(); sb.Append(' ', leftMargin); sb.Append(message); if (exception != null) { sb.AppendLine(); sb.Append(' ', leftMargin); sb.Append(exception); } Output.WriteLine(sb.ToString()); }
public async Task <PackageSessionResult> LoadProject(string path) { var viewUpdater = Services.GetService <IViewUpdater>(); PackageSessionResult sessionResult = await SetupResultProgress(viewUpdater, LoadProjectScope); using (var scope = new TimedScope(LoadProjectScope, TimedScope.Status.Failure)) { // Force PackageSession.Load to be executed on the thread pool // otherwise it would block execution and we want this process to be async await Task.Run(() => { PackageSession.Load(path, sessionResult); }).ConfigureAwait(false); PackageSession = sessionResult.Session; foreach (var pkg in PackageSession.LocalPackages) { pkg.UpdateAssemblyReferences(LoggingScope.Global($"{nameof(Session)}.{nameof(pkg.UpdateAssemblyReferences)}")); } if (!sessionResult.HasErrors) { scope.Result = TimedScope.Status.Success; } } // Create asset browser for package and add it to the viewmodel var browser = new AssetBrowserViewModel(PackageSession); await Services.GetService <ITabManager>().CreateToolTab(browser); EditorViewModel.LoadingStatus = null; await viewUpdater.UpdateView(); ProjectLoaded?.Invoke(sessionResult); return(sessionResult); }
private LoggingScope(object state, LoggingScope parent) { State = state; Parent = parent; }
public IDisposable BeginScope <TState>(TState state) { return(LoggingScope.Push(state)); }
private async Task <PackageSessionResult> SetupResultProgress(IViewUpdater viewUpdater, LoggingScope scope) { EditorViewModel.LoadingStatus = new LoadingStatus(LoadingStatus.LoadingMode.Indeterminate); await viewUpdater.UpdateView(); // in this result will be any errors from loading the project var sessionResult = new PackageSessionResult(); sessionResult.MessageLogged += (_, e) => scope.Log(e.Message); sessionResult.ProgressChanged += async(_, e) => { if (e.HasKnownSteps && e.CurrentStep > 0) { var percentage = EditorViewModel.LoadingStatus.PercentCompleted; var newPercentage = 100 * e.CurrentStep / e.StepCount; EditorViewModel.LoadingStatus.Mode = LoadingStatus.LoadingMode.Percentage; EditorViewModel.LoadingStatus.PercentCompleted = newPercentage; } else { EditorViewModel.LoadingStatus.Mode = LoadingStatus.LoadingMode.Indeterminate; } EditorViewModel.LoadingStatus.Message = e.Message; await viewUpdater.UpdateView(); }; return(sessionResult); }
public void WriteLine(string line) => _next.WriteLine(LoggingScope.GetIndentation() + line);