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) { }
