|
//------------------------------------------------------------------------------
// <copyright file="PerfCounters.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* PerfCounters class
*/
namespace System.Web {
using System.Web.Util;
using System.Threading;
using System.Runtime.InteropServices;
internal sealed class PerfInstanceDataHandle: SafeHandle {
internal PerfInstanceDataHandle() : base(IntPtr.Zero, true) {
}
internal IntPtr UnsafeHandle {
get { return handle; }
}
public override bool IsInvalid {
get { return handle == IntPtr.Zero; }
}
override protected bool ReleaseHandle() {
UnsafeNativeMethods.PerfCloseAppCounters(handle);
handle = IntPtr.Zero;
return true;
}
}
internal sealed class PerfCounters {
// singleton used for providing an abstraction to callers who require an interface implementation
internal static readonly IPerfCounters Instance = new PerfCountersInstance();
private static PerfInstanceDataHandle _instance = null;
private static IntPtr _global = IntPtr.Zero;
private static IntPtr _stateService = IntPtr.Zero;
private PerfCounters () {}
internal static void Open(string appName) {
Debug.Assert(appName != null);
OpenCounter(appName);
}
internal static void OpenStateCounters() {
OpenCounter(null);
}
// The app name should either be a valid app name or be 'null' to get the state service
// counters initialized
private static void OpenCounter(string appName) {
try {
// Don't activate perf counters if webengine.dll isn't loaded
if (! HttpRuntime.IsEngineLoaded)
return;
// Open the global counters
if (_global == IntPtr.Zero) {
_global = UnsafeNativeMethods.PerfOpenGlobalCounters();
}
// If appName is null, then we want the state counters
if (appName == null) {
if (_stateService == IntPtr.Zero) {
_stateService = UnsafeNativeMethods.PerfOpenStateCounters();
}
}
else {
if (appName != null) {
_instance = UnsafeNativeMethods.PerfOpenAppCounters(appName);
}
}
}
catch (Exception e) {
Debug.Trace("Perfcounters", "Exception: " + e.StackTrace);
}
}
// Make sure webengine.dll is loaded before attempting to call into it (ASURT 98531)
internal static void IncrementCounter(AppPerfCounter counter) {
if (_instance != null)
UnsafeNativeMethods.PerfIncrementCounter(_instance.UnsafeHandle, (int) counter);
}
internal static void DecrementCounter(AppPerfCounter counter) {
if (_instance != null)
UnsafeNativeMethods.PerfDecrementCounter(_instance.UnsafeHandle, (int) counter);
}
internal static void IncrementCounterEx(AppPerfCounter counter, int delta) {
if (_instance != null)
UnsafeNativeMethods.PerfIncrementCounterEx(_instance.UnsafeHandle, (int) counter, delta);
}
internal static void SetCounter(AppPerfCounter counter, int value) {
if (_instance != null)
UnsafeNativeMethods.PerfSetCounter(_instance.UnsafeHandle, (int) counter, value);
}
// It's important that this be debug only. We don't want production
// code to access shared memory that another process could corrupt.
#if DBG
internal static int GetCounter(AppPerfCounter counter) {
if (_instance != null)
return UnsafeNativeMethods.PerfGetCounter(_instance.UnsafeHandle, (int) counter);
else
return -1;
}
#endif
internal static int GetGlobalCounter(GlobalPerfCounter counter) {
if (_global != IntPtr.Zero)
return UnsafeNativeMethods.PerfGetCounter(_global, (int) counter);
else
return -1;
}
internal static void IncrementGlobalCounter(GlobalPerfCounter counter) {
if (_global != IntPtr.Zero)
UnsafeNativeMethods.PerfIncrementCounter(_global, (int) counter);
}
internal static void DecrementGlobalCounter(GlobalPerfCounter counter) {
if (_global != IntPtr.Zero)
UnsafeNativeMethods.PerfDecrementCounter(_global, (int) counter);
}
internal static void SetGlobalCounter(GlobalPerfCounter counter, int value) {
if (_global != IntPtr.Zero)
UnsafeNativeMethods.PerfSetCounter(_global, (int) counter, value);
}
internal static void IncrementStateServiceCounter(StateServicePerfCounter counter) {
if (_stateService == IntPtr.Zero)
return;
UnsafeNativeMethods.PerfIncrementCounter(_stateService, (int) counter);
switch (counter) {
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL:
IncrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TOTAL);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE:
IncrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ACTIVE);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_TIMED_OUT:
IncrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TIMED_OUT);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_ABANDONED:
IncrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ABANDONED);
break;
default:
break;
}
}
internal static void DecrementStateServiceCounter(StateServicePerfCounter counter) {
if (_stateService == IntPtr.Zero)
return;
UnsafeNativeMethods.PerfDecrementCounter(_stateService, (int) counter);
switch (counter) {
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL:
DecrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TOTAL);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE:
DecrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ACTIVE);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_TIMED_OUT:
DecrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TIMED_OUT);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_ABANDONED:
DecrementGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ABANDONED);
break;
default:
break;
}
}
internal static void SetStateServiceCounter(StateServicePerfCounter counter, int value) {
if (_stateService == IntPtr.Zero)
return;
UnsafeNativeMethods.PerfSetCounter(_stateService, (int) counter, value);
switch (counter) {
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_TOTAL:
SetGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TOTAL, value);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_ACTIVE:
SetGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ACTIVE, value);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_TIMED_OUT:
SetGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_TIMED_OUT, value);
break;
case StateServicePerfCounter.STATE_SERVICE_SESSIONS_ABANDONED:
SetGlobalCounter(GlobalPerfCounter.STATE_SERVER_SESSIONS_ABANDONED, value);
break;
default:
break;
}
}
private sealed class PerfCountersInstance : IPerfCounters {
public void IncrementCounter(AppPerfCounter counter) {
PerfCounters.IncrementCounter(counter);
}
public void IncrementCounter(AppPerfCounter counter, int value) {
PerfCounters.IncrementCounterEx(counter, value);
}
public void DecrementCounter(AppPerfCounter counter) {
PerfCounters.DecrementCounter(counter);
}
public void SetCounter(AppPerfCounter counter, int value) {
PerfCounters.SetCounter(counter, value);
}
}
};
}
|