using System;
using System.Management.Instrumentation;

namespace MsdnMagazine.InstrumentedHttpModule
{
    [ManagedName("ASPNET_ExcessivelyLongRequestEvent")]
    public class AspNetExcessivelyLongRequestEvent : BaseEvent
    {
        private string applicationNameValue;
        public string ApplicationName
        {
            get { return applicationNameValue; }
        }

        private int durationValue;
        public int Duration { get { return durationValue; } }

        private string requestPathValue;
        public string RequestPath { get { return requestPathValue; } }

        public AspNetExcessivelyLongRequestEvent(
            string applicationName, int duration, string requestPath)
        {
            applicationNameValue = applicationName;
            durationValue = duration;
            requestPathValue = requestPath;
        }
    }
}

using System;
using System.Web;
using System.Threading;
using System.Configuration;
using System.Management.Instrumentation;

namespace MsdnMagazine.InstrumentedHttpModule
{
    public class HttpModule: IHttpModule
    {
        private static string applicationName;
        private static ExpiringUniqueStringCounter anonymousUsers;
        private static ExpiringUniqueStringCounter authenticatedUsers;
        private static int excessivelyLongRequestThreshold=2000;
        private static AspNetCounters counters;
        private static Timer refreshTimer;

        static HttpModule()
        {
            applicationName = HttpContext.Current.
                Request.ApplicationPath.Replace("/","");
            anonymousUsers = new ExpiringUniqueStringCounter(
                TimeSpan.FromMinutes(5));
            authenticatedUsers = new ExpiringUniqueStringCounter(
                TimeSpan.FromMinutes(5));

            // If present, read long request threshold from config file
            if (ConfigurationSettings.AppSettings[
                "ExcessivelyLongRequestThreshold"] != null)
                excessivelyLongRequestThreshold = int.Parse(
                    ConfigurationSettings.AppSettings[
                        "ExcessivelyLongRequestThreshold"]);

            // Initialize and publish counters
            counters = new AspNetCounters(applicationName);
            RefreshCounters(null);
            counters.Published=true;

            // Start periodic refresh of counters
            refreshTimer = new Timer(new TimerCallback(RefreshCounters),
                null, 1000, 1000);
        }

        static void RefreshCounters(object state)
        {
            int availableWorkerThreads, availableIOThreads;
            ThreadPool.GetAvailableThreads(out availableWorkerThreads,
                out availableIOThreads);
            counters.Update(authenticatedUsers.Count,
                anonymousUsers.Count, availableWorkerThreads,
                availableIOThreads);
        }

        public void Init(System.Web.HttpApplication context)
        {
            context.Error += new EventHandler(context_Error);
            context.BeginRequest +=new EventHandler(context_BeginRequest);
            context.EndRequest += new EventHandler(context_EndRequest);
        }

        public void Dispose() {}

        private void context_Error(Object sender, EventArgs e)
        {
            Exception ex = HttpContext.Current.Server.
                GetLastError().InnerException;
            string typeName = ex.GetType().FullName;
            string message = ex.Message;
            string requestPath = HttpContext.Current.Request.Path;
            string details = ex.ToString();
            new AspNetErrorEvent(applicationName, typeName, message,
                requestPath,details).Fire();
        }

        private DateTime startTime;
        
        private void context_BeginRequest(object sender, EventArgs e)
        {
            startTime = DateTime.Now;
        }

        private void context_EndRequest(object sender, EventArgs e)
        {
            // Increment corresponding counter
            string ipAddress = HttpContext.Current.Request.
                ServerVariables["REMOTE_ADDR"];
            if (HttpContext.Current.Request.IsAuthenticated)
                authenticatedUsers.Add(ipAddress);
            else
                anonymousUsers.Add(ipAddress);
            // Fire excessively long request event if necessary
            int duration = (int) DateTime.Now.Subtract(
                startTime).TotalMilliseconds;
            if (duration > excessivelyLongRequestThreshold)
            {
                string requestPath=HttpContext.Current.Request.Path;
                new AspNetExcessivelyLongRequestEvent(applicationName,
                    duration,requestPath).Fire();
            }
        }
    }
}