func TestTraceReportingEnabled(t *testing.T) {
initialTime := time.Date(2015, 2, 1, 10, 10, 0, 0, time.UTC)
var state struct {
signal chan struct{}
call TraceData
span Span
}
testTraceReporter := TraceReporterFunc(func(data TraceData) {
defer close(state.signal)
span := data.Span
data.Span = Span{}
state.call = data
state.span = span
})
traceReporterOpts := testutils.NewOpts().SetTraceReporter(testTraceReporter)
tests := []struct {
name string
serverOpts *testutils.ChannelOpts
clientOpts *testutils.ChannelOpts
expected []Annotation
fromServer bool
}{
{
name: "inbound",
serverOpts: traceReporterOpts,
expected: []Annotation{
{Key: "sr", Timestamp: initialTime.Add(2 * time.Second)},
{Key: "ss", Timestamp: initialTime.Add(3 * time.Second)},
},
fromServer: true,
},
{
name: "outbound",
clientOpts: traceReporterOpts,
expected: []Annotation{
{Key: "cs", Timestamp: initialTime.Add(time.Second)},
{Key: "cr", Timestamp: initialTime.Add(6 * time.Second)},
},
},
}
for _, tt := range tests {
state.signal = make(chan struct{})
serverNow, serverNowFn := testutils.NowStub(initialTime.Add(time.Second))
clientNow, clientNowFn := testutils.NowStub(initialTime)
serverNowFn(time.Second)
clientNowFn(time.Second)
tt.serverOpts = testutils.DefaultOpts(tt.serverOpts).SetTimeNow(serverNow)
tt.clientOpts = testutils.DefaultOpts(tt.clientOpts).SetTimeNow(clientNow)
WithVerifiedServer(t, tt.serverOpts, func(ch *Channel, hostPort string) {
testutils.RegisterEcho(ch, func() {
clientNowFn(5 * time.Second)
})
clientCh := testutils.NewClient(t, tt.clientOpts)
defer clientCh.Close()
ctx, cancel := NewContext(time.Second)
defer cancel()
_, _, _, err := raw.Call(ctx, clientCh, hostPort, ch.PeerInfo().ServiceName, "echo", nil, []byte("arg3"))
require.NoError(t, err, "raw.Call failed")
binaryAnnotations := []BinaryAnnotation{
{"cn", clientCh.PeerInfo().ServiceName},
{"as", Raw.String()},
}
target := TraceEndpoint{
HostPort: hostPort,
ServiceName: ch.ServiceName(),
}
source := target
if !tt.fromServer {
source = TraceEndpoint{
HostPort: "0.0.0.0:0",
ServiceName: clientCh.ServiceName(),
}
}
select {
case <-state.signal:
case <-time.After(time.Second):
t.Fatalf("Did not receive trace report within timeout")
}
expected := TraceData{Annotations: tt.expected, BinaryAnnotations: binaryAnnotations, Source: source, Target: target, Method: "echo"}
assert.Equal(t, expected, state.call, "%v: Report args mismatch", tt.name)
curSpan := CurrentSpan(ctx)
assert.Equal(t, NewSpan(curSpan.TraceID(), 0, curSpan.TraceID()), state.span, "Span mismatch")
})
}
}
func TestTraceReportingEnabled(t *testing.T) {
initialTime := time.Date(2015, 2, 1, 10, 10, 0, 0, time.UTC)
var gotCalls []traceReportArgs
var gotSpans []Span
testTraceReporter := TraceReporterFunc(func(span Span, annotations []Annotation, binaryAnnotations []BinaryAnnotation, targetEndpoint TargetEndpoint) {
gotCalls = append(gotCalls, traceReportArgs{annotations, binaryAnnotations, targetEndpoint})
gotSpans = append(gotSpans, span)
})
traceReporterOpts := testutils.NewOpts().SetTraceReporter(testTraceReporter)
tests := []struct {
name string
serverOpts *testutils.ChannelOpts
clientOpts *testutils.ChannelOpts
expected []Annotation
}{
{
name: "inbound",
serverOpts: traceReporterOpts,
expected: []Annotation{
{Key: "sr", Timestamp: initialTime.Add(3 * time.Second)},
{Key: "ss", Timestamp: initialTime.Add(5 * time.Second)},
},
},
{
name: "outbound",
clientOpts: traceReporterOpts,
expected: []Annotation{
{Key: "cs", Timestamp: initialTime.Add(1 * time.Second)},
{Key: "cr", Timestamp: initialTime.Add(7 * time.Second)},
},
},
}
for _, tt := range tests {
gotCalls, gotSpans = nil, nil
nowStub, addFn := testutils.NowStub(initialTime)
tt.serverOpts = testutils.DefaultOpts(tt.serverOpts).SetTimeNow(nowStub)
tt.clientOpts = testutils.DefaultOpts(tt.clientOpts).SetTimeNow(nowStub)
addFn(time.Second)
WithVerifiedServer(t, tt.serverOpts, func(ch *Channel, hostPort string) {
ch.Register(raw.Wrap(newTestHandler(t)), "echo")
clientCh := testutils.NewClient(t, tt.clientOpts)
defer clientCh.Close()
ctx, cancel := NewContext(time.Second)
defer cancel()
_, _, _, err := raw.Call(ctx, clientCh, hostPort, ch.PeerInfo().ServiceName, "echo", nil, []byte("arg3"))
require.NoError(t, err, "raw.Call failed")
binaryAnnotations := []BinaryAnnotation{
{"cn", clientCh.PeerInfo().ServiceName},
{"as", Raw.String()},
}
targetEndpoint := TargetEndpoint{
HostPort: hostPort,
ServiceName: ch.PeerInfo().ServiceName,
Operation: "echo",
}
expected := []traceReportArgs{{tt.expected, binaryAnnotations, targetEndpoint}}
assert.Equal(t, expected, gotCalls, "%v: Report args mismatch", tt.name)
curSpan := CurrentSpan(ctx)
assert.Equal(t, NewSpan(curSpan.TraceID(), 0, curSpan.TraceID()), gotSpans[0], "Span mismatch")
})
}
}