How to use

IAgent

in

rocks.inspectit.agent.java

/**
 * {@inheritDoc}
 */
@Override
public void onApplicationEvent(AgentMessagesReceivedEvent event) {
  if (event == null) {
    if (log.isDebugEnabled()) {
      log.debug("A 'null' event will not be processed.");
    }
    return;
  }
  // When we update to Spring v4, we should use @Conditional that the RetransformationManager
  // is not running if retransformation is not used.
  if (!Agent.agent.isUsingRetransformation()) {
    if (log.isInfoEnabled()) {
      log.info("Retransformation is disabled by the used retransformation strategy.");
    }
    return;
  }
  List<InstrumentationDefinition> instrumentationDefinitions = getInstrumentatioDefinitions(event.getAgentMessages());
  if (CollectionUtils.isEmpty(instrumentationDefinitions)) {
    return;
  }
  // remove out-dated duplicates
  Collection<InstrumentationDefinition> cleanedInstrumentationDefinitions = removeOutdatedInstrumentationDefinitions(instrumentationDefinitions);
  processInstrumentationDefinitions(cleanedInstrumentationDefinitions);
}

if (!Agent.agent.shouldClassBeIgnored(clazzName) && Agent.agent.shouldAnalyzeOnStartup(clazzName)) {
  try {
    if (useRetransformation) {
      instrumentation.retransformClasses(loadedClass);
    } else {
      byte[] modified = Agent.agent.inspectByteCode(null, clazzName, loadedClass.getClassLoader());
      if (null != modified) {
        ClassDefinition classDefinition = new ClassDefinition(loadedClass, modified);

if (!Agent.agent.isInstrumentationDisabled()) {
  boolean redefineClassesSupported = inst.isRedefineClassesSupported();
  boolean useRetransformation = inst.isRetransformClassesSupported() && Agent.agent.isUsingRetransformation();

  byte[] instrumentedData = Agent.agent.inspectByteCode(data, modifiedClassName, classLoader);
  return instrumentedData;
} catch (Throwable ex) { // NOPMD

@Test
public void unknownMessageClass() throws UnmodifiableClassException {
  IAgentMessage<?> message = mock(IAgentMessage.class);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verifyZeroInteractions(instrumentation, classHashHelper, threadTransformHelper);
}

@Test
public void noInstrumentationDefinitions() throws UnmodifiableClassException {
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verifyZeroInteractions(instrumentation, classHashHelper, threadTransformHelper);
}

  @Test
  public void retransformationDisabled() throws UnmodifiableClassException {
    InstrumentationDefinition objectDefinition = mock(InstrumentationDefinition.class);
    when(objectDefinition.getClassName()).thenReturn("java.lang.Object");
    IAgentMessage<?> message = new UpdatedInstrumentationMessage();
    ((UpdatedInstrumentationMessage) message).getMessageContent().add(objectDefinition);
    AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
    when(agent.isUsingRetransformation()).thenReturn(false);
    retransformManager.onApplicationEvent(event);
    verifyZeroInteractions(instrumentation, classHashHelper, threadTransformHelper);
  }
}

@Test
public void unknownInstrumentationClass() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("unknown.Class");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("unknown.Class"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  verifyNoMoreInteractions(instrumentation, classHashHelper);
  verifyZeroInteractions(threadTransformHelper);
}

@Test
public void unmodifiableClass() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("java.lang.Object");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(instrumentation.isModifiableClass(eq(Object.class))).thenReturn(false);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  verifyNoMoreInteractions(instrumentation, classHashHelper);
  verifyZeroInteractions(threadTransformHelper);
}

@Test
public void retransformationThrowsException() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("java.lang.Object");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  doThrow(Exception.class).when(instrumentation).retransformClasses(any(Class.class));
  when(instrumentation.isModifiableClass(Matchers.<Class<?>> any())).thenReturn(true);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation).retransformClasses(any(Class.class));
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  InOrder inOrder = inOrder(threadTransformHelper);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(false);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(true);
  verifyNoMoreInteractions(instrumentation, classHashHelper);
  verifyZeroInteractions(threadTransformHelper);
}

@Test
@SuppressWarnings("unchecked")
public void instrumentationThrowsOneException() throws UnmodifiableClassException {
  InstrumentationDefinition iDefinition = mock(InstrumentationDefinition.class);
  when(iDefinition.getClassName()).thenReturn("java.lang.Object");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(iDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(instrumentation.isModifiableClass(any(Class.class))).thenReturn(true).thenThrow(RuntimeException.class);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(iDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation).retransformClasses(eq(Object.class));
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  InOrder inOrder = inOrder(threadTransformHelper);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(false);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(true);
  verifyNoMoreInteractions(instrumentation, classHashHelper, threadTransformHelper);
}

@Test
public void successful() throws UnmodifiableClassException {
  InstrumentationDefinition objectDefinition = mock(InstrumentationDefinition.class);
  when(objectDefinition.getClassName()).thenReturn("java.lang.Object");
  InstrumentationDefinition stringDefinition = mock(InstrumentationDefinition.class);
  when(stringDefinition.getClassName()).thenReturn("java.lang.String");
  IAgentMessage<?> message = new UpdatedInstrumentationMessage();
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(objectDefinition);
  ((UpdatedInstrumentationMessage) message).getMessageContent().add(stringDefinition);
  AgentMessagesReceivedEvent event = new AgentMessagesReceivedEvent(eventSource, Arrays.<IAgentMessage<?>> asList(message));
  when(instrumentation.getAllLoadedClasses()).thenReturn(new Class[] { Object.class, String.class });
  when(instrumentation.isModifiableClass(any(Class.class))).thenReturn(true);
  when(agent.isUsingRetransformation()).thenReturn(true);
  retransformManager.onApplicationEvent(event);
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.Object"), eq(objectDefinition));
  verify(classHashHelper).registerInstrumentationDefinition(eq("java.lang.String"), eq(stringDefinition));
  verify(instrumentation).getAllLoadedClasses();
  verify(instrumentation).retransformClasses(eq(Object.class), eq(String.class));
  verify(instrumentation, times(2)).isModifiableClass(any(Class.class));
  verify(agent).isUsingRetransformation();
  InOrder inOrder = inOrder(threadTransformHelper);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(false);
  inOrder.verify(threadTransformHelper).setThreadTransformDisabled(true);
  verifyNoMoreInteractions(instrumentation, classHashHelper, threadTransformHelper, agent);
}