func NewReaper(cnf *conf.Config) *Reaper {
rpr := &Reaper{
lg: common.NewLogger("reaper", cnf),
spanExpiryMs: cnf.GetInt64(conf.HTRACE_SPAN_EXPIRY_MS),
heartbeats: make(chan interface{}, 1),
}
if rpr.spanExpiryMs >= MAX_SPAN_EXPIRY_MS {
rpr.spanExpiryMs = MAX_SPAN_EXPIRY_MS
} else if rpr.spanExpiryMs <= 0 {
rpr.spanExpiryMs = MAX_SPAN_EXPIRY_MS
}
rpr.hb = NewHeartbeater("ReaperHeartbeater",
cnf.GetInt64(conf.HTRACE_REAPER_HEARTBEAT_PERIOD_MS), rpr.lg)
rpr.exited.Add(1)
go rpr.run()
rpr.hb.AddHeartbeatTarget(&HeartbeatTarget{
name: "reaper",
targetChan: rpr.heartbeats,
})
var when string
if rpr.spanExpiryMs >= MAX_SPAN_EXPIRY_MS {
when = "never"
} else {
when = "after " + time.Duration(rpr.spanExpiryMs).String()
}
rpr.lg.Infof("Initializing span reaper: span time out = %s.\n", when)
return rpr
}
func CreateHrpcServer(cnf *conf.Config, store *dataStore,
testHooks *hrpcTestHooks) (*HrpcServer, error) {
lg := common.NewLogger("hrpc", cnf)
numHandlers := cnf.GetInt(conf.HTRACE_NUM_HRPC_HANDLERS)
if numHandlers < 1 {
lg.Warnf("%s must be positive: using 1 handler.\n", conf.HTRACE_NUM_HRPC_HANDLERS)
numHandlers = 1
}
if numHandlers > MAX_HRPC_HANDLERS {
lg.Warnf("%s cannot be more than %d: using %d handlers\n",
conf.HTRACE_NUM_HRPC_HANDLERS, MAX_HRPC_HANDLERS, MAX_HRPC_HANDLERS)
numHandlers = MAX_HRPC_HANDLERS
}
hsv := &HrpcServer{
Server: rpc.NewServer(),
hand: &HrpcHandler{
lg: lg,
store: store,
},
cdcs: make(chan *HrpcServerCodec, numHandlers),
shutdown: make(chan interface{}),
ioTimeo: time.Millisecond *
time.Duration(cnf.GetInt64(conf.HTRACE_HRPC_IO_TIMEOUT_MS)),
testHooks: testHooks,
}
for i := 0; i < numHandlers; i++ {
hsv.cdcs <- &HrpcServerCodec{
lg: lg,
hsv: hsv,
msgpackHandle: codec.MsgpackHandle{
WriteExt: true,
},
}
}
var err error
hsv.listener, err = net.Listen("tcp", cnf.Get(conf.HTRACE_HRPC_ADDRESS))
if err != nil {
return nil, err
}
hsv.Server.Register(hsv.hand)
hsv.exited.Add(1)
go hsv.run()
lg.Infof("Started HRPC server on %s with %d handler routines. "+
"ioTimeo=%s.\n", hsv.listener.Addr().String(), numHandlers,
hsv.ioTimeo.String())
return hsv, nil
}
func CreateDataStore(cnf *conf.Config, writtenSpans *common.Semaphore) (*dataStore, error) {
dld := NewDataStoreLoader(cnf)
defer dld.Close()
err := dld.Load()
if err != nil {
dld.lg.Errorf("Error loading datastore: %s\n", err.Error())
return nil, err
}
store := &dataStore{
lg: dld.lg,
shards: make([]*shard, len(dld.shards)),
readOpts: dld.readOpts,
writeOpts: dld.writeOpts,
WrittenSpans: writtenSpans,
msink: NewMetricsSink(cnf),
hb: NewHeartbeater("DatastoreHeartbeater",
cnf.GetInt64(conf.HTRACE_DATASTORE_HEARTBEAT_PERIOD_MS), dld.lg),
rpr: NewReaper(cnf),
startMs: common.TimeToUnixMs(time.Now().UTC()),
}
spanBufferSize := cnf.GetInt(conf.HTRACE_DATA_STORE_SPAN_BUFFER_SIZE)
for shdIdx := range store.shards {
shd := &shard{
store: store,
ldb: dld.shards[shdIdx].ldb,
path: dld.shards[shdIdx].path,
incoming: make(chan []*IncomingSpan, spanBufferSize),
heartbeats: make(chan interface{}, 1),
}
shd.exited.Add(1)
go shd.processIncoming()
store.shards[shdIdx] = shd
store.hb.AddHeartbeatTarget(&HeartbeatTarget{
name: fmt.Sprintf("shard(%s)", shd.path),
targetChan: shd.heartbeats,
})
}
dld.DisownResources()
return store, nil
}