func main() {
configFile := flag.String("c", "", "config file (json)")
port := flag.Int("p", 0, "port to listen on")
maxprocs := flag.Int("maxprocs", 0, "GOMAXPROCS")
debugLevel := flag.Int("d", 0, "enable debug logging")
logtostdout := flag.Bool("stdout", false, "write logging output also to stdout")
logdir := flag.String("logdir", "/var/log/carbonzipper/", "logging directory")
flag.Parse()
expvar.NewString("BuildVersion").Set(BuildVersion)
if *configFile == "" {
log.Fatal("missing config file")
}
cfgjs, err := ioutil.ReadFile(*configFile)
if err != nil {
log.Fatal("unable to load config file:", err)
}
cfgjs = stripCommentHeader(cfgjs)
if cfgjs == nil {
log.Fatal("error removing header comment from ", *configFile)
}
err = json.Unmarshal(cfgjs, &Config)
if err != nil {
log.Fatal("error parsing config file: ", err)
}
if len(Config.Backends) == 0 {
log.Fatal("no Backends loaded -- exiting")
}
// command line overrides config file
if *port != 0 {
Config.Port = *port
}
if *maxprocs != 0 {
Config.MaxProcs = *maxprocs
}
// set up our logging
rl := rotatelogs.NewRotateLogs(
*logdir + "/carbonzipper.%Y%m%d%H%M.log",
)
// Optional fields must be set afterwards
rl.LinkName = *logdir + "/carbonzipper.log"
if *logtostdout {
log.SetOutput(io.MultiWriter(os.Stdout, rl))
} else {
log.SetOutput(rl)
}
logger = logLevel(*debugLevel)
logger.Logln("starting carbonzipper", BuildVersion)
logger.Logln("setting GOMAXPROCS=", Config.MaxProcs)
runtime.GOMAXPROCS(Config.MaxProcs)
if Config.ConcurrencyLimitPerServer != 0 {
logger.Logln("Setting concurrencyLimit", Config.ConcurrencyLimitPerServer)
Limiter = newServerLimiter(Config.Backends, Config.ConcurrencyLimitPerServer)
}
// +1 to track every over the number of buckets we track
timeBuckets = make([]int64, Config.Buckets+1)
httputil.PublishTrackedConnections("httptrack")
expvar.Publish("requestBuckets", expvar.Func(renderTimeBuckets))
// export config via expvars
expvar.Publish("Config", expvar.Func(func() interface{} { return Config }))
http.HandleFunc("/metrics/find/", httputil.TrackConnections(httputil.TimeHandler(findHandler, bucketRequestTimes)))
http.HandleFunc("/render/", httputil.TrackConnections(httputil.TimeHandler(renderHandler, bucketRequestTimes)))
http.HandleFunc("/info/", httputil.TrackConnections(httputil.TimeHandler(infoHandler, bucketRequestTimes)))
http.HandleFunc("/lb_check", lbCheckHandler)
// nothing in the config? check the environment
if Config.GraphiteHost == "" {
if host := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); host != ":" {
Config.GraphiteHost = host
}
}
// only register g2g if we have a graphite host
if Config.GraphiteHost != "" {
logger.Logln("Using graphite host", Config.GraphiteHost)
// register our metrics with graphite
graphite, err := g2g.NewGraphite(Config.GraphiteHost, 60*time.Second, 10*time.Second)
if err != nil {
log.Fatal("unable to connect to to graphite: ", Config.GraphiteHost, ":", err)
}
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.find_requests", hostname), Metrics.FindRequests)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.find_errors", hostname), Metrics.FindErrors)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.render_requests", hostname), Metrics.RenderRequests)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.render_errors", hostname), Metrics.RenderErrors)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.info_requests", hostname), Metrics.InfoRequests)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.info_errors", hostname), Metrics.InfoErrors)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.timeouts", hostname), Metrics.Timeouts)
for i := 0; i <= Config.Buckets; i++ {
graphite.Register(fmt.Sprintf("carbon.zipper.%s.requests_in_%dms_to_%dms", hostname, i*100, (i+1)*100), bucketEntry(i))
}
}
// configure the storage client
storageClient.Transport = &http.Transport{
MaxIdleConnsPerHost: Config.MaxIdleConnsPerHost,
}
go probeTlds()
// force run now
probeForce <- 1
portStr := fmt.Sprintf(":%d", Config.Port)
logger.Logln("listening on", portStr)
log.Fatal(http.ListenAndServe(portStr, nil))
}
func main() {
addr := flag.String("a", ":2003", "address to bind to")
reportaddr := flag.String("reportaddr", ":8080", "address to bind http report interface to")
verbose := flag.Bool("v", false, "enable verbose logging")
debug := flag.Bool("vv", false, "enable more verbose (debug) logging")
whisperdata := flag.String("w", config.WhisperData, "location where whisper files are stored")
maxprocs := flag.Int("maxprocs", runtime.NumCPU()*80/100, "GOMAXPROCS")
logdir := flag.String("logdir", "/var/log/carbonwriter/", "logging directory")
schemafile := flag.String("schemafile", "/etc/carbon/storage-schemas.conf", "storage-schemas.conf location")
aggrfile := flag.String("aggrfile", "/etc/carbon/storage-aggregation.conf", "storage-aggregation.conf location")
logtostdout := flag.Bool("stdout", false, "log also to stdout")
flag.Parse()
rl := rotatelogs.NewRotateLogs(
*logdir + "/carbonwriter.%Y%m%d%H%M.log",
)
// Optional fields must be set afterwards
rl.LinkName = *logdir + "/carbonwriter.log"
if *logtostdout {
log.SetOutput(io.MultiWriter(os.Stdout, rl))
} else {
log.SetOutput(rl)
}
expvar.NewString("BuildVersion").Set(BuildVersion)
log.Println("starting carbonwriter", BuildVersion)
loglevel := LOG_NORMAL
if *verbose {
loglevel = LOG_DEBUG
}
if *debug {
loglevel = LOG_TRACE
}
logger = logLevel(loglevel)
schemas, err := readStorageSchemas(*schemafile)
if err != nil {
logger.Logf("failed to read %s: %s", *schemafile, err.Error())
os.Exit(1)
}
aggrs, err := readStorageAggregations(*aggrfile)
if err != nil {
logger.Logf("failed to read %s: %s", *aggrfile, err.Error())
os.Exit(1)
}
config.WhisperData = strings.TrimRight(*whisperdata, "/")
logger.Logf("writing whisper files to: %s", config.WhisperData)
logger.Logf("reading storage schemas from: %s", *schemafile)
logger.Logf("reading aggregation rules from: %s", *aggrfile)
runtime.GOMAXPROCS(*maxprocs)
logger.Logf("set GOMAXPROCS=%d", *maxprocs)
httputil.PublishTrackedConnections("httptrack")
expvar.Publish("requestBuckets", expvar.Func(renderTimeBuckets))
// +1 to track every over the number of buckets we track
timeBuckets = make([]int64, config.Buckets+1)
// nothing in the config? check the environment
if config.GraphiteHost == "" {
if host := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); host != ":" {
config.GraphiteHost = host
}
}
// only register g2g if we have a graphite host
if config.GraphiteHost != "" {
logger.Logf("Using graphite host %v", config.GraphiteHost)
// register our metrics with graphite
graphite, err := g2g.NewGraphite(config.GraphiteHost, 60*time.Second, 10*time.Second)
if err != nil {
log.Fatalf("unable to connect to to graphite: %v: %v", config.GraphiteHost, err)
}
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
// graphite.Register(fmt.Sprintf("carbon.writer.%s.metricsReceived",
// hostname), Metrics.received)
for i := 0; i <= config.Buckets; i++ {
graphite.Register(fmt.Sprintf("carbon.writer.%s.write_in_%dms_to_%dms", hostname, i*100, (i+1)*100), bucketEntry(i))
}
}
logger.Logf("listening on %s, statistics via %s", *addr, *reportaddr)
go listenAndServe(*addr, schemas, aggrs)
err = http.ListenAndServe(*reportaddr, nil)
if err != nil {
log.Fatalf("%s", err)
}
logger.Logf("stopped")
}
func main() {
port := flag.Int("p", 8080, "port to bind to")
verbose := flag.Bool("v", false, "enable verbose logging")
debug := flag.Bool("vv", false, "enable more verbose (debug) logging")
whisperdata := flag.String("w", config.WhisperData, "location where whisper files are stored")
maxglobs := flag.Int("maxexpand", config.MaxGlobs, "maximum expansion depth to perform on input via curly braces ({a,b,c})")
maxprocs := flag.Int("maxprocs", runtime.NumCPU()*80/100, "GOMAXPROCS")
logdir := flag.String("logdir", "/var/log/carbonserver/", "logging directory")
logtostdout := flag.Bool("stdout", false, "log also to stdout")
scanFrequency := flag.Duration("scanfreq", 0, "file index scan frequency (0 to disable file index)")
interval := flag.Duration("i", 60*time.Second, "interval to report internal statistics to graphite")
flag.Parse()
mlog.SetOutput(*logdir, "carbonserver", *logtostdout)
expvar.NewString("BuildVersion").Set(BuildVersion)
log.Println("starting carbonserver", BuildVersion)
loglevel := mlog.Normal
if *verbose {
loglevel = mlog.Debug
}
if *debug {
loglevel = mlog.Trace
}
logger = mlog.Level(loglevel)
config.WhisperData = strings.TrimRight(*whisperdata, "/")
logger.Logf("reading whisper files from: %s", config.WhisperData)
config.MaxGlobs = *maxglobs
logger.Logf("maximum brace expansion set to: %d", config.MaxGlobs)
if *scanFrequency != 0 {
logger.Logln("use file cache with scan frequency", *scanFrequency)
force := make(chan struct{})
go fileListUpdater(*whisperdata, time.Tick(*scanFrequency), force)
force <- struct{}{}
}
runtime.GOMAXPROCS(*maxprocs)
logger.Logf("set GOMAXPROCS=%d", *maxprocs)
httputil.PublishTrackedConnections("httptrack")
expvar.Publish("requestBuckets", expvar.Func(renderTimeBuckets))
// +1 to track every over the number of buckets we track
timeBuckets = make([]int64, config.Buckets+1)
http.HandleFunc("/metrics/find/", httputil.TrackConnections(httputil.TimeHandler(findHandler, bucketRequestTimes)))
http.HandleFunc("/render/", httputil.TrackConnections(httputil.TimeHandler(fetchHandler, bucketRequestTimes)))
http.HandleFunc("/info/", httputil.TrackConnections(httputil.TimeHandler(infoHandler, bucketRequestTimes)))
// nothing in the config? check the environment
if config.GraphiteHost == "" {
if host := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); host != ":" {
config.GraphiteHost = host
}
}
// only register g2g if we have a graphite host
if config.GraphiteHost != "" {
logger.Logf("Using graphite host %v", config.GraphiteHost)
// register our metrics with graphite
graphite, err := g2g.NewGraphite(config.GraphiteHost, *interval, 10*time.Second)
if err != nil {
log.Fatalf("unable to connect to to graphite: %v: %v", config.GraphiteHost, err)
}
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
graphite.Register(fmt.Sprintf("carbon.server.%s.render_requests",
hostname), Metrics.RenderRequests)
graphite.Register(fmt.Sprintf("carbon.server.%s.render_errors",
hostname), Metrics.RenderErrors)
graphite.Register(fmt.Sprintf("carbon.server.%s.notfound",
hostname), Metrics.NotFound)
graphite.Register(fmt.Sprintf("carbon.server.%s.find_requests",
hostname), Metrics.FindRequests)
graphite.Register(fmt.Sprintf("carbon.server.%s.find_errors",
hostname), Metrics.FindErrors)
graphite.Register(fmt.Sprintf("carbon.server.%s.find_zero",
hostname), Metrics.FindZero)
for i := 0; i <= config.Buckets; i++ {
graphite.Register(fmt.Sprintf("carbon.server.%s.requests_in_%dms_to_%dms", hostname, i*100, (i+1)*100), bucketEntry(i))
}
}
listen := fmt.Sprintf(":%d", *port)
logger.Logf("listening on %s", listen)
err := http.ListenAndServe(listen, nil)
if err != nil {
log.Fatalf("%s", err)
}
logger.Logf("stopped")
}
func main() {
port := flag.Int("p", 8080, "port to bind to")
verbose := flag.Bool("v", false, "enable verbose logging")
debug := flag.Bool("vv", false, "enable more verbose (debug) logging")
whisperdata := flag.String("w", config.WhisperData, "location where whisper files are stored")
maxprocs := flag.Int("maxprocs", runtime.NumCPU()*80/100, "GOMAXPROCS")
flag.Parse()
loglevel := WARN
if *verbose {
loglevel = INFO
}
if *debug {
loglevel = DEBUG
}
log = NewOutputLogger(loglevel)
config.WhisperData = *whisperdata
log.Infof("reading whisper files from: %s", config.WhisperData)
runtime.GOMAXPROCS(*maxprocs)
log.Infof("set GOMAXPROCS=%d", *maxprocs)
httputil.PublishTrackedConnections("httptrack")
expvar.Publish("requestBuckets", expvar.Func(renderTimeBuckets))
// +1 to track every over the number of buckets we track
timeBuckets = make([]int64, config.Buckets+1)
http.HandleFunc("/metrics/find/", httputil.TrackConnections(httputil.TimeHandler(findHandler, bucketRequestTimes)))
http.HandleFunc("/render/", httputil.TrackConnections(httputil.TimeHandler(fetchHandler, bucketRequestTimes)))
// nothing in the config? check the environment
if config.GraphiteHost == "" {
if host := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); host != ":" {
config.GraphiteHost = host
}
}
// only register g2g if we have a graphite host
if config.GraphiteHost != "" {
log.Infof("Using graphite host %v", config.GraphiteHost)
// register our metrics with graphite
graphite, err := g2g.NewGraphite(config.GraphiteHost, 60*time.Second, 10*time.Second)
if err != nil {
log.Fatalf("unable to connect to to graphite: %v: %v", config.GraphiteHost, err)
}
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
graphite.Register(fmt.Sprintf("carbon.server.%s.render_requests",
hostname), Metrics.RenderRequests)
graphite.Register(fmt.Sprintf("carbon.server.%s.render_errors",
hostname), Metrics.RenderErrors)
graphite.Register(fmt.Sprintf("carbon.server.%s.notfound",
hostname), Metrics.NotFound)
graphite.Register(fmt.Sprintf("carbon.server.%s.find_requests",
hostname), Metrics.FindRequests)
graphite.Register(fmt.Sprintf("carbon.server.%s.find_errors",
hostname), Metrics.FindErrors)
for i := 0; i <= config.Buckets; i++ {
graphite.Register(fmt.Sprintf("carbon.server.%s.requests_in_%dms_to_%dms", hostname, i*100, (i+1)*100), bucketEntry(i))
}
}
listen := fmt.Sprintf(":%d", *port)
log.Infof("listening on %s", listen)
err := http.ListenAndServe(listen, nil)
if err != nil {
log.Fatalf("%s", err)
}
log.Infof("stopped")
}
func main() {
z := flag.String("z", "", "zipper")
port := flag.Int("p", 8080, "port")
l := flag.Int("l", 20, "concurrency limit")
cacheType := flag.String("cache", "mem", "cache type to use")
mc := flag.String("mc", "", "comma separated memcached server list")
memsize := flag.Int("memsize", 0, "in-memory cache size in MB (0 is unlimited)")
cpus := flag.Int("cpus", 0, "number of CPUs to use")
tz := flag.String("tz", "", "timezone,offset to use for dates with no timezone")
graphiteHost := flag.String("graphite", "", "graphite destination host")
logdir := flag.String("logdir", "/var/log/carbonapi/", "logging directory")
logtostdout := flag.Bool("stdout", false, "log also to stdout")
flag.Parse()
rl := rotatelogs.NewRotateLogs(
*logdir + "/carbonapi.%Y%m%d%H%M.log",
)
// Optional fields must be set afterwards
rl.LinkName = *logdir + "/carbonapi.log"
if *logtostdout {
log.SetOutput(io.MultiWriter(os.Stdout, rl))
} else {
log.SetOutput(rl)
}
expvar.NewString("BuildVersion").Set(BuildVersion)
log.Println("starting carbonapi", BuildVersion)
if p := os.Getenv("PORT"); p != "" {
*port, _ = strconv.Atoi(p)
}
Limiter = make(chan struct{}, *l)
if *z == "" {
log.Fatal("no zipper provided")
}
if _, err := url.Parse(*z); err != nil {
log.Fatal("unable to parze zipper:", err)
}
log.Println("using zipper", *z)
Zipper = zipper{
z: *z,
client: &http.Client{
Transport: &http.Transport{
MaxIdleConnsPerHost: *l / 2},
},
}
switch *cacheType {
case "memcache":
if *mc == "" {
log.Fatal("memcache cache requested but no memcache servers provided")
}
servers := strings.Split(*mc, ",")
log.Println("using memcache servers:", servers)
queryCache = &memcachedCache{client: memcache.New(servers...)}
findCache = &memcachedCache{client: memcache.New(servers...)}
case "mem":
qcache := &expireCache{cache: make(map[string]cacheElement), maxSize: uint64(*memsize * 1024 * 1024)}
queryCache = qcache
go queryCache.(*expireCache).cleaner()
findCache = &expireCache{cache: make(map[string]cacheElement)}
go findCache.(*expireCache).cleaner()
Metrics.CacheSize = expvar.Func(func() interface{} {
qcache.Lock()
size := qcache.totalSize
qcache.Unlock()
return size
})
expvar.Publish("cache_size", Metrics.CacheSize)
Metrics.CacheItems = expvar.Func(func() interface{} {
qcache.Lock()
size := len(qcache.keys)
qcache.Unlock()
return size
})
expvar.Publish("cache_items", Metrics.CacheItems)
case "null":
queryCache = &nullCache{}
findCache = &nullCache{}
}
if *tz != "" {
fields := strings.Split(*tz, ",")
if len(fields) != 2 {
log.Fatalf("expected two fields for tz,seconds, got %d", len(fields))
}
var err error
offs, err := strconv.Atoi(fields[1])
if err != nil {
log.Fatalf("unable to parse seconds: %s: %s", fields[1], err)
}
defaultTimeZone = time.FixedZone(fields[0], offs)
log.Printf("using fixed timezone %s, offset %d ", defaultTimeZone.String(), offs)
}
if *cpus != 0 {
log.Println("using GOMAXPROCS", *cpus)
runtime.GOMAXPROCS(*cpus)
}
if envhost := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); envhost != ":" || *graphiteHost != "" {
var host string
switch {
case envhost != ":" && *graphiteHost != "":
host = *graphiteHost
case envhost != ":":
host = envhost
case *graphiteHost != "":
host = *graphiteHost
}
log.Println("Using graphite host", host)
// register our metrics with graphite
graphite, err := g2g.NewGraphite(host, 60*time.Second, 10*time.Second)
if err != nil {
log.Fatal("unable to connect to to graphite: ", host, ":", err)
}
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
graphite.Register(fmt.Sprintf("carbon.api.%s.requests", hostname), Metrics.Requests)
graphite.Register(fmt.Sprintf("carbon.api.%s.request_cache_hits", hostname), Metrics.RequestCacheHits)
graphite.Register(fmt.Sprintf("carbon.api.%s.find_requests", hostname), Metrics.FindRequests)
graphite.Register(fmt.Sprintf("carbon.api.%s.find_cache_hits", hostname), Metrics.FindCacheHits)
graphite.Register(fmt.Sprintf("carbon.api.%s.render_requests", hostname), Metrics.RenderRequests)
graphite.Register(fmt.Sprintf("carbon.api.%s.memcache_timeouts", hostname), Metrics.MemcacheTimeouts)
if Metrics.CacheSize != nil {
graphite.Register(fmt.Sprintf("carbon.api.%s.cache_size", hostname), Metrics.CacheSize)
graphite.Register(fmt.Sprintf("carbon.api.%s.cache_items", hostname), Metrics.CacheItems)
}
}
render := func(w http.ResponseWriter, r *http.Request) {
var stats renderStats
t0 := time.Now()
renderHandler(w, r, &stats)
since := time.Since(t0)
log.Println(r.RequestURI, since.Nanoseconds()/int64(time.Millisecond), stats.zipperRequests)
}
http.HandleFunc("/render/", corsHandler(render))
http.HandleFunc("/render", corsHandler(render))
http.HandleFunc("/metrics/find/", corsHandler(findHandler))
http.HandleFunc("/metrics/find", corsHandler(findHandler))
http.HandleFunc("/info/", passthroughHandler)
http.HandleFunc("/info", passthroughHandler)
http.HandleFunc("/lb_check", lbcheckHandler)
http.HandleFunc("/", usageHandler)
log.Println("listening on port", *port)
log.Fatalln(http.ListenAndServe(":"+strconv.Itoa(*port), nil))
}
func main() {
z := flag.String("z", "", "zipper")
port := flag.Int("p", 8080, "port")
l := flag.Int("l", 20, "concurrency limit")
cacheType := flag.String("cache", "mem", "cache type to use")
mc := flag.String("mc", "", "comma separated memcached server list")
memsize := flag.Int("memsize", 0, "in-memory cache size in MB (0 is unlimited)")
cpus := flag.Int("cpus", 0, "number of CPUs to use")
tz := flag.String("tz", "", "timezone,offset to use for dates with no timezone")
graphiteHost := flag.String("graphite", "", "graphite destination host")
logdir := flag.String("logdir", "/var/log/carbonapi/", "logging directory")
logtostdout := flag.Bool("stdout", false, "log also to stdout")
interval := flag.Duration("i", 60*time.Second, "interval to report internal statistics to graphite")
idleconns := flag.Int("idleconns", 10, "max idle connections")
pidFile := flag.String("pid", "", "pidfile (default: empty, don't create pidfile)")
flag.Parse()
if *logdir == "" {
mlog.SetRawStream(os.Stdout)
} else {
mlog.SetOutput(*logdir, "carbonapi", *logtostdout)
}
expvar.NewString("BuildVersion").Set(BuildVersion)
logger.Logln("starting carbonapi", BuildVersion)
if p := os.Getenv("PORT"); p != "" {
*port, _ = strconv.Atoi(p)
}
Limiter = newLimiter(*l)
if *z == "" {
logger.Fatalln("no zipper provided")
}
if _, err := url.Parse(*z); err != nil {
logger.Fatalln("unable to parze zipper:", err)
}
logger.Logln("using zipper", *z)
Zipper = zipper{
z: *z,
client: &http.Client{
Transport: &http.Transport{
MaxIdleConnsPerHost: *idleconns,
},
},
}
switch *cacheType {
case "memcache":
if *mc == "" {
logger.Fatalln("memcache cache requested but no memcache servers provided")
}
servers := strings.Split(*mc, ",")
logger.Logln("using memcache servers:", servers)
queryCache = &memcachedCache{client: memcache.New(servers...)}
findCache = &memcachedCache{client: memcache.New(servers...)}
case "mem":
qcache := &expireCache{ec: ecache.New(uint64(*memsize * 1024 * 1024))}
queryCache = qcache
go queryCache.(*expireCache).ec.ApproximateCleaner(10 * time.Second)
findCache = &expireCache{ec: ecache.New(0)}
go findCache.(*expireCache).ec.ApproximateCleaner(10 * time.Second)
Metrics.CacheSize = expvar.Func(func() interface{} {
return qcache.ec.Size()
})
expvar.Publish("cache_size", Metrics.CacheSize)
Metrics.CacheItems = expvar.Func(func() interface{} {
return qcache.ec.Items()
})
expvar.Publish("cache_items", Metrics.CacheItems)
case "null":
queryCache = &nullCache{}
findCache = &nullCache{}
}
if *tz != "" {
fields := strings.Split(*tz, ",")
if len(fields) != 2 {
logger.Fatalf("expected two fields for tz,seconds, got %d", len(fields))
}
var err error
offs, err := strconv.Atoi(fields[1])
if err != nil {
logger.Fatalf("unable to parse seconds: %s: %s", fields[1], err)
}
defaultTimeZone = time.FixedZone(fields[0], offs)
logger.Logf("using fixed timezone %s, offset %d ", defaultTimeZone.String(), offs)
}
if *cpus != 0 {
logger.Logln("using GOMAXPROCS", *cpus)
runtime.GOMAXPROCS(*cpus)
}
if envhost := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); envhost != ":" || *graphiteHost != "" {
var host string
switch {
case envhost != ":" && *graphiteHost != "":
host = *graphiteHost
case envhost != ":":
host = envhost
case *graphiteHost != "":
host = *graphiteHost
}
logger.Logln("Using graphite host", host)
logger.Logln("setting stats interval to", *interval)
// register our metrics with graphite
graphite := g2g.NewGraphite(host, *interval, 10*time.Second)
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
graphite.Register(fmt.Sprintf("carbon.api.%s.requests", hostname), Metrics.Requests)
graphite.Register(fmt.Sprintf("carbon.api.%s.request_cache_hits", hostname), Metrics.RequestCacheHits)
graphite.Register(fmt.Sprintf("carbon.api.%s.find_requests", hostname), Metrics.FindRequests)
graphite.Register(fmt.Sprintf("carbon.api.%s.find_cache_hits", hostname), Metrics.FindCacheHits)
graphite.Register(fmt.Sprintf("carbon.api.%s.render_requests", hostname), Metrics.RenderRequests)
graphite.Register(fmt.Sprintf("carbon.api.%s.memcache_timeouts", hostname), Metrics.MemcacheTimeouts)
if Metrics.CacheSize != nil {
graphite.Register(fmt.Sprintf("carbon.api.%s.cache_size", hostname), Metrics.CacheSize)
graphite.Register(fmt.Sprintf("carbon.api.%s.cache_items", hostname), Metrics.CacheItems)
}
go mstats.Start(*interval)
graphite.Register(fmt.Sprintf("carbon.api.%s.alloc", hostname), &mstats.Alloc)
graphite.Register(fmt.Sprintf("carbon.api.%s.total_alloc", hostname), &mstats.TotalAlloc)
graphite.Register(fmt.Sprintf("carbon.api.%s.num_gc", hostname), &mstats.NumGC)
graphite.Register(fmt.Sprintf("carbon.api.%s.pause_ns", hostname), &mstats.PauseNS)
}
render := func(w http.ResponseWriter, r *http.Request) {
var stats renderStats
t0 := time.Now()
renderHandler(w, r, &stats)
since := time.Since(t0)
logger.Logln(r.RequestURI, since.Nanoseconds()/int64(time.Millisecond), stats.zipperRequests)
}
if *pidFile != "" {
pidfile.SetPidfilePath(*pidFile)
err := pidfile.Write()
if err != nil {
logger.Fatalln("error during pidfile.Write():", err)
}
}
r := http.DefaultServeMux
r.HandleFunc("/render/", render)
r.HandleFunc("/render", render)
r.HandleFunc("/metrics/find/", findHandler)
r.HandleFunc("/metrics/find", findHandler)
r.HandleFunc("/info/", passthroughHandler)
r.HandleFunc("/info", passthroughHandler)
r.HandleFunc("/lb_check", lbcheckHandler)
r.HandleFunc("/", usageHandler)
logger.Logln("listening on port", *port)
handler := handlers.CompressHandler(r)
handler = handlers.CORS()(handler)
handler = handlers.CombinedLoggingHandler(mlog.GetOutput(), handler)
err := gracehttp.Serve(&http.Server{
Addr: ":" + strconv.Itoa(*port),
Handler: handler,
})
if err != nil {
logger.Fatalln(err)
}
}
func main() {
configFile := flag.String("c", "", "config file (json)")
port := flag.Int("p", 0, "port to listen on")
maxprocs := flag.Int("maxprocs", 0, "GOMAXPROCS")
flag.IntVar(&Debug, "d", 0, "enable debug logging")
logStdout := flag.Bool("stdout", false, "write logging output also to stdout (default: only syslog)")
flag.Parse()
if *configFile == "" {
log.Fatal("missing config file")
}
cfgjs, err := ioutil.ReadFile(*configFile)
if err != nil {
log.Fatal("unable to load config file:", err)
}
cfgjs = stripCommentHeader(cfgjs)
if cfgjs == nil {
log.Fatal("error removing header comment from ", *configFile)
}
err = json.Unmarshal(cfgjs, &Config)
if err != nil {
log.Fatal("error parsing config file: ", err)
}
if len(Config.Backends) == 0 {
log.Fatal("no Backends loaded -- exiting")
}
// command line overrides config file
if *port != 0 {
Config.Port = *port
}
if *maxprocs != 0 {
Config.MaxProcs = *maxprocs
}
// set up our logging
slog, err := syslog.New(syslog.LOG_DAEMON, "carbonzipper")
if err != nil {
log.Fatal("can't obtain a syslog connection", err)
}
logger = append(logger, &sysLogger{w: slog})
if *logStdout {
logger = append(logger, &stdoutLogger{log.New(os.Stdout, "", log.LstdFlags)})
}
logger.Logln("setting GOMAXPROCS=", Config.MaxProcs)
runtime.GOMAXPROCS(Config.MaxProcs)
// +1 to track every over the number of buckets we track
timeBuckets = make([]int64, Config.Buckets+1)
httputil.PublishTrackedConnections("httptrack")
expvar.Publish("requestBuckets", expvar.Func(renderTimeBuckets))
http.HandleFunc("/metrics/find/", httputil.TrackConnections(httputil.TimeHandler(findHandler, bucketRequestTimes)))
http.HandleFunc("/render/", httputil.TrackConnections(httputil.TimeHandler(renderHandler, bucketRequestTimes)))
// nothing in the config? check the environment
if Config.GraphiteHost == "" {
if host := os.Getenv("GRAPHITEHOST") + ":" + os.Getenv("GRAPHITEPORT"); host != ":" {
Config.GraphiteHost = host
}
}
// only register g2g if we have a graphite host
if Config.GraphiteHost != "" {
logger.Logln("Using graphite host", Config.GraphiteHost)
// register our metrics with graphite
graphite, err := g2g.NewGraphite(Config.GraphiteHost, 60*time.Second, 10*time.Second)
if err != nil {
log.Fatal("unable to connect to to graphite: ", Config.GraphiteHost, ":", err)
}
hostname, _ := os.Hostname()
hostname = strings.Replace(hostname, ".", "_", -1)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.requests", hostname), Metrics.Requests)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.errors", hostname), Metrics.Errors)
graphite.Register(fmt.Sprintf("carbon.zipper.%s.timeouts", hostname), Metrics.Timeouts)
for i := 0; i <= Config.Buckets; i++ {
graphite.Register(fmt.Sprintf("carbon.zipper.%s.requests_in_%dms_to_%dms", hostname, i*100, (i+1)*100), bucketEntry(i))
}
}
portStr := fmt.Sprintf(":%d", Config.Port)
logger.Logln("listening on", portStr)
log.Fatal(http.ListenAndServe(portStr, nil))
}