source: nscp/modules/NSClientCompat/PDHCollector.cpp @ 5fda37e

//////////////////////////////////////////////////////////////////////////
// PDH Collector 
// 
// Functions from this file collects data from the PDH subsystem and stores 
// it for later use
// *NOTICE* that this is done in a separate thread so threading issues has 
// to be handled. I handle threading issues in the CounterListener's get/
// set accessors.
//
// Copyright (c) 2004 MySolutions NORDIC (http://www.medin.nu)
//
// Date: 2004-03-13
// Author: Michael Medin (mickem@medin.nu)
//
// This software is provided "AS IS", without a warranty of any kind.
// You are free to use/modify this code but leave this header intact.
//
//////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PDHCollector.h"


PDHCollector::PDHCollector() : cpu(BACK_INTERVAL*60/CHECK_INTERVAL), hStopEvent_(NULL) {
}
PDHCollector::~PDHCollector() 
{
        if (hStopEvent_)
                CloseHandle(hStopEvent_);
}

/**
 * Thread that collects the data every "CHECK_INTERVAL" seconds.
 *
 * @param lpParameter Not used
 * @return thread exit status
 *
 * @author mickem
 *
 * @date 03-13-2004
 *
 * @bug As this is now we have to wait for CHECK_INTERVAL seconds before the service terminates (should probably be changed into some form of event)
 * @bug If we have "custom named" counters ?
 * @bug This whole concept needs work I think.
 *
 */
DWORD PDHCollector::threadProc(LPVOID lpParameter) {
        PDH::PDHQuery pdh;
        pdh.addCounter("\\\\.\\Memory\\Commit Limit", &memCmtLim);
        pdh.addCounter("\\\\.\\Memory\\Committed Bytes", &memCmt);
        pdh.addCounter("\\\\.\\System\\System Up Time", &upTime);
        pdh.addCounter("\\\\.\\Processor(_total)\\% Processor Time", &cpu);

        try {
                pdh.open();
        } catch (const PDH::PDHException &e) {
                NSC_LOG_ERROR_STD("Failed to open performance counters: " + e.str_);
                return 0;
        }

        hStopEvent_ = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (!hStopEvent_) {
                NSC_LOG_ERROR_STD("Create StopEvent failed: " + strEx::itos(GetLastError()));
                return 0;
        }

        do {
                MutexLock mutex(mutexHandler);
                if (!mutex.hasMutex()) 
                        NSC_LOG_ERROR("Failed to get Mutex!");
                else {
                        try {
                                pdh.collect();
                        } catch (const PDH::PDHException &e) {
                                NSC_LOG_ERROR_STD("Failed to query performance counters: " + e.str_);
                        }
                } 
        }while (!(WaitForSingleObject(hStopEvent_, CHECK_INTERVAL*1000) == WAIT_OBJECT_0));

        if (!CloseHandle(hStopEvent_))
                NSC_LOG_ERROR_STD("Failed to close stopEvent handle: " + strEx::itos(GetLastError()));
        else
                hStopEvent_ = NULL;
        try {
                pdh.close();
        } catch (const PDH::PDHException &e) {
                NSC_LOG_ERROR_STD("Failed to close performance counters: " + e.str_);
        }
        return 0;
}


/**
 * Request termination of the thread (waiting for thread termination is not handled)
 */
void PDHCollector::exitThread(void) {
        if (hStopEvent_ == NULL)
                NSC_LOG_ERROR("Failed to get Mutex!");
        else
                if (!SetEvent(hStopEvent_)) {
                        NSC_LOG_ERROR_STD("SetStopEvent failed");
        }
}
/**
 * Get the average CPU usage for "time"
 * @param backItems 
 * @return average CPU usage
 */
int PDHCollector::getCPUAvrage(unsigned int backItems) {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                NSC_LOG_ERROR("Failed to get Mutex!");
                return -1;
        }
        return cpu.getAvrage(backItems);
}
/**
 * Get uptime from counter
 * @bug Do we need to collect this all the time ? (perhaps we can collect this in real time ?)
 * @return uptime for the system
 * @bug Are we overflow protected here ? (seem to recall some issues with overflow before ?)
 */
long long PDHCollector::getUptime() {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                NSC_LOG_ERROR("Failed to get Mutex!");
                return -1;
        }
        return upTime.getValue();
}
/**
 * Memory commit limit (your guess is as good as mine to what this is :)
 * @return Some form of memory check
 */
long long PDHCollector::getMemCommitLimit() {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                NSC_LOG_ERROR("Failed to get Mutex!");
                return -1;
        }
        return memCmtLim.getValue();
}
/**
 *
 * Memory committed bytes (your guess is as good as mine to what this is :)
 * @return Some form of memory check
 */
long long PDHCollector::getMemCommit() {
        MutexLock mutex(mutexHandler);
        if (!mutex.hasMutex()) {
                NSC_LOG_ERROR("Failed to get Mutex!");
                return -1;
        }
        return memCmt.getValue();
}