/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="workerNotification">The worker notification.</param>
/// <returns></returns>
public async Task HandleAsync(IReceivedMessageInternal message, IWorkerNotification workerNotification)
{
var spanContext = message.Extract(_tracer, _headers.StandardHeaders);
if (spanContext != null)
{
using (IScope scope = _tracer.BuildSpan("MessageHandlerAsync").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true))
{
scope.Span.AddMessageIdTag(message);
await _handler.HandleAsync(message, workerNotification);
}
}
else
{
using (IScope scope = _tracer.BuildSpan("MessageHandlerAsync").StartActive(finishSpanOnDispose: true))
{
scope.Span.AddMessageIdTag(message);
await _handler.HandleAsync(message, workerNotification);
}
}
}
public async Task <IActionResult> GetAll()
{
using (var scope = _tracer.BuildSpan("GetAllChapters").StartActive(finishSpanOnDispose: true))
{
var response = await _mediator.Send(new GetAllChapterQuery());
//catch if failure
return(Ok(response));
}
}
private void HandleActivityStart(string eventName, Activity activity, object untypedArg)
{
ISpanBuilder spanBuilder = _tracer.BuildSpan(activity.OperationName)
.WithTag(Tags.Component.Key, _listenerName);
foreach (var tag in activity.Tags)
{
spanBuilder.WithTag(tag.Key, tag.Value);
}
spanBuilder.StartActive(finishSpanOnDispose: true);
}
public void SetDefaultServiceName()
{
ITracer tracer = OpenTracingTracerFactory.CreateTracer(defaultServiceName: "DefaultServiceName");
var scope = tracer.BuildSpan("Operation")
.StartActive();
var otSpan = (OpenTracingSpan)scope.Span;
var ddSpan = otSpan.Span;
Assert.Equal("DefaultServiceName", ddSpan.ServiceName);
}
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))
{
}
}
public void OnActionExecuting(ActionExecutingContext context)
{
var actionDescriptor = context.ActionDescriptor;
string operationName = actionDescriptor is ControllerActionDescriptor controllerActionDescriptor
? $"Action {controllerActionDescriptor.ControllerTypeInfo.Name}/{controllerActionDescriptor.ActionName}"
: $"Action {actionDescriptor.DisplayName}";
_tracer.BuildSpan(operationName)
.WithTag(Tags.Component, ActionComponent)
.StartActive();
}
public async Task InvokeAsync(HttpContext context, ITracer tracer)
{
var path = context.Request.Path;
if (Path.HasExtension(path))
{
await _next(context);
}
else
{
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");
}
using (IScope scope = builder.StartActive(true))
{
scope.Span.SetOperationName(path);
// 记录请求信息到span
foreach (var query in context.Request.Query)
{
scope.Span.SetTag(query.Key, query.Value);
}
if (context.Request.HasFormContentType)
{
foreach (var form in context.Request.Form)
{
scope.Span.SetTag(form.Key, form.Value);
}
}
await _next(context);
}
}
}
private void RootSpan()
{
using (IScope scope = _tracer.BuildSpan("someWork").StartActive(finishSpanOnDispose: true))
{
try
{
RandomSleep();
// Do some parallel children and wait for the result
MultiSpan();
// Call a sub method
ChildSpan();
// Do a nested call here cos we can
using (IScope scope2 = _tracer.BuildSpan("rootNested").StartActive(finishSpanOnDispose: true))
{
RandomSleep();
}
}
catch (Exception ex)
{
Tags.Error.Set(scope.Span, true);
}
// No need to call scope.Span.Finish() as we've set finishSpanOnDispose:true in StartActive.
}
}
private Task HandleExceptionAsync(HttpContext context, Exception exception)
{
using (var scope = _tracer.BuildSpan(JaegerSpanName).StartActive(true))
{
HttpStatusCode code;
switch (exception)
{
case ArgumentException _:
code = HttpStatusCode.BadRequest;
break;
case RecordNotFoundException _:
code = HttpStatusCode.NotFound;
break;
case NotImplementedException _:
code = HttpStatusCode.NotImplemented;
Tags.Error.Set(scope.Span, true);
break;
default:
code = HttpStatusCode.InternalServerError; // 500 if unexpected
Tags.Error.Set(scope.Span, true);
break;
}
var errorModel = new ErrorModel
{
Error = exception.Message + " " + exception.InnerException?.Message
};
var result = JsonConvert.SerializeObject(errorModel, _jsonSerializerSettings);
context.Response.ContentType = ResponseContentType;
context.Response.StatusCode = (int)code;
scope.Span.Log(new Dictionary <string, object>
{
[LogFields.Event] = "error",
[LogFields.ErrorKind] = exception.GetType().ToString(),
[LogFields.ErrorObject] = exception,
[LogFields.Stack] = exception.StackTrace,
[LogFields.Message] = exception.Message,
["error_id"] = errorModel.ErrorId,
["value"] = result,
["status_code"] = (int)code
});
return(context.Response.WriteAsync(result));
}
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, SearchQuery query, string operationName)
{
var span = tracer.BuildSpan(operationName);
if (span is NullSpan)
{
return(span);
}
return(span
.WithTag(CouchbaseTags.OperationId, GetOrGenerateOperationId(query.ActiveSpan))
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceSearch)
.AsChildOf(query.ActiveSpan));
}
public static IScope StartServerSpan(ITracer tracer, IDictionary <string, string> headers, string operationName)
{
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);
}
// TODO could add more tags like http.url
return(spanBuilder.WithTag(Tags.SpanKind, Tags.SpanKindServer).StartActive(true));
}
public override void InvokeSync(IExecutionContext executionContext)
{
var name = executionContext.RequestContext.RequestName;
Utils.DebugLogIfEnabled("AWSSDK request invoked, {name}", name);
using (var scope = tracer.BuildSpan(name).StartActive(finishSpanOnDispose: true)) {
BuildSpan(executionContext, scope.Span);
try { HandleBefore(executionContext, scope); } catch (Exception e) { scope.Span.AddException(e); }
base.InvokeSync(executionContext);
try {
HandleAfter(executionContext, scope);
scope.Span.SetTag("event.id", executionContext.ResponseContext.Response.ResponseMetadata.RequestId);
} catch (Exception e) {
scope.Span.SetTag("event.id", executionContext.ResponseContext.Response.ResponseMetadata.RequestId);
scope.Span.AddException(e);
}
}
}
public string Get(string helloTo)
{
using (var scope = _tracer.BuildSpan("format-controller").StartActive(true))
{
var formattedHelloString = $"Hello, {helloTo}!";
scope.Span.Log(new Dictionary <string, object>
{
[LogFields.Event] = "string-format",
["value"] = formattedHelloString
});
return(formattedHelloString);
}
}
public ValuesController(ITracer tracer)
{
var operationName = "ValuesController/";
var builder = tracer.BuildSpan(operationName);
using (var scope = builder.StartActive(true))
{
var span = scope.Span;
var log = $"Endpoint called with query parameters ";
span.Log(log + " " + span.ToString());
}
}
public void Send()
{
var message = new Message();
using (IScope scope = _tracer.BuildSpan("send")
.WithTag(Tags.SpanKind.Key, Tags.SpanKindClient)
.WithTag(Tags.Component.Key, "example-client")
.StartActive(finishSpanOnDispose: true))
{
_tracer.Inject(scope.Span.Context, BuiltinFormats.TextMap, new TextMapInjectAdapter(message));
_queue.Add(message);
}
}
public string GetUserInfo(string username)
{
using (var scope = _tracer.BuildSpan("FooService-GetUserInfo").StartActive(true))
{
var result = _fooService.GetUserInfo(username);
//按需使用
scope.Span.Log("a log from FooApi");
scope.Span.SetTag("username", username);
return(result);
}
}
public void OverrideDefaultServiceName_SetTag()
{
ITracer tracer = OpenTracingTracerFactory.CreateTracer(defaultServiceName: "DefaultServiceName");
var scope = tracer.BuildSpan("Operation")
.StartActive();
scope.Span.SetTag(DatadogTags.ServiceName, "MyAwesomeService");
var otSpan = (OpenTracingSpan)scope.Span;
var ddSpan = otSpan.Span;
Assert.Equal("MyAwesomeService", ddSpan.ServiceName);
}
public void Publish(string topicName, Event @event, Dictionary <string, string> headers)
{
try
{
var message = new Message <Null, Event>
{
Value = @event,
Headers = new Headers()
};
//add correlation headers
_producer.OnError += (_, e) =>
{
if (e.IsBrokerError || e.IsFatal)
{
_logger.LogError($"error on the Producer: [{e.Reason} [{e.Code}]]");
}
};
if (_tracer != null)
{
using (var scope = _tracer.BuildSpan(SpanKindProducer).StartActive(true))
{
var span = _tracer.ActiveSpan
.SetTag(Tags.SpanKind, Tags.SpanKindProducer)
.SetTag(Tags.MessageBusDestination, topicName);
_tracer.Inject(span.Context, BuiltinFormats.HttpHeaders, new TextMapInjectAdapter(headers));
//add correlation headers
SetHeaders(headers, message.Headers);
//TenantContext :set current context header for tenant,facility
_contextHeaders.SetContextHeaders(ContextHeader,
message.Headers);
_producer.ProduceAsync(topicName, message)
.GetAwaiter()
.GetResult();
}
}
else
{
SetHeaders(headers, message.Headers);
_producer.ProduceAsync(topicName, message).GetAwaiter().GetResult();
}
}
catch (KafkaException e)
{
_logger.LogError(e, $"failed to deliver message: {e.Message} [{e.Error.Code}]");
throw;
}
}
private IActionResult FastPay(ISpanContext context)
{
using (var scope = tracer.BuildSpan("FastPay")
.AddReference(References.ChildOf, context)
.StartActive())
{
Thread.Sleep(TimeSpan.FromMilliseconds(Math.Max(RandomGauss(80, 20), 40)));
if (rand.NextDouble() < 0.001)
{
scope.Span.SetTag(Tags.Error, true);
return(StatusCode(StatusCodes.Status500InternalServerError, "fast pay failed"));
}
return(Accepted("fast pay accepted"));
};
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, IViewQueryable query, string operationName)
{
var span = tracer.BuildSpan(operationName);
if (span is NoopSpan)
{
return(span);
}
return(span
.WithTag(CouchbaseTags.OperationId, GetOrGenerateOperationId(tracer.ActiveSpan))
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceView)
.AsChildOf(tracer.ActiveSpan));
}
/// <summary>
/// Converts the message to an array of bytes
/// </summary>
/// <typeparam name="T">the message type</typeparam>
/// <param name="message">The message.</param>
/// <param name="headers">The message headers</param>
/// <returns>
/// byte array
/// </returns>
public byte[] ConvertMessageToBytes <T>(T message, IReadOnlyDictionary <string, object> headers) where T : class
{
var spanContext = headers.Extract(_tracer, _headers);
if (spanContext != null && _tracer.ActiveSpan == null)
{
using (IScope scope = _tracer.BuildSpan($"MessageSerializerMessageToBytes{_handler.DisplayName}").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true))
{
var output = _handler.ConvertMessageToBytes(message, headers);
scope.Span.SetTag("Length", output.Length.ToString());
return(output);
}
}
else
{
using (IScope scope = _tracer.BuildSpan($"MessageSerializerMessageToBytes{_handler.DisplayName}").StartActive(finishSpanOnDispose: true))
{
var output = _handler.ConvertMessageToBytes(message, headers);
scope.Span.SetTag("Length", output.Length.ToString());
return(output);
}
}
}
public async Task TellAsync(string message, Teller teller)
{
await Task.Factory.StartNew(async() =>
{
using (IScope scope = _tracer.BuildSpan("TellAsync").StartActive(true))
{
try
{
// avoid burst calling func
await Task.Delay(10);
scope.Span.Log($"{message}");
Console.Write($"{message} ");
await teller.TellAsync(_message, this);
}
catch (Exception ex)
{
Tags.Error.Set(scope.Span, true);
}
}
});
}
public static ISpanBuilder BuildPublisherSpan(string exchange, string routingKey, IBasicProperties basicProperties,
ITracer tracer)
{
var operationName = $"Publishing Message: exchange: {exchange}, routingKey: {routingKey}";
var spanBuilder = tracer.BuildSpan(operationName)
.AsChildOf(tracer.ActiveSpan.Context)
.WithTag("message-id", basicProperties.MessageId)
.WithTag("app-id", basicProperties.AppId)
.WithTag("exchange", exchange)
.WithTag("routing-key", routingKey);
return(spanBuilder);
}
public ValuesController(ILogger <ValuesController> logger, ITracer tracer)
{
_logger = logger;
var operationName = "LoggingController/";
var builder = tracer.BuildSpan(operationName);
using (var scope = builder.StartActive(true))
{
var span = scope.Span;
var log = $"Endpoint Called";
span.Log(log + " " + span.ToString());
}
}
public customersController(IcustomersRepository customersRepository, ITracer tracer)
{
_customersRepository = customersRepository;
var operationName = "CustomerController/";
var builder = tracer.BuildSpan(operationName);
using (var scope = builder.StartActive(true))
{
var span = scope.Span;
var log = $"Endpoint Called";
span.Log(log + " " + span.ToString());
}
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, IAnalyticsRequest request, string operationName)
{
var span = tracer.BuildSpan(operationName);
if (span is NullSpan)
{
return(span);
}
return(span
.WithTag(CouchbaseTags.OperationId, request.CurrentContextId)
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceAnalytics)
.WithTag(Tags.DbStatement, request.OriginalStatement)
.AsChildOf(request.ActiveSpan));
}
public static ISpanBuilder BuildDefaultSpan(
this ITracer tracer,
[CallerMemberName] string?callerMethodName = default,
[CallerFilePath] string?callerFilePath = default)
{
if (tracer is null)
{
throw new ArgumentNullException(nameof(tracer));
}
var operationName = GetOperationName(callerMethodName, callerFilePath);
return(tracer.BuildSpan(operationName));
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, IQueryRequest query, string operationName)
{
var span = tracer.BuildSpan(operationName);
if (span is NullSpan)
{
return(span);
}
return(span
.WithTag(CouchbaseTags.OperationId, query.CurrentContextId)
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceN1ql)
.WithTag(Tags.DbStatement, query.GetOriginalStatement())
.AsChildOf(query.ActiveSpan));
}
private static ISpanBuilder BuildSpan(this ITracer tracer, IOperation operation, string operationName, string bucketName)
{
var span = tracer.BuildSpan(operationName);
if (span is NullSpan)
{
return(span);
}
return(span
.WithTag(CouchbaseTags.OperationId, $"0x{operation.Opaque:x}") // use opaque as hex value
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceKv)
.WithTag(Tags.DbInstance, string.IsNullOrWhiteSpace(bucketName) ? Unknown : bucketName)
.AsChildOf(operation.ActiveSpan));
}
/// <inheritdoc />
public void Handle(IMessageContext context, PoisonMessageException exception)
{
var header = _getHeader.GetHeaders(context.MessageId);
if (header != null)
{
var spanContext = header.Extract(_tracer, _headers);
if (spanContext != null)
{
using (IScope scope = _tracer.BuildSpan("PoisonMessage").AddReference(References.FollowsFrom, spanContext).StartActive(finishSpanOnDispose: true))
{
scope.Span.Log(exception.ToString());
Tags.Error.Set(scope.Span, true);
_handler.Handle(context, exception);
}
}
else
{
using (IScope scope = _tracer.BuildSpan("PoisonMessage").StartActive(finishSpanOnDispose: true))
{
scope.Span.AddMessageIdTag(context);
scope.Span.Log(exception.ToString());
Tags.Error.Set(scope.Span, true);
_handler.Handle(context, exception);
}
}
}
else
{
using (IScope scope = _tracer.BuildSpan("PoisonMessage").StartActive(finishSpanOnDispose: true))
{
scope.Span.AddMessageIdTag(context);
scope.Span.Log(exception.ToString());
_handler.Handle(context, exception);
}
}
}