private static void SetupCategory()
{
if (PerformanceCounterCategory.Exists(CategoryName))
{
PerformanceCounterCategory.Delete(CategoryName);
}
if (!PerformanceCounterCategory.Exists(CategoryName))
{
CounterCreationDataCollection creationDataCollection =
new CounterCreationDataCollection();
CounterCreationData ctrCreationData = new CounterCreationData();
ctrCreationData.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
ctrCreationData.CounterName = SpeedCounterName;
creationDataCollection.Add(ctrCreationData);
CounterCreationData ctrCreationData2 = new CounterCreationData();
ctrCreationData2.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
ctrCreationData2.CounterName = SpeedBytesCounterName;
creationDataCollection.Add(ctrCreationData2);
PerformanceCounterCategory.Create(CategoryName,
"Sample TransVault category",
PerformanceCounterCategoryType.MultiInstance,
creationDataCollection);
}
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("AverageCounter64SampleCategory"))
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
return(true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return(false);
}
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("AverageTimer32SampleCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageTimer32 = new CounterCreationData();
averageTimer32.CounterType = PerformanceCounterType.AverageTimer32;
averageTimer32.CounterName = "AverageTimer32Sample";
CCDC.Add(averageTimer32);
// Add the base counter.
CounterCreationData averageTimer32Base = new CounterCreationData();
averageTimer32Base.CounterType = PerformanceCounterType.AverageBase;
averageTimer32Base.CounterName = "AverageTimer32SampleBase";
CCDC.Add(averageTimer32Base);
// Create the category.
PerformanceCounterCategory.Create("AverageTimer32SampleCategory",
"Demonstrates usage of the AverageTimer32 performance counter type",
CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - " + "AverageTimer32SampleCategory");
return(false);
}
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("SampleFractionCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData sampleFraction = new CounterCreationData();
sampleFraction.CounterType = PerformanceCounterType.SampleFraction;
sampleFraction.CounterName = "SampleFractionSample";
CCDC.Add(sampleFraction);
// Add the base counter.
CounterCreationData sampleFractionBase = new CounterCreationData();
sampleFractionBase.CounterType = PerformanceCounterType.SampleBase;
sampleFractionBase.CounterName = "SampleFractionSampleBase";
CCDC.Add(sampleFractionBase);
// Create the category.
PerformanceCounterCategory.Create("SampleFractionCategory",
"Demonstrates usage of the SampleFraction performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - SampleFractionCategory");
return(false);
}
}
private static void InitializeCounters()
{
try
{
var counterDatas =
new CounterCreationDataCollection();
// Create the counters and set their properties.
var cdCounter1 =
new CounterCreationData();
var cdCounter2 =
new CounterCreationData();
cdCounter1.CounterName = "Total Requests Handled";
cdCounter1.CounterHelp = "Total number of requests handled";
cdCounter1.CounterType = PerformanceCounterType.NumberOfItems64;
cdCounter2.CounterName = "Requests Per Secpmd";
cdCounter2.CounterHelp = "Average number of requests per second.";
cdCounter2.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
// Add both counters to the collection.
counterDatas.Add(cdCounter1);
counterDatas.Add(cdCounter2);
// Create the category and pass the collection to it.
PerformanceCounterCategory.Create(
"Socket Service Data Stats", "Stats for the socket service.",
PerformanceCounterCategoryType.MultiInstance, counterDatas);
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
}
}
public static void CreatingPerformanceCounters()
{
//1.Verify if the category exists
if (!PerformanceCounterCategory.Exists("myCounterCategory"))
{
//2. Create a counter Collection
CounterCreationDataCollection myCounterCollection = new CounterCreationDataCollection();
//3. Create counters and add them to the collection
CounterCreationData myCounter01 = new CounterCreationData();
myCounter01.CounterName = "Counter01";
myCounter01.CounterHelp = "Total number of something done";
myCounter01.CounterType = PerformanceCounterType.NumberOfItems32;
myCounterCollection.Add(myCounter01);
CounterCreationData myCounter02 = new CounterCreationData();
myCounter02.CounterName = "Counter02";
myCounter02.CounterHelp = "Total number of something not done";
myCounter02.CounterType = PerformanceCounterType.NumberOfItems32;
myCounterCollection.Add(myCounter02);
//4. Create a new category
PerformanceCounterCategory.Create("myCounterCategory", "Count something done and not done", myCounterCollection);
}
}
static void Main(string[] args)
{// TODO 1: email this to Mai
CounterCreationDataCollection counters = new CounterCreationDataCollection();
CounterCreationData totalOrders = new CounterCreationData();
totalOrders.CounterName = "# Orders";
totalOrders.CounterHelp = "Total number of orders placed";
totalOrders.CounterType = PerformanceCounterType.NumberOfItems32;
CounterCreationData ordersPerSecond = new CounterCreationData();
ordersPerSecond.CounterName = "# Orders/Sec";
ordersPerSecond.CounterHelp = "Number of orders placed per second";
ordersPerSecond.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
counters.Add(totalOrders);
counters.Add(ordersPerSecond);
// needs elevated permissions to create the counter on the windows machine
PerformanceCounterCategory.Create("MyOrdersCategories", "A sample demonstration", PerformanceCounterCategoryType.SingleInstance, counters);
// call order coffee
Program p = new Program();
p.OrderCoffee();
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists(categoryName))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageTimer32 = new CounterCreationData();
averageTimer32.CounterType = PerformanceCounterType.AverageTimer32;
averageTimer32.CounterName = counterName;
CCDC.Add(averageTimer32);
// Add the base counter.
CounterCreationData averageTimer32Base = new CounterCreationData();
averageTimer32Base.CounterType = PerformanceCounterType.AverageBase;
averageTimer32Base.CounterName = baseCounterName;
CCDC.Add(averageTimer32Base);
// Create the category.
PerformanceCounterCategory.Create(categoryName,
"Demonstrates usage of the AverageTimer32 performance counter type",
PerformanceCounterCategoryType.SingleInstance, CCDC);
Console.WriteLine("Category created - " + categoryName);
return(true);
}
else
{
Console.WriteLine("Category exists - " + categoryName);
return(false);
}
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("Memory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData memory = new CounterCreationData();
memory.CounterType = PerformanceCounterType.NumberOfItems32;
memory.CounterName = "Memory";
CCDC.Add(memory);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.MemoryBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
CCDC.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, CCDC);
return(true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return(false);
}
}
static void Main(string[] args)
{
if (!PerformanceCounterCategory.Exists("ShoppingCounter"))
{
CounterCreationDataCollection counters = new CounterCreationDataCollection();
// *1.contador para contar totais(ShoppingDone): PerformanceCounterType.NumberOfItems32 * /
CounterCreationData totalDone = new CounterCreationData();
totalDone.CounterName = "ShoppingDone";
totalDone.CounterHelp = "Número total de compras concluídas";
totalDone.CounterType = PerformanceCounterType.NumberOfItems32;
counters.Add(totalDone);
// 2.contador para contar totais(ShoppingNotDone): PerformanceCounterType.NumberOfItems32
CounterCreationData totalNotDone = new CounterCreationData();
totalNotDone.CounterName = "ShoppingNotDone";
totalNotDone.CounterHelp = "Número total de compras não concluídas";
totalNotDone.CounterType = PerformanceCounterType.NumberOfItems32;
counters.Add(totalNotDone);
// cria uma nova categoria com os contadores acima
var texto = "Os balcões de compras ajudam a montar quantas compras são feitas e como muitos não são.";
PerformanceCounterCategory.Create("ShoppingCounter", texto,
PerformanceCounterCategoryType.SingleInstance, counters);
Console.WriteLine("Contador de desempenho criado.");
}
else
{
Console.WriteLine("Contador de desempenho já criado.");
}
Console.ReadKey();
}
/// <summary>
/// This routine installs the performance counters on the local machine. Requires administrative privledges to run.
/// </summary>
public virtual void InstallPerformanceCounters()
{
try
{
CounterCreationDataCollection counterCreationDataCollection = new CounterCreationDataCollection();
CounterCreationData transactionsPerSecond = new CounterCreationData("Transactions/Second", "Transactions per second,", PerformanceCounterType.RateOfCountsPerSecond32);
CounterCreationData totalTransactions = new CounterCreationData("Total Transactions", "Total number of transactions the application has processed since it started,", PerformanceCounterType.NumberOfItems32);
CounterCreationData dailyTransactions = new CounterCreationData("Daily Transactions", "Total number of transactions the application has processed today,", PerformanceCounterType.NumberOfItems32);
CounterCreationData runningThreads = new CounterCreationData("Running Threads", "The current number of executing threads,", PerformanceCounterType.NumberOfItems32);
counterCreationDataCollection.Add(transactionsPerSecond);
counterCreationDataCollection.Add(totalTransactions);
counterCreationDataCollection.Add(dailyTransactions);
counterCreationDataCollection.Add(runningThreads);
if (!PerformanceCounterCategory.Exists(CounterCategory))
{
PerformanceCounterCategory.Create(CounterCategory, CounterCategoryHelp,
PerformanceCounterCategoryType.SingleInstance, counterCreationDataCollection);
}
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError(ex.ToString());
throw;
}
}
internal static bool RegisterPerformanceCounters(IEnumerable <TelemetryData> data)
{
int registeredCategories = 0;
foreach (var categoryGroup in data.GroupBy(x => x.Category))
{
if (!PerformanceCounterCategory.Exists(categoryGroup.Key))
{
var counterData = new CounterCreationDataCollection();
foreach (var item in data)
{
counterData.Add(new CounterCreationData(item.Name, "", item.DataTypeToCounterType()));
// Base PC name convention: keep in sync with code in PerformanceCounterHolderCollection
if (item.CounterType == TelemetryDataType.AverageCount)
{
counterData.Add(new CounterCreationData(item.Name + "Base", "", PerformanceCounterType.AverageBase));
}
}
PerformanceCounterCategory.Create(categoryGroup.Key, "", PerformanceCounterCategoryType.SingleInstance, counterData);
++registeredCategories;
}
}
return(registeredCategories > 0);
}
private bool SetupCategory()
{
// PerformanceCounterCategory.Delete("DCC2012");
if (!PerformanceCounterCategory.Exists(this.categoryName))
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.NumberOfItems32;
averageCount64.CounterName = "GetData Call Count";
counterDataCollection.Add(averageCount64);
CounterCreationData averageCount641 = new CounterCreationData();
averageCount641.CounterType = PerformanceCounterType.CounterTimer;
averageCount641.CounterName = "GetData Execution Time";
counterDataCollection.Add(averageCount641);
// Create the category.
PerformanceCounterCategory.Create("DCC2012", "Desert Code Camp.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
return(true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return(false);
}
}
public void PerformanceCounterCategory_CreateCategory()
{
WriteLine("PerformanceCounterCategory_CreateCategory");
var guid = Guid.NewGuid().ToString("N");
string name = "AverageCounter64Sample" + guid;
Assert.False(PerformanceCounterCategory.Exists(name + "Category"));
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = name;
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = name + "Base";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create(name + "Category",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
Assert.True(PerformanceCounterCategory.Exists(name + "Category"));
WriteLine("PerformanceCounterCategory_CreateCategory end");
}
public static void CreateCounters2()
{
if (!PerformanceCounterCategory.Exists("Kanters"))
{
var counters = new CounterCreationDataCollection();
var ccdCounter1 = new CounterCreationData
{
CounterName = "First",
CounterType = PerformanceCounterType.SampleFraction
};
counters.Add(ccdCounter1);
var ccdCounter2 = new CounterCreationData
{
CounterName = "Second",
CounterType = PerformanceCounterType.SampleBase
};
counters.Add(ccdCounter2);
PerformanceCounterCategory.Create(
"Kanters",
"Desc",
PerformanceCounterCategoryType.MultiInstance,
counters);
}
}
private void InitializeClicked(object sender, RoutedEventArgs e)
{
if (PerformanceCounterCategory.Exists(CategoryName))
{
PerformanceCounterCategory.Delete(CategoryName);
}
if (!PerformanceCounterCategory.Exists(CategoryName))
{
CounterCreationDataCollection creationDataCollection =
new CounterCreationDataCollection();
CounterCreationData ctrCreationData = new CounterCreationData();
ctrCreationData.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
ctrCreationData.CounterName = SpeedCounterName;
creationDataCollection.Add(ctrCreationData);
CounterCreationData ctrCreationData2 = new CounterCreationData();
ctrCreationData2.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
ctrCreationData2.CounterName = SpeedBytesCounterName;
creationDataCollection.Add(ctrCreationData2);
PerformanceCounterCategory.Create(CategoryName,
"Sample Custom category",
PerformanceCounterCategoryType.MultiInstance,
creationDataCollection);
}
currentContainer = new CountersContainer()
{
BytesPerSecCounter = SetupCounter(CategoryName, SpeedCounterName, "Task " + currentTask),
ItemsPerSecCounter = SetupCounter(CategoryName, SpeedBytesCounterName, "Task " + currentTask)
};
}
internal Common()
{
guid = Guid.NewGuid().ToString("N");
name = guid + "_Counter";
category = name + "_Category";
counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
counter = new CounterCreationData();
counter.CounterType = PerformanceCounterType.AverageCount64;
counter.CounterName = name;
counterDataCollection.Add(counter);
// Add the base counter.
counterBase = new CounterCreationData();
counterBase.CounterType = PerformanceCounterType.AverageBase;
baseName = name + "Base";
counterBase.CounterName = baseName;
counterDataCollection.Add(counterBase);
// Create the category.
PerformanceCounterCategory.Create(category, "description",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
counterSample = new PerformanceCounter(category, name, false);
counterSample.RawValue = 0;
pcc = new PerformanceCounterCategory(category);
}
public void Install(WindowsIdentity identity)
{
Console.WriteLine("Starting installation of PerformanceCounters ");
var categoryName = "NServiceBus";
if (PerformanceCounterCategory.Exists(categoryName))
{
Console.WriteLine("Category " + categoryName + " already exist, going to delete first");
PerformanceCounterCategory.Delete(categoryName);
}
var data = new CounterCreationDataCollection();
data.Add(new CounterCreationData("Critical Time", "Age of the oldest message in the queue",
PerformanceCounterType.NumberOfItems32));
data.Add(new CounterCreationData("SLA violation countdown", "Seconds until the SLA for this endpoint is breached",
PerformanceCounterType.NumberOfItems32));
PerformanceCounterCategory.Create(categoryName, "NServiceBus statistics",
PerformanceCounterCategoryType.MultiInstance, data);
Console.WriteLine("Installation of PerformanceCounters successful.");
}
public static void Initialize()
{
CounterCreationDataCollection counters = new CounterCreationDataCollection();
CounterCreationData counter = new CounterCreationData(
"Total Files Copied", "Total number of files copied by the application.",
PerformanceCounterType.NumberOfItems32);
counters.Add(counter);
counter = new CounterCreationData(
"% Files Copied", "Percent of files copied in the current operation.",
PerformanceCounterType.NumberOfItems32);
counters.Add(counter);
if (PerformanceCounterCategory.Exists("FileCopier"))
{
PerformanceCounterCategory.Delete("FileCopier");
}
PerformanceCounterCategory.Create("FileCopier",
"Instrumentation of the FileCopier application.",
PerformanceCounterCategoryType.SingleInstance,
counters);
_totalFilesCounter = new PerformanceCounter(
"FileCopier", "Total Files Copied", false);
_percentDoneCounter = new PerformanceCounter(
"FileCopier", "% Files Copied", false);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("CShaerpExamPerformanceCounterTest"))
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("CShaerpExamPerformanceCounterTest",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
// When monitoring performance later, you will see how both counters work together.
// It is important to know that the supporting counter always must follow the counter which will monitor performance!
return(true);
}
else
{
Console.WriteLine("Category exists - CShaerpExamPerformanceCounterTest");
return(false);
}
}
private void InstallPerformanceCounters()
{
if (!PerformanceCounterCategory.Exists("nHydrate"))
{
var counters = new CounterCreationDataCollection();
// 1. counter for counting totals: PerformanceCounterType.NumberOfItems32
var totalAppointments = new CounterCreationData();
totalAppointments.CounterName = "# appointments processed";
totalAppointments.CounterHelp = "Total number of appointments processed.";
totalAppointments.CounterType = PerformanceCounterType.NumberOfItems32;
counters.Add(totalAppointments);
// 2. counter for counting operations per second:
// PerformanceCounterType.RateOfCountsPerSecond32
var appointmentsPerSecond = new CounterCreationData();
appointmentsPerSecond.CounterName = "# appointments / sec";
appointmentsPerSecond.CounterHelp = "Number of operations executed per second";
appointmentsPerSecond.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
counters.Add(appointmentsPerSecond);
// create new category with the counters above
PerformanceCounterCategory.Create("nHydrate", "nHydrate Category", counters);
}
}
private void CreatePerformanceCounter()
{
CounterCreationDataCollection counters = new CounterCreationDataCollection();
CounterCreationData configVersionPerSecond = new CounterCreationData();
configVersionPerSecond.CounterName = CONFIG_VERSION_COUNTER;
configVersionPerSecond.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
configVersionPerSecond.CounterHelp = "configuration version response count per second";
counters.Add(configVersionPerSecond);
CounterCreationData resourceMgrPerSecond = new CounterCreationData();
resourceMgrPerSecond.CounterName = RESOURCE_MGR_COUNTER;
resourceMgrPerSecond.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
resourceMgrPerSecond.CounterHelp = "resource manager response count per second";
counters.Add(resourceMgrPerSecond);
CounterCreationData configMgrPerSecond = new CounterCreationData();
configMgrPerSecond.CounterName = CONFIG_MGR_COUNTER;
configMgrPerSecond.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
configMgrPerSecond.CounterHelp = "configuration management response count per second";
counters.Add(configMgrPerSecond);
PerformanceCounterCategory.Create(REMOTE_CONFIGURATION,
"Remote Configuration Management Counter",
PerformanceCounterCategoryType.SingleInstance, counters);
}
public static void CreateCategory()
{
if (!PerformanceCounterCategory.Exists("MentoringCategory"))
{
var counterCollection = new CounterCreationDataCollection();
//log in counter
var logInCounter = new CounterCreationData();
logInCounter.CounterType = PerformanceCounterType.NumberOfItems32;
logInCounter.CounterName = "LogInCounter";
counterCollection.Add(logInCounter);
var logOutCounter = new CounterCreationData();
logOutCounter.CounterType = PerformanceCounterType.NumberOfItems32;
logOutCounter.CounterName = "LogOutCounter";
counterCollection.Add(logOutCounter);
var homePageVisitCounter = new CounterCreationData();
homePageVisitCounter.CounterType = PerformanceCounterType.NumberOfItems32;
homePageVisitCounter.CounterName = "HomePageVisitCounter";
counterCollection.Add(homePageVisitCounter);
PerformanceCounterCategory.Create("MentoringCategory", "MentoringCategory", PerformanceCounterCategoryType.SingleInstance, counterCollection);
}
}
public static void PerformanceCounterCategory_CreateCategory()
{
if (!PerformanceCounterCategory.Exists("AverageCounter64SampleCategory"))
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
}
Assert.True(PerformanceCounterCategory.Exists("AverageCounter64SampleCategory"));
PerformanceCounterCategory.Delete("AverageCounter64SampleCategory");
}
/// <summary>
/// Instala la categoría y sus contadores asociados en la máquina
/// </summary>
/// <param name="category">Categoría a instalar</param>
private static void InstallPerformanceCounterCategory(CounterCategoryData category)
{
CounterCreationDataCollection counterDataCol = new CounterCreationDataCollection();
foreach (CounterData counterData in category.GetAllCounters())
{
CounterCreationData creationData;
creationData = new CounterCreationData(
counterData.Name,
counterData.Description,
counterData.Type);
counterDataCol.Add(creationData);
if (counterData.HasBaseCounter)
{
creationData = new CounterCreationData(
counterData.BaseName,
counterData.BaseDescription,
counterData.BaseType);
counterDataCol.Add(creationData);
}
}
try
{
PerformanceCounterCategory.Create(category.Name, category.Description,
category.Type, counterDataCol);
}
catch (SecurityException uex)
{
throw new InstrumentationException(string.Format(
Messages.InsufficientPermissionsForCounterCategoryCreation, category.Name), uex);
}
}
//<Snippet4>
public static void CreateCounters()
{
//<Snippet2>
CounterCreationData data1 = new CounterCreationData("Trucks",
"Number of orders", PerformanceCounterType.NumberOfItems32);
CounterCreationData data2 = new CounterCreationData("Rate of sales",
"Orders/second", PerformanceCounterType.RateOfCountsPerSecond32);
CounterCreationDataCollection ccds = new CounterCreationDataCollection();
ccds.Add(data1);
ccds.Add(data2);
Console.WriteLine("Creating Orders custom counter.");
if (!PerformanceCounterCategory.Exists("Orders"))
{
PerformanceCounterCategory.Create("Orders",
"Processed orders",
PerformanceCounterCategoryType.MultiInstance,
ccds);
}
//</Snippet2>
//<Snippet3>
Console.WriteLine("Creating Inventory custom counter");
if (!PerformanceCounterCategory.Exists("Inventory"))
{
PerformanceCounterCategory.Create("Inventory",
"Truck inventory",
PerformanceCounterCategoryType.SingleInstance,
"Trucks", "Number of trucks on hand");
}
//</Snippet3>
}
// Static Constructor
static PerformanceMonitor()
{
try
{
if (!PerformanceCounterCategory.Exists(ThreadPoolCountersCategoryName))
{
CounterCreationDataCollection customPerformanceCounters = new CounterCreationDataCollection();
// Create custom counter objects for thread pool monitoring
CounterCreationData workerThreadCounter = new CounterCreationData();
workerThreadCounter.CounterName = "Worker Threads";
workerThreadCounter.CounterHelp = "Active worker threads in the thread pool";
workerThreadCounter.CounterType = PerformanceCounterType.NumberOfItems32;
CounterCreationData completionPortThreadCounter = new CounterCreationData();
completionPortThreadCounter.CounterName = "Completion Port Threads";
completionPortThreadCounter.CounterHelp = "Active completion port threads in the thread pool";
completionPortThreadCounter.CounterType = PerformanceCounterType.NumberOfItems32;
// Add custom counter objects to CounterCreationDataCollection
customPerformanceCounters.Add(workerThreadCounter);
customPerformanceCounters.Add(completionPortThreadCounter);
// Bind the counters to the PerformanceCounterCategory
PerformanceCounterCategory.Create(ThreadPoolCountersCategoryName, "Application thread pool counters", PerformanceCounterCategoryType.MultiInstance, customPerformanceCounters);
}
}
catch
{
// Not failing if custom counters cannot be created
}
}
private void LoadTestStarting(object sender, EventArgs e)
{
// Delete the category if already exists
if (PerformanceCounterCategory.Exists("AMSStressCounterSet"))
{
PerformanceCounterCategory.Delete("AMSStressCounterSet");
}
CounterCreationDataCollection counters = new CounterCreationDataCollection();
// 1. counter for counting totals: PerformanceCounterType.NumberOfItems32
CounterCreationData totalOps = new CounterCreationData();
totalOps.CounterName = "# operations executed";
totalOps.CounterHelp = "Total number of operations executed";
totalOps.CounterType = PerformanceCounterType.NumberOfItems32;
counters.Add(totalOps);
// 2. counter for counting operations per second:
// PerformanceCounterType.RateOfCountsPerSecond32
CounterCreationData opsPerSecond = new CounterCreationData();
opsPerSecond.CounterName = "# operations / sec";
opsPerSecond.CounterHelp = "Number of operations executed per second";
opsPerSecond.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
counters.Add(opsPerSecond);
// create new category with the counters above
PerformanceCounterCategory.Create("AMSStressCounterSet", "KeyDelivery Stress Counters", PerformanceCounterCategoryType.SingleInstance, counters);
}
void Initialize()
{
if (!PerformanceCounterCategory.Exists(category))
{
var counterDataCollection = new CounterCreationDataCollection();
var counterTotal = new CounterCreationData(TotalMessagesProcessed, "Total processed messages by application",
PerformanceCounterType.NumberOfItems64);
counterDataCollection.Add(counterTotal);
var counterRate = new CounterCreationData(RateMessagesProcessed, "Average messages per second",
PerformanceCounterType.RateOfCountsPerSecond64);
counterDataCollection.Add(counterRate);
var counterAvg = new CounterCreationData(AverageMessagesDuration, "Average message processing time in ms",
PerformanceCounterType.AverageCount64);
counterDataCollection.Add(counterAvg);
var counterAvgBase = new CounterCreationData(AverageMessagesDurationBase,
"Base average message processing time in ms",
PerformanceCounterType.AverageBase);
counterDataCollection.Add(counterAvgBase);
PerformanceCounterCategory.Create(category, "Saritasa Tools Messages", PerformanceCounterCategoryType.SingleInstance,
counterDataCollection);
}
performanceCounterTotal = new PerformanceCounter(category, TotalMessagesProcessed, false);
performanceCounterRate = new PerformanceCounter(category, RateMessagesProcessed, false);
performanceCounterAvg = new PerformanceCounter(category, AverageMessagesDuration, false);
performanceCounterAvgBase = new PerformanceCounter(category, AverageMessagesDurationBase, false);
initialized = true;
}
/// <summary>
/// Initialize custom performance counters for this role.
/// Note that custom performance counter creation requires elevated priveleges
/// for the role. A role instance will not initialize successfully on
/// Windows Azure if these calls are made without elevated priveleges.
/// If the instance is restarted within the host, or in the development emulator,
/// the counters will already exist.
/// </summary>
private static void InitializeCustomPerformanceCounters()
{
if (!PerformanceCounterCategory.Exists(CustomCounterCategory))
{
CounterCreationDataCollection counterCollection = new CounterCreationDataCollection();
// add a counter tracking user button1 clicks
CounterCreationData operationTotal1 = new CounterCreationData();
operationTotal1.CounterName = CustomCounter1Name;
operationTotal1.CounterHelp = CustomCounter1Description;
operationTotal1.CounterType = PerformanceCounterType.NumberOfItems32;
counterCollection.Add(operationTotal1);
// add a counter tracking user button2 clicks
CounterCreationData operationTotal2 = new CounterCreationData();
operationTotal2.CounterName = CustomCounter2Name;
operationTotal2.CounterHelp = CustomCounter2Description;
operationTotal2.CounterType = PerformanceCounterType.NumberOfItems32;
counterCollection.Add(operationTotal2);
PerformanceCounterCategory.Create(
CustomCounterCategory,
CustomCounterCategoryDescription,
PerformanceCounterCategoryType.SingleInstance,
counterCollection);
Trace.WriteLine("Custom counter category created.");
}
else
{
Trace.WriteLine("Custom counter category already exists.");
}
}
//public static void Main()
//{
// ArrayList samplesList = new ArrayList();
// SetupCategory();
// CreateCounters();
// CollectSamples(samplesList);
//}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("ElapsedTimeSampleCategory"))
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData ETimeData = new CounterCreationData();
ETimeData.CounterType = PerformanceCounterType.ElapsedTime;
ETimeData.CounterName = "ElapsedTimeSample";
CCDC.Add(ETimeData);
// Create the category.
PerformanceCounterCategory.Create("ElapsedTimeSampleCategory",
"Demonstrates usage of the ElapsedTime performance counter type.",
CCDC);
return (true);
}
else
{
Console.WriteLine("Category exists - ElapsedTimeSampleCategory");
return (false);
}
}
private static Dictionary<string, PerformanceCounter> CreatePerfCounters(string perfCounterCategoryName, string[] perfCounterNames, bool overWriteCounters)
{
CounterCreationDataCollection counters = new CounterCreationDataCollection();
foreach (string perfCounterName in perfCounterNames)
{
counters.Add(new CounterCreationData(perfCounterName, "", PerformanceCounterType.NumberOfItems64));
}
if (overWriteCounters)
{
if (PerformanceCounterCategory.Exists(perfCounterCategoryName))
{
PerformanceCounterCategory.Delete(perfCounterCategoryName);
}
PerformanceCounterCategory.Create(perfCounterCategoryName, "", PerformanceCounterCategoryType.SingleInstance, counters);
}
else
{
if (!PerformanceCounterCategory.Exists(perfCounterCategoryName))
{
PerformanceCounterCategory.Create(perfCounterCategoryName, "", PerformanceCounterCategoryType.SingleInstance, counters);
}
}
Dictionary<string, PerformanceCounter> perfCounterLookup = new Dictionary<string, PerformanceCounter>();
foreach (string perfCounterName in perfCounterNames)
{
perfCounterLookup.Add(perfCounterName, new PerformanceCounter(perfCounterCategoryName, perfCounterName, false));
}
return perfCounterLookup;
}
public static void Main()
{
string categoryName = "Sample Perf Counters";
string[] counterNames = {"Counter 1", "Counter 2"};
CounterCreationDataCollection counters = new CounterCreationDataCollection();
foreach (string counterName in counterNames)
{
counters.Add(new CounterCreationData(counterName, "", PerformanceCounterType.NumberOfItems64));
}
// example of recreating the counters
if (PerformanceCounterCategory.Exists(categoryName))
{
PerformanceCounterCategory.Delete(categoryName);
}
PerformanceCounterCategory.Create(categoryName, "", PerformanceCounterCategoryType.SingleInstance, counters);
// example of conditionally creating the counters
if (!PerformanceCounterCategory.Exists(categoryName))
{
PerformanceCounterCategory.Create(categoryName, "", PerformanceCounterCategoryType.SingleInstance, counters);
}
// update the counters (don't create a new instance each time you update)
List<PerformanceCounter> perfCounters = new List<PerformanceCounter>();
foreach (string counterName in counterNames)
{
perfCounters.Add(new PerformanceCounter(categoryName, counterName, false));
}
Random rand = new Random();
while (true)
{
foreach (PerformanceCounter perfCounter in perfCounters)
{
perfCounter.RawValue = rand.Next(101);
}
Thread.Sleep(2000);
}
}
static void Main(string[] args)
{
if (args.Length <= 1)
{
System.Console.WriteLine("Please enter CounterGroup and Counters");
System.Console.WriteLine("Usage: executable <CounterGroup> <Counter1> <CounterN>");
return;
}
if (args.Length == 2) {
if (args[0].Equals("delete")) {
if (PerformanceCounterCategory.Exists(args[1]))
{
PerformanceCounterCategory.Delete(args[1]);
Console.Out.WriteLine("Deleting perfGroup: " + args[1]);
}
return;
}
}
CounterCreationDataCollection col = new CounterCreationDataCollection();
String metrics_name = args[0];
for (int i = 1; i < args.Length; i++) {
Console.Out.WriteLine("Adding counters: " + args[i]);
CounterCreationData counter = new CounterCreationData();
counter.CounterName = args[i];
counter.CounterHelp = args[i];
counter.CounterType = PerformanceCounterType.NumberOfItems32;
col.Add(counter);
}
if (PerformanceCounterCategory.Exists(metrics_name))
{
PerformanceCounterCategory.Delete(metrics_name);
Console.Out.WriteLine("Deleting perfGroup:" + metrics_name);
}
PerformanceCounterCategory category = PerformanceCounterCategory.Create(metrics_name,
"Perf Category Description ", col);
Console.Out.WriteLine("Creating perfGroup:" + metrics_name);
}
private static bool SetupCategory()
{
if (!PerformanceCounterCategory.Exists("AverageCounter64SampleCategory"))
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
return (true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return (false);
}
}
public void AddCounterToCollection(CounterCreationDataCollection counterData)
{
CounterCreationData counterCreationData = new CounterCreationData(
_counterName,
_counterHelp,
_pcType);
counterData.Add(counterCreationData);
}