func main() {
flag.Parse()
dsn := os.Getenv("DATA_SOURCE_NAME")
if len(dsn) == 0 {
log.Fatal("couldn't find environment variable DATA_SOURCE_NAME")
}
exporter := NewExporter(dsn)
prometheus.MustRegister(exporter)
handler := prometheus.Handler()
if *authUser != "" || *authPass != "" {
if *authUser == "" || *authPass == "" {
log.Fatal("You need to specify -auth.user and -auth.pass to enable basic auth")
}
handler = &basicAuthHandler{
handler: prometheus.Handler().ServeHTTP,
user: *authUser,
password: *authPass,
}
}
http.Handle(*metricPath, handler)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write(landingPage)
})
log.Infof("Starting Server: %s", *listenAddress)
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func main() {
flag.Parse()
dsn := os.Getenv("DATA_SOURCE_NAME")
if len(dsn) == 0 {
log.Fatal("couldn't find environment variable DATA_SOURCE_NAME")
}
exporter := NewMySQLExporter(dsn)
prometheus.MustRegister(exporter)
http.Handle(*metricPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>MySQLd exporter</title></head>
<body>
<h1>MySQLd exporter</h1>
<p><a href='` + *metricPath + `'>Metrics</a></p>
</body>
</html>
`))
})
log.Infof("Starting Server: %s", *listenAddress)
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func main() {
flag.Parse()
if *printCollectors {
collectorNames := make(sort.StringSlice, 0, len(collector.Factories))
for n := range collector.Factories {
collectorNames = append(collectorNames, n)
}
collectorNames.Sort()
fmt.Printf("Available collectors:\n")
for _, n := range collectorNames {
fmt.Printf(" - %s\n", n)
}
return
}
collectors, err := loadCollectors()
if err != nil {
log.Fatalf("Couldn't load collectors: %s", err)
}
log.Infof("Enabled collectors:")
for n := range collectors {
log.Infof(" - %s", n)
}
nodeCollector := NodeCollector{collectors: collectors}
prometheus.MustRegister(nodeCollector)
sigUsr1 := make(chan os.Signal)
signal.Notify(sigUsr1, syscall.SIGUSR1)
handler := prometheus.Handler()
if *authUser != "" || *authPass != "" {
if *authUser == "" || *authPass == "" {
log.Fatal("You need to specify -auth.user and -auth.pass to enable basic auth")
}
handler = &basicAuthHandler{
handler: prometheus.Handler().ServeHTTP,
user: *authUser,
password: *authPass,
}
}
http.Handle(*metricsPath, handler)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>Node Exporter</title></head>
<body>
<h1>Node Exporter</h1>
<p><a href="` + *metricsPath + `">Metrics</a></p>
</body>
</html>`))
})
log.Infof("Starting node_exporter v%s at %s", Version, *listenAddress)
err = http.ListenAndServe(*listenAddress, nil)
if err != nil {
log.Fatal(err)
}
}
func main() {
flag.Parse()
log.Println("Starting StatsD -> Prometheus Bridge...")
log.Println("Accepting StatsD Traffic on", *statsdListenAddress)
log.Println("Accepting Prometheus Requests on", *listenAddress)
go serveHTTP()
events := make(chan Events, 1024)
defer close(events)
listenAddr := udpAddrFromString(*statsdListenAddress)
conn, err := net.ListenUDP("udp", listenAddr)
if err != nil {
log.Fatal(err)
}
l := &StatsDListener{conn: conn}
go l.Listen(events)
mapper := &metricMapper{}
if *mappingConfig != "" {
err := mapper.initFromFile(*mappingConfig)
if err != nil {
log.Fatal("Error loading config:", err)
}
go watchConfig(*mappingConfig, mapper)
}
bridge := NewBridge(mapper)
bridge.Listen(events)
}
func (w *fileWatcher) Watch(cb ReloadCallback) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
err = watcher.WatchFlags(w.fileName, fsnotify.FSN_MODIFY)
if err != nil {
log.Fatal(err)
}
for {
select {
case ev := <-watcher.Event:
log.Infof("Config file changed (%s), attempting reload", ev)
conf, err := LoadFromFile(w.fileName)
if err != nil {
log.Error("Error loading new config: ", err)
failedConfigReloads.Inc()
} else {
cb(&conf)
log.Info("Config reloaded successfully")
configReloads.Inc()
}
// Re-add the file watcher since it can get lost on some changes. E.g.
// saving a file with vim results in a RENAME-MODIFY-DELETE event
// sequence, after which the newly written file is no longer watched.
err = watcher.WatchFlags(w.fileName, fsnotify.FSN_MODIFY)
case err := <-watcher.Error:
log.Error("Error watching config: ", err)
}
}
}
func watchConfig(fileName string, mapper *metricMapper) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
err = watcher.WatchFlags(fileName, fsnotify.FSN_MODIFY)
if err != nil {
log.Fatal(err)
}
for {
select {
case ev := <-watcher.Event:
log.Printf("Config file changed (%s), attempting reload", ev)
err = mapper.initFromFile(fileName)
if err != nil {
log.Println("Error reloading config:", err)
configLoads.WithLabelValues("failure").Inc()
} else {
log.Println("Config reloaded successfully")
configLoads.WithLabelValues("success").Inc()
}
// Re-add the file watcher since it can get lost on some changes. E.g.
// saving a file with vim results in a RENAME-MODIFY-DELETE event
// sequence, after which the newly written file is no longer watched.
err = watcher.WatchFlags(fileName, fsnotify.FSN_MODIFY)
case err := <-watcher.Error:
log.Println("Error watching config:", err)
}
}
}
func NewNewRelicApi(server string, apikey string) *newRelicApi {
parsed, err := url.Parse(server)
if err != nil {
log.Fatal("Could not parse API URL: ", err)
}
if apikey == "" {
log.Fatal("Cannot continue without an API key.")
}
return &newRelicApi{
server: *parsed,
apiKey: apikey,
}
}
func main() {
flag.Parse()
handler := prometheus.Handler()
prometheus.MustRegister(watts)
prometheus.MustRegister(updatesPerPost)
prometheus.MustRegister(voltage)
http.Handle(*metricsPath, handler)
http.HandleFunc("/activate", activateHandler)
http.HandleFunc("/post", postHandler)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>TED Exporter</title></head>
<body>
<h1>TED Exporter</h1>
<p><a href="` + *metricsPath + `">Metrics</a></p>
</body>
</html>`))
})
log.Infof("Starting ted_exporter v%s at %s", Version, *listenAddress)
err := http.ListenAndServe(*listenAddress, nil)
if err != nil {
log.Fatal(err)
}
}
func startCollectdServer(w api.Writer) {
if *collectdAddress == "" {
return
}
srv := network.Server{
Addr: *collectdAddress,
Writer: w,
}
if *collectdAuth != "" {
srv.PasswordLookup = network.NewAuthFile(*collectdAuth)
}
switch strings.ToLower(*collectdSecurity) {
case "", "none":
srv.SecurityLevel = network.None
case "sign":
srv.SecurityLevel = network.Sign
case "encrypt":
srv.SecurityLevel = network.Encrypt
default:
log.Fatalf("Unknown security level %q. Must be one of \"None\", \"Sign\" and \"Encrypt\".", *collectdSecurity)
}
go func() {
log.Fatal(srv.ListenAndWrite())
}()
}
func udpAddrFromString(addr string) *net.UDPAddr {
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
log.Fatal("Bad StatsD listening address", addr)
}
if host == "" {
host = "0.0.0.0"
}
ip, err := net.ResolveIPAddr("ip", host)
if err != nil {
log.Fatalf("Unable to resolve %s: %s", host, err)
}
port, err := strconv.Atoi(portStr)
if err != nil || port < 0 || port > 65535 {
log.Fatalf("Bad port %s: %s", portStr, err)
}
return &net.UDPAddr{
IP: ip.IP,
Port: port,
Zone: ip.Zone,
}
}
func main() {
var (
listenAddress = flag.String("web.listen-address", ":9107", "Address to listen on for web interface and telemetry.")
metricsPath = flag.String("web.telemetry-path", "/metrics", "Path under which to expose metrics.")
consulServer = flag.String("consul.server", "localhost:8500", "HTTP API address of a Consul server or agent.")
kvPrefix = flag.String("kv.prefix", "", "Prefix from which to expose key/value pairs.")
kvFilter = flag.String("kv.filter", ".*", "Regex that determines which keys to expose.")
)
flag.Parse()
exporter := NewExporter(*consulServer, *kvPrefix, *kvFilter)
prometheus.MustRegister(exporter)
log.Infof("Starting Server: %s", *listenAddress)
http.Handle(*metricsPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>Consul Exporter</title></head>
<body>
<h1>Consul Exporter</h1>
<p><a href='` + *metricsPath + `'>Metrics</a></p>
</body>
</html>`))
})
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func main() {
flag.Parse()
// Initialize Intel Edison
edisonAdaptor := edison.NewEdisonAdaptor("edison")
edisonAdaptor.Connect()
lightSensor := gpio.NewGroveLightSensorDriver(edisonAdaptor, "light", *sensorLightPin, *sensorPollingInterval)
lightSensor.Start()
gobot.On(lightSensor.Event("data"), func(data interface{}) {
raw := float64(data.(int))
// convert to lux
resistance := (1023.0 - raw) * 10.0 / raw * 15.0
light = 10000.0 / math.Pow(resistance, 4.0/3.0)
lightUpdated = time.Now()
log.Debugln("illuminance: ", light)
})
soundSensor := gpio.NewGroveSoundSensorDriver(edisonAdaptor, "sound", *sensorSoundPin, *sensorPollingInterval)
soundSensor.Start()
gobot.On(soundSensor.Event("data"), func(data interface{}) {
sound = float64(data.(int))
soundUpdated = time.Now()
log.Debugln("sound level: ", sound)
})
tempSensor := gpio.NewGroveTemperatureSensorDriver(edisonAdaptor, "temp", *sensorTempPin, *sensorPollingInterval)
tempSensor.Start()
gobot.On(tempSensor.Event("data"), func(data interface{}) {
celsius = data.(float64)
fahrenheit = celsius*1.8 + 32
tempUpdated = time.Now()
log.Debugln("temperature: ", celsius)
})
// Initialize prometheus exporter
exporter := NewExporter()
prometheus.MustRegister(exporter)
log.Infof("Listening on: %s", *listenAddress)
http.Handle(*metricPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`
<html>
<head>
<title>IoT Edison exporter</title>
</head>
<body>
<h1>Prometheus exporter for sensor metrics from Intel Edison</h1>
<p><a href='` + *metricPath + `'>Metrics</a></p>
</body>
</html>
`))
})
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func main() {
flag.Parse()
dsn := os.Getenv("DATA_SOURCE_NAME")
if len(dsn) == 0 {
log.Fatal("couldn't find environment variable DATA_SOURCE_NAME")
}
if *databases == "" {
log.Fatal("please specify at least one database")
}
var err error
db, err = sql.Open("postgres", dsn)
if err != nil {
log.Fatal("error opening connection to database: ", err)
}
defer db.Close()
if err := db.Ping(); err != nil {
log.Fatal("error opening connection to database: ", err)
}
db.SetMaxIdleConns(5)
db.SetMaxOpenConns(5)
exporter := NewPostgreSQLExporter(dsn, parseQueries(*queries))
prometheus.MustRegister(exporter)
http.Handle(*metricPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>PostgreSQL exporter</title></head>
<body>
<h1>PostgreSQL exporter</h1>
<p><a href='` + *metricPath + `'>Metrics</a></p>
</body>
</html>
`))
})
log.Infof("Starting Server: %s", *listenAddress)
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func main() {
flag.Parse()
dsn := os.Getenv("DATA_SOURCE_NAME")
if len(dsn) == 0 {
log.Fatal("couldn't find environment variable DATA_SOURCE_NAME")
}
exporter := NewExporter(dsn)
prometheus.MustRegister(exporter)
http.Handle(*metricPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write(landingPage)
})
log.Infof("Starting Server: %s", *listenAddress)
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func main() {
flag.Parse()
exporter := NewExporter(*nginxScrapeURI)
prometheus.MustRegister(exporter)
log.Printf("Starting Server: %s", *listeningAddress)
http.Handle(*metricsEndpoint, prometheus.Handler())
log.Fatal(http.ListenAndServe(*listeningAddress, nil))
}
func (l *StatsDListener) Listen(e chan<- Events) {
// TODO: evaluate proper size according to MTU
var buf [512]byte
for {
n, _, err := l.conn.ReadFromUDP(buf[0:])
if err != nil {
log.Fatal(err)
}
l.handlePacket(buf[0:n], e)
}
}
func main() {
flag.Parse()
exporter := newZooKeeperExporter(flag.Args(), *useExhibitor)
prometheus.MustRegister(exporter)
http.Handle(*metricPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, *metricPath, http.StatusMovedPermanently)
})
log.Info("starting mesos_exporter on ", *addr)
log.Fatal(http.ListenAndServe(*addr, nil))
}
func parseQueries(queriesPath string) (cq []metrics.CustomQuery) {
if queriesPath == "" {
return
}
f, err := os.Open(queriesPath)
if err != nil {
log.Fatal(err)
}
defer f.Close()
b, err := ioutil.ReadAll(f)
if err != nil {
log.Fatal(err)
}
err = yaml.Unmarshal(b, &cq)
if err != nil {
log.Fatal(err)
}
return
}
func main() {
flag.Parse()
if rancherURL == "" {
log.Fatal("CATTLE_URL must be set and non-empty")
}
log.Info("Starting Prometheus Exporter for Rancher. Listen Address: ", listenAddress, " metricsPath: ", metricsPath, " rancherURL: ", rancherURL, " AccessKey: ", accessKey)
log.Info("System Services Reported on:", hideSys)
// Register internal metrics
measure.Init()
// Pass URL & Credentials out to the Exporters
servicesExporter := services.NewExporter(rancherURL, accessKey, secretKey, hideSys)
stacksExporter := stacks.NewExporter(rancherURL, accessKey, secretKey, hideSys)
hostsExporter := hosts.NewExporter(rancherURL, accessKey, secretKey)
// Register Metrics from each of the endpoints
prometheus.MustRegister(servicesExporter)
prometheus.MustRegister(stacksExporter)
prometheus.MustRegister(hostsExporter)
http.Handle(metricsPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>Rancher exporter</title></head>
<body>
<h1>rancher exporter</h1>
<p><a href='` + metricsPath + `'>Metrics</a></p>
</body>
</html>
`))
})
log.Infof("Starting Server: %s", listenAddress)
log.Fatal(http.ListenAndServe(listenAddress, nil))
}
func main() {
flag.Parse()
handler := prometheus.Handler()
prometheus.MustRegister(percentage)
prometheus.MustRegister(temperature)
prometheus.MustRegister(timestamp)
prometheus.MustRegister(capacity)
http.Handle(*metricsPath, handler)
go startPolling()
log.Infof("Starting tank_utility_exporter v%s at %s", Version, *listenAddress)
err := http.ListenAndServe(*listenAddress, nil)
if err != nil {
log.Fatal(err)
}
}
func main() {
var (
listenAddress = flag.String("web.listen-address", ":9101", "Address to listen on for web interface and telemetry.")
metricsPath = flag.String("web.telemetry-path", "/metrics", "Path under which to expose metrics.")
haProxyScrapeUri = flag.String("haproxy.scrape-uri", "http://localhost/;csv", "URI on which to scrape HAProxy.")
haProxyServerMetricFields = flag.String("haproxy.server-metric-fields", "", "If specified, only export the given csv fields. Comma-seperated list of numbers. See http://cbonte.github.io/haproxy-dconv/configuration-1.5.html#9.1")
haProxyTimeout = flag.Duration("haproxy.timeout", 5*time.Second, "Timeout for trying to get stats from HAProxy.")
haProxyPidFile = flag.String("haproxy.pid-file", "", "Path to haproxy's pid file.")
)
flag.Parse()
exporter := NewExporter(*haProxyScrapeUri, *haProxyServerMetricFields, *haProxyTimeout)
prometheus.MustRegister(exporter)
if *haProxyPidFile != "" {
procExporter := prometheus.NewProcessCollectorPIDFn(
func() (int, error) {
content, err := ioutil.ReadFile(*haProxyPidFile)
if err != nil {
return 0, fmt.Errorf("error reading pid file: %s", err)
}
value, err := strconv.Atoi(strings.TrimSpace(string(content)))
if err != nil {
return 0, fmt.Errorf("error parsing pid file: %s", err)
}
return value, nil
}, namespace)
prometheus.MustRegister(procExporter)
}
log.Printf("Starting Server: %s", *listenAddress)
http.Handle(*metricsPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>Haproxy Exporter</title></head>
<body>
<h1>Haproxy Exporter</h1>
<p><a href='` + *metricsPath + `'>Metrics</a></p>
</body>
</html>`))
})
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
// NewClient creates a new Client.
func NewClient(conf influx.Config, db string, rp string) *Client {
c, err := influx.NewClient(conf)
// Currently influx.NewClient() *should* never return an error.
if err != nil {
log.Fatal(err)
}
return &Client{
client: c,
database: db,
retentionPolicy: rp,
ignoredSamples: prometheus.NewCounter(
prometheus.CounterOpts{
Name: "prometheus_influxdb_ignored_samples_total",
Help: "The total number of samples not sent to InfluxDB due to unsupported float values (Inf, -Inf, NaN).",
},
),
}
}
func main() {
flag.Parse()
exporter := NewPostfixExporter()
prometheus.MustRegister(exporter)
http.Handle(*metricsPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>Postfix exporter</title></head>
<body>
<h1>Postfix exporter</h1>
<p><a href='` + *metricsPath + `'>Metrics</a></p>
</body>
</html>
`))
})
log.Infof("Starting Server: %s", *listenAddress)
log.Fatal(http.ListenAndServe(*listenAddress, nil))
}
func newMesosExporter(opts *exporterOpts) *periodicExporter {
e := &periodicExporter{
errors: prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: "mesos_exporter",
Name: "slave_scrape_errors_total",
Help: "Current total scrape errors",
},
[]string{"slave"},
),
opts: opts,
}
if opts.queryURL == "" {
log.Fatal("Flag '-exporter.url' not set")
}
switch opts.mode {
case "discover":
log.Info("starting mesos_exporter in scrape mode 'discover'")
e.queryURL = parseMasterURL(opts.queryURL)
// Update nr. of mesos slaves.
e.updateSlaves()
go runEvery(e.updateSlaves, e.opts.autoDiscoverInterval)
// Fetch slave metrics every interval.
go runEvery(e.scrapeSlaves, e.opts.interval)
case "master":
log.Info("starting mesos_exporter in scrape mode 'master'")
e.queryURL = parseMasterURL(opts.queryURL)
case "slave":
log.Info("starting mesos_exporter in scrape mode 'slave'")
e.slaves.urls = []string{opts.queryURL}
default:
log.Fatalf("Invalid value '%s' of flag '-exporter.mode' - must be one of 'discover', 'master' or 'slave'", opts.mode)
}
return e
}
func main() {
var server, apikey, listenAddress, metricPath string
var period int
flag.StringVar(&apikey, "api.key", "", "NewRelic API key")
flag.StringVar(&server, "api.server", "https://api.newrelic.com", "NewRelic API URL")
flag.IntVar(&period, "api.period", 60, "Period of data to extract in seconds")
flag.StringVar(&listenAddress, "web.listen-address", ":9126", "Address to listen on for web interface and telemetry.")
flag.StringVar(&metricPath, "web.telemetry-path", "/metrics", "Path under which to expose metrics.")
flag.Parse()
api := NewNewRelicApi(server, apikey)
api.period = period
exporter := NewExporter()
exporter.api = *api
prometheus.MustRegister(exporter)
http.Handle(metricPath, prometheus.Handler())
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`<html>
<head><title>NewRelic exporter</title></head>
<body>
<h1>NewRelic exporter</h1>
<p><a href='` + metricPath + `'>Metrics</a></p>
</body>
</html>
`))
})
log.Printf("Listening on %s.", listenAddress)
err := http.ListenAndServe(listenAddress, nil)
if err != nil {
log.Fatal(err)
}
log.Print("HTTP server stopped.")
}
func main() {
flag.Parse()
opts := &exporterOpts{
autoDiscoverInterval: *autoDiscoverInterval,
interval: *scrapeInterval,
mode: *scrapeMode,
queryURL: strings.TrimRight(*queryURL, "/"),
}
exporter := newMesosExporter(opts)
prometheus.MustRegister(exporter)
http.Handle(*metricsPath, prometheus.Handler())
http.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "OK")
})
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, *metricsPath, http.StatusMovedPermanently)
})
log.Info("starting mesos_exporter on ", *addr)
log.Fatal(http.ListenAndServe(*addr, nil))
}
func main() {
flag.Parse()
versionInfoTmpl.Execute(os.Stdout, BuildInfo)
flags := map[string]string{}
flag.VisitAll(func(f *flag.Flag) {
flags[f.Name] = f.Value.String()
})
ms := storage.NewDiskMetricStore(*persistenceFile, *persistenceInterval)
prometheus.SetMetricFamilyInjectionHook(ms.GetMetricFamilies)
// Enable collect checks for debugging.
// prometheus.EnableCollectChecks(true)
r := httprouter.New()
r.Handler("GET", *metricsPath, prometheus.Handler())
// Handlers for pushing and deleting metrics.
r.PUT("/metrics/job/:job/*labels", handler.Push(ms, true))
r.POST("/metrics/job/:job/*labels", handler.Push(ms, false))
r.DELETE("/metrics/job/:job/*labels", handler.Delete(ms))
r.PUT("/metrics/job/:job", handler.Push(ms, true))
r.POST("/metrics/job/:job", handler.Push(ms, false))
r.DELETE("/metrics/job/:job", handler.Delete(ms))
// Handlers for the deprecated API.
r.PUT("/metrics/jobs/:job/instances/:instance", handler.LegacyPush(ms, true))
r.POST("/metrics/jobs/:job/instances/:instance", handler.LegacyPush(ms, false))
r.DELETE("/metrics/jobs/:job/instances/:instance", handler.LegacyDelete(ms))
r.PUT("/metrics/jobs/:job", handler.LegacyPush(ms, true))
r.POST("/metrics/jobs/:job", handler.LegacyPush(ms, false))
r.DELETE("/metrics/jobs/:job", handler.LegacyDelete(ms))
r.Handler("GET", "/static/*filepath", prometheus.InstrumentHandler(
"static",
http.FileServer(
&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir},
),
))
statusHandler := prometheus.InstrumentHandlerFunc("status", handler.Status(ms, Asset, flags, BuildInfo))
r.Handler("GET", "/status", statusHandler)
r.Handler("GET", "/", statusHandler)
// Re-enable pprof.
r.GET("/debug/pprof/*pprof", handlePprof)
log.Printf("Listening on %s.", *listenAddress)
l, err := net.Listen("tcp", *listenAddress)
if err != nil {
log.Fatal(err)
}
go interruptHandler(l)
err = (&http.Server{Addr: *listenAddress, Handler: r}).Serve(l)
log.Print("HTTP server stopped: ", err)
// To give running connections a chance to submit their payload, we wait
// for 1sec, but we don't want to wait long (e.g. until all connections
// are done) to not delay the shutdown.
time.Sleep(time.Second)
if err := ms.Shutdown(); err != nil {
log.Print("Problem shutting down metric storage: ", err)
}
}