public static TResult Trace <TResult>(this IServiceTracer tracer, ISpanBuilder spanBuilder, Func <ISpan, TResult> operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
var span = tracer.Start(spanBuilder);
var curr = tracer.Tracer.GetCurrentSpan();
try
{
tracer.Tracer.SetCurrentSpan(span);
if (operation == null)
{
return(default(TResult));
}
return(operation(span));
}
catch (Exception exception)
{
span.Exception(exception);
throw;
}
finally
{
span.Finish(DateTimeOffset.UtcNow);
tracer.Tracer.SetCurrentSpan(curr);
}
}
public TracingHandlerFactory(
IServiceTracer tracer,
IRequestScopedDataRepository repo)
{
_repo = repo;
_tracer = tracer;
}
public static async Task <TResult> TraceAsync <TResult>(this IServiceTracer tracer, ISpanBuilder spanBuilder, Func <ISpan, Task <TResult> > operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
var span = tracer.Start(spanBuilder);
var curr = tracer.Tracer.GetCurrentSpan();
try
{
tracer.Tracer.SetCurrentSpan(span);
return(await operation?.Invoke(span));
}
catch (Exception exception)
{
span.Exception(exception);
throw;
}
finally
{
span.Finish(DateTimeOffset.UtcNow);
tracer.Tracer.SetCurrentSpan(curr);
}
}
public virtual void RemoveTracer(IServiceTracer tracer)
{
if (tracer is ClientRuntimeServiceTracer)
{
ServiceClientTracing.RemoveTracingInterceptor((ClientRuntimeServiceTracer)tracer);
}
}
public static TResult Trace <TResult>(this IServiceTracer tracer, ISpanBuilder spanBuilder, Func <ISpan, TResult> operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
using (var span = tracer.Start(spanBuilder))
{
try
{
if (operation == null)
{
return(default(TResult));
}
return(operation(span));
}
catch (Exception exception)
{
span.Exception(exception);
throw;
}
}
}
/// <summary>
/// 使用Autofac的方式进行对象反射
/// </summary>
/// <param name="service"></param>
/// <param name="services"></param>
/// <param name="butterflySetup"></param>
public static void AddAutofac(this RabbitMQConfig service, IServiceCollection services, Action <ButterflyOptions> butterflySetup = null)
{
if (butterflySetup != null)
{
try
{
services.AddButterfly(butterflySetup);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
services.AddSingleton(options =>
{
ILifetimeScope lifetime = options.GetRequiredService <ILifetimeScope>();
IRabbitMQBus bus = options.GetRequiredService <IRabbitMQBus>();
ILogger <AutofacMessageReceive> logger = options.GetService <ILogger <AutofacMessageReceive> >();
IServiceTracer tracer = null;
if (butterflySetup != null)
{
try
{
tracer = options.GetRequiredService <IServiceTracer>();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
return(new AutofacMessageReceive(lifetime, bus, tracer, logger));
});
}
public static void Trace(this IServiceTracer tracer, ISpanBuilder spanBuilder, Action <ISpan> operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
var span = tracer.Start(spanBuilder);
var curr = tracer.Tracer.GetCurrentSpan();
try
{
tracer.Tracer.SetCurrentSpan(span);
operation?.Invoke(span);
}
catch (Exception exception)
{
span.Exception(exception);
throw;
}
finally
{
span.Finish(DateTimeOffset.UtcNow);
tracer.Tracer.SetCurrentSpan(curr);
}
}
public OcelotDiagnosticListenerTests()
{
_factory = new Mock <IOcelotLoggerFactory>();
_logger = new Mock <IOcelotLogger>();
_tracer = new FakeServiceTracer();
_factory.Setup(x => x.CreateLogger <OcelotDiagnosticListener>()).Returns(_logger.Object);
_listener = new OcelotDiagnosticListener(_factory.Object, _tracer);
}
public static ButterflyModuleHandler Handle(IServiceTracer serviceTracer)
{
if (_butterflyHandler == null)
{
_butterflyHandler = new ButterflyModuleHandler(serviceTracer);
}
return(_butterflyHandler);
}
public LiveTestResponse MakeResponse(CommandExecutionResult commandResult, IServiceTracer tracer, IList<DynamicObjectTransform> transforms, Logger logger)
{
LiveTestResponse response = MakeBaseResponse();
if (commandResult.HadErrors)
{
if (logger != null)
{
logger.LogAsync("Command failed with errors.");
commandResult.LogErrors(logger);
}
response.Error = new LiveTestError();
response.Error.Code = InvalidRequest;
List<object> errors = new List<object>();
foreach (object originalError in commandResult.Errors)
{
errors.AddRange(TransformObject(originalError, transforms));
}
response.Error.Data = errors.Count == 0 ? null : errors.Count == 1 ? errors[0] : errors;
if (this.HttpResponse)
{
HttpResponseMessage responseMessage = tracer.HttpResponses.LastOrDefault();
if (responseMessage != null)
{
// Kill the Content property - doesn't work with Newtonsoft.Json serialization
HttpResponseMessage clonedMessage = new HttpResponseMessage(responseMessage.StatusCode);
foreach (var header in responseMessage.Headers)
{
clonedMessage.Headers.Add(header.Key, header.Value);
}
clonedMessage.ReasonPhrase = responseMessage.ReasonPhrase;
clonedMessage.RequestMessage = responseMessage.RequestMessage;
clonedMessage.Version = responseMessage.Version;
response.Error.HttpResponse = clonedMessage;
}
}
}
else
{
if (logger != null)
{
logger.LogAsync("Command executed successfully.");
}
List<object> results = new List<object>();
foreach (object originalResult in commandResult.Results)
{
results.AddRange(TransformObject(originalResult, transforms));
}
response.Result = GetLiveTestResult(results, tracer);
}
return response;
}
/// <summary>
///
/// </summary>
/// <param name="lifetime"></param>
/// <param name="service"></param>
/// <param name="tracer"></param>
/// <param name="logger"></param>
public AutofacMessageReceive(ILifetimeScope lifetime, IRabbitMQBus service, IServiceTracer tracer, ILogger <AutofacMessageReceive> logger)
{
_lifetime = lifetime;
_service = service;
_tracer = tracer;
_logger = logger;
_service.OnMessageReceived += RabbitMQ_OnMessageReceived;
_service.OnPublish += RabbitMQ_OnPublish;
}
public static Task <TResult> ChildTraceAsync <TResult>(this IServiceTracer tracer, string operationName, DateTimeOffset?startTimestamp, Func <ISpan, Task <TResult> > operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
return(TraceAsync(tracer, CreateChildSpanBuilder(tracer, operationName, startTimestamp), operation));
}
public static void ChildTrace(this IServiceTracer tracer, string operationName, DateTimeOffset?startTimestamp, Action <ISpan> operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
Trace(tracer, CreateChildSpanBuilder(tracer, operationName, startTimestamp), operation);
}
public OcelotHttpTracingHandler(
IServiceTracer tracer,
IRequestScopedDataRepository repo,
HttpMessageHandler httpMessageHandler = null)
{
_repo = repo;
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
InnerHandler = httpMessageHandler ?? new HttpClientHandler();
}
private static ISpanBuilder CreateChildSpanBuilder(IServiceTracer tracer, string operationName, DateTimeOffset?startTimestamp = null)
{
var spanBuilder = new SpanBuilder(operationName, startTimestamp);
var spanContext = tracer.Tracer.GetCurrentSpan()?.SpanContext;
if (spanContext != null)
{
spanBuilder.AsChildOf(spanContext);
}
return(spanBuilder);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceTracer tracer)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.RabbitMQEventBusAutoSubscribe();
app.RabbitMQEventBusModule(moduleOptions =>
{
moduleOptions.AddButterfly(tracer);
});
//Task.Factory.StartNew(async () =>
//{
// //为了验证先启动生产者发送消息，后启动消费者消费的情况
// await Task.Delay(20000);
// app.UseRabbitMQBus(true);
//});
app.UseMvc();
}
public static void Trace(this IServiceTracer tracer, ISpanBuilder spanBuilder, Action <ISpan> operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
using (var span = tracer.Start(spanBuilder))
{
try
{
operation?.Invoke(span);
}
catch (Exception exception)
{
span.Exception(exception);
throw;
}
}
}
public static async Task TraceAsync(this IServiceTracer tracer, ISpanBuilder spanBuilder, Func <ISpan, Task> operation)
{
if (tracer == null)
{
throw new ArgumentNullException(nameof(tracer));
}
using (var span = tracer.Start(spanBuilder))
{
try
{
await operation?.Invoke(span);
}
catch (Exception exception)
{
span.Exception(exception);
throw;
}
}
}
private TracerManager(ButterflyOptions options, ILoggerFactory loggerFactory)
{
var senderProvider = new DefaultSenderProvider(options);
var callback = new SpanDispatchCallback(senderProvider, loggerFactory);
var dispatcher = new ButterflyDispatcher(new IDispatchCallback[] { callback }, loggerFactory, 0, 0, 0);
var spanRecorder = new AsyncSpanRecorder(dispatcher);
var tracer = new Tracer(spanRecorder);
#if NETSTANDARD1_6
var environmentName = ((dynamic)Assembly.GetEntryAssembly().GetCustomAttribute <DebuggableAttribute>()).IsJITTrackingEnabled is bool debugMode ? debugMode ? "Development" : "Production" : "Unknown";
#else
var environmentName = Assembly.GetEntryAssembly().GetCustomAttribute <DebuggableAttribute>().IsJITTrackingEnabled ? "Development" : "Production";
#endif
var service = options.Service ?? Assembly.GetEntryAssembly().GetName().Name;
var host = Dns.GetHostName();
var identity = string.IsNullOrEmpty(options.ServiceIdentity) ? $"{service}@{host}" : options.ServiceIdentity;
ServiceTracer = new ServiceTracer(tracer, service, environmentName, identity, host);
}
public WebApiTraceFilterAttribute(IServiceTracer tracer, IJsonHelper jsonHelper)
{
this._tracer = tracer;
this.jsonHelper = jsonHelper;
}
public WebApiTracingFilterAttribute(IJsonHelper jsonHelper, IServiceTracer tracer, IOptions <TracingOptions> options)
{
_jsonHelper = jsonHelper;
_tracer = tracer;
_options = options.Value;
}
public IEnumerable <string> Get([FromServices] IServiceTracer tracer)
{
return(new[] { "value1", "value2" });
}
public HttpHandlerOptionsCreator(IServiceTracer tracer)
{
_tracer = tracer;
}
private ButterflyModuleHandler(IServiceTracer serviceTracer)
{
_serviceTracer = serviceTracer;
}
public static RabbitMQEventBusModuleOption AddButterfly(this RabbitMQEventBusModuleOption build, IServiceTracer tracer)
{
build.AddModule(ButterflyModuleHandler.Handle(tracer));
return(build);
}
public RequestTracer(IServiceTracer tracer, IOptions <TraceOptions> options)
{
_tracer = tracer;
_options = options.Value;
}
public HttpTracingHandler(IServiceTracer tracer, HttpMessageHandler httpMessageHandler = null)
{
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
InnerHandler = httpMessageHandler ?? new HttpClientHandler();
}
public async Task <string> Get([FromServices] HttpClient httpClient, [FromServices] IServiceTracer tracer)
{
return(await httpClient.GetStringAsync("http://localhost:5002/api/values"));
}
public HttpClientDiagnosticListener(IServiceTracer tracer, IOptions <TracingOptions> options)
{
_tracer = tracer;
_options = options.Value;
}
public HttpHandlerOptionsCreatorTests()
{
_serviceTracer = new FakeServiceTracer();
_httpHandlerOptionsCreator = new HttpHandlerOptionsCreator(_serviceTracer);
}
