public async Task InvokeAsync(ClientActionExecutingContext context, ITracer tracer, IOptions <OpenTracingOptions> options)
{
if (context.ContractMethod.IsTracerIgnore)
{
await _next(context);
return;
}
var injectDic = new Dictionary <string, string>();
using var scope = tracer.BuildSpan($"{context.ContractMethod.MethodInfo.Name} {ConstValue.SendStr}").StartActive(true);
tracer.Inject(scope.Span.Context, BuiltinFormats.HttpHeaders, new TextMapInjectAdapter(injectDic));
foreach (var dic in injectDic)
{
context.Header[dic.Key] = dic.Value;
}
try
{
await _next(context);
scope.Span.SetTag("Connection", context.OnceCall.ConnectionInfo.ToString());
scope.Span.SetTagReturn(context, options.Value.LogActionInfoMaxLength);
scope.Span.SetTagMethodObj(context, options.Value.LogActionInfoMaxLength);
}
catch (Exception e)
{
scope.Span.SetTagMethodObj(context, 0, true);
scope.Span.SetTagReturn(context, 0, true);
scope.Span.SetTag(new StringTag("Exception"), e.ExceptionToString());
throw;
}
}
private static void SetTracingBefore(ClientActionExecutingContext context)
{
if (context.Stream == null || GlobalTracer.Instance.ActiveSpan == null)
{
return;
}
var spanBuilder = GlobalTracer.Instance.BuildSpan(
$"{ConstValue.ClientStream} {NetRpc.Helper.SizeSuffix(context.Stream.Length)} {ConstValue.SendStr}").AsChildOf(GlobalTracer.Instance.ActiveSpan);
ISpan?span = null;
context.OnceCall.SendRequestStreamStarted += (s, e) => span = spanBuilder.Start();
context.OnceCall.SendRequestStreamFinished += (s, e) => span?.Finish();
}
public async Task InvokeAsync(ClientActionExecutingContext context, IOptions <OpenTracingOptions> options)
{
if (context.ContractMethod.IsTracerIgnore)
{
await _next(context);
return;
}
SetTracingBefore(context);
await _next(context);
SetTracingAfter(context);
}
private static void SetTracingAfter(ClientActionExecutingContext context)
{
if (GlobalTracer.Instance.ActiveSpan == null)
{
return;
}
if (context.Result.TryGetStream(out var outStream, out _))
{
var readStream = (ReadStream)outStream;
var spanBuilder = GlobalTracer.Instance.BuildSpan(
$"{ConstValue.ClientStream} {NetRpc.Helper.SizeSuffix(readStream.Length)} {ConstValue.ReceiveStr}").AsChildOf(GlobalTracer.Instance.ActiveSpan);
ISpan span = null;
readStream.Started += (s, e) => span = spanBuilder.Start();
readStream.Finished += (s, e) => span?.Finish();
}
}
public async Task InvokeAsync(ClientActionExecutingContext context, ITracer tracer, IOptionsMonitor <ClientSwaggerOptions> options)
{
var opt = options.Get(context.OptionsName);
if (opt.IsPropertiesDefault())
{
await _next(context);
return;
}
var info = context.ContractMethod.HttpRoutInfo;
var requestUrl = Helper.GetRequestUrl(opt.HostPath.FormatUrl(), opt.ApiPath, info.ContractPath, info.MethodPath);
tracer.ActiveSpan?.SetTag(new StringTag("Url"), requestUrl);
await _next(context);
}
private static void SetTracingAfter(ClientActionExecutingContext context)
{
if (GlobalTracer.Instance.ActiveSpan == null)
{
return;
}
if (context.Result.TryGetStream(out var outStream, out _))
{
var readStream = (ProxyStream)outStream !;
var spanBuilder = GlobalTracer.Instance.BuildSpan(
$"{ConstValue.ClientStream} {NetRpc.Helper.SizeSuffix(readStream.Length)} {ConstValue.ReceiveStr}")
.AsChildOf(GlobalTracer.Instance.ActiveSpan);
ISpan?span = null;
#pragma warning disable 1998
readStream.StartedAsync += async(_, _) => span = spanBuilder.Start();
readStream.FinishedAsync += async(_, _) => span?.Finish();
#pragma warning restore 1998
}
}
