public void StartServerSpan_Exception() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var uriHost = "https://[email protected]"; var uriAbsolutePath = "/object"; var methodName = "GET"; var spanName = methodName; var requestUri = new Uri(uriHost + uriAbsolutePath); spanTracerStub.Expect( x => x.ReceiveServerSpan( Arg <string> .Is.Equal(spanName.ToLower()), Arg <string> .Is.Anything, Arg <string> .Is.Anything, Arg <string> .Is.Anything, Arg <Uri> .Is.Equal(requestUri))).Throw(new Exception()); var result = tracerClient.StartServerTrace(requestUri, methodName); Assert.IsNull(result); }
public void SendClientSpanWithDomainUnderFilterList() { var domain = new Uri("https://server.com"); var requestName = fixture.Create <string>(); var traceId = fixture.Create <long>().ToString(); var parentSpanId = fixture.Create <long>().ToString(); var spanId = fixture.Create <long>().ToString(); var serverUri = new Uri("https://" + clientServiceName + zipkinNotToBeDisplayedDomainList.First() + ":" + port + api); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var localEndpoint = new Endpoint { ServiceName = serverServiceName }; zipkinEndpointStub.Expect(x => x.GetLocalEndpoint(Arg.Is(domain.Host), Arg <ushort> .Is.Anything)).Return(localEndpoint); var remoteEndpoint = new Endpoint { ServiceName = clientServiceName }; zipkinEndpointStub.Expect(x => x.GetRemoteEndpoint(Arg.Is(serverUri), Arg.Is(clientServiceName))).Return(remoteEndpoint); var resultSpan = spanTracer.SendClientSpan(requestName, traceId, parentSpanId, spanId, serverUri); var endpoint = resultSpan.GetAnnotationsByType <BinaryAnnotation>().ToArray()[1].Host as Endpoint; Assert.IsNotNull(endpoint); Assert.AreEqual(clientServiceName, endpoint.ServiceName); }
public void ReceiveServerSpan() { var serviceName = fixture.Create<string>(); var requestName = fixture.Create<string>(); var traceId = fixture.Create<long>().ToString(); var parentSpanId = fixture.Create<long>().ToString(); var spanId = fixture.Create<long>().ToString(); var spanTracer = new SpanTracer(spanCollectorStub, serviceName, zipkinEndpointStub); zipkinEndpointStub.Expect(x => x.GetEndpoint(serviceName)).Return(new Endpoint() { Service_name = serviceName }); var resultSpan = spanTracer.ReceiveServerSpan(requestName, traceId, parentSpanId, spanId); Assert.AreEqual(requestName, resultSpan.Name); Assert.AreEqual(Int64.Parse(traceId, System.Globalization.NumberStyles.HexNumber), resultSpan.Trace_id); Assert.AreEqual(Int64.Parse(parentSpanId, System.Globalization.NumberStyles.HexNumber), resultSpan.Parent_id); Assert.AreEqual(Int64.Parse(spanId, System.Globalization.NumberStyles.HexNumber), resultSpan.Id); Assert.AreEqual(1, resultSpan.Annotations.Count); var annotation = resultSpan.Annotations[0] as Annotation; Assert.IsNotNull(annotation); Assert.AreEqual(zipkinCoreConstants.SERVER_RECV, annotation.Value); Assert.IsNotNull(annotation.Timestamp); Assert.IsNotNull(annotation.Host); var endpoint = annotation.Host as Endpoint; Assert.IsNotNull(endpoint); Assert.AreEqual(serviceName, endpoint.Service_name); AssertBinaryAnnotations(resultSpan.Binary_annotations, traceId, spanId, parentSpanId); }
public void SendServerSpan() { var domain = new Uri("https://server.com"); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var endpoint = new Endpoint() { ServiceName = domain.Host }; var expectedSpan = new Span(); expectedSpan.Annotations.Add(new Annotation() { Host = endpoint, Value = ZipkinConstants.ServerReceive, Timestamp = DateTimeOffset.UtcNow }); zipkinEndpointStub.Expect(x => x.GetLocalEndpoint(domain.Host)).Return(new Endpoint() { ServiceName = domain.Host }); spanTracer.SendServerSpan(expectedSpan); spanCollectorStub.AssertWasCalled(x => x.Collect(Arg <Span> .Matches(y => ValidateSendServerSpan(y, domain.Host) )) ); }
public void StartClientSpan_MultipleDomainList() { var zipkinConfig = CreateZipkinConfigWithDefaultValues(); zipkinConfig.NotToBeDisplayedDomainList = new List <string> { ".abc.net", ".xyz.net" }; var tracerClient = SetupZipkinClient(zipkinConfig); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var clientServiceName = "abc-sandbox"; var uriAbsolutePath = "/object"; var methodName = "GET"; var spanName = methodName; var expectedSpan = new Span(); spanTracerStub.Expect( x => x.SendClientSpan( Arg <string> .Is.Equal(spanName.ToLower()), Arg <string> .Is.Equal(traceProvider.TraceId), Arg <string> .Is.Equal(traceProvider.ParentSpanId), Arg <string> .Is.Equal(traceProvider.SpanId), Arg <Uri> .Is.Anything)).Return(expectedSpan); var result = tracerClient.StartClientTrace(new Uri("https://" + clientServiceName + ".xyz.net:8000" + uriAbsolutePath), methodName, traceProvider); Assert.AreEqual(expectedSpan, result); }
public void ReceiveServerSpan_UsingToBeCleanedDomainName() { var serverServiceName = "server"; var requestName = fixture.Create <string>(); var traceId = fixture.Create <long>().ToString(); var parentSpanId = fixture.Create <long>().ToString(); var spanId = fixture.Create <long>().ToString(); var serverUri = new Uri("https://" + clientServiceName + ":" + port + api); var domain = new Uri("https://" + serverServiceName + zipkinNotToBeDisplayedDomainList.First()); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var localEndpoint = new Endpoint { ServiceName = serverServiceName, Port = port }; zipkinEndpointStub.Expect(x => x.GetLocalEndpoint(Arg.Is(serverServiceName), Arg.Is(port))).Return(localEndpoint); var resultSpan = spanTracer.ReceiveServerSpan(requestName, traceId, parentSpanId, spanId, serverUri); var annotation = resultSpan.Annotations[0] as Annotation; Assert.AreEqual(localEndpoint, annotation.Host); }
public void StartClientSpan_UsingIpAddress() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var clientServiceName = "192.168.178.178"; var uriAbsolutePath = "/object"; var methodName = "GET"; var spanName = methodName; var expectedSpan = new Span(); spanTracerStub.Expect( x => x.SendClientSpan( Arg <string> .Is.Equal(spanName.ToLower()), Arg <string> .Is.Equal(traceProvider.TraceId), Arg <string> .Is.Equal(traceProvider.ParentSpanId), Arg <string> .Is.Equal(traceProvider.SpanId), Arg <Uri> .Is.Anything)).Return(expectedSpan); var result = tracerClient.StartClientTrace(new Uri("https://" + clientServiceName + ".xyz.net:8000" + uriAbsolutePath), methodName, traceProvider); Assert.AreEqual(expectedSpan, result); }
protected ListenerHandler(string sourceName) { SourceName = sourceName; var activity = new Activity("ThisIsANewActivity"); Tracer = new SpanTracer(activity); }
public async Task ReceiveServerSpan_InCorrectRequest_ReturnTraceSpan1() { var requestUri = new Uri("http://server.com:999/api"); var requestName = "request"; var traceId = "traceId"; var parentSpanId = "parentSpanId"; var spanId = "spanId"; var spanCollector = Substitute.For <ISpanCollector>(); var zipkinEndpoint = Substitute.For <IServiceEndpoint>(); var zipkinConfig = new ZipkinConfig(new Uri("http://localhost")); var localEndpoint = new Endpoint { ServiceName = "server.com", Port = 999 }; zipkinEndpoint.GetLocalEndpoint(null, null, 0).ReturnsForAnyArgs(localEndpoint); var st = new SpanTracer(zipkinConfig, spanCollector, zipkinEndpoint); var trInfo = new TraceInfo(traceId, spanId, true, false, new Uri("http://localhost"), null, parentSpanId); var resultSpan = await st.ReceiveServerSpan(requestName, trInfo, requestUri); var annotation = resultSpan.Annotations[0] as Annotation; Assert.AreEqual(localEndpoint, annotation.Host); }
public void ReceiveClientSpan() { var domain = new Uri("http://server.com"); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var endpoint = new Endpoint() { ServiceName = clientServiceName }; var serverUri = new Uri("https://" + clientServiceName + ":" + port + api); var returnCode = fixture.Create <short>(); var expectedSpan = new Span(); expectedSpan.Annotations.Add(new Annotation() { Host = endpoint, Value = ZipkinConstants.ClientSend, Timestamp = DateTimeOffset.UtcNow }); zipkinEndpointStub.Expect(x => x.GetRemoteEndpoint(serverUri, domain.Host)).Return(endpoint); spanTracer.ReceiveClientSpan(expectedSpan, returnCode); spanCollectorStub.AssertWasCalled(x => x.Collect(Arg <Span> .Matches(y => ValidateReceiveClientSpan(y, clientServiceName) )) ); }
public void StartServerSpan() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var uriHost = "https://[email protected]"; var uriAbsolutePath = "/object"; var methodName = "GET"; var spanName = methodName; var requestUri = new Uri(uriHost + uriAbsolutePath); var expectedSpan = new Span(); spanTracerStub.Expect( x => x.ReceiveServerSpan( Arg <string> .Is.Equal(spanName.ToLower()), Arg <string> .Is.Equal(traceProvider.TraceId), Arg <string> .Is.Equal(traceProvider.ParentSpanId), Arg <string> .Is.Equal(traceProvider.SpanId), Arg <Uri> .Is.Equal(requestUri))).Return(expectedSpan); var result = tracerClient.StartServerTrace(requestUri, methodName); Assert.AreEqual(expectedSpan, result); }
public void SendServerSpan_InvalidAnnotation() { var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, new Uri("http://server.com")); var expectedSpan = new Span(); spanTracer.SendServerSpan(expectedSpan); }
public void SendClientSpan() { var domain = new Uri("https://server.com"); var requestName = fixture.Create <string>(); var traceId = Guid.NewGuid().ToString("N"); var parentSpanId = fixture.Create <long>().ToString("x"); var spanId = fixture.Create <long>().ToString("x"); var serverUri = new Uri("https://" + clientServiceName + ":" + port + api); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var localEndpoint = new Endpoint { ServiceName = serverServiceName }; zipkinEndpointStub.Expect(x => x.GetLocalEndpoint(Arg.Is(domain.Host), Arg <ushort> .Is.Anything)).Return(localEndpoint); var remoteEndpoint = new Endpoint { ServiceName = clientServiceName, Port = port }; zipkinEndpointStub.Expect(x => x.GetRemoteEndpoint(Arg.Is(serverUri), Arg.Is(clientServiceName))).Return(remoteEndpoint); var resultSpan = spanTracer.SendClientSpan(requestName, traceId, parentSpanId, spanId, serverUri); Assert.AreEqual(requestName, resultSpan.Name); Assert.AreEqual(traceId, resultSpan.TraceId); Assert.AreEqual(parentSpanId, resultSpan.ParentId); Assert.AreEqual(spanId, resultSpan.Id); Assert.AreEqual(1, resultSpan.GetAnnotationsByType <Annotation>().Count()); var annotation = resultSpan.Annotations[0] as Annotation; Assert.IsNotNull(annotation); Assert.AreEqual(ZipkinConstants.ClientSend, annotation.Value); Assert.IsNotNull(annotation.Timestamp); Assert.AreEqual(localEndpoint, annotation.Host); var binaryAnnotations = resultSpan.GetAnnotationsByType <BinaryAnnotation>(); Assert.AreEqual(2, binaryAnnotations.Count()); AssertBinaryAnnotations(binaryAnnotations, "http.path", serverUri.AbsolutePath); AssertBinaryAnnotations(binaryAnnotations, "sa", "1"); var endpoint = binaryAnnotations.ToArray()[1].Host as Endpoint; Assert.IsNotNull(endpoint); Assert.AreEqual(clientServiceName, endpoint.ServiceName); Assert.AreEqual(port, endpoint.Port); }
public void EndServerSpan() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var serverSpan = new Span(); tracerClient.EndServerTrace(serverSpan); spanTracerStub.AssertWasCalled(x => x.SendServerSpan(serverSpan)); }
public void EndServerSpan_Exception() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var serverSpan = new Span(); spanTracerStub.Expect(x => x.SendServerSpan(serverSpan)).Throw(new Exception()); tracerClient.EndServerTrace(serverSpan); }
public void EndClientSpan_Exception() { var returnCode = fixture.Create <short>(); var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var clientSpan = new Span(); spanTracerStub.Expect(x => x.ReceiveClientSpan(clientSpan, returnCode)).Throw(new Exception()); tracerClient.EndClientTrace(clientSpan, returnCode); }
public void EndClientSpan() { var returnCode = fixture.Create <short>(); var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = GetSpanTracerStub(); zipkinClient.spanTracer = spanTracerStub; var clientSpan = new Span(); tracerClient.EndClientTrace(clientSpan, returnCode); spanTracerStub.AssertWasCalled(x => x.ReceiveClientSpan(clientSpan, returnCode)); }
public void CreateNewSpan() { var spanName = fixture.Create <string>(); var traceId = Guid.NewGuid().ToString("N"); var parentSpanId = fixture.Create <long>().ToString("x"); var spanId = fixture.Create <long>().ToString("x"); var resultSpan = SpanTracer.CreateNewSpan(spanName, traceId, parentSpanId, spanId); Assert.AreEqual(spanName, resultSpan.Name); Assert.AreEqual(traceId, resultSpan.TraceId); Assert.AreEqual(parentSpanId, resultSpan.ParentId); Assert.AreEqual(spanId, resultSpan.Id); }
public void EndServerSpan() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub <SpanTracer>(spanCollectorStub, fixture.Create <string>(), MockRepository.GenerateStub <ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; zipkinClient.serverSpan = new Span(); var expectedDuration = fixture.Create <int>(); tracerClient.EndServerTrace(expectedDuration); spanTracerStub.AssertWasCalled(x => x.SendServerSpan(zipkinClient.serverSpan, expectedDuration)); }
public void EndClientSpan_Exception() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub <SpanTracer>(spanCollectorStub, fixture.Create <string>(), MockRepository.GenerateStub <ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; zipkinClient.clientSpan = new Span(); var expectedDuration = fixture.Create <int>(); spanTracerStub.Expect(x => x.ReceiveClientSpan(zipkinClient.clientSpan, expectedDuration)).Throw(new Exception()); tracerClient.EndClientTrace(expectedDuration); }
public void ReceiveClientSpan_EmptyAnnotationsList() { var domain = new Uri("http://server.com"); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var endpoint = new Endpoint() { ServiceName = clientServiceName }; var serverUri = new Uri("https://" + clientServiceName + ":" + port + api); var returnCode = fixture.Create <short>(); var expectedSpan = new Span(); zipkinEndpointStub.Expect(x => x.GetRemoteEndpoint(serverUri, domain.Host)).Return(endpoint); spanTracer.ReceiveClientSpan(expectedSpan, returnCode); }
public void EndClientSpan_NullClientTrace_DoesntThrow() { var returnCode = fixture.Create <short>(); var tracerClient = SetupZipkinClient(); spanTracerStub = GetSpanTracerStub(); var called = false; spanTracerStub.Stub(x => x.ReceiveClientSpan(Arg <Span> .Is.Anything, Arg <short> .Is.Equal(returnCode))) .WhenCalled(x => { called = true; }); tracerClient.EndClientTrace(null, returnCode); Assert.IsFalse(called); }
public void StartClientSpan_Exception() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub <SpanTracer>(spanCollectorStub, fixture.Create <string>(), MockRepository.GenerateStub <ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; var expectedSpan = new Span(); spanTracerStub.Expect(x => x.SendClientSpan(Arg <string> .Is.Equal(requestName), Arg <string> .Is.Anything, Arg <string> .Is.Anything, Arg <string> .Is.Anything)).Throw(new Exception()); tracerClient.StartClientTrace(); Assert.AreEqual(null, zipkinClient.clientSpan); }
public void StartServerSpan() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub <SpanTracer>(spanCollectorStub, fixture.Create <string>(), MockRepository.GenerateStub <ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; var expectedSpan = new Span(); spanTracerStub.Expect(x => x.ReceiveServerSpan(Arg <string> .Is.Equal(requestName), Arg <string> .Is.Anything, Arg <string> .Is.Anything, Arg <string> .Is.Anything)).Return(expectedSpan); tracerClient.StartServerTrace(); Assert.AreEqual(expectedSpan, zipkinClient.serverSpan); }
public void SendServerSpan() { var serviceName = fixture.Create<string>(); var spanTracer = new SpanTracer(spanCollectorStub, serviceName, zipkinEndpointStub); var expectedSpan = new Span() { Annotations = new System.Collections.Generic.List<Annotation>() }; var expectedDuration = fixture.Create<int>(); zipkinEndpointStub.Expect(x => x.GetEndpoint(serviceName)).Return(new Endpoint() { Service_name = serviceName }); spanTracer.SendServerSpan(expectedSpan, expectedDuration); spanCollectorStub.AssertWasCalled(x => x.Collect(Arg<Span>.Matches(y => ValidateSendServerSpan(y, serviceName, expectedDuration) )) ); }
public void Record_WithSpanAndValue_AddsNewAnnotation() { // Arrange var expectedDescription = "Description"; var expectedSpan = new Span(); var domain = new Uri("http://server.com"); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); // Act spanTracer.Record(expectedSpan, expectedDescription); // Assert Assert.IsNotNull( expectedSpan.GetAnnotationsByType <Annotation>().SingleOrDefault(a => (string)a.Value == expectedDescription), "The record is not found in the Annotations." ); }
public void Record_IsTraceOnIsFalse_DoesNotAddAnnotation() { // Arrange var tracerClient = SetupZipkinClient(); spanTracerStub = GetSpanTracerStub(); var zipkinClient = (ZipkinClient)tracerClient; zipkinClient.IsTraceOn = false; var testSpan = new Span(); // Act tracerClient.Record(testSpan, "irrelevant"); // Assert Assert.IsFalse(testSpan.Annotations.Any(), "There are annotations but the trace is off."); }
public void RecordLocalComponent_IsTraceOnIsFalse_DoesNotAddLocalComponentAnnotation() { // Arrange var testValue = "Some Value"; var tracerClient = SetupZipkinClient(); spanTracerStub = GetSpanTracerStub(); var zipkinClient = (ZipkinClient)tracerClient; zipkinClient.IsTraceOn = false; var testSpan = new Span(); // Act tracerClient.RecordBinary(testSpan, ZipkinConstants.LocalComponent, testValue); // Assert Assert.IsFalse(testSpan.GetAnnotationsByType <BinaryAnnotation>().Any(), "There are annotations but the trace is off."); }
public ZipkinClient(IZipkinConfig zipkinConfig, HttpContext context, SpanCollector collector = null) { if (zipkinConfig == null) { throw new ArgumentNullException(nameof(zipkinConfig)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } var traceProvider = new TraceProvider(zipkinConfig, context); IsTraceOn = !zipkinConfig.Bypass(context.Request) && IsTraceProviderSamplingOn(traceProvider); if (!IsTraceOn) { return; } zipkinConfig.Validate(); ZipkinConfig = zipkinConfig; try { spanCollector = collector ?? GetInstance( zipkinConfig.ZipkinBaseUri, zipkinConfig.SpanProcessorBatchSize); spanCollector.Start(); spanTracer = new SpanTracer( spanCollector, new ServiceEndpoint(), zipkinConfig.NotToBeDisplayedDomainList, zipkinConfig.Domain(context.Request)); TraceProvider = traceProvider; } catch (Exception ex) { IsTraceOn = false; } }
public async Task ReceiveServerSpan_InCorrectRequest_ReturnTraceSpan() { var requestUri = new Uri("http://server.com:999/api"); var requestName = "request"; var traceId = "traceId"; var parentSpanId = "parentSpanId"; var spanId = "spanId"; var spanCollector = Substitute.For <ISpanCollector>(); var zipkinEndpoint = Substitute.For <IServiceEndpoint>(); var zipkinConfig = new ZipkinConfig(new Uri("http://localhost")); var localEndpoint = new Endpoint { ServiceName = "server.com", Port = 999 }; zipkinEndpoint.GetLocalEndpoint(null, null, 0).ReturnsForAnyArgs(localEndpoint); var st = new SpanTracer(zipkinConfig, spanCollector, zipkinEndpoint); var trInfo = new TraceInfo(traceId, spanId, true, false, new Uri("http://localhost"), null, parentSpanId); var resultSpan = await st.ReceiveServerSpan(requestName, trInfo, requestUri); Assert.AreEqual(requestName, resultSpan.Name); Assert.AreEqual(traceId, resultSpan.TraceId); Assert.AreEqual(parentSpanId, resultSpan.ParentId); Assert.AreEqual(spanId, resultSpan.Id); Assert.AreEqual(1, resultSpan.GetAnnotationsByType <Annotation>().Count()); var annotation = resultSpan.Annotations[0] as Annotation; Assert.IsNotNull(annotation); Assert.AreEqual(TraceKeys.ServerRecv, annotation.Value); Assert.IsNotNull(annotation.Timestamp); Assert.IsNotNull(annotation.Host); Assert.AreEqual(localEndpoint, annotation.Host); var binaryAnnotations = resultSpan.GetAnnotationsByType <BinaryAnnotation>(); Assert.AreEqual(1, binaryAnnotations.Count()); AssertBinaryAnnotations(binaryAnnotations, "http.path", requestUri.AbsolutePath); }
public void ReceiveServerSpan() { var domain = new Uri("http://server.com"); var requestName = fixture.Create <string>(); var traceId = fixture.Create <long>().ToString(); var parentSpanId = fixture.Create <long>().ToString(); var spanId = fixture.Create <long>().ToString(); var serverUri = new Uri("https://" + clientServiceName + ":" + port + api); var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain); var localEndpoint = new Endpoint { ServiceName = serverServiceName, Port = port }; zipkinEndpointStub.Expect(x => x.GetLocalEndpoint(Arg.Is(domain.Host), Arg.Is(port))).Return(localEndpoint); var resultSpan = spanTracer.ReceiveServerSpan(requestName, traceId, parentSpanId, spanId, serverUri); Assert.AreEqual(requestName, resultSpan.Name); Assert.AreEqual(Int64.Parse(traceId, System.Globalization.NumberStyles.HexNumber), resultSpan.TraceId); Assert.AreEqual(Int64.Parse(parentSpanId, System.Globalization.NumberStyles.HexNumber), resultSpan.ParentId); Assert.AreEqual(Int64.Parse(spanId, System.Globalization.NumberStyles.HexNumber), resultSpan.Id); Assert.AreEqual(1, resultSpan.GetAnnotationsByType <Annotation>().Count()); var annotation = resultSpan.Annotations[0] as Annotation; Assert.IsNotNull(annotation); Assert.AreEqual(ZipkinConstants.ServerReceive, annotation.Value); Assert.IsNotNull(annotation.Timestamp); Assert.IsNotNull(annotation.Host); Assert.AreEqual(localEndpoint, annotation.Host); var binaryAnnotations = resultSpan.GetAnnotationsByType <BinaryAnnotation>(); Assert.AreEqual(1, binaryAnnotations.Count()); AssertBinaryAnnotations(binaryAnnotations, "http.uri", serverUri.AbsolutePath); }
public void RecordLocalComponent_WithNotNullValue_AddsLocalComponentAnnotation() { // Arrange var testValue = "Some Value"; var tracerClient = SetupZipkinClient(); spanTracerStub = GetSpanTracerStub(); var zipkinClient = (ZipkinClient)tracerClient; zipkinClient.IsTraceOn = true; var testSpan = new Span(); // Act tracerClient.RecordLocalComponent(testSpan, testValue); // Assert var annotation = testSpan.GetAnnotationsByType <BinaryAnnotation>().SingleOrDefault(a => a.Key == ZipkinConstants.LocalComponent); Assert.IsNotNull(annotation, "There is no local trace annotation in the binary annotations."); Assert.AreEqual(testValue, annotation.Value, "The local component annotation value is not correct."); }
public void CTOR_WithNullZipkinEndpoint() { var spanTracer = new SpanTracer(spanCollectorStub, fixture.Create<string>(), null); }
public void CTOR_WithNullSpanCollector() { var spanTracer = new SpanTracer(null, fixture.Create<string>(), zipkinEndpointStub); }
public void CTOR_WithNullOrEmptyString() { var spanTracer = new SpanTracer(spanCollectorStub, null, zipkinEndpointStub); }
public void StartServerSpan() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub<SpanTracer>(spanCollectorStub, fixture.Create<string>(), MockRepository.GenerateStub<ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; var expectedSpan = new Span(); spanTracerStub.Expect(x => x.ReceiveServerSpan(Arg<string>.Is.Equal(requestName), Arg<string>.Is.Anything, Arg<string>.Is.Anything, Arg<string>.Is.Anything)).Return(expectedSpan); tracerClient.StartServerTrace(); Assert.AreEqual(expectedSpan, zipkinClient.serverSpan); }
public void EndServerSpan() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub<SpanTracer>(spanCollectorStub, fixture.Create<string>(), MockRepository.GenerateStub<ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; zipkinClient.serverSpan = new Span(); var expectedDuration = fixture.Create<int>(); tracerClient.EndServerTrace(expectedDuration); spanTracerStub.AssertWasCalled(x => x.SendServerSpan(zipkinClient.serverSpan, expectedDuration)); }
public void StartClientSpan_Exception() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub<SpanTracer>(spanCollectorStub, fixture.Create<string>(), MockRepository.GenerateStub<ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; var expectedSpan = new Span(); spanTracerStub.Expect(x => x.SendClientSpan(Arg<string>.Is.Equal(requestName), Arg<string>.Is.Anything, Arg<string>.Is.Anything, Arg<string>.Is.Anything)).Throw(new Exception()); tracerClient.StartClientTrace(); Assert.AreEqual(null, zipkinClient.clientSpan); }
public void EndClientSpan_Exception() { var tracerClient = SetupZipkinClient(); var zipkinClient = (ZipkinClient)tracerClient; spanTracerStub = MockRepository.GenerateStub<SpanTracer>(spanCollectorStub, fixture.Create<string>(), MockRepository.GenerateStub<ServiceEndpoint>()); zipkinClient.spanTracer = spanTracerStub; zipkinClient.clientSpan = new Span(); var expectedDuration = fixture.Create<int>(); spanTracerStub.Expect(x => x.ReceiveClientSpan(zipkinClient.clientSpan, expectedDuration)).Throw(new Exception()); tracerClient.EndClientTrace(expectedDuration); }