public async Task Send(ConsumeContext context, IPipe <ConsumeContext> next)
{
DeimosOptions options = GetDeimosOptions();
if (options is null || !options.Enabled)
{
return;
}
if (GlobalTracer.Instance is null)
{
return;
}
var operationName = $"Consuming Message: {context.DestinationAddress.GetExchangeName()}";
ISpanBuilder spanBuilder;
ITracer tracer = GlobalTracer.Instance;
try
{
ISpanContext parentSpanCtx = ExtractTraceContext(tracer, ExtractMessageHeaders(context));
spanBuilder = CreateSpan(tracer, operationName, parentSpanCtx);
}
catch (Exception e)
{
spanBuilder = GlobalTracer.Instance.BuildSpan(operationName)
.WithTag(Tags.Error, true)
.WithTag("message", e.Message)
.WithTag("context", "Error while extracting message headers or creating the tracing span.")
.WithTag("Type", e.GetType().ToString());
}
spanBuilder
.WithTag("message.types", string.Join(", ", context.SupportedMessageTypes))
.WithTag("source.host.transit.version", context.Host.MassTransitVersion)
.WithTag("source.host.process.id", context.Host.ProcessId)
.WithTag("source.host.framework.version", context.Host.FrameworkVersion)
.WithTag("source.host.machine", context.Host.MachineName)
.WithTag("input.address", context.ReceiveContext.InputAddress.ToString())
.WithTag("destination.address", context.DestinationAddress?.ToString())
.WithTag("source.address", context.SourceAddress?.ToString())
.WithTag("initiator.id", context.InitiatorId?.ToString())
.WithTag("message.id", context.MessageId?.ToString());
using (IScope scope = spanBuilder.StartActive(true))
{
try
{
await next.Send(context);
}
catch (Exception e)
{
scope.Span.SetTag(Tags.Error, true);
scope.Span.SetTag("context", "Error while sending message through the masstransit pipe.");
scope.Span.Log(ExtractExceptionInfo(e));
}
}
}
private static void ConfigureHttpIn(ISolariBuilder builder, DeimosOptions options)
{
builder.Services.AddOpenTracing(build => build.ConfigureAspNetCore(diagnosticOptions =>
{
ConfigureHttpInRequestFiltering(diagnosticOptions, options);
diagnosticOptions.Hosting.ExtractEnabled = message => true;
DeimosLogger.JaegerLogger.ConfiguredHttpIn();
}));
}
public static ISolariBuilder AddJaeger(ISolariBuilder solariBuilder, DeimosOptions options)
{
if (!options.Enabled)
{
return(solariBuilder);
}
ConfigureHttpOut(solariBuilder, options);
ConfigureHttpIn(solariBuilder, options);
ConfigureTracer(solariBuilder, options.Jaeger);
return(solariBuilder);
}
private static void ConfigureHttpOut(ISolariBuilder builder, DeimosOptions options)
{
builder.Services.PostConfigure <HttpHandlerDiagnosticOptions>(conf =>
{
conf.InjectEnabled = message => true;
foreach (string httpIgnoredEndpoint in options.Http.IgnoredOutEndpoints)
{
conf.IgnorePatterns.Add(context => context.RequestUri.OriginalString.Contains(httpIgnoredEndpoint));
}
DeimosLogger.JaegerLogger.ConfiguredHttpOut();
});
}
private static void ConfigureHttpInRequestFiltering(AspNetCoreDiagnosticOptions diagnosticOptions, DeimosOptions options)
{
if (options == null)
{
return;
}
foreach (string httpIgnoredEndpoint in options.Http.IgnoredInEndpoints)
{
DeimosLogger.JaegerLogger.ConfigureRequestFiltering(httpIgnoredEndpoint);
diagnosticOptions.Hosting.IgnorePatterns.Add(context => context.Request.Path
.ToUriComponent()
.Contains(PathString.FromUriComponent(httpIgnoredEndpoint)));
}
}
private static void ConfigureTracing(ISolariBuilder solariBuilder, DeimosOptions options)
{
solariBuilder.AddDeimosCorrelationId(options.Http.UseMiddleware);
JaegerTracerConfiguration.AddJaeger(solariBuilder, options);
}
