public static TraceLevel ToTraceLevel(TraceCategory category) { switch (category) { case TraceCategory.ERROR: return(TraceLevel.Error); case TraceCategory.WARNING: return(TraceLevel.Warning); case TraceCategory.Info: return(TraceLevel.Info); case TraceCategory.TimerStart: case TraceCategory.TimerEnd: case TraceCategory.Debug: return(TraceLevel.Verbose); case TraceCategory.Data: return(TraceLevel.Verbose); default: // No category should fall here, but not throwing exception to avoid exception propagation in java return(TraceLevel.Verbose); } }
public void Fatal(TraceCategory category, string message, Exception exception) { WriteRecord(RecordType.Fatal, new TraceRecord { Category = category, Message = message, Exception = exception }); }
private static void writeLine(string[] messages, TraceCategory category) { foreach (string message in messages) { writeLine(message, category); } }
/// <summary> /// Trace an ETW event. /// </summary> /// <param name="type">The event type.</param> /// <param name="eventId">The event id.</param> /// <param name="category">The trace category.</param> /// <param name="message">The trace message.</param> /// <param name="memberName">For internal use.</param> /// <param name="sourceFilePath">For internal use.</param> /// <param name="sourceLineNumber">For internal use.</param> private static void TraceEvent(TraceEventType type, EventNames eventId, TraceCategory category, string message, string memberName, string sourceFilePath, int sourceLineNumber) { InternalTrace.TraceEvent( PortalSettings.Instance, type, (int)eventId, "Event Level={0}, Category={1}, Message={2}, Member Name={3}, Source File Path={4}, Source Line Number={5}, PortalID={6}, PortalEvent={7}, TenantID={8}, OrgID={9}, Geo={10}, PortalApp={11}, PortalType={12}", eventId, category, message, memberName, sourceFilePath, sourceLineNumber, PortalDetail.Instance.PortalId, PortalEvents.TraceInfo, PortalDetail.Instance.TenantId, PortalDetail.Instance.OrgId, PortalDetail.Instance.Geo, PortalDetail.Instance.PortalApp, PortalDetail.Instance.PortalType); }
private void TagInputBox_Input(object sender, TagInputEventArgs e) { suggestedTags.Notification = String.Empty; try { if (tagInput.IsEmpty) { suggestedTags.Highlighter = new TextSplitter(); } else { IEnumerable <string> tags = tagInput.Tags; if (e.TagInputComplete) { _model.PageTags.AddAll(from t in tags where !_model.PageTags.ContainsKey(t) select new SimpleTagButtonModel(t)); tagInput.Clear(); } suggestedTags.Highlighter = new TextSplitter(tagInput.Tags); } } catch (Exception ex) { TraceLogger.Log(TraceCategory.Error(), "Processing Tag input failed with {0}", ex); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagEditor_Input_Error, ex); } e.Handled = true; }
private void TraceInternal(TraceCategory traceCategory, int errorCode, TraceEventType traceEventType, string traceEventName, DateTime?traceDate, TimeSpan?elapsedTime, Exception exception, string message, TraceContext context) { if (_traceSource == null) { throw new InvalidOperationException("SetSource() must be called before."); } // if no date were specified use now DateTime creationDate = traceDate ?? HighResolutionDateTime.UtcNow; // mapping TraceCategory System.Diagnostics.TraceEventType System.Diagnostics.TraceEventType dotnetTraceEventType = CategoryMapper[traceCategory]; TraceEventData traceEvent = new TraceEventData { CreationDate = creationDate, ContextParameter = context?.ToString(), CorrelationId = GetCorrelationId(), SessionId = GetSessionId(), UserName = GetPrincipalId(), ElapsedTime = elapsedTime, ErrorCode = errorCode, RawException = exception, TraceCategory = traceCategory, TraceEventType = traceEventType, TraceEventName = traceEventName, TraceSourceName = _traceSourceName, TraceSourceType = _traceSourceType, Message = message, }; traceEvent.ComputeAutomaticProperties(); _traceSource.TraceData(dotnetTraceEventType, errorCode, traceEvent); }
private void Hyperlink_Click(object sender, RoutedEventArgs e) { try { HitHighlightedPageLink l = sender as HitHighlightedPageLink; if (l != null) { HitHighlightedPageLinkModel model = l.DataContext as HitHighlightedPageLinkModel; _model.NavigateTo(model.PageID); if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)) { int ndx = foundPagesList.SelectedItems.IndexOf(model); if (ndx >= 0) { foundPagesList.SelectedItems.RemoveAt(ndx); } else { foundPagesList.SelectedItems.Add(model); } } else { // select the link foundPagesList.SelectedItem = model; } e.Handled = true; } } catch (System.Exception ex) { TraceLogger.Log(TraceCategory.Error(), "Navigation to OneNote page failed: {0}", ex); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagSearch_Error_PageNavigation, ex); } }
private async void Filter_MenuItem_Click(object sender, RoutedEventArgs e) { try { if (ContextTagsSource == null) { return; } MenuItem itm = sender as MenuItem; TagContext filter = (TagContext)Enum.Parse(typeof(TagContext), itm.Tag.ToString()); IEnumerable <TagPageSet> tags = await GetContextTagsAsync(filter); Tags = from t in tags select t.TagName; if (string.IsNullOrEmpty(tagInput.Text)) { filterPopup.IsOpen = true; } } catch (Exception ex) { TraceLogger.Log(TraceCategory.Error(), "Applying preset filter failed {0}", ex); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagEditor_Filter_Error, ex); } finally { e.Handled = true; } }
public TabSyncService() { _syncSignatureRegex = new Regex(@".*_sync_\d+\.", RegexOptions.Compiled); _traceCategory = new TraceCategory("TabSyncService"); DownloadSyncFiles = false; }
private static SPDiagnosticsCategory CreateCategory(TraceCategory category) { return(new SPDiagnosticsCategory( GetCategoryName(category), GetCategoryDefaultTraceSeverity(category), GetCategoryDefaultEventSeverity(category) )); }
static void writeLine(string message, TraceCategory category) { Trace.WriteLine(string.Format("{0} [{1}] [{2}] {3}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff"), Thread.CurrentThread.ManagedThreadId, category.ToString(), message)); }
// TODO: strip this code in the end! public static void Info(TraceCategory category, string message) { if (!EnabledMask.HasFlag(category)) { return; } Debug.Log("[" + category.ToString() + "]" + message); }
private static void writeLine(string message, TraceCategory category) { #pragma warning disable 0618 Trace.WriteLine(string.Format("{0} [{3}] [{1}] {2}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff"), category.ToString(), message, AppDomain.GetCurrentThreadId())); #pragma warning restore 0618 }
internal int EnqueuePagesForTagging(TagOperation op) { // bring suggestions up-to-date with new tags that may have been entered TagSuggestions.AddAll(from t in _pageTags where !TagSuggestions.ContainsKey(t.Key) select new HitHighlightedTagButtonModel() { TagName = t.TagName }); TagSuggestions.Save(); // covert scope to context TagContext ctx; switch (Scope) { default: case TaggingScope.CurrentNote: ctx = TagContext.CurrentNote; break; case TaggingScope.SelectedNotes: ctx = TagContext.SelectedNotes; break; case TaggingScope.CurrentSection: ctx = TagContext.CurrentSection; break; } IEnumerable <string> pageIDs = null; if (ScopesEnabled) { TagsAndPages tc = new TagsAndPages(OneNoteApp); tc.LoadPageTags(ctx); pageIDs = tc.Pages.Select(p => p.Key); } else { pageIDs = PagesToTag; } int enqueuedPages = 0; string[] pageTags = (from t in _pageTags.Values select t.TagName).ToArray(); foreach (string pageID in pageIDs) { OneNoteApp.TaggingService.Add(new TaggingJob(pageID, pageTags, op)); enqueuedPages++; } TraceLogger.Log(TraceCategory.Info(), "{0} page(s) enqueued for tagging with '{1}' using {2}", enqueuedPages, string.Join(";", pageTags), op); TraceLogger.Flush(); return(enqueuedPages); }
private static string GetCategoryName(TraceCategory cat) { // Get the type Type type = cat.GetType(); // Get fieldinfo for this type System.Reflection.FieldInfo fieldInfo = type.GetField(cat.ToString()); // Get the stringvalue attributes CategoryNameAttribute[] attribs = fieldInfo.GetCustomAttributes(typeof(CategoryNameAttribute), false) as CategoryNameAttribute[]; // Return the first if there was a match. return(attribs.Length > 0 ? attribs[0].Name : null); }
private static EventSeverity GetCategoryDefaultEventSeverity(TraceCategory cat) { // Get the type Type type = cat.GetType(); // Get fieldinfo for this type System.Reflection.FieldInfo fieldInfo = type.GetField(cat.ToString()); // Get the stringvalue attributes DefaultEventSeverityAttribute[] attribs = fieldInfo.GetCustomAttributes(typeof(DefaultEventSeverityAttribute), false) as DefaultEventSeverityAttribute[]; // Return the first if there was a match. return(attribs.Length > 0 ? attribs[0].Severity : EventSeverity.Error); }
private static void write(string message, TraceCategory category) { if (message.Contains("\n")) { message = message.Replace("\r\n", "\n"); string[] lines = message.Split('\n'); writeLine(lines, category); } else { writeLine(message, category); } }
private void _model_PropertyChanged(object sender, PropertyChangedEventArgs e) { if (e == FindTaggedPagesModel.PAGE_COUNT) { foundPagesList.UnselectAll(); } else if (e == FindTaggedPagesModel.CURRENT_TAGS) { // update query if necessary string thisScopID; switch (scopeSelect.SelectedScope) { case SearchScope.Notebook: thisScopID = ViewModel.OneNoteApp.CurrentNotebookID; break; case SearchScope.SectionGroup: thisScopID = ViewModel.OneNoteApp.CurrentSectionGroupID; break; case SearchScope.Section: thisScopID = ViewModel.OneNoteApp.CurrentSectionID; break; default: thisScopID = string.Empty; break; } if (!thisScopID.Equals(ViewModel.LastScopeID)) { // rerun the query for the current scope try { pBar.Visibility = System.Windows.Visibility.Visible; string query = searchComboBox.Text; _model.FindPagesAsync(query, scopeSelect.SelectedScope).Wait(); tagInput.Tags = ViewModel.CurrentTags; pBar.Visibility = System.Windows.Visibility.Hidden; searchComboBox.SelectedValue = query; } catch (System.Exception ex) { TraceLogger.Log(TraceCategory.Error(), "Changing search scope failed: {0}", ex); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagSearch_Error_ScopeChange, ex); } } else { tagInput.Tags = ViewModel.CurrentTags; } } }
public void TraceWarning(TraceCategory category, string message, [System.Runtime.CompilerServices.CallerMemberName] string memberName = "", [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "", [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0) { this.TraceWarning( category, message, memberName, sourceFilePath, sourceLineNumber, this.PortalUrl, this.PortalVersion, this.ProductionOrTrial, this.SessionId, this.ElapsedTime()); }
private async void SearchButton_Click(object sender, RoutedEventArgs e) { string query = searchComboBox.Text; try { pBar.Visibility = System.Windows.Visibility.Visible; await _model.FindPagesAsync(query, scopeSelect.SelectedScope); searchComboBox.SelectedValue = query; pBar.Visibility = System.Windows.Visibility.Hidden; } catch (System.Exception ex) { TraceLogger.Log(TraceCategory.Error(), "search for '{0}' failed: {1}", query, ex); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagSearch_Error_Find, ex); } e.Handled = true; }
/// <summary> /// Extract tags from page descriptors. /// </summary> /// <param name="pageDescriptors"> /// XML document describing pages in the OneNote hierarchy or search result. /// </param> /// <param name="selectedPagesOnly">true to process only pages selected by user</param> /// <param name="omitUntaggedPages">drip untagged pages</param> internal void ExtractTags(XDocument pageDescriptors, bool selectedPagesOnly, bool omitUntaggedPages = false) { // parse the search results _tags.Clear(); _pages.Clear(); try { XNamespace one = pageDescriptors.Root.GetNamespaceOfPrefix("one"); Dictionary <string, TagPageSet> tags = new Dictionary <string, TagPageSet>(); foreach (XElement page in pageDescriptors.Descendants(one.GetName("Page"))) { TaggedPage tp = new TaggedPage(page); if (selectedPagesOnly && !tp.IsSelected) { continue; } // assign Tags int tagcount = 0; foreach (string tagname in tp.TagNames) { tagcount++; TagPageSet t; if (!tags.TryGetValue(tagname, out t)) { t = new TagPageSet(tagname); tags.Add(tagname, t); } t.AddPage(tp); tp.Tags.Add(t); } if (!omitUntaggedPages || tagcount > 0) { _pages.Add(tp.Key, tp); } } // bulk update for performance reasons _tags.UnionWith(tags.Values); TraceLogger.Log(TraceCategory.Info(), "Extracted {0} tags from {1} pages.", _tags.Count, _pages.Count); } catch (Exception ex) { TraceLogger.Log(TraceCategory.Error(), "Parsing Hierarchy data failed: {0}", ex); TraceLogger.Flush(); } }
private void ScopeSelector_ScopeChanged(object sender, ScopeChangedEventArgs e) { try { pBar.Visibility = System.Windows.Visibility.Visible; string query = searchComboBox.Text; // using ContinueWith until I've discovered how to do implement async // events properly _model.FindPagesAsync(query, scopeSelect.SelectedScope).ContinueWith(tsk => Dispatcher.Invoke(() => { pBar.Visibility = System.Windows.Visibility.Hidden; searchComboBox.SelectedValue = query; })); } catch (System.Exception ex) { TraceLogger.Log(TraceCategory.Error(), "Changing search scope failed: {0}", ex); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagSearch_Error_ScopeChange, ex); } e.Handled = true; }
/// <summary> /// Run the background tagger. /// </summary> /// <returns></returns> public Task Run() { TaskFactory tf = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None); CancellationToken cancel = _cancel.Token; return(tf.StartNew(() => { TraceLogger.Log(TraceCategory.Info(), "Background tagging service started"); try { OneNotePageProxy lastPage = null; while (!_jobs.IsCompleted) { TaggingJob j = _jobs.Take(); cancel.ThrowIfCancellationRequested(); try { lastPage = j.Execute(_onenote, lastPage); if (lastPage != null && _jobs.Count == 0) { // no more pending pages - must update the last one and stop carrying forward lastPage.Update(); lastPage = null; } } catch (Exception e) { lastPage = null; TraceLogger.ShowGenericErrorBox("page tagging failed", e); } } } catch (InvalidOperationException) { TraceLogger.Log(TraceCategory.Warning(), "Background tagging job queue depleted"); TraceLogger.Flush(); } catch (OperationCanceledException) { TraceLogger.Log(TraceCategory.Warning(), "Background tagging canceled"); TraceLogger.Flush(); } }, cancel)); }
private void ApplyPageTags(TagOperation op) { tagInput.FocusInput(); try { TaggingScope scope = ((TaggingScopeDescriptor)taggingScope.SelectedItem).Scope; int pagesTagged = _model.EnqueuePagesForTagging(op, scope); taggingScope.SelectedIndex = 0; tagInput.Clear(); suggestedTags.Highlighter = new TextSplitter(); suggestedTags.Notification = pagesTagged == 0 ? Properties.Resources.TagEditor_Popup_NothingTagged : string.Format(Properties.Resources.TagEditor_Popup_TaggingInProgress, pagesTagged); } catch (Exception xe) { TraceLogger.Log(TraceCategory.Error(), "Applying tags to page failed: {0}", xe); TraceLogger.ShowGenericErrorBox(Properties.Resources.TagEditor_TagUpdate_Error, xe); } }
public void Warn(TraceCategory category, string message) { WriteRecord(RecordType.Warn, new TraceRecord { Category = category, Message = message }); }
public void Info(TraceCategory category, string message) { WriteRecord(RecordType.Info, new TraceRecord { Category = category, Message = message }); }
public static void LogException(string ProviderInternalName, string faultyAction, TraceCategory category, Exception ex) { try { if (ex is AggregateException) { string message = String.Format("[{0}] Unexpected error(s) occurred {1}:", ProviderInternalName, faultyAction); string excetpionMessage = Environment.NewLine + "[EXCEPTION {0}]: {1}: {2}. Callstack: {3}"; var aggEx = ex as AggregateException; int count = 1; foreach (var innerEx in aggEx.InnerExceptions) { string currentMessage; if (innerEx.InnerException != null) { currentMessage = String.Format(excetpionMessage, count++.ToString(), innerEx.InnerException.GetType().FullName, innerEx.InnerException.Message, innerEx.InnerException.StackTrace); } else { currentMessage = String.Format(excetpionMessage, count++.ToString(), innerEx.GetType().FullName, innerEx.Message, innerEx.StackTrace); } message += currentMessage; } WriteTrace(category, TraceSeverity.Unexpected, message); } else { string message = "[{0}] Unexpected error occurred {1}: {2}: {3}, Callstack: {4}"; if (ex.InnerException != null) { message = String.Format(message, ProviderInternalName, faultyAction, ex.InnerException.GetType().FullName, ex.InnerException.Message, ex.InnerException.StackTrace); } else { message = String.Format(message, ProviderInternalName, faultyAction, ex.GetType().FullName, ex.Message, ex.StackTrace); } WriteTrace(category, TraceSeverity.Unexpected, message); } } catch { // Don't want to do anything if logging goes wrong, just ignore and continue } }
public static void Log(string message, TraceSeverity traceSeverity, EventSeverity eventSeverity, TraceCategory category) { try { WriteTrace(category, traceSeverity, message); //LdapcpLoggingService.WriteEvent(LdapcpLoggingService.TraceCategory.LDAPCP, eventSeverity, message); } catch { // Don't want to do anything if logging goes wrong, just ignore and continue } }
public static void Trace(TraceLevel level, TraceCategory category, string message) { TraceSwitch sw = switches[(int)category]; if (sw.Level < level && (sw == all || all.Level < level)) return; switch (level) { case TraceLevel.Error: new ErrorEvent(level, category, message).Raise(); break; case TraceLevel.Warning: case TraceLevel.Info: case TraceLevel.Verbose: new TraceEvent(level, category, message).Raise(); break; } }
public static void Trace(TraceLevel level, TraceCategory category, string fmt, params object[] pars) { Trace(level, category, string.Format(fmt, pars)); }
private SPDiagnosticsCategory GetCategory(TraceCategory cat) { return(base.Areas[DiagnosticsAreaName].Categories[GetCategoryName(cat)]); }
public TraceEvent(TraceLevel level, TraceCategory category, string message) : base(HttpContext.Current == null ? message : HttpContext.Current.Request.UserHostAddress + ": " + message, null, (int)level, (int)category) { }
public static void WriteEvent(TraceCategory Category, EventSeverity Severity, string message) { Local.WriteEvent(1337, Local.GetCategory(Category), Severity, message); }
public ErrorEvent(TraceLevel level, TraceCategory category, string message) : base(level, category, message) { }