func ExampleIncludeNodes_multipleNodes() {
inputRecords := store.SliceStore{}
inputRecords.BeginWriting()
inputRecords.WriteRecord(makeRecordToInclude("node1", 1))
inputRecords.WriteRecord(makeRecordToInclude("node1", 2))
inputRecords.WriteRecord(makeRecordToInclude("node2", 3))
inputRecords.WriteRecord(makeRecordToInclude("node2", 4))
inputRecords.WriteRecord(makeRecordToInclude("node2", 5))
inputRecords.WriteRecord(makeRecordToInclude("node3", 6))
inputRecords.WriteRecord(makeRecordToInclude("node3", 7))
inputRecords.WriteRecord(makeRecordToInclude("node4", 8))
inputRecords.WriteRecord(makeRecordToInclude("node4", 9))
inputRecords.WriteRecord(makeRecordToInclude("node5", 10))
inputRecords.WriteRecord(makeRecordToInclude("node6", 11))
inputRecords.WriteRecord(makeRecordToInclude("node7", 12))
inputRecords.EndWriting()
outputRecords := FilterNodes(&inputRecords, "node2", "node4", "node5", "node7")
runIncludeNodes(outputRecords)
// Output:
// node2 3
// node2 4
// node2 5
// node4 8
// node4 9
// node5 10
// node7 12
}
func runCalculateTraceKeyRanges(records []*store.Record) {
traces := store.SliceStore{}
traces.BeginWriting()
for _, record := range records {
traces.WriteRecord(record)
}
traces.EndWriting()
rangesStore := store.SliceStore{}
consolidatedStore := store.SliceStore{}
transformer.RunPipeline(TraceKeyRangesPipeline(&traces, &rangesStore, &consolidatedStore))
rangesStore.BeginReading()
for {
record, err := rangesStore.ReadRecord()
if err != nil {
panic(err)
}
if record == nil {
break
}
fmt.Printf("%s %s\n", formatTraceKey(record.Key), formatTraceKey(record.Value))
}
rangesStore.EndReading()
}
func runSessions(records []*store.Record) {
traces := store.SliceStore{}
traces.BeginWriting()
for _, record := range records {
traces.WriteRecord(record)
}
traces.EndWriting()
sessionsStore := store.SliceStore{}
transformer.RunPipeline([]transformer.PipelineStage{
SessionPipelineStage(&traces, &sessionsStore),
})
sessionsStore.BeginReading()
for {
record, err := sessionsStore.ReadRecord()
if err != nil {
panic(err)
}
if record == nil {
break
}
fmt.Printf("%s\n", formatSessionKey(record.Key))
}
sessionsStore.EndReading()
}
func ExampleJoin_inner() {
left := store.SliceStore{}
left.BeginWriting()
left.WriteRecord(store.NewRecord("1", "news", 0))
left.WriteRecord(store.NewRecord("2", "book", 0))
left.EndWriting()
right := store.SliceStore{}
right.BeginWriting()
right.WriteRecord(store.NewRecord("1", "paper", 0))
right.WriteRecord(store.NewRecord("3", "brush", 0))
right.EndWriting()
output := store.SliceStore{}
joiner := Join(nil, nil)
transformer.RunTransformer(transformer.MakeGroupDoFunc(joiner), store.NewDemuxingReader(&left, &right), &output)
output.BeginReading()
for {
record, err := output.ReadRecord()
if err != nil {
panic(err)
}
if record == nil {
break
}
fmt.Printf("%s: %s\n", record.Key, record.Value)
}
output.EndReading()
// Output:
//
// 1: newspaper
}
func FilterNodes(reader store.Seeker, nodes ...string) store.Seeker {
nodesStore := store.SliceStore{}
nodesStore.BeginWriting()
for _, node := range nodes {
nodesStore.WriteRecord(&store.Record{
Key: lex.EncodeOrDie(node),
})
}
nodesStore.EndWriting()
return store.NewPrefixIncludingReader(reader, &nodesStore)
}
func ReadOnlySomeLogs(stor store.Seeker, logTypes ...string) store.Seeker {
prefixStore := store.SliceStore{}
prefixStore.BeginWriting()
for _, logType := range logTypes {
record := store.Record{
Key: lex.EncodeOrDie(logType),
}
prefixStore.WriteRecord(&record)
}
prefixStore.EndWriting()
return store.NewPrefixIncludingReader(stor, &prefixStore)
}
func ExampleIncludeNodes() {
inputRecords := store.SliceStore{}
inputRecords.BeginWriting()
inputRecords.WriteRecord(makeRecordToInclude("node1", 1))
inputRecords.WriteRecord(makeRecordToInclude("node1", 2))
inputRecords.WriteRecord(makeRecordToInclude("node2", 3))
inputRecords.WriteRecord(makeRecordToInclude("node2", 4))
inputRecords.WriteRecord(makeRecordToInclude("node2", 5))
inputRecords.WriteRecord(makeRecordToInclude("node3", 6))
inputRecords.EndWriting()
outputRecords := FilterNodes(&inputRecords, "node2")
runIncludeNodes(outputRecords)
// Output:
// node2 3
// node2 4
// node2 5
}
func ExampleJoin_multiple() {
left := store.SliceStore{}
left.BeginWriting()
left.WriteRecord(store.NewRecord("1", "what", 0))
left.WriteRecord(store.NewRecord("2", "news", 0))
left.EndWriting()
middle := store.SliceStore{}
middle.BeginWriting()
middle.WriteRecord(store.NewRecord("1", "so", 0))
middle.WriteRecord(store.NewRecord("3", "the", 0))
middle.EndWriting()
right := store.SliceStore{}
right.BeginWriting()
right.WriteRecord(store.NewRecord("1", "ever", 0))
right.WriteRecord(store.NewRecord("3", "less", 0))
right.EndWriting()
output := store.SliceStore{}
joiner := Join([]byte("never"), []byte("paper"), []byte("man"))
transformer.RunTransformer(transformer.MakeGroupDoFunc(joiner), store.NewDemuxingReader(&left, &middle, &right), &output)
output.BeginReading()
for {
record, err := output.ReadRecord()
if err != nil {
panic(err)
}
if record == nil {
break
}
fmt.Printf("%s: %s\n", record.Key, record.Value)
}
output.EndReading()
// Output:
//
// 1: whatsoever
// 2: newspaperman
// 3: nevertheless
}