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