func TestQueries3(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestQueries3",
Cnf: map[string]string{
conf.HTRACE_DATASTORE_HEARTBEAT_PERIOD_MS: "30000",
},
WrittenSpans: common.NewSemaphore(0),
}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
assertNumWrittenEquals(t, ht.Store.msink, len(SIMPLE_TEST_SPANS))
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.CONTAINS,
Field: common.DESCRIPTION,
Val: "Fd",
},
common.Predicate{
Op: common.GREATER_THAN_OR_EQUALS,
Field: common.BEGIN_TIME,
Val: "100",
},
},
Lim: 5,
}, []common.Span{SIMPLE_TEST_SPANS[1], SIMPLE_TEST_SPANS[2]})
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.LESS_THAN_OR_EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000000").String(),
},
},
Lim: 200,
}, []common.Span{})
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.LESS_THAN_OR_EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000002").String(),
},
},
Lim: 200,
}, []common.Span{SIMPLE_TEST_SPANS[1], SIMPLE_TEST_SPANS[0]})
}
func TestSpansToDot(t *testing.T) {
TEST_SPANS := common.SpanSlice{
&common.Span{
Id: common.TestId("814c8ee0e7984be3a8af00ac64adccb6"),
SpanData: common.SpanData{
Begin: 1424813349020,
End: 1424813349134,
Description: "newDFSInputStream",
TracerId: "FsShell",
Parents: []common.SpanId{},
Info: common.TraceInfoMap{
"path": "/",
},
},
},
&common.Span{
Id: common.TestId("cf2d5de696454548bc055d1e6024054c"),
SpanData: common.SpanData{
Begin: 1424813349025,
End: 1424813349133,
Description: "getBlockLocations",
TracerId: "FsShell",
Parents: []common.SpanId{common.TestId("814c8ee0e7984be3a8af00ac64adccb6")},
},
},
&common.Span{
Id: common.TestId("37623806f9c64483b834b8ea5d6b4827"),
SpanData: common.SpanData{
Begin: 1424813349027,
End: 1424813349073,
Description: "ClientNamenodeProtocol#getBlockLocations",
TracerId: "FsShell",
Parents: []common.SpanId{common.TestId("cf2d5de696454548bc055d1e6024054c")},
},
},
}
w := bytes.NewBuffer(make([]byte, 0, 2048))
err := spansToDot(TEST_SPANS, w)
if err != nil {
t.Fatalf("spansToDot failed: error %s\n", err.Error())
}
EXPECTED_STR := `digraph spans {
"37623806f9c64483b834b8ea5d6b4827" [label="ClientNamenodeProtocol#getBlockLocations"];
"814c8ee0e7984be3a8af00ac64adccb6" [label="newDFSInputStream"];
"cf2d5de696454548bc055d1e6024054c" [label="getBlockLocations"];
"814c8ee0e7984be3a8af00ac64adccb6" -> "cf2d5de696454548bc055d1e6024054c";
"cf2d5de696454548bc055d1e6024054c" -> "37623806f9c64483b834b8ea5d6b4827";
}
`
if w.String() != EXPECTED_STR {
t.Fatalf("Expected to get:\n%s\nGot:\n%s\n", EXPECTED_STR, w.String())
}
}
func TestQueries3(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestQueries3",
WrittenSpans: make(chan *common.Span, 100)}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
if ht.Store.GetStatistics().NumSpansWritten < uint64(len(SIMPLE_TEST_SPANS)) {
t.Fatal()
}
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.CONTAINS,
Field: common.DESCRIPTION,
Val: "Fd",
},
common.Predicate{
Op: common.GREATER_THAN_OR_EQUALS,
Field: common.BEGIN_TIME,
Val: "100",
},
},
Lim: 5,
}, []common.Span{SIMPLE_TEST_SPANS[1], SIMPLE_TEST_SPANS[2]})
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.LESS_THAN_OR_EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000000").String(),
},
},
Lim: 200,
}, []common.Span{})
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.LESS_THAN_OR_EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000002").String(),
},
},
Lim: 200,
}, []common.Span{SIMPLE_TEST_SPANS[1], SIMPLE_TEST_SPANS[0]})
}
func TestQueryRowsScanned(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestQueryRowsScanned",
WrittenSpans: common.NewSemaphore(0),
}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
assertNumWrittenEquals(t, ht.Store.msink, len(SIMPLE_TEST_SPANS))
testQueryExt(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000001").String(),
},
},
Lim: 100,
Prev: nil,
}, []common.Span{SIMPLE_TEST_SPANS[0]},
[]int{2, 1})
}
func TestReadSpans(t *testing.T) {
SPAN_TEST_STR := `{"a":"b9f2a1e07b6e4f16b0c2b27303b20e79",` +
`"b":1424736225037,"e":1424736225901,"d":"ClientNamenodeProtocol#getFileInfo",` +
`"r":"FsShell","p":["3afebdc0a13f4feb811cc5c0e42d30b1"]}
{"a":"3afebdc0a13f4feb811cc5c0e42d30b1","b":1424736224969,` +
`"e":1424736225960,"d":"getFileInfo","r":"FsShell","p":[],"n":{"path":"/"}}
`
r := strings.NewReader(SPAN_TEST_STR)
spans, err := readSpans(r)
if err != nil {
t.Fatalf("Failed to read spans from string via readSpans: %s\n", err.Error())
}
SPAN_TEST_EXPECTED := common.SpanSlice{
&common.Span{
Id: common.TestId("b9f2a1e07b6e4f16b0c2b27303b20e79"),
SpanData: common.SpanData{
Begin: 1424736225037,
End: 1424736225901,
Description: "ClientNamenodeProtocol#getFileInfo",
TracerId: "FsShell",
Parents: []common.SpanId{common.TestId("3afebdc0a13f4feb811cc5c0e42d30b1")},
},
},
&common.Span{
Id: common.TestId("3afebdc0a13f4feb811cc5c0e42d30b1"),
SpanData: common.SpanData{
Begin: 1424736224969,
End: 1424736225960,
Description: "getFileInfo",
TracerId: "FsShell",
Parents: []common.SpanId{},
Info: common.TraceInfoMap{
"path": "/",
},
},
},
}
if len(spans) != len(SPAN_TEST_EXPECTED) {
t.Fatalf("Expected %d spans, but got %d\n",
len(SPAN_TEST_EXPECTED), len(spans))
}
for i := range SPAN_TEST_EXPECTED {
common.ExpectSpansEqual(t, spans[i], SPAN_TEST_EXPECTED[i])
}
}
// Test creating a datastore and adding some spans.
func TestDatastoreWriteAndRead(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestDatastoreWriteAndRead",
Cnf: map[string]string{
conf.HTRACE_DATASTORE_HEARTBEAT_PERIOD_MS: "30000",
},
WrittenSpans: common.NewSemaphore(0),
}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
span := ht.Store.FindSpan(common.TestId("00000000000000000000000000000001"))
if span == nil {
t.Fatal()
}
if !span.Id.Equal(common.TestId("00000000000000000000000000000001")) {
t.Fatal()
}
common.ExpectSpansEqual(t, &SIMPLE_TEST_SPANS[0], span)
children := ht.Store.FindChildren(common.TestId("00000000000000000000000000000001"), 1)
if len(children) != 1 {
t.Fatalf("expected 1 child, but got %d\n", len(children))
}
children = ht.Store.FindChildren(common.TestId("00000000000000000000000000000001"), 2)
if len(children) != 2 {
t.Fatalf("expected 2 children, but got %d\n", len(children))
}
sort.Sort(common.SpanIdSlice(children))
if !children[0].Equal(common.TestId("00000000000000000000000000000002")) {
t.Fatal()
}
if !children[1].Equal(common.TestId("00000000000000000000000000000003")) {
t.Fatal()
}
}
// Test creating a datastore and adding some spans.
func TestDatastoreWriteAndRead(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestDatastoreWriteAndRead",
WrittenSpans: make(chan *common.Span, 100)}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
if ht.Store.GetStatistics().NumSpansWritten < uint64(len(SIMPLE_TEST_SPANS)) {
t.Fatal()
}
span := ht.Store.FindSpan(common.TestId("00000000000000000000000000000001"))
if span == nil {
t.Fatal()
}
if !span.Id.Equal(common.TestId("00000000000000000000000000000001")) {
t.Fatal()
}
common.ExpectSpansEqual(t, &SIMPLE_TEST_SPANS[0], span)
children := ht.Store.FindChildren(common.TestId("00000000000000000000000000000001"), 1)
if len(children) != 1 {
t.Fatalf("expected 1 child, but got %d\n", len(children))
}
children = ht.Store.FindChildren(common.TestId("00000000000000000000000000000001"), 2)
if len(children) != 2 {
t.Fatalf("expected 2 children, but got %d\n", len(children))
}
sort.Sort(common.SpanIdSlice(children))
if !children[0].Equal(common.TestId("00000000000000000000000000000002")) {
t.Fatal()
}
if !children[1].Equal(common.TestId("00000000000000000000000000000003")) {
t.Fatal()
}
}
func TestQueriesWithContinuationTokens1(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestQueriesWithContinuationTokens1",
Cnf: map[string]string{
conf.HTRACE_DATASTORE_HEARTBEAT_PERIOD_MS: "30000",
},
WrittenSpans: common.NewSemaphore(0),
}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
assertNumWrittenEquals(t, ht.Store.msink, len(SIMPLE_TEST_SPANS))
// Adding a prev value to this query excludes the first result that we
// would normally get.
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.GREATER_THAN,
Field: common.BEGIN_TIME,
Val: "120",
},
},
Lim: 5,
Prev: &SIMPLE_TEST_SPANS[0],
}, []common.Span{SIMPLE_TEST_SPANS[1], SIMPLE_TEST_SPANS[2]})
// There is only one result from an EQUALS query on SPAN_ID.
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000001").String(),
},
},
Lim: 100,
Prev: &SIMPLE_TEST_SPANS[0],
}, []common.Span{})
// When doing a LESS_THAN_OR_EQUALS search, we still don't get back the
// span we pass as a continuation token. (Primary index edition).
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.LESS_THAN_OR_EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000002").String(),
},
},
Lim: 100,
Prev: &SIMPLE_TEST_SPANS[1],
}, []common.Span{SIMPLE_TEST_SPANS[0]})
// When doing a GREATER_THAN_OR_EQUALS search, we still don't get back the
// span we pass as a continuation token. (Secondary index edition).
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.GREATER_THAN,
Field: common.DURATION,
Val: "0",
},
},
Lim: 100,
Prev: &SIMPLE_TEST_SPANS[1],
}, []common.Span{SIMPLE_TEST_SPANS[2], SIMPLE_TEST_SPANS[0]})
}
"time"
)
// Test creating and tearing down a datastore.
func TestCreateDatastore(t *testing.T) {
htraceBld := &MiniHTracedBuilder{Name: "TestCreateDatastore",
DataDirs: make([]string, 3)}
ht, err := htraceBld.Build()
if err != nil {
t.Fatalf("failed to create datastore: %s", err.Error())
}
defer ht.Close()
}
var SIMPLE_TEST_SPANS []common.Span = []common.Span{
common.Span{Id: common.TestId("00000000000000000000000000000001"),
SpanData: common.SpanData{
Begin: 123,
End: 456,
Description: "getFileDescriptors",
Parents: []common.SpanId{},
TracerId: "firstd",
}},
common.Span{Id: common.TestId("00000000000000000000000000000002"),
SpanData: common.SpanData{
Begin: 125,
End: 200,
Description: "openFd",
Parents: []common.SpanId{common.TestId("00000000000000000000000000000001")},
TracerId: "secondd",
}},
func TestQueriesWithContinuationTokens1(t *testing.T) {
t.Parallel()
htraceBld := &MiniHTracedBuilder{Name: "TestQueriesWithContinuationTokens1",
WrittenSpans: make(chan *common.Span, 100)}
ht, err := htraceBld.Build()
if err != nil {
panic(err)
}
defer ht.Close()
createSpans(SIMPLE_TEST_SPANS, ht.Store)
if ht.Store.GetStatistics().NumSpansWritten < uint64(len(SIMPLE_TEST_SPANS)) {
t.Fatal()
}
// Adding a prev value to this query excludes the first result that we
// would normally get.
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.GREATER_THAN,
Field: common.BEGIN_TIME,
Val: "120",
},
},
Lim: 5,
Prev: &SIMPLE_TEST_SPANS[0],
}, []common.Span{SIMPLE_TEST_SPANS[1], SIMPLE_TEST_SPANS[2]})
// There is only one result from an EQUALS query on SPAN_ID.
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000001").String(),
},
},
Lim: 100,
Prev: &SIMPLE_TEST_SPANS[0],
}, []common.Span{})
// When doing a LESS_THAN_OR_EQUALS search, we still don't get back the
// span we pass as a continuation token. (Primary index edition).
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.LESS_THAN_OR_EQUALS,
Field: common.SPAN_ID,
Val: common.TestId("00000000000000000000000000000002").String(),
},
},
Lim: 100,
Prev: &SIMPLE_TEST_SPANS[1],
}, []common.Span{SIMPLE_TEST_SPANS[0]})
// When doing a GREATER_THAN_OR_EQUALS search, we still don't get back the
// span we pass as a continuation token. (Secondary index edition).
testQuery(t, ht, &common.Query{
Predicates: []common.Predicate{
common.Predicate{
Op: common.GREATER_THAN,
Field: common.DURATION,
Val: "0",
},
},
Lim: 100,
Prev: &SIMPLE_TEST_SPANS[1],
}, []common.Span{SIMPLE_TEST_SPANS[2], SIMPLE_TEST_SPANS[0]})
}
