use of com.axway.ats.agent.core.monitoring.UserActionsMonitoringAgent in project ats-framework by Axway.
the class RestSystemMonitor method startMonitoringAgent.
private List<MonitoringException> startMonitoringAgent(String monitoredAgent, long startTimestamp, int pollInterval) {
List<MonitoringException> errors = new ArrayList<MonitoringException>();
log.debug("Starting ATS Agent monitoring on " + monitoredAgent);
UserActionsMonitoringAgent userActionsMonitoringAgent = UserActionsMonitoringAgent.getInstance(ThreadsPerCaller.getCaller());
userActionsMonitoringAgent.setAgentAddress(monitoredAgent);
userActionsMonitoringAgent.startMonitoring(startTimestamp, pollInterval);
return errors;
}
use of com.axway.ats.agent.core.monitoring.UserActionsMonitoringAgent in project ats-framework by Axway.
the class AbstractActionTask method invokeActions.
/**
* Invoke one iteration of all actions in the queue
*
* @throws InterruptedException
*/
protected final void invokeActions() throws InterruptedException {
UserActionsMonitoringAgent userActionsMonitoringAgent = UserActionsMonitoringAgent.getInstance(caller);
if (log.isDebugEnabled()) {
log.debug("Starting '" + queueName + "' queue for " + (++nIterations) + "th time");
}
// generate the input arguments for all action invokers
generateInputArguments();
long queueDuration = 0;
long actionStartTimestamp = 0;
long actionEndTimestamp = 0;
if (this.itManager != null) {
// inform a new iteration is starting now
this.itManager.setIterationStartTime(this, System.currentTimeMillis());
}
try {
for (int i = 0; i < actionInvokers.size(); i++) {
// start cycling all actions in this iteration
ActionInvoker actionInvoker = actionInvokers.get(i);
Object actionClassInstance = actionClassInstances.get(i);
ActionMethod actionMethod = actionInvoker.getActionMethod();
final String actionName = actionInvoker.getActionName();
final String transferUnit = actionMethod.getTransferUnit();
// read some settings
final boolean registerActionExecution = actionMethod.isRegisterActionExecution();
final boolean registerActionExecutionInQueueExecutionTime = actionMethod.isRegisterActionExecutionInQueueExecutionTime();
final boolean isTemplateActionMethod = actionMethod instanceof TemplateActionMethod;
final boolean logCheckpoints = !isTemplateActionMethod || REGISTER_FULL_AND_NET_ACTION_TIME_FOR_TEMPLATE_ACTIONS;
// checkpoint name. For template actions by default only network time is tracked.
// Here "-full" adds total action processing including XML (de)serializations, parameterization
String checkpointName;
if (!isTemplateActionMethod) {
checkpointName = actionName;
} else {
checkpointName = actionName + "-full";
}
// start a checkpoint
userActionsMonitoringAgent.actionStarted(actionName);
if (registerActionExecution) {
actionStartTimestamp = System.currentTimeMillis();
if (logCheckpoints && !isLoggingInBatchMode) {
log.startCheckpoint(checkpointName, transferUnit, actionStartTimestamp);
}
}
// invoke the current action
Object actionReturnedResult = null;
try {
actionReturnedResult = actionInvoker.invoke(actionClassInstance);
} catch (Exception e) {
// the action failed - end the checkpoint
if (registerActionExecution) {
if (logCheckpoints) {
if (isLoggingInBatchMode) {
log.insertCheckpoint(checkpointName, actionStartTimestamp, 0, 0, transferUnit, CheckpointResult.FAILED);
} else {
log.endCheckpoint(checkpointName, 0, CheckpointResult.FAILED);
}
}
QueueExecutionStatistics.getInstance().registerActionExecutionResult(queueName, actionName, false);
log.insertCheckpoint(ATS_ACTION__QUEUE_EXECUTION_TIME, queueDuration, CheckpointResult.FAILED);
}
// re-throw the exception
throw e;
} finally {
userActionsMonitoringAgent.actionEnded(actionName);
}
// the action passed
if (registerActionExecution) {
actionEndTimestamp = System.currentTimeMillis();
long responseTimeMs = actionEndTimestamp - actionStartTimestamp;
long transferSize = 0;
if (transferUnit.length() > 0) {
transferSize = (Long) actionReturnedResult;
}
if (logCheckpoints) {
if (isLoggingInBatchMode) {
log.insertCheckpoint(checkpointName, actionStartTimestamp, responseTimeMs, transferSize, transferUnit, CheckpointResult.PASSED);
} else {
log.endCheckpoint(checkpointName, transferSize, CheckpointResult.PASSED, actionEndTimestamp);
}
}
if (registerActionExecutionInQueueExecutionTime) {
if (isTemplateActionMethod) {
// add net time in queue instead of full processing time
if (actionReturnedResult instanceof CompositeResult) {
CompositeResult res = (CompositeResult) actionReturnedResult;
responseTimeMs = res.getReqRespNetworkTime();
}
}
queueDuration += responseTimeMs;
}
QueueExecutionStatistics.getInstance().registerActionExecutionResult(queueName, actionName, true);
}
}
// end cycling all actions in this iteration
} catch (Exception e) {
// We are particularly interested if the thread was interrupted
Throwable cause = e.getCause();
if (cause != null && cause instanceof InterruptedException) {
// the thread was interrupted
if (this.timedOut) {
// the thread was interrupted due to timeout, log the timeout and go to next iteration
log.error("Iteration timed out in " + this.timedOutSeconds + " seconds - skipping to next iteration");
// reset our flag as we will start another iteration
this.timedOut = false;
this.timedOutSeconds = 0;
} else {
// the thread interrupted, but not due to timeout, maybe the user cancelled the queue
this.externallyInterrupted = true;
throw (InterruptedException) cause;
}
} else {
// some kind of generic exception has occurred
log.error("Exception caught during invocation - skipping to next iteration", e);
}
// continue to the next iteration
return;
} finally {
if (this.itManager != null) {
this.itManager.clearIterationStartTime();
}
}
log.insertCheckpoint(ATS_ACTION__QUEUE_EXECUTION_TIME, queueDuration, CheckpointResult.PASSED);
}
Aggregations