From 906e5edaf21a3a1b7cb8c02f9a70e86a8b6cee49 Mon Sep 17 00:00:00 2001 From: emeroad Date: Wed, 25 Nov 2015 13:15:23 +0900 Subject: [PATCH] #1262 added ErrorMarking option for spring bean profile --- ...inpoint-real-env-lowoverhead-sample.config | 1 + agent/src/main/resources/pinpoint.config | 1 + .../pinpoint-disabled-plugin-test.config | 1 + .../pinpoint-spring-bean-test.config | 1 + .../bootstrap/context/SpanEventRecorder.java | 2 + .../bootstrap/context/SpanRecorder.java | 2 + plugins/spring/pom.xml | 5 ++ .../spring/beans/BeanMethodTransformer.java | 18 ++++-- .../spring/beans/SpringBeansPlugin.java | 14 +++-- .../interceptor/BeanMethodInterceptor.java | 6 +- .../BeanMethodInterceptorTest.java | 54 +++++++++++++++++ .../profiler/context/AbstractRecorder.java | 16 +++-- .../profiler/context/DefaultSpanRecorder.java | 11 +++- .../context/WrappedSpanEventRecorder.java | 12 +++- .../AutoBindingObjectFactory.java | 38 ++++++------ .../objectfactory/OrderedValueProvider.java | 18 +++++- .../context/WrappedSpanEventRecorderTest.java | 59 +++++++++++++++++++ 17 files changed, 219 insertions(+), 40 deletions(-) create mode 100644 plugins/spring/src/test/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptorTest.java create mode 100644 profiler/src/test/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorderTest.java diff --git a/agent/src/main/resources/pinpoint-real-env-lowoverhead-sample.config b/agent/src/main/resources/pinpoint-real-env-lowoverhead-sample.config index b5947b0e93dd..819dcdc1cda4 100644 --- a/agent/src/main/resources/pinpoint-real-env-lowoverhead-sample.config +++ b/agent/src/main/resources/pinpoint-real-env-lowoverhead-sample.config @@ -292,6 +292,7 @@ profiler.spring.beans=true profiler.spring.beans.name.pattern= profiler.spring.beans.class.pattern= profiler.spring.beans.annotation=org.springframework.stereotype.Controller,org.springframework.stereotype.Service,org.springframework.stereotype.Repository +profiler.spring.beans.mark.error=false ########################################################### # log4j (guide url : https://github.com/naver/pinpoint/blob/master/doc/per-request_feature_guide.md) diff --git a/agent/src/main/resources/pinpoint.config b/agent/src/main/resources/pinpoint.config index 57d19c34319f..c2a8ffaddc08 100644 --- a/agent/src/main/resources/pinpoint.config +++ b/agent/src/main/resources/pinpoint.config @@ -328,6 +328,7 @@ profiler.spring.beans=true profiler.spring.beans.name.pattern= profiler.spring.beans.class.pattern= profiler.spring.beans.annotation=org.springframework.stereotype.Controller,org.springframework.stereotype.Service,org.springframework.stereotype.Repository +profiler.spring.beans.mark.error=false ########################################################### # log4j (guide url : https://github.com/naver/pinpoint/blob/master/doc/per-request_feature_guide.md) diff --git a/agent/src/test/resources/pinpoint-disabled-plugin-test.config b/agent/src/test/resources/pinpoint-disabled-plugin-test.config index a06eeac772b7..43868ef78667 100644 --- a/agent/src/test/resources/pinpoint-disabled-plugin-test.config +++ b/agent/src/test/resources/pinpoint-disabled-plugin-test.config @@ -197,6 +197,7 @@ profiler.spring.beans=true profiler.spring.beans.name.pattern=ma.*, outer profiler.spring.beans.class.pattern=.*Morae profiler.spring.beans.annotation=org.springframework.stereotype.Component +profiler.spring.beans.mark.error=false ########################################################### # log4j diff --git a/agent/src/test/resources/pinpoint-spring-bean-test.config b/agent/src/test/resources/pinpoint-spring-bean-test.config index ae84a451220a..c6f3492a2d7f 100644 --- a/agent/src/test/resources/pinpoint-spring-bean-test.config +++ b/agent/src/test/resources/pinpoint-spring-bean-test.config @@ -197,6 +197,7 @@ profiler.spring.beans=true profiler.spring.beans.name.pattern=ma.*, outer profiler.spring.beans.class.pattern=.*Morae profiler.spring.beans.annotation=org.springframework.stereotype.Component +profiler.spring.beans.mark.error=false ########################################################### # log4j diff --git a/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanEventRecorder.java b/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanEventRecorder.java index c61f3376bc64..e0b48cf1ede2 100644 --- a/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanEventRecorder.java +++ b/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanEventRecorder.java @@ -9,6 +9,8 @@ public interface SpanEventRecorder extends FrameAttachment { void recordException(Throwable throwable); + void recordException(boolean markError, Throwable throwable); + void recordApi(MethodDescriptor methodDescriptor); void recordApi(MethodDescriptor methodDescriptor, Object[] args); diff --git a/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanRecorder.java b/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanRecorder.java index 1e0b59e67ee5..0b7aad117fac 100644 --- a/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanRecorder.java +++ b/bootstrap-core/src/main/java/com/navercorp/pinpoint/bootstrap/context/SpanRecorder.java @@ -16,6 +16,8 @@ public interface SpanRecorder extends FrameAttachment { void recordException(Throwable throwable); + void recordException(boolean markError, Throwable throwable); + void recordApi(MethodDescriptor methodDescriptor); void recordApi(MethodDescriptor methodDescriptor, Object[] args); diff --git a/plugins/spring/pom.xml b/plugins/spring/pom.xml index 4eec1bac7adb..7a7ae0bc50a8 100644 --- a/plugins/spring/pom.xml +++ b/plugins/spring/pom.xml @@ -18,5 +18,10 @@ pinpoint-bootstrap-core provided + + com.navercorp.pinpoint + pinpoint-test + test + diff --git a/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/BeanMethodTransformer.java b/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/BeanMethodTransformer.java index b5cdb225edb1..c0c1da523901 100644 --- a/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/BeanMethodTransformer.java +++ b/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/BeanMethodTransformer.java @@ -30,6 +30,8 @@ import com.navercorp.pinpoint.bootstrap.logging.PLogger; import com.navercorp.pinpoint.bootstrap.logging.PLoggerFactory; +import static com.navercorp.pinpoint.common.util.VarArgs.va; + /** * @author Jongho Moon * @@ -43,8 +45,14 @@ public class BeanMethodTransformer implements TransformCallback { private final Object lock = new Object(); private final AtomicInteger interceptorId = new AtomicInteger(-1); - - + + private final boolean markError; + + + public BeanMethodTransformer(boolean markError) { + this.markError = markError; + } + @Override public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException { if (logger.isInfoEnabled()) { @@ -59,8 +67,8 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin final List methodList = target.getDeclaredMethods(METHOD_FILTER); for (InstrumentMethod method : methodList) { - if (logger.isTraceEnabled()) { - logger.trace("### c={}, m={}, params={}", className, method.getName(), Arrays.toString(method.getParameterTypes())); + if (logger.isDebugEnabled()) { + logger.debug("### c={}, m={}, params={}", className, method.getName(), Arrays.toString(method.getParameterTypes())); } addInterceptor(method); @@ -89,7 +97,7 @@ private void addInterceptor(InstrumentMethod targetMethod) throws InstrumentExce return; } - id = targetMethod.addInterceptor("com.navercorp.pinpoint.plugin.spring.beans.interceptor.BeanMethodInterceptor"); + id = targetMethod.addInterceptor("com.navercorp.pinpoint.plugin.spring.beans.interceptor.BeanMethodInterceptor", va(markError)); interceptorId.set(id); } } diff --git a/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/SpringBeansPlugin.java b/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/SpringBeansPlugin.java index f39a2ae2d2e8..34f3594abb06 100644 --- a/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/SpringBeansPlugin.java +++ b/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/SpringBeansPlugin.java @@ -16,6 +16,7 @@ import java.security.ProtectionDomain; +import com.navercorp.pinpoint.bootstrap.config.ProfilerConfig; import com.navercorp.pinpoint.bootstrap.instrument.InstrumentClass; import com.navercorp.pinpoint.bootstrap.instrument.InstrumentException; import com.navercorp.pinpoint.bootstrap.instrument.InstrumentMethod; @@ -35,6 +36,8 @@ */ public class SpringBeansPlugin implements ProfilerPlugin, TransformTemplateAware { + public static final String SPRING_BEANS_MARK_ERROR = "profiler.spring.beans.mark.error"; + private TransformTemplate transformTemplate; @Override @@ -43,19 +46,22 @@ public void setup(ProfilerPluginSetupContext context) { } private void addAbstractAutowireCapableBeanFactoryTransformer(final ProfilerPluginSetupContext context) { + final ProfilerConfig config = context.getConfig(); + final boolean errorMark = config.readBoolean(SPRING_BEANS_MARK_ERROR, false); + transformTemplate.transform("org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory", new TransformCallback() { @Override public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException { InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer); - BeanMethodTransformer beanTransformer = new BeanMethodTransformer(); - ObjectFactory beanFilterFactory = ObjectFactory.byStaticFactory("com.navercorp.pinpoint.plugin.spring.beans.interceptor.TargetBeanFilter", "of", context.getConfig()); + final BeanMethodTransformer beanTransformer = new BeanMethodTransformer(errorMark); + final ObjectFactory beanFilterFactory = ObjectFactory.byStaticFactory("com.navercorp.pinpoint.plugin.spring.beans.interceptor.TargetBeanFilter", "of", config); - InstrumentMethod createBeanInstance = target.getDeclaredMethod("createBeanInstance", "java.lang.String", "org.springframework.beans.factory.support.RootBeanDefinition", "java.lang.Object[]"); + final InstrumentMethod createBeanInstance = target.getDeclaredMethod("createBeanInstance", "java.lang.String", "org.springframework.beans.factory.support.RootBeanDefinition", "java.lang.Object[]"); createBeanInstance.addInterceptor("com.navercorp.pinpoint.plugin.spring.beans.interceptor.CreateBeanInstanceInterceptor", va(beanTransformer, beanFilterFactory)); - InstrumentMethod postProcessor = target.getDeclaredMethod("applyBeanPostProcessorsBeforeInstantiation", "java.lang.Class", "java.lang.String"); + final InstrumentMethod postProcessor = target.getDeclaredMethod("applyBeanPostProcessorsBeforeInstantiation", "java.lang.Class", "java.lang.String"); postProcessor.addInterceptor("com.navercorp.pinpoint.plugin.spring.beans.interceptor.PostProcessorInterceptor", va(beanTransformer, beanFilterFactory)); return target.toBytecode(); diff --git a/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptor.java b/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptor.java index 8d42983a3b08..374ee25ad0cf 100644 --- a/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptor.java +++ b/plugins/spring/src/main/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptor.java @@ -35,9 +35,11 @@ public class BeanMethodInterceptor implements ApiIdAwareAroundInterceptor { private final boolean isDebug = logger.isDebugEnabled(); private final TraceContext traceContext; + private final boolean markError; - public BeanMethodInterceptor(TraceContext traceContext) { + public BeanMethodInterceptor(TraceContext traceContext, boolean markError) { this.traceContext = traceContext; + this.markError = markError; } @Override @@ -69,7 +71,7 @@ public void after(Object target, int apiId, Object[] args, Object result, Throwa try { final SpanEventRecorder recorder = trace.currentSpanEventRecorder(); recorder.recordApi(new DummyMethodDescriptor(apiId)); - recorder.recordException(throwable); + recorder.recordException(markError, throwable); } finally { trace.traceBlockEnd(); } diff --git a/plugins/spring/src/test/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptorTest.java b/plugins/spring/src/test/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptorTest.java new file mode 100644 index 000000000000..9228601aa2ed --- /dev/null +++ b/plugins/spring/src/test/java/com/navercorp/pinpoint/plugin/spring/beans/interceptor/BeanMethodInterceptorTest.java @@ -0,0 +1,54 @@ +/* + * * + * * Copyright 2014 NAVER Corp. + * * Licensed under the Apache License, Version 2.0 (the "License"); + * * you may not use this file except in compliance with the License. + * * You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package com.navercorp.pinpoint.plugin.spring.beans.interceptor; + +import com.navercorp.pinpoint.bootstrap.context.SpanEventRecorder; +import com.navercorp.pinpoint.bootstrap.context.Trace; +import com.navercorp.pinpoint.test.mock.MockTraceContext; +import org.junit.Test; +import org.mockito.Mockito; + +import static org.mockito.Mockito.times; + +/** + * @author Woonduk Kang(emeroad) + */ +public class BeanMethodInterceptorTest { + + @Test + public void testBefore() throws Exception { + + } + + @Test + public void testAfter() throws Exception { + final MockTraceContext traceContext = new MockTraceContext(); + final Trace trace = Mockito.mock(Trace.class); + traceContext.setTrace(trace); + final SpanEventRecorder recorder = Mockito.mock(SpanEventRecorder.class); + Mockito.when(trace.currentSpanEventRecorder()).thenReturn(recorder); + + final BeanMethodInterceptor beanMethodInterceptor = new BeanMethodInterceptor(traceContext, true); + + Object thisObject = new Object(); + final Exception throwable = new Exception(); + beanMethodInterceptor.after(thisObject, 10, null, null, throwable); + + Mockito.verify(recorder, times(1)).recordException(true, throwable); + } +} \ No newline at end of file diff --git a/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/AbstractRecorder.java b/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/AbstractRecorder.java index adb5feb6eb54..610c8b349f77 100644 --- a/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/AbstractRecorder.java +++ b/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/AbstractRecorder.java @@ -34,17 +34,23 @@ public AbstractRecorder(final TraceContext traceContext) { this.traceContext = traceContext; } - public void recordException(Throwable th) { - if (th == null) { + public void recordException(Throwable throwable) { + recordException(true, throwable); + } + + public void recordException(boolean markError, Throwable throwable) { + if (throwable == null) { return; } - final String drop = StringUtils.drop(th.getMessage(), 256); + final String drop = StringUtils.drop(throwable.getMessage(), 256); // An exception that is an instance of a proxy class could make something wrong because the class name will vary. - final int exceptionId = traceContext.cacheString(th.getClass().getName()); - setExceptionInfo(exceptionId, drop); + final int exceptionId = traceContext.cacheString(throwable.getClass().getName()); + setExceptionInfo(markError, exceptionId, drop); } abstract void setExceptionInfo(int exceptionClassId, String exceptionMessage); + + abstract void setExceptionInfo(boolean markError, int exceptionClassId, String exceptionMessage); public void recordApi(MethodDescriptor methodDescriptor) { if (methodDescriptor == null) { diff --git a/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/DefaultSpanRecorder.java b/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/DefaultSpanRecorder.java index 5b6a5837374a..d0c797714484 100644 --- a/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/DefaultSpanRecorder.java +++ b/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/DefaultSpanRecorder.java @@ -60,9 +60,16 @@ public void recordStartTime(long startTime) { @Override void setExceptionInfo(int exceptionClassId, String exceptionMessage) { + setExceptionInfo(true, exceptionClassId, exceptionMessage); + } + + @Override + void setExceptionInfo(boolean markError, int exceptionClassId, String exceptionMessage) { span.setExceptionInfo(exceptionClassId, exceptionMessage); - if (!span.isSetErrCode()) { - span.setErrCode(1); + if (markError) { + if (!span.isSetErrCode()) { + span.setErrCode(1); + } } } diff --git a/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorder.java b/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorder.java index 67725b8b8493..8393ad4df24d 100644 --- a/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorder.java +++ b/profiler/src/main/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorder.java @@ -122,9 +122,17 @@ public void recordAsyncSequence(short asyncSequence) { @Override void setExceptionInfo(int exceptionClassId, String exceptionMessage) { + this.setExceptionInfo(true, exceptionClassId, exceptionMessage); + } + + @Override + void setExceptionInfo(boolean markError, int exceptionClassId, String exceptionMessage) { spanEvent.setExceptionInfo(exceptionClassId, exceptionMessage); - if (!spanEvent.getSpan().isSetErrCode()) { - spanEvent.getSpan().setErrCode(1); + if (markError) { + final Span span = spanEvent.getSpan(); + if (!span.isSetErrCode()) { + span.setErrCode(1); + } } } diff --git a/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/AutoBindingObjectFactory.java b/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/AutoBindingObjectFactory.java index 9f9e7c30a682..3019c74ffe4e 100644 --- a/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/AutoBindingObjectFactory.java +++ b/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/AutoBindingObjectFactory.java @@ -49,8 +49,8 @@ public AutoBindingObjectFactory(InstrumentContext pluginContext, ClassLoader cla } public Object createInstance(ObjectFactory objectFactory, ArgumentProvider... providers) { - Class type = pluginContext.injectClass(classLoader, objectFactory.getClassName()); - ArgumentsResolver argumentsResolver = getArgumentResolver(objectFactory, providers); + final Class type = pluginContext.injectClass(classLoader, objectFactory.getClassName()); + final ArgumentsResolver argumentsResolver = getArgumentResolver(objectFactory, providers); if (objectFactory instanceof ByConstructor) { return byConstructor(type, (ByConstructor) objectFactory, argumentsResolver); @@ -61,18 +61,18 @@ public Object createInstance(ObjectFactory objectFactory, ArgumentProvider... pr throw new IllegalArgumentException("Unknown objectFactory type: " + objectFactory); } - private Object byConstructor(Class type, ByConstructor recipe, ArgumentsResolver argumentsResolver) { - ConstructorResolver resolver = new ConstructorResolver(type, argumentsResolver); + private Object byConstructor(Class type, ByConstructor byConstructor, ArgumentsResolver argumentsResolver) { + final ConstructorResolver resolver = new ConstructorResolver(type, argumentsResolver); if (!resolver.resolve()) { throw new PinpointException("Cannot find suitable constructor for " + type.getName()); } - Constructor constructor = resolver.getResolvedConstructor(); - Object[] resolvedArguments = resolver.getResolvedArguments(); + final Constructor constructor = resolver.getResolvedConstructor(); + final Object[] resolvedArguments = resolver.getResolvedArguments(); if (isDebug) { - logger.debug("Create insatnce by constructor {}, with arguments {}", constructor, Arrays.toString(resolvedArguments)); + logger.debug("Create instance by constructor {}, with arguments {}", constructor, Arrays.toString(resolvedArguments)); } try { @@ -81,35 +81,35 @@ private Object byConstructor(Class type, ByConstructor recipe, ArgumentsResol throw new PinpointException("Fail to invoke constructor: " + constructor + ", arguments: " + Arrays.toString(resolvedArguments), e); } } - - private Object byStaticFactoryMethod(Class type, ByStaticFactoryMethod recipe, ArgumentsResolver argumentsResolver) { - StaticMethodResolver resolver = new StaticMethodResolver(type, recipe.getFactoryMethodName(), argumentsResolver); + + private Object byStaticFactoryMethod(Class type, ByStaticFactoryMethod staticFactoryMethod, ArgumentsResolver argumentsResolver) { + StaticMethodResolver resolver = new StaticMethodResolver(type, staticFactoryMethod.getFactoryMethodName(), argumentsResolver); if (!resolver.resolve()) { - throw new PinpointException("Cannot find suitable factory method " + type.getName() + "." + recipe.getFactoryMethodName()); + throw new PinpointException("Cannot find suitable factory method " + type.getName() + "." + staticFactoryMethod.getFactoryMethodName()); } - Method method = resolver.getResolvedMethod(); - Object[] resolvedArguments = resolver.getResolvedArguments(); + final Method method = resolver.getResolvedMethod(); + final Object[] resolvedArguments = resolver.getResolvedArguments(); if (isDebug) { - logger.debug("Create insatnce by static factory method {}, with arguments {}", method, Arrays.toString(resolvedArguments)); + logger.debug("Create instance by static factory method {}, with arguments {}", method, Arrays.toString(resolvedArguments)); } try { return method.invoke(null, resolvedArguments); } catch (Exception e) { - throw new PinpointException("Fail to invoke factory method: " + type.getName() + "." + recipe.getFactoryMethodName() + ", arguments: " + Arrays.toString(resolvedArguments), e); + throw new PinpointException("Fail to invoke factory method: " + type.getName() + "." + staticFactoryMethod.getFactoryMethodName() + ", arguments: " + Arrays.toString(resolvedArguments), e); } } - private ArgumentsResolver getArgumentResolver(ObjectFactory recipe, ArgumentProvider[] providers) { - List merged = new ArrayList(commonProviders); + private ArgumentsResolver getArgumentResolver(ObjectFactory objectFactory, ArgumentProvider[] providers) { + final List merged = new ArrayList(commonProviders); merged.addAll(Arrays.asList(providers)); - if (recipe.getArguments() != null) { - merged.add(new OrderedValueProvider(this, recipe.getArguments())); + if (objectFactory.getArguments() != null) { + merged.add(new OrderedValueProvider(this, objectFactory.getArguments())); } return new ArgumentsResolver(merged); diff --git a/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/OrderedValueProvider.java b/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/OrderedValueProvider.java index 5d201cb1c7ce..2d6e493d539a 100644 --- a/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/OrderedValueProvider.java +++ b/profiler/src/main/java/com/navercorp/pinpoint/profiler/objectfactory/OrderedValueProvider.java @@ -18,12 +18,17 @@ import com.navercorp.pinpoint.bootstrap.plugin.ObjectFactory; import com.navercorp.pinpoint.profiler.util.TypeUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * @author Jongho Moon * */ public class OrderedValueProvider implements JudgingParameterResolver { + + private final Logger logger = LoggerFactory.getLogger(this.getClass()); + private final AutoBindingObjectFactory objectFactory; private final Object[] values; private int index = 0; @@ -45,7 +50,7 @@ public Option get(int index, Class type, Annotation[] annotations) { return Option.empty(); } - Object value = values[this.index]; + final Object value = values[this.index]; if (type.isPrimitive()) { if (value == null) { @@ -60,12 +65,23 @@ public Option get(int index, Class type, Annotation[] annotations) { if (type.isInstance(value)) { prepareNextCandidate(); return Option.withValue(value); + } else { + if (logger.isDebugEnabled()) { + logger.debug("argument miss match index:{}, type:{} value:{} typeCl:{}, valueCl:{}", this.index, type, value, type.getClassLoader(), getClassLoader(value)); + } } } return Option.empty(); } + private ClassLoader getClassLoader(Object object) { + if (object == null) { + return null; + } + return object.getClass().getClassLoader(); + } + private void prepareNextCandidate() { index++; diff --git a/profiler/src/test/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorderTest.java b/profiler/src/test/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorderTest.java new file mode 100644 index 000000000000..08ba1fb08fe6 --- /dev/null +++ b/profiler/src/test/java/com/navercorp/pinpoint/profiler/context/WrappedSpanEventRecorderTest.java @@ -0,0 +1,59 @@ +/* + * * + * * Copyright 2014 NAVER Corp. + * * Licensed under the Apache License, Version 2.0 (the "License"); + * * you may not use this file except in compliance with the License. + * * You may obtain a copy of the License at + * * + * * http://www.apache.org/licenses/LICENSE-2.0 + * * + * * Unless required by applicable law or agreed to in writing, software + * * distributed under the License is distributed on an "AS IS" BASIS, + * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * * See the License for the specific language governing permissions and + * * limitations under the License. + * + */ + +package com.navercorp.pinpoint.profiler.context; + +import com.navercorp.pinpoint.bootstrap.context.TraceContext; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; + + +/** + * @author Woonduk Kang(emeroad) + */ +public class WrappedSpanEventRecorderTest { + + + @Test + public void testSetExceptionInfo_RootMarkError() throws Exception { + Span span = new Span(); + SpanEvent spanEvent = new SpanEvent(span); + TraceContext traceContext = Mockito.mock(TraceContext.class); + + WrappedSpanEventRecorder recorder = new WrappedSpanEventRecorder(traceContext); + recorder.setWrapped(spanEvent); + + final String exceptionMessage1 = "exceptionMessage1"; + final Exception exception1 = new Exception(exceptionMessage1); + recorder.recordException(false, exception1); + + Assert.assertEquals("Exception recoding", exceptionMessage1, spanEvent.getExceptionInfo().getStringValue()); + Assert.assertFalse("markRootError=false", span.isSetErrCode()); + + + final String exceptionMessage2 = "exceptionMessage2"; + final Exception exception2 = new Exception(exceptionMessage2); + recorder.recordException(true, exception2); + + Assert.assertEquals("Exception recoding", exceptionMessage2, spanEvent.getExceptionInfo().getStringValue()); + Assert.assertTrue("markRootError=true", span.isSetErrCode()); + } + + +} \ No newline at end of file