public async void InMemory()
{
var counter = new FaultCounter();
var harness = new InMemoryTestHarness();
try
{
harness.OnConfigureInMemoryBus += cfg =>
cfg.UseRetry(x =>
{
x.Immediate(1);
x.ConnectRetryObserver(new RetryObserver(counter));
});
harness.OnConfigureInMemoryReceiveEndpoint += cfg => harness.Handler <PingMessage>(cfg, ctx => throw new Exception());
await harness.Start();
var faultHandlerTask = harness.SubscribeHandler <Fault <PingMessage> >();
await harness.InputQueueSendEndpoint.Send(new PingMessage(), ctx =>
{
ctx.ResponseAddress = harness.BusAddress;
ctx.FaultAddress = harness.BusAddress;
});
await faultHandlerTask;
Assert.Equal(1, counter.Faults);
}
finally
{
await harness.Stop();
}
}
public async Task MassTransitInstrumentationConsumerAndHandlerTest()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation()
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new
{
Text = "Hello, world!",
});
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
}
Assert.Equal(10, activityProcessor.Invocations.Count);
var sends = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Send);
var receives = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Receive);
var consumes = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Consume);
var handles = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Handle);
foreach (var activity in sends)
{
Assert.Equal("SEND /input_queue", activity.DisplayName);
}
foreach (var activity in receives)
{
Assert.Equal("RECV /input_queue", activity.DisplayName);
}
foreach (var activity in consumes)
{
Assert.Equal("CONSUME OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests.TestConsumer", activity.DisplayName);
}
foreach (var activity in handles)
{
Assert.Equal("HANDLE TestMessage/OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests", activity.DisplayName);
}
}
public async Task A_handler_responds_to_a_message()
{
_harness = new InMemoryTestHarness();
_handler = _harness.Handler <A>(async context => context.Respond(new B()));
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A(), x => x.ResponseAddress = _harness.BusAddress);
}
public async Task ShouldMapMassTransitTagsForReceiveMessageToOpenTelemetrySpecification()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation()
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new { Text = "Hello, world!" });
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
var expectedMessageContext = harness.Sent.Select <TestMessage>().FirstOrDefault()?.Context;
var actualActivity = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Receive).LastOrDefault();
Assert.NotNull(actualActivity);
Assert.NotNull(expectedMessageContext);
Assert.Equal("/input_queue consume", actualActivity.DisplayName);
Assert.Equal(ActivityKind.Consumer, actualActivity.Kind);
Assert.Equal("loopback", actualActivity.GetTagValue(SemanticConventions.AttributeMessagingSystem)?.ToString());
Assert.Equal(expectedMessageContext.MessageId.ToString(), actualActivity.GetTagValue(SemanticConventions.AttributeMessagingMessageId)?.ToString());
Assert.Equal(expectedMessageContext.ConversationId.ToString(), actualActivity.GetTagValue(SemanticConventions.AttributeMessagingConversationId)?.ToString());
Assert.Equal(expectedMessageContext.DestinationAddress.AbsolutePath, actualActivity.GetTagValue(SemanticConventions.AttributeMessagingDestination)?.ToString());
Assert.Equal(expectedMessageContext.DestinationAddress.Host, actualActivity.GetTagValue(SemanticConventions.AttributeNetPeerName)?.ToString());
Assert.Null(actualActivity.GetTagValue(TagName.MessageId));
Assert.Null(actualActivity.GetTagValue(TagName.ConversationId));
Assert.Null(actualActivity.GetTagValue(TagName.DestinationAddress));
Assert.Null(actualActivity.GetTagValue(TagName.SpanKind));
Assert.Null(actualActivity.GetTagValue(TagName.PeerService));
Assert.Null(actualActivity.GetTagValue(TagName.PeerAddress));
Assert.Null(actualActivity.GetTagValue(TagName.PeerHost));
Assert.Null(actualActivity.GetTagValue(TagName.MessageTypes));
Assert.Null(actualActivity.GetTagValue(TagName.SourceAddress));
Assert.Null(actualActivity.GetTagValue(TagName.SourceHostMachine));
}
}
public async Task Setup()
{
_harness = new InMemoryTestHarness();
_handler = _harness.Handler <A>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
await _harness.InputQueueSendEndpoint.Send(new B());
}
public async Task Setup()
{
_harness = new InMemoryTestHarness();
_handler = _harness.Handler <A>();
await _harness.Start();
await _harness.Bus.Publish(new A());
await _harness.Bus.Publish(new B());
}
public async Task InitializeAsync()
{
_bus = new InMemoryTestHarness {
TestTimeout = TimeSpan.FromSeconds(2)
};
_handler = _bus.Handler <TestMessage>();
_bus.OnConfigureBus += cfg =>
{
cfg.UseSerilog();
cfg.AddJsonQueueTableSqlServerGateway(_dbFixture.TableName,
_dbFixture.GetConnection,
TimeSpan.FromMilliseconds(100));
};
await _bus.Start();
}
public async Task MassTransitInstrumentationTestOptions()
{
using Activity activity = new Activity("Parent");
activity.SetParentId(
ActivityTraceId.CreateRandom(),
ActivitySpanId.CreateRandom(),
ActivityTraceFlags.Recorded);
activity.Start();
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation(o =>
o.TracedOperations = new HashSet <string>(new[] { OperationName.Consumer.Consume }))
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new
{
Text = "Hello, world!",
});
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
}
Assert.Equal(4, activityProcessor.Invocations.Count);
var consumes = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Consume);
Assert.Equal(2, consumes.Count());
}
public async Task ShouldMapMassTransitTagsForConsumeMessageToOpenTelemetrySpecification()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation()
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new { Text = "Hello, world!" });
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
var expectedMessageContext = harness.Sent.Select <TestMessage>().FirstOrDefault()?.Context;
var actualActivity = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Consume).LastOrDefault();
Assert.NotNull(actualActivity);
Assert.NotNull(expectedMessageContext);
Assert.Equal("OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests.TestConsumer process", actualActivity.DisplayName);
Assert.Equal(ActivityKind.Internal, actualActivity.Kind);
Assert.Equal("OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests.TestConsumer", actualActivity.GetTagValue(MassTransitSemanticConventions.AttributeMessagingMassTransitConsumerType)?.ToString());
Assert.Null(actualActivity.GetTagValue(TagName.SpanKind));
Assert.Null(actualActivity.GetTagValue(TagName.PeerService));
Assert.Null(actualActivity.GetTagValue(TagName.PeerAddress));
Assert.Null(actualActivity.GetTagValue(TagName.PeerHost));
}
}
public async Task ShouldMapMassTransitTagsWhenIntrumentationIsSuppressed()
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation()
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
using var scope = SuppressInstrumentationScope.Begin();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new { Text = "Hello, world!" });
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
var expectedMessageContext = harness.Sent.Select <TestMessage>().FirstOrDefault()?.Context;
Assert.NotNull(expectedMessageContext);
}
// Since instrumentation is suppressed, activiy is not emitted
Assert.Equal(3, activityProcessor.Invocations.Count); // SetParentProvider + OnShutdown + Dispose
// Processor.OnStart and Processor.OnEnd are not called
Assert.DoesNotContain(activityProcessor.Invocations, invo => invo.Method.Name == nameof(activityProcessor.Object.OnStart));
Assert.DoesNotContain(activityProcessor.Invocations, invo => invo.Method.Name == nameof(activityProcessor.Object.OnEnd));
}
public async Task ShouldMapMassTransitTagsWhenIntrumentationWhenSampled(SamplingDecision samplingDecision, bool isActivityExpected)
{
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using (Sdk.CreateTracerProviderBuilder()
.SetSampler(new TestSampler()
{
SamplingAction = (samplingParameters) => new SamplingResult(samplingDecision)
})
.AddProcessor(activityProcessor.Object)
.AddMassTransitInstrumentation()
.Build())
{
var harness = new InMemoryTestHarness();
var consumerHarness = harness.Consumer <TestConsumer>();
var handlerHarness = harness.Handler <TestMessage>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send <TestMessage>(new { Text = "Hello, world!" });
Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any());
Assert.True(await handlerHarness.Consumed.SelectAsync().Any());
}
finally
{
await harness.Stop();
}
var expectedMessageContext = harness.Sent.Select <TestMessage>().FirstOrDefault()?.Context;
Assert.NotNull(expectedMessageContext);
}
Assert.Equal(isActivityExpected, activityProcessor.Invocations.Any(invo => invo.Method.Name == nameof(activityProcessor.Object.OnStart)));
Assert.Equal(isActivityExpected, activityProcessor.Invocations.Any(invo => invo.Method.Name == nameof(activityProcessor.Object.OnEnd)));
}
