Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

904 lines
38 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Diagnostics
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.Diagnostics;
using System.Security;
using System.Security.Permissions;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
using System.ServiceModel.Description;
using System.ServiceModel.Dispatcher;
static class PerformanceCounters
{
static PerformanceCounterScope scope;
static object perfCounterDictionarySyncObject = new object();
internal const int MaxInstanceNameLength = 127;
static bool serviceOOM = false;
static bool endpointOOM = false;
static bool operationOOM = false;
//we need a couple of ways of accessing the same performance counters. Normally, we know which endpoint
//for which we need to update a perf counter. In some cases (e.g. RM), we only have a base uri. In those
//cases, we update all the perf counters associated with the base uri. These two dictionaries point to
//the same underlying perf counters, but in different ways.
static Dictionary<string, ServiceModelPerformanceCounters> performanceCounters = null;
static Dictionary<string, ServiceModelPerformanceCountersEntry> performanceCountersBaseUri = null;
static List<ServiceModelPerformanceCounters> performanceCountersList = null;
static internal PerformanceCounterScope Scope
{
get
{
return PerformanceCounters.scope;
}
set
{
PerformanceCounters.scope = value;
}
}
static internal bool PerformanceCountersEnabled
{
get
{
return (PerformanceCounters.scope != PerformanceCounterScope.Off) &&
(PerformanceCounters.scope != PerformanceCounterScope.Default);
}
}
static internal bool MinimalPerformanceCountersEnabled
{
get
{
return (PerformanceCounters.scope == PerformanceCounterScope.Default);
}
}
static PerformanceCounters()
{
PerformanceCounterScope scope = GetPerformanceCountersFromConfig();
if (PerformanceCounterScope.Off != scope)
{
try
{
if (scope == PerformanceCounterScope.Default)
{
scope = OSEnvironmentHelper.IsVistaOrGreater ? PerformanceCounterScope.ServiceOnly : PerformanceCounterScope.Off;
}
PerformanceCounters.scope = scope;
}
catch (SecurityException securityException)
{
//switch off the counters - not supported in PT
PerformanceCounters.scope = PerformanceCounterScope.Off;
// not re-throwing on purpose
DiagnosticUtility.TraceHandledException(securityException, TraceEventType.Warning);
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(System.Diagnostics.TraceEventType.Warning,
TraceCode.PerformanceCounterFailedToLoad,
SR.GetString(SR.PartialTrustPerformanceCountersNotEnabled));
}
}
}
else
{
PerformanceCounters.scope = PerformanceCounterScope.Off;
}
}
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method UnsafeGetSection which elevates in order to load config.",
Safe = "Does not leak any config objects.")]
[SecuritySafeCritical]
static PerformanceCounterScope GetPerformanceCountersFromConfig()
{
return DiagnosticSection.UnsafeGetSection().PerformanceCounters;
}
static internal PerformanceCounter GetOperationPerformanceCounter(string perfCounterName, string instanceName)
{
return PerformanceCounters.GetPerformanceCounter(
PerformanceCounterStrings.SERVICEMODELOPERATION.OperationPerfCounters,
perfCounterName,
instanceName,
PerformanceCounterInstanceLifetime.Process);
}
static internal PerformanceCounter GetEndpointPerformanceCounter(string perfCounterName, string instanceName)
{
return PerformanceCounters.GetPerformanceCounter(
PerformanceCounterStrings.SERVICEMODELENDPOINT.EndpointPerfCounters,
perfCounterName,
instanceName,
PerformanceCounterInstanceLifetime.Process);
}
static internal PerformanceCounter GetServicePerformanceCounter(string perfCounterName, string instanceName)
{
return PerformanceCounters.GetPerformanceCounter(
PerformanceCounterStrings.SERVICEMODELSERVICE.ServicePerfCounters,
perfCounterName,
instanceName,
PerformanceCounterInstanceLifetime.Process);
}
static internal PerformanceCounter GetDefaultPerformanceCounter(string perfCounterName, string instanceName)
{
return PerformanceCounters.GetPerformanceCounter(
PerformanceCounterStrings.SERVICEMODELSERVICE.ServicePerfCounters,
perfCounterName,
instanceName,
PerformanceCounterInstanceLifetime.Global);
}
static internal PerformanceCounter GetPerformanceCounter(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime)
{
PerformanceCounter counter = null;
if (PerformanceCounters.PerformanceCountersEnabled || PerformanceCounters.MinimalPerformanceCountersEnabled)
{
counter = PerformanceCounters.GetPerformanceCounterInternal(categoryName, perfCounterName, instanceName, instanceLifetime);
}
return counter;
}
static internal PerformanceCounter GetPerformanceCounterInternal(string categoryName, string perfCounterName, string instanceName, PerformanceCounterInstanceLifetime instanceLifetime)
{
PerformanceCounter counter = null;
try
{
counter = new PerformanceCounter();
counter.CategoryName = categoryName;
counter.CounterName = perfCounterName;
counter.InstanceName = instanceName;
counter.ReadOnly = false;
counter.InstanceLifetime = instanceLifetime;
// We now need to access the counter raw data to
// force the counter object to be initialized. This
// will force any exceptions due to mis-installation
// of counters to occur here and be traced appropriately.
try
{
long rawValue = counter.RawValue;
}
catch (InvalidOperationException)
{
counter = null;
throw;
}
catch (SecurityException securityException)
{
// Cannot access performance counter due to partial trust scenarios
// Disable the default performance counters' access otherwise
// in PT the service will be broken
PerformanceCounters.scope = PerformanceCounterScope.Off;
DiagnosticUtility.TraceHandledException(new SecurityException(SR.GetString(
SR.PartialTrustPerformanceCountersNotEnabled), securityException), TraceEventType.Warning);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new SecurityException(SR.GetString(
SR.PartialTrustPerformanceCountersNotEnabled)));
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (null != counter)
{
if (!counter.ReadOnly)
{
try
{
counter.RemoveInstance();
}
// Already inside a catch block for a failure case
// ok to ---- any exceptions here and trace the
// original failure.
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e1)
{
if (Fx.IsFatal(e1))
{
throw;
}
}
}
counter = null;
}
bool logEvent = true;
if (categoryName == PerformanceCounterStrings.SERVICEMODELSERVICE.ServicePerfCounters)
{
if (serviceOOM == false)
{
serviceOOM = true;
}
else
{
logEvent = false;
}
}
else if (categoryName == PerformanceCounterStrings.SERVICEMODELOPERATION.OperationPerfCounters)
{
if (operationOOM == false)
{
operationOOM = true;
}
else
{
logEvent = false;
}
}
else if (categoryName == PerformanceCounterStrings.SERVICEMODELENDPOINT.EndpointPerfCounters)
{
if (endpointOOM == false)
{
endpointOOM = true;
}
else
{
logEvent = false;
}
}
if (logEvent)
{
DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error,
(ushort)System.Runtime.Diagnostics.EventLogCategory.PerformanceCounter,
(uint)System.Runtime.Diagnostics.EventLogEventId.FailedToLoadPerformanceCounter,
categoryName,
perfCounterName,
e.ToString());
}
}
return counter;
}
internal static Dictionary<string, ServiceModelPerformanceCounters> PerformanceCountersForEndpoint
{
get
{
if (PerformanceCounters.performanceCounters == null)
{
lock (PerformanceCounters.perfCounterDictionarySyncObject)
{
if (PerformanceCounters.performanceCounters == null)
{
PerformanceCounters.performanceCounters = new Dictionary<string, ServiceModelPerformanceCounters>();
}
}
}
return PerformanceCounters.performanceCounters;
}
}
internal static List<ServiceModelPerformanceCounters> PerformanceCountersForEndpointList
{
get
{
if (PerformanceCounters.performanceCountersList == null)
{
lock (PerformanceCounters.perfCounterDictionarySyncObject)
{
if (PerformanceCounters.performanceCountersList == null)
{
PerformanceCounters.performanceCountersList = new List<ServiceModelPerformanceCounters>();
}
}
}
return PerformanceCounters.performanceCountersList;
}
}
internal static Dictionary<string, ServiceModelPerformanceCountersEntry> PerformanceCountersForBaseUri
{
get
{
if (PerformanceCounters.performanceCountersBaseUri == null)
{
lock (PerformanceCounters.perfCounterDictionarySyncObject)
{
if (PerformanceCounters.performanceCountersBaseUri == null)
{
PerformanceCounters.performanceCountersBaseUri = new Dictionary<string, ServiceModelPerformanceCountersEntry>();
}
}
}
return PerformanceCounters.performanceCountersBaseUri;
}
}
internal static void AddPerformanceCountersForEndpoint(
ServiceHostBase serviceHost,
ContractDescription contractDescription,
EndpointDispatcher endpointDispatcher)
{
Fx.Assert(serviceHost != null, "The 'serviceHost' argument must not be null.");
Fx.Assert(contractDescription != null, "The 'contractDescription' argument must not be null.");
Fx.Assert(endpointDispatcher != null, "The 'endpointDispatcher' argument must not be null.");
bool performanceCountersEnabled = PerformanceCounters.PerformanceCountersEnabled;
bool minimalPerformanceCountersEnabled = PerformanceCounters.MinimalPerformanceCountersEnabled;
if (performanceCountersEnabled || minimalPerformanceCountersEnabled)
{
if (endpointDispatcher.SetPerfCounterId())
{
ServiceModelPerformanceCounters counters;
lock (PerformanceCounters.perfCounterDictionarySyncObject)
{
if (!PerformanceCounters.PerformanceCountersForEndpoint.TryGetValue(endpointDispatcher.PerfCounterId, out counters))
{
counters = new ServiceModelPerformanceCounters(serviceHost, contractDescription, endpointDispatcher);
if (counters.Initialized)
{
PerformanceCounters.PerformanceCountersForEndpoint.Add(endpointDispatcher.PerfCounterId, counters);
int index = PerformanceCounters.PerformanceCountersForEndpointList.FindIndex(c => c == null);
if (index >= 0)
{
PerformanceCounters.PerformanceCountersForEndpointList[index] = counters;
}
else
{
PerformanceCounters.PerformanceCountersForEndpointList.Add(counters);
index = PerformanceCounters.PerformanceCountersForEndpointList.Count - 1;
}
endpointDispatcher.PerfCounterInstanceId = index;
}
else
{
return;
}
}
}
ServiceModelPerformanceCountersEntry countersEntry;
lock (PerformanceCounters.perfCounterDictionarySyncObject)
{
if (!PerformanceCounters.PerformanceCountersForBaseUri.TryGetValue(endpointDispatcher.PerfCounterBaseId, out countersEntry))
{
if (performanceCountersEnabled)
{
countersEntry = new ServiceModelPerformanceCountersEntry(serviceHost.Counters);
}
else if (minimalPerformanceCountersEnabled)
{
countersEntry = new ServiceModelPerformanceCountersEntry(serviceHost.DefaultCounters);
}
PerformanceCounters.PerformanceCountersForBaseUri.Add(endpointDispatcher.PerfCounterBaseId, countersEntry);
}
countersEntry.Add(counters);
}
}
}
}
internal static void ReleasePerformanceCountersForEndpoint(string id, string baseId)
{
if (PerformanceCounters.PerformanceCountersEnabled)
{
lock (PerformanceCounters.perfCounterDictionarySyncObject)
{
if (!String.IsNullOrEmpty(id))
{
ServiceModelPerformanceCounters counters;
if (PerformanceCounters.PerformanceCountersForEndpoint.TryGetValue(id, out counters))
{
PerformanceCounters.PerformanceCountersForEndpoint.Remove(id);
int index = PerformanceCounters.PerformanceCountersForEndpointList.IndexOf(counters);
PerformanceCounters.PerformanceCountersForEndpointList[index] = null;
}
}
if (!String.IsNullOrEmpty(baseId))
{
PerformanceCounters.PerformanceCountersForBaseUri.Remove(baseId);
}
}
}
}
internal static void ReleasePerformanceCounter(ref PerformanceCounter counter)
{
if (counter != null)
{
try
{
counter.RemoveInstance();
counter = null;
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
}
}
}
internal static void TxFlowed(EndpointDispatcher el, string operation)
{
if (null != el)
{
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.TxFlowed();
}
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
OperationPerformanceCountersBase oCounters = PerformanceCounters.GetOperationPerformanceCounters(el.PerfCounterInstanceId, operation);
if (null != oCounters)
{
oCounters.TxFlowed();
}
EndpointPerformanceCountersBase eCounters = PerformanceCounters.GetEndpointPerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
eCounters.TxFlowed();
}
}
}
}
internal static void TxAborted(EndpointDispatcher el, long count)
{
if (PerformanceCounters.PerformanceCountersEnabled)
{
if (null != el)
{
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.TxAborted(count);
}
}
}
}
internal static void TxCommitted(EndpointDispatcher el, long count)
{
if (PerformanceCounters.PerformanceCountersEnabled)
{
if (null != el)
{
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.TxCommitted(count);
}
}
}
}
internal static void TxInDoubt(EndpointDispatcher el, long count)
{
if (PerformanceCounters.PerformanceCountersEnabled)
{
if (null != el)
{
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.TxInDoubt(count);
}
}
}
}
internal static void MethodCalled(string operationName)
{
EndpointDispatcher el = GetEndpointDispatcher();
if (null != el)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
string uri = el.PerfCounterId;
OperationPerformanceCountersBase opCounters = PerformanceCounters.GetOperationPerformanceCounters(el.PerfCounterInstanceId, operationName);
if (null != opCounters)
{
opCounters.MethodCalled();
}
EndpointPerformanceCountersBase eCounters = PerformanceCounters.GetEndpointPerformanceCounters(el.PerfCounterInstanceId);
if (null != eCounters)
{
eCounters.MethodCalled();
}
}
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.MethodCalled();
}
}
}
internal static void MethodReturnedSuccess(string operationName)
{
PerformanceCounters.MethodReturnedSuccess(operationName, -1);
}
internal static void MethodReturnedSuccess(string operationName, long time)
{
EndpointDispatcher el = GetEndpointDispatcher();
if (null != el)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
string uri = el.PerfCounterId;
OperationPerformanceCountersBase counters = PerformanceCounters.GetOperationPerformanceCounters(el.PerfCounterInstanceId, operationName);
if (null != counters)
{
counters.MethodReturnedSuccess();
if (time > 0)
{
counters.SaveCallDuration(time);
}
}
EndpointPerformanceCountersBase eCounters = PerformanceCounters.GetEndpointPerformanceCounters(el.PerfCounterInstanceId);
if (null != eCounters)
{
eCounters.MethodReturnedSuccess();
if (time > 0)
{
eCounters.SaveCallDuration(time);
}
}
}
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.MethodReturnedSuccess();
if (time > 0)
{
sCounters.SaveCallDuration(time);
}
}
}
}
internal static void MethodReturnedFault(string operationName)
{
PerformanceCounters.MethodReturnedFault(operationName, -1);
}
internal static void MethodReturnedFault(string operationName, long time)
{
EndpointDispatcher el = GetEndpointDispatcher();
if (null != el)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
string uri = el.PerfCounterId;
OperationPerformanceCountersBase counters = PerformanceCounters.GetOperationPerformanceCounters(el.PerfCounterInstanceId, operationName);
if (null != counters)
{
counters.MethodReturnedFault();
if (time > 0)
{
counters.SaveCallDuration(time);
}
}
EndpointPerformanceCountersBase eCounters = PerformanceCounters.GetEndpointPerformanceCounters(el.PerfCounterInstanceId);
if (null != eCounters)
{
eCounters.MethodReturnedFault();
if (time > 0)
{
eCounters.SaveCallDuration(time);
}
}
}
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.MethodReturnedFault();
if (time > 0)
{
sCounters.SaveCallDuration(time);
}
}
}
}
internal static void MethodReturnedError(string operationName)
{
PerformanceCounters.MethodReturnedError(operationName, -1);
}
internal static void MethodReturnedError(string operationName, long time)
{
EndpointDispatcher el = GetEndpointDispatcher();
if (null != el)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
string uri = el.PerfCounterId;
OperationPerformanceCountersBase counters = PerformanceCounters.GetOperationPerformanceCounters(el.PerfCounterInstanceId, operationName);
if (null != counters)
{
counters.MethodReturnedError();
if (time > 0)
{
counters.SaveCallDuration(time);
}
}
EndpointPerformanceCountersBase eCounters = PerformanceCounters.GetEndpointPerformanceCounters(el.PerfCounterInstanceId);
if (null != eCounters)
{
eCounters.MethodReturnedError();
if (time > 0)
{
eCounters.SaveCallDuration(time);
}
}
}
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.MethodReturnedError();
if (time > 0)
{
sCounters.SaveCallDuration(time);
}
}
}
}
static void InvokeMethod(object o, string methodName)
{
Fx.Assert(null != o, "object must not be null");
MethodInfo method = o.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
Fx.Assert(null != method, o.GetType().ToString() + " must have method " + methodName);
method.Invoke(o, null);
}
static void CallOnAllCounters(string methodName, Message message, Uri listenUri, bool includeOperations)
{
Fx.Assert(null != message, "message must not be null");
Fx.Assert(null != listenUri, "listenUri must not be null");
if (null != message && null != message.Headers && null != message.Headers.To && null != listenUri)
{
string uri = listenUri.AbsoluteUri.ToUpperInvariant();
ServiceModelPerformanceCountersEntry counters = PerformanceCounters.GetServiceModelPerformanceCountersBaseUri(uri);
if (null != counters)
{
Fx.Assert(null != counters.ServicePerformanceCounters, "counters.ServicePerformanceCounters must not be null");
PerformanceCounters.InvokeMethod(counters.ServicePerformanceCounters, methodName);
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
List<ServiceModelPerformanceCounters> counters2 = counters.CounterList;
foreach (ServiceModelPerformanceCounters sCounters in counters2)
{
if (sCounters.EndpointPerformanceCounters != null)
{
PerformanceCounters.InvokeMethod(sCounters.EndpointPerformanceCounters, methodName);
}
if (includeOperations)
{
OperationPerformanceCountersBase oCounters = sCounters.GetOperationPerformanceCountersFromMessage(message);
if (oCounters != null)
{
PerformanceCounters.InvokeMethod(oCounters, methodName);
}
}
}
}
}
}
}
static internal void AuthenticationFailed(Message message, Uri listenUri)
{
PerformanceCounters.CallOnAllCounters("AuthenticationFailed", message, listenUri, true);
}
static internal void AuthorizationFailed(string operationName)
{
EndpointDispatcher el = GetEndpointDispatcher();
if (null != el)
{
string uri = el.PerfCounterId;
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
OperationPerformanceCountersBase counters = PerformanceCounters.GetOperationPerformanceCounters(el.PerfCounterInstanceId, operationName);
if (null != counters)
{
counters.AuthorizationFailed();
}
EndpointPerformanceCountersBase eCounters = PerformanceCounters.GetEndpointPerformanceCounters(el.PerfCounterInstanceId);
if (null != eCounters)
{
eCounters.AuthorizationFailed();
}
}
ServicePerformanceCountersBase sCounters = PerformanceCounters.GetServicePerformanceCounters(el.PerfCounterInstanceId);
if (null != sCounters)
{
sCounters.AuthorizationFailed();
}
}
}
internal static void SessionFaulted(string uri)
{
ServiceModelPerformanceCountersEntry counters = PerformanceCounters.GetServiceModelPerformanceCountersBaseUri(uri);
if (null != counters)
{
counters.ServicePerformanceCounters.SessionFaulted();
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
List<ServiceModelPerformanceCounters> counters2 = counters.CounterList;
foreach (ServiceModelPerformanceCounters sCounters in counters2)
{
if (sCounters.EndpointPerformanceCounters != null)
{
sCounters.EndpointPerformanceCounters.SessionFaulted();
}
}
}
}
}
internal static void MessageDropped(string uri)
{
ServiceModelPerformanceCountersEntry counters = PerformanceCounters.GetServiceModelPerformanceCountersBaseUri(uri);
if (null != counters)
{
counters.ServicePerformanceCounters.MessageDropped();
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
List<ServiceModelPerformanceCounters> counters2 = counters.CounterList;
foreach (ServiceModelPerformanceCounters sCounters in counters2)
{
if (sCounters.EndpointPerformanceCounters != null)
{
sCounters.EndpointPerformanceCounters.MessageDropped();
}
}
}
}
}
internal static void MsmqDroppedMessage(string uri)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
ServiceModelPerformanceCountersEntry counters = PerformanceCounters.GetServiceModelPerformanceCountersBaseUri(uri);
if (null != counters)
{
counters.ServicePerformanceCounters.MsmqDroppedMessage();
}
}
}
internal static void MsmqPoisonMessage(string uri)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
ServiceModelPerformanceCountersEntry counters = PerformanceCounters.GetServiceModelPerformanceCountersBaseUri(uri);
if (null != counters)
{
counters.ServicePerformanceCounters.MsmqPoisonMessage();
}
}
}
internal static void MsmqRejectedMessage(string uri)
{
if (PerformanceCounters.Scope == PerformanceCounterScope.All)
{
ServiceModelPerformanceCountersEntry counters = PerformanceCounters.GetServiceModelPerformanceCountersBaseUri(uri);
if (null != counters)
{
counters.ServicePerformanceCounters.MsmqRejectedMessage();
}
}
}
static internal EndpointDispatcher GetEndpointDispatcher()
{
EndpointDispatcher endpointDispatcher = null;
OperationContext currentContext = OperationContext.Current;
if (null != currentContext && currentContext.InternalServiceChannel != null)
{
endpointDispatcher = currentContext.EndpointDispatcher;
}
return endpointDispatcher;
}
static ServiceModelPerformanceCounters GetServiceModelPerformanceCounters(int perfCounterInstanceId)
{
if (PerformanceCounters.PerformanceCountersForEndpointList.Count == 0)
{
return null;
}
return PerformanceCounters.PerformanceCountersForEndpointList[perfCounterInstanceId];
}
static ServiceModelPerformanceCountersEntry GetServiceModelPerformanceCountersBaseUri(string uri)
{
ServiceModelPerformanceCountersEntry counters = null;
if (!String.IsNullOrEmpty(uri))
{
PerformanceCounters.PerformanceCountersForBaseUri.TryGetValue(uri, out counters);
}
return counters;
}
static OperationPerformanceCountersBase GetOperationPerformanceCounters(int perfCounterInstanceId, string operation)
{
ServiceModelPerformanceCounters counters = PerformanceCounters.GetServiceModelPerformanceCounters(perfCounterInstanceId);
if (counters != null)
{
return counters.GetOperationPerformanceCounters(operation);
}
return null;
}
static EndpointPerformanceCountersBase GetEndpointPerformanceCounters(int perfCounterInstanceId)
{
ServiceModelPerformanceCounters counters = PerformanceCounters.GetServiceModelPerformanceCounters(perfCounterInstanceId);
if (counters != null)
{
return counters.EndpointPerformanceCounters;
}
return null;
}
static ServicePerformanceCountersBase GetServicePerformanceCounters(int perfCounterInstanceId)
{
ServiceModelPerformanceCounters counters = PerformanceCounters.GetServiceModelPerformanceCounters(perfCounterInstanceId);
if (counters != null)
{
return counters.ServicePerformanceCounters;
}
return null;
}
static internal void TracePerformanceCounterUpdateFailure(string instanceName, string perfCounterName)
{
if (DiagnosticUtility.ShouldTraceError)
{
TraceUtility.TraceEvent(
System.Diagnostics.TraceEventType.Error,
TraceCode.PerformanceCountersFailedDuringUpdate,
SR.GetString(SR.TraceCodePerformanceCountersFailedDuringUpdate, perfCounterName + "::" + instanceName));
}
}
}
}