Taking a computer "performance snapshot"

Question

I was asked at work today to create a tool for end-users to run whenever they're experiencing "performance issues". This is in reaction to an increasingly large number of reports of several computers and/or applications experiencing extreme performance problems. Because of the large number of reports, we need this data collection to happen automatically, so we can drill down on the data later.

I've set up a backend to collect the information and am already collection a bunch of information, but I'm having trouble collecting performance data of processes. Here's what I looked into:

1) Using System.Diagnotics.Process.GetProcesses():

This gets me a list of all running procs, which is good, but this requires the application to be able to run elevated apparently, as it throws exceptions whenever I want to collect UserProcessorTime, even though this information is available for every non-admin user for his own processes in the Task Manager. It also throws exceptions even when running as a full-blown admin user.

2) Using PerformanceCounter

Performance counters seem pretty powerfull, but I've had trouble matching a performance counter by process id, and it would seem performance counters are mostly used to track performance over a period of time. That's not the case here. We're mainly looking for a pattern of processes going haywire.

Basically, what we're looking for (more or less) is a quick snapshot of the information that's displayed in the process list of the task manager (process name, cpu cycles, private memory usage) and without the need for application to run elevated (process list can be limited to user procs). This is in accordance of what was asked of me.

EDIT: Here's some code I tried to use, sorry for not providing any earlier

Here's an example that tries to use Performance Counters to get the '% Processor Time' and 'Working Set - Private' for all processes.

PerformanceCounterCategory perfCategory = PerformanceCounterCategory.GetCategories().First(c => c.CategoryName == "Process");
Console.WriteLine("{0} [{1}]", perfCategory.CategoryName, perfCategory.CategoryType);
string[] instanceNames = perfCategory.GetInstanceNames();

if (instanceNames.Length > 0)
{
    foreach (string instanceName in instanceNames)
    {
        Console.WriteLine("    {0}", instanceName);
        PerformanceCounter[] counters = perfCategory.GetCounters(instanceName);

        foreach (PerformanceCounter counter in counters)
        {
            if (counter.CounterName == "Working Set - Private")
            {
                Console.WriteLine("        {0} - {1}", counter.CounterName, counter.RawValue, counter.RawValue / 1024);
            }
            if (counter.CounterName == "% Processor Time")
            {
                Console.WriteLine("        {0} - {1}", counter.CounterName, counter.RawValue);
            }
        }
    }
}

The results for 'Working Set - Private' are spot on, but for '% Processor Time', these values make no sense whatsoever.

Here's an example of the output, as you can see, % Processor Time results make no sense whatsoever:

WDExpress#1
    % Processor Time - 378146424
    Working Set - Private - 136257536
taskhost
    % Processor Time - 129480830
    Working Set - Private - 1835008
svchost
    % Processor Time - 2877438445
    Working Set - Private - 4096000
IpOverUsbSvc
    % Processor Time - 15600100
    Working Set - Private - 1236992
vncserver
    % Processor Time - 238213527
    Working Set - Private - 2555904
chrome#21
    % Processor Time - 1652830595
    Working Set - Private - 56799232

EDIT 2:

Scott already provided a large part of the answer, but now I'm still facing other issues with both options below:

1. Fast, inaccurate, bombs CPU

   counter.NextValue();
   Console.WriteLine("{0} - {1}", counter.CounterName, counter.NextValue());
   

Calling NextValue() twice after each other collects data very fast, but pretty much bombards my CPU (and results are probably sub-optimal).

2. Accurate, VERY slow, easy on the CPU

   counter.NextValue();
   System.Threading.Thread.Sleep(1000);
   Console.WriteLine("{0} - {1}", counter.CounterName, counter.NextValue());
   

The other option is to Thread.Sleep() between each call to NextValue(), but that makes it very slow (as we're probably talking about 100+ processes)

Answer 1

Your problem with processor time is you are not supposed to use RawValue on it (you really should not use it for working set either). For processor time you must take two samples calling NextValue, One you get a 2nd sample you will have accurate numbers.

PerformanceCounterCategory perfCategory = PerformanceCounterCategory.GetCategories().First(c => c.CategoryName == "Process");
Console.WriteLine("{0} [{1}]", perfCategory.CategoryName, perfCategory.CategoryType);
string[] instanceNames = perfCategory.GetInstanceNames();

if (instanceNames.Length > 0)
{
    foreach (string instanceName in instanceNames)
    {
        Console.WriteLine("    {0}", instanceName);
        PerformanceCounter[] counters = perfCategory.GetCounters(instanceName);

        //Go through each processor counter once to get the first value, should just return 0.
        foreach (PerformanceCounter counter in counters)
        {
            if (counter.CounterName == "% Processor Time")
            {
                counter.NextValue();
            }            
        }

        //You need to wait at least 100ms between samples to get useful values, the longer you wait the better the reading.
        Thread.Sleep(150);

        foreach (PerformanceCounter counter in counters)
        {
            if (counter.CounterName == "Working Set - Private")
            {
                Console.WriteLine("        {0} - {1}", counter.CounterName, counter.RawValue, counter.RawValue / 1024);
            }
            if (counter.CounterName == "% Processor Time")
            {
                Console.WriteLine("        {0} - {1:N1}", counter.CounterName, counter.NextValue());
            }
        }
    }
}