public void Publish(IMessage message, string destination, bool forceDestination, Action <IMessage, string, bool> publish)
{
var method = new StackFrame().GetMethod();
var name = GetName(message, method, publish.GetMethodInfo().Name);
var transaction = _elasticApmtracer.CurrentTransaction;
if (transaction != null)
{
PublishMessage(message, destination, forceDestination, publish, transaction, name);
}
else
{
_elasticApmtracer.CaptureTransaction(name, TransactionType, () => Publish(message, destination, forceDestination, publish));
}
}
public void ProcessMessage(IMessage message, IPublisher publisher, Action <IMessage, IPublisher> processMessage)
{
var method = new StackFrame().GetMethod();
var name = GetName(message, method, processMessage.GetMethodInfo().Name);
var traceAsyncTransaction = GetTraceAsyncTransaction(message);
if (message.Headers.ContainsKey(ApmConstants.TraceParent) && traceAsyncTransaction)
{
var traceParent = message.Headers[ApmConstants.TraceParent].ToString();
_elasticApmtracer.CaptureTransaction(name, TransactionType, () => processMessage(message, publisher), DistributedTracingData.TryDeserializeFromString(traceParent));
}
else
{
_elasticApmtracer.CaptureTransaction(name, TransactionType, () => processMessage(message, publisher));
}
}
/// <summary>
/// ElasticTransaction
/// -
/// ---> OTSpan
/// -
/// ---> ElasticSpan
/// </summary>
/// <param name="tracer"></param>
public static void Sample4(ITracer tracer)
{
var src = new ActivitySource("Test");
tracer.CaptureTransaction(nameof(Sample4), "test", t =>
{
Thread.Sleep(100);
using (var activity = src.StartActivity("foo"))
{
tracer.CurrentSpan.CaptureSpan("ElasticApmSpan", "test", () => Thread.Sleep(50));
Thread.Sleep(150);
}
});
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (true)
{
await _tracer.CaptureTransaction("SampleHttpTransaction", ApiConstants.TypeRequest, async() =>
{
var client = new HttpClient();
HttpResponseMessage response = await client.GetAsync("http://www.example.com/");
response.EnsureSuccessStatusCode();
string responseBody = await response.Content.ReadAsStringAsync();
// Above three lines can be replaced with new helper method below
// string responseBody = await client.GetStringAsync(uri);
Console.WriteLine(responseBody);
});
await Task.Delay(10_000);
}
}
public async Task <CommandResult> Handle(TCommand command, RequestContext context)
{
var commandName = command.GetType().FullName;
bool shouldCreateSpan = traceSettings?.ShouldCreateSpan(commandName) ?? false;
CommandResult commandResult = null;
if (!shouldCreateSpan)
{
commandResult = await decoratedRequestHandler.Handle(command, context);
}
if (!context.Headers.ContainsKey(DistributedTracingHeader.DistributedTracingDataKey))
{
string outgoingDistributedTracingData =
(tracer.CurrentSpan?.OutgoingDistributedTracingData
?? tracer.CurrentTransaction?.OutgoingDistributedTracingData)?.SerializeToString();
context.Headers.Add(DistributedTracingHeader.DistributedTracingDataKey, outgoingDistributedTracingData);
}
if (tracer.CurrentTransaction == null)
{
await tracer.CaptureTransaction(commandName.ToTransactionName(), commandName.ToTransactionType(), async(transaction) =>
{
// transaction.Labels["TK"] = "kadirzade";
await tracer.CurrentTransaction.CaptureSpan(commandName.ToSpanName(), commandName.ToSpanType(), async(span) =>
{
commandResult = await decoratedRequestHandler.Handle(command, context);
});
}, DistributedTracingData.TryDeserializeFromString(context.Headers[DistributedTracingHeader.DistributedTracingDataKey]));
}
else
{
await tracer.CurrentTransaction.CaptureSpan(commandName.ToSpanName(), commandName.ToSpanType(), async (span) =>
{
commandResult = await decoratedRequestHandler.Handle(command, context);
span.Labels["result"] = commandResult.FormatResult();
});
}
return(commandResult);
}
public async Task <QueryResult <TResponse> > Handle(TQuery query, RequestContext context)
{
var queryName = query.GetType().FullName;
bool shouldCreateSpan = traceSettings?.ShouldCreateSpan(queryName) ?? false;
QueryResult <TResponse> queryResult = null;
if (!shouldCreateSpan)
{
queryResult = await decoratedRequestHandler.Handle(query, context);
}
if (!context.Headers.ContainsKey(DistributedTracingHeader.DistributedTracingDataKey))
{
string outgoingDistributedTracingData =
(tracer.CurrentSpan?.OutgoingDistributedTracingData
?? tracer.CurrentTransaction?.OutgoingDistributedTracingData)?.SerializeToString();
context.Headers.Add(DistributedTracingHeader.DistributedTracingDataKey, outgoingDistributedTracingData);
}
if (tracer.CurrentTransaction == null)
{
await tracer.CaptureTransaction(queryName.ToTransactionName(), queryName.ToTransactionType(), async() =>
{
await tracer.CurrentTransaction.CaptureSpan(queryName.ToSpanName(), queryName.ToSpanType(), async(span) =>
{
queryResult = await decoratedRequestHandler.Handle(query, context);
});
}, DistributedTracingData.TryDeserializeFromString(context.Headers[DistributedTracingHeader.DistributedTracingDataKey]));
}
else
{
await tracer.CurrentTransaction.CaptureSpan(queryName.ToSpanName(), queryName.ToSpanType(), async (span) =>
{
queryResult = await decoratedRequestHandler.Handle(query, context);
span.Labels["result"] = queryResult.FormatResult();
span.Type = "";
});
}
return(queryResult);
}