How to use

DefaultDataWrapper

in

rocks.inspectit.agent.java.core.impl

/**
 * {@inheritDoc}
 */
@Override
public DefaultDataWrapper newInstance() {
  return new DefaultDataWrapper();
}

/**
 * {@inheritDoc}
 */
@Override
public void onEvent(DefaultDataWrapper defaultDataWrapper, long sequence, boolean endOfBatch) {
  defaultDatas.add(defaultDataWrapper.getDefaultData());
  if (endOfBatch) {
    try {
      if (connection.isConnected()) {
        connection.sendDataObjects(defaultDatas);
        sendingExceptionNotice = false;
      } else {
        statsLogger.dataDropped(defaultDatas.size());
      }
    } catch (ServerUnavailableException serverUnavailableException) {
      if (serverUnavailableException.isServerTimeout()) {
        log.warn("Timeout on server when sending actual data. Data might be lost!", serverUnavailableException);
      } else {
        if (!sendingExceptionNotice) {
          sendingExceptionNotice = true;
          log.error("Connection problem appeared, stopping sending actual data!", serverUnavailableException);
        }
      }
    } finally {
      defaultDatas.clear();
    }
  }
}

/**
 * {@inheritDoc}
 */
@Override
public void addDefaultData(DefaultData defaultData) {
  // ignore any data adding if we are in the shutdown phase
  if (shutdown) {
    return;
  }
  try {
    // grab the next sequence, never wait for it to be available so that that we don't block
    long sequence = ringBuffer.tryNext();
    try {
      // get the entry in the disruptor for the sequence and simply change the reference
      DefaultDataWrapper defaultDataWrapper = ringBuffer.get(sequence);
      defaultDataWrapper.setDefaultData(defaultData);
    } finally {
      ringBuffer.publish(sequence);
    }
  } catch (InsufficientCapacityException e) {
    // pass the dropped count
    statsLogger.dataDropped(1);
  }
}

@Test
public void notEndOfBatch() throws ServerUnavailableException {
  when(wrapper.getDefaultData()).thenReturn(defaultData);
  when(connection.isConnected()).thenReturn(true);
  handler.onEvent(wrapper, 0L, false);
  verifyZeroInteractions(connection, statsLogger);
}

@Test
public void happyPath() throws ServerUnavailableException {
  when(wrapper.getDefaultData()).thenReturn(defaultData);
  when(connection.isConnected()).thenReturn(true);
  handler.onEvent(wrapper, 0L, true);
  verify(connection).isConnected();
  verify(connection).sendDataObjects(Mockito.<List<DefaultData>> any());
  verifyNoMoreInteractions(connection);
  verifyZeroInteractions(statsLogger);
  assertThat(sent, hasSize(1));
  assertThat(sent, hasItem(defaultData));
}

@Test
public void notConnected() throws ServerUnavailableException {
  when(wrapper.getDefaultData()).thenReturn(defaultData);
  when(connection.isConnected()).thenReturn(false);
  handler.onEvent(wrapper, 0L, true);
  verify(statsLogger).dataDropped(1);
  verify(connection).isConnected();
  verifyNoMoreInteractions(connection, statsLogger);
}

@Test
public void noRepeat() throws ServerUnavailableException {
  DefaultData defaultData2 = mock(DefaultData.class);
  when(wrapper.getDefaultData()).thenReturn(defaultData).thenReturn(defaultData2);
  when(connection.isConnected()).thenReturn(true);
  handler.onEvent(wrapper, 0L, true);
  handler.onEvent(wrapper, 0L, true);
  verify(connection, times(2)).isConnected();
  verify(connection, times(2)).sendDataObjects(Mockito.<List<DefaultData>> any());
  verifyNoMoreInteractions(connection);
  verifyZeroInteractions(statsLogger);
  assertThat(sent, hasSize(2));
  assertThat(sent, hasItems(defaultData, defaultData2));
}

@Test
public void happyPath() throws InterruptedException, StorageException {
  when(disruptorStrategy.getDataBufferSize()).thenReturn(8);
  coreService.start();
  coreService.addDefaultData(data);
  // need to sleep a bit so handler is notified
  Thread.sleep(100);
  ArgumentCaptor<DefaultDataWrapper> captor = ArgumentCaptor.forClass(DefaultDataWrapper.class);
  verify(defaultDataHandler).onEvent(captor.capture(), anyLong(), eq(true));
  assertThat(captor.getValue().getDefaultData(), is(data));
}

@Test
public void correctOrder() throws ServerUnavailableException {
  DefaultData defaultData2 = mock(DefaultData.class);
  when(wrapper.getDefaultData()).thenReturn(defaultData).thenReturn(defaultData2);
  when(connection.isConnected()).thenReturn(true);
  handler.onEvent(wrapper, 0L, false);
  handler.onEvent(wrapper, 0L, true);
  verify(connection).isConnected();
  verify(connection).sendDataObjects(Mockito.<List<DefaultData>> any());
  verifyNoMoreInteractions(connection);
  verifyZeroInteractions(statsLogger);
  assertThat(sent, hasSize(2));
  assertThat(sent, hasItems(defaultData, defaultData2));
}

@Test
public void platformSensorCollect() throws InterruptedException, StorageException {
  when(jmxSensors.isEmpty()).thenReturn(true);
  doAnswer(new Answer<Iterator<?>>() {
    @Override
    public Iterator<?> answer(InvocationOnMock invocation) throws Throwable {
      return new ArrayIterator(new IPlatformSensor[] { platformSensor });
    }
  }).when(platformSensors).iterator();
  SystemInformationData sid = mock(SystemInformationData.class);
  when(platformSensor.get()).thenReturn(sid);
  when(disruptorStrategy.getDataBufferSize()).thenReturn(8);
  coreService.start();
  Runnable sensorRefresher = coreService.new SensorRefresher();
  sensorRefresher.run();
  sensorRefresher.run();
  sensorRefresher.run();
  sensorRefresher.run();
  sensorRefresher.run();
  verify(platformSensor).reset();
  verify(platformSensor, times(5)).gather();
  verify(platformSensor).get();
  verifyNoMoreInteractions(platformSensor);
  // need to sleep a bit so handler is notified
  Thread.sleep(100);
  ArgumentCaptor<DefaultDataWrapper> captor = ArgumentCaptor.forClass(DefaultDataWrapper.class);
  verify(defaultDataHandler).onEvent(captor.capture(), anyLong(), eq(true));
  assertThat(captor.getValue().getDefaultData(), is((DefaultData) sid));
}