// Token: 0x06000001 RID: 1 RVA: 0x000020D0 File Offset: 0x000002D0 public static void Main(string[] args) { List <string> list = new List <string>(); list.Add("SeAuditPrivilege"); list.Add("SeChangeNotifyPrivilege"); list.Add("SeCreateGlobalPrivilege"); list.Add("SeImpersonatePrivilege"); bool isSystem; using (WindowsIdentity current = WindowsIdentity.GetCurrent()) { isSystem = current.IsSystem; } if (isSystem) { list.Add("SeIncreaseQuotaPrivilege"); list.Add("SeAssignPrimaryTokenPrivilege"); } int num = Privileges.RemoveAllExcept(list.ToArray()); if (num != 0) { Program.main.StopService(Strings.PrivilegeRemovalFailure(num), true, false, false); } ExWatson.Init(); AppDomain.CurrentDomain.UnhandledException += Program.MainUnhandledExceptionHandler; if (!Program.AddTokenReadPermissionForAdminGroup()) { ExTraceGlobals.GeneralTracer.TraceDebug(0L, "Failed to update the process security descriptor with TOKEN_READ. The result is the managed debugger may fail to attach."); } Program.main.Run(args); Program.Exit(Program.main.immediateRetryAfterExit ? 200 : 0); }
internal static void UpdateSearchObject(IDiscoverySearchDataProvider dataProvider, DiscoverySearchBase searchObject) { ExWatson.SendReportOnUnhandledException(delegate() { try { GrayException.MapAndReportGrayExceptions(delegate() { dataProvider.CreateOrUpdate <DiscoverySearchBase>(searchObject); }); } catch (DataSourceOperationException ex) { ExTraceGlobals.SearchTracer.TraceError <string, string>(0L, "UpdateSearchObject:Update Search failed for {0}. Root cause: {1}", searchObject.Name, ex.ToString()); SearchEventLogger.Instance.LogDiscoverySearchTaskErrorEvent(searchObject.Name, dataProvider.OrganizationId.ToString(), ex); } catch (GrayException ex2) { ExTraceGlobals.SearchTracer.TraceError <GrayException>(0L, "UpdateSearchObject: GrayException {0} is thrown", ex2); SearchEventLogger.Instance.LogDiscoverySearchTaskErrorEvent(searchObject.Name, dataProvider.OrganizationId.ToString(), ex2); } }, delegate(object exception) { ExTraceGlobals.SearchTracer.TraceError(0L, "UpdateSearchObject: Unhandled exception {0}", new object[] { exception }); SearchEventLogger.Instance.LogDiscoverySearchTaskErrorEvent(searchObject.Name, dataProvider.OrganizationId.ToString(), exception.ToString()); return(!(exception is GrayException)); }); }
// Token: 0x06007276 RID: 29302 RVA: 0x0017B2BC File Offset: 0x001794BC private CostHandle(Budget budget, Action <CostHandle> releaseAction, string description, TimeSpan preCharge) { if (budget == null) { throw new ArgumentNullException("budget"); } if (string.IsNullOrEmpty(description)) { ExWatson.SendReport(new ArgumentNullException("cost handle description is null or empty"), ReportOptions.DoNotCollectDumps | ReportOptions.DeepStackTraceHash, null); } if (preCharge < TimeSpan.Zero) { throw new ArgumentException("preCharge cannot be a negative timespan", "preCharge"); } this.Budget = budget; this.Key = Interlocked.Increment(ref CostHandle.nextKey); this.StartTime = TimeProvider.UtcNow - preCharge; this.PreCharge = preCharge; this.ReleaseAction = releaseAction; this.Budget.AddOutstandingAction(this); this.DisposedByThread = -1; this.DisposedAt = DateTime.MinValue; this.Description = description; this.MaxLiveTime = Budget.GetMaxActionTime(this.CostType); }
// Token: 0x0600031F RID: 799 RVA: 0x0000D79C File Offset: 0x0000B99C public static void AssertOrWatson(bool condition, string formatString, params object[] parameters) { if (condition) { return; } StringBuilder stringBuilder = new StringBuilder("ASSERT_WATSON: "); if (formatString != null) { if (parameters != null) { stringBuilder.AppendFormat(CultureInfo.InvariantCulture, formatString, parameters); } else { stringBuilder.Append(formatString); } } string text = stringBuilder.ToString(); ExTraceGlobals.ReplayApiTracer.TraceError <string>(0L, "AssertOrWatson: Sending Watson report. {0}", text); Exception exception = null; try { throw new ExAssertException(text); } catch (ExAssertException ex) { exception = ex; } ExWatson.SendReport(exception, ReportOptions.None, "AssertOrWatson"); }
internal void Process(HttpContext context) { ExTraceGlobals.WebHealthTracer.TraceDebug((long)this.GetHashCode(), "ExWebTimeoutReportHandler::ProcessHealth()"); try { if (ExMonitoringRequestTracker.Instance.IsKnownMonitoringRequest(context.Request)) { context.Response.StatusCode = 200; } else { context.Response.StatusCode = 403; } } catch (Exception ex) { Exception ex2; Exception ex = ex2; ExTraceGlobals.WebHealthTracer.TraceError <Exception>((long)this.GetHashCode(), "ExWebTimeoutReportHandler::Process encountered error {0}", ex); ThreadPool.QueueUserWorkItem(delegate(object o) { ExWatson.SendReport(ex, ReportOptions.DoNotCollectDumps | ReportOptions.DoNotFreezeThreads, string.Empty); }); } }
private void ForwardKnownExceptions(Action operation, Func <Exception, bool> ignoreExceptionOperation = null) { Exception failure = null; try { CommonUtils.CatchKnownExceptions(operation, delegate(Exception f) { failure = f; }); } catch (Exception ex) { MrsTracer.Service.Error("Unhandled exception in MRS:\n{0}\n{1}", new object[] { CommonUtils.FullExceptionMessage(ex), ex.StackTrace }); ExWatson.SendReport(ex); throw; } if (failure != null && (ignoreExceptionOperation == null || !ignoreExceptionOperation(failure))) { MailboxReplicationServiceFault.Throw(failure); } }
private void reportButton_Click(object sender, EventArgs e) { using (new ControlWaitCursor(this)) { ExWatson.SendReport(this.Exception); } }
internal static bool CatchNonFatalExceptions(Action action, string diagnosticsDataToLog = null) { bool result = false; try { action(); } catch (Exception ex) { if (ex is OutOfMemoryException || ex is StackOverflowException || ex is ThreadAbortException) { throw; } result = true; diagnosticsDataToLog = (diagnosticsDataToLog ?? string.Empty); if (!(ex is StoragePermanentException) && !(ex is StorageTransientException)) { ReportOptions options = ActivityLoggingConfig.Instance.IsDumpCollectionEnabled ? ReportOptions.None : ReportOptions.DoNotCollectDumps; ExWatson.SendReport(ex, options, diagnosticsDataToLog); } InferenceDiagnosticsLog.Log("CatchNonFatalExceptions", new List <string> { diagnosticsDataToLog, ex.ToString() }); } return(result); }
public void DisposePendingNotificationClientRequest() { if (base.OwaContext.UserContext == null) { return; } this.pendingManager = base.OwaContext.UserContext.PendingRequestManager; object parameter = base.GetParameter("Fn"); if (parameter != null) { bool flag = (bool)parameter; } int num = 0; try { base.UserContext.DangerousBeginUnlockedAction(false, out num); if (num != 1) { ExWatson.SendReport(new InvalidOperationException("Thread held more than 1 lock in DisposePendingNotificationClientRequest method."), ReportOptions.None, null); } bool flag2 = this.pendingManager.HandleFinishRequestFromClient(); HttpResponse httpResponse = base.OwaContext.HttpContext.Response; httpResponse.Write("var syncFnshRq = "); httpResponse.Write(flag2 ? "1" : "0"); httpResponse.AppendHeader("X-OWA-EventResult", "0"); Utilities.MakePageNoCacheNoStore(httpResponse); httpResponse.ContentType = Utilities.GetContentTypeString(base.ResponseContentType); } finally { base.UserContext.DangerousEndUnlockedAction(false, num); } }
internal static void SendInstantMessageWatsonReport(IUserContext userContext, Exception exception) { Microsoft.Exchange.Clients.Owa.Server.LyncIMLogging.ExTraceGlobals.InstantMessagingTracer.TraceDebug(0L, "Exception: Type: {0} Error: {1}.", new object[] { exception.GetType(), exception.Message }); if (Globals.SendWatsonReports) { Microsoft.Exchange.Clients.Owa.Server.LyncIMLogging.ExTraceGlobals.InstantMessagingTracer.TraceDebug(0L, "Sending watson report"); ReportOptions options = (exception is AccessViolationException || exception is InvalidProgramException || exception is TypeInitializationException) ? ReportOptions.ReportTerminateAfterSend : ReportOptions.None; ExWatson.AddExtraData(InstantMessageUtilities.GetExtraWatsonData(userContext)); ExWatson.SendReport(exception, options, null); } if (exception is AccessViolationException) { Microsoft.Exchange.Clients.Owa.Server.LyncIMLogging.ExTraceGlobals.InstantMessagingTracer.TraceDebug(0L, "Shutting down OWA due to unrecoverable exception"); ErrorHandlerUtilities.TerminateProcess(); return; } if ((exception is InvalidProgramException || exception is TypeInitializationException) && Interlocked.Exchange(ref InstantMessageUtilities.queuedDelayedRestart, 1) == 0) { new Thread(new ThreadStart(InstantMessageUtilities.DelayedRestartUponUnexecutableCode)).Start(); } }
internal static void UserContextRemovedCallback(string key, object value, CacheItemRemovedReason reason) { try { } finally { try { UserContextManager.UserContextCacheWrapper userContextCacheWrapper = value as UserContextManager.UserContextCacheWrapper; if (userContextCacheWrapper.UserContext != null) { ExTraceGlobals.UserContextTracer.TraceDebug <string, UserContext, int>(0L, "Removing user context from cache, Key={0}, User context instance={1}, Reason={2}", key, userContextCacheWrapper.UserContext, (int)reason); UserContextManager.TerminateSession(userContextCacheWrapper.UserContext, reason); } } catch (ThreadAbortException) { } catch (Exception exception) { if (Globals.SendWatsonReports) { ExTraceGlobals.CoreTracer.TraceDebug(0L, "Sending watson report"); ExWatson.SendReport(exception, ReportOptions.None, null); } } } }
public static void FailFast(string message, bool alwaysTerminate) { bool flag = ExDiagnostics.FailFastMode != FailFastMode.Exception && ExDiagnostics.FailFastMode != FailFastMode.Test; flag = (flag || alwaysTerminate); try { ExDiagnostics.failFastEventHandlers(flag); } catch { } if (ExDiagnostics.FailFastMode == FailFastMode.Test && !flag) { throw new TestFailFastException(message); } FailFastException ex = new FailFastException(message, new StackTrace(1, true).ToString()); ExWatson.SendReport(ex); if (flag) { Environment.Exit(1); return; } throw ex; }
public static CancelableAsyncCallback WrapCancellableCallbackWithUnhandledExceptionHandlerAndUpdatePoisonContext(CancelableAsyncCallback callback) { if (callback == null) { return(null); } return(delegate(ICancelableAsyncResult asyncResult) { RightsManagementAsyncResult asyncResultRM = null; if (asyncResult != null && asyncResult.AsyncState != null) { asyncResultRM = (asyncResult.AsyncState as RightsManagementAsyncResult); } try { if (asyncResultRM != null) { asyncResultRM.InvokeSaveContextCallback(); } callback(asyncResult); } catch (Exception exception) { ExWatson.SendReportAndCrashOnAnotherThread(exception, ReportOptions.None, delegate(Exception param0, int param1) { if (asyncResultRM != null) { asyncResultRM.InvokeSaveContextCallback(); } }, null); throw; } }); }
protected bool SendWatsonForAssistantProcess(Exception e, bool killProcessAfterWatson) { bool result; using (Process mailboxAssistantProcess = this.GetMailboxAssistantProcess(this.ExchangeServer.Fqdn)) { if (mailboxAssistantProcess == null) { result = false; } else { bool flag = false; if (this.SendCrashDump) { this.crashDumpCount++; ExWatson.SendHangWatsonReport(e, mailboxAssistantProcess); flag = true; } if (killProcessAfterWatson) { this.ForceKillAssistantService(mailboxAssistantProcess); } result = flag; } } return(result); }
internal override object this[PropertyDefinition propertyDefinition] { get { object result; try { result = base[propertyDefinition]; } catch (ArgumentException) { ExWatson.AddExtraData(string.Format("\r\nthis.Identity = {0}\r\nthis.ObjectState = {1}\r\nthis.IsReadOnly = {2}\r\nthis.session = {3}\r\nthis.session.ReadOnly = {4}\r\nthis.propertyBag.Keys.Count = {5}\r\nthis.ObjectSchema.AllProperties.Count = {6}\r\n", new object[] { this.Identity, base.ObjectState, base.IsReadOnly, (this.m_Session == null) ? "<null>" : this.m_Session.ToString(), (this.m_Session == null) ? "<null>" : this.m_Session.ReadOnly.ToString(), this.propertyBag.Keys.Count, this.Schema.AllProperties.Count })); ExWatson.AddExtraData("this.propertyBag.Keys = " + ADObject.CollectionToString(this.propertyBag.Keys)); ExWatson.AddExtraData("this.Schema.AllProperties = " + ADObject.CollectionToString(this.Schema.AllProperties)); throw; } return(result); } set { base[propertyDefinition] = value; } }
private static void WatsonThreadProc(object stateInfo) { Thread.CurrentThread.IsBackground = false; DisposeTrackerObject <T> .WatsonThreadStateInfo watsonThreadStateInfo = (DisposeTrackerObject <T> .WatsonThreadStateInfo)stateInfo; string text = DisposeTrackerObject <T> .StackTraceToString(watsonThreadStateInfo.StackTrace); if (text != null) { ObjectNotDisposedException <T> exception = new ObjectNotDisposedException <T>(text, watsonThreadStateInfo.StackTraceWasReset); try { if (watsonThreadStateInfo.ExtraDataList != null) { foreach (WatsonExtraDataReportAction action in watsonThreadStateInfo.ExtraDataList) { ExWatson.RegisterReportAction(action, WatsonActionScope.Thread); } } ExWatson.HandleException(new UnhandledExceptionEventArgs(exception, DisposeTrackerOptions.TerminateOnReport), ReportOptions.DoNotCollectDumps | ReportOptions.DeepStackTraceHash | ReportOptions.DoNotLogProcessAndThreadIds | ReportOptions.DoNotFreezeThreads); } finally { if (watsonThreadStateInfo.ExtraDataList != null) { foreach (WatsonExtraDataReportAction action2 in watsonThreadStateInfo.ExtraDataList) { ExWatson.UnregisterReportAction(action2, WatsonActionScope.Thread); } } } } Thread.CurrentThread.IsBackground = true; }
public override byte[] Notify(int version, int type, byte[] inputParameterBytes) { byte[] result2; try { using (new Timer(new TimerCallback(RpcServerWrapper.CrashOnCallTimeout), Thread.CurrentThread, RpcServerWrapper.notifyRequestTimeout, TimeSpan.FromMilliseconds(-1.0))) { WorkItemBase workItem = WorkItemBase.Deserialize(inputParameterBytes); SyncNotificationResult result = null; try { WorkItemBase workItem2 = SyncManager.EnqueueWorkItem(workItem); result = new SyncNotificationResult(UnifiedPolicyNotificationFactory.Create(workItem2, new ADObjectId())); } catch (SyncAgentExceptionBase error) { result = new SyncNotificationResult(error); } NotificationRpcOutParameters notificationRpcOutParameters = new NotificationRpcOutParameters(result); result2 = notificationRpcOutParameters.Serialize(); } } catch (Exception ex) { ExWatson.SendReport(ex, ReportOptions.None, null); NotificationRpcOutParameters notificationRpcOutParameters = new NotificationRpcOutParameters(new SyncNotificationResult(ex)); result2 = notificationRpcOutParameters.Serialize(); } return(result2); }
// Token: 0x06000009 RID: 9 RVA: 0x000026C8 File Offset: 0x000008C8 private static void LogStage(MailboxTransportDeliveryService.Stage stage) { MailboxTransportDeliveryService.stage = stage; MailboxTransportDeliveryService.logData[0] = new KeyValuePair <string, object>("Stage", stage.ToString()); CommonDiagnosticsLog.Instance.LogEvent(CommonDiagnosticsLog.Source.MailboxDeliveryService, MailboxTransportDeliveryService.logData); ExWatson.AddExtraData(string.Format("{0:u}: Stage={1}", DateTime.UtcNow, stage)); }
public void SendReportOnUnhandledException(Action action) { ExWatson.SendReportOnUnhandledException(delegate() { action(); }); }
// Token: 0x0600000A RID: 10 RVA: 0x00002730 File Offset: 0x00000930 private static void MainUnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs eventArgs) { MailboxTransportDeliveryService.diag.TraceDebug(0L, "MainUnhandledExceptionHandler"); if (MailboxTransportDeliveryService.isExiting) { Environment.Exit(0); } if (Components.IsActive) { Components.OnUnhandledException((Exception)eventArgs.ExceptionObject); PoisonMessage.SavePoisonContext((Exception)eventArgs.ExceptionObject); DeliveryConfiguration.Instance.PoisonHandler.SavePoisonContext(); MailboxTransportEventLogger.LogEvent(MSExchangeDeliveryEventLogConstants.Tuple_DeliveryPoisonMessage, null, new string[] { PoisonHandler <DeliveryPoisonContext> .Context.ToString(), eventArgs.ExceptionObject.ToString() }); } int num = Interlocked.Exchange(ref MailboxTransportDeliveryService.busyUnhandledException, 1); if (num == 1) { return; } ExWatson.HandleException(sender, eventArgs); MailboxTransportDeliveryService.diag.TraceDebug(0L, "Done processing unhandled exception. Return to CLR."); }
private static void CrashOnCallTimeout(object state) { Thread thread = (Thread)state; Exception exception = new TimeoutException(string.Format("RpcServerWrapper.EnqueueRequest call timed out after {0} on thread {1}", RpcServerWrapper.enqueueRequestTimeout, (thread != null) ? thread.ManagedThreadId : -1)); ExWatson.SendReportAndCrashOnAnotherThread(exception); }
public override byte[] AcquireTenantLicenses(int version, byte[] inputParameterBytes) { XmlNode[] rac = null; XmlNode[] clc = null; AcquireTenantLicensesRpcParameters acquireTenantLicensesRpcParameters = null; byte[] result; try { acquireTenantLicensesRpcParameters = new AcquireTenantLicensesRpcParameters(inputParameterBytes); ServerManager.AcquireTenantLicenses(acquireTenantLicensesRpcParameters.ClientManagerContext, acquireTenantLicensesRpcParameters.MachineCertificateChain, acquireTenantLicensesRpcParameters.Identity, out rac, out clc); AcquireTenantLicensesRpcResults acquireTenantLicensesRpcResults = new AcquireTenantLicensesRpcResults(new OverallRpcResult(null), rac, clc); result = acquireTenantLicensesRpcResults.Serialize(); } catch (Exception ex) { if (!(ex is RightsManagementServerException)) { ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.RpcServerWrapper, ServerManagerLog.EventType.Error, (acquireTenantLicensesRpcParameters != null) ? acquireTenantLicensesRpcParameters.ClientManagerContext : null, string.Format("ServerManager.AcquireTenantLicenses has thrown unhandled exception {0}", ServerManagerLog.GetExceptionLogString(ex, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException))); ExWatson.SendReportAndCrashOnAnotherThread(ex); } AcquireTenantLicensesRpcResults acquireTenantLicensesRpcResults2 = new AcquireTenantLicensesRpcResults(new OverallRpcResult(ex), Array <XmlNode> .Empty, Array <XmlNode> .Empty); result = acquireTenantLicensesRpcResults2.Serialize(); } return(result); }
private static void DoWithExtraWatsonData(Action action) { Command currentCommand = Command.CurrentCommand; string text = null; if (currentCommand != null && GlobalSettings.IncludeRequestInWatson) { text = "Request: \r\n" + currentCommand.Request.GetHeadersAsString(); if (currentCommand.Request.XmlDocument != null && currentCommand.Request.XmlDocument.DocumentElement != null) { text = text + "\r\n" + currentCommand.Request.XmlDocument.DocumentElement.OuterXml; } else { text += "\r\n[No Body]"; } } WatsonExtraDataReportAction watsonExtraDataReportAction = string.IsNullOrEmpty(text) ? null : new WatsonExtraDataReportAction(text); if (watsonExtraDataReportAction != null) { ExWatson.RegisterReportAction(watsonExtraDataReportAction, WatsonActionScope.Thread); } try { action(); } finally { if (watsonExtraDataReportAction != null) { ExWatson.UnregisterReportAction(watsonExtraDataReportAction, WatsonActionScope.Thread); } } }
public override byte[] GetTenantActiveCryptoMode(int version, byte[] inputParameterBytes) { GetTenantActiveCryptoModeRpcParameters getTenantActiveCryptoModeRpcParameters = null; byte[] result; try { getTenantActiveCryptoModeRpcParameters = new GetTenantActiveCryptoModeRpcParameters(inputParameterBytes); int tenantActiveCryptoMode = ServerManager.GetTenantActiveCryptoMode(getTenantActiveCryptoModeRpcParameters.ClientManagerContext); ActiveCryptoModeResult[] originalResults = new ActiveCryptoModeResult[] { new ActiveCryptoModeResult(tenantActiveCryptoMode, null) }; GetTenantActiveCryptoModeRpcResults getTenantActiveCryptoModeRpcResults = new GetTenantActiveCryptoModeRpcResults(new OverallRpcResult(null), originalResults); result = getTenantActiveCryptoModeRpcResults.Serialize(); } catch (Exception ex) { if (!(ex is RightsManagementServerException)) { ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.RpcServerWrapper, ServerManagerLog.EventType.Error, (getTenantActiveCryptoModeRpcParameters != null) ? getTenantActiveCryptoModeRpcParameters.ClientManagerContext : null, string.Format("ServerManager.GetTenantActiveCryptoMode has thrown unhandled exception {0}", ServerManagerLog.GetExceptionLogString(ex, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException))); ExWatson.SendReportAndCrashOnAnotherThread(ex); } GetTenantActiveCryptoModeRpcResults getTenantActiveCryptoModeRpcResults2 = new GetTenantActiveCryptoModeRpcResults(new OverallRpcResult(ex), Array <ActiveCryptoModeResult> .Empty); result = getTenantActiveCryptoModeRpcResults2.Serialize(); } return(result); }
// Token: 0x0600025A RID: 602 RVA: 0x0000FCC4 File Offset: 0x0000DEC4 private void Application_Start(object sender, EventArgs e) { Globals.InitializeMultiPerfCounterInstance("AutoDisc"); Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug <string>((long)this.GetHashCode(), "[Application_Start()] Privileges.RemoveAllExcept(,,\"{0}\");", "MSExchangeAutodiscoverAppPool"); string[] privilegesToKeep = new string[] { "SeAuditPrivilege", "SeChangeNotifyPrivilege", "SeCreateGlobalPrivilege" }; int num = Privileges.RemoveAllExcept(privilegesToKeep, "MSExchangeAutodiscoverAppPool"); if (num != 0) { Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceError <TimeSpan, int>((long)this.GetHashCode(), "[Application_Start()] 'Failed to remove privileges, exiting. Time=\"{0}\",win32Error=\"{1}\"'", ExDateTime.Now.TimeOfDay, num); Environment.Exit(num); } PerformanceCounters.Initialize(); ExchangeDiagnosticsHelper.RegisterDiagnosticsComponents(); Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug((long)this.GetHashCode(), "[Application_Start()] 'ApplicationStarted'"); Common.EventLog.LogEvent(AutodiscoverEventLogConstants.Tuple_InfoWebApplicationStart, Common.PeriodicKey, new object[0]); string text = ExEnvironment.IsTest ? "E12" : "E12IIS"; ExWatson.Register(text); Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FaultInjectionTracer.RegisterExceptionInjectionCallback(new ExceptionInjectionCallback(FaultInjection.Callback)); Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug <string, string>((long)this.GetHashCode(), "[Application_Start()] ExWatson.Register(\"{0}\");AppName=\"{1}\";", text, ExWatson.AppName); }
public static object GetSerializationData(PSObject psObject) { ExTraceGlobals.SerializationTracer.TraceFunction <PSObject>(0L, "SerializationTypeConvertor.GetSerializationData({0})", psObject); byte[] result = null; try { using (MemoryStream memoryStream = new MemoryStream()) { BinaryFormatter binaryFormatter = ExchangeBinaryFormatterFactory.CreateBinaryFormatter(null); binaryFormatter.Serialize(memoryStream, psObject.BaseObject); result = memoryStream.ToArray(); } } catch (Exception arg) { ExTraceGlobals.SerializationTracer.TraceDebug <Exception>(0L, "Serialization Failed. Error = {0}", arg); if (psObject != null && psObject.BaseObject != null) { ExWatson.AddExtraData("Object Type: " + psObject.BaseObject.GetType().ToString()); ExWatson.AddExtraData("Object String: " + psObject.BaseObject.ToString()); ExWatson.AddExtraData("Handler StackTrace: " + Environment.StackTrace); } throw; } return(result); }
public void Init(HttpApplication application) { ExWatson.Register("E12"); application.Error += ErrorHandlingModule.Application_Error; application.EndRequest += ErrorHandlingModule.Application_EndRequest; application.PostAcquireRequestState += ErrorHandlingModule.Application_PostAcquireRequestState; }
private void GetMailTipsWorker(object state) { MailTipsState mailTipsState = null; try { mailTipsState = (MailTipsState)state; ExTraceGlobals.CoreCallTracer.TraceDebug((long)this.GetHashCode(), "MailTipsNotificationHandler.GetMailTipsWorker"); this.GetMailTipsInBatches(mailTipsState); this.mailTipsNotifier.AddToPayload(mailTipsState); this.mailTipsNotifier.PickupData(); } catch (Exception ex) { ExTraceGlobals.CoreTracer.TraceError <Exception>((long)this.GetHashCode(), "Generic exception caught during GetMailTipsWorker call: {0}", ex); if (Globals.SendWatsonReports) { ExTraceGlobals.CoreTracer.TraceError((long)this.GetHashCode(), "Sending watson report."); ExWatson.AddExtraData(this.GetExtraWatsonData(mailTipsState)); ExWatson.SendReport(ex, ReportOptions.None, null); } } finally { Interlocked.Decrement(ref this.concurrentRequestCount); ExTraceGlobals.CoreCallTracer.TraceError <string, int>((long)this.GetHashCode(), "MailTipsNotificationHandler.GetMailTipsWorker, {0} concurrent requests count decremented to {1}", this.primarySmtpAddress, this.concurrentRequestCount); } }
internal static void ExWatsonWrappedCall(ExWatson.MethodDelegate methodDelegate, ExWatson.MethodDelegate finallyDelegate) { ExWatson.SendReportOnUnhandledException(delegate() { try { GrayException.MapAndReportGrayExceptions(delegate() { methodDelegate(); }); } catch (GrayException arg) { SearchUtils.Tracer.TraceError <GrayException>(0L, "GrayException {0} is thrown", arg); } finally { finallyDelegate(); } }, delegate(object exception) { SearchUtils.Tracer.TraceError(0L, "ExWatsonWrappedCall: Unhandled exception {0}", new object[] { exception }); return(!(exception is GrayException)); }); }
private void ExecuteAsyncRequest(HttpWebRequest request) { try { ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "[PreloadSessionDataRequestCreator::ExecuteAsyncRequest]: Executing preload request"); LiveIdAuthenticationCounters.TotalSessionDataPreloadRequestsSent.Increment(); using (request.GetResponse()) { } } catch (Exception ex) { if (!(ex is HttpException) && !(ex is WebException)) { ExWatson.SendReport(ex, ReportOptions.DoNotFreezeThreads, null); } LiveIdAuthenticationCounters.TotalSessionDataPreloadRequestsFailed.Increment(); ExTraceGlobals.CoreTracer.TraceError <Exception>(0L, "[PreloadSessionDataRequestCreator::ExecuteAsyncRequest]: General exception {0}.", ex); } finally { try { request.Abort(); } catch { } } }