1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
// Demonstrates basic usage of the OpenTracing API. Uses OpenTracing's
// mocktracer to capture all the recorded spans as JSON.
#include <opentracing/mocktracer/json_recorder.h>
#include <opentracing/mocktracer/tracer.h>
#include <cassert>
#include <iostream>
#include <sstream>
#include <unordered_map>
#include "text_map_carrier.h"
using namespace opentracing;
using namespace opentracing::mocktracer;
int main() {
MockTracerOptions options;
std::unique_ptr<std::ostringstream> output{new std::ostringstream{}};
std::ostringstream& oss = *output;
options.recorder = std::unique_ptr<mocktracer::Recorder>{
new JsonRecorder{std::move(output)}};
std::shared_ptr<opentracing::Tracer> tracer{
new MockTracer{std::move(options)}};
auto parent_span = tracer->StartSpan("parent");
assert(parent_span);
// Create a child span.
{
auto child_span =
tracer->StartSpan("childA", {ChildOf(&parent_span->context())});
assert(child_span);
// Set a simple tag.
child_span->SetTag("simple tag", 123);
// Set a complex tag.
child_span->SetTag("complex tag",
Values{123, Dictionary{{"abc", 123}, {"xyz", 4.0}}});
// Log simple values.
child_span->Log({{"event", "simple log"}, {"abc", 123}});
// Log complex values.
child_span->Log({{"event", "complex log"},
{"data", Dictionary{{"a", 1}, {"b", Values{1, 2}}}}});
child_span->Finish();
}
// Create a follows from span.
{
auto child_span =
tracer->StartSpan("childB", {FollowsFrom(&parent_span->context())});
// child_span's destructor will finish the span if not done so explicitly.
}
// Use custom timestamps.
{
auto t1 = SystemClock::now();
auto t2 = SteadyClock::now();
auto span = tracer->StartSpan(
"useCustomTimestamps",
{ChildOf(&parent_span->context()), StartTimestamp(t1)});
assert(span);
span->Finish({FinishTimestamp(t2)});
}
// Extract and Inject a span context.
{
std::unordered_map<std::string, std::string> text_map;
TextMapCarrier carrier(text_map);
auto err = tracer->Inject(parent_span->context(), carrier);
assert(err);
auto span_context_maybe = tracer->Extract(carrier);
assert(span_context_maybe);
auto span = tracer->StartSpan("propagationSpan",
{ChildOf(span_context_maybe->get())});
}
// You get an error when trying to extract a corrupt span.
{
std::unordered_map<std::string, std::string> text_map = {
{"x-ot-span-context", "123"}};
TextMapCarrier carrier(text_map);
auto err = tracer->Extract(carrier);
assert(!err);
assert(err.error() == span_context_corrupted_error);
// How to get a readable message from the error.
std::cout << "Example error message: \"" << err.error().message() << "\"\n";
}
parent_span->Finish();
tracer->Close();
std::cout << "\nRecorded spans as JSON:\n\n";
std::cout << oss.str() << "\n";
return 0;
}
|
