internal static string GetDiagnosticsInfo(HttpContext context)
{
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(context);
Guid guid = Guid.Empty;
IActivityScope activityScope = null;
if (current != null)
{
guid = current.ActivityId;
activityScope = current.ActivityScope;
}
string text = string.Format("[ClientAccessServer={0},BackEndServer={1},RequestId={2},TimeStamp={3}] ", new object[]
{
Environment.MachineName,
(activityScope == null) ? "UnKown" : activityScope.GetProperty(HttpProxyMetadata.TargetServer),
guid,
DateTime.UtcNow
});
string text2 = string.Empty;
if (context != null)
{
text2 = WinRMInfo.GetFailureCategoryInfo(context);
}
if (!string.IsNullOrEmpty(text2))
{
text += string.Format("[FailureCategory={0}] ", text2);
}
ExTraceGlobals.VerboseTracer.TraceDebug <string>(0L, "[WinRMHelper::GetDiagnosticsInfo] diagnosticsInfo = {0}.", text);
return(text);
}
protected override byte[] GetUpdatedBufferToSend(ArraySegment <byte> buffer)
{
try
{
byte[] result;
string text;
if (this.TryGetUpdatedBufferToSend(buffer, out result, out text))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[RpsOutDataResponseStreamProxy::GetUpdatedBufferToSend] Context={0}, Buffer updated.", base.RequestContext.TraceContext);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.RequestContext.Logger, "FriendlyError", "StreamProxy");
return(result);
}
if (text != null)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.RequestContext.Logger, "FriendlyError", text);
}
}
catch (Exception ex)
{
Diagnostics.ReportException(ex, FrontEndHttpProxyEventLogConstants.Tuple_InternalServerError, null, "Exception from RpsOutDataResponseStreamProxy::GetUpdatedBufferToSend event: {0}");
RequestDetailsLogger logger = base.RequestContext.Logger;
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericError(logger, "GetUpdatedBufferToSendException", ex.ToString());
}
return(base.GetUpdatedBufferToSend(buffer));
}
// Token: 0x06000731 RID: 1841 RVA: 0x0002A46C File Offset: 0x0002866C
protected override void OnPostAuthorizeInternal(HttpApplication httpApplication)
{
if (ExTraceGlobals.HttpModuleTracer.IsTraceEnabled(7))
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[RpsHttpProxyModule::OnPostAuthorizeInternal] Enter");
}
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpApplication.Context);
if (current != null)
{
Dictionary <Enum, string> authValues = ServiceCommonMetadataPublisher.GetAuthValues(new HttpContextWrapper(httpApplication.Context), false);
if (authValues.ContainsKey(8))
{
RequestMonitor.Instance.Log(current.ActivityId, 3, authValues[8]);
}
if (authValues.ContainsKey(5))
{
RequestMonitor.Instance.Log(current.ActivityId, 4, authValues[5]);
}
}
base.OnPostAuthorizeInternal(httpApplication);
if (ExTraceGlobals.HttpModuleTracer.IsTraceEnabled(7))
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[RpsHttpProxyModule::OnPostAuthorizeInternal] Exit");
}
}
// Token: 0x060006FB RID: 1787 RVA: 0x000292BC File Offset: 0x000274BC
private WinRMInfo ParseWinRMInfo(Stream stream)
{
WinRMInfo winRMInfo;
string text;
if (new WinRMParser(base.TraceContext).TryParseStream(stream, out winRMInfo, out text))
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(base.Logger, 21, winRMInfo.Action);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.Logger, "CommandId", winRMInfo.CommandId);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.Logger, "SessionId", winRMInfo.SessionId);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.Logger, "ShellId", winRMInfo.ShellId);
if (!"http://schemas.microsoft.com/wbem/wsman/1/windows/shell/signal/terminate".Equals(winRMInfo.SignalCode, StringComparison.OrdinalIgnoreCase))
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.Logger, "SignalCode", winRMInfo.SignalCode);
}
}
else
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(base.Logger, 21, text);
}
return(winRMInfo);
}
protected override void OnBeginRequestInternal(HttpApplication httpApplication)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[RpsHttpProxyModule::OnBeginRequestInternal] Enter");
HttpContext context = httpApplication.Context;
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(context);
if (current != null)
{
RequestMonitor.Instance.RegisterRequest(current.ActivityId);
string text = context.Request.Headers["Authorization"];
byte[] bytes;
byte[] array;
if (!string.IsNullOrEmpty(text) && LiveIdBasicAuthModule.ParseCredentials(context, text, false, out bytes, out array))
{
string text2 = Encoding.UTF8.GetString(bytes).Trim();
SmtpAddress smtpAddress = new SmtpAddress(text2);
RequestMonitor.Instance.Log(current.ActivityId, RequestMonitorMetadata.AuthenticatedUser, text2);
RequestMonitor.Instance.Log(current.ActivityId, RequestMonitorMetadata.Organization, smtpAddress.Domain);
context.Items[Constants.WLIDMemberName] = text2;
ExTraceGlobals.HttpModuleTracer.TraceDebug <string>((long)this.GetHashCode(), "[RpsHttpProxyModule::OnBeginRequestInternal] LiveIdMember={0}", text2);
}
}
base.OnBeginRequestInternal(httpApplication);
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[RpsHttpProxyModule::OnBeginRequestInternal] Exit");
}
private void OnPostAuthorizeRequest(object sender, EventArgs e)
{
HttpApplication httpApplication = (HttpApplication)sender;
HttpContext httpContext = httpApplication.Context;
Diagnostics.SendWatsonReportOnUnhandledException(delegate()
{
if (Microsoft.Exchange.Diagnostics.Components.HttpProxy.ExTraceGlobals.VerboseTracer.IsTraceEnabled(TraceType.DebugTrace))
{
Microsoft.Exchange.Diagnostics.Components.HttpProxy.ExTraceGlobals.VerboseTracer.TraceDebug((long)this.GetHashCode(), "[ProxyModule::OnPostAuthorizeRequest]: Method {0}; Url {1}; Username {2}; Context {3};", new object[]
{
httpContext.Request.HttpMethod,
httpContext.Request.Url,
(httpContext.User == null) ? string.Empty : httpContext.User.Identity.GetSafeName(true),
httpContext.GetTraceContext()
});
}
this.OnPostAuthorizeInternal(httpApplication);
LatencyTracker latencyTracker = LatencyTracker.FromHttpContext(httpContext);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpContext), ServiceLatencyMetadata.HttpPipelineLatency, latencyTracker.GetCurrentLatency(LatencyTrackerKey.ProxyModuleLatency));
long currentLatency = latencyTracker.GetCurrentLatency(LatencyTrackerKey.AuthenticationLatency);
PerfCounters.UpdateMovingAveragePerformanceCounter(PerfCounters.HttpProxyCountersInstance.MovingAverageAuthenticationLatency, currentLatency);
latencyTracker.StartTracking(LatencyTrackerKey.ModuleToHandlerSwitchingLatency, false);
}, new Diagnostics.LastChanceExceptionHandler(RequestDetailsLogger.LastChanceExceptionHandler));
}
// Token: 0x06000715 RID: 1813 RVA: 0x0001595C File Offset: 0x00013B5C
internal void UseIfReady(RequestDetailsLogger logger, Stream responseStream, out bool used)
{
ExAssert.RetailAssert(responseStream != null, "responseStream is null");
used = false;
if (this.state != SessionDataCacheState.Obsolete)
{
bool flag = false;
RequestDetailsLogger.LogEvent(logger, SessionDataMetadata.SessionDataCacheFirstTimeRetriveveBegin);
this.InternalUseIfReady(responseStream, out used, out flag);
RequestDetailsLogger.LogEvent(logger, SessionDataMetadata.SessionDataCacheFirstTimeRetriveveEnd);
if (flag)
{
OwaSingleCounters.SessionDataCacheWaitedForPreload.Increment();
bool flag2 = this.signalEvent.WaitOne(5000);
if (!flag2)
{
OwaSingleCounters.SessionDataCacheWaitTimeout.Increment();
}
RequestDetailsLogger.LogEvent(logger, SessionDataMetadata.SessionDataCacheSecondTimeRetriveveBegin);
this.InternalUseIfReady(responseStream, out used, out flag);
RequestDetailsLogger.LogEvent(logger, SessionDataMetadata.SessionDataCacheSecondTimeRetriveveEnd);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(logger, SessionDataMetadata.SessionDataCacheWaitTimeOut, !flag2);
}
if (used)
{
OwaSingleCounters.SessionDataCacheUsed.Increment();
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(logger, SessionDataMetadata.SessionDataCacheUsed, used);
}
}
// Token: 0x0600025B RID: 603 RVA: 0x0000FDDC File Offset: 0x0000DFDC
private void Application_BeginRequest(object sender, EventArgs e)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .InitializeRequestLogger();
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.ActivityScope.UpdateFromMessage(HttpContext.Current.Request);
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.ActivityScope.SerializeTo(HttpContext.Current.Response);
string sourceCafeServer = CafeHelper.GetSourceCafeServer(HttpContext.Current.Request);
if (!string.IsNullOrEmpty(sourceCafeServer))
{
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.Set(AutoDiscoverMetadata.FrontEndServer, sourceCafeServer);
}
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceDebug <string, string>((long)this.GetHashCode(), "[Application_BeginRequest()] Request.Path=\"{0}\"; Request.PhysicalPath=\"{1}\";", base.Request.Path, base.Request.PhysicalPath);
int num = base.Request.Path.IndexOf('\\');
string fullPath = Path.GetFullPath(base.Request.PhysicalPath);
if (num >= 0 || fullPath != base.Request.PhysicalPath)
{
Microsoft.Exchange.Diagnostics.Components.Autodiscover.ExTraceGlobals.FrameworkTracer.TraceError <int, string>((long)this.GetHashCode(), "[Application_BeginRequest()] IndexOf('\\')={0};FullPath=\"{1}\"; // Throwing 404 HttpException", num, fullPath);
this.exception = new HttpException(404, string.Empty);
throw this.exception;
}
}
protected override void OnEndRequestInternal(HttpApplication httpApplication)
{
HttpRequest request = httpApplication.Context.Request;
HttpResponse response = httpApplication.Context.Response;
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpApplication.Context);
if (httpApplication.Context.Items[Constants.RequestCompletedHttpContextKeyName] == null && !UrlUtilities.IsIntegratedAuthUrl(request.Url) && !UrlUtilities.IsOwaMiniUrl(request.Url) && (response.StatusCode == 401 || (HttpProxyGlobals.ProtocolType == ProtocolType.Ecp && (response.StatusCode == 403 || response.StatusCode == 404))))
{
FbaModule.LogonReason reason = FbaModule.LogonReason.None;
if (request.Headers["Authorization"] != null)
{
reason = FbaModule.LogonReason.InvalidCredentials;
}
bool flag = request.Url.AbsolutePath.Equals("/owa/auth.owa", StringComparison.OrdinalIgnoreCase);
if (request.HttpMethod.Equals("GET", StringComparison.OrdinalIgnoreCase) || flag)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(current, "NoCookies", "302 - GET/E14AuthPost");
this.RedirectToFbaLogon(httpApplication, reason);
}
else if (request.HttpMethod.Equals("POST", StringComparison.OrdinalIgnoreCase))
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(current, "NoCookies", "440 - POST");
this.Send440Response(httpApplication, true);
}
else
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(current, "NoCookies", "440 - " + request.HttpMethod);
this.Send440Response(httpApplication, false);
}
}
base.OnEndRequestInternal(httpApplication);
}
// Token: 0x060006F3 RID: 1779 RVA: 0x00028E60 File Offset: 0x00027060
protected override void ExposeExceptionToClientResponse(Exception ex)
{
if (!WinRMHelper.FriendlyErrorEnabled.Value)
{
base.ExposeExceptionToClientResponse(ex);
return;
}
if (ex is WebException)
{
WebException ex2 = (WebException)ex;
if (WinRMHelper.IsPingRequest(ex2))
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::ExposeExceptionToClientResponse]: Context={0}, Ping found.", base.TraceContext);
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(base.Logger, 21, "Ping");
base.ClientResponse.Headers["X-RemotePS-Ping"] = "Ping";
return;
}
if (WinRMHelper.CouldBePingRequest(ex2))
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::ExposeExceptionToClientResponse]: Context={0}, Could be Ping request.", base.TraceContext);
}
base.ClientResponse.Headers["X-RemotePS-Ping"] = "Possible-Ping";
return;
}
if (ex2.Status != WebExceptionStatus.ProtocolError)
{
WinRMInfo.SetFailureCategoryInfo(base.ClientResponse.Headers, 3, ex2.Status.ToString());
}
if (ex2.Response != null)
{
string text = ex2.Response.Headers["X-BasicAuthToOAuthConversionDiagnostics"];
if (!string.IsNullOrWhiteSpace(text))
{
base.ClientResponse.Headers["X-BasicAuthToOAuthConversionDiagnostics"] = text + " ";
}
}
}
if (ex is HttpProxyException && !string.IsNullOrWhiteSpace(ex.Message) && !WinRMHelper.DiagnosticsInfoHasBeenWritten(base.ClientResponse.Headers))
{
WinRMInfo.SetFailureCategoryInfo(base.ClientResponse.Headers, 3, ex.GetType().Name);
string diagnosticsInfo = WinRMHelper.GetDiagnosticsInfo(base.HttpContext);
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <int, string>((long)this.GetHashCode(), "[RemotePowerShellProxyRequestHandler::ExposeExceptionToClientResponse]: Context={0}, Write Message {1} to client response.", base.TraceContext, ex.Message);
}
WinRMHelper.SetDiagnosticsInfoWrittenFlag(base.ClientResponse.Headers);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(base.Logger, "FriendlyError", "ExposeException");
base.ClientResponse.Write(diagnosticsInfo + ex.Message);
return;
}
base.ExposeExceptionToClientResponse(ex);
}
public static RequestDetailsLogger GetLogger(this HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException();
}
return(RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpContext));
}
// Token: 0x060026A7 RID: 9895 RVA: 0x0008C0E8 File Offset: 0x0008A2E8
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
string text = base.IsAppCacheEnabledClient ? "1" : "0";
base.Response.AppendToLog("&appcache=" + text);
RequestDetailsLogger getRequestDetailsLogger = OwaApplication.GetRequestDetailsLogger;
RequestDetailsLoggerBase<RequestDetailsLogger>.SafeSetLogger(getRequestDetailsLogger, OwaServerLogger.LoggerData.AppCache, text);
}
internal void LogElapsedTime(RequestDetailsLogger logger, string latencyName)
{
if (HttpProxySettings.DetailedLatencyTracingEnabled.Value)
{
long currentLatency = this.GetCurrentLatency(LatencyTrackerKey.ProxyModuleLatency);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(logger, latencyName, currentLatency);
}
}
private static void FinalizeRequestLatencies(HttpContext httpContext, RequestDetailsLogger requestDetailsLogger, IActivityScope activityScope, LatencyTracker tracker, int traceContext)
{
if (tracker == null)
{
return;
}
if (requestDetailsLogger == null)
{
throw new ArgumentNullException("requestDetailsLogger");
}
if (activityScope == null)
{
throw new ArgumentNullException("activityScope");
}
if (httpContext == null)
{
throw new ArgumentNullException("httpContext");
}
long num = tracker.GetCurrentLatency(LatencyTrackerKey.ProxyModuleLatency);
if (num >= 0L)
{
long num2 = 0L;
long.TryParse(activityScope.GetProperty(ServiceLatencyMetadata.HttpPipelineLatency), out num2);
long num3 = 0L;
bool flag = requestDetailsLogger.TryGetLatency(HttpProxyMetadata.BackendProcessingLatency, out num3);
long num4 = requestDetailsLogger.GetLatency(HttpProxyMetadata.ClientRequestStreamingLatency, 0L) + requestDetailsLogger.GetLatency(HttpProxyMetadata.BackendRequestStreamingLatency, 0L) + num3 + requestDetailsLogger.GetLatency(HttpProxyMetadata.BackendResponseStreamingLatency, 0L) + requestDetailsLogger.GetLatency(HttpProxyMetadata.ClientResponseStreamingLatency, 0L);
long num5 = num - num4;
PerfCounters.UpdateMovingAveragePerformanceCounter(PerfCounters.HttpProxyCountersInstance.MovingAverageCasLatency, num5);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, HttpProxyMetadata.HttpProxyOverhead, num5);
long num6 = num5 - num2;
if (flag)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, HttpProxyMetadata.RoutingLatency, Math.Max(num6, 0L));
string property = activityScope.GetProperty(HttpProxyMetadata.TargetServer);
if (PerfCounters.RoutingLatenciesEnabled && !string.IsNullOrEmpty(property))
{
string empty = string.Empty;
Utilities.TryGetSiteNameFromServerFqdn(property, out empty);
PercentilePerfCounters.UpdateRoutingLatencyPerfCounter(empty, (double)num6);
PerfCounters.GetHttpProxyPerSiteCountersInstance(empty).TotalProxyWithLatencyRequests.Increment();
}
}
long val = num6 - requestDetailsLogger.GetLatency(HttpProxyMetadata.BackendRequestInitLatency, 0L) - requestDetailsLogger.GetLatency(HttpProxyMetadata.BackendResponseInitLatency, 0L);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, HttpProxyMetadata.CoreLatency, Math.Max(val, 0L));
long currentLatency = tracker.GetCurrentLatency(LatencyTrackerKey.ProxyModuleLatency);
long num7 = currentLatency - num;
num = currentLatency;
if (num7 > 5L)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(requestDetailsLogger, "TotalRequestTimeDelta", num7);
}
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, HttpProxyMetadata.TotalRequestTime, num);
}
private static void LogTargetOustandingRequests(ConcurrencyGuard guard, string bucketName, object stateObject)
{
RequestDetailsLogger requestDetailsLogger = stateObject as RequestDetailsLogger;
if (requestDetailsLogger == null)
{
return;
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, HttpProxyMetadata.TargetOutstandingRequests, guard.GetCurrentValue(bucketName));
}
public static void LogSharedCacheCall(this IRequestContext requestContext, long latency, string diagnostics)
{
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
requestContext.LatencyTracker.HandleSharedCacheLatency(latency);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(requestContext.Logger, "SharedCache", diagnostics);
PerfCounters.UpdateMovingAveragePerformanceCounter(PerfCounters.HttpProxyCountersInstance.MovingAverageSharedCacheLatency, latency);
}
public static void LastChanceExceptionHandler(Exception ex)
{
RequestDetailsLogger requestDetailsLogger = RequestDetailsLoggerBase <RequestDetailsLogger> .Current;
if (requestDetailsLogger != null && !requestDetailsLogger.IsDisposed)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeLogRequestException(requestDetailsLogger, ex, "OnUnhandledException");
requestDetailsLogger.AsyncCommit(true);
}
}
internal void SafeLogUriData(Uri requestUrl)
{
if (requestUrl.IsAbsoluteUri)
{
this.Set(HttpProxyMetadata.UrlHost, requestUrl.DnsSafeHost);
this.Set(HttpProxyMetadata.UrlStem, requestUrl.LocalPath);
this.Set(HttpProxyMetadata.UrlQuery, requestUrl.Query);
return;
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericError(this, "InvalidRelativeUri", requestUrl.ToString());
}
public void BeforeSendReply(ref Message reply, object correlationState)
{
HttpContext httpContext = HttpContext.Current;
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpContext);
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.OwaMessageInspectorEndRequestBegin);
using (CpuTracker.StartCpuTracking("POST"))
{
this.InternalBeforeSendReply();
}
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.OwaMessageInspectorEndRequestEnd);
}
// Token: 0x060001F3 RID: 499 RVA: 0x00009988 File Offset: 0x00007B88
private ServiceType GetClientAccessServiceFromList <ServiceType>(List <DownLevelServerStatusEntry> serverList, ServiceTopology topology, AnchorMailbox anchorMailbox, Site targetSite, ClientAccessType clientAccessType, Predicate <ServiceType> otherFilter, RequestDetailsLogger logger, DownLevelServerManager.DownlevelExchangeServerVersion targetDownlevelExchangeServerVersion) where ServiceType : HttpService
{
string text = anchorMailbox.ToCookieKey();
int hashCode = HttpProxyBackEndHelper.GetHashCode(text);
serverList = this.GetFilteredServerListByVersion(serverList, targetDownlevelExchangeServerVersion);
int[] shuffledList = DownLevelServerManager.GetShuffledList(serverList.Count, hashCode);
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <string, int, string>((long)this.GetHashCode(), "[DownLevelServerManager::GetClientAccessServiceFromList]: HashKey: {0}, HashCode: {1}, Anchor mailbox {2}.", text, hashCode, anchorMailbox.ToString());
}
for (int i = 0; i < shuffledList.Length; i++)
{
int num = shuffledList[i];
DownLevelServerStatusEntry currentServer = serverList[num];
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <string, int, bool>((long)this.GetHashCode(), "[DownLevelServerManager::GetClientAccessServiceFromList]: Back end server {0} is selected by current index {1}. IsHealthy = {2}", currentServer.BackEndServer.Fqdn, num, currentServer.IsHealthy);
}
if (currentServer.IsHealthy)
{
ServiceType serviceType = topology.FindAny <ServiceType>(clientAccessType, (ServiceType service) => service != null && service.ServerFullyQualifiedDomainName.Equals(currentServer.BackEndServer.Fqdn, StringComparison.OrdinalIgnoreCase) && !service.IsOutOfService && otherFilter(service), "d:\\dbs\\sh\\e16df\\0212_214120_0\\cmd\\1g\\sources\\Dev\\Cafe\\src\\HttpProxy\\DownLevelServerManager\\DownLevelServerManager.cs", "GetClientAccessServiceFromList", 799);
if (serviceType != null)
{
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(1))
{
ExTraceGlobals.VerboseTracer.TraceDebug <Uri, string>((long)this.GetHashCode(), "[DownLevelServerManager::GetClientAccessServiceFromList]: Found service {0} matching back end server {1}.", serviceType.Url, currentServer.BackEndServer.Fqdn);
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(logger, "DownLevelTargetRandomHashing", string.Format("{0}/{1}", i, serverList.Count));
return(serviceType);
}
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(3))
{
ExTraceGlobals.VerboseTracer.TraceError <string>((long)this.GetHashCode(), "[DownLevelServerManager::GetClientAccessServiceFromList]: Back end server {0} cannot be found by ServiceDiscovery.", currentServer.BackEndServer.Fqdn);
}
}
else if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(2))
{
ExTraceGlobals.VerboseTracer.TraceWarning <string>((long)this.GetHashCode(), "[DownLevelServerManager::GetClientAccessServiceFromList]: Back end server {0} is marked as unhealthy.", currentServer.BackEndServer.Fqdn);
}
}
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(logger, "DownLevelTargetRandomHashingFailure", string.Format("{0}", serverList.Count));
this.TriggerServerMapRefreshIfNeeded(topology, serverList);
string text2 = string.Format("Unable to find proper back end service for {0} in site {1}.", anchorMailbox, targetSite.DistinguishedName);
if (ExTraceGlobals.VerboseTracer.IsTraceEnabled(3))
{
ExTraceGlobals.VerboseTracer.TraceError <string>((long)this.GetHashCode(), "[DownLevelServerManager::GetClientAccessServiceFromList]: {0}", text2);
}
throw new NoAvailableDownLevelBackEndException(text2);
}
protected override void OnEndRequestInternal(HttpApplication httpApplication)
{
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[RpsHttpProxyModule::OnEndRequestInternal] Enter");
HttpContext context = httpApplication.Context;
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(context);
if (current != null)
{
RequestMonitor.Instance.UnRegisterRequest(current.ActivityId);
}
base.OnEndRequestInternal(httpApplication);
ExTraceGlobals.HttpModuleTracer.TraceFunction((long)this.GetHashCode(), "[RpsHttpProxyModule::OnEndRequestInternal] Exit");
}
private void OnPreSendRequestHeaders(object sender, EventArgs e)
{
HttpContext httpContext = HttpContext.Current;
HttpResponse response = httpContext.Response;
if (response != null)
{
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpContext);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(current, "OnPreSendRequestHeaders.ContentType", response.ContentType);
}
HttpContext.Current.Items["X-HeaderPreSent"] = true;
}
// Token: 0x060005F3 RID: 1523 RVA: 0x00021354 File Offset: 0x0001F554
private static void InspectNativeProxyFatalError(HttpResponse httpResponse, RequestDetailsLogger requestLogger)
{
if (!HttpProxySettings.DiagnosticsEnabled.Value)
{
string text = httpResponse.Headers[NativeProxyHelper.NativeProxyStatusHeaders.ProxyErrorHResult];
if (!string.IsNullOrEmpty(text))
{
string arg = httpResponse.Headers[NativeProxyHelper.NativeProxyStatusHeaders.ProxyErrorLabel];
string arg2 = httpResponse.Headers[NativeProxyHelper.NativeProxyStatusHeaders.ProxyErrorMessage];
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericError(requestLogger, "ProxyError", string.Format("[{0}] [{1}] {2}", text, arg, arg2));
}
}
}
internal static void SafeSetLogger(Enum key, object value)
{
if (!LoggerSettings.LogEnabled)
{
return;
}
if (LoggerSettings.IsPowerShellWebService)
{
RequestDetailsLoggerBase <PswsLogger> .SafeSetLogger(RequestDetailsLoggerBase <PswsLogger> .Current, key, value);
return;
}
RequestDetailsLoggerBase <RpsHttpLogger> .SafeSetLogger(RequestDetailsLoggerBase <RpsHttpLogger> .Current, key, value);
}
public static void PublishBackendDataToLog(RequestDetailsLogger logger, HttpWebResponse backendRespone)
{
if (backendRespone != null)
{
foreach (object obj in backendRespone.Headers.Keys)
{
string text = (string)obj;
if (text.StartsWith(Constants.XBackendHeaderPrefix))
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendBackEndGenericInfo(logger, text, backendRespone.Headers[text]);
}
}
}
}
internal static void SafeAppendColumn(Enum column, string key, string value)
{
if (!LoggerSettings.LogEnabled)
{
return;
}
if (LoggerSettings.IsPowerShellWebService)
{
RequestDetailsLoggerBase <PswsLogger> .SafeAppendColumn(RequestDetailsLoggerBase <PswsLogger> .Current, column, key, value);
return;
}
RequestDetailsLoggerBase <RpsHttpLogger> .SafeAppendColumn(RequestDetailsLoggerBase <RpsHttpLogger> .Current, column, key, value);
}
internal static void InitializeRequestLogger()
{
if (!LoggerSettings.LogEnabled)
{
return;
}
if (LoggerSettings.IsPowerShellWebService)
{
RequestDetailsLoggerBase <PswsLogger> .InitializeRequestLogger();
return;
}
RequestDetailsLoggerBase <RpsHttpLogger> .InitializeRequestLogger();
}
internal static void SafeAppendGenericInfo(string key, string value)
{
if (!LoggerSettings.LogEnabled)
{
return;
}
if (LoggerSettings.IsPowerShellWebService)
{
RequestDetailsLoggerBase <PswsLogger> .SafeAppendGenericInfo(RequestDetailsLoggerBase <PswsLogger> .Current, key, value);
return;
}
RequestDetailsLoggerBase <RpsAuthZLogger> .SafeAppendGenericInfo(RequestDetailsLoggerBase <RpsAuthZLogger> .Current, key, value);
}
private void OnBeginRequest(object sender, EventArgs e)
{
HttpApplication httpApplication = (HttpApplication)sender;
HttpContext httpContext = httpApplication.Context;
Diagnostics.SendWatsonReportOnUnhandledException(delegate()
{
LatencyTracker latencyTracker = new LatencyTracker();
latencyTracker.StartTracking(LatencyTrackerKey.ProxyModuleLatency, false);
AspNetHelper.AddTimestampHeaderIfNecessary(httpContext.Request.Headers, "X-FrontEnd-Begin");
if (Microsoft.Exchange.Diagnostics.Components.HttpProxy.ExTraceGlobals.VerboseTracer.IsTraceEnabled(TraceType.DebugTrace))
{
Microsoft.Exchange.Diagnostics.Components.HttpProxy.ExTraceGlobals.VerboseTracer.TraceDebug <string, Uri, int>((long)this.GetHashCode(), "[ProxyModule::OnBeginRequest]: Method {0}; Url {1}; Context {2};", httpContext.Request.HttpMethod, httpContext.Request.Url, httpContext.GetHashCode());
}
if (HealthCheckResponder.Instance.IsHealthCheckRequest(httpContext))
{
HealthCheckResponder.Instance.CheckHealthStateAndRespond(httpContext);
return;
}
RequestDetailsLogger requestDetailsLogger = RequestDetailsLoggerBase <RequestDetailsLogger> .InitializeRequestLogger();
requestDetailsLogger.LogCurrentTime("BeginRequest");
httpContext.Items[Constants.TraceContextKey] = httpContext.GetHashCode();
httpContext.Items[Constants.LatencyTrackerContextKeyName] = latencyTracker;
requestDetailsLogger.ActivityScope.UpdateFromMessage(httpContext.Request);
requestDetailsLogger.ActivityScope.SerializeTo(httpContext.Response);
RequestDetailsLoggerBase <RequestDetailsLogger> .SetCurrent(httpContext, requestDetailsLogger);
httpContext.Items[typeof(ActivityScope)] = requestDetailsLogger.ActivityScope;
httpContext.Items[Constants.RequestIdHttpContextKeyName] = requestDetailsLogger.ActivityScope.ActivityId;
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, HttpProxyMetadata.Protocol, HttpProxyGlobals.ProtocolType);
requestDetailsLogger.SafeLogUriData(httpContext.Request.Url);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, ServiceCommonMetadata.HttpMethod, httpContext.Request.HttpMethod);
string requestCorrelationId = AspNetHelper.GetRequestCorrelationId(httpContext);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericInfo(requestDetailsLogger, "CorrelationID", requestCorrelationId);
httpContext.Response.AppendToLog(Constants.CorrelationIdKeyForIISLogs + requestCorrelationId + ";");
string cookieValueAndSetIfNull = ClientIdCookie.GetCookieValueAndSetIfNull(httpContext);
httpContext.Response.AppendToLog(string.Format("&{0}={1}", "ClientId", cookieValueAndSetIfNull));
UrlUtilities.SaveOriginalRequestHostSchemePortToContext(httpContext);
try
{
this.OnBeginRequestInternal(httpApplication);
}
catch (Exception ex)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeAppendGenericError(requestDetailsLogger, "OnBeginRequestInternal", ex.ToString());
requestDetailsLogger.AsyncCommit(false);
throw;
}
}, new Diagnostics.LastChanceExceptionHandler(RequestDetailsLogger.LastChanceExceptionHandler));
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
HttpContext httpContext = HttpContext.Current;
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpContext);
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.OwaMessageInspectorReceiveRequestBegin);
object result;
using (CpuTracker.StartCpuTracking("PRE"))
{
result = this.InternalAfterReceiveRequest(ref request, current);
}
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.OwaMessageInspectorReceiveRequestEnd);
return(result);
}
