/** * {@inheritDoc} */ @Override public Object beforeBody(long methodId, Object object, Object[] parameters, SpecialSensorConfig ssc) { return loadClass(object, parameters); }
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { hook = new EUMInstrumentationHook(linker, tracer, dataHandler, config, agentBuilder); }
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { hook = new CloseableHttpAsyncClientHook(runtimeLinker); }
@SuppressWarnings("unchecked") @Test public void testPreventDoubleInstrumentation() throws IOException { hook = new EUMInstrumentationHook(linker, tracer, dataHandler, config, agentBuilder); Object[] params = new Object[] { dummyRequest, new FakeWrapper(dummyResponse) }; boolean intercepted = null != hook.beforeBody(METHOD_ID, dummyServlet, params, ssc); assertThat(intercepted, equalTo(false)); verify(linker, never()).createProxy(any(Class.class), any(IProxySubject.class), any(ClassLoader.class)); }
@Test public void testInstrumentation() throws IOException { hook = new EUMInstrumentationHook(linker, tracer, dataHandler, config, agentBuilder); Object[] params = new Object[] { dummyRequest, dummyResponse }; boolean intercepted = null != hook.beforeBody(METHOD_ID, dummyServlet, params, ssc); Object response = params[1]; assertThat(intercepted, equalTo(false)); assertThat(response, instanceOf(FakeWrapper.class)); } @SuppressWarnings("unchecked")
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { if (CollectionUtils.isNotEmpty(mBeanServerListeners)) { hook = new MBeanServerInterceptorHook(mBeanServerListeners); } else { hook = new MBeanServerInterceptorHook(Collections.<IMBeanServerListener> emptyList()); } }
/** * {@inheritDoc} */ @Override public Object beforeBody(long methodId, Object object, Object[] parameters, SpecialSensorConfig ssc) { Object servletRequest = parameters[0]; Object servletResponse = parameters[1]; if (interceptRequest(servletRequest, servletResponse)) { // remove marker here as afterBody will not be called interceptionCheckPerformed.markEndCall(); if (interceptionCheckPerformed.matchesFirst()) { interceptionCheckPerformed.remove(); // cleanup } return 1; // prevents the original request handling from being executed } else { parameters[1] = instrumentResponse(servletRequest, servletResponse); return null; } }
@Test public void mustNotHaveAProxyInThirdParametersIfParametersIsNull() { Object[] parameters = null; hook.beforeBody(METHOD_ID, object, parameters, ssc); verifyNoMoreInteractions(runtimeLinker); verifyZeroInteractions(ssc, object, httpContext, futureCallback); }
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { hook = new ExecutorIntercepterHook(tracer); } }
/** * {@inheritDoc} */ @Override protected void initHook(Map<String, Object> parameters) { hook = new ClassLoadingDelegationHook(); }
/** * Initialises this hook. * * @param linker * the {@link RuntimeLinker} to use for generating proxies. * @param tracer * the {@link TracerImpl} for correlating front- and backend traces. * @param dataHandler * the {@link DataHandler} responsible for decoding received beacons. * @param config * the configuration storage containing the EUM config. * @param agentBuilder * the agent script builder. */ public EUMInstrumentationHook(IRuntimeLinker linker, TracerImpl tracer, IDataHandler dataHandler, IConfigurationStorage config, JSAgentBuilder agentBuilder) { super(); this.linker = linker; this.tracer = tracer; this.dataHandler = dataHandler; this.agentBuilder = agentBuilder; initConfig(config); }
@Override public Object answer(InvocationOnMock invocation) throws Throwable { respWrapper = (TagInjectionResponseWrapper) invocation.getArguments()[1]; return new FakeWrapper(dummyResponse); } });
@Test public void notExistingOurClass() { Object[] parameters = new String[] { "rocks.inspectit.agent.java.StupidClass" }; Object result = hook.beforeBody(METHOD_ID, object, parameters, ssc); assertThat(result, is(nullValue())); verifyZeroInteractions(object, ssc); }
@Test public void returnsANullValueAndHasZeroInteractionsWithAnyOfTheParamters() { long methodId = 11L; Object[] parameters = new Object[0]; Object result = mock(Object.class); Object afterBodyObject = hook.afterBody(methodId, object, parameters, result, ssc); assertThat("The returned object after body must be null.", afterBodyObject, is(nullValue())); verifyZeroInteractions(object, result, ssc, runtimeLinker); } }
@Test public void noInteraction() { Object object = mock(Object.class); Object[] parameters = new Object[] { object }; Object result = hook.afterBody(0, targetObject, parameters, resultObject, ssc); assertThat(result, is(nullValue())); assertThat(parameters, is(arrayWithSize(1))); assertThat(parameters[0], is(object)); verifyZeroInteractions(object, targetObject, resultObject, ssc, tracer); }
@BeforeMethod public void init() { hook = new MBeanServerInterceptorHook(Collections.singletonList(listener)); }
@Test public void mustNotSetProxyIfThereIsTooFewParameters() { Object[] parameters = new String[] { null, null, null }; hook.beforeBody(METHOD_ID, object, parameters, ssc); verifyNoMoreInteractions(runtimeLinker); verifyZeroInteractions(ssc, object, httpContext, futureCallback); }
/** * Loads class with the given parameters that have been passed to the target class loader. * <p> * Loading will be delegated only if parameters are of size 1 and that single parameter is * String type. * * @see #loadClass(String) * @param classLoader * Class loader loading the class (object where the method is executed). * @param params * Original parameters passed to class loader. * @return Loaded class or <code>null</code>. */ private Class<?> loadClass(Object classLoader, Object[] params) { if ((null != params) && (params.length == 1)) { Object p = params[0]; if (p instanceof String) { return loadClass(classLoader, (String) p); } } return null; }
@Test public void mustNotHaveAProxyInThirdParametersIfThereIsNoParameters() { Object[] parameters = new Object[] {}; hook.beforeBody(METHOD_ID, object, parameters, ssc); verifyNoMoreInteractions(runtimeLinker); verifyZeroInteractions(ssc, object, httpContext, futureCallback); }
@Test public void mustNotSetProxyIfThereIsTooManyParameters() { Object[] parameters = new String[] { null, null, null, null, null }; hook.beforeBody(METHOD_ID, object, parameters, ssc); assertThat("Third parameter (proxy) must not be set.", parameters[3], is(nullValue())); verifyNoMoreInteractions(runtimeLinker); verifyZeroInteractions(ssc, object, httpContext, futureCallback); }