support plugin testcase
This commit is contained in:
ascrutae
parent
f64d414260
commit
4c1963cb45
|
|
@ -21,8 +21,7 @@ public class SkywalkingSpan implements Span {
|
|||
* @param tracer
|
||||
*/
|
||||
@NeedSnifferActivation(
|
||||
"1. set the span reference to the dynamic field of enhanced SkywalkingSpan"
|
||||
)
|
||||
"1. set the span reference to the dynamic field of enhanced SkywalkingSpan")
|
||||
public SkywalkingSpan(SkywalkingTracer tracer) {
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,39 +0,0 @@
|
|||
package org.skywalking.apm.toolkit.opentracing;
|
||||
|
||||
import io.opentracing.Span;
|
||||
import io.opentracing.SpanContext;
|
||||
import io.opentracing.Tracer;
|
||||
import io.opentracing.propagation.TextMap;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Created by wusheng on 2016/12/21.
|
||||
*/
|
||||
public class SkyWalkingTracerTest {
|
||||
@Test
|
||||
public void testBuildSpan() {
|
||||
Tracer tracer = SkyWalkingTracer.INSTANCE;
|
||||
Tracer.SpanBuilder spanBuilder = tracer.buildSpan("/http/serviceName");
|
||||
|
||||
SpanContext context = new TextMapContext(new TextMap() {
|
||||
|
||||
@Override
|
||||
public Iterator<Map.Entry<String, String>> iterator() {
|
||||
throw new UnsupportedOperationException(
|
||||
"TextMapInjectAdapter should only be used with Tracer.inject()");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void put(String key, String value) {
|
||||
|
||||
}
|
||||
});
|
||||
spanBuilder.asChildOf(context).withTag("example.tag", "testtag");
|
||||
Span span = spanBuilder.start();
|
||||
|
||||
span.finish();
|
||||
}
|
||||
}
|
||||
|
|
@ -5,42 +5,60 @@ import com.alibaba.dubbo.rpc.Invocation;
|
|||
import com.alibaba.dubbo.rpc.Invoker;
|
||||
import com.alibaba.dubbo.rpc.Result;
|
||||
import com.alibaba.dubbo.rpc.RpcContext;
|
||||
import java.util.List;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.powermock.core.classloader.annotations.PrepareForTest;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.agent.core.context.ContextCarrier;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.plugin.dubbox.BugFixActive;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.agent.test.helper.FieldSetter;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentRefHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.plugin.dubbox.BugFixActive;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.powermock.api.mockito.PowerMockito.mockStatic;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.powermock.api.mockito.PowerMockito.when;
|
||||
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
@PrepareForTest({RpcContext.class, BugFixActive.class})
|
||||
public class DubboInterceptorTest {
|
||||
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule agentServiceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
private DubboInterceptor dubboInterceptor;
|
||||
|
||||
private RequestParamForTestBelow283 testParam;
|
||||
@Mock
|
||||
private RpcContext rpcContext;
|
||||
|
|
@ -49,182 +67,152 @@ public class DubboInterceptorTest {
|
|||
@Mock
|
||||
private Invocation invocation;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
@Mock
|
||||
private MethodInterceptResult methodInterceptResult;
|
||||
@Mock
|
||||
private Result result;
|
||||
|
||||
private Object[] allArguments;
|
||||
private Class[] argumentTypes;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
dubboInterceptor = new DubboInterceptor();
|
||||
testParam = new RequestParamForTestBelow283();
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
mockStatic(RpcContext.class);
|
||||
mockStatic(BugFixActive.class);
|
||||
PowerMockito.mockStatic(RpcContext.class);
|
||||
|
||||
when(invoker.getUrl()).thenReturn(URL.valueOf("dubbo://127.0.0.1:20880/org.skywalking.apm.test.TestDubboService"));
|
||||
when(invocation.getMethodName()).thenReturn("test");
|
||||
when(invocation.getParameterTypes()).thenReturn(new Class[] {String.class});
|
||||
when(invocation.getArguments()).thenReturn(new Object[] {testParam});
|
||||
Mockito.when(RpcContext.getContext()).thenReturn(rpcContext);
|
||||
PowerMockito.when(RpcContext.getContext()).thenReturn(rpcContext);
|
||||
when(rpcContext.isConsumerSide()).thenReturn(true);
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {invoker, invocation});
|
||||
allArguments = new Object[] {invoker, invocation};
|
||||
argumentTypes = new Class[] {invoker.getClass(), invocation.getClass()};
|
||||
Config.Agent.APPLICATION_CODE = "DubboTestCases-APP";
|
||||
FieldSetter.setStaticValue(BugFixActive.class, "ACTIVE", false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConsumerBelow283() {
|
||||
when(BugFixActive.isActive()).thenReturn(true);
|
||||
public void testConsumerBelow283() throws Throwable {
|
||||
BugFixActive.active();
|
||||
|
||||
dubboInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(classInstanceContext, methodInvokeContext, result);
|
||||
dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertConsumerSpan(traceSegment.getSpans().get(0));
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
assertNotNull(testParam.getTraceContext());
|
||||
ContextCarrier contextCarrier = new ContextCarrier();
|
||||
contextCarrier.deserialize(testParam.getTraceContext());
|
||||
Assert.assertTrue(contextCarrier.isValid());
|
||||
}
|
||||
});
|
||||
assertThat(SegmentHelper.getSpans(traceSegment).size(), is(1));
|
||||
assertConsumerSpan(SegmentHelper.getSpans(traceSegment).get(0));
|
||||
|
||||
ContextCarrier contextCarrier = new ContextCarrier();
|
||||
contextCarrier.deserialize(testParam.getTraceContext());
|
||||
assertTrue(contextCarrier.isValid());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConsumerWithAttachment() {
|
||||
dubboInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(classInstanceContext, methodInvokeContext, result);
|
||||
public void testConsumerWithAttachment() throws Throwable {
|
||||
dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertConsumerSpan(traceSegment.getSpans().get(0));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertConsumerSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConsumerWithException() {
|
||||
dubboInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
dubboInterceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
dubboInterceptor.afterMethod(classInstanceContext, methodInvokeContext, result);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertConsumerTraceSegmentInErrorCase(traceSegment);
|
||||
}
|
||||
});
|
||||
public void testConsumerWithException() throws Throwable {
|
||||
dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult);
|
||||
dubboInterceptor.handleMethodException(enhancedInstance, "invoke", allArguments, argumentTypes, new RuntimeException());
|
||||
dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result);
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
assertConsumerTraceSegmentInErrorCase(traceSegment);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConsumerWithResultHasException() {
|
||||
public void testConsumerWithResultHasException() throws Throwable {
|
||||
when(result.getException()).thenReturn(new RuntimeException());
|
||||
|
||||
dubboInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(classInstanceContext, methodInvokeContext, result);
|
||||
dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertConsumerTraceSegmentInErrorCase(traceSegment);
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
assertConsumerTraceSegmentInErrorCase(traceSegment);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testProviderWithAttachment() {
|
||||
public void testProviderWithAttachment() throws Throwable {
|
||||
when(rpcContext.isConsumerSide()).thenReturn(false);
|
||||
when(rpcContext.getAttachment(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("302017.1487666919810.624424584.17332.1.1|1|REMOTE_APP|127.0.0.1|Trace.globalId.123");
|
||||
when(rpcContext.getAttachment(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("S.1499176688384.581928182.80935.69.1|3|1|#192.168.1.8 :18002|#/portal/|T.1499176688386.581928182.80935.69.2");
|
||||
|
||||
dubboInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(classInstanceContext, methodInvokeContext, result);
|
||||
dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result);
|
||||
assertProvider();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testProviderBelow283() {
|
||||
public void testProviderBelow283() throws Throwable {
|
||||
when(rpcContext.isConsumerSide()).thenReturn(false);
|
||||
when(BugFixActive.isActive()).thenReturn(true);
|
||||
FieldSetter.setStaticValue(BugFixActive.class, "ACTIVE", true);
|
||||
|
||||
testParam.setTraceContext("302017.1487666919810.624424584.17332.1.1|1|REMOTE_APP|127.0.0.1|Trace.globalId.123");
|
||||
testParam.setTraceContext("S.1499176688384.581928182.80935.69.1|3|1|#192.168.1.8 :18002|#/portal/|T.1499176688386.581928182.80935.69.2");
|
||||
|
||||
dubboInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(classInstanceContext, methodInvokeContext, result);
|
||||
dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult);
|
||||
dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result);
|
||||
|
||||
assertProvider();
|
||||
}
|
||||
|
||||
private void assertConsumerTraceSegmentInErrorCase(
|
||||
TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertConsumerSpan(traceSegment.getSpans().get(0));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
assertErrorLog(SpanLogReader.getLogs(span).get(0));
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertConsumerSpan(spans.get(0));
|
||||
AbstractTracingSpan span = spans.get(0);
|
||||
assertThat(SpanHelper.getLogs(span).size(), is(1));
|
||||
assertErrorLog(SpanHelper.getLogs(span).get(0));
|
||||
}
|
||||
|
||||
private void assertErrorLog(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertThat(logData.getFields().get("error.kind"), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getFields().get("message"));
|
||||
private void assertErrorLog(LogDataEntity logData) {
|
||||
assertThat(logData.getLogs().size(), is(4));
|
||||
assertThat(logData.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
assertThat(logData.getLogs().get(1).getValue(), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getLogs().get(2).getValue());
|
||||
}
|
||||
|
||||
private void assertProvider() {
|
||||
final TraceSegmentRef expect = new TraceSegmentRef();
|
||||
expect.setSpanId(1);
|
||||
expect.setTraceSegmentId("302017.1487666919810.624424584.17332.1.1");
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertProviderSpan(traceSegment.getSpans().get(0));
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0), expect);
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
assertThat(SegmentHelper.getSpans(traceSegment).size(), is(1));
|
||||
assertProviderSpan(SegmentHelper.getSpans(traceSegment).get(0));
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
|
||||
private void assertTraceSegmentRef(TraceSegmentRef actual, TraceSegmentRef expect) {
|
||||
assertThat(actual.getSpanId(), is(expect.getSpanId()));
|
||||
assertThat(actual.getTraceSegmentId(), is(expect.getTraceSegmentId()));
|
||||
private void assertTraceSegmentRef(TraceSegmentRef actual) {
|
||||
assertThat(SegmentRefHelper.getSpanId(actual), is(3));
|
||||
assertThat(SegmentRefHelper.getTraceSegmentId(actual), is("S.1499176688384.581928182.80935.69.1"));
|
||||
}
|
||||
|
||||
private void assertProviderSpan(Span span) {
|
||||
private void assertProviderSpan(AbstractTracingSpan span) {
|
||||
assertCommonsAttribute(span);
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_SERVER));
|
||||
assertTrue(span.isEntry());
|
||||
}
|
||||
|
||||
private void assertConsumerSpan(Span span) {
|
||||
private void assertConsumerSpan(AbstractTracingSpan span) {
|
||||
assertCommonsAttribute(span);
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_CLIENT));
|
||||
assertTrue(span.isExit());
|
||||
}
|
||||
|
||||
private void assertCommonsAttribute(Span span) {
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("rpc"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is(DubboInterceptor.DUBBO_COMPONENT));
|
||||
assertThat(StringTagReader.get(span, Tags.URL), is("dubbo://127.0.0.1:20880/org.skywalking.apm.test.TestDubboService.test(String)"));
|
||||
private void assertCommonsAttribute(AbstractTracingSpan span) {
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(span);
|
||||
assertThat(tags.size(), is(1));
|
||||
assertThat(SpanHelper.getLayer(span), is(SpanLayer.RPC_FRAMEWORK));
|
||||
assertThat(SpanHelper.getComponentId(span), is(3));
|
||||
assertThat(tags.get(0).getValue(), is("dubbo://127.0.0.1:20880/org.skywalking.apm.test.TestDubboService.test(String)"));
|
||||
assertThat(span.getOperationName(), is("org.skywalking.apm.test.TestDubboService.test(String)"));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,23 +5,35 @@ import feign.Response;
|
|||
import java.nio.charset.Charset;
|
||||
import java.util.Collection;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.core.classloader.annotations.PrepareForTest;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.BooleanTagReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
|
@ -29,106 +41,124 @@ import static org.mockito.Mockito.when;
|
|||
* @author pengys5
|
||||
*/
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
@PrepareForTest({Response.class})
|
||||
public class DefaultHttpClientInterceptorTest {
|
||||
|
||||
private DefaultHttpClientInterceptor defaultHttpClientInterceptor;
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Rule
|
||||
public AgentServiceRule agentServiceRule = new AgentServiceRule();
|
||||
|
||||
private DefaultHttpClientInterceptor defaultHttpClientInterceptor;
|
||||
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext instanceMethodInvokeContext;
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Mock
|
||||
private MethodInterceptResult result;
|
||||
|
||||
private Request request;
|
||||
|
||||
private Object[] allArguments;
|
||||
private Class[] argumentTypes;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
classInstanceContext = new EnhancedClassInstanceContext();
|
||||
|
||||
Map<String, Collection<String>> headers = new LinkedHashMap<String, Collection<String>>();
|
||||
request = Request.create("GET", "http://skywalking.org", headers, "Test".getBytes(), Charset.forName("UTF-8"));
|
||||
|
||||
Request.Options options = new Request.Options();
|
||||
|
||||
Object[] allArguments = {request, options};
|
||||
when(instanceMethodInvokeContext.allArguments()).thenReturn(allArguments);
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
allArguments = new Object[] {request, options};
|
||||
argumentTypes = new Class[] {request.getClass(), options.getClass()};
|
||||
defaultHttpClientInterceptor = new DefaultHttpClientInterceptor();
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMethodsAround() throws Throwable {
|
||||
defaultHttpClientInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.status()).thenReturn(200);
|
||||
defaultHttpClientInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, response);
|
||||
defaultHttpClientInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, result);
|
||||
defaultHttpClientInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override public void call(TraceSegment finishedSegment) {
|
||||
Assert.assertEquals(1, finishedSegment.getSpans().size());
|
||||
assertSpan(finishedSegment.getSpans().get(0));
|
||||
Assert.assertEquals(false, BooleanTagReader.get(finishedSegment.getSpans().get(0), Tags.ERROR));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
Assert.assertEquals(1, SegmentHelper.getSpans(traceSegment).size());
|
||||
AbstractTracingSpan finishedSpan = SegmentHelper.getSpans(traceSegment).get(0);
|
||||
assertSpan(finishedSpan);
|
||||
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(finishedSpan);
|
||||
assertThat(tags.size(), is(2));
|
||||
assertThat(tags.get(0).getValue(), is("GET"));
|
||||
assertThat(tags.get(1).getValue(), is(""));
|
||||
|
||||
|
||||
Assert.assertEquals(false, SpanHelper.getErrorOccurred(finishedSpan));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMethodsAroundError() throws Throwable {
|
||||
defaultHttpClientInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
defaultHttpClientInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, result);
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.status()).thenReturn(404);
|
||||
defaultHttpClientInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, response);
|
||||
defaultHttpClientInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override public void call(TraceSegment finishedSegment) {
|
||||
Assert.assertEquals(1, finishedSegment.getSpans().size());
|
||||
assertSpan(finishedSegment.getSpans().get(0));
|
||||
Assert.assertEquals(true, BooleanTagReader.get(finishedSegment.getSpans().get(0), Tags.ERROR));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
Assert.assertEquals(1, SegmentHelper.getSpans(traceSegment).size());
|
||||
AbstractTracingSpan finishedSpan = SegmentHelper.getSpans(traceSegment).get(0);
|
||||
assertSpan(finishedSpan);
|
||||
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(finishedSpan);
|
||||
assertThat(tags.size(), is(3));
|
||||
assertThat(tags.get(0).getValue(), is("GET"));
|
||||
assertThat(tags.get(1).getValue(), is(""));
|
||||
assertThat(tags.get(2).getValue(), is("404"));
|
||||
|
||||
Assert.assertEquals(true, SpanHelper.getErrorOccurred(finishedSpan));
|
||||
}
|
||||
|
||||
private void assertSpan(Span span) {
|
||||
Assert.assertEquals("http", StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG));
|
||||
Assert.assertEquals("GET", StringTagReader.get(span, Tags.HTTP.METHOD));
|
||||
Assert.assertEquals("skywalking.org", span.getPeerHost());
|
||||
Assert.assertEquals(-1, span.getPort());
|
||||
Assert.assertEquals("FeignDefaultHttp", StringTagReader.get(span, Tags.COMPONENT));
|
||||
Assert.assertEquals("discovery", StringTagReader.get(span, Tags.SPAN_KIND));
|
||||
Assert.assertEquals("", StringTagReader.get(span, Tags.URL));
|
||||
private void assertSpan(AbstractTracingSpan span) {
|
||||
assertThat(SpanHelper.getLayer(span), is(SpanLayer.HTTP));
|
||||
assertThat(SpanHelper.getComponentId(span), is(11));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testException() throws Throwable {
|
||||
defaultHttpClientInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
defaultHttpClientInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, result);
|
||||
|
||||
defaultHttpClientInterceptor.handleMethodException(new NullPointerException("testException"), classInstanceContext, null);
|
||||
defaultHttpClientInterceptor.handleMethodException(enhancedInstance, "execute", allArguments, argumentTypes, new NullPointerException("testException"));
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.status()).thenReturn(200);
|
||||
defaultHttpClientInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, response);
|
||||
defaultHttpClientInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override public void call(TraceSegment finishedSegment) {
|
||||
Assert.assertEquals(1, finishedSegment.getSpans().size());
|
||||
assertSpan(finishedSegment.getSpans().get(0));
|
||||
Assert.assertEquals(true, BooleanTagReader.get(finishedSegment.getSpans().get(0), Tags.ERROR));
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
Assert.assertEquals(1, SpanLogReader.getLogs(finishedSegment.getSpans().get(0)).size());
|
||||
Assert.assertEquals(true, SpanLogReader.getLogs(finishedSegment.getSpans().get(0)).get(0).getFields().containsKey("stack"));
|
||||
Assert.assertEquals("testException", SpanLogReader.getLogs(finishedSegment.getSpans().get(0)).get(0).getFields().get("message"));
|
||||
}
|
||||
});
|
||||
Assert.assertEquals(1, SegmentHelper.getSpans(traceSegment).size());
|
||||
AbstractTracingSpan finishedSpan = SegmentHelper.getSpans(traceSegment).get(0);
|
||||
assertSpan(finishedSpan);
|
||||
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(finishedSpan);
|
||||
assertThat(tags.size(), is(2));
|
||||
assertThat(tags.get(0).getValue(), is("GET"));
|
||||
assertThat(tags.get(1).getValue(), is(""));
|
||||
|
||||
Assert.assertEquals(true, SpanHelper.getErrorOccurred(finishedSpan));
|
||||
|
||||
Assert.assertEquals(1, SpanHelper.getLogs(finishedSpan).size());
|
||||
|
||||
LogDataEntity logDataEntity = SpanHelper.getLogs(finishedSpan).get(0);
|
||||
assertThat(logDataEntity.getLogs().size(), is(4));
|
||||
assertThat(logDataEntity.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
assertThat(logDataEntity.getLogs().get(1).getValue(), CoreMatchers.<Object>is(NullPointerException.class.getName()));
|
||||
assertThat(logDataEntity.getLogs().get(2).getValue(), is("testException"));
|
||||
assertNotNull(logDataEntity.getLogs().get(3).getValue());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ public class HttpClientExecuteInterceptor implements InstanceMethodsAroundInterc
|
|||
|
||||
span.setComponent(ComponentsDefine.HTTPCLIENT);
|
||||
Tags.URL.set(span, httpRequest.getRequestLine().getUri());
|
||||
Tags.HTTP.METHOD.set(span, httpRequest.getRequestLine().getMethod());
|
||||
SpanLayer.asHttp(span);
|
||||
|
||||
httpRequest.setHeader(Config.Plugin.Propagation.HEADER_NAME, contextCarrier.serialize());
|
||||
|
|
|
|||
|
|
@ -1,40 +1,56 @@
|
|||
package org.skywalking.apm.plugin.httpClient.v4;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import org.apache.http.*;
|
||||
import org.junit.After;
|
||||
import java.util.List;
|
||||
import org.apache.http.HttpHost;
|
||||
import org.apache.http.HttpRequest;
|
||||
import org.apache.http.HttpResponse;
|
||||
import org.apache.http.ProtocolVersion;
|
||||
import org.apache.http.RequestLine;
|
||||
import org.apache.http.StatusLine;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.powermock.core.classloader.annotations.PrepareForTest;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.BooleanTagReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
|
||||
import java.util.List;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
@PrepareForTest(HttpHost.class)
|
||||
public class HttpClientExecuteInterceptorTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule agentServiceRule = new AgentServiceRule();
|
||||
|
||||
private HttpClientExecuteInterceptor httpClientExecuteInterceptor;
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext instanceMethodInvokeContext;
|
||||
@Mock
|
||||
private HttpHost httpHost;
|
||||
@Mock
|
||||
|
|
@ -44,16 +60,20 @@ public class HttpClientExecuteInterceptorTest {
|
|||
@Mock
|
||||
private StatusLine statusLine;
|
||||
|
||||
private Object[] allArguments;
|
||||
private Class[] argumentsType;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
httpClientExecuteInterceptor = new HttpClientExecuteInterceptor();
|
||||
|
||||
PowerMockito.mock(HttpHost.class);
|
||||
when(statusLine.getStatusCode()).thenReturn(200);
|
||||
when(instanceMethodInvokeContext.allArguments()).thenReturn(new Object[] {httpHost, request});
|
||||
when(httpResponse.getStatusLine()).thenReturn(statusLine);
|
||||
when(httpHost.getHostName()).thenReturn("127.0.0.1");
|
||||
when(httpHost.getSchemeName()).thenReturn("http");
|
||||
|
|
@ -75,95 +95,80 @@ public class HttpClientExecuteInterceptorTest {
|
|||
});
|
||||
when(httpHost.getPort()).thenReturn(8080);
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
allArguments = new Object[] {httpHost, request};
|
||||
argumentsType = new Class[] {httpHost.getClass(), request.getClass()};
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHttpClient() {
|
||||
httpClientExecuteInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
httpClientExecuteInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, httpResponse);
|
||||
public void testHttpClient() throws Throwable {
|
||||
httpClientExecuteInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentsType, null);
|
||||
httpClientExecuteInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentsType, httpResponse);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertHttpSpan(traceSegment.getSpans().get(0));
|
||||
verify(request, times(1)).setHeader(anyString(), anyString());
|
||||
}
|
||||
});
|
||||
Assert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertHttpSpan(spans.get(0));
|
||||
verify(request, times(1)).setHeader(anyString(), anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStatusCodeNotEquals200() {
|
||||
public void testStatusCodeNotEquals200() throws Throwable {
|
||||
when(statusLine.getStatusCode()).thenReturn(500);
|
||||
httpClientExecuteInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
httpClientExecuteInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, httpResponse);
|
||||
httpClientExecuteInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentsType, null);
|
||||
httpClientExecuteInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentsType, httpResponse);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertHttpSpan(traceSegment.getSpans().get(0));
|
||||
assertThat(BooleanTagReader.get(traceSegment.getSpans().get(0), Tags.ERROR), is(true));
|
||||
verify(request, times(1)).setHeader(anyString(), anyString());
|
||||
}
|
||||
});
|
||||
Assert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertThat(spans.size(), is(1));
|
||||
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(spans.get(0));
|
||||
assertThat(tags.size(), is(3));
|
||||
assertThat(tags.get(2).getValue(), is("500"));
|
||||
|
||||
assertHttpSpan(spans.get(0));
|
||||
assertThat(SpanHelper.getErrorOccurred(spans.get(0)), is(true));
|
||||
verify(request, times(1)).setHeader(anyString(), anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHttpClientWithException() {
|
||||
httpClientExecuteInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
httpClientExecuteInterceptor.handleMethodException(new RuntimeException(), classInstanceContext, instanceMethodInvokeContext);
|
||||
httpClientExecuteInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, httpResponse);
|
||||
public void testHttpClientWithException() throws Throwable {
|
||||
httpClientExecuteInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentsType, null);
|
||||
httpClientExecuteInterceptor.handleMethodException(enhancedInstance, "execute", allArguments, argumentsType, new RuntimeException("testException"));
|
||||
httpClientExecuteInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentsType, httpResponse);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertThat(BooleanTagReader.get(span, Tags.ERROR), is(true));
|
||||
try {
|
||||
assertHttpSpanErrorLog(getLogs(span));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
verify(request, times(1)).setHeader(anyString(), anyString());
|
||||
Assert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
}
|
||||
|
||||
private void assertHttpSpanErrorLog(List<LogData> logs) {
|
||||
assertThat(logs.size(), is(1));
|
||||
LogData logData = logs.get(0);
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
}
|
||||
});
|
||||
assertThat(spans.size(), is(1));
|
||||
AbstractTracingSpan span = spans.get(0);
|
||||
assertHttpSpan(span);
|
||||
assertThat(SpanHelper.getErrorOccurred(span), is(true));
|
||||
assertHttpSpanErrorLog(SpanHelper.getLogs(span));
|
||||
verify(request, times(1)).setHeader(anyString(), anyString());
|
||||
|
||||
}
|
||||
|
||||
private void assertHttpSpan(Span span) {
|
||||
private void assertHttpSpanErrorLog(List<LogDataEntity> logs) {
|
||||
assertThat(logs.size(), is(1));
|
||||
LogDataEntity logData = logs.get(0);
|
||||
Assert.assertThat(logData.getLogs().size(), is(4));
|
||||
Assert.assertThat(logData.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
Assert.assertThat(logData.getLogs().get(1).getValue(), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
Assert.assertThat(logData.getLogs().get(2).getValue(), is("testException"));
|
||||
assertNotNull(logData.getLogs().get(3).getValue());
|
||||
}
|
||||
|
||||
private void assertHttpSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("/test-web/test"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("HttpClient"));
|
||||
assertThat(span.getPeerHost(), is("127.0.0.1"));
|
||||
assertThat(span.getPort(), is(8080));
|
||||
assertThat(StringTagReader.get(span, Tags.URL), is("http://127.0.0.1:8080/test-web/test"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_CLIENT));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
|
||||
protected List<LogData> getLogs(Span span) throws NoSuchFieldException, IllegalAccessException {
|
||||
Field logs = Span.class.getDeclaredField("logs");
|
||||
logs.setAccessible(true);
|
||||
return (List<LogData>)logs.get(span);
|
||||
assertThat(SpanHelper.getComponentId(span), is(2));
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(span);
|
||||
assertThat(tags.get(0).getValue(), is("http://127.0.0.1:8080/test-web/test"));
|
||||
assertThat(tags.get(1).getValue(), is("GET"));
|
||||
assertThat(span.isExit(), is(true));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ public class StatementTracing {
|
|||
Tags.DB_TYPE.set(span, "sql");
|
||||
Tags.DB_INSTANCE.set(span, connectInfo.getDatabaseName());
|
||||
Tags.DB_STATEMENT.set(span, sql);
|
||||
span.setComponent(connectInfo.getDBType());
|
||||
span.setComponent(connectInfo.getComponent());
|
||||
SpanLayer.asDB(span);
|
||||
return exec.exe(realStatement, sql);
|
||||
} catch (SQLException e) {
|
||||
|
|
|
|||
|
|
@ -1,45 +1,43 @@
|
|||
package org.skywalking.apm.plugin.jdbc;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.sql.SQLException;
|
||||
import java.util.List;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import org.junit.Assert;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public abstract class AbstractStatementTest {
|
||||
|
||||
protected MockTracingContextListener mockTracerContextListener;
|
||||
|
||||
protected void assertDBSpanLog(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertEquals(logData.getFields().get("error.kind"), SQLException.class.getName());
|
||||
assertNull(logData.getFields().get("message"));
|
||||
protected void assertDBSpanLog(LogDataEntity logData) {
|
||||
Assert.assertThat(logData.getLogs().size(), is(4));
|
||||
Assert.assertThat(logData.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
Assert.assertThat(logData.getLogs().get(1).getValue(), CoreMatchers.<Object>is(SQLException.class.getName()));
|
||||
Assert.assertNull(logData.getLogs().get(2).getValue());
|
||||
assertNotNull(logData.getLogs().get(3).getValue());
|
||||
}
|
||||
|
||||
protected void assertDBSpan(Span span, String exceptOperationName, String exceptDBStatement) {
|
||||
protected void assertDBSpan(AbstractTracingSpan span, String exceptOperationName, String exceptDBStatement) {
|
||||
assertDBSpan(span, exceptOperationName);
|
||||
assertThat(StringTagReader.get(span, Tags.DB_STATEMENT), is(exceptDBStatement));
|
||||
assertThat(span.isExit(), is(true));
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(span);
|
||||
assertThat(tags.get(2).getValue(), is(exceptDBStatement));
|
||||
}
|
||||
|
||||
protected void assertDBSpan(Span span, String exceptOperationName) {
|
||||
protected void assertDBSpan(AbstractTracingSpan span, String exceptOperationName) {
|
||||
assertThat(span.getOperationName(), is(exceptOperationName));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Mysql"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_INSTANCE), is("test"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("db"));
|
||||
}
|
||||
|
||||
protected List<LogData> getLogs(Span span) throws NoSuchFieldException, IllegalAccessException {
|
||||
Field logs = Span.class.getDeclaredField("logs");
|
||||
logs.setAccessible(true);
|
||||
return (List<LogData>)logs.get(span);
|
||||
assertThat(SpanHelper.getComponentId(span), is(5));
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(span);
|
||||
assertThat(tags.get(0).getValue(), is("sql"));
|
||||
assertThat(tags.get(1).getValue(), is("test"));
|
||||
assertThat(SpanHelper.getLayer(span), is(SpanLayer.DB));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,30 +1,48 @@
|
|||
package org.skywalking.apm.plugin.jdbc;
|
||||
|
||||
import com.mysql.cj.api.jdbc.JdbcConnection;
|
||||
import java.util.List;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Matchers;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.io.Reader;
|
||||
import java.math.BigDecimal;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.sql.*;
|
||||
import java.sql.Array;
|
||||
import java.sql.Blob;
|
||||
import java.sql.CallableStatement;
|
||||
import java.sql.Clob;
|
||||
import java.sql.Connection;
|
||||
import java.sql.Date;
|
||||
import java.sql.NClob;
|
||||
import java.sql.Ref;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.RowId;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.SQLXML;
|
||||
import java.sql.Time;
|
||||
import java.sql.Timestamp;
|
||||
import java.util.Calendar;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Matchers;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
|
|
@ -37,10 +55,20 @@ import static org.mockito.Matchers.anyInt;
|
|||
import static org.mockito.Matchers.anyLong;
|
||||
import static org.mockito.Matchers.anyShort;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class SWCallableStatementTest extends AbstractStatementTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private Array array;
|
||||
@Mock
|
||||
|
|
@ -69,13 +97,8 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
ServiceManager.INSTANCE.boot();
|
||||
swConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306/test", new Properties(), jdbcConnection);
|
||||
multiHostConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306,127.0.0.1:3309/test", new Properties(), jdbcConnection);
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
when(jdbcConnection.prepareCall(anyString())).thenReturn(mysqlCallableStatement);
|
||||
when(jdbcConnection.prepareCall(anyString(), anyInt(), anyInt(), anyInt())).thenReturn(mysqlCallableStatement);
|
||||
when(jdbcConnection.prepareCall(anyString(), anyInt(), anyInt())).thenReturn(mysqlCallableStatement);
|
||||
|
|
@ -95,14 +118,14 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
callableStatement.setCharacterStream(4, reader);
|
||||
callableStatement.setCharacterStream(4, reader, 10);
|
||||
callableStatement.setCharacterStream(5, reader, 10L);
|
||||
callableStatement.setShort(6, (short) 12);
|
||||
callableStatement.setShort(6, (short)12);
|
||||
callableStatement.setInt(7, 1);
|
||||
callableStatement.setString(8, "test");
|
||||
callableStatement.setBoolean(9, true);
|
||||
callableStatement.setLong(10, 100L);
|
||||
callableStatement.setDouble(11, 12.0);
|
||||
callableStatement.setFloat(12, 12.0f);
|
||||
callableStatement.setByte(13, (byte) 1);
|
||||
callableStatement.setByte(13, (byte)1);
|
||||
callableStatement.setBytes(14, bytesParam);
|
||||
callableStatement.setDate(15, new Date(System.currentTimeMillis()));
|
||||
callableStatement.setNull(16, 1);
|
||||
|
|
@ -209,14 +232,14 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
callableStatement.setCharacterStream("d", reader);
|
||||
callableStatement.setCharacterStream("e", reader, 10);
|
||||
callableStatement.setCharacterStream("f", reader, 10L);
|
||||
callableStatement.setShort("g", (short) 12);
|
||||
callableStatement.setShort("g", (short)12);
|
||||
callableStatement.setInt("h", 1);
|
||||
callableStatement.setString("i", "test");
|
||||
callableStatement.setBoolean("j", true);
|
||||
callableStatement.setLong("k", 100L);
|
||||
callableStatement.setDouble("l", 12.0);
|
||||
callableStatement.setFloat("m", 12.0f);
|
||||
callableStatement.setByte("n", (byte) 1);
|
||||
callableStatement.setByte("n", (byte)1);
|
||||
callableStatement.setBytes("o", bytesParam);
|
||||
callableStatement.setDate("p", new Date(System.currentTimeMillis()));
|
||||
callableStatement.setNull("q", 1);
|
||||
|
|
@ -437,15 +460,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlCallableStatement, times(1)).executeQuery();
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -458,15 +477,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlCallableStatement, times(1)).executeQuery(anyString());
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -477,15 +492,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlCallableStatement, times(1)).execute(anyString(), anyInt());
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -495,15 +506,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -513,15 +520,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -534,15 +537,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlCallableStatement, times(1)).execute(anyString());
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/execute", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/execute", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -555,15 +554,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlCallableStatement, times(1)).executeUpdate();
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = ?");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -576,15 +571,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlCallableStatement, times(1)).executeUpdate(anyString());
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -596,15 +587,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -616,15 +603,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -636,21 +619,17 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlCallableStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBatch() throws SQLException, MalformedURLException {
|
||||
CallableStatement preparedStatement = multiHostConnection.prepareCall("UPDATE test SET a = ? WHERE b = ?");
|
||||
preparedStatement.setShort(1, (short) 12);
|
||||
preparedStatement.setShort(1, (short)12);
|
||||
preparedStatement.setTime(2, new Time(System.currentTimeMillis()));
|
||||
preparedStatement.addBatch();
|
||||
int[] resultSet = preparedStatement.executeBatch();
|
||||
|
|
@ -660,15 +639,11 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
verify(mysqlCallableStatement, times(1)).addBatch();
|
||||
verify(mysqlCallableStatement, times(1)).clearBatch();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeBatch", "");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeBatch", "");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -694,7 +669,7 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.setBigDecimal(1, new BigDecimal(10000));
|
||||
preparedStatement.setBlob(2, inputStream);
|
||||
preparedStatement.setBlob(3, inputStream, 1000000L);
|
||||
preparedStatement.setByte(3, (byte) 1);
|
||||
preparedStatement.setByte(3, (byte)1);
|
||||
preparedStatement.setBytes(4, bytesParam);
|
||||
preparedStatement.setLong(5, 100L);
|
||||
|
||||
|
|
@ -708,32 +683,14 @@ public class SWCallableStatementTest extends AbstractStatementTest {
|
|||
verify(mysqlCallableStatement, times(1)).setBlob(anyInt(), any(InputStream.class));
|
||||
verify(mysqlCallableStatement, times(1)).setBlob(anyInt(), any(InputStream.class), anyLong());
|
||||
verify(mysqlCallableStatement, times(1)).setByte(anyInt(), anyByte());
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/CallableStatement/executeQuery", "SELECT * FROM test WHERE a = ? or b = ? or c=? or d = ? or e=?");
|
||||
try {
|
||||
List<LogData> logData = getLogs(span);
|
||||
Assert.assertThat(logData.size(), is(1));
|
||||
assertThat(logData.size(), is(1));
|
||||
assertDBSpanLog(logData.get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/CallableStatement/executeQuery", "SELECT * FROM test WHERE a = ? or b = ? or c=? or d = ? or e=?");
|
||||
List<LogDataEntity> logs = SpanHelper.getLogs(spans.get(0));
|
||||
Assert.assertThat(logs.size(), is(1));
|
||||
assertDBSpanLog(logs.get(0));
|
||||
}
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,23 +1,28 @@
|
|||
package org.skywalking.apm.plugin.jdbc;
|
||||
|
||||
import com.mysql.cj.api.jdbc.JdbcConnection;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Savepoint;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
import java.util.concurrent.Executor;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.assertThat;
|
||||
|
|
@ -25,10 +30,21 @@ import static org.mockito.Matchers.any;
|
|||
import static org.mockito.Matchers.anyBoolean;
|
||||
import static org.mockito.Matchers.anyInt;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.doThrow;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class SWConnectionTest extends AbstractStatementTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private com.mysql.cj.jdbc.PreparedStatement mysqlPreparedStatement;
|
||||
@Mock
|
||||
|
|
@ -42,13 +58,8 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
swConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306/test", new Properties(), jdbcConnection);
|
||||
multiHostConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306,127.0.0.1:3309/test", new Properties(), jdbcConnection);
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
when(jdbcConnection.prepareStatement(anyString())).thenReturn(mysqlPreparedStatement);
|
||||
}
|
||||
|
||||
|
|
@ -58,14 +69,12 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
|
||||
swConnection.commit();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/commit");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/commit");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -73,14 +82,12 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", new String[] {"1"});
|
||||
multiHostConnection.commit();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/commit");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/commit");
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
|
|
@ -90,21 +97,14 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
try {
|
||||
swConnection.commit();
|
||||
} finally {
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/commit");
|
||||
try {
|
||||
assertDBSpanLog(getLogs(traceSegment.getSpans().get(0)).get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/commit");
|
||||
assertThat(SpanHelper.getLogs(spans.get(0)).size(), is(1));
|
||||
assertDBSpanLog(SpanHelper.getLogs(spans.get(0)).get(0));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -113,15 +113,12 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", 1, 1);
|
||||
swConnection.rollback();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/rollback");
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
}
|
||||
});
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/rollback");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -129,14 +126,12 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
PreparedStatement preparedStatement = swConnection.prepareStatement("SELECT * FROM test", 1, 1, 1);
|
||||
multiHostConnection.rollback();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/rollback");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/rollback");
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
|
|
@ -145,42 +140,38 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
|
||||
swConnection.rollback();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/rollback");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/rollback");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRollBackWithSavePoint() throws SQLException {
|
||||
swConnection.rollback(savepoint);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/rollback to savepoint");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/rollback to savepoint");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultiHostRollBackWithSavePoint() throws SQLException {
|
||||
multiHostConnection.rollback(savepoint);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/rollback to savepoint");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/rollback to savepoint");
|
||||
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
|
|
@ -189,21 +180,14 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
|
||||
swConnection.rollback(savepoint);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/rollback to savepoint");
|
||||
try {
|
||||
assertDBSpanLog(getLogs(traceSegment.getSpans().get(0)).get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/rollback to savepoint");
|
||||
assertDBSpanLog(SpanHelper.getLogs(spans.get(0)).get(0));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -211,28 +195,26 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
swConnection.close();
|
||||
swConnection.clearWarnings();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/close");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/close");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultiHostClose() throws SQLException {
|
||||
multiHostConnection.close();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/close");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/close");
|
||||
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
|
|
@ -241,21 +223,13 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
|
||||
swConnection.close();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/close");
|
||||
try {
|
||||
assertDBSpanLog(getLogs(traceSegment.getSpans().get(0)).get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/close");
|
||||
assertDBSpanLog(SpanHelper.getLogs(spans.get(0)).get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -263,28 +237,25 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
swConnection.releaseSavepoint(savepoint);
|
||||
swConnection.clearWarnings();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/releaseSavepoint savepoint");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/releaseSavepoint savepoint");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultiHostReleaseSavePoint() throws SQLException {
|
||||
multiHostConnection.releaseSavepoint(savepoint);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/releaseSavepoint savepoint");
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/releaseSavepoint savepoint");
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
|
|
@ -293,21 +264,13 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
|
||||
swConnection.releaseSavepoint(savepoint);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
assertDBSpan(traceSegment.getSpans().get(0), "Mysql/JDBI/Connection/releaseSavepoint savepoint");
|
||||
try {
|
||||
assertDBSpanLog(getLogs(traceSegment.getSpans().get(0)).get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Connection/releaseSavepoint savepoint");
|
||||
assertDBSpanLog(SpanHelper.getLogs(spans.get(0)).get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -370,10 +333,4 @@ public class SWConnectionTest extends AbstractStatementTest {
|
|||
verify(jdbcConnection, times(1)).setTypeMap(any(HashMap.class));
|
||||
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,35 +1,50 @@
|
|||
package org.skywalking.apm.plugin.jdbc;
|
||||
|
||||
import com.mysql.cj.api.jdbc.JdbcConnection;
|
||||
import java.util.List;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
|
||||
import java.net.MalformedURLException;
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.mockito.Matchers.anyBoolean;
|
||||
import static org.mockito.Matchers.anyInt;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class SWStatementTest extends AbstractStatementTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private com.mysql.cj.jdbc.StatementImpl mysqlStatement;
|
||||
@Mock
|
||||
|
|
@ -39,14 +54,9 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
swConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306/test", new Properties(), jdbcConnection);
|
||||
multiHostConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306,127.0.0.1:3309/test", new Properties(), jdbcConnection);
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
when(jdbcConnection.createStatement()).thenReturn(mysqlStatement);
|
||||
when(jdbcConnection.createStatement(anyInt(), anyInt())).thenReturn(mysqlStatement);
|
||||
when(jdbcConnection.createStatement(anyInt(), anyInt(), anyInt())).thenReturn(mysqlStatement);
|
||||
|
|
@ -111,15 +121,10 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
verify(mysqlStatement, times(1)).getResultSet();
|
||||
assertThat(connection, CoreMatchers.<Connection>is(swConnection));
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/execute", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/execute", "SELECT * FROM test");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -127,15 +132,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1);
|
||||
boolean executeSuccess = statement.execute("SELECT * FROM test", 1);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/execute", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/execute", "SELECT * FROM test");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -143,15 +144,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1, 1);
|
||||
ResultSet executeSuccess = statement.executeQuery("SELECT * FROM test");
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/executeQuery", "SELECT * FROM test");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -159,15 +156,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1, 1);
|
||||
int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1");
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -177,15 +170,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
statement.getGeneratedKeys();
|
||||
|
||||
verify(mysqlStatement, times(1)).getGeneratedKeys();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -193,15 +182,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1, 1);
|
||||
int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1", new int[] {1});
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -209,15 +194,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1, 1);
|
||||
int executeSuccess = statement.executeUpdate("UPDATE test SET a = 1", new String[] {"1"});
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/executeUpdate", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -225,15 +206,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1, 1);
|
||||
boolean executeSuccess = statement.execute("UPDATE test SET a = 1", new int[] {1});
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/execute", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/execute", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -241,15 +218,10 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
Statement statement = swConnection.createStatement(1, 1, 1);
|
||||
boolean executeSuccess = statement.execute("UPDATE test SET a = 1", new String[] {"1"});
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/execute", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/execute", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -263,15 +235,11 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
verify(mysqlStatement, times(1)).addBatch(anyString());
|
||||
verify(mysqlStatement, times(1)).clearBatch();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/executeBatch", "");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/executeBatch", "");
|
||||
|
||||
}
|
||||
|
||||
@Test(expected = SQLException.class)
|
||||
|
|
@ -282,30 +250,14 @@ public class SWStatementTest extends AbstractStatementTest {
|
|||
statement.execute("UPDATE test SET a = 1 WHERE b = 2");
|
||||
} finally {
|
||||
verify(mysqlStatement, times(1)).execute(anyString());
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/Statement/execute", "UPDATE test SET a = 1 WHERE b = 2");
|
||||
List<LogData> logs = null;
|
||||
try {
|
||||
logs = getLogs(span);
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
assertThat(logs.size(), is(1));
|
||||
assertDBSpanLog(logs.get(0));
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/Statement/execute", "UPDATE test SET a = 1 WHERE b = 2");
|
||||
assertThat(SpanHelper.getLogs(spans.get(0)).size(), is(1));
|
||||
assertDBSpanLog(SpanHelper.getLogs(spans.get(0)).get(0));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,30 +1,48 @@
|
|||
package org.skywalking.apm.plugin.jdbc;
|
||||
|
||||
import com.mysql.cj.api.jdbc.JdbcConnection;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.List;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Matchers;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.io.Reader;
|
||||
import java.math.BigDecimal;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.sql.*;
|
||||
import java.sql.Array;
|
||||
import java.sql.Blob;
|
||||
import java.sql.Clob;
|
||||
import java.sql.Connection;
|
||||
import java.sql.Date;
|
||||
import java.sql.NClob;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.Ref;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.RowId;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.SQLXML;
|
||||
import java.sql.Time;
|
||||
import java.sql.Timestamp;
|
||||
import java.util.Calendar;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Matchers;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
|
|
@ -37,10 +55,18 @@ import static org.mockito.Matchers.anyInt;
|
|||
import static org.mockito.Matchers.anyLong;
|
||||
import static org.mockito.Matchers.anyShort;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class SwPreparedStatementTest extends AbstractStatementTest {
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private Array array;
|
||||
|
|
@ -70,14 +96,9 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
swConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306/test", new Properties(), jdbcConnection);
|
||||
multiHostConnection = new SWConnection("jdbc:mysql://127.0.0.1:3306,127.0.0.1:3309/test", new Properties(), jdbcConnection);
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
when(jdbcConnection.prepareStatement(anyString())).thenReturn(mysqlPreparedStatement);
|
||||
when(jdbcConnection.prepareStatement(anyString(), anyInt(), anyInt(), anyInt())).thenReturn(mysqlPreparedStatement);
|
||||
when(jdbcConnection.prepareStatement(anyString(), anyInt(), anyInt())).thenReturn(mysqlPreparedStatement);
|
||||
|
|
@ -98,14 +119,14 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.setCharacterStream(4, reader);
|
||||
preparedStatement.setCharacterStream(4, reader, 10);
|
||||
preparedStatement.setCharacterStream(5, reader, 10L);
|
||||
preparedStatement.setShort(6, (short) 12);
|
||||
preparedStatement.setShort(6, (short)12);
|
||||
preparedStatement.setInt(7, 1);
|
||||
preparedStatement.setString(8, "test");
|
||||
preparedStatement.setBoolean(9, true);
|
||||
preparedStatement.setLong(10, 100L);
|
||||
preparedStatement.setDouble(11, 12.0);
|
||||
preparedStatement.setFloat(12, 12.0f);
|
||||
preparedStatement.setByte(13, (byte) 1);
|
||||
preparedStatement.setByte(13, (byte)1);
|
||||
preparedStatement.setBytes(14, bytesParam);
|
||||
preparedStatement.setDate(15, new Date(System.currentTimeMillis()));
|
||||
preparedStatement.setNull(16, 1);
|
||||
|
|
@ -271,15 +292,10 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlPreparedStatement, times(1)).executeQuery();
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -292,15 +308,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlPreparedStatement, times(1)).executeQuery(anyString());
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeQuery", "SELECT * FROM test");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeQuery", "SELECT * FROM test");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -311,15 +323,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlPreparedStatement, times(1)).execute(anyString(), anyInt());
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -329,15 +337,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -347,15 +351,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/execute", "INSERT INTO test VALUES(1)");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -368,15 +368,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlPreparedStatement, times(1)).execute(anyString());
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/execute", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/execute", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -389,15 +385,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlPreparedStatement, times(1)).executeUpdate();
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = ?");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = ?");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -410,15 +402,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
|
||||
verify(mysqlPreparedStatement, times(1)).executeUpdate(anyString());
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -430,15 +418,10 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -450,15 +433,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -470,21 +449,16 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.close();
|
||||
|
||||
verify(mysqlPreparedStatement, times(1)).close();
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeUpdate", "UPDATE test SET a = 1");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBatch() throws SQLException, MalformedURLException {
|
||||
PreparedStatement preparedStatement = multiHostConnection.prepareStatement("UPDATE test SET a = ? WHERE b = ?");
|
||||
preparedStatement.setShort(1, (short) 12);
|
||||
preparedStatement.setShort(1, (short)12);
|
||||
preparedStatement.setTime(2, new Time(System.currentTimeMillis()));
|
||||
preparedStatement.addBatch();
|
||||
int[] resultSet = preparedStatement.executeBatch();
|
||||
|
|
@ -494,15 +468,11 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
verify(mysqlPreparedStatement, times(1)).addBatch();
|
||||
verify(mysqlPreparedStatement, times(1)).clearBatch();
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeBatch", "");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeBatch", "");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -528,7 +498,7 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
preparedStatement.setBigDecimal(1, new BigDecimal(10000));
|
||||
preparedStatement.setBlob(2, inputStream);
|
||||
preparedStatement.setBlob(3, inputStream, 1000000L);
|
||||
preparedStatement.setByte(3, (byte) 1);
|
||||
preparedStatement.setByte(3, (byte)1);
|
||||
preparedStatement.setBytes(4, new byte[] {1, 2});
|
||||
preparedStatement.setLong(5, 100L);
|
||||
|
||||
|
|
@ -543,33 +513,17 @@ public class SwPreparedStatementTest extends AbstractStatementTest {
|
|||
verify(mysqlPreparedStatement, times(1)).setBlob(anyInt(), any(InputStream.class), anyLong());
|
||||
verify(mysqlPreparedStatement, times(1)).setByte(anyInt(), anyByte());
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertDBSpan(span, "Mysql/JDBI/PreparedStatement/executeQuery", "SELECT * FROM test WHERE a = ? or b = ? or c=? or d = ? or e=?");
|
||||
try {
|
||||
Field logs = Span.class.getDeclaredField("logs");
|
||||
logs.setAccessible(true);
|
||||
List<LogData> logData = (List<LogData>)logs.get(span);
|
||||
Assert.assertThat(logData.size(), is(1));
|
||||
assertThat(logData.size(), is(1));
|
||||
assertDBSpanLog(logData.get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertDBSpan(spans.get(0), "Mysql/JDBI/PreparedStatement/executeQuery", "SELECT * FROM test WHERE a = ? or b = ? or c=? or d = ? or e=?");
|
||||
|
||||
}
|
||||
});
|
||||
List<LogDataEntity> logData = SpanHelper.getLogs(spans.get(0));
|
||||
Assert.assertThat(logData.size(), is(1));
|
||||
assertThat(logData.size(), is(1));
|
||||
assertDBSpanLog(logData.get(0));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ import org.junit.Test;
|
|||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import redis.clients.jedis.HostAndPort;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
|
|
@ -17,15 +18,11 @@ public class JedisClusterConstructorWithHostAndPortArgInterceptorTest {
|
|||
private JedisClusterConstructorWithHostAndPortArgInterceptor interceptor;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private ConstructorInvokeContext invokeContext;
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
interceptor = new JedisClusterConstructorWithHostAndPortArgInterceptor();
|
||||
|
||||
when(invokeContext.allArguments()).thenReturn(new Object[] {new HostAndPort("127.0.0.1", 6379)});
|
||||
}
|
||||
|
||||
@After
|
||||
|
|
@ -35,11 +32,8 @@ public class JedisClusterConstructorWithHostAndPortArgInterceptorTest {
|
|||
|
||||
@Test
|
||||
public void onConstruct() throws Exception {
|
||||
interceptor.onConstruct(instanceContext, invokeContext);
|
||||
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_CONN_INFO, "127.0.0.1:6379");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_PORT, 6379);
|
||||
interceptor.onConstruct(enhancedInstance, new Object[] {new HostAndPort("127.0.0.1", 6379)});
|
||||
verify(enhancedInstance, times(1)).setSkyWalkingDynamicField("127.0.0.1:6379");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,41 +1,35 @@
|
|||
package org.skywalking.apm.plugin.jedis.v2;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import redis.clients.jedis.HostAndPort;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.mockito.Matchers.contains;
|
||||
import static org.mockito.Matchers.eq;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.skywalking.apm.plugin.jedis.v2.JedisMethodInterceptor.KEY_OF_REDIS_CONN_INFO;
|
||||
import static org.skywalking.apm.plugin.jedis.v2.JedisMethodInterceptor.KEY_OF_REDIS_HOSTS;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class JedisClusterConstructorWithListHostAndPortArgInterceptorTest {
|
||||
|
||||
private JedisClusterConstructorWithListHostAndPortArgInterceptor interceptor;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private ConstructorInvokeContext invokeContext;
|
||||
|
||||
private Set<HostAndPort> hostAndPortSet;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
hostAndPortSet = new HashSet<HostAndPort>();
|
||||
interceptor = new JedisClusterConstructorWithListHostAndPortArgInterceptor();
|
||||
hostAndPortSet.add(new HostAndPort("127.0.0.1", 6379));
|
||||
hostAndPortSet.add(new HostAndPort("127.0.0.1", 16379));
|
||||
|
||||
when(invokeContext.allArguments()).thenReturn(new Object[] {hostAndPortSet});
|
||||
}
|
||||
|
||||
@After
|
||||
|
|
@ -45,10 +39,9 @@ public class JedisClusterConstructorWithListHostAndPortArgInterceptorTest {
|
|||
|
||||
@Test
|
||||
public void onConstruct() throws Exception {
|
||||
interceptor.onConstruct(instanceContext, invokeContext);
|
||||
interceptor.onConstruct(enhancedInstance, new Object[] {hostAndPortSet});
|
||||
|
||||
verify(instanceContext, times(1)).set(eq(KEY_OF_REDIS_CONN_INFO), contains("127.0.0.1:6379;"));
|
||||
verify(instanceContext, times(1)).set(eq(KEY_OF_REDIS_HOSTS), contains("127.0.0.1:16379;"));
|
||||
verify(enhancedInstance, times(1)).setSkyWalkingDynamicField("127.0.0.1:6379;127.0.0.1:16379;");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,24 +6,21 @@ import org.junit.Test;
|
|||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import redis.clients.jedis.JedisShardInfo;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.skywalking.apm.plugin.jedis.v2.JedisMethodInterceptor.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class JedisConstructorWithShardInfoArgInterceptorTest {
|
||||
private JedisConstructorWithShardInfoArgInterceptor interceptor;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private ConstructorInvokeContext invokeContext;
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
interceptor = new JedisConstructorWithShardInfoArgInterceptor();
|
||||
|
||||
when(invokeContext.allArguments()).thenReturn(new Object[] {new JedisShardInfo("127.0.0.1", 6379)});
|
||||
}
|
||||
|
||||
@After
|
||||
|
|
@ -34,10 +31,8 @@ public class JedisConstructorWithShardInfoArgInterceptorTest {
|
|||
@Test
|
||||
public void onConstruct() throws Exception {
|
||||
|
||||
interceptor.onConstruct(instanceContext, invokeContext);
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_CONN_INFO, "127.0.0.1:6379");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_PORT, 6379);
|
||||
interceptor.onConstruct(enhancedInstance, new Object[] {new JedisShardInfo("127.0.0.1", 6379)});
|
||||
verify(enhancedInstance, times(1)).setSkyWalkingDynamicField("127.0.0.1:6379");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,9 +5,10 @@ import org.junit.Test;
|
|||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.skywalking.apm.plugin.jedis.v2.JedisMethodInterceptor.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class JedisConstructorWithStringArgInterceptorTest {
|
||||
|
|
@ -15,33 +16,25 @@ public class JedisConstructorWithStringArgInterceptorTest {
|
|||
private JedisConstructorWithStringArgInterceptor interceptor;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private ConstructorInvokeContext invokeContext;
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
interceptor = new JedisConstructorWithStringArgInterceptor();
|
||||
when(invokeContext.allArguments()).thenReturn(new Object[] {"127.0.0.1"});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void onConstruct() throws Exception {
|
||||
interceptor.onConstruct(instanceContext, invokeContext);
|
||||
interceptor.onConstruct(enhancedInstance, new Object[] {"127.0.0.1"});
|
||||
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_CONN_INFO, "127.0.0.1:6379");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_PORT, 6379);
|
||||
verify(enhancedInstance, times(1)).setSkyWalkingDynamicField("127.0.0.1:6379");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void onConstructWithPort() {
|
||||
when(invokeContext.allArguments()).thenReturn(new Object[] {"127.0.0.1", 16379});
|
||||
interceptor.onConstruct(instanceContext, invokeContext);
|
||||
interceptor.onConstruct(enhancedInstance, new Object[] {"127.0.0.1", 16379});
|
||||
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_CONN_INFO, "127.0.0.1:16379");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(KEY_OF_REDIS_PORT, 16379);
|
||||
verify(enhancedInstance, times(1)).setSkyWalkingDynamicField("127.0.0.1:16379");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,15 +1,16 @@
|
|||
package org.skywalking.apm.plugin.jedis.v2;
|
||||
|
||||
import java.net.URI;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.core.classloader.annotations.PrepareForTest;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
|
||||
import java.net.URI;
|
||||
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PrepareForTest(URI.class)
|
||||
|
|
@ -18,24 +19,18 @@ public class JedisConstructorWithUriArgInterceptorTest {
|
|||
private JedisConstructorWithUriArgInterceptor interceptor;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private ConstructorInvokeContext invokeContext;
|
||||
private EnhancedInstance enhancedInstance;
|
||||
private URI uri = URI.create("http://127.0.0.1:6379");
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
interceptor = new JedisConstructorWithUriArgInterceptor();
|
||||
|
||||
when(invokeContext.allArguments()).thenReturn(new Object[] {uri});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void onConstruct() throws Exception {
|
||||
interceptor.onConstruct(instanceContext, invokeContext);
|
||||
interceptor.onConstruct(enhancedInstance, new Object[] {uri});
|
||||
|
||||
verify(instanceContext, times(1)).set(JedisMethodInterceptor.KEY_OF_REDIS_CONN_INFO, "127.0.0.1:6379");
|
||||
verify(instanceContext, times(1)).set(JedisMethodInterceptor.KEY_OF_REDIS_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(JedisMethodInterceptor.KEY_OF_REDIS_PORT, 6379);
|
||||
verify(enhancedInstance, times(1)).setSkyWalkingDynamicField("127.0.0.1:6379");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,154 +1,117 @@
|
|||
package org.skywalking.apm.plugin.jedis.v2;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.List;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.hamcrest.MatcherAssert;
|
||||
import org.junit.After;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.*;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.plugin.jedis.v2.JedisMethodInterceptor.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class JedisMethodInterceptorTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
private JedisMethodInterceptor interceptor;
|
||||
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
private Object[] allArgument;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
private Class[] argumentType;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
allArgument = new Object[] {"OperationKey", "OperationValue"};
|
||||
argumentType = new Class[] {String.class, String.class};
|
||||
|
||||
interceptor = new JedisMethodInterceptor();
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
when(classInstanceContext.get(KEY_OF_REDIS_HOST)).thenReturn("127.0.0.1");
|
||||
when(classInstanceContext.get(KEY_OF_REDIS_PORT)).thenReturn(6379);
|
||||
when(methodInvokeContext.methodName()).thenReturn("set");
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {"OperationKey"});
|
||||
when(classInstanceContext.isContain("__$invokeCounterKey")).thenReturn(true);
|
||||
when(enhancedInstance.getSkyWalkingDynamicField()).thenReturn("127.0.0.1:6379");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntercept() {
|
||||
when(classInstanceContext.get("__$invokeCounterKey")).thenReturn(0);
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
when(classInstanceContext.get("__$invokeCounterKey")).thenReturn(1);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testIntercept() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "set", allArgument, argumentType, null);
|
||||
interceptor.afterMethod(enhancedInstance, "set", allArgument, argumentType, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span);
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertRedisSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInterceptWithMultiHost() {
|
||||
when(classInstanceContext.get("__$invokeCounterKey")).thenReturn(0);
|
||||
when(classInstanceContext.get(KEY_OF_REDIS_HOST)).thenReturn(null);
|
||||
when(classInstanceContext.get(KEY_OF_REDIS_HOSTS)).thenReturn("127.0.0.1:6379;127.0.0.1:16379;");
|
||||
public void testInterceptWithMultiHost() throws Throwable {
|
||||
when(enhancedInstance.getSkyWalkingDynamicField()).thenReturn("127.0.0.1:6379;127.0.0.1:16379;");
|
||||
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
when(classInstanceContext.get("__$invokeCounterKey")).thenReturn(1);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.beforeMethod(enhancedInstance, "set", allArgument, argumentType, null);
|
||||
interceptor.afterMethod(enhancedInstance, "set", allArgument, argumentType, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span, "127.0.0.1:6379;127.0.0.1:16379;");
|
||||
}
|
||||
});
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertRedisSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInterceptWithException() {
|
||||
when(classInstanceContext.get("__$invokeCounterKey")).thenReturn(0);
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
when(classInstanceContext.get("__$invokeCounterKey")).thenReturn(1);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testInterceptWithException() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "set", allArgument, argumentType, null);
|
||||
interceptor.handleMethodException(enhancedInstance, "set", allArgument, argumentType, new RuntimeException());
|
||||
interceptor.afterMethod(enhancedInstance, "set", allArgument, argumentType, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span);
|
||||
try {
|
||||
Field logs = Span.class.getDeclaredField("logs");
|
||||
logs.setAccessible(true);
|
||||
List<LogData> logData = (List<LogData>)logs.get(span);
|
||||
assertThat(logData.size(), is(1));
|
||||
assertLogData(logData.get(0));
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new RuntimeException(e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertThat(spans.size(), is(1));
|
||||
assertRedisSpan(spans.get(0));
|
||||
|
||||
}
|
||||
});
|
||||
assertLogData(SpanHelper.getLogs(spans.get(0)));
|
||||
}
|
||||
|
||||
private void assertLogData(LogData logData) {
|
||||
MatcherAssert.assertThat(logData.getFields().size(), is(4));
|
||||
MatcherAssert.assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertEquals(logData.getFields().get("error.kind"), RuntimeException.class.getName());
|
||||
assertNull(logData.getFields().get("message"));
|
||||
private void assertLogData(List<LogDataEntity> logDataEntities) {
|
||||
assertThat(logDataEntities.size(), is(1));
|
||||
LogDataEntity logData = logDataEntities.get(0);
|
||||
Assert.assertThat(logData.getLogs().size(), is(4));
|
||||
Assert.assertThat(logData.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
Assert.assertThat(logData.getLogs().get(1).getValue(), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
Assert.assertNull(logData.getLogs().get(2).getValue());
|
||||
assertNotNull(logData.getLogs().get(3).getValue());
|
||||
}
|
||||
|
||||
private void assertRedisSpan(Span span) {
|
||||
private void assertRedisSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("Jedis/set"));
|
||||
assertThat(span.getPeerHost(), is("127.0.0.1"));
|
||||
assertThat(span.getPort(), is(6379));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Redis"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_STATEMENT), is("set OperationKey"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_TYPE), is("Redis"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("db"));
|
||||
}
|
||||
|
||||
private void assertRedisSpan(Span span, String exceptedPeerHosts) {
|
||||
assertThat(span.getOperationName(), is("Jedis/set"));
|
||||
assertThat(span.getPeers(), is(exceptedPeerHosts));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Redis"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_STATEMENT), is("set OperationKey"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_TYPE), is("Redis"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("db"));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
assertThat(span.isExit(), is(true));
|
||||
assertThat(SpanHelper.getComponentId(span), is(7));
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(span);
|
||||
assertThat(tags.get(0).getValue(), is("Redis"));
|
||||
assertThat(tags.get(1).getValue(), is("set OperationKey"));
|
||||
assertThat(SpanHelper.getLayer(span), is(SpanLayer.DB));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,57 +2,68 @@ package org.skywalking.apm.plugin.mongodb.v3;
|
|||
|
||||
import com.mongodb.MongoNamespace;
|
||||
import com.mongodb.operation.FindOperation;
|
||||
import java.util.List;
|
||||
import org.bson.BsonDocument;
|
||||
import org.bson.BsonString;
|
||||
import org.bson.codecs.Decoder;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.hamcrest.MatcherAssert;
|
||||
import org.junit.After;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.*;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class MongoDBMethodInterceptorTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
private MongoDBMethodInterceptor interceptor;
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@SuppressWarnings( {"rawtypes", "unchecked"})
|
||||
private Object[] arguments;
|
||||
private Class[] argumentTypes;
|
||||
|
||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
interceptor = new MongoDBMethodInterceptor();
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
Config.Plugin.MongoDB.TRACE_PARAM = true;
|
||||
|
||||
when(classInstanceContext.get(MongoDBMethodInterceptor.MONGODB_HOST)).thenReturn("127.0.0.1");
|
||||
when(classInstanceContext.get(MongoDBMethodInterceptor.MONGODB_PORT)).thenReturn(27017);
|
||||
when(methodInvokeContext.methodName()).thenReturn("find");
|
||||
when(enhancedInstance.getSkyWalkingDynamicField()).thenReturn("127.0.0.1:27017");
|
||||
|
||||
BsonDocument document = new BsonDocument();
|
||||
document.append("name", new BsonString("by"));
|
||||
|
|
@ -61,64 +72,44 @@ public class MongoDBMethodInterceptorTest {
|
|||
FindOperation findOperation = new FindOperation(mongoNamespace, decoder);
|
||||
findOperation.filter(document);
|
||||
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {findOperation});
|
||||
arguments = new Object[] {findOperation};
|
||||
argumentTypes = new Class[] {findOperation.getClass()};
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntercept() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testIntercept() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null);
|
||||
interceptor.afterMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span);
|
||||
}
|
||||
});
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertRedisSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInterceptWithException() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testInterceptWithException() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null);
|
||||
interceptor.handleMethodException(enhancedInstance, "FindOperation", arguments, argumentTypes, new RuntimeException());
|
||||
interceptor.afterMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
assertLogData(SpanLogReader.getLogs(span).get(0));
|
||||
}
|
||||
});
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertRedisSpan(spans.get(0));
|
||||
List<LogDataEntity> logDataEntities = SpanHelper.getLogs(spans.get(0));
|
||||
assertThat(logDataEntities.size(), is(1));
|
||||
assertException(logDataEntities.get(0), RuntimeException.class);
|
||||
}
|
||||
|
||||
private void assertLogData(LogData logData) {
|
||||
MatcherAssert.assertThat(logData.getFields().size(), is(4));
|
||||
MatcherAssert.assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertEquals(logData.getFields().get("error.kind"), RuntimeException.class.getName());
|
||||
assertNull(logData.getFields().get("message"));
|
||||
}
|
||||
|
||||
private void assertRedisSpan(Span span) {
|
||||
private void assertRedisSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("MongoDB/FindOperation"));
|
||||
assertThat(span.getPeerHost(), is("127.0.0.1"));
|
||||
assertThat(span.getPort(), is(27017));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("MongoDB"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_STATEMENT), is("FindOperation { \"name\" : \"by\" }"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_TYPE), is("MongoDB"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("db"));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
assertThat(SpanHelper.getComponentId(span), is(9));
|
||||
List<KeyValuePair> tags = SpanHelper.getTags(span);
|
||||
assertThat(tags.get(1).getValue(), is("FindOperation { \"name\" : \"by\" }"));
|
||||
assertThat(tags.get(0).getValue(), is("MongoDB"));
|
||||
assertThat(span.isExit(), is(true));
|
||||
assertThat(SpanHelper.getLayer(span), is(SpanLayer.DB));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,58 +0,0 @@
|
|||
package org.skywalking.apm.plugin.mongodb.v3;
|
||||
|
||||
import com.mongodb.ServerAddress;
|
||||
import com.mongodb.binding.ConnectionSource;
|
||||
import com.mongodb.binding.ReadBinding;
|
||||
import com.mongodb.connection.ServerConnectionState;
|
||||
import com.mongodb.connection.ServerDescription;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(PowerMockRunner.class)
|
||||
public class MongoDBReadBindingInterceptorTest {
|
||||
|
||||
private MongoDBReadBindingInterceptor interceptor;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext interceptorContext;
|
||||
|
||||
@Mock
|
||||
private ReadBinding readBinding;
|
||||
|
||||
@Mock
|
||||
private ConnectionSource connectionSource;
|
||||
|
||||
private ServerAddress address = new ServerAddress("127.0.0.1", 27017);
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
interceptor = new MongoDBReadBindingInterceptor();
|
||||
|
||||
ServerDescription serverDescription =
|
||||
ServerDescription.builder().address(address).state(ServerConnectionState.CONNECTED).build();
|
||||
|
||||
PowerMockito.when(connectionSource.getServerDescription()).thenReturn(serverDescription);
|
||||
|
||||
PowerMockito.when(readBinding.getReadConnectionSource()).thenReturn(connectionSource);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterMethodTest() throws Exception {
|
||||
interceptor.afterMethod(instanceContext, interceptorContext, readBinding);
|
||||
verify(instanceContext, times(1)).set(MongoDBMethodInterceptor.MONGODB_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(MongoDBMethodInterceptor.MONGODB_PORT, 27017);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
package org.skywalking.apm.plugin.mongodb.v3;
|
||||
|
||||
import com.mongodb.ServerAddress;
|
||||
import com.mongodb.binding.ConnectionSource;
|
||||
import com.mongodb.binding.WriteBinding;
|
||||
import com.mongodb.connection.ServerConnectionState;
|
||||
import com.mongodb.connection.ServerDescription;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
@RunWith(PowerMockRunner.class)
|
||||
public class MongoDBWriteBindingInterceptorTest {
|
||||
|
||||
private MongoDBWriteBindingInterceptor interceptor;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext interceptorContext;
|
||||
|
||||
@Mock
|
||||
private WriteBinding writeBinding;
|
||||
|
||||
@Mock
|
||||
private ConnectionSource connectionSource;
|
||||
|
||||
private ServerAddress address = new ServerAddress("127.0.0.1", 27017);
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
interceptor = new MongoDBWriteBindingInterceptor();
|
||||
|
||||
ServerDescription serverDescription =
|
||||
ServerDescription.builder().address(address).state(ServerConnectionState.CONNECTED).build();
|
||||
|
||||
PowerMockito.when(connectionSource.getServerDescription()).thenReturn(serverDescription);
|
||||
|
||||
PowerMockito.when(writeBinding.getWriteConnectionSource()).thenReturn(connectionSource);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterMethodTest() throws Exception {
|
||||
interceptor.afterMethod(instanceContext, interceptorContext, writeBinding);
|
||||
verify(instanceContext, times(1)).set(MongoDBMethodInterceptor.MONGODB_HOST, "127.0.0.1");
|
||||
verify(instanceContext, times(1)).set(MongoDBMethodInterceptor.MONGODB_PORT, 27017);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
package org.skywalking.apm.plugin.mongodb.v3;
|
||||
|
||||
import com.mongodb.MongoNamespace;
|
||||
import com.mongodb.WriteConcern;
|
||||
import com.mongodb.bulk.DeleteRequest;
|
||||
import com.mongodb.operation.DeleteOperation;
|
||||
import org.bson.BsonDocument;
|
||||
import org.bson.BsonString;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.hamcrest.MatcherAssert;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.powermock.api.mockito.PowerMockito;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.*;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class MongoDBWriteMethodInterceptorTest {
|
||||
|
||||
private MongoDBMethodInterceptor interceptor;
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
interceptor = new MongoDBMethodInterceptor();
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
|
||||
Config.Plugin.MongoDB.TRACE_PARAM = true;
|
||||
|
||||
when(classInstanceContext.get(MongoDBMethodInterceptor.MONGODB_HOST)).thenReturn("127.0.0.1");
|
||||
when(classInstanceContext.get(MongoDBMethodInterceptor.MONGODB_PORT)).thenReturn(27017);
|
||||
when(methodInvokeContext.methodName()).thenReturn("find");
|
||||
|
||||
BsonDocument document = new BsonDocument();
|
||||
document.append("name", new BsonString("by"));
|
||||
|
||||
List<DeleteRequest> requestList = new ArrayList<DeleteRequest>();
|
||||
|
||||
DeleteRequest deleteRequest = new DeleteRequest(document);
|
||||
|
||||
requestList.add(deleteRequest);
|
||||
|
||||
MongoNamespace mongoNamespace = new MongoNamespace("test.user");
|
||||
|
||||
WriteConcern writeConcern = PowerMockito.mock(WriteConcern.class);
|
||||
|
||||
DeleteOperation deleteOperation = new DeleteOperation(mongoNamespace, false, writeConcern, requestList);
|
||||
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {deleteOperation});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntercept() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private void assertRedisSpan(Span span) {
|
||||
assertThat(span.getOperationName(), is("MongoDB/DeleteOperation"));
|
||||
assertThat(span.getPeerHost(), is("127.0.0.1"));
|
||||
assertThat(span.getPort(), is(27017));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("MongoDB"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_STATEMENT), is("DeleteOperation { \"name\" : \"by\" },"));
|
||||
assertThat(StringTagReader.get(span, Tags.DB_TYPE), is("MongoDB"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("db"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInterceptWithException() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertRedisSpan(span);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
assertLogData(SpanLogReader.getLogs(span).get(0));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private void assertLogData(LogData logData) {
|
||||
MatcherAssert.assertThat(logData.getFields().size(), is(4));
|
||||
MatcherAssert.assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertEquals(logData.getFields().get("error.kind"), RuntimeException.class.getName());
|
||||
assertNull(logData.getFields().get("message"));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(mockTracerContextListener);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -3,134 +3,122 @@ package org.skywalking.apm.plugin.motan;
|
|||
import com.weibo.api.motan.rpc.Request;
|
||||
import com.weibo.api.motan.rpc.Response;
|
||||
import com.weibo.api.motan.rpc.URL;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import java.util.List;
|
||||
import org.hamcrest.MatcherAssert;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.network.trace.component.ComponentsDefine;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.*;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLayer;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertTag;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class MotanConsumerInterceptorTest {
|
||||
|
||||
private MockTracingContextListener contextListener;
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
private MotanConsumerInterceptor invokeInterceptor;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext interceptorContext;
|
||||
@Mock
|
||||
private Response response;
|
||||
@Mock
|
||||
private Request request;
|
||||
|
||||
private URL url;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
contextListener = new MockTracingContextListener();
|
||||
invokeInterceptor = new MotanConsumerInterceptor();
|
||||
url = URL.valueOf("motan://127.0.0.1:34000/org.skywalking.apm.test.TestService");
|
||||
|
||||
TracerContext.ListenerManager.add(contextListener);
|
||||
|
||||
when(instanceContext.get("REQUEST_URL")).thenReturn(url);
|
||||
when(interceptorContext.allArguments()).thenReturn(new Object[] {request});
|
||||
when(enhancedInstance.getSkyWalkingDynamicField()).thenReturn(url);
|
||||
when(request.getMethodName()).thenReturn("test");
|
||||
when(request.getInterfaceName()).thenReturn("org.skywalking.apm.test.TestService");
|
||||
when(request.getParamtersDesc()).thenReturn("java.lang.String, java.lang.Object");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInvokeInterceptor() {
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
public void testInvokeInterceptor() throws Throwable {
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, null);
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, response);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertMotanConsumerSpan(span);
|
||||
verify(request, times(1)).setAttachment(anyString(), anyString());
|
||||
}
|
||||
});
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertMotanConsumerSpan(spans.get(0));
|
||||
verify(request, times(1)).setAttachment(anyString(), anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponseWithException() {
|
||||
public void testResponseWithException() throws Throwable {
|
||||
when(response.getException()).thenReturn(new RuntimeException());
|
||||
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, null);
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, response);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
assertTraceSegmentWhenOccurException();
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertTraceSegmentWhenOccurException(spans.get(0));
|
||||
}
|
||||
|
||||
private void assertTraceSegmentWhenOccurException() {
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertMotanConsumerSpan(span);
|
||||
verify(request, times(1)).setAttachment(anyString(), anyString());
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
LogData logData = SpanLogReader.getLogs(span).get(0);
|
||||
assertLogData(logData);
|
||||
}
|
||||
});
|
||||
private void assertTraceSegmentWhenOccurException(AbstractTracingSpan tracingSpan) {
|
||||
assertMotanConsumerSpan(tracingSpan);
|
||||
verify(request, times(1)).setAttachment(anyString(), anyString());
|
||||
List<LogDataEntity> logDataEntities = SpanHelper.getLogs(tracingSpan);
|
||||
assertThat(logDataEntities.size(), is(1));
|
||||
assertException(logDataEntities.get(0), RuntimeException.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInvokeInterceptorWithException() {
|
||||
public void testInvokeInterceptorWithException() throws Throwable {
|
||||
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.handleMethodException(new RuntimeException(), instanceContext, interceptorContext);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, null);
|
||||
invokeInterceptor.handleMethodException(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, new RuntimeException());
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, response);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
assertTraceSegmentWhenOccurException();
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertTraceSegmentWhenOccurException(spans.get(0));
|
||||
}
|
||||
|
||||
private void assertLogData(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
MatcherAssert.assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
MatcherAssert.assertThat(logData.getFields().get("error.kind"), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getFields().get("message"));
|
||||
}
|
||||
|
||||
private void assertMotanConsumerSpan(Span span) {
|
||||
private void assertMotanConsumerSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("org.skywalking.apm.test.TestService.test(java.lang.String, java.lang.Object)"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Motan"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_CLIENT));
|
||||
assertThat(span.getPeerHost(), is("127.0.0.1"));
|
||||
assertThat(span.getPort(), is(34000));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("rpc"));
|
||||
assertThat(StringTagReader.get(span, Tags.URL), is("motan://127.0.0.1:34000/default_rpc/org.skywalking.apm.test.TestService/1.0/service"));
|
||||
assertComponent(span, ComponentsDefine.MOTAN);
|
||||
assertLayer(span, SpanLayer.RPC_FRAMEWORK);
|
||||
assertTag(span, 0, "motan://127.0.0.1:34000/default_rpc/org.skywalking.apm.test.TestService/1.0/service");
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() {
|
||||
TracerContext.ListenerManager.remove(contextListener);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,162 +3,148 @@ package org.skywalking.apm.plugin.motan;
|
|||
import com.weibo.api.motan.rpc.Request;
|
||||
import com.weibo.api.motan.rpc.Response;
|
||||
import com.weibo.api.motan.rpc.URL;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import org.hamcrest.MatcherAssert;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
|
||||
import java.util.HashMap;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentRefHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.network.trace.component.ComponentsDefine;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.*;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLayer;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLogSize;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class MotanProviderInterceptorTest {
|
||||
|
||||
private MockTracingContextListener contextListener;
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
private MotanProviderInterceptor invokeInterceptor;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext instanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext interceptorContext;
|
||||
@Mock
|
||||
private ConstructorInvokeContext constructorInvokeContext;
|
||||
@Mock
|
||||
private Response response;
|
||||
@Mock
|
||||
private Request request;
|
||||
|
||||
private URL url;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
private Object[] arguments;
|
||||
private Class[] argumentType;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
invokeInterceptor = new MotanProviderInterceptor();
|
||||
contextListener = new MockTracingContextListener();
|
||||
url = URL.valueOf("motan://127.0.0.1:34000/org.skywalking.apm.test.TestService");
|
||||
|
||||
TracerContext.ListenerManager.add(contextListener);
|
||||
|
||||
when(instanceContext.get("REQUEST_URL")).thenReturn(url);
|
||||
when(interceptorContext.allArguments()).thenReturn(new Object[] {request});
|
||||
when(enhancedInstance.getSkyWalkingDynamicField()).thenReturn(url);
|
||||
arguments = new Object[] {request};
|
||||
argumentType = new Class[] {request.getClass()};
|
||||
when(request.getMethodName()).thenReturn("test");
|
||||
when(request.getInterfaceName()).thenReturn("org.skywalking.apm.test.TestService");
|
||||
when(request.getParamtersDesc()).thenReturn("java.lang.String, java.lang.Object");
|
||||
when(constructorInvokeContext.allArguments()).thenReturn(new Object[] {url});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInvokerWithoutRefSegment() {
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
public void testInvokerWithoutRefSegment() throws Throwable {
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null);
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response);
|
||||
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertMotanProviderSpan(spans.get(0));
|
||||
assertTrue(traceSegment.getRefs() == null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertMotanProviderSpan(span);
|
||||
assertTrue(traceSegment.getRefs() == null);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInvokerWithRefSegment() {
|
||||
public void testInvokerWithRefSegment() throws Throwable {
|
||||
HashMap attachments = new HashMap();
|
||||
attachments.put(Config.Plugin.Propagation.HEADER_NAME, "302017.1487666919810.624424584.17332.1.1|1|REMOTE_APP|127.0.0.1|Trace.globalId.123");
|
||||
attachments.put(Config.Plugin.Propagation.HEADER_NAME, "S.1499176688384.581928182.80935.69.1|3|1|#192.168.1.8:18002|#/portal/|T.1499176688386.581928182.80935.69.2");
|
||||
when(request.getAttachments()).thenReturn(attachments);
|
||||
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null);
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertMotanProviderSpan(span);
|
||||
assertRefSegment(traceSegment.getRefs().get(0));
|
||||
}
|
||||
});
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertMotanProviderSpan(spans.get(0));
|
||||
assertRefSegment(traceSegment.getRefs().get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testResponseWithException() {
|
||||
public void testResponseWithException() throws Throwable {
|
||||
when(response.getException()).thenReturn(new RuntimeException());
|
||||
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null);
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response);
|
||||
|
||||
assertTraceSegmentWhenOccurException();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOccurException() {
|
||||
public void testOccurException() throws Throwable {
|
||||
|
||||
invokeInterceptor.beforeMethod(instanceContext, interceptorContext, null);
|
||||
invokeInterceptor.handleMethodException(new RuntimeException(), instanceContext, interceptorContext);
|
||||
invokeInterceptor.afterMethod(instanceContext, interceptorContext, response);
|
||||
invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null);
|
||||
invokeInterceptor.handleMethodException(enhancedInstance, "execute", arguments, argumentType, new RuntimeException());
|
||||
invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response);
|
||||
|
||||
assertTraceSegmentWhenOccurException();
|
||||
}
|
||||
|
||||
private void assertTraceSegmentWhenOccurException() {
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertMotanProviderSpan(span);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
LogData logData = SpanLogReader.getLogs(span).get(0);
|
||||
assertLogData(logData);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private void assertLogData(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
MatcherAssert.assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
MatcherAssert.assertThat(logData.getFields().get("error.kind"), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getFields().get("message"));
|
||||
MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertMotanProviderSpan(spans.get(0));
|
||||
assertLogSize(spans.get(0), 1);
|
||||
List<LogDataEntity> logDataEntities = SpanHelper.getLogs(spans.get(0));
|
||||
assertException(logDataEntities.get(0), RuntimeException.class);
|
||||
}
|
||||
|
||||
private void assertRefSegment(TraceSegmentRef primaryRef) {
|
||||
assertThat(primaryRef.getTraceSegmentId(), is("302017.1487666919810.624424584.17332.1.1"));
|
||||
assertThat(primaryRef.getSpanId(), is(1));
|
||||
assertThat(primaryRef.getPeerHost(), is("127.0.0.1"));
|
||||
assertThat(SegmentRefHelper.getTraceSegmentId(primaryRef), is("S.1499176688384.581928182.80935.69.1"));
|
||||
assertThat(SegmentRefHelper.getSpanId(primaryRef), is(3));
|
||||
assertThat(SegmentRefHelper.getPeerHost(primaryRef), is("192.168.1.8:18002"));
|
||||
}
|
||||
|
||||
private void assertMotanProviderSpan(Span span) {
|
||||
private void assertMotanProviderSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("org.skywalking.apm.test.TestService.test(java.lang.String, java.lang.Object)"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Motan"));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_SERVER));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("rpc"));
|
||||
assertComponent(span, ComponentsDefine.MOTAN);
|
||||
assertThat(span.isEntry(), is(true));
|
||||
assertLayer(span, SpanLayer.RPC_FRAMEWORK);
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() {
|
||||
TracerContext.ListenerManager.remove(contextListener);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,10 +52,10 @@ public class RealCallInterceptor implements InstanceMethodsAroundInterceptor, In
|
|||
|
||||
ContextCarrier contextCarrier = new ContextCarrier();
|
||||
HttpUrl requestUrl = request.url();
|
||||
AbstractSpan span = ContextManager.createExitSpan(requestUrl.uri().toString(), contextCarrier, requestUrl.host() + ":" + requestUrl.port());
|
||||
AbstractSpan span = ContextManager.createExitSpan(requestUrl.uri().getPath(), contextCarrier, requestUrl.host() + ":" + requestUrl.port());
|
||||
span.setComponent(ComponentsDefine.OKHTTP);
|
||||
Tags.HTTP.METHOD.set(span, request.method());
|
||||
Tags.URL.set(span, requestUrl.url().getPath());
|
||||
Tags.URL.set(span, requestUrl.uri().toString());
|
||||
SpanLayer.asHttp(span);
|
||||
|
||||
Field headersField = Request.class.getDeclaredField("headers");
|
||||
|
|
@ -96,6 +96,8 @@ public class RealCallInterceptor implements InstanceMethodsAroundInterceptor, In
|
|||
|
||||
@Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
|
||||
Class<?>[] argumentsTypes, Throwable t) {
|
||||
|
||||
AbstractSpan abstractSpan = ContextManager.activeSpan();
|
||||
abstractSpan.errorOccurred();
|
||||
abstractSpan.log(t);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,141 +1,156 @@
|
|||
package org.skywalking.apm.plugin.okhttp.v3;
|
||||
|
||||
import java.util.List;
|
||||
import okhttp3.OkHttpClient;
|
||||
import okhttp3.Request;
|
||||
import okhttp3.Response;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.powermock.core.classloader.annotations.PrepareForTest;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.BooleanTagReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.network.trace.component.ComponentsDefine;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLayer;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLogSize;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertOccurException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertTag;
|
||||
|
||||
/**
|
||||
* @author pengys5
|
||||
*/
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
@PrepareForTest({Response.class})
|
||||
public class RealCallInterceptorTest {
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
private RealCallInterceptor realCallInterceptor;
|
||||
private MockTracingContextListener mockTracerContextListener;
|
||||
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
|
||||
@Mock
|
||||
private ConstructorInvokeContext constructorInvokeContext;
|
||||
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext instanceMethodInvokeContext;
|
||||
|
||||
@Mock
|
||||
private OkHttpClient client;
|
||||
|
||||
private Request request;
|
||||
|
||||
private Object[] allArguments;
|
||||
private Class[] argumentTypes;
|
||||
|
||||
private EnhancedInstance enhancedInstance = new EnhancedInstance() {
|
||||
|
||||
private Object object;
|
||||
|
||||
@Override
|
||||
public Object getSkyWalkingDynamicField() {
|
||||
return object;
|
||||
}
|
||||
|
||||
@Override public void setSkyWalkingDynamicField(Object value) {
|
||||
this.object = value;
|
||||
}
|
||||
};
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
mockTracerContextListener = new MockTracingContextListener();
|
||||
|
||||
classInstanceContext = new EnhancedClassInstanceContext();
|
||||
|
||||
request = new Request.Builder().url("http://skywalking.org").build();
|
||||
Object[] allArguments = {client, request, false};
|
||||
when(constructorInvokeContext.allArguments()).thenReturn(allArguments);
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
allArguments = new Object[] {client, request, false};
|
||||
argumentTypes = new Class[] {client.getClass(), request.getClass(), Boolean.class};
|
||||
realCallInterceptor = new RealCallInterceptor();
|
||||
|
||||
TracerContext.ListenerManager.add(mockTracerContextListener);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOnConstruct() {
|
||||
realCallInterceptor.onConstruct(classInstanceContext, constructorInvokeContext);
|
||||
Assert.assertEquals(request, classInstanceContext.get("SWRequestContextKey"));
|
||||
realCallInterceptor.onConstruct(enhancedInstance, allArguments);
|
||||
assertThat(enhancedInstance.getSkyWalkingDynamicField(), is(allArguments[1]));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMethodsAround() throws Throwable {
|
||||
realCallInterceptor.onConstruct(classInstanceContext, constructorInvokeContext);
|
||||
realCallInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
realCallInterceptor.onConstruct(enhancedInstance, allArguments);
|
||||
realCallInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, null);
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.code()).thenReturn(200);
|
||||
realCallInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, response);
|
||||
realCallInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override public void call(TraceSegment finishedSegment) {
|
||||
Assert.assertEquals(1, finishedSegment.getSpans().size());
|
||||
assertSpan(finishedSegment.getSpans().get(0));
|
||||
Assert.assertEquals(false, BooleanTagReader.get(finishedSegment.getSpans().get(0), Tags.ERROR));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertSpan(spans.get(0));
|
||||
assertOccurException(spans.get(0), false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMethodsAroundError() throws Throwable {
|
||||
realCallInterceptor.onConstruct(classInstanceContext, constructorInvokeContext);
|
||||
realCallInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
realCallInterceptor.onConstruct(enhancedInstance, allArguments);
|
||||
realCallInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, null);
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.code()).thenReturn(404);
|
||||
realCallInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, response);
|
||||
realCallInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override public void call(TraceSegment finishedSegment) {
|
||||
Assert.assertEquals(1, finishedSegment.getSpans().size());
|
||||
assertSpan(finishedSegment.getSpans().get(0));
|
||||
Assert.assertEquals(true, BooleanTagReader.get(finishedSegment.getSpans().get(0), Tags.ERROR));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertSpan(spans.get(0));
|
||||
assertOccurException(spans.get(0), true);
|
||||
}
|
||||
|
||||
private void assertSpan(Span span) {
|
||||
Assert.assertEquals("http", StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG));
|
||||
Assert.assertEquals("GET", StringTagReader.get(span, Tags.HTTP.METHOD));
|
||||
Assert.assertEquals("skywalking.org", span.getPeerHost());
|
||||
Assert.assertEquals(80, span.getPort());
|
||||
Assert.assertEquals("OKHttp", StringTagReader.get(span, Tags.COMPONENT));
|
||||
Assert.assertEquals("discovery", StringTagReader.get(span, Tags.SPAN_KIND));
|
||||
Assert.assertEquals("/", StringTagReader.get(span, Tags.URL));
|
||||
private void assertSpan(AbstractTracingSpan span) {
|
||||
assertComponent(span, ComponentsDefine.OKHTTP);
|
||||
assertLayer(span, SpanLayer.HTTP);
|
||||
assertTag(span, 0, "GET");
|
||||
assertTag(span, 1, "http://skywalking.org/");
|
||||
assertThat(span.isExit(), is(true));
|
||||
assertThat(span.getOperationName(), is("/"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testException() throws Throwable {
|
||||
realCallInterceptor.onConstruct(classInstanceContext, constructorInvokeContext);
|
||||
realCallInterceptor.beforeMethod(classInstanceContext, instanceMethodInvokeContext, null);
|
||||
realCallInterceptor.onConstruct(enhancedInstance, allArguments);
|
||||
realCallInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, null);
|
||||
|
||||
realCallInterceptor.handleMethodException(new NullPointerException("testException"), classInstanceContext, null);
|
||||
realCallInterceptor.handleMethodException(enhancedInstance, "execute", allArguments, argumentTypes, new NullPointerException("testException"));
|
||||
|
||||
Response response = mock(Response.class);
|
||||
when(response.code()).thenReturn(200);
|
||||
realCallInterceptor.afterMethod(classInstanceContext, instanceMethodInvokeContext, response);
|
||||
realCallInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response);
|
||||
|
||||
mockTracerContextListener.assertSize(1);
|
||||
mockTracerContextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override public void call(TraceSegment finishedSegment) {
|
||||
Assert.assertEquals(1, finishedSegment.getSpans().size());
|
||||
assertSpan(finishedSegment.getSpans().get(0));
|
||||
Assert.assertEquals(true, BooleanTagReader.get(finishedSegment.getSpans().get(0), Tags.ERROR));
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
Assert.assertEquals(1, SpanLogReader.getLogs(finishedSegment.getSpans().get(0)).size());
|
||||
Assert.assertEquals(true, SpanLogReader.getLogs(finishedSegment.getSpans().get(0)).get(0).getFields().containsKey("stack"));
|
||||
}
|
||||
});
|
||||
assertSpan(spans.get(0));
|
||||
assertOccurException(spans.get(0), true);
|
||||
assertLogSize(spans.get(0), 1);
|
||||
assertException(SpanHelper.getLogs(spans.get(0)).get(0), NullPointerException.class, "testException");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,6 +38,12 @@
|
|||
<artifactId>apm-agent-core</artifactId>
|
||||
<version>${project.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.skywalking</groupId>
|
||||
<artifactId>apm-test-tools</artifactId>
|
||||
<version>${project.version}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
|
|
|
|||
|
|
@ -2,148 +2,134 @@ package org.skywalking.apm.plugin.resin.v3;
|
|||
|
||||
import com.caucho.server.connection.CauchoRequest;
|
||||
import com.caucho.server.http.HttpResponse;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import java.util.List;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.IntTagReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentRefHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.network.trace.component.ComponentsDefine;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLayer;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertTag;
|
||||
|
||||
/**
|
||||
* ResinInterceptorTest
|
||||
*
|
||||
* @author baiyang
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class ResinV3InterceptorTest {
|
||||
private ResinV3Interceptor interceptor;
|
||||
private MockTracingContextListener contextListener;
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private CauchoRequest request;
|
||||
@Mock
|
||||
private HttpResponse response;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
@Mock
|
||||
private MethodInterceptResult methodInterceptResult;
|
||||
|
||||
private Object[] arguments;
|
||||
private Class[] argumentType;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
interceptor = new ResinV3Interceptor();
|
||||
contextListener = new MockTracingContextListener();
|
||||
|
||||
TracerContext.ListenerManager.add(contextListener);
|
||||
|
||||
when(request.getPageURI()).thenReturn("/test/testRequestURL");
|
||||
when(request.getScheme()).thenReturn("http");
|
||||
when(request.getServerName()).thenReturn("localhost");
|
||||
when(request.getServerPort()).thenReturn(8080);
|
||||
when(request.getRequestURL()).thenReturn(new StringBuffer("http://localhost:8080/test/testRequestURL"));
|
||||
when(response.getStatusCode()).thenReturn(200);
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {request, response});
|
||||
arguments = new Object[] {request, response};
|
||||
argumentType = new Class[] {request.getClass(), response.getClass()};
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithoutSerializedContextData() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testWithoutSerializedContextData() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult);
|
||||
interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertHttpSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithSerializedContextData() {
|
||||
when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("302017.1487666919810.624424584.17332.1.1|1|REMOTE_APP|127.0.0.1|Trace.globalId.123");
|
||||
public void testWithSerializedContextData() throws Throwable {
|
||||
when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("S.1499176688384.581928182.80935.69.1|3|1|#192.168.1.8:18002|#/portal/|T.1499176688386.581928182.80935.69.2");
|
||||
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult);
|
||||
interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertHttpSpan(spans.get(0));
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithOccurException() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
interceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testWithOccurException() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult);
|
||||
interceptor.handleMethodException(enhancedInstance, "service", arguments, argumentType, new RuntimeException());
|
||||
interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
assertSpanLog(SpanLogReader.getLogs(span).get(0));
|
||||
}
|
||||
});
|
||||
}
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
private void assertSpanLog(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertThat(logData.getFields().get("error.kind"), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getFields().get("message"));
|
||||
assertHttpSpan(spans.get(0));
|
||||
List<LogDataEntity> logDataEntities = SpanHelper.getLogs(spans.get(0));
|
||||
assertThat(logDataEntities.size(), is(1));
|
||||
assertException(logDataEntities.get(0), RuntimeException.class);
|
||||
}
|
||||
|
||||
private void assertTraceSegmentRef(TraceSegmentRef ref) {
|
||||
assertThat(ref.getSpanId(), is(1));
|
||||
assertThat(ref.getTraceSegmentId(), is("302017.1487666919810.624424584.17332.1.1"));
|
||||
assertThat(SegmentRefHelper.getSpanId(ref), is(3));
|
||||
assertThat(SegmentRefHelper.getTraceSegmentId(ref), is("S.1499176688384.581928182.80935.69.1"));
|
||||
}
|
||||
|
||||
private void assertHttpSpan(Span span) {
|
||||
private void assertHttpSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("/test/testRequestURL"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Resin"));
|
||||
assertThat(StringTagReader.get(span, Tags.URL), is("http://localhost:8080/test/testRequestURL"));
|
||||
assertThat(IntTagReader.get(span, Tags.STATUS_CODE), is(200));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_SERVER));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("http"));
|
||||
assertComponent(span, ComponentsDefine.RESIN);
|
||||
assertTag(span, 0, "http://localhost:8080/test/testRequestURL");
|
||||
assertThat(span.isEntry(), is(true));
|
||||
assertLayer(span, SpanLayer.HTTP);
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(new MockTracingContextListener());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,60 +1,71 @@
|
|||
package org.skywalking.apm.plugin.resin.v4;
|
||||
|
||||
import com.caucho.server.http.CauchoRequest;
|
||||
import java.util.List;
|
||||
import javax.servlet.http.HttpServletResponse;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.IntTagReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentRefHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.network.trace.component.ComponentsDefine;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLayer;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertTag;
|
||||
|
||||
/**
|
||||
* Created by Baiyang on 2017/5/6.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class ResinV4InterceptorTest {
|
||||
private ResinV4Interceptor interceptor;
|
||||
private MockTracingContextListener contextListener;
|
||||
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private CauchoRequest request;
|
||||
@Mock
|
||||
private HttpServletResponse response;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
@Mock
|
||||
private MethodInterceptResult methodInterceptResult;
|
||||
|
||||
private Object[] arguments;
|
||||
private Class[] argumentType;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
interceptor = new ResinV4Interceptor();
|
||||
contextListener = new MockTracingContextListener();
|
||||
|
||||
TracerContext.ListenerManager.add(contextListener);
|
||||
|
||||
when(request.getPageURI()).thenReturn("/test/testRequestURL");
|
||||
when(request.getScheme()).thenReturn("http");
|
||||
|
|
@ -63,86 +74,63 @@ public class ResinV4InterceptorTest {
|
|||
when(request.getRequestURI()).thenReturn("/test/testRequestURL");
|
||||
when(request.getRequestURL()).thenReturn(new StringBuffer("http://localhost:8080/test/testRequestURL"));
|
||||
when(response.getStatus()).thenReturn(200);
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {request, response});
|
||||
arguments = new Object[] {request, response};
|
||||
argumentType = new Class[] {request.getClass(), response.getClass()};
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithoutSerializedContextData() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testWithoutSerializedContextData() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult);
|
||||
interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertHttpSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithSerializedContextData() {
|
||||
when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("302017.1487666919810.624424584.17332.1.1|1|REMOTE_APP|127.0.0.1|Trace.globalId.123");
|
||||
public void testWithSerializedContextData() throws Throwable {
|
||||
when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("S.1499176688384.581928182.80935.69.1|3|1|#192.168.1.8:18002|#/portal/|T.1499176688386.581928182.80935.69.2");
|
||||
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult);
|
||||
interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertHttpSpan(spans.get(0));
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithOccurException() {
|
||||
interceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
interceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
interceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testWithOccurException() throws Throwable {
|
||||
interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult);
|
||||
interceptor.handleMethodException(enhancedInstance, "service", arguments, argumentType, new RuntimeException());
|
||||
interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
assertSpanLog(SpanLogReader.getLogs(span).get(0));
|
||||
}
|
||||
});
|
||||
}
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
private void assertSpanLog(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertThat(logData.getFields().get("error.kind"), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getFields().get("message"));
|
||||
assertHttpSpan(spans.get(0));
|
||||
List<LogDataEntity> logDataEntities = SpanHelper.getLogs(spans.get(0));
|
||||
assertThat(logDataEntities.size(), is(1));
|
||||
assertException(logDataEntities.get(0), RuntimeException.class);
|
||||
}
|
||||
|
||||
private void assertTraceSegmentRef(TraceSegmentRef ref) {
|
||||
assertThat(ref.getSpanId(), is(1));
|
||||
assertThat(ref.getTraceSegmentId(), is("302017.1487666919810.624424584.17332.1.1"));
|
||||
assertThat(SegmentRefHelper.getSpanId(ref), is(3));
|
||||
assertThat(SegmentRefHelper.getTraceSegmentId(ref), is("S.1499176688384.581928182.80935.69.1"));
|
||||
}
|
||||
|
||||
private void assertHttpSpan(Span span) {
|
||||
private void assertHttpSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("/test/testRequestURL"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Resin"));
|
||||
assertThat(StringTagReader.get(span, Tags.URL), is("http://localhost:8080/test/testRequestURL"));
|
||||
assertThat(IntTagReader.get(span, Tags.STATUS_CODE), is(200));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_SERVER));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("http"));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(new MockTracingContextListener());
|
||||
assertComponent(span, ComponentsDefine.RESIN);
|
||||
assertTag(span, 0, "http://localhost:8080/test/testRequestURL");
|
||||
assertThat(span.isEntry(), is(true));
|
||||
assertLayer(span, SpanLayer.HTTP);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,141 +1,126 @@
|
|||
package org.skywalking.apm.plugin.tomcat78x;
|
||||
|
||||
import java.util.List;
|
||||
import javax.servlet.http.HttpServletRequest;
|
||||
import javax.servlet.http.HttpServletResponse;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.powermock.modules.junit4.PowerMockRunner;
|
||||
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
|
||||
import org.skywalking.apm.agent.core.conf.Config;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.sniffer.mock.context.MockTracingContextListener;
|
||||
import org.skywalking.apm.sniffer.mock.context.SegmentAssert;
|
||||
import org.skywalking.apm.sniffer.mock.trace.SpanLogReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.IntTagReader;
|
||||
import org.skywalking.apm.sniffer.mock.trace.tags.StringTagReader;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
import org.skywalking.apm.agent.core.context.tag.Tags;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
|
||||
import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SegmentRefHelper;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.agent.test.tools.AgentServiceRule;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStorage;
|
||||
import org.skywalking.apm.agent.test.tools.SegmentStoragePoint;
|
||||
import org.skywalking.apm.agent.test.tools.TracingSegmentRunner;
|
||||
import org.skywalking.apm.network.trace.component.ComponentsDefine;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertException;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLayer;
|
||||
import static org.skywalking.apm.agent.test.tools.SpanAssert.assertTag;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
@RunWith(PowerMockRunner.class)
|
||||
@PowerMockRunnerDelegate(TracingSegmentRunner.class)
|
||||
public class TomcatInterceptorTest {
|
||||
|
||||
private TomcatInterceptor tomcatInterceptor;
|
||||
private MockTracingContextListener contextListener;
|
||||
@SegmentStoragePoint
|
||||
private SegmentStorage segmentStorage;
|
||||
|
||||
@Rule
|
||||
public AgentServiceRule serviceRule = new AgentServiceRule();
|
||||
|
||||
@Mock
|
||||
private HttpServletRequest request;
|
||||
@Mock
|
||||
private HttpServletResponse response;
|
||||
@Mock
|
||||
private EnhancedClassInstanceContext classInstanceContext;
|
||||
@Mock
|
||||
private InstanceMethodInvokeContext methodInvokeContext;
|
||||
@Mock
|
||||
private MethodInterceptResult methodInterceptResult;
|
||||
|
||||
@Mock
|
||||
private EnhancedInstance enhancedInstance;
|
||||
|
||||
private Object[] arguments;
|
||||
private Class[] argumentType;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
|
||||
ServiceManager.INSTANCE.boot();
|
||||
|
||||
tomcatInterceptor = new TomcatInterceptor();
|
||||
contextListener = new MockTracingContextListener();
|
||||
|
||||
TracerContext.ListenerManager.add(contextListener);
|
||||
|
||||
when(request.getRequestURI()).thenReturn("/test/testRequestURL");
|
||||
when(request.getRequestURL()).thenReturn(new StringBuffer("http://localhost:8080/test/testRequestURL"));
|
||||
when(response.getStatus()).thenReturn(200);
|
||||
when(methodInvokeContext.allArguments()).thenReturn(new Object[] {request, response});
|
||||
arguments = new Object[] {request, response};
|
||||
argumentType = new Class[] {request.getClass(), response.getClass()};
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithoutSerializedContextData() {
|
||||
tomcatInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
tomcatInterceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testWithoutSerializedContextData() throws Throwable {
|
||||
tomcatInterceptor.beforeMethod(enhancedInstance, "invoke", arguments, argumentType, methodInterceptResult);
|
||||
tomcatInterceptor.afterMethod(enhancedInstance, "invoke", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
assertHttpSpan(spans.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithSerializedContextData() {
|
||||
when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("302017.1487666919810.624424584.17332.1.1|1|REMOTE_APP|127.0.0.1|Trace.globalId.123");
|
||||
public void testWithSerializedContextData() throws Throwable {
|
||||
when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("S.1499176688384.581928182.80935.69.1|3|1|#192.168.1.8:18002|#/portal/|T.1499176688386.581928182.80935.69.2");
|
||||
|
||||
tomcatInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
tomcatInterceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
tomcatInterceptor.beforeMethod(enhancedInstance, "invoke", arguments, argumentType, methodInterceptResult);
|
||||
tomcatInterceptor.afterMethod(enhancedInstance, "invoke", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
});
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
assertHttpSpan(spans.get(0));
|
||||
assertTraceSegmentRef(traceSegment.getRefs().get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithOccurException() {
|
||||
tomcatInterceptor.beforeMethod(classInstanceContext, methodInvokeContext, methodInterceptResult);
|
||||
tomcatInterceptor.handleMethodException(new RuntimeException(), classInstanceContext, methodInvokeContext);
|
||||
tomcatInterceptor.afterMethod(classInstanceContext, methodInvokeContext, null);
|
||||
public void testWithOccurException() throws Throwable {
|
||||
tomcatInterceptor.beforeMethod(enhancedInstance, "invoke", arguments, argumentType, methodInterceptResult);
|
||||
tomcatInterceptor.handleMethodException(enhancedInstance, "invoke", arguments, argumentType, new RuntimeException());
|
||||
tomcatInterceptor.afterMethod(enhancedInstance, "invoke", arguments, argumentType, null);
|
||||
|
||||
contextListener.assertSize(1);
|
||||
contextListener.assertTraceSegment(0, new SegmentAssert() {
|
||||
@Override
|
||||
public void call(TraceSegment traceSegment) {
|
||||
assertThat(traceSegment.getSpans().size(), is(1));
|
||||
Span span = traceSegment.getSpans().get(0);
|
||||
assertHttpSpan(span);
|
||||
assertThat(SpanLogReader.getLogs(span).size(), is(1));
|
||||
assertSpanLog(SpanLogReader.getLogs(span).get(0));
|
||||
}
|
||||
});
|
||||
}
|
||||
assertThat(segmentStorage.getTraceSegments().size(), is(1));
|
||||
TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0);
|
||||
List<AbstractTracingSpan> spans = SegmentHelper.getSpans(traceSegment);
|
||||
|
||||
private void assertSpanLog(LogData logData) {
|
||||
assertThat(logData.getFields().size(), is(4));
|
||||
assertThat(logData.getFields().get("event"), CoreMatchers.<Object>is("error"));
|
||||
assertThat(logData.getFields().get("error.kind"), CoreMatchers.<Object>is(RuntimeException.class.getName()));
|
||||
assertNull(logData.getFields().get("message"));
|
||||
assertHttpSpan(spans.get(0));
|
||||
List<LogDataEntity> logDataEntities = SpanHelper.getLogs(spans.get(0));
|
||||
assertThat(logDataEntities.size(), is(1));
|
||||
assertException(logDataEntities.get(0), RuntimeException.class);
|
||||
}
|
||||
|
||||
private void assertTraceSegmentRef(TraceSegmentRef ref) {
|
||||
assertThat(ref.getSpanId(), is(1));
|
||||
assertThat(ref.getTraceSegmentId(), is("302017.1487666919810.624424584.17332.1.1"));
|
||||
assertThat(SegmentRefHelper.getSpanId(ref), is(3));
|
||||
assertThat(SegmentRefHelper.getTraceSegmentId(ref), is("S.1499176688384.581928182.80935.69.1"));
|
||||
}
|
||||
|
||||
private void assertHttpSpan(Span span) {
|
||||
private void assertHttpSpan(AbstractTracingSpan span) {
|
||||
assertThat(span.getOperationName(), is("/test/testRequestURL"));
|
||||
assertThat(StringTagReader.get(span, Tags.COMPONENT), is("Tomcat"));
|
||||
assertThat(StringTagReader.get(span, Tags.URL), is("http://localhost:8080/test/testRequestURL"));
|
||||
assertThat(IntTagReader.get(span, Tags.STATUS_CODE), is(200));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_KIND), is(Tags.SPAN_KIND_SERVER));
|
||||
assertThat(StringTagReader.get(span, Tags.SPAN_LAYER.SPAN_LAYER_TAG), is("http"));
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() throws Exception {
|
||||
TracerContext.ListenerManager.remove(new MockTracingContextListener());
|
||||
assertComponent(span, ComponentsDefine.TOMCAT);
|
||||
assertTag(span, 0, "http://localhost:8080/test/testRequestURL");
|
||||
assertThat(span.isEntry(), is(true));
|
||||
assertLayer(span, SpanLayer.HTTP);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,26 +0,0 @@
|
|||
package org.skywalking.apm.agent.test.helper;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
|
||||
public class AbstractTracingSpanHelper {
|
||||
public static int getParentSpanId(AbstractTracingSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "parentSpanId");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return -9999;
|
||||
}
|
||||
|
||||
public static List<LogDataEntity> getLogs(AbstractTracingSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "logs");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return Collections.emptyList();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
package org.skywalking.apm.agent.test.helper;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
|
||||
/**
|
||||
* Created by xin on 2017/7/9.
|
||||
*/
|
||||
public class FieldSetter {
|
||||
|
||||
public static <T> void setValue(Object instance,
|
||||
String fieldName, T value) throws IllegalAccessException, NoSuchFieldException {
|
||||
Field field = instance.getClass().getDeclaredField(fieldName);
|
||||
field.setAccessible(true);
|
||||
field.set(instance, value);
|
||||
}
|
||||
|
||||
public static <T> void setStaticValue(Class instance,
|
||||
String fieldName, T value) throws IllegalAccessException, NoSuchFieldException {
|
||||
Field field = instance.getDeclaredField(fieldName);
|
||||
field.setAccessible(true);
|
||||
field.set(instance, value);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -6,7 +6,7 @@ import org.skywalking.apm.agent.core.context.trace.TraceSegment;
|
|||
|
||||
public class SegmentHelper {
|
||||
|
||||
public static List<AbstractTracingSpan> getSpan(TraceSegment traceSegment) {
|
||||
public static List<AbstractTracingSpan> getSpans(TraceSegment traceSegment) {
|
||||
try {
|
||||
return FieldGetter.getValue(traceSegment, "spans");
|
||||
} catch (Exception e) {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,32 @@
|
|||
package org.skywalking.apm.agent.test.helper;
|
||||
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
|
||||
public class SegmentRefHelper {
|
||||
public static String getPeerHost(TraceSegmentRef ref) {
|
||||
try {
|
||||
return FieldGetter.getValue(ref, "peerHost");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static String getTraceSegmentId(TraceSegmentRef ref) {
|
||||
try {
|
||||
return FieldGetter.getValue(ref, "traceSegmentId");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static int getSpanId(TraceSegmentRef ref) {
|
||||
try {
|
||||
return FieldGetter.getValue(ref, "spanId");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
package org.skywalking.apm.agent.test.helper;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.core.context.util.KeyValuePair;
|
||||
|
||||
public class SpanHelper {
|
||||
public static int getParentSpanId(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "parentSpanId");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return -9999;
|
||||
}
|
||||
|
||||
public static List<LogDataEntity> getLogs(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "logs");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
public static List<KeyValuePair> getTags(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "tags");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
public static SpanLayer getLayer(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "layer");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static String getComponentName(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "componentName");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public static int getComponentId(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "componentId");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
public static boolean getErrorOccurred(AbstractSpan tracingSpan) {
|
||||
try {
|
||||
return FieldGetter.getParentFieldValue(tracingSpan, "errorOccurred");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package org.skywalking.apm.agent.test.helper;
|
||||
|
||||
import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
|
||||
|
||||
public class TraceSegmentRefHelper {
|
||||
public static String getPeerHost(TraceSegmentRef ref) {
|
||||
try {
|
||||
return FieldGetter.getValue(ref, "peerHost");
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
package org.skywalking.apm.agent.test.tools;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedList;
|
||||
import org.junit.rules.ExternalResource;
|
||||
import org.skywalking.apm.agent.core.boot.BootService;
|
||||
import org.skywalking.apm.agent.core.boot.ServiceManager;
|
||||
import org.skywalking.apm.agent.core.conf.RemoteDownstreamConfig;
|
||||
import org.skywalking.apm.agent.core.context.IgnoredTracerContext;
|
||||
import org.skywalking.apm.agent.core.context.TracingContext;
|
||||
import org.skywalking.apm.agent.core.context.TracingContextListener;
|
||||
import org.skywalking.apm.agent.test.helper.FieldSetter;
|
||||
|
||||
public class AgentServiceRule extends ExternalResource {
|
||||
|
||||
@Override
|
||||
protected void after() {
|
||||
super.after();
|
||||
try {
|
||||
FieldSetter.setValue(ServiceManager.INSTANCE.getClass(), "bootedServices", new HashMap<Class, BootService>());
|
||||
FieldSetter.setValue(IgnoredTracerContext.ListenerManager.class, "LISTENERS", new LinkedList<TracingContextListener>());
|
||||
FieldSetter.setValue(TracingContext.ListenerManager.class, "LISTENERS", new LinkedList<TracingContextListener>());
|
||||
} catch (Exception e) {
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void before() throws Throwable {
|
||||
super.before();
|
||||
ServiceManager.INSTANCE.boot();
|
||||
RemoteDownstreamConfig.Agent.APPLICATION_ID = 1;
|
||||
RemoteDownstreamConfig.Agent.APPLICATION_INSTANCE_ID = 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -9,7 +9,7 @@ public class SegmentStorage {
|
|||
private LinkedList<TraceSegment> traceSegments;
|
||||
private LinkedList<IgnoredTracerContext> ignoredTracerContexts;
|
||||
|
||||
SegmentStorage() {
|
||||
public SegmentStorage() {
|
||||
traceSegments = new LinkedList<TraceSegment>();
|
||||
ignoredTracerContexts = new LinkedList<IgnoredTracerContext>();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,53 @@
|
|||
package org.skywalking.apm.agent.test.tools;
|
||||
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Assert;
|
||||
import org.skywalking.apm.agent.core.context.trace.AbstractSpan;
|
||||
import org.skywalking.apm.agent.core.context.trace.LogDataEntity;
|
||||
import org.skywalking.apm.agent.core.context.trace.SpanLayer;
|
||||
import org.skywalking.apm.agent.test.helper.SpanHelper;
|
||||
import org.skywalking.apm.network.trace.component.Component;
|
||||
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static org.hamcrest.CoreMatchers.is;
|
||||
import static org.junit.Assert.assertThat;
|
||||
|
||||
public class SpanAssert {
|
||||
public static void assertLogSize(AbstractSpan span, int exceptedSize) {
|
||||
assertThat(SpanHelper.getLogs(span).size(), is(exceptedSize));
|
||||
}
|
||||
|
||||
public static void assertException(LogDataEntity logDataEntity, Class<? extends Throwable> throwableClass,
|
||||
String message) {
|
||||
Assert.assertThat(logDataEntity.getLogs().size(), is(4));
|
||||
Assert.assertThat(logDataEntity.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
Assert.assertThat(logDataEntity.getLogs().get(1).getValue(), CoreMatchers.<Object>is(throwableClass.getName()));
|
||||
Assert.assertThat(logDataEntity.getLogs().get(2).getValue(), is(message));
|
||||
assertNotNull(logDataEntity.getLogs().get(3).getValue());
|
||||
}
|
||||
|
||||
public static void assertException(LogDataEntity logDataEntity, Class<? extends Throwable> throwableClass) {
|
||||
Assert.assertThat(logDataEntity.getLogs().size(), is(4));
|
||||
Assert.assertThat(logDataEntity.getLogs().get(0).getValue(), CoreMatchers.<Object>is("error"));
|
||||
Assert.assertThat(logDataEntity.getLogs().get(1).getValue(), CoreMatchers.<Object>is(throwableClass.getName()));
|
||||
Assert.assertNull(logDataEntity.getLogs().get(2).getValue());
|
||||
assertNotNull(logDataEntity.getLogs().get(3).getValue());
|
||||
}
|
||||
|
||||
public static void assertComponent(AbstractSpan span, Component component) {
|
||||
assertThat(SpanHelper.getComponentId(span), is(component.getId()));
|
||||
}
|
||||
|
||||
public static void assertLayer(AbstractSpan span, SpanLayer spanLayer) {
|
||||
assertThat(SpanHelper.getLayer(span), is(spanLayer));
|
||||
}
|
||||
|
||||
public static void assertTag(AbstractSpan span, int index, String value) {
|
||||
assertThat(SpanHelper.getTags(span).get(index).getValue(), is(value));
|
||||
}
|
||||
|
||||
public static void assertOccurException(AbstractSpan span, boolean excepted) {
|
||||
assertThat(SpanHelper.getErrorOccurred(span), is(excepted));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,11 +1,10 @@
|
|||
package org.skywalking.apm.agent.test.tools;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import org.junit.runner.Description;
|
||||
import org.junit.runner.notification.Failure;
|
||||
import org.junit.runner.notification.RunNotifier;
|
||||
import org.junit.runners.BlockJUnit4ClassRunner;
|
||||
import org.junit.runners.model.FrameworkMethod;
|
||||
import org.junit.runners.model.InitializationError;
|
||||
import org.junit.runners.model.Statement;
|
||||
import org.skywalking.apm.agent.core.context.IgnoreTracerContextListener;
|
||||
import org.skywalking.apm.agent.core.context.IgnoredTracerContext;
|
||||
import org.skywalking.apm.agent.core.context.TracingContext;
|
||||
|
|
@ -36,51 +35,39 @@ public class TracingSegmentRunner extends BlockJUnit4ClassRunner {
|
|||
return targetObject;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run(RunNotifier notifier) {
|
||||
notifier.addListener(new RunListener());
|
||||
super.run(notifier);
|
||||
}
|
||||
@Override protected Statement withAfters(FrameworkMethod method, Object target, final Statement statement) {
|
||||
return new Statement() {
|
||||
@Override public void evaluate() throws Throwable {
|
||||
if (field != null) {
|
||||
try {
|
||||
tracingData = new SegmentStorage();
|
||||
field.set(targetObject, tracingData);
|
||||
} catch (IllegalAccessException e) {
|
||||
}
|
||||
}
|
||||
tracingContextListener = new TracingContextListener() {
|
||||
@Override
|
||||
public void afterFinished(TraceSegment traceSegment) {
|
||||
tracingData.addTraceSegment(traceSegment);
|
||||
}
|
||||
};
|
||||
|
||||
class RunListener extends org.junit.runner.notification.RunListener {
|
||||
@Override
|
||||
public void testStarted(Description description) throws Exception {
|
||||
if (field != null) {
|
||||
ignoreTracerContextListener = new IgnoreTracerContextListener() {
|
||||
@Override
|
||||
public void afterFinished(IgnoredTracerContext tracerContext) {
|
||||
tracingData.addIgnoreTraceContext(tracerContext);
|
||||
}
|
||||
};
|
||||
|
||||
TracingContext.ListenerManager.add(tracingContextListener);
|
||||
IgnoredTracerContext.ListenerManager.add(ignoreTracerContextListener);
|
||||
try {
|
||||
tracingData = new SegmentStorage();
|
||||
field.set(targetObject, tracingData);
|
||||
} catch (IllegalAccessException e) {
|
||||
statement.evaluate();
|
||||
} finally {
|
||||
TracingContext.ListenerManager.remove(tracingContextListener);
|
||||
IgnoredTracerContext.ListenerManager.remove(ignoreTracerContextListener);
|
||||
}
|
||||
}
|
||||
tracingContextListener = new TracingContextListener() {
|
||||
@Override
|
||||
public void afterFinished(TraceSegment traceSegment) {
|
||||
tracingData.addTraceSegment(traceSegment);
|
||||
}
|
||||
};
|
||||
|
||||
ignoreTracerContextListener = new IgnoreTracerContextListener() {
|
||||
@Override
|
||||
public void afterFinished(IgnoredTracerContext tracerContext) {
|
||||
tracingData.addIgnoreTraceContext(tracerContext);
|
||||
}
|
||||
};
|
||||
TracingContext.ListenerManager.add(tracingContextListener);
|
||||
IgnoredTracerContext.ListenerManager.add(ignoreTracerContextListener);
|
||||
super.testStarted(description);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void testFinished(Description description) throws Exception {
|
||||
super.testFinished(description);
|
||||
TracingContext.ListenerManager.remove(tracingContextListener);
|
||||
IgnoredTracerContext.ListenerManager.remove(ignoreTracerContextListener);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void testFailure(Failure failure) throws Exception {
|
||||
super.testFailure(failure);
|
||||
TracingContext.ListenerManager.remove(tracingContextListener);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,4 +10,18 @@
|
|||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<artifactId>apm-toolkit-log4j-1.x-activation</artifactId>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>log4j</groupId>
|
||||
<artifactId>log4j</artifactId>
|
||||
<version>1.2.17</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.skywalking</groupId>
|
||||
<artifactId>apm-toolkit-log4j-1.x</artifactId>
|
||||
<version>${project.version}</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
</project>
|
||||
|
|
|
|||
Loading…
Reference in New Issue