Examples with InstrumentClass com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass used on opensource projects

Example 46 with InstrumentClass

use of com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass in project pinpoint by naver.

the class BeanMethodTransformer method doInTransform.

@Override
public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
    try {
        final InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer);
        if (!target.isInterceptable()) {
            return null;
        }
        final List<InstrumentMethod> methodList = target.getDeclaredMethods(METHOD_FILTER);
        for (InstrumentMethod method : methodList) {
            addInterceptor(method);
        }
        return target.toBytecode();
    } catch (Exception e) {
        if (logger.isWarnEnabled()) {
            logger.warn("Failed to spring beans modify. Cause:{}", e.getMessage(), e);
        }
        return null;
    }
}

Example 47 with InstrumentClass

use of com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass in project pinpoint by naver.

the class ThriftPlugin method addTTransportEditor.

private void addTTransportEditor(String tTransportClassName, final String tTransportInterceptorFqcn, final String[]... parameterTypeGroups) {
    final String targetClassName = tTransportClassName;
    transformTemplate.transform(targetClassName, new TransformCallback() {

        @Override
        public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
            final InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer);
            target.addField(ThriftConstants.FIELD_ACCESSOR_SOCKET);
            for (String[] parameterTypeGroup : parameterTypeGroups) {
                final InstrumentMethod constructor = target.getConstructor(parameterTypeGroup);
                if (constructor != null) {
                    constructor.addInterceptor(tTransportInterceptorFqcn);
                }
            }
            return target.toBytecode();
        }
    });
}

Example 48 with InstrumentClass

use of com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass in project pinpoint by naver.

the class ThriftPlugin method addTBaseAsyncProcessorEditor.

private void addTBaseAsyncProcessorEditor() {
    final String targetClassName = "org.apache.thrift.TBaseAsyncProcessor";
    transformTemplate.transform(targetClassName, new TransformCallback() {

        @Override
        public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
            final InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer);
            target.addField(ThriftConstants.FIELD_ACCESSOR_SERVER_MARKER_FLAG);
            target.addField(ThriftConstants.FIELD_ACCESSOR_ASYNC_MARKER_FLAG);
            // TBaseAsyncProcessor.process(AbstractNonblockingServer$AsyncFrameBuffer)
            final InstrumentMethod process = target.getDeclaredMethod("process", "org.apache.thrift.server.AbstractNonblockingServer$AsyncFrameBuffer");
            if (process != null) {
                String interceptor = "com.navercorp.pinpoint.plugin.thrift.interceptor.server.async.TBaseAsyncProcessorProcessInterceptor";
                process.addInterceptor(interceptor);
            }
            return target.toBytecode();
        }
    });
}

Example 49 with InstrumentClass

use of com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass in project pinpoint by naver.

the class ThriftPlugin method addTAsyncMethodCallEditor.

private void addTAsyncMethodCallEditor() {
    final String targetClassName = "org.apache.thrift.async.TAsyncMethodCall";
    transformTemplate.transform(targetClassName, new TransformCallback() {

        @Override
        public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
            final InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer);
            target.addField(AsyncTraceIdAccessor.class.getName());
            target.addField(ThriftConstants.FIELD_ACCESSOR_SOCKET_ADDRESS);
            target.addGetter(ThriftConstants.FIELD_GETTER_T_NON_BLOCKING_TRANSPORT, ThriftConstants.T_ASYNC_METHOD_CALL_FIELD_TRANSPORT);
            // TAsyncMethodCall(TAsyncClient, TProtocolFactory, TNonblockingTransport, AsyncMethodCallback<T>, boolean)
            final InstrumentMethod constructor = target.getConstructor("org.apache.thrift.async.TAsyncClient", "org.apache.thrift.protocol.TProtocolFactory", "org.apache.thrift.transport.TNonblockingTransport", "org.apache.thrift.async.AsyncMethodCallback", "boolean");
            if (constructor != null) {
                String interceptor = "com.navercorp.pinpoint.plugin.thrift.interceptor.client.async.TAsyncMethodCallConstructInterceptor";
                constructor.addInterceptor(interceptor);
            }
            // TAsyncMethodCall.cleanUpAndFireCallback(SelectionKey)
            final InstrumentMethod cleanUpAndFireCallback = target.getDeclaredMethod("cleanUpAndFireCallback", "java.nio.channels.SelectionKey");
            if (cleanUpAndFireCallback != null) {
                String interceptor = "com.navercorp.pinpoint.plugin.thrift.interceptor.client.async.TAsyncMethodCallCleanUpAndFireCallbackInterceptor";
                cleanUpAndFireCallback.addInterceptor(interceptor);
            }
            // TAsyncMethodCall.onError(Exception)
            final InstrumentMethod onError = target.getDeclaredMethod("onError", "java.lang.Exception");
            if (onError != null) {
                String interceptor = "com.navercorp.pinpoint.plugin.thrift.interceptor.client.async.TAsyncMethodCallOnErrorInterceptor";
                onError.addInterceptor(interceptor);
            }
            return target.toBytecode();
        }
    });
}

Example 50 with InstrumentClass

use of com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass in project pinpoint by naver.

the class AccessorInjectionTest method testAddSetter.

@Test
public void testAddSetter() throws Exception {
    final TestClassLoader loader = getTestClassLoader();
    final String targetClassName = "com.navercorp.pinpoint.test.javasssit.mock.TestObject4";
    loader.addTransformer(targetClassName, new TransformCallback() {

        @Override
        public byte[] doInTransform(Instrumentor instrumentor, ClassLoader classLoader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException {
            try {
                logger.info("modify cl:{}", classLoader);
                InstrumentClass testClass = instrumentor.getInstrumentClass(classLoader, className, classfileBuffer);
                testClass.addSetter(IntSetter.class.getName(), "intValue");
                testClass.addSetter(IntArraySetter.class.getName(), "intValues");
                testClass.addSetter(IntegerArraySetter.class.getName(), "integerValues");
                return testClass.toBytecode();
            } catch (InstrumentException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    });
    Object testObject = loader.loadClass(targetClassName).newInstance();
    Class<?> intSetter = loader.loadClass(IntSetter.class.getName());
    Class<?> intsSetter = loader.loadClass(IntArraySetter.class.getName());
    Class<?> integersSetter = loader.loadClass(IntegerArraySetter.class.getName());
    Assert.assertTrue(intSetter.isInstance(testObject));
    Assert.assertTrue(intsSetter.isInstance(testObject));
    Assert.assertTrue(integersSetter.isInstance(testObject));
    int intValue = 99;
    int[] intValues = { 99, 100 };
    Integer[] integerValues = { 99, 100 };
    Method setInt = intSetter.getMethod("_$PINPOINT$_setInt", int.class);
    setInt.invoke(testObject, intValue);
    Method getInt = testObject.getClass().getMethod("getIntValue");
    Assert.assertEquals(intValue, getInt.invoke(testObject));
    Method setInts = intsSetter.getMethod("_$PINPOINT$_setIntArray", int[].class);
    setInts.invoke(testObject, intValues);
    Method getInts = testObject.getClass().getMethod("getIntValues");
    Assert.assertEquals(intValues, getInts.invoke(testObject));
    Method setIntegers = integersSetter.getMethod("_$PINPOINT$_setIntegerArray", Integer[].class);
    // wrap due to vararg expansion
    Object[] wrappedIntegerValues = new Object[] { integerValues };
    setIntegers.invoke(testObject, wrappedIntegerValues);
    Method getIntegers = testObject.getClass().getMethod("getIntegerValues");
    Assert.assertEquals(integerValues, getIntegers.invoke(testObject));
}