863 lines
36 KiB
C#
863 lines
36 KiB
C#
// <copyright file="JaegerActivityConversionTest.cs" company="OpenTelemetry Authors">
|
|
// Copyright The OpenTelemetry Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// </copyright>
|
|
|
|
using System.Diagnostics;
|
|
using OpenTelemetry.Internal;
|
|
using OpenTelemetry.Resources;
|
|
using OpenTelemetry.Trace;
|
|
using Xunit;
|
|
|
|
namespace OpenTelemetry.Exporter.Jaeger.Implementation.Tests
|
|
{
|
|
public class JaegerActivityConversionTest
|
|
{
|
|
static JaegerActivityConversionTest()
|
|
{
|
|
Activity.DefaultIdFormat = ActivityIdFormat.W3C;
|
|
Activity.ForceDefaultIdFormat = true;
|
|
|
|
var listener = new ActivityListener
|
|
{
|
|
ShouldListenTo = _ => true,
|
|
Sample = (ref ActivityCreationOptions<ActivityContext> options) => ActivitySamplingResult.AllData,
|
|
};
|
|
|
|
ActivitySource.AddActivityListener(listener);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(true)]
|
|
[InlineData(false)]
|
|
public void JaegerActivityConverterTest_ConvertActivityToJaegerSpan_AllPropertiesSet(bool isRootSpan)
|
|
{
|
|
using var activity = CreateTestActivity(isRootSpan: isRootSpan);
|
|
var traceIdAsInt = new Int128(activity.Context.TraceId);
|
|
var spanIdAsInt = new Int128(activity.Context.SpanId);
|
|
var linkTraceIdAsInt = new Int128(activity.Links.Single().Context.TraceId);
|
|
var linkSpanIdAsInt = new Int128(activity.Links.Single().Context.SpanId);
|
|
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
Assert.Equal("Name", jaegerSpan.OperationName);
|
|
Assert.Equal(2, jaegerSpan.Logs.Count);
|
|
|
|
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
|
|
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
|
|
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
|
|
Assert.Equal(new Int128(activity.ParentSpanId).Low, jaegerSpan.ParentSpanId);
|
|
|
|
Assert.Equal(activity.Links.Count(), jaegerSpan.References.Count);
|
|
var references = jaegerSpan.References.ToArray();
|
|
var jaegerRef = references[0];
|
|
Assert.Equal(linkTraceIdAsInt.High, jaegerRef.TraceIdHigh);
|
|
Assert.Equal(linkTraceIdAsInt.Low, jaegerRef.TraceIdLow);
|
|
Assert.Equal(linkSpanIdAsInt.Low, jaegerRef.SpanId);
|
|
|
|
Assert.Equal(0x1, jaegerSpan.Flags);
|
|
|
|
Assert.Equal(activity.StartTimeUtc.ToEpochMicroseconds(), jaegerSpan.StartTime);
|
|
Assert.Equal(TimeSpanToMicroseconds(activity.Duration), jaegerSpan.Duration);
|
|
|
|
var tags = jaegerSpan.Tags.ToArray();
|
|
var tag = tags[0];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("stringKey", tag.Key);
|
|
Assert.Equal("value", tag.VStr);
|
|
tag = tags[1];
|
|
Assert.Equal(JaegerTagType.LONG, tag.VType);
|
|
Assert.Equal("longKey", tag.Key);
|
|
Assert.Equal(1, tag.VLong);
|
|
tag = tags[2];
|
|
Assert.Equal(JaegerTagType.LONG, tag.VType);
|
|
Assert.Equal("longKey2", tag.Key);
|
|
Assert.Equal(1, tag.VLong);
|
|
tag = tags[3];
|
|
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
|
|
Assert.Equal("doubleKey", tag.Key);
|
|
Assert.Equal(1, tag.VDouble);
|
|
tag = tags[4];
|
|
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
|
|
Assert.Equal("doubleKey2", tag.Key);
|
|
Assert.Equal(1, tag.VDouble);
|
|
tag = tags[5];
|
|
Assert.Equal(JaegerTagType.BOOL, tag.VType);
|
|
Assert.Equal("boolKey", tag.Key);
|
|
Assert.Equal(true, tag.VBool);
|
|
|
|
var logs = jaegerSpan.Logs.ToArray();
|
|
var jaegerLog = logs[0];
|
|
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
|
|
Assert.Equal(3, jaegerLog.Fields.Count);
|
|
var eventFields = jaegerLog.Fields.ToArray();
|
|
var eventField = eventFields[0];
|
|
Assert.Equal("key", eventField.Key);
|
|
Assert.Equal("value", eventField.VStr);
|
|
eventField = eventFields[1];
|
|
Assert.Equal("string_array", eventField.Key);
|
|
Assert.Equal(@"[""a"",""b""]", eventField.VStr);
|
|
eventField = eventFields[2];
|
|
Assert.Equal("event", eventField.Key);
|
|
Assert.Equal("Event1", eventField.VStr);
|
|
|
|
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
|
|
|
|
jaegerLog = logs[1];
|
|
Assert.Equal(2, jaegerLog.Fields.Count);
|
|
eventFields = jaegerLog.Fields.ToArray();
|
|
eventField = eventFields[0];
|
|
Assert.Equal("key", eventField.Key);
|
|
Assert.Equal("value", eventField.VStr);
|
|
eventField = eventFields[1];
|
|
Assert.Equal("event", eventField.Key);
|
|
Assert.Equal("Event2", eventField.VStr);
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_ConvertActivityToJaegerSpan_NoAttributes()
|
|
{
|
|
using var activity = CreateTestActivity(setAttributes: false);
|
|
var traceIdAsInt = new Int128(activity.Context.TraceId);
|
|
var spanIdAsInt = new Int128(activity.Context.SpanId);
|
|
var linkTraceIdAsInt = new Int128(activity.Links.Single().Context.TraceId);
|
|
var linkSpanIdAsInt = new Int128(activity.Links.Single().Context.SpanId);
|
|
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
Assert.Equal("Name", jaegerSpan.OperationName);
|
|
Assert.Equal(2, jaegerSpan.Logs.Count);
|
|
|
|
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
|
|
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
|
|
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
|
|
Assert.Equal(new Int128(activity.ParentSpanId).Low, jaegerSpan.ParentSpanId);
|
|
|
|
Assert.Equal(activity.Links.Count(), jaegerSpan.References.Count);
|
|
var references = jaegerSpan.References.ToArray();
|
|
var jaegerRef = references[0];
|
|
Assert.Equal(linkTraceIdAsInt.High, jaegerRef.TraceIdHigh);
|
|
Assert.Equal(linkTraceIdAsInt.Low, jaegerRef.TraceIdLow);
|
|
Assert.Equal(linkSpanIdAsInt.Low, jaegerRef.SpanId);
|
|
|
|
Assert.Equal(0x1, jaegerSpan.Flags);
|
|
|
|
Assert.Equal(activity.StartTimeUtc.ToEpochMicroseconds(), jaegerSpan.StartTime);
|
|
Assert.Equal(TimeSpanToMicroseconds(activity.Duration), jaegerSpan.Duration);
|
|
|
|
// 2 tags: span.kind & library.name.
|
|
Assert.Equal(2, jaegerSpan.Tags.Count);
|
|
|
|
var logs = jaegerSpan.Logs.ToArray();
|
|
var jaegerLog = logs[0];
|
|
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
|
|
Assert.Equal(3, jaegerLog.Fields.Count);
|
|
var eventFields = jaegerLog.Fields.ToArray();
|
|
var eventField = eventFields[0];
|
|
Assert.Equal("key", eventField.Key);
|
|
Assert.Equal("value", eventField.VStr);
|
|
eventField = eventFields[2];
|
|
Assert.Equal("event", eventField.Key);
|
|
Assert.Equal("Event1", eventField.VStr);
|
|
|
|
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
|
|
|
|
jaegerLog = logs[1];
|
|
Assert.Equal(2, jaegerLog.Fields.Count);
|
|
eventFields = jaegerLog.Fields.ToArray();
|
|
eventField = eventFields[0];
|
|
Assert.Equal("key", eventField.Key);
|
|
Assert.Equal("value", eventField.VStr);
|
|
eventField = eventFields[1];
|
|
Assert.Equal("event", eventField.Key);
|
|
Assert.Equal("Event2", eventField.VStr);
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_ConvertActivityToJaegerSpan_NoEvents()
|
|
{
|
|
using var activity = CreateTestActivity(addEvents: false);
|
|
var traceIdAsInt = new Int128(activity.Context.TraceId);
|
|
var spanIdAsInt = new Int128(activity.Context.SpanId);
|
|
var linkTraceIdAsInt = new Int128(activity.Links.Single().Context.TraceId);
|
|
var linkSpanIdAsInt = new Int128(activity.Links.Single().Context.SpanId);
|
|
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
Assert.Equal("Name", jaegerSpan.OperationName);
|
|
Assert.Empty(jaegerSpan.Logs);
|
|
|
|
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
|
|
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
|
|
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
|
|
Assert.Equal(new Int128(activity.ParentSpanId).Low, jaegerSpan.ParentSpanId);
|
|
|
|
Assert.Equal(activity.Links.Count(), jaegerSpan.References.Count);
|
|
var references = jaegerSpan.References.ToArray();
|
|
var jaegerRef = references[0];
|
|
Assert.Equal(linkTraceIdAsInt.High, jaegerRef.TraceIdHigh);
|
|
Assert.Equal(linkTraceIdAsInt.Low, jaegerRef.TraceIdLow);
|
|
Assert.Equal(linkSpanIdAsInt.Low, jaegerRef.SpanId);
|
|
|
|
Assert.Equal(0x1, jaegerSpan.Flags);
|
|
|
|
Assert.Equal(activity.StartTimeUtc.ToEpochMicroseconds(), jaegerSpan.StartTime);
|
|
Assert.Equal(TimeSpanToMicroseconds(activity.Duration), jaegerSpan.Duration);
|
|
|
|
var tags = jaegerSpan.Tags.ToArray();
|
|
var tag = tags[0];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("stringKey", tag.Key);
|
|
Assert.Equal("value", tag.VStr);
|
|
tag = tags[1];
|
|
Assert.Equal(JaegerTagType.LONG, tag.VType);
|
|
Assert.Equal("longKey", tag.Key);
|
|
Assert.Equal(1, tag.VLong);
|
|
tag = tags[2];
|
|
Assert.Equal(JaegerTagType.LONG, tag.VType);
|
|
Assert.Equal("longKey2", tag.Key);
|
|
Assert.Equal(1, tag.VLong);
|
|
tag = tags[3];
|
|
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
|
|
Assert.Equal("doubleKey", tag.Key);
|
|
Assert.Equal(1, tag.VDouble);
|
|
tag = tags[4];
|
|
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
|
|
Assert.Equal("doubleKey2", tag.Key);
|
|
Assert.Equal(1, tag.VDouble);
|
|
tag = tags[5];
|
|
Assert.Equal(JaegerTagType.BOOL, tag.VType);
|
|
Assert.Equal("boolKey", tag.Key);
|
|
Assert.Equal(true, tag.VBool);
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_ConvertActivityToJaegerSpan_NoLinks()
|
|
{
|
|
using var activity = CreateTestActivity(addLinks: false, ticksToAdd: 8000);
|
|
var traceIdAsInt = new Int128(activity.Context.TraceId);
|
|
var spanIdAsInt = new Int128(activity.Context.SpanId);
|
|
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
Assert.Equal("Name", jaegerSpan.OperationName);
|
|
Assert.Equal(2, jaegerSpan.Logs.Count);
|
|
|
|
Assert.Equal(traceIdAsInt.High, jaegerSpan.TraceIdHigh);
|
|
Assert.Equal(traceIdAsInt.Low, jaegerSpan.TraceIdLow);
|
|
Assert.Equal(spanIdAsInt.Low, jaegerSpan.SpanId);
|
|
Assert.Equal(new Int128(activity.ParentSpanId).Low, jaegerSpan.ParentSpanId);
|
|
|
|
Assert.Empty(jaegerSpan.References);
|
|
|
|
Assert.Equal(0x1, jaegerSpan.Flags);
|
|
|
|
Assert.Equal(activity.StartTimeUtc.ToEpochMicroseconds(), jaegerSpan.StartTime);
|
|
Assert.Equal(TimeSpanToMicroseconds(activity.Duration), jaegerSpan.Duration);
|
|
|
|
var tags = jaegerSpan.Tags.ToArray();
|
|
var tag = tags[0];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("stringKey", tag.Key);
|
|
Assert.Equal("value", tag.VStr);
|
|
tag = tags[1];
|
|
Assert.Equal(JaegerTagType.LONG, tag.VType);
|
|
Assert.Equal("longKey", tag.Key);
|
|
Assert.Equal(1, tag.VLong);
|
|
tag = tags[2];
|
|
Assert.Equal(JaegerTagType.LONG, tag.VType);
|
|
Assert.Equal("longKey2", tag.Key);
|
|
Assert.Equal(1, tag.VLong);
|
|
tag = tags[3];
|
|
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
|
|
Assert.Equal("doubleKey", tag.Key);
|
|
Assert.Equal(1, tag.VDouble);
|
|
tag = tags[4];
|
|
Assert.Equal(JaegerTagType.DOUBLE, tag.VType);
|
|
Assert.Equal("doubleKey2", tag.Key);
|
|
Assert.Equal(1, tag.VDouble);
|
|
tag = tags[5];
|
|
Assert.Equal(JaegerTagType.BOOL, tag.VType);
|
|
Assert.Equal("boolKey", tag.Key);
|
|
Assert.Equal(true, tag.VBool);
|
|
|
|
tag = tags[6];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("int_array", tag.Key);
|
|
Assert.Equal(System.Text.Json.JsonSerializer.Serialize(new[] { 1, 2 }), tag.VStr);
|
|
|
|
tag = tags[7];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("bool_array", tag.Key);
|
|
Assert.Equal(System.Text.Json.JsonSerializer.Serialize(new[] { true, false }), tag.VStr);
|
|
|
|
tag = tags[8];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("double_array", tag.Key);
|
|
Assert.Equal(System.Text.Json.JsonSerializer.Serialize(new[] { 1, 1.1 }), tag.VStr);
|
|
|
|
tag = tags[9];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("string_array", tag.Key);
|
|
Assert.Equal(System.Text.Json.JsonSerializer.Serialize(new[] { "a", "b" }), tag.VStr);
|
|
|
|
tag = tags[10];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("obj_array", tag.Key);
|
|
Assert.Equal(System.Text.Json.JsonSerializer.Serialize(new[] { 1.ToString(), false.ToString(), new object().ToString(), "string", string.Empty, null }), tag.VStr);
|
|
|
|
// The second to last tag should be span.kind in this case
|
|
tag = tags[tags.Length - 2];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("span.kind", tag.Key);
|
|
Assert.Equal("client", tag.VStr);
|
|
|
|
// The last tag should be library.name in this case
|
|
tag = tags[tags.Length - 1];
|
|
Assert.Equal(JaegerTagType.STRING, tag.VType);
|
|
Assert.Equal("otel.library.name", tag.Key);
|
|
Assert.Equal(nameof(CreateTestActivity), tag.VStr);
|
|
|
|
var logs = jaegerSpan.Logs.ToArray();
|
|
var jaegerLog = logs[0];
|
|
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
|
|
Assert.Equal(3, jaegerLog.Fields.Count);
|
|
var eventFields = jaegerLog.Fields.ToArray();
|
|
var eventField = eventFields[0];
|
|
Assert.Equal("key", eventField.Key);
|
|
Assert.Equal("value", eventField.VStr);
|
|
eventField = eventFields[2];
|
|
Assert.Equal("event", eventField.Key);
|
|
Assert.Equal("Event1", eventField.VStr);
|
|
Assert.Equal(activity.Events.First().Timestamp.ToEpochMicroseconds(), jaegerLog.Timestamp);
|
|
|
|
jaegerLog = logs[1];
|
|
Assert.Equal(2, jaegerLog.Fields.Count);
|
|
eventFields = jaegerLog.Fields.ToArray();
|
|
eventField = eventFields[0];
|
|
Assert.Equal("key", eventField.Key);
|
|
Assert.Equal("value", eventField.VStr);
|
|
eventField = eventFields[1];
|
|
Assert.Equal("event", eventField.Key);
|
|
Assert.Equal("Event2", eventField.VStr);
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_GenerateJaegerSpan_RemoteEndpointOmittedByDefault()
|
|
{
|
|
// Arrange
|
|
using var span = CreateTestActivity();
|
|
|
|
// Act
|
|
var jaegerSpan = span.ToJaegerSpan();
|
|
|
|
// Assert
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == "peer.service");
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_GenerateJaegerSpan_RemoteEndpointResolution()
|
|
{
|
|
// Arrange
|
|
using var span = CreateTestActivity(
|
|
additionalAttributes: new Dictionary<string, object>
|
|
{
|
|
["net.peer.name"] = "RemoteServiceName",
|
|
});
|
|
|
|
// Act
|
|
var jaegerSpan = span.ToJaegerSpan();
|
|
|
|
// Assert
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == "peer.service");
|
|
Assert.Equal("RemoteServiceName", jaegerSpan.Tags.First(t => t.Key == "peer.service").VStr);
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_GenerateJaegerSpan_PeerServiceNameIgnoredForServerSpan()
|
|
{
|
|
// Arrange
|
|
using var span = CreateTestActivity(
|
|
additionalAttributes: new Dictionary<string, object>
|
|
{
|
|
["http.host"] = "DiscardedRemoteServiceName",
|
|
},
|
|
kind: ActivityKind.Server);
|
|
|
|
// Act
|
|
var jaegerSpan = span.ToJaegerSpan();
|
|
|
|
// Assert
|
|
Assert.Null(jaegerSpan.PeerServiceName);
|
|
Assert.Empty(jaegerSpan.Tags.Where(t => t.Key == "peer.service"));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData(nameof(RemoteEndpointPriorityTestCase.GetTestCases), MemberType = typeof(RemoteEndpointPriorityTestCase))]
|
|
public void JaegerActivityConverterTest_GenerateJaegerSpan_RemoteEndpointResolutionPriority(RemoteEndpointPriorityTestCase testCase)
|
|
{
|
|
// Arrange
|
|
using var activity = CreateTestActivity(additionalAttributes: testCase.RemoteEndpointAttributes);
|
|
|
|
// Act
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert
|
|
var tags = jaegerSpan.Tags.Where(t => t.Key == "peer.service");
|
|
Assert.Single(tags);
|
|
var tag = tags.First();
|
|
Assert.Equal(testCase.ExpectedResult, tag.VStr);
|
|
}
|
|
|
|
[Fact]
|
|
public void JaegerActivityConverterTest_NullTagValueTest()
|
|
{
|
|
// Arrange
|
|
using var activity = CreateTestActivity(additionalAttributes: new Dictionary<string, object> { ["nullTag"] = null });
|
|
|
|
// Act
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == "nullTag");
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(StatusCode.Unset, "unset", "")]
|
|
[InlineData(StatusCode.Ok, "Ok", "")]
|
|
[InlineData(StatusCode.Error, "ERROR", "error description")]
|
|
[InlineData(StatusCode.Unset, "iNvAlId", "")]
|
|
public void JaegerActivityConverterTest_Status_ErrorFlagTest(StatusCode expectedStatusCode, string statusCodeTagValue, string statusDescription)
|
|
{
|
|
// Arrange
|
|
using var activity = CreateTestActivity();
|
|
activity.SetTag(SpanAttributeConstants.StatusCodeKey, statusCodeTagValue);
|
|
activity.SetTag(SpanAttributeConstants.StatusDescriptionKey, statusDescription);
|
|
|
|
// Act
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert
|
|
|
|
Assert.Equal(expectedStatusCode, activity.GetStatus().StatusCode);
|
|
|
|
if (expectedStatusCode == StatusCode.Unset)
|
|
{
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == SpanAttributeConstants.StatusCodeKey);
|
|
}
|
|
else
|
|
{
|
|
Assert.Equal(
|
|
StatusHelper.GetTagValueForStatusCode(expectedStatusCode),
|
|
jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
|
|
}
|
|
|
|
if (expectedStatusCode == StatusCode.Error)
|
|
{
|
|
Assert.Contains(
|
|
jaegerSpan.Tags, t =>
|
|
t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName &&
|
|
t.VType == JaegerTagType.BOOL && (t.VBool ?? false));
|
|
Assert.Contains(
|
|
jaegerSpan.Tags, t =>
|
|
t.Key == SpanAttributeConstants.StatusDescriptionKey &&
|
|
t.VType == JaegerTagType.STRING && t.VStr.Equals(statusDescription));
|
|
}
|
|
else
|
|
{
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(ActivityStatusCode.Unset)]
|
|
[InlineData(ActivityStatusCode.Ok)]
|
|
[InlineData(ActivityStatusCode.Error)]
|
|
public void ToJaegerSpan_Activity_Status_And_StatusDescription_is_Set(ActivityStatusCode expectedStatusCode)
|
|
{
|
|
// Arrange
|
|
using var activity = CreateTestActivity();
|
|
activity.SetStatus(expectedStatusCode);
|
|
|
|
// Act
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert
|
|
if (expectedStatusCode == ActivityStatusCode.Unset)
|
|
{
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == SpanAttributeConstants.StatusCodeKey);
|
|
}
|
|
else if (expectedStatusCode == ActivityStatusCode.Ok)
|
|
{
|
|
Assert.Equal("OK", jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
|
|
}
|
|
|
|
// expectedStatusCode is Error
|
|
else
|
|
{
|
|
Assert.Equal("ERROR", jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
|
|
}
|
|
|
|
if (expectedStatusCode == ActivityStatusCode.Error)
|
|
{
|
|
Assert.Contains(
|
|
jaegerSpan.Tags, t =>
|
|
t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName &&
|
|
t.VType == JaegerTagType.BOOL && (t.VBool ?? false));
|
|
}
|
|
else
|
|
{
|
|
Assert.DoesNotContain(
|
|
jaegerSpan.Tags, t =>
|
|
t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void ActivityStatus_Takes_precedence_Over_Status_Tags_ActivityStatusCodeIsOk()
|
|
{
|
|
// Arrange.
|
|
using var activity = CreateTestActivity();
|
|
const string TagDescriptionOnError = "Description when TagStatusCode is Error.";
|
|
activity.SetStatus(ActivityStatusCode.Ok);
|
|
activity.SetTag(SpanAttributeConstants.StatusCodeKey, "ERROR");
|
|
activity.SetTag(SpanAttributeConstants.StatusDescriptionKey, TagDescriptionOnError);
|
|
|
|
// Enrich activity with additional tags.
|
|
activity.SetTag("myCustomTag", "myCustomTagValue");
|
|
|
|
// Act.
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert.
|
|
Assert.Equal("OK", jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
|
|
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == "otel.status_code" && t.VStr == "OK");
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == "otel.status_code" && t.VStr == "ERROR");
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName);
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == SpanAttributeConstants.StatusDescriptionKey &&
|
|
t.VType == JaegerTagType.STRING && t.VStr.Equals(TagDescriptionOnError));
|
|
|
|
// Ensure additional Activity tags were being converted.
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == "myCustomTag" && t.VStr == "myCustomTagValue");
|
|
}
|
|
|
|
[Fact]
|
|
public void ActivityStatus_Takes_precedence_Over_Status_Tags_ActivityStatusCodeIsError()
|
|
{
|
|
// Arrange.
|
|
using var activity = CreateTestActivity();
|
|
const string StatusDescriptionOnError = "Description when ActivityStatusCode is Error.";
|
|
activity.SetStatus(ActivityStatusCode.Error, StatusDescriptionOnError);
|
|
activity.SetTag(SpanAttributeConstants.StatusCodeKey, "OK");
|
|
|
|
// Enrich activity with additional tags.
|
|
activity.SetTag("myCustomTag", "myCustomTagValue");
|
|
|
|
// Act.
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert.
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == "otel.status_code" && t.VStr == "ERROR");
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName);
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == SpanAttributeConstants.StatusDescriptionKey &&
|
|
t.VType == JaegerTagType.STRING && t.VStr.Equals(StatusDescriptionOnError));
|
|
|
|
Assert.DoesNotContain(jaegerSpan.Tags, t => t.Key == "otel.status_code" && t.VStr == "OK");
|
|
|
|
// Ensure additional Activity tags were being converted.
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == "myCustomTag" && t.VStr == "myCustomTagValue");
|
|
}
|
|
|
|
[Fact]
|
|
public void ActivityDescription_Takes_precedence_Over_Status_Tags_When_ActivityStatusCodeIsError()
|
|
{
|
|
// Arrange.
|
|
using var activity = CreateTestActivity();
|
|
|
|
const string StatusDescriptionOnError = "Description when ActivityStatusCode is Error.";
|
|
const string TagDescriptionOnError = "Description when TagStatusCode is Error.";
|
|
activity.SetStatus(ActivityStatusCode.Error, StatusDescriptionOnError);
|
|
activity.SetTag(SpanAttributeConstants.StatusCodeKey, "ERROR");
|
|
activity.SetTag(SpanAttributeConstants.StatusDescriptionKey, TagDescriptionOnError);
|
|
|
|
// Enrich activity with additional tags.
|
|
activity.SetTag("myCustomTag", "myCustomTagValue");
|
|
|
|
// Act.
|
|
var jaegerSpan = activity.ToJaegerSpan();
|
|
|
|
// Assert.
|
|
Assert.Equal("ERROR", jaegerSpan.Tags.FirstOrDefault(t => t.Key == SpanAttributeConstants.StatusCodeKey).VStr);
|
|
|
|
Assert.Contains(
|
|
jaegerSpan.Tags, t =>
|
|
t.Key == JaegerActivityExtensions.JaegerErrorFlagTagName &&
|
|
t.VType == JaegerTagType.BOOL && (t.VBool ?? false));
|
|
|
|
Assert.Contains(
|
|
jaegerSpan.Tags, t =>
|
|
t.Key == SpanAttributeConstants.StatusDescriptionKey &&
|
|
t.VType == JaegerTagType.STRING && t.VStr.Equals(StatusDescriptionOnError));
|
|
|
|
// Ensure additional Activity tags were being converted.
|
|
Assert.Contains(jaegerSpan.Tags, t => t.Key == "myCustomTag" && t.VStr == "myCustomTagValue");
|
|
}
|
|
|
|
internal static Activity CreateTestActivity(
|
|
bool setAttributes = true,
|
|
Dictionary<string, object> additionalAttributes = null,
|
|
bool addEvents = true,
|
|
bool addLinks = true,
|
|
Resource resource = null,
|
|
ActivityKind kind = ActivityKind.Client,
|
|
bool isRootSpan = false,
|
|
Status? status = null,
|
|
long ticksToAdd = 60 * TimeSpan.TicksPerSecond)
|
|
{
|
|
var startTimestamp = DateTime.UtcNow;
|
|
var endTimestamp = startTimestamp.AddTicks(ticksToAdd);
|
|
var eventTimestamp = DateTime.UtcNow;
|
|
var traceId = ActivityTraceId.CreateFromString("e8ea7e9ac72de94e91fabc613f9686b2".AsSpan());
|
|
|
|
var parentSpanId = isRootSpan ? default : ActivitySpanId.CreateFromBytes(new byte[] { 12, 23, 34, 45, 56, 67, 78, 89 });
|
|
|
|
var attributes = new Dictionary<string, object>
|
|
{
|
|
{ "exceptionFromToString", new MyToStringMethodThrowsAnException() },
|
|
{ "exceptionFromToStringInArray", new MyToStringMethodThrowsAnException[] { new MyToStringMethodThrowsAnException() } },
|
|
{ "stringKey", "value" },
|
|
{ "longKey", 1L },
|
|
{ "longKey2", 1 },
|
|
{ "doubleKey", 1D },
|
|
{ "doubleKey2", 1F },
|
|
{ "boolKey", true },
|
|
{ "int_array", new int[] { 1, 2 } },
|
|
{ "bool_array", new bool[] { true, false } },
|
|
{ "double_array", new double[] { 1.0, 1.1 } },
|
|
{ "string_array", new string[] { "a", "b" } },
|
|
{ "obj_array", new object[] { 1, false, new object(), "string", string.Empty, null } },
|
|
};
|
|
if (additionalAttributes != null)
|
|
{
|
|
foreach (var attribute in additionalAttributes)
|
|
{
|
|
attributes.Add(attribute.Key, attribute.Value);
|
|
}
|
|
}
|
|
|
|
var events = new List<ActivityEvent>
|
|
{
|
|
new ActivityEvent(
|
|
"Event1",
|
|
eventTimestamp,
|
|
new ActivityTagsCollection(new Dictionary<string, object>
|
|
{
|
|
{ "key", "value" },
|
|
{ "string_array", new string[] { "a", "b" } },
|
|
})),
|
|
new ActivityEvent(
|
|
"Event2",
|
|
eventTimestamp,
|
|
new ActivityTagsCollection(new Dictionary<string, object>
|
|
{
|
|
{ "key", "value" },
|
|
})),
|
|
};
|
|
|
|
var linkedSpanId = ActivitySpanId.CreateFromString("888915b6286b9c41".AsSpan());
|
|
|
|
using var activitySource = new ActivitySource(nameof(CreateTestActivity));
|
|
|
|
var tags = setAttributes ?
|
|
attributes
|
|
: null;
|
|
var links = addLinks ?
|
|
new[]
|
|
{
|
|
new ActivityLink(new ActivityContext(
|
|
traceId,
|
|
linkedSpanId,
|
|
ActivityTraceFlags.Recorded)),
|
|
}
|
|
: null;
|
|
|
|
using var activity = activitySource.StartActivity(
|
|
"Name",
|
|
kind,
|
|
parentContext: new ActivityContext(traceId, parentSpanId, ActivityTraceFlags.Recorded),
|
|
tags,
|
|
links,
|
|
startTime: startTimestamp);
|
|
|
|
if (addEvents)
|
|
{
|
|
foreach (var evnt in events)
|
|
{
|
|
activity.AddEvent(evnt);
|
|
}
|
|
}
|
|
|
|
if (status.HasValue)
|
|
{
|
|
activity.SetStatus(status.Value);
|
|
}
|
|
|
|
activity.SetEndTime(endTimestamp);
|
|
activity.Stop();
|
|
|
|
return activity;
|
|
}
|
|
|
|
private static long TimeSpanToMicroseconds(TimeSpan timeSpan)
|
|
{
|
|
return timeSpan.Ticks / (TimeSpan.TicksPerMillisecond / 1000);
|
|
}
|
|
|
|
public class RemoteEndpointPriorityTestCase
|
|
{
|
|
public string Name { get; set; }
|
|
|
|
public string ExpectedResult { get; set; }
|
|
|
|
public Dictionary<string, object> RemoteEndpointAttributes { get; set; }
|
|
|
|
public static IEnumerable<object[]> GetTestCases()
|
|
{
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "Highest priority name = net.peer.name",
|
|
ExpectedResult = "RemoteServiceName",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
["http.host"] = "DiscardedRemoteServiceName",
|
|
["net.peer.name"] = "RemoteServiceName",
|
|
["peer.hostname"] = "DiscardedRemoteServiceName",
|
|
},
|
|
},
|
|
};
|
|
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "Highest priority name = SemanticConventions.AttributePeerService",
|
|
ExpectedResult = "RemoteServiceName",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
[SemanticConventions.AttributePeerService] = "RemoteServiceName",
|
|
["http.host"] = "DiscardedRemoteServiceName",
|
|
["net.peer.name"] = "DiscardedRemoteServiceName",
|
|
["net.peer.port"] = "1234",
|
|
["peer.hostname"] = "DiscardedRemoteServiceName",
|
|
},
|
|
},
|
|
};
|
|
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "Only has net.peer.name and net.peer.port",
|
|
ExpectedResult = "RemoteServiceName:1234",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
["net.peer.name"] = "RemoteServiceName",
|
|
["net.peer.port"] = "1234",
|
|
},
|
|
},
|
|
};
|
|
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "net.peer.port is an int",
|
|
ExpectedResult = "RemoteServiceName:1234",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
["net.peer.name"] = "RemoteServiceName",
|
|
["net.peer.port"] = 1234,
|
|
},
|
|
},
|
|
};
|
|
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "Has net.peer.name and net.peer.port",
|
|
ExpectedResult = "RemoteServiceName:1234",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
["http.host"] = "DiscardedRemoteServiceName",
|
|
["net.peer.name"] = "RemoteServiceName",
|
|
["net.peer.port"] = "1234",
|
|
["peer.hostname"] = "DiscardedRemoteServiceName",
|
|
},
|
|
},
|
|
};
|
|
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "Has net.peer.ip and net.peer.port",
|
|
ExpectedResult = "1.2.3.4:1234",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
["http.host"] = "DiscardedRemoteServiceName",
|
|
["net.peer.ip"] = "1.2.3.4",
|
|
["net.peer.port"] = "1234",
|
|
["peer.hostname"] = "DiscardedRemoteServiceName",
|
|
},
|
|
},
|
|
};
|
|
|
|
yield return new object[]
|
|
{
|
|
new RemoteEndpointPriorityTestCase
|
|
{
|
|
Name = "Has net.peer.name, net.peer.ip, and net.peer.port",
|
|
ExpectedResult = "RemoteServiceName:1234",
|
|
RemoteEndpointAttributes = new Dictionary<string, object>
|
|
{
|
|
["http.host"] = "DiscardedRemoteServiceName",
|
|
["net.peer.name"] = "RemoteServiceName",
|
|
["net.peer.ip"] = "1.2.3.4",
|
|
["net.peer.port"] = "1234",
|
|
["peer.hostname"] = "DiscardedRemoteServiceName",
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return this.Name;
|
|
}
|
|
}
|
|
|
|
private class MyToStringMethodThrowsAnException
|
|
{
|
|
public override string ToString()
|
|
{
|
|
throw new Exception("Nope.");
|
|
}
|
|
}
|
|
}
|
|
}
|