private void AddCaptureObject(CPNHSDataVO.PackDataType dataType, string userId, out CPNHSDataVO cvo)
{
cvo = null;
List <CPNHSDataVO> activeDataCapture = null;
if (CollectionUtilities.isNotEmptyContainsKey(this.activeDataCaptureObject, userId))
{
activeDataCapture = this.activeDataCaptureObject[userId];
}
else
{
activeDataCapture = new List <CPNHSDataVO>();
}
if (CollectionUtilities.isNotEmpty(activeDataCapture))
{
cvo = activeDataCapture.Last();
if ((cvo.PackType & dataType) > 0)
{
cvo = new CPNHSDataVO();
activeDataCapture.Add(cvo);
}
}
else
{
cvo = new CPNHSDataVO();
activeDataCapture.Add(cvo);
}
}
private bool UpdateCPNHSData(CPNHSDataVO cvo, bool force = false)
{
var rt = false;
lock (mutex)
{
var timeDiff = this.lastTimeStamp - DateTime.Now;
if (force || timeDiff.TotalMinutes > DEFAULT_CAPTURE_INTERVAL)
{
//Insert CPNHS data
if (cvo != null)
{
try
{
CPNHSProcedures.InsertCPNHSData(cvo);
}
catch (Exception eX)
{
FileLogger.Instance.logMessage(LogLevel.WARN, "CPNHSController", "InsertCPNHSData threw exception: {0}", eX);
return(false);
}
}
//Update last time stamp only after data insert
if (!force)
{
this.lastTimeStamp = DateTime.Now;
rt = true;
}
}
}
return(rt);
}
private void computeDataTransferOut(string userId, ref CPNHSDataVO cvo)
{
if ((cvo.PackType & CPNHSDataVO.PackDataType.DATAXFEROUT) > 0)
{
var cvoList = this.activeDataCaptureObject[userId];
var cvoListSz = cvoList.Count;
if (cvoListSz <= 1)
{
//There must be at least two entries
return;
}
//Setup the accumulator copy
var tmp = new CPNHSDataVO(cvo);
var cvoCntLat = (cvo.CurrentLatency > 0.0M) ? 1 : 0;
var cvoCntOut = (cvo.CurrentDataRateOut > 0.0M) ? 1 : 0;
for (var j = 0; j < cvoListSz - 1; ++j)
{
var curCvo = cvoList[j];
if (curCvo == null || (curCvo.PackType & CPNHSDataVO.PackDataType.DATAXFEROUT) == 0)
{
continue;
}
if (curCvo.CurrentDataRateOut > 0.0M)
{
cvoCntOut++;
tmp.NumberTransactionsOut++;
tmp.AverageDataRateOut = tmp.CurrentDataRateOut + curCvo.CurrentDataRateOut;
}
if (curCvo.CurrentLatency > 0.0M)
{
cvoCntLat++;
tmp.AverageLatency = tmp.CurrentLatency + curCvo.CurrentLatency;
}
tmp.TotalTimeTxferDataOut = tmp.TotalTimeTxferDataOut + curCvo.TotalTimeTxferDataOut;
}
//Compute data transfer averages now that they are accumulated
if (cvoCntOut > 0)
{
tmp.AverageDataRateOut /= cvoCntOut;
}
if (cvoCntLat > 0)
{
tmp.AverageLatency /= cvoCntLat;
}
//Set the ref cvo to the tmp object
cvo = tmp;
}
}
private void computeStoredProcCounts(string userId, ref CPNHSDataVO cvo)
{
if ((cvo.PackType & CPNHSDataVO.PackDataType.STOREDPROC) > 0)
{
if (CollectionUtilities.isNotEmptyContainsKey(this.storedProcCounts, userId))
{
var curStorage = this.storedProcCounts[userId];
if (CollectionUtilities.isNotEmpty(curStorage))
{
var maxCount = 0L;
var maxCountProc = string.Empty;
var maxTime = 0L;
var maxTimeProc = string.Empty;
var maxBytes = 0L;
var maxBytesProc = string.Empty;
foreach (var key in curStorage.Keys)
{
var curEntry = curStorage[key];
if (curEntry == null)
{
continue;
}
if (curEntry.Left > maxCount)
{
maxCount = curEntry.Left;
maxCountProc = key;
}
if (curEntry.Mid > maxTime)
{
maxTime = curEntry.Mid;
maxTimeProc = key;
}
if (curEntry.Right > maxBytes)
{
maxBytes = curEntry.Right;
maxBytesProc = key;
}
}
//Update stats
cvo.ClientProcTopCalledName = maxCountProc;
cvo.ClientProcTopDataName = maxBytesProc;
cvo.ClientProcTopTimeName = maxTimeProc;
}
}
}
}
public void AddGranularStoredProcData(string userId, string procName, long callPrep, long callWait, long callProcess, long callTotal, long dataTransferAmt)
{
List <QuadType <long, long, long, long> > innerList;
if (CollectionUtilities.isNotEmptyContainsKey(this.granularStoredProcCounts, userId))
{
innerList = this.granularStoredProcCounts[userId];
}
else
{
innerList = new List <QuadType <long, long, long, long> >();
this.granularStoredProcCounts.Add(userId, innerList);
}
var procStats = new QuadType <long, long, long, long>(callPrep, callWait, callProcess, callTotal);
innerList.Add(procStats);
//Get the capture object
CPNHSDataVO cvo = null;
AddCaptureObject(CPNHSDataVO.PackDataType.GRANSTOREDPROC, userId, out cvo);
//Fill in capture data
cvo.PackType |= CPNHSDataVO.PackDataType.GRANSTOREDPROC;
cvo.PackType |= CPNHSDataVO.PackDataType.DATAXFERIN;
cvo.ClientProcName = procName;
cvo.ClientCallPrepTime = callPrep;
cvo.ClientCallProcessTime = callProcess;
cvo.ClientCallTotalTime = callTotal;
cvo.ClientCallWaitTime = callWait;
cvo.NumberTransactionsIn += 1;
cvo.TotalTimeTxferDataIn += callTotal;
cvo.CurrentLatency += callWait;
//Must be in bytes per second
cvo.CurrentDataRateIn += (decimal)dataTransferAmt / (callTotal * 1000);
//Force this call through as we need every granular proc data point
UpdateInternalData(userId, true);
}
/*
* PROCEDURE insert_cpnhs (p_curdata_in IN NUMBER, -- bytes/sec
* p_curdata_out IN NUMBER, -- bytes/sec
* p_avgdata_in IN NUMBER, -- bytes/sec
* p_avgdata_out IN NUMBER, -- bytes/sec
* p_cur_latency IN NUMBER, -- ms
* p_avg_latency IN NUMBER, -- ms
* p_tottime_in IN NUMBER, -- ms
* p_tottime_out IN NUMBER, -- ms
* p_numtrans_in IN NUMBER, -- count - number times received data
* p_numtrans_out IN NUMBER, -- count - number times sent data
* p_totdata_in IN NUMBER, -- bytes - number bytes received
* p_totdata_out IN NUMBER, -- bytes - number bytes sent
* p_cli_procname IN VARCHAR2,-- procedure name
* p_cli_hifreq_proc IN VARCHAR2,-- procedure called the most during the session
* p_cli_hitime_proc IN VARCHAR2,-- procedure consuming the most time during the session
* p_cli_hidata_proc IN VARCHAR2,-- procedure consuming the most data
* p_cli_callprep IN NUMBER, -- ms
* p_cli_callwait IN NUMBER, -- ms
* p_cli_callproc IN NUMBER, -- ms
* p_cli_calltot IN NUMBER, -- ms
* p_store_number IN VARCHAR2,-- store name
* p_wkst_name IN VARCHAR2,-- workstation name
* p_user_id IN VARCHAR2,-- user id
* p_tot_sess_time IN NUMBER, -- seconds - session is alive
* p_tot_sess_act IN NUMBER, -- seconds - session is active
* p_tot_sess_inact IN NUMBER, -- seconds - session is inactive
* p_num_trans_tend IN NUMBER, -- count - number transactions tendered
* p_tot_trans_tend IN NUMBER, -- amount - total tendered during session
* o_error_code OUT NUMBER, -- error code
* o_error_text OUT VARCHAR2
*/
public static bool InsertCPNHSData(CPNHSDataVO cpnhsData)
{
if (cpnhsData == null)
{
if (FileLogger.Instance.IsLogError)
{
FileLogger.Instance.logMessage(LogLevel.ERROR, "CPNHSProcedures", "Invalid data capture object");
}
BasicExceptionHandler.Instance.AddException(
"InsertCPNHSData Failed",
new ApplicationException("InsertCPNHSData Failed: Data capture object is null"));
}
//
if (GlobalDataAccessor.Instance == null ||
!GlobalDataAccessor.Instance.IsDataAccessorValid())
{
if (FileLogger.Instance.IsLogWarn)
{
FileLogger.Instance.logMessage(LogLevel.WARN, "CPNHSProcedures", "Invalid data accessor");
}
BasicExceptionHandler.Instance.AddException(
"InsertCPNHSData Failed",
new ApplicationException("InsertCPNHSData Failed: Data accessor instance is invalid"));
return(false);
}
var inParams = new List <OracleProcParam>
{
new OracleProcParam("p_curdata_in", cpnhsData.CurrentDataRateIn),
new OracleProcParam("p_curdata_out", cpnhsData.CurrentDataRateOut),
new OracleProcParam("p_avgdata_in", cpnhsData.AverageDataRateIn),
new OracleProcParam("p_avgdata_out", cpnhsData.AverageDataRateOut),
new OracleProcParam("p_cur_latency", cpnhsData.CurrentLatency),
new OracleProcParam("p_avg_latency", cpnhsData.AverageLatency),
new OracleProcParam("p_tottime_in", cpnhsData.TotalTimeTxferDataIn),
new OracleProcParam("p_tottime_out", cpnhsData.TotalTimeTxferDataOut),
new OracleProcParam("p_numtrans_in", cpnhsData.NumberTransactionsIn),
new OracleProcParam("p_numtrans_out", cpnhsData.NumberTransactionsOut),
new OracleProcParam("p_totdata_in", cpnhsData.NumberTransactionsIn),
new OracleProcParam("p_totdata_out", cpnhsData.NumberTransactionsOut),
new OracleProcParam("p_cli_procname", cpnhsData.ClientProcName),
new OracleProcParam("p_cli_highfreq_proc", cpnhsData.ClientProcTopCalledName),
new OracleProcParam("p_cli_hitime_proc", cpnhsData.ClientProcTopTimeName),
new OracleProcParam("p_cli_hidata_proc", cpnhsData.ClientProcTopDataName),
new OracleProcParam("p_cli_callprep", cpnhsData.ClientCallPrepTime),
new OracleProcParam("p_cli_callwait", cpnhsData.ClientCallWaitTime),
new OracleProcParam("p_cli_callproc", cpnhsData.ClientCallProcessTime),
new OracleProcParam("p_cli_calltot", cpnhsData.ClientCallTotalTime),
new OracleProcParam("p_store_number", cpnhsData.StoreNumber),
new OracleProcParam("p_wkst_name", cpnhsData.WorkstationName),
new OracleProcParam("p_user_id", cpnhsData.UserID),
new OracleProcParam("p_tot_sess_time", cpnhsData.TotalSessionTime),
new OracleProcParam("p_tot_sess_act", cpnhsData.TotalSessionTimeActive),
new OracleProcParam("p_tot_sess_inact", cpnhsData.TotalSessionTimeInActive),
new OracleProcParam("p_num_trans_tend", cpnhsData.NumberTransactionsTendered),
new OracleProcParam("p_tot_trans_tend", cpnhsData.TotalAmountTendered),
};
bool retVal;
DataSet outputDataSet;
var errorCode = string.Empty;
var errorText = string.Empty;
try
{
retVal = GlobalDataAccessor.Instance.OracleDA.issueSqlStoredProcCommand(
"ccsowner",
"cpnhs",
"insert_cpnhs",
inParams,
null,
"o_error_code",
"o_error_text",
out outputDataSet);
errorCode = GlobalDataAccessor.Instance.OracleDA.ErrorCode;
errorText = GlobalDataAccessor.Instance.OracleDA.ErrorDescription;
}
catch (OracleException oEx)
{
BasicExceptionHandler.Instance.AddException("InsertCPNHS Failed", oEx);
errorCode += " --- InsertCPNHS Failed";
errorText += " --- OracleException thrown: " + oEx.Message;
FileLogger.Instance.logMessage(LogLevel.ERROR,
"CPNHSProcedures.InsertCPNHSData - Oracle exception - Code {0} Message {1}",
oEx.Number.ToString(), oEx.Message);
return(false);
}
return(true);
}
