func main() {
fmt.Println("allocating 1100 kB every second. should hit the 10MB threshold within 10 seconds. look for a profile..")
errors := make(chan error)
trigger, _ := heap.New(".", 10000000, 60, time.Duration(1)*time.Second, errors)
go trigger.Run()
go HungryAllocator()
go LightAllocator()
for e := range errors {
log.Fatal("profiletrigger heap saw error:", e)
}
}
func main() {
buildstampInt64, _ := strconv.ParseInt(buildstamp, 10, 64)
setting.BuildVersion = version
setting.BuildCommit = commit
setting.BuildStamp = buildstampInt64
go listenToSystemSignels()
flag.Parse()
writePIDFile()
initRuntime()
if setting.ProfileHeapMB > 0 {
errors := make(chan error)
go func() {
for e := range errors {
log.Error(0, e.Error())
}
}()
heap, _ := heap.New(setting.ProfileHeapDir, setting.ProfileHeapMB*1000000, setting.ProfileHeapWait, time.Duration(1)*time.Second, errors)
go heap.Run()
}
search.Init()
login.Init()
social.NewOAuthService()
eventpublisher.Init()
plugins.Init()
elasticstore.Init()
metricsBackend, err := helper.New(setting.StatsdEnabled, setting.StatsdAddr, setting.StatsdType, "grafana", setting.InstanceId)
if err != nil {
log.Error(3, "Statsd client:", err)
}
metricpublisher.Init(metricsBackend)
collectoreventpublisher.Init(metricsBackend)
api.InitCollectorController(metricsBackend)
if setting.AlertingEnabled {
alerting.Init(metricsBackend)
alerting.Construct()
}
if err := notifications.Init(); err != nil {
log.Fatal(3, "Notification service failed to initialize", err)
}
if setting.ReportingEnabled {
go metrics.StartUsageReportLoop()
}
cmd.StartServer()
exitChan <- 0
}
func main() {
flag.Parse()
if *showVersion {
fmt.Printf("statsdaemon v%s (built w/%s, git hash %s)\n", VERSION, runtime.Version(), GitHash)
return
}
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *memprofile != "" {
f, err := os.Create(*memprofile)
if err != nil {
log.Fatal(err)
}
defer f.Close()
defer pprof.WriteHeapProfile(f)
}
err := config.Parse(*config_file)
if err != nil {
fmt.Println(fmt.Sprintf("Could not read config file: %v", err))
return
}
proftrigHeapFreq := dur.MustParseUsec("proftrigger_heap_freq", *proftrigHeapFreqStr)
proftrigHeapMinDiff := int(dur.MustParseUNsec("proftrigger_heap_min_diff", *proftrigHeapMinDiffStr))
proftrigCpuFreq := dur.MustParseUsec("proftrigger_cpu_freq", *proftrigCpuFreqStr)
proftrigCpuMinDiff := int(dur.MustParseUNsec("proftrigger_cpu_min_diff", *proftrigCpuMinDiffStr))
proftrigCpuDur := int(dur.MustParseUNsec("proftrigger_cpu_dur", *proftrigCpuDurStr))
if proftrigHeapFreq > 0 {
errors := make(chan error)
trigger, _ := heap.New(*proftrigPath, *proftrigHeapThresh, proftrigHeapMinDiff, time.Duration(proftrigHeapFreq)*time.Second, errors)
go func() {
for e := range errors {
log.Printf("profiletrigger heap: %s", e)
}
}()
go trigger.Run()
}
if proftrigCpuFreq > 0 {
errors := make(chan error)
freq := time.Duration(proftrigCpuFreq) * time.Second
duration := time.Duration(proftrigCpuDur) * time.Second
trigger, _ := cpu.New(*proftrigPath, *proftrigCpuThresh, proftrigCpuMinDiff, freq, duration, errors)
go func() {
for e := range errors {
log.Printf("profiletrigger cpu: %s", e)
}
}()
go trigger.Run()
}
runtime.GOMAXPROCS(*processes)
pct, err := timers.NewPercentiles(*percentile_thresholds)
if err != nil {
log.Fatal(err)
}
inst := os.Expand(*instance, expand_cfg_vars)
if inst == "" {
inst = "null"
}
signalchan := make(chan os.Signal, 1)
signal.Notify(signalchan)
if *profile_addr != "" {
go func() {
fmt.Println("Profiling endpoint listening on " + *profile_addr)
log.Println(http.ListenAndServe(*profile_addr, nil))
}()
}
daemon := statsdaemon.New(inst, *prefix_rates, *prefix_timers, *prefix_gauges, *prefix_counters, *pct, *flushInterval, MAX_UNPROCESSED_PACKETS, *max_timers_per_s, signalchan, *debug, *legacy_namespace, *flush_rates, *flush_counts)
if *debug {
consumer := make(chan interface{}, 100)
daemon.Invalid_lines.Register(consumer)
go func() {
for line := range consumer {
log.Printf("invalid line '%s'\n", line)
}
}()
}
daemon.Run(*listen_addr, *admin_addr, *graphite_addr)
}