Performance Counter Example

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DTech.Processor
{
    /// <summary>
    /// Helper class to demonstrate the setup of performance counters.
    /// </summary>
    public static class PerformanceCounterHelper
    {
        public static readonly string CATEGORY = "IFP";

        public static readonly string COUNTER_FILES_RECEIVED = "Total Files Processed";
        public static readonly string COUNTER_Transactions_RECEIVED = "Total Transactions Processed";
        public static readonly string COUNTER_DUP_Transactions_RECEIVED = "Total Duplicates Transactions Processed";

        public static readonly string COUNTER_AVG_FILE_DURATION = "Avg time to process file";
        public static readonly string COUNTER_AVG_FILE_DURATION_BASE = "Avg time to process file Base";

        public static readonly string COUNTER_IFP_ERRORS = "Total IFP Errors";


        // Total number of tests executed
        private static PerformanceCounter _TotalFiles = null;
        // Total Transactions
        private static PerformanceCounter _TotalTransactions = null;
        // Total dup Transactions
        private static PerformanceCounter _TotalDupTransactions = null;
        // avg files
        private static PerformanceCounter _AvgFiles = null;
        // avg files
        private static PerformanceCounter _AvgFilesBase = null;
        // avg files
        private static PerformanceCounter _TotalErrors = null;


        /// <summary>
        /// Constructor
        /// </summary>
        static PerformanceCounterHelper()
        {
            try
            {
                // Set up the performance counter(s)
                if (!PerformanceCounterCategory.Exists(CATEGORY))
                {
                    // Create the collection container
                    CounterCreationDataCollection counters = new
                        CounterCreationDataCollection();
                    addCounter(counters, COUNTER_FILES_RECEIVED, COUNTER_FILES_RECEIVED, PerformanceCounterType.NumberOfItems64);
                    addCounter(counters, COUNTER_Transactions_RECEIVED, COUNTER_Transactions_RECEIVED, PerformanceCounterType.NumberOfItems64);
                    addCounter(counters, COUNTER_DUP_Transactions_RECEIVED, COUNTER_DUP_Transactions_RECEIVED, PerformanceCounterType.NumberOfItems64);

                    addCounter(counters, COUNTER_IFP_ERRORS, COUNTER_IFP_ERRORS, PerformanceCounterType.NumberOfItems64);

                    addCounter(counters, COUNTER_AVG_FILE_DURATION, COUNTER_AVG_FILE_DURATION, PerformanceCounterType.AverageTimer32);
                    addCounter(counters, COUNTER_AVG_FILE_DURATION_BASE, COUNTER_AVG_FILE_DURATION_BASE, PerformanceCounterType.AverageBase);
                   

                    //// Create counter #1 and add it to the collection
                    //CounterCreationData tests = new CounterCreationData();
                    //tests.CounterName = "Total Tests Executed";
                    //tests.CounterHelp = "Total number of tests executed.";
                    //tests.CounterType = PerformanceCounterType.NumberOfItems32;
                    //counters.Add(tests);

                    //// Create counter #2 and add it to the collection
                    //CounterCreationData testsPerSec = new CounterCreationData();
                    //testsPerSec.CounterName = "Tests Executed / sec";
                    //testsPerSec.CounterHelp = "Number of tests executed per second.";
                    //testsPerSec.CounterType =
                    //   PerformanceCounterType.RateOfCountsPerSecond32;
                    //counters.Add(testsPerSec);


                    //// Create counter #3 and add it to the collection
                    //CounterCreationData avgTest = new CounterCreationData();
                    //avgTest.CounterName = "Average Test Duration";
                    //avgTest.CounterHelp = "Average time to execute a test.";
                    //avgTest.CounterType = PerformanceCounterType.AverageTimer32;
                    //counters.Add(avgTest);

                    //// Create counter #4 and add it to the collection
                    //CounterCreationData avgTestBase = new CounterCreationData();
                    //avgTestBase.CounterName = "Average Test Duration Base";
                    //avgTestBase.CounterHelp = "Average time to execute a test base.";
                    //avgTestBase.CounterType = PerformanceCounterType.AverageBase;
                    //counters.Add(avgTestBase);

                    // Create the category and all of the counters.
                    PerformanceCounterCategory.Create(CATEGORY,
                       "IFP Counters.",
                       counters);
                }

                _TotalFiles = buildPerfCounter(COUNTER_FILES_RECEIVED);
                _TotalFiles.RawValue = 0;

                _TotalTransactions = buildPerfCounter(COUNTER_Transactions_RECEIVED);
                _TotalTransactions.RawValue = 0;

                _TotalDupTransactions = buildPerfCounter(COUNTER_DUP_Transactions_RECEIVED);
                _TotalDupTransactions.RawValue = 0;

                _TotalErrors = buildPerfCounter(COUNTER_IFP_ERRORS);
                _TotalErrors.RawValue = 0;

                _AvgFiles = buildPerfCounter(COUNTER_AVG_FILE_DURATION);
                _AvgFiles.RawValue = 0;

                _AvgFilesBase = buildPerfCounter(COUNTER_AVG_FILE_DURATION_BASE);
                _AvgFilesBase.RawValue = 0;
            }
            catch (Exception exc)
            {
                Debug.Write("PerformanceCounterHelper: ERROR-> " + exc.Message);
            }

        }


        /// <summary>
        /// Increment the CodeGuru sample counters.
        /// </summary>
        /// <param name="Ticks">Timing interval</param>
        public static void IncrementFiles()
        {
            try
            {
                checkReset();
                if (_TotalFiles.RawValue >= Int64.MaxValue || rF)
                {
                    _TotalFiles.RawValue = 0;
                    rF = false;
                }
                else
                    _TotalFiles.Increment();
            }
            catch { }
            //_TestsPerSecond.Increment();
            //_TotalDupTransactions.IncrementBy(Ticks);
            //_TotalDupTransactionsBase.Increment();
        }

        public static void IncrementTransactions()
        {
            try
            {
                checkReset();
                if (_TotalTransactions.RawValue >= Int64.MaxValue || rS)
                {
                    _TotalTransactions.RawValue = 0;
                    rS = false;
                }
                else
                    _TotalTransactions.Increment();
            }
            catch { }
        }

        public static void IncrementDupTransactions()
        {
            try
            {
                checkReset();
                if (_TotalDupTransactions.RawValue >= Int64.MaxValue || rDS)
                {
                    _TotalDupTransactions.RawValue = 0;
                    rDS = false;
                }
                else
                    _TotalDupTransactions.Increment();
            }
            catch { }
        }

        public static void IncrementErrors()
        {
            try
            {
                checkReset();
                if (_TotalErrors.RawValue >= Int64.MaxValue || rE)
                {
                    _TotalErrors.RawValue = 0;
                    rDS = false;
                }
                else
                    _TotalErrors.Increment();
            }
            catch { }
        }

        public static void IncrementAvgFiles(long ticks)
        {
            try
            {
                _AvgFiles.IncrementBy(ticks);
                if (_AvgFilesBase.RawValue > Int64.MaxValue)
                    _AvgFilesBase.RawValue = 0;
                else
                    _AvgFilesBase.Increment();

            }
            catch { }
        }

        public static void IncrementAvgFiles(long ticks, int howmany)
        {
            try
            {
                _AvgFiles.IncrementBy(ticks);
                _AvgFilesBase.IncrementBy(howmany);

            }
            catch { }
        }

        private static void addCounter(CounterCreationDataCollection counters, string counterName, string help, PerformanceCounterType type)
        {
            // Create counter #1 and add it to the collection
            CounterCreationData tests = new CounterCreationData();
            tests.CounterName = counterName;
            tests.CounterHelp = help;
            tests.CounterType = type;
            counters.Add(tests);
        }

        private static PerformanceCounter buildPerfCounter(string name)
        {
            PerformanceCounter r = new PerformanceCounter();
            r.CategoryName = CATEGORY;
            r.CounterName = name;
            r.MachineName = ".";
            r.ReadOnly = false;
            return r;
        }

        private static DateTime lastResetDate = DateTime.Now;

        private static bool rF = false;
        private static bool rS = false;
        private static bool rDS = false;
        private static bool rE = false;

        private static object _lock = new object();
        private static void checkReset()
        {
            lock (_lock)
            {
                if (DateTime.Now.Subtract(lastResetDate).TotalHours > 24)
                {
                    Debug.WriteLine("RESET Perf Counters");
                    rF = true;
                    rS = true;
                    rS = true;
                    rE = true;
                    lastResetDate = DateTime.Now;
                }
            }
        }
    }
}