/// <summary>
/// Обработка вернувшихся сообщений
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void OnMessageReturned(object sender, EasyNetQ.MessageReturnedEventArgs args)
{
var stringDictionary = args.MessageProperties.Headers.ToDictionary(x => x.Key, x => Encoding.UTF8.GetString((byte[])x.Value));
var textMapExtractAdapter = new TextMapExtractAdapter(stringDictionary);
var spanContext = _tracer.Extract(BuiltinFormats.HttpHeaders, textMapExtractAdapter);
using (_tracer.BuildSpan(nameof(OnMessageReturned)).AddReference(References.ChildOf, spanContext).StartActive(true))
using (_logger.BeginScope(new[] { new KeyValuePair <string, object>(nameof(_tracer.ActiveSpan.Context.TraceId), _tracer.ActiveSpan.Context.TraceId) }))
{
_tracer.ActiveSpan.SetTag(Tags.Error, true);
if (args.MessageProperties.Headers.TryGetValue(MessageKeyHeader, out var bytes) && bytes is byte[] value)
{
var key = Encoding.UTF8.GetString(value);
_logger.LogError("Message returned {Exchange} {RoutingKey} reason {ReturnReason} {Key}",
args.MessageReturnedInfo.Exchange,
args.MessageReturnedInfo.RoutingKey,
args.MessageReturnedInfo.ReturnReason,
key);
MessageReturned?.Invoke(new MessageReturnedEventArgs(key));
}
else
{
_logger.LogError("Can not get error message filename");
}
}
}
private IScope BeforeWrappedMethod(string name, ILambdaContext lambdaContext, ISpanContext distributedTraceContext, object input = null)
{
// Should we use _tracer.ScopeManager.Active instead? It returns null if none is active;
IScope scope = null;
try
{
var tags = IOParser.ParseRequest(input);
var extractAdapter = new TextMapExtractAdapter(tags);
var spanContext = distributedTraceContext ?? _tracer.Extract(BuiltinFormats.TextMap, extractAdapter);
tags.Remove("newrelic");
scope = _tracer
.BuildSpan(name)
.AsChildOf(spanContext)
.WithTag("aws.requestId", lambdaContext.AwsRequestId ?? string.Empty)
.WithTag("aws.arn", lambdaContext.InvokedFunctionArn ?? string.Empty)
.StartActive();
DetectColdStart(scope, ref _isColdStart);
if (input != null)
{
AddTagsToActiveSpan(scope.Span, "request", tags);
}
}
catch (Exception exception)
{
Logger.Log(message: exception.ToString(), level: "ERROR");
}
return(scope);
}
private static IScope StartServerSpan(ITracer tracer, IDictionary <string, string> headers, string operationName)
{
if (tracer != null)
{
ISpanBuilder spanBuilder;
try
{
ISpanContext parentSpanCtx =
tracer.Extract(BuiltinFormats.HttpHeaders, new TextMapExtractAdapter(headers));
spanBuilder = tracer.BuildSpan(operationName);
if (parentSpanCtx != null)
{
spanBuilder = spanBuilder.AsChildOf(parentSpanCtx);
}
}
catch (Exception)
{
spanBuilder = tracer.BuildSpan(operationName);
}
return(spanBuilder.StartActive(true));
}
return(null);
}
/// <summary>
/// 开始执行Action
/// </summary>
/// <param name="context"></param>
public void OnActionExecuting(ActionExecutingContext context)
{
var path = context.HttpContext.Request.Path;
var callingHeaders = new TextMapExtractAdapter(context.HttpContext.Request.Headers.ToDictionary(m => m.Key, m => m.Value.ToString()));
var spanContex = _tracer.Extract(BuiltinFormats.HttpHeaders, callingHeaders);
ISpanBuilder builder = null;
if (spanContex != null)
{
builder = _tracer.BuildSpan("中间件Span").AsChildOf(spanContex);
}
else
{
builder = _tracer.BuildSpan("中间件Span");
}
_scope = builder.StartActive(true);
_scope.Span.SetOperationName(path);
// 记录请求信息到span
foreach (var query in context.HttpContext.Request.Query)
{
_scope.Span.SetTag(query.Key, query.Value);
}
if (context.HttpContext.Request.HasFormContentType)
{
foreach (var form in context.HttpContext.Request.Form)
{
_scope.Span.SetTag(form.Key, form.Value);
}
}
}
public async Task InvokeAsync(HttpContext context)
{
HttpRequest request = context.Request;
ISpanContext extractedSpanContext = _tracer.Extract(BuiltinFormats.HttpHeaders, new RequestHeadersExtractAdapter(request.Headers));
string operationName = "HTTP " + request.Method;
IScope scope = _tracer.BuildSpan(operationName)
.AsChildOf(extractedSpanContext)
.WithTag(Tags.Component, "ICH.WebAPI")
.WithTag(Tags.SpanKind, Tags.SpanKindServer)
.WithTag(Tags.HttpMethod, request.Method)
.WithTag(Tags.HttpUrl, GetDisplayUrl(request))
.StartActive();
context.Response.Headers["traceid"] = new StringValues(scope.Span.Context.TraceId);
try
{
await _next(context);
scope.Span.SetTag(Tags.HttpStatus, context.Response.StatusCode);
scope.Dispose();
}
catch (Exception e)
{
scope.Span.SetException(e);
scope.Dispose();
await HandleException(context, e);
}
}
private EventHandler <MsgHandlerEventArgs> Consumer_Received()
{
return(async(sender, args) =>
{
var eventName = args.Message.Subject;
var message = Encoding.UTF8.GetString(args.Message.Data);
var eventType = _subsManager.GetEventTypeByName(eventName);
var integrationEvent = JsonSerializer.Deserialize(message, eventType) as IntegrationEvent;
ISpanContext spanCtx = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(integrationEvent.TracingKeys));
using var tracingScope = _tracer.BuildSpan($"EventBus-Consume-{eventName}")
.AsChildOf(spanCtx)
.WithTag(Tags.SpanKind, Tags.SpanKindConsumer)
.StartActive(finishSpanOnDispose: true);
try
{
await ProcessEvent(eventName, message);
}
catch (Exception ex)
{
tracingScope.Span.SetTag(Tags.Error, true);
tracingScope.Span.Log(ex.Message);
_logger.LogWarning(ex, "----- ERROR Processing message \"{Message}\"", message);
}
});
}
public EndMethodDelegate BeforeWrappedMethod(TraceMethodInfo traceMethodInfo)
{
if (HttpRuntime.UsingIntegratedPipeline)
{
HttpContext context = (traceMethodInfo.InvocationTarget as HttpApplication)?.Context;
if (context != null)
{
if (context.Items["ClrProfiler.Trace.AspNet.TraceScope"] == null)
{
var extractedSpanContext = _tracer.Extract(BuiltinFormats.HttpHeaders, new RequestHeadersExtractAdapter(context.Request.Headers));
var scope = _tracer.BuildSpan("http.in")
.AsChildOf(extractedSpanContext)
.WithTag(Tags.SpanKind, Tags.SpanKindServer)
.WithTag(Tags.Component, "AspNet")
.WithTag(Tags.HttpMethod, context.Request.HttpMethod)
.WithTag(Tags.HttpUrl, context.Request.Path.ToString())
.WithTag(Tags.PeerHostname, context.Request.UserHostName)
.StartActive();
context.Items["ClrProfiler.Trace.AspNet.TraceScope"] = scope;
}
}
}
return(null);
}
public async Task Invoke(MessagingContext context, CancellationToken cancellationToken, Func <Task> next)
{
var extractedSpanContext = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(context.MessagingEnvelope.Headers));
string operationName = $"Subscriber {context.MessagingEnvelope.Payload.GetType().GetPrettyName()}";
using (var scope = _tracer.BuildSpan(operationName)
.AddReference(References.FollowsFrom, extractedSpanContext)
.WithTag(Tags.Component, "NBB.Messaging")
.WithTag(Tags.SpanKind, Tags.SpanKindConsumer)
.WithTag(Tags.PeerService,
context.MessagingEnvelope.Headers.TryGetValue(MessagingHeaders.Source, out var value) ? value : default)
.WithTag("correlationId", CorrelationManager.GetCorrelationId()?.ToString())
.StartActive(true))
{
try
{
await next();
}
catch (Exception exception)
{
scope.Span.SetException(exception);
throw;
}
}
}
public IScope CreateServerSpan(ServerCallContext context)
{
_ = context ?? throw new ArgumentNullException(nameof(context));
var operationName = context.Method.Split('/').Last();
ISpanBuilder spanBuilder = null;
try
{
var headers = context.RequestHeaders.ToDictionary(x => x.Key, x => x.Value);
ISpanContext parentSpanCtx = _tracer.Extract(BuiltinFormats.HttpHeaders, new TextMapExtractAdapter(headers));
spanBuilder = _tracer.BuildSpan(operationName);
spanBuilder = parentSpanCtx != null?spanBuilder.AsChildOf(parentSpanCtx) : spanBuilder;
}
finally
{
if (spanBuilder == null)
{
spanBuilder = _tracer.BuildSpan(operationName);
}
}
return
(spanBuilder
.WithTag(Tags.SpanKind, Tags.SpanKindServer)
.WithTag(Tags.PeerHostname, context.Host)
.WithTag("correlation-id", GetCorrelationId())
.StartActive(true));
}
private IScope BuildServerScope(HttpContext context)
{
ISpanBuilder spanBuilder = null;
var operationName = GetOperationName(context);
var requestTraceHeaders = context.GetTraceHeaders();
if (requestTraceHeaders?.Any() ?? false)
{
try
{
spanBuilder = _tracer.BuildSpan(operationName);
var parentSpanContext = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(requestTraceHeaders));
if (parentSpanContext != null)
{
spanBuilder = spanBuilder.AsChildOf(parentSpanContext);
}
}
catch { }
}
if (spanBuilder == null)
{
spanBuilder = _tracer.BuildSpan(operationName);
}
return(spanBuilder.WithTag(Tags.SpanKind, Tags.SpanKindServer).StartActive(true));
}
public static ISpanBuilder ObtainConsumerSpanBuilder(ITracer tracer, Headers headers, string spanName)
{
// See if we have a trace header
IHeader traceHeader = null;
// For whatever insane reason this linq query is not working ??
//traceHeader = cr.Message.Headers.FirstOrDefault(p => p.Key == "tracing-id");
foreach (var header in headers)
{
bool isKey = header.Key == "tracing-id";
if (isKey)
{
traceHeader = header;
break;
}
}
ISpanBuilder spanBuilder;
if (traceHeader != null)
{
var map = KafkaTracingContextHelper.Decode(traceHeader.GetValueBytes());
var ctx = tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(map));
spanBuilder = tracer.BuildSpan(spanName)
.WithTag(Tags.SpanKind.Key, Tags.SpanKindConsumer)
.AsChildOf(ctx);
}
else
{
spanBuilder = tracer.BuildSpan(spanName)
.WithTag(Tags.SpanKind.Key, Tags.SpanKindConsumer);
}
return(spanBuilder);
}
internal static async Task Receive(MessageEnvelope envelope, SpanSetup receiveSpanSetup, ITracer tracer, Func <Task> receive)
{
var message = envelope.Message;
var parentSpanCtx = envelope.Header != null
? tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(envelope.Header.ToDictionary()))
: null;
using (var scope = tracer.BuildStartedScope(parentSpanCtx, nameof(Receive), message, receiveSpanSetup))
{
try
{
var span = scope.Span;
if (envelope.Sender != null)
{
ProtoTags.SenderPID.Set(span, envelope.Sender.ToShortString());
}
receiveSpanSetup?.Invoke(span, message);
await receive().ConfigureAwait(false);
}
catch (Exception ex)
{
ex.SetupSpan(scope.Span);
throw;
}
}
}
private static IScope GetScope(ActionExecutingContext context, ITracer tracer, OpenTracingOptions options)
{
//get spanContext
ISpanContext spanContext;
if (context.Header == null)
{
spanContext = null;
}
else
{
spanContext = tracer.Extract(BuiltinFormats.HttpHeaders, new RequestHeadersExtractAdapter(context.Header));
}
//get scope
IScope scope;
if (spanContext == null)
{
scope = tracer.BuildSpan($"{context.ContractMethod.MethodInfo.Name} {ConstValue.ReceiveStr}")
.StartActive(true);
}
else
{
scope = tracer.BuildSpan($"{context.ContractMethod.MethodInfo.Name} {ConstValue.ReceiveStr}")
.AsChildOf(spanContext).StartActive(true);
spanContext.CopyBaggageItemsTo(scope.Span);
}
return(scope);
}
public IScope AroundReceive(IActorContext context, TracedMessage tracedMessage, Type actorType)
{
var actorPath = context.Self.Path.ToString().Substring(context.Self.Path.Address.ToString().Length);
string operationName = $"{actorPath}:{tracedMessage.Message.GetType().Name}";
string parent = "no";
var builder = _tracer.BuildSpan(operationName);
if (tracedMessage.Span != null)
{
parent = tracedMessage.Span.Context.SpanId;
builder = builder.AsChildOf(tracedMessage.Span);
}
else if (tracedMessage.Context.Count != 0)
{
ISpanContext spanContext = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(tracedMessage.Context));
parent = spanContext.SpanId;
builder = builder.AsChildOf(spanContext);
}
IScope ret = builder.StartActive(true);
ret.Span.SetTag("sender.path", GetSenderPath(context.Sender));
ret.Span.SetTag("receiver.path", GetLocalActorPath(context.Self));
ret.Span.SetTag("receiver.type", actorType.ToString());
ret.Span.SetTag("message.type", tracedMessage.Message.GetType().ToString());
LocalLog($"> {context.Self.Path}.Tell({tracedMessage.Message}) Thread={Thread.CurrentThread.ManagedThreadId}, parent={parent}");
return(ret);
}
/// <summary>
/// 调用管道
/// </summary>
/// <param name="context">上下文</param>
/// <param name="tracer">跟踪器</param>
/// <returns></returns>
public async Task InvokeAsync(HttpContext context, ITracer tracer)
{
_logger.LogInformation("jaeger调用");
var path = context.Request.Path;
if (Path.HasExtension(path))
{
await _next(context);
}
else
{
//接收传入的Headers
var callingHeaders = new TextMapExtractAdapter(context.Request.Headers.ToDictionary(m => m.Key, m => m.Value.ToString()));
var spanContex = tracer.Extract(BuiltinFormats.HttpHeaders, callingHeaders);
ISpanBuilder builder = null;
if (spanContex != null)
{
builder = tracer.BuildSpan("中间件Span").AsChildOf(spanContex);
}
else
{
builder = tracer.BuildSpan("中间件Span");
}
//开始设置Span
using (IScope scope = builder.StartActive(true))
{
scope.Span.SetOperationName(path);
// 记录请求信息到span
if (_jaegerOptions.IsQuerySpan)
{
foreach (var query in context.Request.Query)
{
//包含敏感词跳出
if (_jaegerOptions.NoSpanKeys.Contains(query.Key))
{
continue;
}
var value = query.Value.ToString().Length > _jaegerOptions.QueryValueMaxLength ? query.Value.ToString()?.Substring(0, _jaegerOptions.QueryValueMaxLength) : query.Value.ToString();
scope.Span.SetTag(query.Key, value);
}
}
if (_jaegerOptions.IsFormSpan && context.Request.HasFormContentType)
{
foreach (var form in context.Request.Form)
{
//包含敏感词跳出
if (_jaegerOptions.NoSpanKeys.Contains(form.Key))
{
continue;
}
var value = form.Value.ToString().Length > _jaegerOptions.FormValueMaxLength ? form.Value.ToString()?.Substring(0, _jaegerOptions.FormValueMaxLength) : form.Value.ToString();
scope.Span.SetTag(form.Key, value);
}
}
await _next(context);
}
}
}
/// <summary>
/// Extracts the specified tracer.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="tracer">The tracer.</param>
/// <param name="headers">The headers.</param>
/// <returns></returns>
public static ISpanContext Extract(this IMessage message, ITracer tracer, IStandardHeaders headers)
{
if (message.Headers.ContainsKey(headers.TraceSpan.Name))
{
var mapping =
(DataMappingTextMap)message.Headers[headers.TraceSpan.Name];
return(tracer.Extract(BuiltinFormats.TextMap, mapping));
}
return(null);
}
/// <summary>
/// Extracts the specified tracer.
/// </summary>
/// <param name="inputHeaders">The input headers.</param>
/// <param name="tracer">The tracer.</param>
/// <param name="headers">The headers.</param>
/// <returns></returns>
public static ISpanContext Extract(this IDictionary <string, object> inputHeaders, ITracer tracer, IStandardHeaders headers)
{
if (inputHeaders.ContainsKey(headers.TraceSpan.Name))
{
var mapping =
(DataMappingTextMap)inputHeaders[headers.TraceSpan.Name];
return(tracer.Extract(BuiltinFormats.TextMap, mapping));
}
return(null);
}
public static ISpanContext?CreateSpanContextFromHeaders(this ITracer tracer,
IDictionary <string, object> headers)
{
if (headers == null)
{
return(null);
}
var dictionary = headers.ToDictionary(x => x.Key, x => Encoding.UTF8.GetString((byte[])x.Value));
return(tracer.Extract(BuiltinFormats.HttpHeaders, new TextMapExtractAdapter(dictionary)));
}
private void Process(Message message)
{
ISpanContext context = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(message));
using (IScope scope = _tracer.BuildSpan("receive")
.WithTag(Tags.SpanKind.Key, Tags.SpanKindServer)
.WithTag(Tags.Component.Key, "example-server")
.AsChildOf(context)
.StartActive(finishSpanOnDispose: true))
{
}
}
private static ISpanContext ExtractSpanContextOrDefault(
ITracer tracer,
ServerCallContext context,
ISpanContext defaultVal = null)
{
ISpanContext spanContext = defaultVal;
try {
var dict = MetadataToDictionary(context.RequestHeaders);
var adapter = new TextMapExtractAdapter(dict);
spanContext = tracer.Extract(BuiltinFormats.HttpHeaders, adapter);
} catch {}
return(spanContext);
}
protected ISpanBuilder CreateTracingSpanBuilder(string spanName, ITracer tracer, HttpRequest request)
{
var callingHeaders = new TextMapExtractAdapter(request.Headers.ToDictionary(m => m.Key, m => m.Value.ToString()));
var spanContex = tracer.Extract(BuiltinFormats.HttpHeaders, callingHeaders);
if (spanContex != null)
{
return(tracer.BuildSpan(spanName).AsChildOf(spanContex));
}
else
{
return(tracer.BuildSpan(spanName));
}
}
public static IScope CreateAndInjectActiveConsumerScopeFrom(this ITracer tracer, IDictionary <string, string> headers)
{
var spanBuilder = tracer.BuildSpan("receive")
.WithTag(Tags.SpanKind.Key, Tags.SpanKindConsumer);
var parentSpanContext = tracer.Extract(BuiltinFormats.TextMap,
new TextMapExtractAdapter(headers));
spanBuilder.AddReference(References.FollowsFrom, parentSpanContext);
var scope = spanBuilder.StartActive(true);
tracer.Inject(scope.Span.Context, BuiltinFormats.TextMap,
new TextMapInjectAdapter(headers));
return(scope);
}
public static IScope CreateAndInjectActiveProducerScopeFrom(this ITracer tracer, IDictionary <string, string> headers)
{
var spanBuilder = tracer.BuildSpan("send")
.WithTag(Tags.SpanKind.Key, Tags.SpanKindProducer);
var spanContext = tracer.Extract(BuiltinFormats.TextMap,
new TextMapExtractAdapter(headers));
spanBuilder.AsChildOf(spanContext);
var scope = spanBuilder.StartActive(true);
tracer.Inject(scope.Span.Context, BuiltinFormats.TextMap,
new TextMapInjectAdapter(headers));
return(scope);
}
public Videos Get(string id)
{
ISpanContext traceContext = _tracer.Extract(BuiltinFormats.HttpHeaders, new TextMapExtractAdapter(GetHeaders()));
string videoContent;
using (var scope = _tracer.BuildSpan("videos-api-net: redis-get")
.AsChildOf(traceContext)
.StartActive(true))
{
IDatabase db = _redis.GetDatabase();
videoContent = db.StringGet(id);
}
var video = JsonSerializer.Deserialize <Videos>(videoContent, _serializationOptions);
return(video);
}
public static ISpanContext Extract(IBasicProperties props, ITracer tracer)
{
var spanContext = tracer
.Extract(BuiltinFormats.TextMap, new HeadersMapExtractAdapter(props.Headers));
if (spanContext != null)
{
return(spanContext);
}
var span = tracer.ActiveSpan;
if (span != null)
{
return(span.Context);
}
return(null);
}
private ISpan BuildClientSpan <TRequest, TResponse>(ClientInterceptorContext <TRequest, TResponse> context) where TRequest : class where TResponse : class
{
var spanBuilder = tracer.BuildSpan(context.Method.FullName) //TODO: make an OperationNameConstructor configurable like in java impl?
.IgnoreActiveSpan()
.WithTag(Tags.SpanKind.Key, Tags.SpanKindClient)
.WithTag(Tags.PeerHostname.Key, context.Host)
.WithTag(Tags.PeerService.Key, context.Method.ServiceName)
.WithTag(GRPCTags.GrpcMethodName.Key, context.Method.FullName)
.WithTag(GRPCTags.GrpcMethodType.Key, context.Method.Type.ToString()); //TODO: Check this...
if (context.Options.Deadline.HasValue)
{
spanBuilder.WithTag(GRPCTags.GrpcDeadline.Key, (DateTime.Now - context.Options.Deadline).Value.Milliseconds);
}
ISpanContext spanContext = null;
if (context.Options.Headers != null)
{
// just in case if span context was injected manually to props in basicPublish
spanContext = tracer.Extract(BuiltinFormats.TextMap,
new HeadersMapExtractAdapter(context.Options.Headers));
}
if (spanContext == null)
{
var parentSpan = tracer.ActiveSpan;
if (parentSpan != null)
{
spanContext = parentSpan.Context;
}
}
if (spanContext != null)
{
spanBuilder.AsChildOf(spanContext);
}
var span = spanBuilder.Start();
SpanDecorator.OnRequest(span);
return(span);
}
public static IScope StartServerSpan(ITracer tracer, IDictionary <string, string> headers, string operationName)
{
ISpanBuilder spanBuilder;
try {
var parentSpanCtx = tracer.Extract(BuiltinFormats.HttpHeaders, new TextMapExtractAdapter(headers));
spanBuilder = tracer.BuildSpan(operationName);
if (parentSpanCtx != null)
{
spanBuilder = spanBuilder.AsChildOf(parentSpanCtx);
}
} catch (Exception) {
spanBuilder = tracer.BuildSpan(operationName);
}
// TODO could add more tags like http.url
return(spanBuilder.WithTag(Tags.SpanKind, Tags.SpanKindServer).StartActive(true));
}
internal static IScope StartSpanConsumer(this ITracer tracer, IDictionary <string, string> messageAttributes, string operationName)
{
ISpanBuilder spanBuilder;
try
{
ISpanContext spanContext = tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(messageAttributes));
spanBuilder = tracer.BuildSpan(operationName);
if (spanContext != null)
{
spanBuilder = spanBuilder.AsChildOf(spanContext);
}
}
catch (Exception)
{
spanBuilder = tracer.BuildSpan(operationName);
}
return(spanBuilder.WithTag(Tags.SpanKind, Tags.SpanKindConsumer).StartActive(true));
}
public static IScope StartSpan(
this ITracer tracer,
[CallerMemberName] string?callerMethodName = default,
[CallerFilePath] string?callerFilePath = default)
{
var operationName = GetOperationName(callerMethodName, callerFilePath);
var context = tracer.Extract(
format: BuiltinFormats.TextMap,
carrier: new TextMapExtractAdapter(_textMap));
if (context is null)
{
return(tracer.StartParentSpan(callerMethodName, callerFilePath));
}
return(tracer.BuildSpan(operationName)
.AsChildOf(context)
.StartActive());
}
public static IScope StartServerSpan(ITracer tracer, IDictionary <string, string> headers, string operationName)
{
ISpanBuilder spanBuilder;
try
{
ISpanContext parentSpanCtx = tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(headers));
spanBuilder = tracer.BuildSpan(operationName);
if (parentSpanCtx != null)
{
spanBuilder = spanBuilder.AsChildOf(parentSpanCtx);
}
}
catch (Exception)
{
spanBuilder = tracer.BuildSpan(operationName);
}
return(spanBuilder.WithTag(Tags.SpanKind, Tags.SpanKindConsumer).StartActive(true));
}