public void TestInjectExtract()
{
var tracer = new WavefrontTracer
.Builder(new ConsoleReporter(DefaultSource), BuildApplicationTags())
.Build();
var span = tracer.BuildSpan("testOp").Start();
Assert.NotNull(span);
span.SetBaggageItem("customer", "testCustomer");
span.SetBaggageItem("requestType", "mobile");
var dictionary = new Dictionary <string, string>();
var textMapInjectAdapter = new TextMapInjectAdapter(dictionary);
tracer.Inject(span.Context, BuiltinFormats.TextMap, textMapInjectAdapter);
var textMapExtractAdapter = new TextMapExtractAdapter(dictionary);
var context =
(WavefrontSpanContext)tracer.Extract(BuiltinFormats.TextMap, textMapExtractAdapter);
Assert.Equal("testCustomer", context.GetBaggageItem("customer"));
Assert.Equal("mobile", context.GetBaggageItem("requesttype"));
}
public static Dictionary <string, string> CreateInjectTracingSpanHeader()
{
var headers = new Dictionary <string, string>();
var carrier = new TextMapInjectAdapter(headers);
GlobalTracer.Instance.Inject(GlobalTracer.Instance.ActiveSpan.Context, BuiltinFormats.HttpHeaders, carrier);
return(headers);
}
public void TestTraceIdInjectRoot()
{
var traceId = Guid.Parse("00000000-0000-0000-3871-de7e09c53ae8");
var spanId = Guid.Parse("00000000-0000-0000-7499-dd16d98ab60e");
var dictionary = new Dictionary <string, string>();
var textMapInjectAdapter = new TextMapInjectAdapter(dictionary);
wfJaegerPropagator.Inject(new WavefrontSpanContext(traceId, spanId, null, true),
textMapInjectAdapter);
Assert.True(dictionary.ContainsKey(JaegerHeader));
Assert.Equal("3871de7e09c53ae8:7499dd16d98ab60e:0:1", dictionary[JaegerHeader]);
}
private static Metadata CreateInjectMetadataFromSpan(ITracer tracer, ISpan span)
{
var dict = new Dictionary <string, string>();
var injectAdapter = new TextMapInjectAdapter(dict);
tracer.Inject(span.Context, BuiltinFormats.HttpHeaders, injectAdapter);
var meta = new Metadata();
foreach (var entry in dict)
{
meta.Add(entry.Key, entry.Value);
}
return(meta);
}
public void Publish <T>(T @event) where T : Event
{
var tracer = GlobalTracer.Instance;
using (IScope scope = GlobalTracer.Instance.BuildSpan("send")
.WithTag(Tags.SpanKind.Key, Tags.SpanKindClient)
.WithTag(Tags.Component.Key, "example-client")
.StartActive(finishSpanOnDispose: true))
{
var headers = new Dictionary <string, string>();
var adapter = new TextMapInjectAdapter(headers);
GlobalTracer.Instance.Inject(scope.Span.Context, BuiltinFormats.TextMap, adapter);
tracer.ActiveSpan?.Log(new Dictionary <string, object> {
{ "event", nameof(@event) },
{ "type", @event.GetType().ToString() },
{ "customer_name", "teste" },
{ "item_number", "teste" },
{ "quantity", "teste" }
});
var factory = new ConnectionFactory()
{
HostName = "192.168.99.100"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
var properties = channel.CreateBasicProperties();
properties.Headers = new Dictionary <string, object>();
foreach (var item in headers)
{
properties.Headers.Add(new KeyValuePair <string, object>(item.Key, item.Value));
}
var eventName = @event.GetType().Name;
channel.QueueDeclare(eventName, false, false, false, null);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish("", eventName, properties, body);
}
}
}
public async Task <string> RequestAsync(string content, CancellationToken cancellationToken)
{
string responseContent;
var request = new HttpRequestMessage
{
RequestUri = _uri,
Method = HttpMethod.Post,
Content = new StringContent(content, Encoding.UTF8),
};
var tracer = GlobalTracer.Instance;
using (var scope = tracer.BuildSpan("Client POST " + _uri.AbsolutePath)
.WithTag("span.kind", "client")
.StartActive())
{
var contextPropagationHeaders = new Dictionary <string, string>();
var contextCarrier = new TextMapInjectAdapter(contextPropagationHeaders);
tracer.Inject(scope.Span.Context, BuiltinFormats.TextMap, contextCarrier);
foreach (var kvp in contextPropagationHeaders)
{
request.Headers.Add(kvp.Key, kvp.Value);
}
using var response = await _client.SendAsync(request, cancellationToken);
scope.Span.SetTag("http.status_code", (int)response.StatusCode);
responseContent = await response.Content.ReadAsStringAsync();
scope.Span.SetTag("response.content", responseContent);
scope.Span.SetTag("response.length", responseContent.Length);
foreach (var header in response.Headers)
{
if (header.Value is IEnumerable <object> enumerable)
{
scope.Span.SetTag($"http.header.{header.Key}", string.Join(",", enumerable));
}
else
{
scope.Span.SetTag($"http.header.{header.Key}", header.Value.ToString());
}
}
}
return(responseContent);
}
public void Inject_Dictionary()
{
var tracer = LambdaTracer.Instance as LambdaTracer;
tracer.AccountId = "test-accountId";
tracer.TrustedAccountKey = "test-accountId";
var scope = tracer.BuildSpan("stuff").StartActive();
var headers = new Dictionary <string, string>();
var injector = new TextMapInjectAdapter(headers);
tracer.Inject(scope.Span.Context, BuiltinFormats.HttpHeaders, injector);
Assert.That(headers.Count, Is.EqualTo(1));
Assert.That(headers.ContainsKey(NEWRELIC_TRACE_HEADER), Is.True);
Assert.That(headers[NEWRELIC_TRACE_HEADER], Is.Not.Null);
}
private static async Task RunAsync()
{
using var client = new HttpClient();
await HttpGet("https://www.example.com/default-handler");
await HttpGet("http://127.0.0.1:8080/api/mongo");
await HttpGet("http://127.0.0.1:8080/api/redis");
await HttpGet("http://127.0.0.1:8080/api/metrics");
const string requestUrl = "https://www.example.com/";
var request = new HttpRequestMessage
{
RequestUri = new Uri(requestUrl),
Method = HttpMethod.Post,
Content = new StringContent(string.Empty, Encoding.UTF8),
};
var tracer = GlobalTracer.Instance;
using (var scope = tracer.BuildSpan("Client POST " + request.RequestUri)
.WithTag("span.kind", "client")
.StartActive())
{
var contextPropagationHeaders = new Dictionary <string, string>();
var contextCarrier = new TextMapInjectAdapter(contextPropagationHeaders);
tracer.Inject(scope.Span.Context, BuiltinFormats.TextMap, contextCarrier);
foreach (var kvp in contextPropagationHeaders)
{
request.Headers.Add(kvp.Key, kvp.Value);
}
try
{
using var response = await client.SendAsync(request);
await response.Content.ReadAsStringAsync();
}
catch (HttpRequestException e)
{
Console.WriteLine($"HttpRequestException occurred while calling {requestUrl}, {e}");
}
scope.Span.SetTag("custom.opentracing", "manual span");
}
}
public void TestTraceIdInject()
{
var traceId = Guid.Parse("00000000-0000-0000-3871-de7e09c53ae8");
var spanId = Guid.Parse("00000000-0000-0000-7499-dd16d98ab60e");
var baggage = new Dictionary <string, string>();
baggage[ParentIdKey] = "ef27b4b9-f6e9-46f5-ab2b-47bbb24746c5";
var dictionary = new Dictionary <string, string>();
var textMapInjectAdapter = new TextMapInjectAdapter(dictionary);
wfJaegerPropagator.Inject(new WavefrontSpanContext(traceId, spanId, baggage, true),
textMapInjectAdapter);
Assert.True(dictionary.ContainsKey(JaegerHeader));
Assert.Equal("3871de7e09c53ae8:7499dd16d98ab60e:ef27b4b9f6e946f5ab2b47bbb24746c5:1",
dictionary[JaegerHeader]);
Assert.Equal("ef27b4b9-f6e9-46f5-ab2b-47bbb24746c5",
dictionary[BaggagePrefix + ParentIdKey]);
}
