internal override void OnEndRequest(OwaContext owaContext)
 {
     try
     {
     }
     finally
     {
         UserContext userContext = owaContext.UserContext;
         bool        flag        = false;
         try
         {
             if (owaContext.UserContext != null && !owaContext.UserContext.LockedByCurrentThread())
             {
                 if (!owaContext.IsAsyncRequest && !owaContext.HandledCriticalError && !owaContext.UserContext.LastLockRequestFailed)
                 {
                     ExWatson.SendReport(new InvalidOperationException("Entered OwaRequestEventInspector without the UserContext lock when we should have had it."), ReportOptions.None, null);
                 }
                 owaContext.UserContext.Lock();
             }
             try
             {
                 try
                 {
                     if (userContext != null && userContext.State == UserContextState.Active)
                     {
                         userContext.CleanupOnEndRequest();
                         owaContext.ExitLatencyDetectionContext();
                         OwaPerformanceLogger.LogPerformanceStatistics(userContext);
                         OwaPerformanceLogger.TracePerformance(userContext);
                         this.AppendServerHeaders(owaContext);
                         if (owaContext.SearchPerformanceData != null)
                         {
                             owaContext.SearchPerformanceData.RefreshEnd();
                             owaContext.SearchPerformanceData.WriteLog();
                         }
                     }
                 }
                 finally
                 {
                     owaContext.DisposeObjectsOnEndRequest();
                 }
             }
             catch (OwaLockTimeoutException)
             {
                 flag = true;
             }
             finally
             {
                 if (userContext != null && !flag)
                 {
                     if (owaContext.IgnoreUnlockForcefully)
                     {
                         userContext.Unlock();
                     }
                     else
                     {
                         userContext.UnlockForcefully();
                     }
                 }
             }
         }
         finally
         {
             owaContext.TryReleaseBudgetAndStopTiming();
             if (owaContext.PreFormActionData != null && owaContext.PreFormActionData is IDisposable)
             {
                 ((IDisposable)owaContext.PreFormActionData).Dispose();
                 owaContext.PreFormActionData = null;
             }
         }
     }
 }
        internal static void LogPerformanceStatistics(UserContext userContext)
        {
            OwaContext owaContext = OwaContext.Current;

            if (userContext.IsClientSideDataCollectingEnabled)
            {
                string str = "&v=";
                owaContext.HttpContext.Response.AppendToLog(str + Globals.ApplicationVersion);
            }
            StringBuilder stringBuilder = new StringBuilder(OwaPerformanceLogger.EstimatedIISStringBuilderCapacity);
            long          requestLatencyMilliseconds = owaContext.RequestLatencyMilliseconds;

            if (userContext.HasValidMailboxSession())
            {
                ExchangePrincipal exchangePrincipal = userContext.ExchangePrincipal;
                if (exchangePrincipal != null)
                {
                    string serverFqdn = exchangePrincipal.MailboxInfo.Location.ServerFqdn;
                    if (serverFqdn != null)
                    {
                        stringBuilder.Append("&mbx=").Append(serverFqdn);
                    }
                }
            }
            stringBuilder.Append("&sessionId=").Append(userContext.Key.UserContextId);
            stringBuilder.Append("&prfltncy=").Append(requestLatencyMilliseconds);
            uint num  = 0U;
            long num2 = 0L;
            uint num3 = 0U;
            long num4 = 0L;

            if (owaContext.RequestExecution == RequestExecution.Local)
            {
                TaskPerformanceData rpcData = owaContext.RpcData;
                if (rpcData != null && rpcData.End != PerformanceData.Zero)
                {
                    PerformanceData difference = rpcData.Difference;
                    num  = difference.Count;
                    num2 = (long)difference.Milliseconds;
                    PerformanceData ewsRpcData = owaContext.EwsRpcData;
                    if (ewsRpcData != PerformanceData.Zero)
                    {
                        num  += ewsRpcData.Count;
                        num2 += (long)ewsRpcData.Milliseconds;
                    }
                    OwaPerformanceLogger.rpcLogger.AppendIISLogsEntry(stringBuilder, num, num2);
                }
                TaskPerformanceData ldapData = owaContext.LdapData;
                if (ldapData != null)
                {
                    PerformanceData difference2 = ldapData.Difference;
                    num3 = difference2.Count;
                    num4 = (long)difference2.Milliseconds;
                    PerformanceData ewsLdapData = owaContext.EwsLdapData;
                    if (ewsLdapData != PerformanceData.Zero)
                    {
                        num3 += ewsLdapData.Count;
                        num4 += (long)ewsLdapData.Milliseconds;
                    }
                    OwaPerformanceLogger.ldapLogger.AppendIISLogsEntry(stringBuilder, num3, num4);
                }
                OwaPerformanceLogger.AppendLatencyHeaders(num2, num4, requestLatencyMilliseconds);
                OwaPerformanceLogger.availabilityLogger.AppendIISLogsEntry(stringBuilder, owaContext.AvailabilityQueryCount, owaContext.AvailabilityQueryLatency);
            }
            owaContext.HttpContext.Response.AppendToLog(stringBuilder.ToString());
            if (Globals.CollectPerRequestPerformanceStats)
            {
                StringBuilder stringBuilder2 = new StringBuilder(OwaPerformanceLogger.EstimatedBreadcrumbStringBuilderCapacity);
                stringBuilder2.Append("Total: ").Append(requestLatencyMilliseconds).Append(" ms");
                owaContext.OwaPerformanceData.TotalLatency       = requestLatencyMilliseconds;
                owaContext.OwaPerformanceData.KilobytesAllocated = (long)((ulong)owaContext.MemoryData.Difference.Count);
                if (owaContext.HasTrustworthyRequestCpuLatency)
                {
                    stringBuilder2.Append(" CPU: ");
                    stringBuilder2.Append(owaContext.RequestCpuLatencyMilliseconds).Append(" ms");
                }
                if (owaContext.RequestExecution == RequestExecution.Local)
                {
                    owaContext.OwaPerformanceData.RpcCount    = num;
                    owaContext.OwaPerformanceData.RpcLatency  = (int)num2;
                    owaContext.OwaPerformanceData.LdapCount   = num3;
                    owaContext.OwaPerformanceData.LdapLatency = (int)num4;
                    OwaPerformanceLogger.rpcLogger.AppendBreadcrumbEntry(stringBuilder2, num, num2);
                    OwaPerformanceLogger.ldapLogger.AppendBreadcrumbEntry(stringBuilder2, num3, num4);
                    OwaPerformanceLogger.availabilityLogger.AppendBreadcrumbEntry(stringBuilder2, owaContext.AvailabilityQueryCount, owaContext.AvailabilityQueryLatency);
                    if (!string.IsNullOrEmpty(owaContext.EwsPerformanceHeader))
                    {
                        owaContext.OwaPerformanceData.TraceOther(owaContext.EwsPerformanceHeader);
                    }
                }
                owaContext.UserContext.PerformanceConsoleNotifier.UpdatePerformanceData(owaContext.OwaPerformanceData, true);
                userContext.LogBreadcrumb(stringBuilder2.ToString());
            }
        }