mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Diagnostics/PerformanceCounters.cs

//------------------------------------------------------------
// 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));
            }
        }
    }
}