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);
}
