func start(ctx *cli.Context) {
if ctx.Bool("profile") {
pcfg := profile.Config{
CPUProfile: true,
MemProfile: true,
BlockProfile: true,
ProfilePath: ".",
}
p := profile.Start(&pcfg)
defer p.Stop()
}
initLogrus(ctx)
log.Info("Starting fullerite...")
c, err := config.ReadConfig(ctx.String("config"))
if err != nil {
return
}
collectors := startCollectors(c)
handlers := startHandlers(c)
internalServer := internalserver.New(c, &handlers)
go internalServer.Run()
metrics := make(chan metric.Metric)
readFromCollectors(collectors, metrics)
hook := NewLogErrorHook(metrics)
log.Logger.Hooks.Add(hook)
relayMetricsToHandlers(handlers, metrics)
}
func start(ctx *cli.Context) {
if ctx.Bool("profile") {
defer profile.Start(profile.CPUProfile).Stop()
defer profile.Start(profile.MemProfile).Stop()
defer profile.Start(profile.BlockProfile).Stop()
defer profile.Start(profile.ProfilePath("."))
}
quit := make(chan bool)
initLogrus(ctx)
log.Info("Starting fullerite...")
c, err := config.ReadConfig(ctx.String("config"))
if err != nil {
return
}
handlers := createHandlers(c)
hook := NewLogErrorHook(handlers)
log.Logger.Hooks.Add(hook)
startHandlers(handlers)
collectors := startCollectors(c)
collectorStatChan := make(chan metric.CollectorEmission)
internalServer := internalserver.New(c,
handlerStatFunc(handlers),
readCollectorStat(collectorStatChan))
go internalServer.Run()
readFromCollectors(collectors, handlers, collectorStatChan)
<-quit
}
func start(ctx *cli.Context) {
if ctx.Bool("profile") {
pcfg := profile.Config{
CPUProfile: true,
MemProfile: true,
BlockProfile: true,
ProfilePath: ".",
}
p := profile.Start(&pcfg)
defer p.Stop()
}
initLogrus(ctx)
log.Info("Starting fullerite...")
c, err := config.ReadConfig(ctx.String("config"))
if err != nil {
return
}
collectors := startCollectors(c)
handlers := startHandlers(c)
metrics := make(chan metric.Metric)
readFromCollectors(collectors, metrics)
for metric := range metrics {
// Writing to handlers' channels. Sending metrics is
// handled asynchronously in handlers' Run functions.
writeToHandlers(handlers, metric)
}
}
func TestStartCollectorsMixedConfig(t *testing.T) {
logrus.SetLevel(logrus.ErrorLevel)
conf, _ := config.ReadConfig(tmpTestFakeFile)
collectors := startCollectors(conf)
for _, c := range collectors {
assert.Equal(t, c.Name(), "Test", "Only create valid collectors")
}
}
func visualize(ctx *cli.Context) {
initLogrus(ctx)
log.Info("Visualizing fullerite...")
if len(ctx.Args()) == 0 {
log.Error("You need a collector file to visualize!, see 'fullerite help visualize'")
return
}
c, err := config.ReadConfig(ctx.String("config"))
if err != nil {
return
}
// Setup AdHoc Collector config from context and args
collectorFile, _ := filepath.Abs(ctx.Args()[0])
configMap := make(map[string]interface{})
configMap["interval"] = ctx.Int("interval")
configMap["collectorFile"] = collectorFile
// Start collector and handlers
collector := startCollector("AdHoc", c, configMap)
handlers := startHandlers(c)
// Create channel for incoming metrics
metrics := make(chan metric.Metric)
defer close(metrics)
// Read the metrics from the AdHoc collector
go readFromCollector(collector, metrics)
go relayMetricsToHandlers(handlers, metrics)
// Stop collecting after `die-after` duration expires
quitChannel := make(chan bool, 1)
defer close(quitChannel)
dieAfter := time.Duration(ctx.Int("die-after"))
time.AfterFunc(dieAfter*time.Second, func() {
log.Info("Quitting...")
quitChannel <- true
})
// Wait to quit
for {
select {
case <-quitChannel:
return
}
}
}
func start(ctx *cli.Context) {
initLogrus(ctx)
log.Info("Starting beatit...")
runtime.GOMAXPROCS(runtime.NumCPU())
c, err := config.ReadConfig(ctx.String("config"))
if err != nil {
return
}
var handlers []handler.Handler
for i := 0; i < ctx.Int("num-tasks"); i++ {
if ctx.Bool("graphite") {
h := newHandler("Graphite", c, ctx.Int("num-datapoints"))
go h.Run()
handlers = append(handlers, h)
}
if ctx.Bool("signalfx") {
h := newHandler("SignalFx", c, ctx.Int("num-datapoints"))
go h.Run()
handlers = append(handlers, h)
}
if ctx.Bool("datadog") {
h := newHandler("Datadog", c, ctx.Int("num-datapoints"))
go h.Run()
handlers = append(handlers, h)
}
}
t := time.Tick(1 * time.Second)
count := 0
for _ = range t {
if count++; count > ctx.Int("time") {
os.Exit(0)
}
metrics := generateMetrics(ctx.String("prefix"),
ctx.Int("num-metrics"),
ctx.Int("num-datapoints"),
ctx.Bool("randomize"))
for _, h := range handlers {
go sendMetrics(h, metrics)
}
}
}
func TestParseBadConfig(t *testing.T) {
_, err := config.ReadConfig(tmpTestBadFile)
assert.NotNil(t, err, "should fail")
}
func TestParseGoodConfig(t *testing.T) {
_, err := config.ReadConfig(tmpTestGoodFile)
assert.Nil(t, err, "should succeed")
}