void log(String msg) { Span logServiceSpan = this.tracer.createSpan("logService"); try { LOGGER.info(msg); } finally { this.tracer.close(logServiceSpan); } } }
private Span getSpanOrCreateOne() { return trace.isTracing() ? trace.getCurrentSpan() : trace.createSpan(Thread.currentThread().getName()); }
@Test public void testRootSpanAndContinue() { Span root = tracer.createSpan("root"); assertCurrentSpanIs(root); tracer.detach(root); Span span = tracer.continueSpan(root); assertThat(span).isEqualTo(root); tracer.detach(span); }
public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException { URL url = invoker.getUrl(); String spanName = url.getServiceInterface() + "." + invocation.getMethodName(); Span newSpan = tracer.createSpan(spanName); try { dubboSpanInjector.inject(newSpan, RpcContext.getContext()); newSpan.logEvent(Span.CLIENT_SEND); return invoker.invoke(invocation); } catch (RpcException e) { newSpan.tag("error", e.getMessage()); throw e; } finally { if (tracer.isTracing()) { tracer.getCurrentSpan().logEvent(Span.CLIENT_RECV); tracer.close(tracer.getCurrentSpan()); } } }
@Test public void testSpanStackAndCreateAndContinue() { createSpansAndAssertCurrent(3); Span original = tracer.getCurrentSpan(); tracer.detach(original); Span root = tracer.createSpan("root"); assertCurrentSpanIs(root); Span continued = tracer.continueSpan(original); assertCurrentSpanIs(continued); assertThat(continued.getSavedSpan()).isEqualTo(root); assertThat(continued).isEqualTo(original); assertThat(continued.getSavedSpan()).isNotEqualTo(original.getSavedSpan()); tracer.detach(continued); }
protected Span extractTraceInfo(Request request, Tracer tracer) { Span parentSpan = tracer.getCurrentSpan(); if(parentSpan==null){ Span.SpanBuilder spanBuilder = Span.builder(); Span newSpan = tracer.createSpan("motan:"+request.getMethodName(),parentSpan); newSpan.tag("motan_method",operationName);
Cluster.initMQHeader(name -> { TraceLogWrap.request("MQ", name, ""); Span span = tracer.createSpan(name); Long parentId = !span.getParents().isEmpty() ? span.getParents().get(0) : null; HashMap<String, Object> hashMap = new HashMap<String, Object>() {{ tracer.detach(span); return hashMap; }, headerWithName -> { tracer.createSpan(name); } else { Span.SpanBuilder spanBuilder = Span.builder(); tracer.createSpan(name, span); TraceLogWrap.response("MQ", 200, name, "");
@Test public void testSpanStackAndContinue() { Span[] spans = createSpansAndAssertCurrent(3); Span original = tracer.getCurrentSpan(); assertThat(original).isEqualTo(spans[spans.length - 1]); Span parent = tracer.detach(original); assertThat(parent).isEqualTo(spans[spans.length - 2]); assertThat(tracer.getCurrentSpan()).isNull(); Span continued = tracer.continueSpan(original); assertCurrentSpanIs(continued); assertThat(continued.getSavedSpan()).isEqualTo(parent); assertThat(continued).isEqualTo(original); tracer.detach(continued); }
@Override public void doFilter(ServletRequest request, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { HttpServletResponse response = (HttpServletResponse) servletResponse; Span currentSpan = this.tracer.getCurrentSpan(); this.spanInjector.inject(currentSpan, response); filterChain.doFilter(request, response); } }
@Test public void testSpanStackAndCloseOutOfOrder() { Span[] spans = createSpansAndAssertCurrent(3); // try to close a non-current span tracer.close(spans[spans.length - 2]); assertCurrentSpanIs(spans[spans.length - 1]); // pop the stack for (int i = spans.length - 1; i >= 0; i--) { tracer.close(spans[i]); } }
private static Span[] createSpansAndAssertCurrent(int len) { Span[] spans = new Span[len]; Span current = null; for (int i = 0; i < len; i++) { current = tracer.createSpan("span" + i, current); spans[i] = current; assertCurrentSpanIs(current); } return spans; } }
@Test public void testSpanStackAndDetachOutOfOrder() { Span[] spans = createSpansAndAssertCurrent(3); // try to detach a non-current span tracer.detach(spans[spans.length - 2]); assertCurrentSpanIs(spans[spans.length - 1]); Span parent = tracer.detach(spans[spans.length - 1]); assertThat(parent).isEqualTo(spans[spans.length - 2]); }
@After @Before public void verifyNotTracing() { assertThat(tracer.isTracing()).isFalse(); }
@RequestMapping("/greeting") public String greeting() throws InterruptedException { int millis = this.random.nextInt(1000); Thread.sleep(millis); this.tracer.addTag("random-sleep-millis", String.valueOf(millis)); return "Hello"; }
@Test public void testRootSpanAndDetach() { Span root = tracer.createSpan("root"); assertCurrentSpanIs(root); assertThat(root.getSavedSpan()).isNull(); Span parent = tracer.detach(root); assertThat(parent).isNull(); }
private static void assertCurrentSpanIs(Span span) { assertThat(tracer.getCurrentSpan()).isEqualTo(span); assertThat(tracer.getCurrentSpan().getSavedSpan()).isEqualTo(span.getSavedSpan()); assertThat(OpenCensusSleuthSpanContextHolder.getCurrentSpan()).isEqualTo(span); assertThat(OpenCensusSleuthSpanContextHolder.getCurrentSpan().getSavedSpan()) .isEqualTo(span.getSavedSpan()); }
tracer.close(span); } catch (Exception e) { LoggerUtil.error("opentracing span finish error!", e);
@Test public void testDetachNull() { Span parent = tracer.detach(null); assertThat(parent).isNull(); }
String getTimeAsString() { Span dateServiceSpan = this.tracer.createSpan("dateService"); try { LOGGER.info("Returning time as String"); dateServiceSpan.logEvent("This is my date service event"); return LocalDateTime.now().toString(); } finally { this.tracer.close(dateServiceSpan); } } }
@Test public void testSpanStackAndClose() { Span[] spans = createSpansAndAssertCurrent(3); // pop the stack for (int i = spans.length - 1; i >= 0; i--) { assertCurrentSpanIs(spans[i]); Span parent = tracer.close(spans[i]); assertThat(parent).isEqualTo(spans[i].getSavedSpan()); } }