timingSum += stepProfiler.stopInfo(step.getDescription());
}
item.dto.setStatus(SUCCESS);
- queueStatus.addSuccess();
+ long timing = logProcessingEnd(message, profiler, timingSum);
+ queueStatus.addSuccess(timing);
} catch (Throwable e) {
item.dto.setStatus(FAILED);
- queueStatus.addError();
+ long timing = logProcessingEnd(message, profiler, timingSum);
+ queueStatus.addError(timing);
throw Throwables.propagate(e);
} finally {
item.dto.setFinishedAt(system.now());
activityManager.saveActivity(item.dto);
- profiler.stopInfo(format("%s total time spent in steps=%sms", message, timingSum));
}
}
+
+ private static long logProcessingEnd(String message, Profiler profiler, long timingSum) {
+ return profiler.stopInfo(format("%s total time spent in steps=%sms", message, timingSum));
+ }
}
/**
* Adds 1 to the count of batch reports which processing ended with an error and removes 1 from the count of batch
- * reports under processing.
+ * reports under processing. Adds the specified time to the processing time counter.
+ *
+ * @param processingTime duration of processing in ms
*
* @return the new count of batch reports which processing ended with an error
*
* @see #getErrorCount()
* @see #getInProgressCount()
+ *
+ * @throws IllegalArgumentException if processingTime is < 0
*/
- long addError();
+ long addError(long processingTime);
/**
* Count of batch reports which processing ended with an error since instance startup.
/**
* Adds 1 to the count of batch reports which processing ended successfully and removes 1 from the count of batch
- * reports under processing.
+ * reports under processing. Adds the specified time to the processing time counter.
+ *
+ * @param processingTime duration of processing in ms
*
* @return the new count of batch reports which processing ended successfully
*
* @see #getSuccessCount()
* @see #getInProgressCount()
+ *
+ * @throws IllegalArgumentException if processingTime is < 0
*/
- long addSuccess();
+ long addSuccess(long processingTime);
/**
* Count of batch reports which processing ended successfully since instance startup.
*/
long getSuccessCount();
+
+ /**
+ * Time spent processing batch reports since startup.
+ */
+ long getProcessingTime();
}
private final AtomicLong inProgress = new AtomicLong(0);
private final AtomicLong error = new AtomicLong(0);
private final AtomicLong success = new AtomicLong(0);
+ private final AtomicLong processingTime = new AtomicLong(0);
@Override
public long addReceived() {
}
@Override
- public long addError() {
+ public long addError(long processingTime) {
+ addProcessingTime(processingTime);
inProgress.decrementAndGet();
return error.incrementAndGet();
}
}
@Override
- public long addSuccess() {
+ public long addSuccess(long processingTime) {
+ addProcessingTime(processingTime);
inProgress.decrementAndGet();
return success.incrementAndGet();
}
+ private void addProcessingTime(long time) {
+ checkArgument(time >= 0, "Processing time can not be < 0");
+ processingTime.addAndGet(time);
+ }
+
@Override
public long getSuccessCount() {
return success.get();
}
+
+ @Override
+ public long getProcessingTime() {
+ return processingTime.get();
+ }
}
attributes.put("In progress", getInProgressCount());
attributes.put("Successfully processed", getSuccessCount());
attributes.put("Processed with error", getErrorCount());
+ attributes.put("Processing time", getProcessingTime());
return attributes;
}
public long getSuccessCount() {
return queueStatus.getSuccessCount();
}
+
+ @Override
+ public long getProcessingTime() {
+ return queueStatus.getProcessingTime();
+ }
}
long getReceivedCount();
/**
- * Count of batch report waiting for processing since startup, including reports received before instance startup.
+ * Count of batch reports waiting for processing since startup, including reports received before instance startup.
*/
long getPendingCount();
/**
- * Count of batch report under processing.
+ * Count of batch reports under processing.
*/
long getInProgressCount();
/**
- * Count of batch report which processing ended with an error since instance startup.
+ * Count of batch reports which processing ended with an error since instance startup.
*/
long getErrorCount();
/**
- * Count of batch report which processing ended successfully since instance startup.
+ * Count of batch reports which processing ended successfully since instance startup.
*/
long getSuccessCount();
+
+ /**
+ * Time spent processing reports since startup.
+ */
+ long getProcessingTime();
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
verify(activityManager).saveActivity(dto);
verify(queueStatus).addInProgress();
- verify(queueStatus).addSuccess();
+ verify(queueStatus).addSuccess(anyLong());
verifyNoMoreInteractions(queueStatus);
}
assertThat(dto.getFinishedAt()).isNotNull();
verify(queueStatus).addInProgress();
- verify(queueStatus).addError();
+ verify(queueStatus).addError(anyLong());
verifyNoMoreInteractions(queueStatus);
}
}
assertThat(dto.getFinishedAt()).isNotNull();
verify(queueStatus).addInProgress();
- verify(queueStatus).addError();
+ verify(queueStatus).addError(anyLong());
verifyNoMoreInteractions(queueStatus);
}
}
assertThat(underTest.getInProgressCount()).isEqualTo(1);
assertThat(underTest.getErrorCount()).isEqualTo(17);
assertThat(underTest.getSuccessCount()).isEqualTo(80);
+ assertThat(underTest.getProcessingTime()).isEqualTo(177);
}
private List<Runnable> buildShuffleCallsToUnderTest() {
private class AddErrorRunnable implements Runnable {
@Override
public void run() {
- underTest.addError();
+ underTest.addError(1);
}
}
private class AddSuccessRunnable implements Runnable {
@Override
public void run() {
- underTest.addSuccess();
+ underTest.addSuccess(2);
}
}
}
public class CEQueueStatusImplTest {
private static final String ISE_initPendingCount_CALL_MSG = "Method initPendingCount must be used before any other method and can not be called twice";
private static final int SOME_RANDOM_MAX = 96535;
+ private static final int SOME_PROCESSING_TIME = 8723;
@Rule
public ExpectedException expectedException = ExpectedException.none();
assertThat(underTest.getInProgressCount()).isEqualTo(0);
assertThat(underTest.getErrorCount()).isEqualTo(0);
assertThat(underTest.getSuccessCount()).isEqualTo(0);
+ assertThat(underTest.getProcessingTime()).isEqualTo(0);
}
@Test
assertThat(underTest.getInProgressCount()).isEqualTo(1);
assertThat(underTest.getErrorCount()).isEqualTo(0);
assertThat(underTest.getSuccessCount()).isEqualTo(0);
+ assertThat(underTest.getProcessingTime()).isEqualTo(0);
}
@Test
assertThat(underTest.getInProgressCount()).isEqualTo(calls);
assertThat(underTest.getPendingCount()).isEqualTo(-calls);
+ assertThat(underTest.getProcessingTime()).isEqualTo(0);
+ }
+
+ @Test
+ public void addError_throws_IAE_if_time_is_less_than_0() {
+ expectedException.expect(IllegalArgumentException.class);
+ expectedException.expectMessage("Processing time can not be < 0");
+
+ underTest.addError(-1);
}
@Test
public void addError_increases_Error_and_decreases_InProgress_by_1_without_check_on_InProgress() {
- underTest.addError();
+ underTest.addError(SOME_PROCESSING_TIME);
assertThat(underTest.getReceivedCount()).isEqualTo(0);
assertThat(underTest.getPendingCount()).isEqualTo(0);
assertThat(underTest.getInProgressCount()).isEqualTo(-1);
assertThat(underTest.getErrorCount()).isEqualTo(1);
assertThat(underTest.getSuccessCount()).isEqualTo(0);
+ assertThat(underTest.getProcessingTime()).isEqualTo(SOME_PROCESSING_TIME);
}
@Test
public void addError_any_number_of_call_change_by_1_per_call() {
int calls = new Random().nextInt(SOME_RANDOM_MAX);
for (int i = 0; i < calls; i++) {
- underTest.addError();
+ underTest.addError(1);
}
assertThat(underTest.getErrorCount()).isEqualTo(calls);
assertThat(underTest.getInProgressCount()).isEqualTo(-calls);
+ assertThat(underTest.getProcessingTime()).isEqualTo(calls);
+ }
+
+ @Test
+ public void addSuccess_throws_IAE_if_time_is_less_than_0() {
+ expectedException.expect(IllegalArgumentException.class);
+ expectedException.expectMessage("Processing time can not be < 0");
+
+ underTest.addSuccess(-1);
}
@Test
public void addSuccess_increases_Error_and_decreases_InProgress_by_1_without_check_on_InProgress() {
- underTest.addSuccess();
+ underTest.addSuccess(SOME_PROCESSING_TIME);
assertThat(underTest.getReceivedCount()).isEqualTo(0);
assertThat(underTest.getPendingCount()).isEqualTo(0);
assertThat(underTest.getInProgressCount()).isEqualTo(-1);
assertThat(underTest.getErrorCount()).isEqualTo(0);
assertThat(underTest.getSuccessCount()).isEqualTo(1);
+ assertThat(underTest.getProcessingTime()).isEqualTo(SOME_PROCESSING_TIME);
}
@Test
public void addSuccess_any_number_of_call_change_by_1_per_call() {
int calls = new Random().nextInt(SOME_RANDOM_MAX);
for (int i = 0; i < calls; i++) {
- underTest.addSuccess();
+ underTest.addSuccess(1);
}
assertThat(underTest.getSuccessCount()).isEqualTo(calls);
assertThat(underTest.getInProgressCount()).isEqualTo(-calls);
+ assertThat(underTest.getProcessingTime()).isEqualTo(calls);
}
}
private static final long IN_PROGRESS_COUNT = 5;
private static final long ERROR_COUNT = 10;
private static final long SUCCESS_COUNT = 13;
+ private static final long PROCESSING_TIME = 987;
private ComputeEngineQueueMonitor underTest = new ComputeEngineQueueMonitor(new DumbCEQueueStatus(), mock(ReportQueue.class));
@Test
public void attributes_has_entry_for_each_get_method() {
assertThat(underTest.attributes()).containsOnly(
- entry("Received reports", RECEIVED_COUNT),
- entry("Pending reports", PENDING_COUNT),
+ entry("Received", RECEIVED_COUNT),
+ entry("Pending", PENDING_COUNT),
entry("In progress", IN_PROGRESS_COUNT),
entry("Successfully processed", SUCCESS_COUNT),
- entry("Processed with error", ERROR_COUNT));
+ entry("Processed with error", ERROR_COUNT),
+ entry("Processing time", PROCESSING_TIME));
}
@Test
assertThat(underTest.getInProgressCount()).isEqualTo(IN_PROGRESS_COUNT);
assertThat(underTest.getErrorCount()).isEqualTo(ERROR_COUNT);
assertThat(underTest.getSuccessCount()).isEqualTo(SUCCESS_COUNT);
+ assertThat(underTest.getProcessingTime()).isEqualTo(PROCESSING_TIME);
}
/**
}
@Override
- public long addError() {
+ public long addError(long processingTime) {
return methodNotImplemented();
}
}
@Override
- public long addSuccess() {
+ public long addSuccess(long processingTime) {
return methodNotImplemented();
}
public long getSuccessCount() {
return SUCCESS_COUNT;
}
+
+ @Override
+ public long getProcessingTime() {
+ return PROCESSING_TIME;
+ }
}
}
projects / sonarqube.git / commitdiff